sync from checkpoint works well

Author: pauldelucia

dash-spv/src/chain/checkpoints.rs

@@ -286,55 +286,31 @@ pub fn mainnet_checkpoints() -> Vec<Checkpoint> {
             28917698,
             None,
         ),
-        // Early network checkpoint (1 week after genesis)
-        create_checkpoint(
-            4991,
-            "000000003b01809551952460744d5dbb8fcbd6cbae3c220267bf7fa43f837367",
-            "000000001263f3327dd2f6bc445b47beb82fb8807a62e252ba064e2d2b6f91a6",
-            1390163520,
-            0x1e0fffff,
-            "0x00000000000000000000000000000000000000000000000000000000271027f0",
-            "7faff642d9e914716c50e3406df522b2b9a10ea3df4fef4e2229997367a6cab1",
-            357631712,
-            None,
-        ),
-        // 3 months checkpoint
-        create_checkpoint(
-            107996,
-            "00000000000a23840ac16115407488267aa3da2b9bc843e301185b7d17e4dc40",
-            "000000000006fe4020a310786bd34e17aa7681c86a20a2e121e0e3dd599800e8",
-            1395522898,
-            0x1b04864c,
-            "0x0000000000000000000000000000000000000000000000000056bf9caa56bf9d",
-            "15c3852f9e71a6cbc0cfa96d88202746cfeae6fc645ccc878580bc29daeff193",
-            10049236,
-            None,
-        ),
-        // 2017 checkpoint
+        // Block 750000 (2017)
         create_checkpoint(
             750000,
             "00000000000000b4181bbbdddbae464ce11fede5d0292fb63fdede1e7c8ab21c",
             "00000000000001e115237541be8dd91bce2653edd712429d11371842f85bd3e1",
-            1491953700,
-            0x1a075a02,
-            "0x00000000000000000000000000000000000000000000000485f01ee9f01ee9f8",
+            1507424630,
+            0x1a027884,
+            "0x0000000000000000000000000000000000000000000000172210fe351643b3f1",
             "0ce99835e2de1240e230b5075024817aace2b03b3944967a88af079744d0aa62",
             2199533779,
             None,
         ),
-        // Recent checkpoint with masternode list (2022)
+        // Block 1700000 (2022) with masternode list
         create_checkpoint(
             1700000,
             "000000000000001d7579a371e782fd9c4480f626a62b916fa4eb97e16a49043a",
             "000000000000001a5631d781a4be0d9cda08b470ac6f108843cedf32e4dc081e",
             1657142113,
             0x1927e30e,
-            "000000000000000000000000000000000000000000007562df93a26b81386288",
+            "0x000000000000000000000000000000000000000000007562df93a26b81386288",
             "dafe57cefc3bc265dfe8416e2f2e3a22af268fd587a48f36affd404bec738305",
             3820512540,
             Some("ML1700000__70227"),
         ),
-        // Latest checkpoint with masternode list (2022/2023)
+        // Block 1900000 (2023) with masternode list
         create_checkpoint(
             1900000,
             "000000000000001b8187c744355da78857cca5b9aeb665c39d12f26a0e3a9af5",
@@ -346,6 +322,18 @@ pub fn mainnet_checkpoints() -> Vec<Checkpoint> {
             498598646,
             Some("ML1900000__70230"),
         ),
+        // Block 2300000 (2025) - recent checkpoint
+        create_checkpoint(
+            2300000,
+            "00000000000000186f9f2fde843be3d66b8ae317cabb7d43dbde943d02a4b4d7",
+            "000000000000000d51caa0307836ca3eabe93068a9007515ac128a43d6addd4e",
+            1751767455,
+            0x1938df46,
+            "0x00000000000000000000000000000000000000000000aa3859b6456688a3fb53",
+            "b026649607d72d486480c0cef823dba6b28d0884a0d86f5a8b9e5a7919545cef",
+            972444458,
+            Some("ML2300000__70232"),  // Has masternode list with protocol version 70232
+        ),
     ]
 }
 

dash-spv/src/sync/masternodes.rs

@@ -127,7 +127,14 @@ impl MasternodeSyncManager {
         // Check if the terminal block exists in our chain
         match storage.get_header(terminal_height).await {
             Ok(Some(header)) => {
-                if header.block_hash() == expected_hash {
+                let actual_hash = header.block_hash();
+                tracing::info!(
+                    "Terminal block validation at height {}: expected hash {}, actual hash {}",
+                    terminal_height,
+                    expected_hash,
+                    actual_hash
+                );
+                if actual_hash == expected_hash {
                     if has_precalculated_data {
                         tracing::info!(
                             "Using terminal block at height {} with pre-calculated masternode data as base for sync",
@@ -184,34 +191,40 @@ impl MasternodeSyncManager {
             return Ok(0);
         }
 
-        // Convert blockchain height to storage height
-        let storage_height = terminal_height - sync_base_height;
+        // When syncing from checkpoint, storage uses absolute blockchain heights
+        // No need to convert - just use terminal_height directly
+        let storage_height = terminal_height;
 
         // Check if the terminal block exists in our chain
         match storage.get_header(storage_height).await {
             Ok(Some(header)) => {
-                if header.block_hash() == expected_hash {
+                let actual_hash = header.block_hash();
+                tracing::info!(
+                    "Terminal block validation at height {}: expected hash {}, actual hash {}",
+                    terminal_height,
+                    expected_hash,
+                    actual_hash
+                );
+                if actual_hash == expected_hash {
                     if has_precalculated_data {
                         tracing::info!(
-                            "Using terminal block at blockchain height {} (storage height {}) with pre-calculated masternode data as base for sync",
-                            terminal_height,
-                            storage_height
+                            "Using terminal block at height {} with pre-calculated masternode data as base for sync",
+                            terminal_height
                         );
                     } else {
                         tracing::info!(
-                            "Using terminal block at blockchain height {} (storage height {}) as base for masternode sync (no pre-calculated data)",
-                            terminal_height,
-                            storage_height
+                            "Using terminal block at height {} as base for masternode sync (no pre-calculated data)",
+                            terminal_height
                         );
                     }
                     Ok(terminal_height)
                 } else {
                     let msg = if has_precalculated_data {
-                        "Terminal block hash mismatch at blockchain height {} (storage height {}) (with pre-calculated data) - falling back to genesis"
+                        "Terminal block hash mismatch at height {} (with pre-calculated data) - falling back to genesis"
                     } else {
-                        "Terminal block hash mismatch at blockchain height {} (storage height {}) (without pre-calculated data) - falling back to genesis"
+                        "Terminal block hash mismatch at height {} (without pre-calculated data) - falling back to genesis"
                     };
-                    tracing::warn!(msg, terminal_height, storage_height);
+                    tracing::warn!(msg, terminal_height);
                     Ok(0)
                 }
             }
@@ -1053,21 +1066,10 @@ impl MasternodeSyncManager {
         current_height: u32,
         sync_base_height: u32,
     ) -> SyncResult<()> {
-        // Convert blockchain heights to storage heights
-        let storage_base_height = if base_height >= sync_base_height {
-            base_height - sync_base_height
-        } else {
-            0
-        };
-
-        let storage_current_height = if current_height >= sync_base_height {
-            current_height - sync_base_height
-        } else {
-            return Err(SyncError::InvalidState(format!(
-                "Current height {} is less than sync base height {}",
-                current_height, sync_base_height
-            )));
-        };
+        // When syncing from checkpoint, storage uses absolute blockchain heights
+        // No need to convert
+        let storage_base_height = base_height;
+        let storage_current_height = current_height;
 
         // Verify the storage height actually exists
         let storage_tip = storage
@@ -1086,7 +1088,7 @@ impl MasternodeSyncManager {
 
             // Use the storage tip as the current height
             let adjusted_storage_height = storage_tip;
-            let adjusted_blockchain_height = storage_tip + sync_base_height;
+            let adjusted_blockchain_height = storage_tip; // Storage already uses blockchain heights
 
             // Update the heights to use what's actually available
             // Don't recurse - just continue with adjusted values
@@ -1402,8 +1404,8 @@ impl MasternodeSyncManager {
                 .await
                 .map_err(|e| SyncError::Storage(format!("Failed to lookup target hash: {}", e)))?
             {
-                // Convert storage height to blockchain height
-                let blockchain_target_height = storage_target_height + self.sync_base_height;
+                // Storage already uses blockchain heights when syncing from checkpoint
+                let blockchain_target_height = storage_target_height;
                 engine.feed_block_height(blockchain_target_height, target_block_hash);
                 tracing::debug!(
                     "Fed target block hash {} at blockchain height {} (storage height {})",
@@ -1437,8 +1439,8 @@ impl MasternodeSyncManager {
                     .await
                     .map_err(|e| SyncError::Storage(format!("Failed to lookup base hash: {}", e)))?
                 {
-                    // Convert storage height to blockchain height
-                    let blockchain_base_height = storage_base_height + self.sync_base_height;
+                    // Storage already uses blockchain heights when syncing from checkpoint
+                    let blockchain_base_height = storage_base_height;
                     engine.feed_block_height(blockchain_base_height, base_block_hash);
                     tracing::debug!(
                         "Fed base block hash {} at blockchain height {} (storage height {})",
@@ -1479,9 +1481,8 @@ impl MasternodeSyncManager {
                 {
                     // Only feed blocks at or after start_height to avoid redundant submissions
                     if storage_quorum_height >= storage_start_height {
-                        // Convert storage height to blockchain height
-                        let blockchain_quorum_height =
-                            storage_quorum_height + self.sync_base_height;
+                        // Storage already uses blockchain heights when syncing from checkpoint
+                        let blockchain_quorum_height = storage_quorum_height;
 
                         // Check if this block hash is already known to avoid duplicate feeds
                         if !engine.block_container.contains_hash(&quorum.quorum_hash) {
@@ -1525,8 +1526,8 @@ impl MasternodeSyncManager {
                     )?;
 
                 for (storage_height, header) in headers {
-                    // Convert storage height to blockchain height
-                    let blockchain_height = storage_height + self.sync_base_height;
+                    // Storage already uses blockchain heights when syncing from checkpoint
+                    let blockchain_height = storage_height;
                     let block_hash = header.block_hash();
 
                     // Only feed if not already known

dash-spv/src/sync/sequential/mod.rs

@@ -406,10 +406,17 @@ impl SequentialSyncManager {
             }
 
             SyncPhase::DownloadingCFHeaders {
+                current_height,
+                target_height,
                 ..
             } => {
-                tracing::info!("📥 Starting filter header download phase");
-
+                tracing::info!("📥 Starting filter headers download phase");
+                tracing::info!(
+                    "🔍 [DEBUG] Filter headers phase: current={}, target={}",
+                    current_height,
+                    target_height
+                );
+                
                 // Get sync base height from header sync
                 let sync_base_height = self.header_sync.get_sync_base_height();
                 if sync_base_height > 0 {
@@ -419,23 +426,57 @@ impl SequentialSyncManager {
                     );
                     self.filter_sync.set_sync_base_height(sync_base_height);
                 }
-
-                // Check if filter sync actually started
-                let sync_started = self.filter_sync.start_sync_headers(network, storage).await?;
-
-                if !sync_started {
-                    // No peers support compact filters or already up to date
-                    tracing::info!("Filter header sync not started (no peers support filters or already synced)");
-                    // Transition to next phase immediately
-                    self.transition_to_next_phase(storage, "Filter sync skipped - no peer support")
-                        .await?;
-                    // Return true to indicate we transitioned and can continue execution
+                
+                // Check if we need to request filter headers
+                if current_height < target_height {
+                    // For checkpoint sync, we need to convert target height to storage height
+                    let sync_base_height = self.header_sync.get_sync_base_height();
+                    let storage_height = if sync_base_height > 0 && *target_height > sync_base_height {
+                        target_height - sync_base_height
+                    } else {
+                        *target_height
+                    };
+                    
+                    tracing::info!(
+                        "🔍 [DEBUG] Getting header at storage height {} (blockchain height {})",
+                        storage_height,
+                        target_height
+                    );
+                    
+                    // Get the stop hash for the target height
+                    let stop_hash = if let Some(header) = storage.get_header(storage_height).await
+                        .map_err(|e| SyncError::Storage(format!("Failed to get header at {}: {}", storage_height, e)))? {
+                        header.block_hash()
+                    } else {
+                        tracing::error!("No header found at storage height {} (blockchain height {})", storage_height, target_height);
+                        self.transition_to_next_phase(storage, "No header at target height").await?;
+                        return Ok(true);
+                    };
+                    
+                    // Request filter headers
+                    let start_height = current_height + 1;
+                    self.filter_sync.request_filter_headers(
+                        network,
+                        start_height,
+                        stop_hash,
+                    ).await?;
+                    
+                    tracing::info!(
+                        "📡 Requested filter headers from {} to {} (stop hash: {})",
+                        start_height,
+                        target_height,
+                        stop_hash
+                    );
+                } else {
+                    tracing::info!("Filter headers already synced, transitioning to next phase");
+                    self.transition_to_next_phase(storage, "Filter headers already synced").await?;
                     return Ok(true);
                 }
+                
                 // Return false to indicate we need to wait for messages
                 return Ok(false);
             }
-
+            
             SyncPhase::DownloadingFilters {
                 ..
             } => {
@@ -1046,59 +1087,28 @@ impl SequentialSyncManager {
 
             let previous_phase = std::mem::discriminant(&self.current_phase);
 
-            // Execute the current phase with special handling
-            match &self.current_phase {
-                SyncPhase::DownloadingMnList {
-                    ..
-                } => {
-                    // Special handling for masternode sync that might already be complete
-                    let sync_result = self.execute_current_phase_internal(network, storage).await?;
-                    if !sync_result {
-                        // Phase indicated it needs to wait for messages
-                        break;
-                    }
-                }
-                _ => {
-                    // Normal execution
-                    self.execute_current_phase_internal(network, storage).await?;
-                }
+            // Execute the current phase
+            let continue_execution = self.execute_current_phase_internal(network, storage).await?;
+            
+            if !continue_execution {
+                // Phase indicated it needs to wait for messages
+                tracing::info!("🔍 [DEBUG] Phase {} needs to wait for messages, breaking execute loop", 
+                    self.current_phase.name());
+                break;
             }
 
             let current_phase_discriminant = std::mem::discriminant(&self.current_phase);
 
             // If we didn't transition to a new phase, we're done
             if previous_phase == current_phase_discriminant {
+                tracing::info!("🔍 [DEBUG] Phase didn't change, breaking execute loop");
                 break;
             }
-
-            // If we reached a phase that needs network messages or is complete, stop
-            match &self.current_phase {
-                SyncPhase::DownloadingHeaders {
-                    ..
-                }
-                | SyncPhase::DownloadingMnList {
-                    ..
-                }
-                | SyncPhase::DownloadingCFHeaders {
-                    ..
-                }
-                | SyncPhase::DownloadingFilters {
-                    ..
-                }
-                | SyncPhase::DownloadingBlocks {
-                    ..
-                } => {
-                    // These phases need to wait for network messages
-                    break;
-                }
-                SyncPhase::FullySynced {
-                    ..
-                }
-                | SyncPhase::Idle => {
-                    // We're done
-                    break;
-                }
-            }
+            
+            tracing::info!("🔍 [DEBUG] Phase changed to {}, continuing execution loop", 
+                self.current_phase.name());
+            
+            // Continue looping to execute the new phase
         }
 
         Ok(())