fix(ffi): Fix additional memory leaks in tests

- address_pool.rs: Add error.free_message() cleanup to tests
- wallet_manager_tests.rs: Fix shadowed variable issue where valid
  wallet/wallet_info were overwritten by later null results, causing
  the valid ones to leak. Also free wallet in serialization test.
- wallet_manager_serialization_tests.rs: Fix test_import_serialized_wallet
  which created a second manager without freeing the first one

Author: xdustinface

key-wallet-ffi/src/address_pool.rs

@@ -1135,6 +1135,7 @@ mod tests {
             managed_account_free(account);
             wallet_manager_free_wallet_ids(wallet_ids_out, count_out);
             wallet_manager_free(manager);
+            error.free_message();
         }
     }
 
@@ -1263,6 +1264,7 @@ mod tests {
             managed_account_free(account);
             wallet_manager_free_wallet_ids(wallet_ids_out, count_out);
             wallet_manager_free(manager);
+            error.free_message();
         }
     }
 }

key-wallet-ffi/src/wallet_manager_serialization_tests.rs

@@ -216,8 +216,8 @@ mod tests {
         let error = &mut error as *mut FFIError;
 
         // Create a wallet manager
-        let manager = wallet_manager::wallet_manager_create(FFINetwork::Testnet, error);
-        assert!(!manager.is_null());
+        let manager1 = wallet_manager::wallet_manager_create(FFINetwork::Testnet, error);
+        assert!(!manager1.is_null());
 
         let mnemonic = CString::new(TEST_MNEMONIC).unwrap();
         let passphrase = CString::new("").unwrap();
@@ -229,7 +229,7 @@ mod tests {
         // First create and serialize a wallet
         let success = unsafe {
             wallet_manager::wallet_manager_add_wallet_from_mnemonic_return_serialized_bytes(
-                manager,
+                manager1,
                 mnemonic.as_ptr(),
                 passphrase.as_ptr(),
                 0,
@@ -247,13 +247,13 @@ mod tests {
         assert!(!wallet_bytes_out.is_null());
 
         // Now import the wallet into a new manager
-        let manager = wallet_manager::wallet_manager_create(FFINetwork::Testnet, error);
-        assert!(!manager.is_null());
+        let manager2 = wallet_manager::wallet_manager_create(FFINetwork::Testnet, error);
+        assert!(!manager2.is_null());
 
         let mut imported_wallet_id = [0u8; 32];
         let import_success = unsafe {
             wallet_manager::wallet_manager_import_wallet_from_bytes(
-                manager,
+                manager2,
                 wallet_bytes_out,
                 wallet_bytes_len_out,
                 imported_wallet_id.as_mut_ptr(),
@@ -273,7 +273,8 @@ mod tests {
                 wallet_bytes_out,
                 wallet_bytes_len_out,
             );
-            wallet_manager::wallet_manager_free(manager);
+            wallet_manager::wallet_manager_free(manager1);
+            wallet_manager::wallet_manager_free(manager2);
             (*error).free_message();
         }
     }

key-wallet-ffi/src/wallet_manager_tests.rs

@@ -818,65 +818,65 @@ mod tests {
         let wallet_id_slice = unsafe { slice::from_raw_parts(wallet_ids, 32) };
 
         // Test getting the wallet
-        let wallet = unsafe {
+        let valid_wallet = unsafe {
             wallet_manager::wallet_manager_get_wallet(manager, wallet_id_slice.as_ptr(), error)
         };
-        assert!(!wallet.is_null());
+        assert!(!valid_wallet.is_null());
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::Success);
 
         // Test getting the managed wallet info
-        let wallet_info = unsafe {
+        let valid_wallet_info = unsafe {
             wallet_manager::wallet_manager_get_managed_wallet_info(
                 manager,
                 wallet_id_slice.as_ptr(),
                 error,
             )
         };
-        assert!(!wallet_info.is_null());
+        assert!(!valid_wallet_info.is_null());
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::Success);
 
         // Test with invalid wallet ID (all zeros)
         let invalid_wallet_id = [0u8; 32];
 
-        let wallet = unsafe {
+        let invalid_wallet = unsafe {
             wallet_manager::wallet_manager_get_wallet(manager, invalid_wallet_id.as_ptr(), error)
         };
-        assert!(wallet.is_null());
+        assert!(invalid_wallet.is_null());
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::NotFound);
 
-        let wallet_info = unsafe {
+        let invalid_wallet_info = unsafe {
             wallet_manager::wallet_manager_get_managed_wallet_info(
                 manager,
                 invalid_wallet_id.as_ptr(),
                 error,
             )
         };
-        assert!(wallet_info.is_null());
+        assert!(invalid_wallet_info.is_null());
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::NotFound);
 
         // Test with null manager
-        let wallet = unsafe {
+        let null_wallet = unsafe {
             wallet_manager::wallet_manager_get_wallet(ptr::null(), wallet_id_slice.as_ptr(), error)
         };
-        assert!(wallet.is_null());
+        assert!(null_wallet.is_null());
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::InvalidInput);
 
-        let wallet_info = unsafe {
+        let null_wallet_info = unsafe {
             wallet_manager::wallet_manager_get_managed_wallet_info(
                 ptr::null(),
                 wallet_id_slice.as_ptr(),
                 error,
             )
         };
-        assert!(wallet_info.is_null());
+        assert!(null_wallet_info.is_null());
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::InvalidInput);
 
         // Clean up
         unsafe {
-            // Free the wallet (cast from const to mut for free)
-            wallet::wallet_free(wallet as *mut _);
-            // Free the managed wallet info
-            crate::managed_wallet::managed_wallet_info_free(wallet_info);
+            // Free the valid wallet (cast from const to mut for free)
+            wallet::wallet_free(valid_wallet as *mut _);
+            // Free the valid managed wallet info
+            crate::managed_wallet::managed_wallet_info_free(valid_wallet_info);
             // Free the wallet IDs
             wallet_manager::wallet_manager_free_wallet_ids(wallet_ids, id_count);
             // Free the manager
@@ -1174,6 +1174,7 @@ mod tests {
 
         // Clean up
         unsafe {
+            crate::wallet::wallet_free(wallet as *mut _);
             crate::wallet_manager::wallet_manager_free_wallet_bytes(
                 wallet_bytes_out,
                 wallet_bytes_len_out,