chore: run cargo fmt

Author: PastaPastaPasta

dash-spv-ffi/src/callbacks.rs

@@ -1,6 +1,6 @@
+use dashcore::hashes::Hash;
 use std::ffi::CString;
 use std::os::raw::{c_char, c_void};
-use dashcore::hashes::Hash;
 
 pub type ProgressCallback =
     extern "C" fn(progress: f64, message: *const c_char, user_data: *mut c_void);
@@ -256,7 +256,12 @@ impl FFIEventCallbacks {
             );
             let txid_bytes = txid.as_byte_array();
             let hash_bytes = block_hash.as_byte_array();
-            callback(txid_bytes.as_ptr() as *const [u8; 32], block_height, hash_bytes.as_ptr() as *const [u8; 32], self.user_data);
+            callback(
+                txid_bytes.as_ptr() as *const [u8; 32],
+                block_height,
+                hash_bytes.as_ptr() as *const [u8; 32],
+                self.user_data,
+            );
             tracing::info!("✅ Mempool transaction confirmed callback completed");
         } else {
             tracing::debug!("Mempool transaction confirmed callback not set");

dash-spv-ffi/src/client.rs

@@ -45,27 +45,27 @@ enum CallbackInfo {
 }
 
 /// # Safety
-/// 
+///
 /// `CallbackInfo` is only `Send` if the following conditions are met:
 /// - All callback functions must be safe to call from any thread
 /// - The `user_data` pointer must either:
 ///   - Point to thread-safe data (i.e., data that implements `Send`)
 ///   - Be properly synchronized by the caller (e.g., using mutexes)
 ///   - Be null
-/// 
+///
 /// The caller is responsible for ensuring these conditions are met. Violating
 /// these requirements will result in undefined behavior.
 unsafe impl Send for CallbackInfo {}
 
 /// # Safety
-/// 
+///
 /// `CallbackInfo` is only `Sync` if the following conditions are met:
 /// - All callback functions must be safe to call concurrently from multiple threads
 /// - The `user_data` pointer must either:
 ///   - Point to thread-safe data (i.e., data that implements `Sync`)
 ///   - Be properly synchronized by the caller (e.g., using mutexes)
 ///   - Be null
-/// 
+///
 /// The caller is responsible for ensuring these conditions are met. Violating
 /// these requirements will result in undefined behavior.
 unsafe impl Sync for CallbackInfo {}
@@ -157,9 +157,10 @@ pub unsafe extern "C" fn dash_spv_ffi_client_new(
     let config = &(*config);
     let runtime = match tokio::runtime::Builder::new_multi_thread()
         .thread_name("dash-spv-worker")
-        .worker_threads(1)  // Reduce threads for mobile
+        .worker_threads(1) // Reduce threads for mobile
         .enable_all()
-        .build() {
+        .build()
+    {
         Ok(rt) => Arc::new(rt),
         Err(e) => {
             set_last_error(&format!("Failed to create runtime: {}", e));
@@ -360,25 +361,25 @@ pub unsafe extern "C" fn dash_spv_ffi_client_stop(client: *mut FFIDashSpvClient)
 }
 
 /// Sync the SPV client to the chain tip.
-/// 
+///
 /// # Safety
-/// 
+///
 /// This function is unsafe because:
 /// - `client` must be a valid pointer to an initialized `FFIDashSpvClient`
 /// - `user_data` must satisfy thread safety requirements:
 ///   - If non-null, it must point to data that is safe to access from multiple threads
 ///   - The caller must ensure proper synchronization if the data is mutable
 ///   - The data must remain valid for the entire duration of the sync operation
 /// - `completion_callback` must be thread-safe and can be called from any thread
-/// 
+///
 /// # Parameters
-/// 
+///
 /// - `client`: Pointer to the SPV client
 /// - `completion_callback`: Optional callback invoked on completion
 /// - `user_data`: Optional user data pointer passed to callbacks
-/// 
+///
 /// # Returns
-/// 
+///
 /// 0 on success, error code on failure
 #[no_mangle]
 pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip(
@@ -418,7 +419,10 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip(
                         {
                             if let Some(callback) = completion_callback {
                                 let msg = CString::new("Sync completed successfully")
-                                    .unwrap_or_else(|_| CString::new("Sync completed").expect("hardcoded string is safe"));
+                                    .unwrap_or_else(|_| {
+                                        CString::new("Sync completed")
+                                            .expect("hardcoded string is safe")
+                                    });
                                 // SAFETY: The callback and user_data are safely managed through the registry
                                 // The registry ensures proper lifetime management and thread safety
                                 callback(true, msg.as_ptr(), user_data);
@@ -440,7 +444,8 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip(
                             if let Some(callback) = completion_callback {
                                 let msg = match CString::new(format!("Sync failed: {}", e)) {
                                     Ok(s) => s,
-                                    Err(_) => CString::new("Sync failed").expect("hardcoded string is safe"),
+                                    Err(_) => CString::new("Sync failed")
+                                        .expect("hardcoded string is safe"),
                                 };
                                 // SAFETY: The callback and user_data are safely managed through the registry
                                 // The registry ensures proper lifetime management and thread safety
@@ -544,26 +549,26 @@ pub unsafe extern "C" fn dash_spv_ffi_client_test_sync(client: *mut FFIDashSpvCl
 }
 
 /// Sync the SPV client to the chain tip with detailed progress updates.
-/// 
+///
 /// # Safety
-/// 
+///
 /// This function is unsafe because:
 /// - `client` must be a valid pointer to an initialized `FFIDashSpvClient`
 /// - `user_data` must satisfy thread safety requirements:
 ///   - If non-null, it must point to data that is safe to access from multiple threads
 ///   - The caller must ensure proper synchronization if the data is mutable
 ///   - The data must remain valid for the entire duration of the sync operation
 /// - Both `progress_callback` and `completion_callback` must be thread-safe and can be called from any thread
-/// 
+///
 /// # Parameters
-/// 
+///
 /// - `client`: Pointer to the SPV client
 /// - `progress_callback`: Optional callback invoked periodically with sync progress
 /// - `completion_callback`: Optional callback invoked on completion
 /// - `user_data`: Optional user data pointer passed to all callbacks
-/// 
+///
 /// # Returns
-/// 
+///
 /// 0 on success, error code on failure
 #[no_mangle]
 pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
@@ -674,8 +679,11 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
                 {
                     match monitor_result {
                         Ok(_) => {
-                            let msg = CString::new("Sync completed successfully")
-                                .unwrap_or_else(|_| CString::new("Sync completed").expect("hardcoded string is safe"));
+                            let msg =
+                                CString::new("Sync completed successfully").unwrap_or_else(|_| {
+                                    CString::new("Sync completed")
+                                        .expect("hardcoded string is safe")
+                                });
                             // SAFETY: The callback and user_data are safely managed through the registry.
                             // The registry ensures proper lifetime management and thread safety.
                             // The string pointer is only valid for the duration of the callback.
@@ -686,7 +694,9 @@ pub unsafe extern "C" fn dash_spv_ffi_client_sync_to_tip_with_progress(
                         Err(e) => {
                             let msg = match CString::new(format!("Sync failed: {}", e)) {
                                 Ok(s) => s,
-                                Err(_) => CString::new("Sync failed").expect("hardcoded string is safe"),
+                                Err(_) => {
+                                    CString::new("Sync failed").expect("hardcoded string is safe")
+                                }
                             };
                             // SAFETY: Same as above
                             callback(false, msg.as_ptr(), user_data);

dash-spv-ffi/src/platform_integration.rs

@@ -41,7 +41,9 @@ pub unsafe extern "C" fn ffi_dash_spv_get_core_handle(
         return ptr::null_mut();
     }
 
-    Box::into_raw(Box::new(CoreSDKHandle { client }))
+    Box::into_raw(Box::new(CoreSDKHandle {
+        client,
+    }))
 }
 
 /// Releases a CoreSDKHandle
@@ -105,7 +107,10 @@ pub unsafe extern "C" fn ffi_dash_spv_get_quorum_public_key(
 
     // TODO: Implement actual quorum public key retrieval
     // For now, return a placeholder error
-    FFIResult::error(FFIErrorCode::NotImplemented, "Quorum public key retrieval not yet implemented")
+    FFIResult::error(
+        FFIErrorCode::NotImplemented,
+        "Quorum public key retrieval not yet implemented",
+    )
 }
 
 /// Gets the platform activation height from the Core chain
@@ -136,4 +141,4 @@ pub unsafe extern "C" fn ffi_dash_spv_get_platform_activation_height(
         FFIErrorCode::NotImplemented,
         "Platform activation height retrieval not yet implemented",
     )
-}
+}

dash-spv-ffi/tests/test_event_callbacks.rs

@@ -1,5 +1,5 @@
-use dash_spv_ffi::*;
 use dash_spv_ffi::callbacks::{BlockCallback, TransactionCallback};
+use dash_spv_ffi::*;
 use std::ffi::{c_char, c_void, CStr, CString};
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
 use std::sync::Arc;

dash-spv-ffi/tests/test_mempool_tracking.rs

@@ -1,5 +1,7 @@
+use dash_spv_ffi::callbacks::{
+    MempoolConfirmedCallback, MempoolRemovedCallback, MempoolTransactionCallback,
+};
 use dash_spv_ffi::*;
-use dash_spv_ffi::callbacks::{MempoolTransactionCallback, MempoolConfirmedCallback, MempoolRemovedCallback};
 use std::ffi::{CStr, CString};
 use std::os::raw::{c_char, c_void};
 use std::sync::{Arc, Mutex};

dash-spv-ffi/tests/test_platform_integration.rs

@@ -56,4 +56,4 @@ mod test_platform_integration {
             */
         }
     }
-}
+}

dash-spv-ffi/tests/unit/test_async_operations.rs

@@ -266,7 +266,7 @@ mod tests {
             ) {
                 let data = unsafe { &*(user_data as *const ReentrantData) };
                 let count = data.count.fetch_add(1, Ordering::SeqCst);
-                
+
                 // Check if callback is already active (reentrancy detection)
                 if data.callback_active.swap(true, Ordering::SeqCst) {
                     data.reentrancy_detected.store(true, Ordering::SeqCst);
@@ -281,16 +281,16 @@ mod tests {
                     // Attempt to start another sync operation from within callback
                     // This tests that the FFI layer properly handles reentrancy
                     let start_time = Instant::now();
-                    
+
                     // Try to call test_sync which is a simpler operation
                     let test_result = unsafe { dash_spv_ffi_client_test_sync(data.client) };
                     let elapsed = start_time.elapsed();
-                    
+
                     // If this takes too long, it might indicate a deadlock
                     if elapsed > Duration::from_secs(1) {
                         data.deadlock_detected.store(true, Ordering::SeqCst);
                     }
-                    
+
                     if test_result != 0 {
                         println!("Reentrant call failed with error code: {}", test_result);
                     }
@@ -319,7 +319,7 @@ mod tests {
                 Some(reentrant_callback),
                 &reentrant_data as *const _ as *mut c_void,
             );
-            
+
             // Wait for operations to complete
             thread::sleep(Duration::from_millis(500));
 
@@ -381,24 +381,32 @@ mod tests {
                 user_data: *mut c_void,
             ) {
                 let data = unsafe { &*(user_data as *const ThreadSafetyData) };
-                
+
                 // Increment concurrent callback count
-                let current_concurrent = data.concurrent_callbacks.fetch_add(1, Ordering::SeqCst) + 1;
-                
+                let current_concurrent =
+                    data.concurrent_callbacks.fetch_add(1, Ordering::SeqCst) + 1;
+
                 // Update max concurrent callbacks
                 loop {
                     let max = data.max_concurrent.load(Ordering::SeqCst);
-                    if current_concurrent <= max || 
-                       data.max_concurrent.compare_exchange(max, current_concurrent, 
-                                                          Ordering::SeqCst, 
-                                                          Ordering::SeqCst).is_ok() {
+                    if current_concurrent <= max
+                        || data
+                            .max_concurrent
+                            .compare_exchange(
+                                max,
+                                current_concurrent,
+                                Ordering::SeqCst,
+                                Ordering::SeqCst,
+                            )
+                            .is_ok()
+                    {
                         break;
                     }
                 }
 
                 // Test shared state access (potential race condition)
                 let count = data.count.fetch_add(1, Ordering::SeqCst);
-                
+
                 // Try to detect race conditions by accessing shared state
                 {
                     let mut state = match data.shared_state.try_lock() {
@@ -415,7 +423,7 @@ mod tests {
 
                 // Simulate some work
                 thread::sleep(Duration::from_micros(100));
-                
+
                 // Decrement concurrent callback count
                 data.concurrent_callbacks.fetch_sub(1, Ordering::SeqCst);
             }
@@ -429,34 +437,36 @@ mod tests {
 
             // Create thread-safe wrapper for the data
             let thread_data_arc = Arc::new(thread_data);
-            
+
             // Spawn multiple threads that will trigger callbacks
-            let handles: Vec<_> = (0..3).map(|i| {
-                let thread_data_clone = thread_data_arc.clone();
-                let barrier_clone = barrier.clone();
-                
-                thread::spawn(move || {
-                    // Synchronize thread start
-                    barrier_clone.wait();
-                    
-                    // Each thread performs multiple operations
-                    for j in 0..5 {
-                        println!("Thread {} iteration {}", i, j);
-                        
-                        // Invoke callback directly
-                        thread_safe_callback(
-                            true, 
-                            std::ptr::null(), 
-                            &*thread_data_clone as *const ThreadSafetyData as *mut c_void
-                        );
-                        
-                        // Note: We can't safely pass client pointers across threads
-                        // so we'll focus on testing concurrent callback invocations
-                        
-                        thread::sleep(Duration::from_millis(10));
-                    }
+            let handles: Vec<_> = (0..3)
+                .map(|i| {
+                    let thread_data_clone = thread_data_arc.clone();
+                    let barrier_clone = barrier.clone();
+
+                    thread::spawn(move || {
+                        // Synchronize thread start
+                        barrier_clone.wait();
+
+                        // Each thread performs multiple operations
+                        for j in 0..5 {
+                            println!("Thread {} iteration {}", i, j);
+
+                            // Invoke callback directly
+                            thread_safe_callback(
+                                true,
+                                std::ptr::null(),
+                                &*thread_data_clone as *const ThreadSafetyData as *mut c_void,
+                            );
+
+                            // Note: We can't safely pass client pointers across threads
+                            // so we'll focus on testing concurrent callback invocations
+
+                            thread::sleep(Duration::from_millis(10));
+                        }
+                    })
                 })
-            }).collect();
+                .collect();
 
             // Wait for all threads to complete
             for handle in handles {
@@ -479,11 +489,11 @@ mod tests {
             let state = thread_data_arc.shared_state.lock().unwrap();
             let mut sorted_state = state.clone();
             sorted_state.sort();
-            
+
             // Check for duplicates (would indicate race condition)
             let mut duplicates = 0;
             for i in 1..sorted_state.len() {
-                if sorted_state[i] == sorted_state[i-1] {
+                if sorted_state[i] == sorted_state[i - 1] {
                     duplicates += 1;
                 }
             }