fix: prevent FFI event flooding and memory leak in progress callbacks

This commit addresses two critical issues in the FFI layer:

1. Event Throttling: Limit event draining to 500 events per call to prevent
   UI/main thread flooding. Remaining events stay queued for the next drain.

2. Memory Leak Fix: Properly free heap-allocated stage_message strings in
   FFIDetailedSyncProgress after each progress callback to avoid per-callback
   memory leaks.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: PastaPastaPasta

dash-spv-ffi/src/client.rs

@@ -239,7 +239,14 @@ impl FFIDashSpvClient {
             return;
         };
         let callbacks = self.event_callbacks.lock().unwrap();
+        // Prevent flooding the UI/main thread by limiting events per drain call.
+        // Remaining events stay queued and will be drained on the next tick.
+        let max_events_per_call: usize = 500;
+        let mut processed: usize = 0;
         loop {
+            if processed >= max_events_per_call {
+                break;
+            }
             match rx.try_recv() {
                 Ok(event) => match event {
                     dash_spv::types::SpvEvent::BalanceUpdate {
@@ -354,6 +361,7 @@ impl FFIDashSpvClient {
                     break;
                 }
             }
+            processed += 1;
         }
     }
 }
@@ -823,6 +831,13 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
                                                 // and accessed through thread-safe mechanisms. The registry ensures
                                                 // proper lifetime management without raw pointer passing across threads.
                                                 callback(ffi_progress.as_ref(), *user_data);
+
+                                                // Free any heap-allocated strings inside the progress struct
+                                                // to avoid leaking per-callback allocations (e.g., stage_message).
+                                                unsafe {
+                                                    // Destroy stage_message allocated in FFIDetailedSyncProgress::from
+                                                    crate::types::dash_spv_ffi_string_destroy(std::ptr::read(&ffi_progress.stage_message));
+                                                }
                                             }
                                         }
                                     }