feat: add CFHeader gap detection and auto-restart functionality

Author: PastaPastaPasta

dash-spv/src/client/config.rs

@@ -65,6 +65,36 @@ pub struct ClientConfig {
 
     /// Delay between filter requests in milliseconds (default: 50).
     pub filter_request_delay_ms: u64,
+    
+    /// Enable automatic CFHeader gap detection and restart
+    pub enable_cfheader_gap_restart: bool,
+    
+    /// Interval for checking CFHeader gaps (seconds)
+    pub cfheader_gap_check_interval_secs: u64,
+    
+    /// Cooldown between CFHeader restart attempts (seconds)  
+    pub cfheader_gap_restart_cooldown_secs: u64,
+    
+    /// Maximum CFHeader gap restart attempts
+    pub max_cfheader_gap_restart_attempts: u32,
+    
+    /// Enable automatic filter gap detection and restart
+    pub enable_filter_gap_restart: bool,
+    
+    /// Interval for checking filter gaps (seconds)
+    pub filter_gap_check_interval_secs: u64,
+    
+    /// Minimum filter gap size to trigger restart (blocks)
+    pub min_filter_gap_size: u32,
+    
+    /// Cooldown between filter restart attempts (seconds)
+    pub filter_gap_restart_cooldown_secs: u64,
+    
+    /// Maximum filter gap restart attempts
+    pub max_filter_gap_restart_attempts: u32,
+    
+    /// Maximum number of filters to sync in a single gap sync batch
+    pub max_filter_gap_sync_size: u32,
 }
 
 impl Default for ClientConfig {
@@ -88,6 +118,16 @@ impl Default for ClientConfig {
             max_concurrent_filter_requests: 16,
             enable_filter_flow_control: true,
             filter_request_delay_ms: 0,
+            enable_cfheader_gap_restart: true,
+            cfheader_gap_check_interval_secs: 15,
+            cfheader_gap_restart_cooldown_secs: 30,
+            max_cfheader_gap_restart_attempts: 5,
+            enable_filter_gap_restart: true,
+            filter_gap_check_interval_secs: 20,
+            min_filter_gap_size: 10,
+            filter_gap_restart_cooldown_secs: 30,
+            max_filter_gap_restart_attempts: 5,
+            max_filter_gap_sync_size: 50000,
         }
     }
 }

dash-spv/src/client/filter_sync.rs

@@ -92,6 +92,21 @@ impl<'a> FilterSyncCoordinator<'a> {
         Ok(Vec::new())
     }
 
+    /// Sync filters for a specific height range.
+    pub async fn sync_filters_range(&mut self, start_height: Option<u32>, count: Option<u32>) -> Result<()> {
+        // Get filter tip height to determine default values
+        let filter_tip_height = self.storage.get_filter_tip_height().await
+            .map_err(|e| SpvError::Storage(e))?
+            .unwrap_or(0);
+        
+        let start = start_height.unwrap_or(filter_tip_height.saturating_sub(99));
+        let num_blocks = count.unwrap_or(100);
+        
+        tracing::info!("Starting filter sync for specific range from height {} ({} blocks)", start, num_blocks);
+        
+        self.sync_filters_coordinated(start, num_blocks).await
+    }
+    
     /// Sync filters in coordination with the monitoring loop using flow control processing
     async fn sync_filters_coordinated(&mut self, start_height: u32, count: u32) -> Result<()> {
         tracing::info!("Starting coordinated filter sync with flow control from height {} to {} ({} filters expected)", 

dash-spv/src/client/mod.rs

@@ -451,7 +451,7 @@ impl DashSpvClient {
 
         // Timer for filter gap checking
         let mut last_filter_gap_check = Instant::now();
-        let filter_gap_check_interval = std::time::Duration::from_secs(10);
+        let filter_gap_check_interval = std::time::Duration::from_secs(self.config.cfheader_gap_check_interval_secs);
 
         loop {
             // Check if we should stop
@@ -510,6 +510,17 @@ impl DashSpvClient {
             if last_status_update.elapsed() >= status_update_interval {
                 self.update_status_display().await;
 
+                // Report CFHeader gap information if enabled
+                if self.config.enable_filters {
+                    if let Ok((has_gap, block_height, filter_height, gap_size)) = 
+                        self.sync_manager.filter_sync().check_cfheader_gap(&*self.storage).await {
+                        if has_gap && gap_size >= 100 { // Only log significant gaps
+                            tracing::info!("📏 CFHeader Gap: {} block headers vs {} filter headers (gap: {})", 
+                                          block_height, filter_height, gap_size);
+                        }
+                    }
+                }
+
                 // Report enhanced filter sync progress if active
                 let (filters_requested, filters_received, basic_progress, timeout, total_missing, actual_coverage, missing_ranges) = 
                     crate::sync::filters::FilterSyncManager::get_filter_sync_status_with_gaps(&self.stats, self.sync_manager.filter_sync()).await;
@@ -587,6 +598,68 @@ impl DashSpvClient {
                         .check_and_retry_missing_filters(&mut *self.network, &*self.storage).await {
                         tracing::warn!("Failed to check and retry missing filters: {}", e);
                     }
+                    
+                    // Check for CFHeader gaps and auto-restart if needed
+                    if self.config.enable_cfheader_gap_restart {
+                        match self.sync_manager.filter_sync_mut()
+                            .maybe_restart_cfheader_sync_for_gap(&mut *self.network, &mut *self.storage).await {
+                            Ok(restarted) => {
+                                if restarted {
+                                    tracing::info!("🔄 Auto-restarted CFHeader sync due to detected gap");
+                                }
+                            }
+                            Err(e) => {
+                                tracing::warn!("Failed to check/restart CFHeader sync for gap: {}", e);
+                            }
+                        }
+                    }
+                    
+                    // Check for filter gaps and auto-restart if needed
+                    if self.config.enable_filter_gap_restart && !self.watch_items.read().await.is_empty() {
+                        // Get current sync progress
+                        let progress = self.sync_progress().await?;
+                        
+                        // Check if there's a gap between synced filters and filter headers
+                        match self.sync_manager.filter_sync()
+                            .check_filter_gap(&*self.storage, &progress).await {
+                            Ok((has_gap, filter_header_height, last_synced_filter, gap_size)) => {
+                                if has_gap && gap_size >= self.config.min_filter_gap_size {
+                                    tracing::info!("🔍 Detected filter gap: filter headers at {}, last synced filter at {} (gap: {} blocks)",
+                                                  filter_header_height, last_synced_filter, gap_size);
+                                    
+                                    // Check if we're not already syncing filters
+                                    if !self.sync_manager.filter_sync().is_syncing_filters() {
+                                        // Start filter sync for the missing range
+                                        let start_height = last_synced_filter + 1;
+                                        
+                                        // Limit the sync size to avoid overwhelming the system
+                                        let max_sync_size = self.config.max_filter_gap_sync_size;
+                                        let sync_count = gap_size.min(max_sync_size);
+                                        
+                                        if sync_count < gap_size {
+                                            tracing::info!("🔄 Auto-starting filter sync for gap from height {} ({} blocks of {} total gap)", 
+                                                          start_height, sync_count, gap_size);
+                                        } else {
+                                            tracing::info!("🔄 Auto-starting filter sync for gap from height {} ({} blocks)", 
+                                                          start_height, sync_count);
+                                        }
+                                        
+                                        match self.sync_filters_range(Some(start_height), Some(sync_count)).await {
+                                            Ok(_) => {
+                                                tracing::info!("✅ Successfully started filter sync for gap");
+                                            }
+                                            Err(e) => {
+                                                tracing::warn!("Failed to start filter sync for gap: {}", e);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                tracing::debug!("Failed to check filter gap: {}", e);
+                            }
+                        }
+                    }
                 }
                 last_filter_gap_check = Instant::now();
             }
@@ -1271,6 +1344,19 @@ impl DashSpvClient {
         );
         coordinator.sync_and_check_filters(num_blocks).await
     }
+    
+    /// Sync filters for a specific height range.
+    pub async fn sync_filters_range(&mut self, start_height: Option<u32>, count: Option<u32>) -> Result<()> {
+        let mut coordinator = FilterSyncCoordinator::new(
+            &mut self.sync_manager,
+            &mut *self.storage,
+            &mut *self.network,
+            &self.watch_items,
+            &self.stats,
+            &self.running,
+        );
+        coordinator.sync_filters_range(start_height, count).await
+    }
 
     /// Initialize genesis block if not already present in storage.
     async fn initialize_genesis_block(&mut self) -> Result<()> {

dash-spv/src/client/status_display.rs

@@ -39,6 +39,15 @@ impl<'a> StatusDisplay<'a> {
     /// Get current sync progress.
     pub async fn sync_progress(&self) -> Result<SyncProgress> {
         let state = self.state.read().await;
+        let stats = self.stats.read().await;
+        
+        // Calculate last synced filter height from received filter heights
+        let last_synced_filter_height = if let Ok(heights) = stats.received_filter_heights.lock() {
+            heights.iter().max().copied()
+        } else {
+            None
+        };
+        
         Ok(SyncProgress {
             header_height: state.tip_height(),
             filter_header_height: state.filter_headers.len().saturating_sub(1) as u32,
@@ -47,7 +56,8 @@ impl<'a> StatusDisplay<'a> {
             headers_synced: false, // TODO: Implement
             filter_headers_synced: false, // TODO: Implement
             masternodes_synced: false, // TODO: Implement
-            filters_downloaded: 0, // TODO: Track properly
+            filters_downloaded: stats.filters_received,
+            last_synced_filter_height,
             sync_start: std::time::SystemTime::now(), // TODO: Track properly
             last_update: std::time::SystemTime::now(),
         })

dash-spv/src/main.rs

@@ -234,7 +234,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         let example_addresses = match network {
             dashcore::Network::Dash => vec![
                 // Some example mainnet addresses (these are from block explorers/faucets)
-                "XjbaGWaGnvEtuQAUoBgDxJWe8ZNv45upG2", // Crowdnode
+                "Xesjop7V9xLndFMgZoCrckJ5ZPgJdJFbA3", // Crowdnode
             ],
             dashcore::Network::Testnet => vec![
                 // Testnet addresses
@@ -255,7 +255,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     if let Ok(valid_addr) = addr.require_network(network) {
                         // For the example mainnet address (Crowdnode), set earliest height to 1,000,000
                         let watch_item = if network == dashcore::Network::Dash && addr_str == "XjbaGWaGnvEtuQAUoBgDxJWe8ZNv45upG2" {
-                            dash_spv::WatchItem::address_from_height(valid_addr, 500_000)
+                            dash_spv::WatchItem::address_from_height(valid_addr, 200_000)
                         } else {
                             dash_spv::WatchItem::address(valid_addr)
                         };

dash-spv/src/network/tests.rs

@@ -30,6 +30,10 @@ mod multi_peer_tests {
             enable_filter_flow_control: true,
             filter_request_delay_ms: 0,
             max_concurrent_filter_requests: 50,
+            enable_cfheader_gap_restart: true,
+            cfheader_gap_check_interval_secs: 15,
+            cfheader_gap_restart_cooldown_secs: 30,
+            max_cfheader_gap_restart_attempts: 5,
         }
     }