fix(ffi): Use weak reference for callback registry

Convert CALLBACK_REGISTRY from static Lazy<Arc<...>> to use the same
weak reference pattern as RUNTIME_WEAK. This ensures the callback
registry is properly cleaned up when the last client is destroyed,
avoiding memory leak reports from sanitizers.

Author: xdustinface

dash-spv-ffi/src/client.rs

@@ -12,7 +12,6 @@ use dash_spv::Hash;
 use dashcore::Txid;
 
 use futures::future::{AbortHandle, Abortable};
-use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::ffi::{CStr, CString};
 use std::os::raw::{c_char, c_void};
@@ -24,9 +23,30 @@ use tokio::runtime::Runtime;
 use tokio::sync::mpsc::{error::TryRecvError, UnboundedReceiver};
 use tokio_util::sync::CancellationToken;
 
-/// Global callback registry for thread-safe callback management
-static CALLBACK_REGISTRY: Lazy<Arc<Mutex<CallbackRegistry>>> =
-    Lazy::new(|| Arc::new(Mutex::new(CallbackRegistry::new())));
+/// Weak reference to the shared callback registry.
+/// The registry is created when the first client is created and dropped when
+/// the last client is destroyed. This avoids memory leaks from static Lazy
+/// allocations that are never cleaned up.
+static CALLBACK_REGISTRY_WEAK: Mutex<Weak<Mutex<CallbackRegistry>>> = Mutex::new(Weak::new());
+
+/// Get or create the shared callback registry.
+/// Returns an Arc that keeps the registry alive while clients exist.
+/// When all clients are destroyed, the registry is dropped and cleaned up.
+fn get_or_create_callback_registry() -> Arc<Mutex<CallbackRegistry>> {
+    let mut weak = CALLBACK_REGISTRY_WEAK.lock().unwrap();
+
+    // Try to upgrade existing weak reference
+    if let Some(registry) = weak.upgrade() {
+        return registry;
+    }
+
+    // Create new registry if none exists
+    let registry = Arc::new(Mutex::new(CallbackRegistry::new()));
+
+    // Store weak reference
+    *weak = Arc::downgrade(&registry);
+    registry
+}
 
 /// Weak reference to the shared tokio runtime.
 /// The runtime is created when the first client is created and dropped when
@@ -149,6 +169,7 @@ type SharedClient = Arc<Mutex<Option<InnerClient>>>;
 pub struct FFIDashSpvClient {
     pub(crate) inner: SharedClient,
     pub(crate) runtime: Arc<Runtime>,
+    callback_registry: Arc<Mutex<CallbackRegistry>>,
     event_callbacks: Arc<Mutex<FFIEventCallbacks>>,
     active_threads: Arc<Mutex<Vec<std::thread::JoinHandle<()>>>>,
     sync_callbacks: Arc<Mutex<Option<SyncCallbackData>>>,
@@ -218,9 +239,13 @@ pub unsafe extern "C" fn dash_spv_ffi_client_new(
 
     match client_result {
         Ok(client) => {
+            // Get or create shared callback registry (cleaned up when last client is destroyed)
+            let callback_registry = get_or_create_callback_registry();
+
             let ffi_client = FFIDashSpvClient {
                 inner: Arc::new(Mutex::new(Some(client))),
                 runtime,
+                callback_registry,
                 event_callbacks: Arc::new(Mutex::new(FFIEventCallbacks::default())),
                 active_threads: Arc::new(Mutex::new(Vec::new())),
                 sync_callbacks: Arc::new(Mutex::new(None)),
@@ -412,7 +437,7 @@ fn stop_client_internal(client: &mut FFIDashSpvClient) -> Result<(), dash_spv::S
     {
         let mut cb_guard = client.sync_callbacks.lock().unwrap();
         if let Some(ref callback_data) = *cb_guard {
-            CALLBACK_REGISTRY.lock().unwrap().unregister(callback_data.callback_id);
+            client.callback_registry.lock().unwrap().unregister(callback_data.callback_id);
         }
         *cb_guard = None;
     }
@@ -594,13 +619,14 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip(
     let client = &(*client);
     let inner = client.inner.clone();
     let runtime = client.runtime.clone();
+    let callback_registry = client.callback_registry.clone();
 
-    // Register callbacks in the global registry for safe lifetime management
+    // Register callbacks in the registry for safe lifetime management
     let callback_info = CallbackInfo::Simple {
         completion_callback,
         user_data,
     };
-    let callback_id = CALLBACK_REGISTRY.lock().unwrap().register(callback_info);
+    let callback_id = callback_registry.lock().unwrap().register(callback_info);
 
     // Execute sync in the runtime
     let result = runtime.block_on(async {
@@ -621,7 +647,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip(
                 // Progress callbacks removed as sync_to_tip doesn't provide real progress updates
 
                 // Report completion and unregister callbacks
-                let mut registry = CALLBACK_REGISTRY.lock().unwrap();
+                let mut registry = callback_registry.lock().unwrap();
                 if let Some(CallbackInfo::Simple {
                     completion_callback: Some(callback),
                     user_data,
@@ -641,7 +667,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip(
             }
             Err(e) => {
                 // Report error and unregister callbacks
-                let mut registry = CALLBACK_REGISTRY.lock().unwrap();
+                let mut registry = callback_registry.lock().unwrap();
                 if let Some(CallbackInfo::Simple {
                     completion_callback: Some(callback),
                     user_data,
@@ -793,14 +819,15 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
     null_check!(client);
 
     let client = &(*client);
+    let callback_registry = client.callback_registry.clone();
 
-    // Register callbacks in the global registry
+    // Register callbacks in the registry
     let callback_info = CallbackInfo::Detailed {
         progress_callback,
         completion_callback,
         user_data,
     };
-    let callback_id = CALLBACK_REGISTRY.lock().unwrap().register(callback_info);
+    let callback_id = callback_registry.lock().unwrap().register(callback_info);
 
     // Store callback ID in the client
     let callback_data = SyncCallbackData {
@@ -824,6 +851,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
         let runtime_handle = runtime.handle().clone();
         let sync_callbacks_clone = sync_callbacks.clone();
         let shutdown_token_monitor = client.shutdown_token.clone();
+        let callback_registry_clone = callback_registry.clone();
 
         let handle = std::thread::spawn(move || {
             runtime_handle.block_on(async move {
@@ -846,7 +874,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
                                         let cb_guard = sync_callbacks_clone.lock().unwrap();
 
                                         if let Some(ref callback_data) = *cb_guard {
-                                            let registry = CALLBACK_REGISTRY.lock().unwrap();
+                                            let registry = callback_registry_clone.lock().unwrap();
                                             if let Some(CallbackInfo::Detailed {
                                                 progress_callback: Some(callback),
                                                 user_data,
@@ -901,6 +929,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
     let runtime_handle = runtime.handle().clone();
     let sync_callbacks_clone = sync_callbacks.clone();
     let shutdown_token_sync = client.shutdown_token.clone();
+    let callback_registry_sync = callback_registry.clone();
     let sync_handle = std::thread::spawn(move || {
         let shutdown_token_callback = shutdown_token_sync.clone();
         // Run monitoring loop
@@ -949,7 +978,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
         {
             let mut cb_guard = sync_callbacks_clone.lock().unwrap();
             if let Some(ref callback_data) = *cb_guard {
-                let mut registry = CALLBACK_REGISTRY.lock().unwrap();
+                let mut registry = callback_registry_sync.lock().unwrap();
                 if let Some(CallbackInfo::Detailed {
                     completion_callback: Some(callback),
                     user_data,
@@ -1310,7 +1339,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_destroy(client: *mut FFIDashSpvClie
 
         // Clean up any registered callbacks
         if let Some(ref callback_data) = *client.sync_callbacks.lock().unwrap() {
-            CALLBACK_REGISTRY.lock().unwrap().unregister(callback_data.callback_id);
+            client.callback_registry.lock().unwrap().unregister(callback_data.callback_id);
         }
 
         // Stop the SPV client