feat: additional ffi

Author: QuantumExplorer

dash-spv-ffi/include/dash_spv_ffi.h

@@ -421,6 +421,40 @@ int32_t dash_spv_ffi_client_sync_to_tip_with_progress(struct FFIDashSpvClient *c
  */
  struct FFISpvStats *dash_spv_ffi_client_get_stats(struct FFIDashSpvClient *client) ;
 
+/**
+ * Get the current chain tip hash (32 bytes) if available.
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ * - `out_hash` must be a valid pointer to a 32-byte buffer.
+ */
+ int32_t dash_spv_ffi_client_get_tip_hash(struct FFIDashSpvClient *client, uint8_t *out_hash) ;
+
+/**
+ * Get the current chain tip height (absolute).
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ * - `out_height` must be a valid, non-null pointer.
+ */
+ int32_t dash_spv_ffi_client_get_tip_height(struct FFIDashSpvClient *client, uint32_t *out_height) ;
+
+/**
+ * Clear all persisted SPV storage (headers, filters, metadata, sync state).
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ */
+ int32_t dash_spv_ffi_client_clear_storage(struct FFIDashSpvClient *client) ;
+
+/**
+ * Clear only the persisted sync-state snapshot.
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ */
+ int32_t dash_spv_ffi_client_clear_sync_state(struct FFIDashSpvClient *client) ;
+
 /**
  * Check if compact filter sync is currently available.
  *

dash-spv-ffi/src/client.rs

@@ -5,8 +5,10 @@ use crate::{
 // Import wallet types from key-wallet-ffi
 use key_wallet_ffi::FFIWalletManager;
 
+use dash_spv::storage::DiskStorageManager;
 use dash_spv::types::SyncStage;
 use dash_spv::DashSpvClient;
+use dash_spv::Hash;
 use dashcore::Txid;
 
 use once_cell::sync::Lazy;
@@ -106,7 +108,7 @@ type InnerClient = DashSpvClient<
         key_wallet::wallet::managed_wallet_info::ManagedWalletInfo,
     >,
     dash_spv::network::MultiPeerNetworkManager,
-    dash_spv::storage::MemoryStorageManager,
+    DiskStorageManager,
 >;
 type SharedClient = Arc<Mutex<Option<InnerClient>>>;
 
@@ -144,11 +146,24 @@ pub unsafe extern "C" fn dash_spv_ffi_client_new(
         }
     };
 
-    let client_config = config.clone_inner();
-    let client_result = runtime.block_on(async {
+    let mut client_config = config.clone_inner();
+
+    let storage_path = client_config.storage_path.clone().unwrap_or_else(|| {
+        let mut path = std::env::temp_dir();
+        path.push("dash-spv");
+        path.push(format!("{:?}", client_config.network).to_lowercase());
+        tracing::warn!(
+            "dash-spv FFI config missing storage path, falling back to temp dir {:?}",
+            path
+        );
+        path
+    });
+    client_config.storage_path = Some(storage_path.clone());
+
+    let client_result = runtime.block_on(async move {
         // Construct concrete implementations for generics
         let network = dash_spv::network::MultiPeerNetworkManager::new(&client_config).await;
-        let storage = dash_spv::storage::MemoryStorageManager::new().await;
+        let storage = DiskStorageManager::new(storage_path.clone()).await;
         let wallet = key_wallet_manager::wallet_manager::WalletManager::<
             key_wallet::wallet::managed_wallet_info::ManagedWalletInfo,
         >::new();
@@ -994,6 +1009,187 @@ pub unsafe extern "C" fn dash_spv_ffi_client_get_stats(
     }
 }
 
+/// Get the current chain tip hash (32 bytes) if available.
+///
+/// # Safety
+/// - `client` must be a valid, non-null pointer.
+/// - `out_hash` must be a valid pointer to a 32-byte buffer.
+#[no_mangle]
+pub unsafe extern "C" fn dash_spv_ffi_client_get_tip_hash(
+    client: *mut FFIDashSpvClient,
+    out_hash: *mut u8,
+) -> i32 {
+    null_check!(client);
+    if out_hash.is_null() {
+        set_last_error("Null out_hash pointer");
+        return FFIErrorCode::NullPointer as i32;
+    }
+
+    let client = &(*client);
+    let inner = client.inner.clone();
+
+    let result = client.runtime.block_on(async {
+        let spv_client = {
+            let mut guard = inner.lock().unwrap();
+            match guard.take() {
+                Some(c) => c,
+                None => {
+                    return Err(dash_spv::SpvError::Config("Client not initialized".to_string()))
+                }
+            }
+        };
+        let tip = spv_client.tip_hash().await;
+        let mut guard = inner.lock().unwrap();
+        *guard = Some(spv_client);
+        Ok(tip)
+    });
+
+    match result {
+        Ok(Some(hash)) => {
+            let bytes = hash.to_byte_array();
+            // SAFETY: out_hash points to a buffer with at least 32 bytes
+            std::ptr::copy_nonoverlapping(bytes.as_ptr(), out_hash, 32);
+            FFIErrorCode::Success as i32
+        }
+        Ok(None) => {
+            set_last_error("No tip hash available");
+            FFIErrorCode::StorageError as i32
+        }
+        Err(e) => {
+            set_last_error(&e.to_string());
+            FFIErrorCode::from(e) as i32
+        }
+    }
+}
+
+/// Get the current chain tip height (absolute).
+///
+/// # Safety
+/// - `client` must be a valid, non-null pointer.
+/// - `out_height` must be a valid, non-null pointer.
+#[no_mangle]
+pub unsafe extern "C" fn dash_spv_ffi_client_get_tip_height(
+    client: *mut FFIDashSpvClient,
+    out_height: *mut u32,
+) -> i32 {
+    null_check!(client);
+    if out_height.is_null() {
+        set_last_error("Null out_height pointer");
+        return FFIErrorCode::NullPointer as i32;
+    }
+
+    let client = &(*client);
+    let inner = client.inner.clone();
+
+    let result = client.runtime.block_on(async {
+        let spv_client = {
+            let mut guard = inner.lock().unwrap();
+            match guard.take() {
+                Some(c) => c,
+                None => {
+                    return Err(dash_spv::SpvError::Config("Client not initialized".to_string()))
+                }
+            }
+        };
+        let height = spv_client.tip_height().await;
+        let mut guard = inner.lock().unwrap();
+        *guard = Some(spv_client);
+        Ok(height)
+    });
+
+    match result {
+        Ok(height) => {
+            *out_height = height;
+            FFIErrorCode::Success as i32
+        }
+        Err(e) => {
+            set_last_error(&e.to_string());
+            FFIErrorCode::from(e) as i32
+        }
+    }
+}
+
+/// Clear all persisted SPV storage (headers, filters, metadata, sync state).
+///
+/// # Safety
+/// - `client` must be a valid, non-null pointer.
+#[no_mangle]
+pub unsafe extern "C" fn dash_spv_ffi_client_clear_storage(client: *mut FFIDashSpvClient) -> i32 {
+    null_check!(client);
+
+    let client = &(*client);
+    let inner = client.inner.clone();
+
+    let result = client.runtime.block_on(async {
+        let mut spv_client = {
+            let mut guard = inner.lock().unwrap();
+            match guard.take() {
+                Some(c) => c,
+                None => {
+                    return Err(dash_spv::SpvError::Config("Client not initialized".to_string()))
+                }
+            }
+        };
+
+        // Try to stop before clearing to ensure no in-flight writes race the wipe.
+        if let Err(e) = spv_client.stop().await {
+            tracing::warn!("Failed to stop client before clearing storage: {}", e);
+        }
+
+        let res = spv_client.clear_storage().await;
+        let mut guard = inner.lock().unwrap();
+        *guard = Some(spv_client);
+        res
+    });
+
+    match result {
+        Ok(_) => FFIErrorCode::Success as i32,
+        Err(e) => {
+            set_last_error(&e.to_string());
+            FFIErrorCode::from(e) as i32
+        }
+    }
+}
+
+/// Clear only the persisted sync-state snapshot.
+///
+/// # Safety
+/// - `client` must be a valid, non-null pointer.
+#[no_mangle]
+pub unsafe extern "C" fn dash_spv_ffi_client_clear_sync_state(
+    client: *mut FFIDashSpvClient,
+) -> i32 {
+    null_check!(client);
+
+    let client = &(*client);
+    let inner = client.inner.clone();
+
+    let result = client.runtime.block_on(async {
+        let mut spv_client = {
+            let mut guard = inner.lock().unwrap();
+            match guard.take() {
+                Some(c) => c,
+                None => {
+                    return Err(dash_spv::SpvError::Config("Client not initialized".to_string()))
+                }
+            }
+        };
+
+        let res = spv_client.clear_sync_state().await;
+        let mut guard = inner.lock().unwrap();
+        *guard = Some(spv_client);
+        res
+    });
+
+    match result {
+        Ok(_) => FFIErrorCode::Success as i32,
+        Err(e) => {
+            set_last_error(&e.to_string());
+            FFIErrorCode::from(e) as i32
+        }
+    }
+}
+
 /// Check if compact filter sync is currently available.
 ///
 /// # Safety

dash-spv/src/client/mod.rs

@@ -94,6 +94,30 @@ impl<
         S: StorageManager + Send + Sync + 'static,
     > DashSpvClient<W, N, S>
 {
+    /// Returns the current chain tip hash if available.
+    pub async fn tip_hash(&self) -> Option<dashcore::BlockHash> {
+        let state = self.state.read().await;
+        state.tip_hash()
+    }
+
+    /// Returns the current chain tip height (absolute), accounting for checkpoint base.
+    pub async fn tip_height(&self) -> u32 {
+        let state = self.state.read().await;
+        state.tip_height()
+    }
+
+    /// Clear all persisted storage (headers, filters, state, sync state).
+    pub async fn clear_storage(&mut self) -> Result<()> {
+        let mut storage = self.storage.lock().await;
+        storage.clear().await.map_err(SpvError::Storage)
+    }
+
+    /// Clear only the persisted sync state snapshot (keep headers/filters).
+    pub async fn clear_sync_state(&mut self) -> Result<()> {
+        let mut storage = self.storage.lock().await;
+        storage.clear_sync_state().await.map_err(SpvError::Storage)
+    }
+
     /// Take the progress receiver for external consumption.
     pub fn take_progress_receiver(
         &mut self,

swift-dash-core-sdk/Sources/DashSPVFFI/include/dash_spv_ffi.h

@@ -149,6 +149,11 @@ typedef void (*WalletTransactionCallback)(const char *wallet_id,
                                           bool is_ours,
                                           void *user_data);
 
+typedef void (*FilterHeadersProgressCallback)(uint32_t filter_height,
+                                              uint32_t header_height,
+                                              double percentage,
+                                              void *user_data);
+
 typedef struct FFIEventCallbacks {
   BlockCallback on_block;
   TransactionCallback on_transaction;
@@ -158,6 +163,7 @@ typedef struct FFIEventCallbacks {
   MempoolRemovedCallback on_mempool_transaction_removed;
   CompactFilterMatchedCallback on_compact_filter_matched;
   WalletTransactionCallback on_wallet_transaction;
+  FilterHeadersProgressCallback on_filter_headers_progress;
   void *user_data;
 } FFIEventCallbacks;
 
@@ -415,6 +421,40 @@ int32_t dash_spv_ffi_client_sync_to_tip_with_progress(struct FFIDashSpvClient *c
  */
  struct FFISpvStats *dash_spv_ffi_client_get_stats(struct FFIDashSpvClient *client) ;
 
+/**
+ * Get the current chain tip hash (32 bytes) if available.
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ * - `out_hash` must be a valid pointer to a 32-byte buffer.
+ */
+ int32_t dash_spv_ffi_client_get_tip_hash(struct FFIDashSpvClient *client, uint8_t *out_hash) ;
+
+/**
+ * Get the current chain tip height (absolute).
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ * - `out_height` must be a valid, non-null pointer.
+ */
+ int32_t dash_spv_ffi_client_get_tip_height(struct FFIDashSpvClient *client, uint32_t *out_height) ;
+
+/**
+ * Clear all persisted SPV storage (headers, filters, metadata, sync state).
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ */
+ int32_t dash_spv_ffi_client_clear_storage(struct FFIDashSpvClient *client) ;
+
+/**
+ * Clear only the persisted sync-state snapshot.
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer.
+ */
+ int32_t dash_spv_ffi_client_clear_sync_state(struct FFIDashSpvClient *client) ;
+
 /**
  * Check if compact filter sync is currently available.
  *