fix(ffi): Free FFIManagedWalletInfo in tests to prevent memory leaks

Tests now properly heap-allocate FFIManagedWalletInfo using Box and
call managed_wallet_free for cleanup, matching how C code would use the FFI.

Author: xdustinface

key-wallet-ffi/src/managed_wallet.rs

@@ -36,6 +36,7 @@ impl FFIManagedWalletInfo {
     pub fn inner_mut(&mut self) -> &mut ManagedWalletInfo {
         unsafe { &mut *(self.inner as *mut ManagedWalletInfo) }
     }
+
 }
 
 /// Get the next unused receive address
@@ -748,14 +749,14 @@ mod tests {
         assert!(!wallet.is_null());
         assert_eq!(error.code, FFIErrorCode::Success);
 
-        // Create managed wallet info from the wallet
+        // Create managed wallet info from the wallet (heap-allocated like C would do)
         let wallet_rust = unsafe { &(*wallet).wallet };
         let managed_info = ManagedWalletInfo::from_wallet(wallet_rust);
-        let mut ffi_managed = FFIManagedWalletInfo::new(managed_info);
+        let ffi_managed = Box::into_raw(Box::new(FFIManagedWalletInfo::new(managed_info)));
 
         // Test get_next_receive_address with valid pointers
         let receive_addr = unsafe {
-            managed_wallet_get_next_bip44_receive_address(&mut ffi_managed, wallet, 0, &mut error)
+            managed_wallet_get_next_bip44_receive_address(ffi_managed, wallet, 0, &mut error)
         };
 
         if !receive_addr.is_null() {
@@ -776,7 +777,7 @@ mod tests {
 
         // Test get_next_change_address with valid pointers
         let change_addr = unsafe {
-            managed_wallet_get_next_bip44_change_address(&mut ffi_managed, wallet, 0, &mut error)
+            managed_wallet_get_next_bip44_change_address(ffi_managed, wallet, 0, &mut error)
         };
 
         if !change_addr.is_null() {
@@ -795,6 +796,7 @@ mod tests {
 
         // Clean up
         unsafe {
+            managed_wallet_free(ffi_managed);
             wallet::wallet_free(wallet);
         }
     }
@@ -869,20 +871,15 @@ mod tests {
         // Insert the managed account directly into managed_info's accounts
         managed_info.accounts.insert(managed_account);
 
-        // Create wrapper for managed info
-        let mut ffi_managed = FFIManagedWalletInfo::new(managed_info);
+        // Create wrapper for managed info (heap-allocated like C would do)
+        let ffi_managed = Box::into_raw(Box::new(FFIManagedWalletInfo::new(managed_info)));
 
         // Use the existing wallet pointer
         let ffi_wallet_ptr = wallet_ptr;
 
         // Test 1: Get next receive address
         let receive_addr = unsafe {
-            managed_wallet_get_next_bip44_receive_address(
-                &mut ffi_managed,
-                ffi_wallet_ptr,
-                0,
-                &mut error,
-            )
+            managed_wallet_get_next_bip44_receive_address(ffi_managed, ffi_wallet_ptr, 0, &mut error)
         };
 
         assert!(!receive_addr.is_null());
@@ -895,12 +892,7 @@ mod tests {
 
         // Test 2: Get next change address
         let change_addr = unsafe {
-            managed_wallet_get_next_bip44_change_address(
-                &mut ffi_managed,
-                ffi_wallet_ptr,
-                0,
-                &mut error,
-            )
+            managed_wallet_get_next_bip44_change_address(ffi_managed, ffi_wallet_ptr, 0, &mut error)
         };
 
         assert!(!change_addr.is_null());
@@ -917,7 +909,7 @@ mod tests {
 
         let success = unsafe {
             managed_wallet_get_bip_44_external_address_range(
-                &mut ffi_managed,
+                ffi_managed,
                 ffi_wallet_ptr,
                 0,
                 0,
@@ -950,7 +942,7 @@ mod tests {
 
         let success = unsafe {
             managed_wallet_get_bip_44_internal_address_range(
-                &mut ffi_managed,
+                ffi_managed,
                 ffi_wallet_ptr,
                 0,
                 0,
@@ -980,6 +972,7 @@ mod tests {
 
         // Clean up
         unsafe {
+            managed_wallet_free(ffi_managed);
             wallet::wallet_free(wallet_ptr);
         }
     }

key-wallet-ffi/src/utxo_tests.rs

@@ -113,18 +113,20 @@ mod utxo_tests {
         let mut utxos_out: *mut FFIUTXO = ptr::null_mut();
         let mut count_out: usize = 0;
 
-        // Create an empty managed wallet info
+        // Create an empty managed wallet info (heap-allocated like C would do)
         let managed_info = ManagedWalletInfo::new(Network::Testnet, [0u8; 32]);
-        let ffi_managed_info = FFIManagedWalletInfo::new(managed_info);
+        let ffi_managed_info = Box::into_raw(Box::new(FFIManagedWalletInfo::new(managed_info)));
 
         let result = unsafe {
-            managed_wallet_get_utxos(&ffi_managed_info, &mut utxos_out, &mut count_out, error)
+            managed_wallet_get_utxos(&*ffi_managed_info, &mut utxos_out, &mut count_out, error)
         };
 
         assert!(result);
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::Success);
         assert_eq!(count_out, 0);
         assert!(utxos_out.is_null());
+
+        unsafe { crate::managed_wallet::managed_wallet_free(ffi_managed_info) };
     }
 
     // Note: There's no individual utxo_free function, only utxo_array_free
@@ -229,10 +231,10 @@ mod utxo_tests {
 
         managed_info.accounts.insert(bip44_account);
 
-        let ffi_managed_info = FFIManagedWalletInfo::new(managed_info);
+        let ffi_managed_info = Box::into_raw(Box::new(FFIManagedWalletInfo::new(managed_info)));
 
         let result = unsafe {
-            managed_wallet_get_utxos(&ffi_managed_info, &mut utxos_out, &mut count_out, error)
+            managed_wallet_get_utxos(&*ffi_managed_info, &mut utxos_out, &mut count_out, error)
         };
 
         assert!(result);
@@ -267,6 +269,7 @@ mod utxo_tests {
         // Clean up
         unsafe {
             utxo_array_free(utxos_out, count_out);
+            crate::managed_wallet::managed_wallet_free(ffi_managed_info);
         }
     }
 
@@ -393,10 +396,10 @@ mod utxo_tests {
         }
         managed_info.accounts.insert(coinjoin_account);
 
-        let ffi_managed_info = FFIManagedWalletInfo::new(managed_info);
+        let ffi_managed_info = Box::into_raw(Box::new(FFIManagedWalletInfo::new(managed_info)));
 
         let result = unsafe {
-            managed_wallet_get_utxos(&ffi_managed_info, &mut utxos_out, &mut count_out, error)
+            managed_wallet_get_utxos(&*ffi_managed_info, &mut utxos_out, &mut count_out, error)
         };
 
         assert!(result);
@@ -406,6 +409,7 @@ mod utxo_tests {
         // Clean up
         unsafe {
             utxo_array_free(utxos_out, count_out);
+            crate::managed_wallet::managed_wallet_free(ffi_managed_info);
         }
     }
 
@@ -464,16 +468,17 @@ mod utxo_tests {
         testnet_account.utxos.insert(outpoint, utxo);
         managed_info.accounts.insert(testnet_account);
 
-        let ffi_managed_info = FFIManagedWalletInfo::new(managed_info);
+        let ffi_managed_info = Box::into_raw(Box::new(FFIManagedWalletInfo::new(managed_info)));
 
         // Get UTXOs
         let result = unsafe {
-            managed_wallet_get_utxos(&ffi_managed_info, &mut utxos_out, &mut count_out, error)
+            managed_wallet_get_utxos(&*ffi_managed_info, &mut utxos_out, &mut count_out, error)
         };
         assert!(result);
         assert_eq!(count_out, 1);
         unsafe {
             utxo_array_free(utxos_out, count_out);
+            crate::managed_wallet::managed_wallet_free(ffi_managed_info);
         }
     }
 
@@ -573,22 +578,24 @@ mod utxo_tests {
         let mut count_out: usize = 0;
 
         let managed_info = ManagedWalletInfo::new(Network::Testnet, [4u8; 32]);
-        let ffi_managed_info = FFIManagedWalletInfo::new(managed_info);
+        let ffi_managed_info = Box::into_raw(Box::new(FFIManagedWalletInfo::new(managed_info)));
 
         // Test with null utxos_out
         let result = unsafe {
-            managed_wallet_get_utxos(&ffi_managed_info, ptr::null_mut(), &mut count_out, error)
+            managed_wallet_get_utxos(&*ffi_managed_info, ptr::null_mut(), &mut count_out, error)
         };
         assert!(!result);
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::InvalidInput);
 
         // Test with null count_out
         let mut utxos_out: *mut FFIUTXO = ptr::null_mut();
         let result = unsafe {
-            managed_wallet_get_utxos(&ffi_managed_info, &mut utxos_out, ptr::null_mut(), error)
+            managed_wallet_get_utxos(&*ffi_managed_info, &mut utxos_out, ptr::null_mut(), error)
         };
         assert!(!result);
         assert_eq!(unsafe { (*error).code }, FFIErrorCode::InvalidInput);
+
+        unsafe { crate::managed_wallet::managed_wallet_free(ffi_managed_info) };
     }
 
     #[test]