clear filters

Author: QuantumExplorer

dash-spv/src/client/block_processor.rs

@@ -180,7 +180,6 @@ impl<W: WalletInterface + Send + Sync + 'static, S: StorageManager + Send + Sync
                     let matches =
                         wallet.check_compact_filter(&filter, &block_hash, self.network).await;
 
-
                     if matches {
                         tracing::info!("🎯 Compact filter matched for block {}", block_hash);
                         drop(wallet);
@@ -189,7 +188,11 @@ impl<W: WalletInterface + Send + Sync + 'static, S: StorageManager + Send + Sync
                             hash: block_hash.to_string(),
                         });
                     } else {
-                        tracing::debug!("Compact filter did not match for block {}, {}", block_hash, wallet.describe(self.network).await);
+                        tracing::debug!(
+                            "Compact filter did not match for block {}, {}",
+                            block_hash,
+                            wallet.describe(self.network).await
+                        );
                         drop(wallet);
                     }
 

dash-spv/src/client/mod.rs

@@ -119,6 +119,42 @@ impl<
         storage.clear_sync_state().await.map_err(SpvError::Storage)
     }
 
+    /// Clear all stored filter headers and compact filters while keeping other data intact.
+    pub async fn clear_filters(&mut self) -> Result<()> {
+        {
+            let mut storage = self.storage.lock().await;
+            storage.clear_filters().await.map_err(SpvError::Storage)?;
+        }
+
+        // Reset in-memory chain state for filters
+        {
+            let mut state = self.state.write().await;
+            state.filter_headers.clear();
+            state.current_filter_tip = None;
+        }
+
+        // Reset filter sync manager tracking
+        self.sync_manager.filter_sync_mut().clear_filter_state().await;
+
+        // Reset filter-related statistics
+        let received_heights = {
+            let stats = self.stats.read().await;
+            stats.received_filter_heights.clone()
+        };
+
+        {
+            let mut stats = self.stats.write().await;
+            stats.filter_headers_downloaded = 0;
+            stats.filter_height = 0;
+            stats.filters_downloaded = 0;
+            stats.filters_received = 0;
+        }
+
+        received_heights.lock().await.clear();
+
+        Ok(())
+    }
+
     /// Take the progress receiver for external consumption.
     pub fn take_progress_receiver(
         &mut self,

dash-spv/src/storage/disk.rs

@@ -1631,6 +1631,27 @@ impl StorageManager for DiskStorageManager {
         Ok(())
     }
 
+    async fn clear_filters(&mut self) -> StorageResult<()> {
+        // Stop worker to prevent concurrent writes to filter directories
+        self.stop_worker().await;
+
+        // Clear in-memory filter state
+        self.active_filter_segments.write().await.clear();
+        *self.cached_filter_tip_height.write().await = None;
+
+        // Remove filter headers and compact filter files
+        let filters_dir = self.base_path.join("filters");
+        if filters_dir.exists() {
+            tokio::fs::remove_dir_all(&filters_dir).await?;
+        }
+        tokio::fs::create_dir_all(&filters_dir).await?;
+
+        // Restart background worker for future operations
+        self.start_worker().await;
+
+        Ok(())
+    }
+
     async fn stats(&self) -> StorageResult<StorageStats> {
         let mut component_sizes = HashMap::new();
         let mut total_size = 0u64;

dash-spv/src/storage/memory.rs

@@ -307,6 +307,12 @@ impl StorageManager for MemoryStorageManager {
         Ok(())
     }
 
+    async fn clear_filters(&mut self) -> StorageResult<()> {
+        self.filter_headers.clear();
+        self.filters.clear();
+        Ok(())
+    }
+
     async fn stats(&self) -> StorageResult<StorageStats> {
         let mut component_sizes = HashMap::new();
 

dash-spv/src/storage/mod.rs

@@ -154,6 +154,9 @@ pub trait StorageManager: Send + Sync {
     /// Clear all data.
     async fn clear(&mut self) -> StorageResult<()>;
 
+    /// Clear all filter headers and compact filters.
+    async fn clear_filters(&mut self) -> StorageResult<()>;
+
     /// Get storage statistics.
     async fn stats(&self) -> StorageResult<StorageStats>;
 

dash-spv/src/sync/filters.rs

@@ -3466,4 +3466,12 @@ impl<S: StorageManager + Send + Sync + 'static, N: NetworkManager + Send + Sync
         self.last_sync_progress = std::time::Instant::now();
         tracing::debug!("Reset filter sync pending requests");
     }
+
+    /// Fully clear filter tracking state, including received heights.
+    pub async fn clear_filter_state(&mut self) {
+        self.reset_pending_requests();
+        let mut heights = self.received_filter_heights.lock().await;
+        heights.clear();
+        tracing::info!("Cleared filter sync state and received heights");
+    }
 }

dash-spv/tests/error_handling_test.rs

@@ -380,6 +380,13 @@ impl StorageManager for MockStorageManager {
         Ok(())
     }
 
+    async fn clear_filters(&mut self) -> StorageResult<()> {
+        if self.fail_on_write {
+            return Err(StorageError::WriteFailed("Mock write failure".to_string()));
+        }
+        Ok(())
+    }
+
     async fn stats(&self) -> StorageResult<dash_spv::storage::StorageStats> {
         Ok(dash_spv::storage::StorageStats {
             header_count: 0,

dash-spv/tests/error_recovery_integration_test.rs

@@ -655,6 +655,10 @@ impl StorageManager for MockStorageManager {
         Ok(())
     }
 
+    async fn clear_filters(&mut self) -> dash_spv::error::StorageResult<()> {
+        Ok(())
+    }
+
     async fn stats(&self) -> dash_spv::error::StorageResult<dash_spv::storage::StorageStats> {
         Ok(dash_spv::storage::StorageStats {
             header_count: 0,

key-wallet-manager/src/wallet_manager/process_block.rs

@@ -2,8 +2,8 @@ use crate::wallet_interface::WalletInterface;
 use crate::{Network, WalletManager};
 use alloc::string::String;
 use alloc::vec::Vec;
-use core::fmt::Write as _;
 use async_trait::async_trait;
+use core::fmt::Write as _;
 use dashcore::bip158::BlockFilter;
 use dashcore::prelude::CoreBlockHeight;
 use dashcore::{Block, BlockHash, Transaction, Txid};
@@ -161,11 +161,6 @@ impl<T: WalletInfoInterface + Send + Sync + 'static> WalletInterface for WalletM
             details.push(format!("{} ({}): {}", name, wallet_id_hex, summary));
         }
 
-        format!(
-            "WalletManager: {} wallet(s) on {}\n{}",
-            wallet_count,
-            network,
-            details.join("\n")
-        )
+        format!("WalletManager: {} wallet(s) on {}\n{}", wallet_count, network, details.join("\n"))
     }
 }