fix: sync deadlock — sequential window + priority eviction for pending queue

Sync was stuck because parallel_download_microblocks requested ALL missing
ranges simultaneously, flooding PENDING_SYNC_BLOCKS (max 1000) with far-away
blocks and rejecting near-height blocks the node needs to advance.

- Limit parallel sync to nearest 500 blocks (MAX_SYNC_WINDOW), caller
  re-invokes as local_height advances — sliding window
- Smart eviction: when queue overflows, evict farthest blocks first so
  near-height blocks always have priority
- Lower snapshot threshold from 10K to 2K blocks for faster catch-up

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: AIQnetLab

development/qnet-integration/src/node.rs

@@ -7354,18 +7354,19 @@ impl BlockchainNode {
                             // Skip snapshot for Light nodes - they sync only recent blocks
                             let is_light_node = blockchain_for_sync.node_type == NodeType::Light;
 
-                            // v3.3: IMPROVED SNAPSHOT SYNC for returning nodes
+                            // v10.3: IMPROVED SNAPSHOT SYNC for returning nodes
                             // Try snapshot if:
                             // 1. Not a Light node (they don't need full history)
                             // 2. EITHER: New node (local_height < 100)
-                            //    OR: Large gap (>10,000 blocks = ~2.7 hours offline)
+                            //    OR: Large gap (>2,000 blocks = ~33 min offline)
                             // 3. Network has at least one full snapshot (43,200+ blocks)
                             //
-                            // RATIONALE: Node offline for days should use snapshot, not sync 500K blocks!
-                            // Example: 500K blocks × 100 batch = 5,000 requests × 25 sec = ~35 hours to sync
-                            // With snapshot: download snapshot + sync remaining = minutes
+                            // RATIONALE: Block-by-block sync for large gaps floods the
+                            // pending queue with parallel requests, causing backpressure
+                            // deadlocks. Snapshot avoids this entirely.
+                            // Threshold lowered from 10K to 2K to use snapshot more aggressively.
                             let gap = network_height.saturating_sub(local_height);
-                            let large_gap_threshold = 10_000; // ~2.7 hours worth of blocks
+                            let large_gap_threshold = 2_000; // ~33 minutes worth of blocks
                             let should_use_snapshot = !is_light_node 
                                 && (local_height < 100 || gap > large_gap_threshold)
                                 && network_height > SNAPSHOT_FULL_INTERVAL;  // Need at least 1 full snapshot

development/qnet-integration/src/unified_p2p.rs

@@ -301,28 +301,46 @@ pub fn mark_block_pending_sync(height: u64) -> bool {
         cleanup_pending_sync_blocks();
     }
 
-    // Hard limit: emergency cleanup
+    // Hard limit: emergency cleanup with PRIORITY EVICTION
     if PENDING_SYNC_BLOCKS.len() >= MAX_PENDING_SYNC_BLOCKS {
         let local_height = LOCAL_BLOCKCHAIN_HEIGHT.load(std::sync::atomic::Ordering::Relaxed);
         let mut entries_to_remove: Vec<u64> = Vec::new();
-        
-        // Remove entries below local height (already processed)
+
+        // Phase 1: Remove entries below local height (already processed)
         for entry in PENDING_SYNC_BLOCKS.iter() {
             if *entry.key() < local_height.saturating_sub(5) {
                 entries_to_remove.push(*entry.key());
             }
-            if entries_to_remove.len() >= 100 {
-                break;
-            }
         }
-        
-        for h in entries_to_remove {
-            PENDING_SYNC_BLOCKS.remove(&h);
+
+        for h in &entries_to_remove {
+            PENDING_SYNC_BLOCKS.remove(h);
         }
-        
+
+        // Phase 2: If still full, EVICT FARTHEST blocks from local_height.
+        // Near-height blocks are needed next; far blocks can be re-requested later.
+        // This prevents the deadlock where far blocks occupy all slots and
+        // near blocks (that the node needs to advance) get rejected.
+        if PENDING_SYNC_BLOCKS.len() >= MAX_PENDING_SYNC_BLOCKS {
+            let mut all_heights: Vec<u64> = PENDING_SYNC_BLOCKS.iter()
+                .map(|entry| *entry.key())
+                .collect();
+            // Sort by distance from local_height (farthest first)
+            all_heights.sort_by_key(|h| std::cmp::Reverse(h.abs_diff(local_height)));
+            // Evict top 50% (farthest blocks)
+            let evict_count = all_heights.len() / 2;
+            for h in all_heights.iter().take(evict_count) {
+                PENDING_SYNC_BLOCKS.remove(h);
+            }
+            if crate::node::is_info() {
+                println!("[INFO][SYNC] priority_eviction local_h={} evicted={} remaining={}",
+                         local_height, evict_count, PENDING_SYNC_BLOCKS.len());
+            }
+        }
+
         if PENDING_SYNC_BLOCKS.len() >= MAX_PENDING_SYNC_BLOCKS {
             if crate::node::is_warn() {
-                println!("[WARN][SYNC] queue_full_after_cleanup size={} rejecting={}", 
+                println!("[WARN][SYNC] queue_full_after_cleanup size={} rejecting={}",
                          PENDING_SYNC_BLOCKS.len(), height);
             }
             return false;
@@ -10468,11 +10486,19 @@ impl SimplifiedP2P {
         let parallel_workers: usize = workers;
         let chunk_size_blocks: u64 = chunk_size;
 
-        // v10.1: Download ALL missing blocks in one call.
-        // Wave-based limiting (old WAVE_SIZE=100) was causing our fast sync loop
-        // to need many iterations. Semaphore already limits concurrency.
-        // The caller (fast sync loop) handles re-invocation if network advances.
-        let actual_target = target_height;
+        // v10.3: Download only NEAREST missing blocks, not all at once.
+        // Downloading ALL ranges simultaneously floods PENDING_SYNC_BLOCKS (max 1000)
+        // with far-away blocks, causing backpressure that rejects near-height blocks
+        // the node actually needs next. This creates a sync deadlock where the node
+        // advances ~100 blocks per 60s TTL cycle instead of continuously.
+        //
+        // Solution: limit to nearest 500 blocks. The caller (fast sync loop) re-invokes
+        // as local_height advances, naturally sliding the window forward.
+        const MAX_SYNC_WINDOW: u64 = 500;
+        let actual_target = std::cmp::min(target_height, current_height + MAX_SYNC_WINDOW);
+
+        // Filter missing_blocks to only include blocks within the window
+        missing_blocks.retain(|h| *h <= actual_target);
 
         if crate::node::is_info() {
             println!("[SYNC] ⚡ Starting parallel sync: {} blocks (target: {}) with {} workers",