unused ffi functions removed from dash-spv-ffi crate (#377)

Author: ZocoLini

dash-spv-ffi/FFI_API.md

@@ -74,12 +74,6 @@ fn main() {
                 .action(ArgAction::Append)
                 .help("Peer address host:port (repeatable)"),
         )
-        .arg(
-            Arg::new("workers")
-                .long("workers")
-                .value_parser(clap::value_parser!(u32))
-                .help("Tokio worker threads (0=auto)"),
-        )
         .arg(
             Arg::new("log-level")
                 .long("log-level")
@@ -99,12 +93,6 @@ fn main() {
                 .action(ArgAction::SetTrue)
                 .help("Disable masternode list synchronization"),
         )
-        .arg(
-            Arg::new("no-filters")
-                .long("no-filters")
-                .action(ArgAction::SetTrue)
-                .help("Disable compact filter synchronization"),
-        )
         .get_matches();
 
     // Map network
@@ -115,8 +103,6 @@ fn main() {
         _ => FFINetwork::Dash,
     };
 
-    let disable_filter_sync = matches.get_flag("no-filters");
-
     unsafe {
         // Initialize tracing/logging via FFI so `tracing::info!` emits output
         let level = matches.get_one::<String>("log-level").map(String::as_str).unwrap_or("info");
@@ -133,12 +119,6 @@ fn main() {
             std::process::exit(1);
         }
 
-        let _ = dash_spv_ffi_config_set_filter_load(cfg, !disable_filter_sync);
-
-        if let Some(workers) = matches.get_one::<u32>("workers") {
-            let _ = dash_spv_ffi_config_set_worker_threads(cfg, *workers);
-        }
-
         if let Some(height) = matches.get_one::<u32>("start-height") {
             let _ = dash_spv_ffi_config_set_start_from_height(cfg, *height);
         }
@@ -214,13 +194,9 @@ fn main() {
             if !prog_ptr.is_null() {
                 let prog = &*prog_ptr;
                 let headers_done = SYNC_COMPLETED.load(Ordering::SeqCst);
-                let filters_complete = if disable_filter_sync || !prog.filter_sync_available {
-                    false
-                } else {
-                    prog.filter_header_height >= prog.header_height
-                        && prog.last_synced_filter_height >= prog.filter_header_height
-                };
-                if headers_done && (filters_complete || disable_filter_sync) {
+                let filters_complete = prog.filter_header_height >= prog.header_height
+                    && prog.last_synced_filter_height >= prog.filter_header_height;
+                if headers_done && filters_complete {
                     dash_spv_ffi_sync_progress_destroy(prog_ptr);
                     break;
                 }

dash-spv-ffi/include/dash_spv_ffi.h

@@ -1,4 +1,4 @@
-use crate::{set_last_error, FFIArray, FFIErrorCode};
+use crate::{set_last_error, FFIErrorCode};
 use dash_spv::chain::checkpoints::{mainnet_checkpoints, testnet_checkpoints, CheckpointManager};
 use dashcore::hashes::Hash;
 use dashcore::Network;
@@ -120,43 +120,3 @@ pub unsafe extern "C" fn dash_spv_ffi_checkpoint_before_timestamp(
         FFIErrorCode::ValidationError as i32
     }
 }
-
-/// Get all checkpoints between two heights (inclusive).
-///
-/// Returns an `FFIArray` of `FFICheckpoint` items. The caller owns the memory and
-/// must free the array buffer using `dash_spv_ffi_array_destroy` when done.
-#[no_mangle]
-pub extern "C" fn dash_spv_ffi_checkpoints_between_heights(
-    network: FFINetwork,
-    start_height: u32,
-    end_height: u32,
-) -> FFIArray {
-    match manager_for_network(network) {
-        Ok(mgr) => {
-            // Collect checkpoints within inclusive range
-            let mut out: Vec<FFICheckpoint> = Vec::new();
-            for &h in mgr.checkpoint_heights() {
-                if h >= start_height && h <= end_height {
-                    if let Some(cp) = mgr.get_checkpoint(h) {
-                        out.push(FFICheckpoint {
-                            height: cp.height,
-                            block_hash: cp.block_hash.to_byte_array(),
-                        });
-                    }
-                }
-            }
-            FFIArray::new(out)
-        }
-        Err(e) => {
-            set_last_error(&e);
-            // Return empty array on error
-            FFIArray {
-                data: std::ptr::null_mut(),
-                len: 0,
-                capacity: 0,
-                elem_size: std::mem::size_of::<FFICheckpoint>(),
-                elem_align: std::mem::align_of::<FFICheckpoint>(),
-            }
-        }
-    }
-}

dash-spv-ffi/src/bin/ffi_cli.rs

@@ -9,14 +9,12 @@ use dash_spv::storage::DiskStorageManager;
 use dash_spv::types::SyncStage;
 use dash_spv::DashSpvClient;
 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::ffi::CString;
 use std::os::raw::{c_char, c_void};
-use std::str::FromStr;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -513,23 +511,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_stop(client: *mut FFIDashSpvClient)
     }
 }
 
-/// Performs a test synchronization of the SPV client
-///
-/// # Parameters
-/// - `client`: Pointer to an FFIDashSpvClient instance
-///
-/// # Returns
-/// - `0` on success
-/// - Negative error code on failure
-///
-/// # Safety
-/// This function is unsafe because it dereferences a raw pointer.
-/// The caller must ensure that the client pointer is valid.
-#[no_mangle]
-pub unsafe extern "C" fn dash_spv_ffi_client_test_sync(client: *mut FFIDashSpvClient) -> i32 {
-    null_check!(client);
-
-    let client = &(*client);
+pub fn client_test_sync(client: &FFIDashSpvClient) -> i32 {
     let result = client.runtime.block_on(async {
         let spv_client = {
             let mut guard = client.inner.lock().unwrap();
@@ -1033,34 +1015,6 @@ pub unsafe extern "C" fn dash_spv_ffi_client_clear_storage(client: *mut FFIDashS
     }
 }
 
-/// Check if compact filter sync is currently available.
-///
-/// # Safety
-/// - `client` must be a valid, non-null pointer.
-#[no_mangle]
-pub unsafe extern "C" fn dash_spv_ffi_client_is_filter_sync_available(
-    client: *mut FFIDashSpvClient,
-) -> bool {
-    null_check!(client, false);
-
-    let client = &(*client);
-    let inner = client.inner.clone();
-
-    client.runtime.block_on(async {
-        let spv_client = {
-            let mut guard = inner.lock().unwrap();
-            match guard.take() {
-                Some(client) => client,
-                None => return false,
-            }
-        };
-        let res = spv_client.is_filter_sync_available().await;
-        let mut guard = inner.lock().unwrap();
-        *guard = Some(spv_client);
-        res
-    })
-}
-
 /// Set event callbacks for the client.
 ///
 /// # Safety
@@ -1144,99 +1098,6 @@ pub unsafe extern "C" fn dash_spv_ffi_sync_progress_destroy(progress: *mut FFISy
 
 // Wallet operations
 
-/// Request a rescan of the blockchain from a given height (not yet implemented).
-///
-/// # Safety
-/// - `client` must be a valid, non-null pointer.
-#[no_mangle]
-pub unsafe extern "C" fn dash_spv_ffi_client_rescan_blockchain(
-    client: *mut FFIDashSpvClient,
-    _from_height: u32,
-) -> i32 {
-    null_check!(client);
-
-    let client = &(*client);
-    let inner = client.inner.clone();
-
-    let result: Result<(), dash_spv::SpvError> = client.runtime.block_on(async {
-        let mut guard = inner.lock().unwrap();
-        if let Some(ref mut _spv_client) = *guard {
-            // TODO: rescan_from_height not yet implemented in dash-spv
-            Err(dash_spv::SpvError::Config("Not implemented".to_string()))
-        } else {
-            Err(dash_spv::SpvError::Storage(dash_spv::StorageError::NotFound(
-                "Client not initialized".to_string(),
-            )))
-        }
-    });
-
-    match result {
-        Ok(_) => FFIErrorCode::Success as i32,
-        Err(e) => {
-            set_last_error(&format!("Failed to rescan blockchain: {}", e));
-            FFIErrorCode::from(e) as i32
-        }
-    }
-}
-
-/// Record that we attempted to send a transaction by its txid.
-///
-/// # Safety
-/// - `client` and `txid` must be valid, non-null pointers.
-#[no_mangle]
-pub unsafe extern "C" fn dash_spv_ffi_client_record_send(
-    client: *mut FFIDashSpvClient,
-    txid: *const c_char,
-) -> i32 {
-    null_check!(client);
-    null_check!(txid);
-
-    let txid_str = match CStr::from_ptr(txid).to_str() {
-        Ok(s) => s,
-        Err(e) => {
-            set_last_error(&format!("Invalid UTF-8 in txid: {}", e));
-            return FFIErrorCode::InvalidArgument as i32;
-        }
-    };
-
-    let txid = match Txid::from_str(txid_str) {
-        Ok(t) => t,
-        Err(e) => {
-            set_last_error(&format!("Invalid txid: {}", e));
-            return FFIErrorCode::InvalidArgument 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(client) => client,
-                None => {
-                    return Err(dash_spv::SpvError::Storage(dash_spv::StorageError::NotFound(
-                        "Client not initialized".to_string(),
-                    )))
-                }
-            }
-        };
-        let res = spv_client.record_send(txid).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
-        }
-    }
-}
-
 /// Get the wallet manager from the SPV client
 ///
 /// Returns a pointer to an `FFIWalletManager` wrapper that clones the underlying