more work

Author: QuantumExplorer

dash-spv-ffi/include/dash_spv_ffi.h

@@ -710,6 +710,44 @@ struct FFIFilterMatches *dash_spv_ffi_client_get_filter_matched_heights(struct F
                                                                         uint32_t end_height)
 ;
 
+/**
+ * Get the total count of transactions across all wallets.
+ *
+ * This returns the persisted transaction count from the wallet,
+ * not the ephemeral sync statistics. Use this to show how many
+ * blocks contained relevant transactions for the user's wallets.
+ *
+ * # Parameters
+ * - `client`: Valid pointer to an FFIDashSpvClient
+ *
+ * # Returns
+ * - Transaction count (0 or higher)
+ * - Returns 0 if client not initialized or wallet not available
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer
+ */
+ uintptr_t dash_spv_ffi_client_get_transaction_count(struct FFIDashSpvClient *client) ;
+
+/**
+ * Get the count of blocks that contained relevant transactions.
+ *
+ * This counts unique block heights from the wallet's transaction history,
+ * representing how many blocks actually had transactions for the user's wallets.
+ * This is a persistent metric that survives app restarts.
+ *
+ * # Parameters
+ * - `client`: Valid pointer to an FFIDashSpvClient
+ *
+ * # Returns
+ * - Count of blocks with transactions (0 or higher)
+ * - Returns 0 if client not initialized or wallet not available
+ *
+ * # Safety
+ * - `client` must be a valid, non-null pointer
+ */
+ uintptr_t dash_spv_ffi_client_get_blocks_with_transactions_count(struct FFIDashSpvClient *client) ;
+
  struct FFIClientConfig *dash_spv_ffi_config_new(FFINetwork network) ;
 
  struct FFIClientConfig *dash_spv_ffi_config_mainnet(void) ;

dash-spv-ffi/src/client.rs

@@ -1770,3 +1770,104 @@ pub unsafe extern "C" fn dash_spv_ffi_client_get_filter_matched_heights(
 
     result.unwrap_or(std::ptr::null_mut())
 }
+
+/// Get the total count of transactions across all wallets.
+///
+/// This returns the persisted transaction count from the wallet,
+/// not the ephemeral sync statistics. Use this to show how many
+/// blocks contained relevant transactions for the user's wallets.
+///
+/// # Parameters
+/// - `client`: Valid pointer to an FFIDashSpvClient
+///
+/// # Returns
+/// - Transaction count (0 or higher)
+/// - Returns 0 if client not initialized or wallet not available
+///
+/// # Safety
+/// - `client` must be a valid, non-null pointer
+#[no_mangle]
+pub unsafe extern "C" fn dash_spv_ffi_client_get_transaction_count(
+    client: *mut FFIDashSpvClient,
+) -> usize {
+    null_check!(client, 0);
+
+    let client = &(*client);
+    let inner = client.inner.clone();
+
+    let result = client.runtime.block_on(async {
+        // Get wallet without taking the client
+        let guard = inner.lock().unwrap();
+        match guard.as_ref() {
+            Some(spv_client) => {
+                // Access wallet and get transaction count
+                let wallet = spv_client.wallet();
+                let wallet_guard = wallet.read().await;
+                let tx_history = wallet_guard.transaction_history();
+                tx_history.len()
+            }
+            None => {
+                tracing::warn!("Client not initialized when querying transaction count");
+                0
+            }
+        }
+    });
+
+    result
+}
+
+/// Get the count of blocks that contained relevant transactions.
+///
+/// This counts unique block heights from the wallet's transaction history,
+/// representing how many blocks actually had transactions for the user's wallets.
+/// This is a persistent metric that survives app restarts.
+///
+/// # Parameters
+/// - `client`: Valid pointer to an FFIDashSpvClient
+///
+/// # Returns
+/// - Count of blocks with transactions (0 or higher)
+/// - Returns 0 if client not initialized or wallet not available
+///
+/// # Safety
+/// - `client` must be a valid, non-null pointer
+#[no_mangle]
+pub unsafe extern "C" fn dash_spv_ffi_client_get_blocks_with_transactions_count(
+    client: *mut FFIDashSpvClient,
+) -> usize {
+    null_check!(client, 0);
+
+    let client = &(*client);
+    let inner = client.inner.clone();
+
+    let result = client.runtime.block_on(async {
+        // Get wallet without taking the client
+        let guard = inner.lock().unwrap();
+        match guard.as_ref() {
+            Some(spv_client) => {
+                // Access wallet and get unique block heights
+                let wallet = spv_client.wallet();
+                let wallet_guard = wallet.read().await;
+                let tx_history = wallet_guard.transaction_history();
+
+                // Count unique block heights (confirmed transactions only)
+                let mut unique_heights = std::collections::HashSet::new();
+                for tx in tx_history {
+                    if let Some(height) = tx.height {
+                        unique_heights.insert(height);
+                    }
+                }
+
+                unique_heights.len()
+            }
+            None => {
+                tracing::warn!(
+                    "Client not initialized when querying blocks with transactions count"
+                );
+                0
+            }
+        }
+    });
+
+    result
+}

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

@@ -241,4 +241,61 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    #[serial]
+    fn test_transaction_count_with_empty_wallet() {
+        unsafe {
+            let (config, _temp_dir) = create_test_config_with_dir();
+            let client = dash_spv_ffi_client_new(config);
+            assert!(!client.is_null(), "Client creation failed");
+
+            // Should return 0 for a new wallet with no transactions
+            let tx_count = dash_spv_ffi_client_get_transaction_count(client);
+            assert_eq!(tx_count, 0, "Expected 0 transactions for new wallet");
+
+            // Cleanup
+            dash_spv_ffi_client_destroy(client);
+            dash_spv_ffi_config_destroy(config);
+        }
+    }
+
+    #[test]
+    #[serial]
+    fn test_blocks_with_transactions_count_with_empty_wallet() {
+        unsafe {
+            let (config, _temp_dir) = create_test_config_with_dir();
+            let client = dash_spv_ffi_client_new(config);
+            assert!(!client.is_null(), "Client creation failed");
+
+            // Should return 0 for a new wallet with no transactions
+            let block_count = dash_spv_ffi_client_get_blocks_with_transactions_count(client);
+            assert_eq!(block_count, 0, "Expected 0 blocks for new wallet");
+
+            // Cleanup
+            dash_spv_ffi_client_destroy(client);
+            dash_spv_ffi_config_destroy(config);
+        }
+    }
+
+    #[test]
+    #[serial]
+    fn test_transaction_count_with_null_client() {
+        unsafe {
+            // Should handle null client gracefully
+            let tx_count = dash_spv_ffi_client_get_transaction_count(std::ptr::null_mut());
+            assert_eq!(tx_count, 0, "Expected 0 for null client");
+        }
+    }
+
+    #[test]
+    #[serial]
+    fn test_blocks_count_with_null_client() {
+        unsafe {
+            // Should handle null client gracefully
+            let block_count =
+                dash_spv_ffi_client_get_blocks_with_transactions_count(std::ptr::null_mut());
+            assert_eq!(block_count, 0, "Expected 0 for null client");
+        }
+    }
 }

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

@@ -172,6 +172,7 @@ mod tests {
             last_masternode_diff_height: None,
             sync_base_height: 0,
             synced_from_checkpoint: false,
+            filter_matches: std::collections::BTreeMap::new(),
         };
 
         let ffi_state = FFIChainState::from(state);

dash-spv/src/client/block_processor.rs

@@ -177,11 +177,17 @@ impl<W: WalletInterface + Send + Sync + 'static, S: StorageManager + Send + Sync
                 } => {
                     // Check compact filter with wallet
                     let mut wallet = self.wallet.write().await;
-                    let matches =
+                    let matched_wallet_ids =
                         wallet.check_compact_filter(&filter, &block_hash, self.network).await;
 
-                    if matches {
-                        tracing::info!("🎯 Compact filter matched for block {}", block_hash);
+                    let has_matches = !matched_wallet_ids.is_empty();
+
+                    if has_matches {
+                        tracing::info!(
+                            "🎯 Compact filter matched for block {} ({} wallet(s))",
+                            block_hash,
+                            matched_wallet_ids.len()
+                        );
                         drop(wallet);
                         // Emit event if filter matched
                         let _ = self.event_tx.send(SpvEvent::CompactFilterMatched {
@@ -196,7 +202,7 @@ impl<W: WalletInterface + Send + Sync + 'static, S: StorageManager + Send + Sync
                         drop(wallet);
                     }
 
-                    let _ = response_tx.send(Ok(matches));
+                    let _ = response_tx.send(Ok(has_matches));
                 }
             }
         }

dash-spv/src/client/block_processor_test.rs

@@ -68,9 +68,9 @@ mod tests {
             _filter: &dashcore::bip158::BlockFilter,
             _block_hash: &dashcore::BlockHash,
             _network: Network,
-        ) -> bool {
-            // Return true for all filters in test
-            true
+        ) -> Vec<[u8; 32]> {
+            // Return a test wallet ID for all filters in test
+            vec![[1u8; 32]]
         }
 
         async fn describe(&self, _network: Network) -> String {
@@ -291,9 +291,9 @@ mod tests {
                 _filter: &dashcore::bip158::BlockFilter,
                 _block_hash: &dashcore::BlockHash,
                 _network: Network,
-            ) -> bool {
-                // Always return false - filter doesn't match
-                false
+            ) -> Vec<[u8; 32]> {
+                // Return empty vector - filter doesn't match
+                Vec::new()
             }
 
             async fn describe(&self, _network: Network) -> String {

dash-spv/src/storage/disk/filters.rs

@@ -182,6 +182,66 @@ impl DiskStorageManager {
         Ok(*self.cached_filter_tip_height.read().await)
     }
 
+    /// Get the highest stored compact filter height by scanning the filters directory.
+    /// This checks which filters are actually persisted on disk, not just filter headers.
+    ///
+    /// Returns None if no filters are stored, otherwise returns the highest height found.
+    ///
+    /// Note: This only counts individual filter files ({height}.dat), not segment files.
+    pub async fn get_stored_filter_height(&self) -> StorageResult<Option<u32>> {
+        let filters_dir = self.base_path.join("filters");
+
+        // If filters directory doesn't exist, no filters are stored
+        if !filters_dir.exists() {
+            return Ok(None);
+        }
+
+        let mut max_height: Option<u32> = None;
+
+        // Read directory entries
+        let mut entries = tokio::fs::read_dir(&filters_dir).await?;
+
+        while let Some(entry) = entries.next_entry().await? {
+            let path = entry.path();
+
+            // Skip if not a file
+            if !path.is_file() {
+                continue;
+            }
+
+            // Check if it's a .dat file
+            if let Some(extension) = path.extension() {
+                if extension == "dat" {
+                    // Extract height from filename (format: "{height}.dat")
+                    if let Some(filename) = path.file_stem() {
+                        if let Some(filename_str) = filename.to_str() {
+                            // Only parse if filename is PURELY numeric (not "filter_segment_0001")
+                            // This ensures we only count individual filter files, not segments
+                            if filename_str.chars().all(|c| c.is_ascii_digit()) {
+                                if let Ok(height) = filename_str.parse::<u32>() {
+                                    if height > 2_000_000 {
+                                        // Sanity check - testnet/mainnet should never exceed 2M blocks
+                                        tracing::warn!(
+                                            "Found suspiciously high filter file: {}.dat (height {}), ignoring",
+                                            filename_str,
+                                            height
+                                        );
+                                        continue;
+                                    }
+                                    max_height = Some(
+                                        max_height.map_or(height, |current| current.max(height)),
+                                    );
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(max_height)
+    }
+
     /// Store a compact filter.
     pub async fn store_filter(&mut self, height: u32, filter: &[u8]) -> StorageResult<()> {
         let path = self.base_path.join(format!("filters/{}.dat", height));

dash-spv/src/storage/disk/state.rs

@@ -547,6 +547,10 @@ impl StorageManager for DiskStorageManager {
         Self::get_filter_tip_height(self).await
     }
 
+    async fn get_stored_filter_height(&self) -> StorageResult<Option<u32>> {
+        Self::get_stored_filter_height(self).await
+    }
+
     async fn store_masternode_state(&mut self, state: &MasternodeState) -> StorageResult<()> {
         Self::store_masternode_state(self, state).await
     }

dash-spv/src/storage/memory.rs

@@ -258,6 +258,15 @@ impl StorageManager for MemoryStorageManager {
         }
     }
 
+    async fn get_stored_filter_height(&self) -> StorageResult<Option<u32>> {
+        // For memory storage, find the highest filter in the HashMap
+        if self.filters.is_empty() {
+            Ok(None)
+        } else {
+            Ok(self.filters.keys().max().copied())
+        }
+    }
+
     async fn store_masternode_state(&mut self, state: &MasternodeState) -> StorageResult<()> {
         self.masternode_state = Some(state.clone());
         Ok(())

dash-spv/src/storage/mod.rs

@@ -127,6 +127,10 @@ pub trait StorageManager: Send + Sync {
     /// Get the current filter tip blockchain height.
     async fn get_filter_tip_height(&self) -> StorageResult<Option<u32>>;
 
+    /// Get the highest stored compact filter height by checking which filters are persisted.
+    /// This is distinct from filter header tip - it shows which filters are actually downloaded.
+    async fn get_stored_filter_height(&self) -> StorageResult<Option<u32>>;
+
     /// Store masternode state.
     async fn store_masternode_state(&mut self, state: &MasternodeState) -> StorageResult<()>;