fix: require height consistency in is_synced() to prevent race

When new blocks arrive after initial sync, there is a window between
a manager completing and downstream managers processing the event.
During this window all manager states show Synced but heights are
inconsistent. Add checks that filter headers have caught up to block
headers and filters have caught up to filter headers.

Author: xdustinface

dash-spv/src/sync/progress.rs

@@ -78,6 +78,11 @@ impl SyncProgress {
     }
 
     /// Check if all managers are idle (sync complete).
+    ///
+    /// Each manager must report `Synced` and downstream managers must have caught
+    /// up to their upstream counterparts. This prevents a false positive in the
+    /// window between an upstream manager completing and the downstream manager
+    /// processing the resulting event.
     pub fn is_synced(&self) -> bool {
         let states: Vec<SyncState> = [
             self.headers.as_ref().map(|h| h.state()),
@@ -95,7 +100,25 @@ impl SyncProgress {
             return false;
         }
 
-        states.iter().all(|state| *state == SyncState::Synced)
+        if !states.iter().all(|state| *state == SyncState::Synced) {
+            return false;
+        }
+
+        // Filter headers must have caught up to block headers
+        if let (Some(h), Some(fh)) = (&self.headers, &self.filter_headers) {
+            if fh.current_height() < h.current_height() {
+                return false;
+            }
+        }
+
+        // Filters must have caught up to filter headers
+        if let (Some(fh), Some(fl)) = (&self.filter_headers, &self.filters) {
+            if fl.current_height() < fh.current_height() {
+                return false;
+            }
+        }
+
+        true
     }
 
     /// Get overall completion percentage (0.0 to 1.0).

dash-spv/src/sync/sync_coordinator.rs

@@ -393,6 +393,64 @@ mod tests {
         assert_eq!(progress.percentage(), 1.0);
     }
 
+    #[test]
+    fn test_is_synced_requires_height_consistency() {
+        use crate::sync::{BlocksProgress, FilterHeadersProgress, MasternodesProgress};
+
+        let mut progress = SyncProgress::default();
+
+        // Set up all managers as Synced at height 1000
+        let mut h = BlockHeadersProgress::default();
+        h.set_state(SyncState::Synced);
+        h.update_current_height(1000);
+        h.update_target_height(1000);
+        progress.update_headers(h);
+
+        let mut fh = FilterHeadersProgress::default();
+        fh.set_state(SyncState::Synced);
+        fh.update_current_height(1000);
+        fh.update_target_height(1000);
+        progress.update_filter_headers(fh);
+
+        let mut fl = FiltersProgress::default();
+        fl.set_state(SyncState::Synced);
+        fl.update_current_height(1000);
+        fl.update_target_height(1000);
+        progress.update_filters(fl);
+
+        let mut b = BlocksProgress::default();
+        b.set_state(SyncState::Synced);
+        progress.update_blocks(b);
+
+        let mut m = MasternodesProgress::default();
+        m.set_state(SyncState::Synced);
+        progress.update_masternodes(m);
+
+        assert!(progress.is_synced(), "should be synced when all heights match");
+
+        // Simulate filter headers advancing to 1006 (new blocks arrived)
+        // while filters haven't processed the event yet
+        let mut fh = FilterHeadersProgress::default();
+        fh.set_state(SyncState::Synced);
+        fh.update_current_height(1006);
+        fh.update_target_height(1006);
+        progress.update_filter_headers(fh);
+
+        assert!(
+            !progress.is_synced(),
+            "should not be synced when filters lag behind filter headers"
+        );
+
+        // Now filters catch up
+        let mut fl = FiltersProgress::default();
+        fl.set_state(SyncState::Synced);
+        fl.update_current_height(1006);
+        fl.update_target_height(1006);
+        progress.update_filters(fl);
+
+        assert!(progress.is_synced(), "should be synced after filters catch up");
+    }
+
     #[test]
     fn test_sync_percentage() {
         let mut progress = SyncProgress::default();