sync from genesis working kind of

Author: pauldelucia

dash-spv/src/chain/chainlock_manager.rs

@@ -6,7 +6,8 @@
 use dashcore::{BlockHash, ChainLock};
 use dashcore::sml::masternode_list_engine::MasternodeListEngine;
 use indexmap::IndexMap;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use tracing::{debug, error, info, warn};
 
 use crate::error::{StorageError, StorageResult, ValidationError, ValidationResult};
@@ -57,22 +58,15 @@ impl ChainLockManager {
     }
 
     /// Set the masternode engine for validation
-    pub fn set_masternode_engine(&self, engine: Arc<MasternodeListEngine>) {
-        match self.masternode_engine.write() {
-            Ok(mut guard) => {
-                *guard = Some(engine);
-                info!("Masternode engine set for ChainLock validation");
-            }
-            Err(e) => {
-                error!("Failed to set masternode engine: {}", e);
-            }
-        }
+    pub async fn set_masternode_engine(&self, engine: Arc<MasternodeListEngine>) {
+        let mut guard = self.masternode_engine.write().await;
+        *guard = Some(engine);
+        info!("Masternode engine set for ChainLock validation");
     }
 
     /// Queue a ChainLock for validation when masternode data is available
-    pub fn queue_pending_chainlock(&self, chain_lock: ChainLock) -> StorageResult<()> {
-        let mut pending = self.pending_chainlocks.write()
-            .map_err(|_| StorageError::LockPoisoned("pending_chainlocks".to_string()))?;
+    pub async fn queue_pending_chainlock(&self, chain_lock: ChainLock) -> StorageResult<()> {
+        let mut pending = self.pending_chainlocks.write().await;
 
         // If at capacity, drop the oldest ChainLock
         if pending.len() >= MAX_PENDING_CHAINLOCKS {
@@ -95,8 +89,7 @@ impl ChainLockManager {
         storage: &mut dyn StorageManager,
     ) -> ValidationResult<()> {
         let pending = {
-            let mut pending_guard = self.pending_chainlocks.write()
-                .map_err(|_| ValidationError::InvalidChainLock("Lock poisoned".to_string()))?;
+            let mut pending_guard = self.pending_chainlocks.write().await;
             std::mem::take(&mut *pending_guard)
         };
 
@@ -138,8 +131,8 @@ impl ChainLockManager {
         );
 
         // Check if we already have this chain lock
-        if self.has_chain_lock_at_height(chain_lock.block_height) {
-            let existing = self.get_chain_lock_by_height(chain_lock.block_height);
+        if self.has_chain_lock_at_height(chain_lock.block_height).await {
+            let existing = self.get_chain_lock_by_height(chain_lock.block_height).await;
             if let Some(existing_entry) = existing {
                 if existing_entry.chain_lock.block_hash != chain_lock.block_hash {
                     error!(
@@ -173,8 +166,7 @@ impl ChainLockManager {
         }
 
         // Full validation with masternode engine if available
-        let engine_guard = self.masternode_engine.read()
-            .map_err(|_| ValidationError::InvalidChainLock("Lock poisoned".to_string()))?;
+        let engine_guard = self.masternode_engine.read().await;
 
         let mut validated = false;
 
@@ -195,7 +187,7 @@ impl ChainLockManager {
                         warn!("⚠️ Masternode engine exists but lacks required masternode lists for height {} (needs list at height {} for ChainLock validation), queueing ChainLock for later validation", 
                             chain_lock.block_height, required_height);
                         drop(engine_guard); // Release the read lock before acquiring write lock
-                        self.queue_pending_chainlock(chain_lock.clone())
+                        self.queue_pending_chainlock(chain_lock.clone()).await
                             .map_err(|e| ValidationError::InvalidChainLock(
                                 format!("Failed to queue pending ChainLock: {}", e)
                             ))?;
@@ -210,7 +202,7 @@ impl ChainLockManager {
             // Queue for later validation when engine becomes available
             warn!("⚠️ Masternode engine not available, queueing ChainLock for later validation");
             drop(engine_guard); // Release the read lock before acquiring write lock
-            self.queue_pending_chainlock(chain_lock.clone())
+            self.queue_pending_chainlock(chain_lock.clone()).await
                 .map_err(|e| ValidationError::InvalidChainLock(
                     format!("Failed to queue pending ChainLock: {}", e)
                 ))?;
@@ -266,10 +258,8 @@ impl ChainLockManager {
 
         // Store in memory caches
         {
-            let mut by_height = self.chain_locks_by_height.write()
-                .map_err(|_| StorageError::LockPoisoned("chain_locks_by_height".to_string()))?;
-            let mut by_hash = self.chain_locks_by_hash.write()
-                .map_err(|_| StorageError::LockPoisoned("chain_locks_by_hash".to_string()))?;
+            let mut by_height = self.chain_locks_by_height.write().await;
+            let mut by_hash = self.chain_locks_by_hash.write().await;
 
             by_height.insert(chain_lock.block_height, entry.clone());
             by_hash.insert(chain_lock.block_hash, entry.clone());
@@ -304,58 +294,51 @@ impl ChainLockManager {
     }
 
     /// Check if we have a chain lock at the given height
-    pub fn has_chain_lock_at_height(&self, height: u32) -> bool {
-        self.chain_locks_by_height.read()
-            .map(|locks| locks.contains_key(&height))
-            .unwrap_or(false)
+    pub async fn has_chain_lock_at_height(&self, height: u32) -> bool {
+        let locks = self.chain_locks_by_height.read().await;
+        locks.contains_key(&height)
     }
 
     /// Get chain lock by height
-    pub fn get_chain_lock_by_height(&self, height: u32) -> Option<ChainLockEntry> {
-        self.chain_locks_by_height.read()
-            .ok()
-            .and_then(|locks| locks.get(&height).cloned())
+    pub async fn get_chain_lock_by_height(&self, height: u32) -> Option<ChainLockEntry> {
+        let locks = self.chain_locks_by_height.read().await;
+        locks.get(&height).cloned()
     }
 
     /// Get chain lock by block hash
-    pub fn get_chain_lock_by_hash(&self, hash: &BlockHash) -> Option<ChainLockEntry> {
-        self.chain_locks_by_hash.read()
-            .ok()
-            .and_then(|locks| locks.get(hash).cloned())
+    pub async fn get_chain_lock_by_hash(&self, hash: &BlockHash) -> Option<ChainLockEntry> {
+        let locks = self.chain_locks_by_hash.read().await;
+        locks.get(hash).cloned()
     }
 
     /// Check if a block is chain-locked
-    pub fn is_block_chain_locked(&self, block_hash: &BlockHash, height: u32) -> bool {
+    pub async fn is_block_chain_locked(&self, block_hash: &BlockHash, height: u32) -> bool {
         // First check by hash (most specific)
-        if let Some(entry) = self.get_chain_lock_by_hash(block_hash) {
+        if let Some(entry) = self.get_chain_lock_by_hash(block_hash).await {
             return entry.validated && entry.chain_lock.block_hash == *block_hash;
         }
 
         // Then check by height
-        if let Some(entry) = self.get_chain_lock_by_height(height) {
+        if let Some(entry) = self.get_chain_lock_by_height(height).await {
             return entry.validated && entry.chain_lock.block_hash == *block_hash;
         }
 
         false
     }
 
     /// Get the highest chain-locked block height
-    pub fn get_highest_chain_locked_height(&self) -> Option<u32> {
-        self.chain_locks_by_height.read()
-            .ok()
-            .and_then(|locks| locks.keys().max().cloned())
+    pub async fn get_highest_chain_locked_height(&self) -> Option<u32> {
+        let locks = self.chain_locks_by_height.read().await;
+        locks.keys().max().cloned()
     }
 
     /// Check if a reorganization would violate chain locks
-    pub fn would_violate_chain_lock(&self, reorg_from_height: u32, reorg_to_height: u32) -> bool {
+    pub async fn would_violate_chain_lock(&self, reorg_from_height: u32, reorg_to_height: u32) -> bool {
         if !self.enforce_chain_locks {
             return false;
         }
 
-        let locks = match self.chain_locks_by_height.read() {
-            Ok(locks) => locks,
-            Err(_) => return false, // If we can't read locks, assume no violation
-        };
+        let locks = self.chain_locks_by_height.read().await;
 
         // Check if any chain-locked block would be reorganized
         for height in reorg_from_height..=reorg_to_height {
@@ -395,10 +378,8 @@ impl ChainLockManager {
                             validated: true,
                         };
 
-                        let mut by_height = self.chain_locks_by_height.write()
-                            .map_err(|_| StorageError::LockPoisoned("chain_locks_by_height".to_string()))?;
-                        let mut by_hash = self.chain_locks_by_hash.write()
-                            .map_err(|_| StorageError::LockPoisoned("chain_locks_by_hash".to_string()))?;
+                        let mut by_height = self.chain_locks_by_height.write().await;
+                        let mut by_hash = self.chain_locks_by_hash.write().await;
 
                         by_height.insert(chain_lock.block_height, entry.clone());
                         by_hash.insert(chain_lock.block_hash, entry);
@@ -417,29 +398,9 @@ impl ChainLockManager {
 
 
     /// Get chain lock statistics
-    pub fn get_stats(&self) -> ChainLockStats {
-        let by_height = match self.chain_locks_by_height.read() {
-            Ok(guard) => guard,
-            Err(_) => return ChainLockStats {
-                total_chain_locks: 0,
-                cached_by_height: 0,
-                cached_by_hash: 0,
-                highest_locked_height: None,
-                lowest_locked_height: None,
-                enforce_chain_locks: self.enforce_chain_locks,
-            },
-        };
-        let by_hash = match self.chain_locks_by_hash.read() {
-            Ok(guard) => guard,
-            Err(_) => return ChainLockStats {
-                total_chain_locks: 0,
-                cached_by_height: 0,
-                cached_by_hash: 0,
-                highest_locked_height: None,
-                lowest_locked_height: None,
-                enforce_chain_locks: self.enforce_chain_locks,
-            },
-        };
+    pub async fn get_stats(&self) -> ChainLockStats {
+        let by_height = self.chain_locks_by_height.read().await;
+        let by_hash = self.chain_locks_by_hash.read().await;
 
         ChainLockStats {
             total_chain_locks: by_height.len(),

dash-spv/src/chain/chainlock_test.rs

@@ -29,10 +29,10 @@ mod tests {
         assert!(result.is_ok(), "ChainLock processing should succeed");
 
         // Verify it was stored
-        assert!(chainlock_manager.has_chain_lock_at_height(1000));
+        assert!(chainlock_manager.has_chain_lock_at_height(1000).await);
 
         // Verify we can retrieve it
-        let entry = chainlock_manager.get_chain_lock_by_height(1000)
+        let entry = chainlock_manager.get_chain_lock_by_height(1000).await
             .expect("ChainLock should be retrievable after storing");
         assert_eq!(entry.chain_lock.block_height, 1000);
         assert_eq!(entry.chain_lock.block_hash, chainlock.block_hash);
@@ -67,11 +67,11 @@ mod tests {
             .expect("Second ChainLock should process successfully");
 
         // Verify both are stored
-        assert!(chainlock_manager.has_chain_lock_at_height(1000));
-        assert!(chainlock_manager.has_chain_lock_at_height(2000));
+        assert!(chainlock_manager.has_chain_lock_at_height(1000).await);
+        assert!(chainlock_manager.has_chain_lock_at_height(2000).await);
 
         // Get highest ChainLock
-        let highest = chainlock_manager.get_highest_chain_locked_height();
+        let highest = chainlock_manager.get_highest_chain_locked_height().await;
         assert_eq!(highest, Some(2000));
     }
 
@@ -97,8 +97,8 @@ mod tests {
         }
 
         // Test reorganization protection
-        assert!(!chainlock_manager.would_violate_chain_lock(500, 999)); // Before ChainLocks - OK
-        assert!(chainlock_manager.would_violate_chain_lock(1500, 2500)); // Would reorg ChainLock at 2000
-        assert!(!chainlock_manager.would_violate_chain_lock(3001, 4000)); // After ChainLocks - OK
+        assert!(!chainlock_manager.would_violate_chain_lock(500, 999).await); // Before ChainLocks - OK
+        assert!(chainlock_manager.would_violate_chain_lock(1500, 2500).await); // Would reorg ChainLock at 2000
+        assert!(!chainlock_manager.would_violate_chain_lock(3001, 4000).await); // After ChainLocks - OK
     }
 }

dash-spv/src/chain/checkpoints.rs

@@ -36,6 +36,8 @@ pub struct Checkpoint {
     pub protocol_version: Option<u32>,
     /// Nonce value for the block
     pub nonce: u32,
+    /// Block version
+    pub version: u32,
 }
 
 impl Checkpoint {
@@ -433,6 +435,17 @@ fn create_checkpoint(
     nonce: u32,
     masternode_list: Option<&str>,
 ) -> Checkpoint {
+    // Determine version based on height
+    let version = if height == 0 {
+        1 // Genesis block version
+    } else if height < 750000 {
+        2 // Pre-v0.12 blocks
+    } else if height < 1700000 {
+        536870912 // v0.12+ blocks (0x20000000)
+    } else {
+        536870912 // v0.14+ blocks (0x20000000)
+    };
+    
     Checkpoint {
         height,
         block_hash: parse_block_hash_safe(hash),
@@ -448,6 +461,7 @@ fn create_checkpoint(
             ml.split("__").nth(1).and_then(|s| s.parse().ok())
         }),
         nonce,
+        version,
     }
 }
 

dash-spv/src/chain/reorg.rs

@@ -79,18 +79,18 @@ impl ReorgManager {
     }
 
     /// Check if a fork has more work than the current chain and should trigger a reorg
-    pub fn should_reorganize(
+    pub async fn should_reorganize(
         &self,
         current_tip: &ChainTip,
         fork: &Fork,
         storage: &dyn ChainStorage,
     ) -> Result<bool, String> {
-        self.should_reorganize_with_chain_state(current_tip, fork, storage, None)
+        self.should_reorganize_with_chain_state(current_tip, fork, storage, None).await
     }
 
     /// Check if a fork has more work than the current chain and should trigger a reorg
     /// This version is checkpoint-aware when chain_state is provided
-    pub fn should_reorganize_with_chain_state(
+    pub async fn should_reorganize_with_chain_state(
         &self,
         current_tip: &ChainTip,
         fork: &Fork,
@@ -153,7 +153,7 @@ impl ReorgManager {
         if self.respect_chain_locks {
             if let Some(ref chain_lock_mgr) = self.chain_lock_manager {
                 // Check if reorg would violate chain locks
-                if chain_lock_mgr.would_violate_chain_lock(fork.fork_height, current_tip.height) {
+                if chain_lock_mgr.would_violate_chain_lock(fork.fork_height, current_tip.height).await {
                     return Err(format!(
                         "Cannot reorg: would violate chain lock between heights {} and {}",
                         fork.fork_height, current_tip.height
@@ -163,7 +163,7 @@ impl ReorgManager {
                 // Fall back to checking individual blocks
                 for height in (fork.fork_height + 1)..=current_tip.height {
                     if let Ok(Some(header)) = storage.get_header_by_height(height) {
-                        if self.is_chain_locked(&header, storage)? {
+                        if self.is_chain_locked(&header, storage).await? {
                             return Err(format!(
                                 "Cannot reorg past chain-locked block at height {}",
                                 height
@@ -478,15 +478,15 @@ impl ReorgManager {
     }
 
     /// Check if a block is chain-locked
-    fn is_chain_locked(
+    async fn is_chain_locked(
         &self,
         header: &BlockHeader,
         storage: &dyn ChainStorage,
     ) -> Result<bool, String> {
         if let Some(ref chain_lock_mgr) = self.chain_lock_manager {
             // Get the height of this header
             if let Ok(Some(height)) = storage.get_header_height(&header.block_hash()) {
-                return Ok(chain_lock_mgr.is_block_chain_locked(&header.block_hash(), height));
+                return Ok(chain_lock_mgr.is_block_chain_locked(&header.block_hash(), height).await);
             }
         }
         // If no chain lock manager or height not found, assume not locked

dash-spv/src/client/mod.rs

@@ -818,7 +818,18 @@ impl DashSpvClient {
 
             // Check if we have connected peers and start initial sync operations (once)
             if !initial_sync_started && self.network.peer_count() > 0 {
-                tracing::info!("🚀 Peers connected, starting initial sync operations...");
+                tracing::info!("🚀 Peers connected (count: {}), starting initial sync operations...", self.network.peer_count());
+                
+                // Log peer info
+                let peer_info = self.network.peer_info();
+                for (i, peer) in peer_info.iter().enumerate() {
+                    tracing::info!("  Peer {}: {} (version: {}, height: {:?})", 
+                        i + 1, 
+                        peer.address, 
+                        peer.version.unwrap_or(0),
+                        peer.best_height
+                    );
+                }
 
                 // Start initial sync with sequential sync manager
                 match self.sync_manager.start_sync(&mut *self.network, &mut *self.storage).await {
@@ -1050,7 +1061,7 @@ impl DashSpvClient {
             // Check if masternode sync has completed and update ChainLock validation
             if !masternode_engine_updated && self.config.enable_masternodes {
                 // Check if we have a masternode engine available now
-                if let Ok(has_engine) = self.update_chainlock_validation() {
+                if let Ok(has_engine) = self.update_chainlock_validation().await {
                     if has_engine {
                         masternode_engine_updated = true;
                         info!("✅ Masternode sync complete - ChainLock validation enabled");
@@ -1682,12 +1693,12 @@ impl DashSpvClient {
     /// Update ChainLock validation with masternode engine after sync completes.
     /// This should be called when masternode sync finishes to enable full validation.
     /// Returns true if the engine was successfully set.
-    pub fn update_chainlock_validation(&self) -> Result<bool> {
+    pub async fn update_chainlock_validation(&self) -> Result<bool> {
         // Check if masternode sync has an engine available
         if let Some(engine) = self.sync_manager.get_masternode_engine() {
             // Clone the engine for the ChainLockManager
             let engine_arc = Arc::new(engine.clone());
-            self.chainlock_manager.set_masternode_engine(engine_arc);
+            self.chainlock_manager.set_masternode_engine(engine_arc).await;
 
             info!("Updated ChainLockManager with masternode engine for full validation");