Merge branch 'main' of github.com:decipherhub/cipherbft into feat/weighted-proposer

Author: qj0r9j0vc2

crates/execution/src/database.rs

@@ -100,6 +100,25 @@ pub trait Provider: Send + Sync {
     /// # Returns
     /// A BTreeMap of all storage slots (slot -> value) for the account.
     fn get_all_storage(&self, address: Address) -> Result<BTreeMap<U256, U256>>;
+
+    /// Get the current block number (last executed block).
+    ///
+    /// This method retrieves the persisted block number for execution engine recovery.
+    /// Returns `None` if no block has been executed yet (first startup).
+    ///
+    /// # Returns
+    /// * `Ok(Some(block_number))` - The last executed block number
+    /// * `Ok(None)` - No block has been executed yet
+    fn get_current_block(&self) -> Result<Option<u64>>;
+
+    /// Set the current block number (last executed block).
+    ///
+    /// This method persists the block number after each block execution to enable
+    /// proper recovery after node restart.
+    ///
+    /// # Arguments
+    /// * `block_number` - The block number to persist
+    fn set_current_block(&self, block_number: u64) -> Result<()>;
 }
 
 /// In-memory provider for testing and development.
@@ -112,6 +131,8 @@ pub struct InMemoryProvider {
     code: Arc<DashMap<B256, Bytecode>>,
     storage: Arc<DashMap<(Address, U256), U256>>,
     block_hashes: Arc<DashMap<u64, B256>>,
+    /// Current block number (last executed block). Uses RwLock for atomic u64 access.
+    current_block: Arc<RwLock<Option<u64>>>,
 }
 
 impl InMemoryProvider {
@@ -122,6 +143,7 @@ impl InMemoryProvider {
             code: Arc::new(DashMap::new()),
             storage: Arc::new(DashMap::new()),
             block_hashes: Arc::new(DashMap::new()),
+            current_block: Arc::new(RwLock::new(None)),
         }
     }
 
@@ -204,6 +226,15 @@ impl Provider for InMemoryProvider {
         }
         Ok(result)
     }
+
+    fn get_current_block(&self) -> Result<Option<u64>> {
+        Ok(*self.current_block.read())
+    }
+
+    fn set_current_block(&self, block_number: u64) -> Result<()> {
+        *self.current_block.write() = Some(block_number);
+        Ok(())
+    }
 }
 
 /// Blanket implementation of Provider for Arc<P> where P: Provider.
@@ -254,6 +285,14 @@ impl<P: Provider> Provider for Arc<P> {
     fn get_all_storage(&self, address: Address) -> Result<BTreeMap<U256, U256>> {
         (**self).get_all_storage(address)
     }
+
+    fn get_current_block(&self) -> Result<Option<u64>> {
+        (**self).get_current_block()
+    }
+
+    fn set_current_block(&self, block_number: u64) -> Result<()> {
+        (**self).set_current_block(block_number)
+    }
 }
 
 /// CipherBFT database implementation that implements revm's Database trait.
@@ -779,6 +818,22 @@ mod tests {
         // Verify cache contains the entry
         assert!(db.cache_accounts.write().contains(&addr));
     }
+
+    #[test]
+    fn test_in_memory_provider_current_block() {
+        let provider = InMemoryProvider::new();
+
+        // Initially no current block
+        assert!(provider.get_current_block().unwrap().is_none());
+
+        // Set current block
+        provider.set_current_block(100).unwrap();
+        assert_eq!(provider.get_current_block().unwrap(), Some(100));
+
+        // Update current block
+        provider.set_current_block(200).unwrap();
+        assert_eq!(provider.get_current_block().unwrap(), Some(200));
+    }
 }
 
 // =============================================================================
@@ -798,6 +853,7 @@ pub mod mdbx_provider {
     ///
     /// This provider wraps `MdbxEvmStore` from the storage layer and implements
     /// the `Provider` trait to integrate with the execution layer.
+    #[derive(Clone)]
     pub struct MdbxProvider {
         store: MdbxEvmStore,
     }
@@ -923,6 +979,18 @@ pub mod mdbx_provider {
                 })
                 .map_err(|e| DatabaseError::mdbx(e.to_string()).into())
         }
+
+        fn get_current_block(&self) -> Result<Option<u64>> {
+            self.store
+                .get_current_block()
+                .map_err(|e| DatabaseError::mdbx(e.to_string()).into())
+        }
+
+        fn set_current_block(&self, block_number: u64) -> Result<()> {
+            self.store
+                .set_current_block(block_number)
+                .map_err(|e| DatabaseError::mdbx(e.to_string()).into())
+        }
     }
 
     #[cfg(test)]

crates/execution/src/engine.rs

@@ -166,6 +166,10 @@ impl<P: Provider + Clone> ExecutionEngine<P> {
     /// staking precompile with the validator set from the genesis file, ensuring
     /// the validator state is correctly populated on node startup.
     ///
+    /// The engine will attempt to restore `current_block` from persistent storage
+    /// to survive node restarts. If no persisted state exists (first startup),
+    /// it defaults to 0.
+    ///
     /// # Arguments
     /// * `chain_config` - Chain configuration parameters
     /// * `provider` - Storage provider (factory pattern)
@@ -185,6 +189,29 @@ impl<P: Provider + Clone> ExecutionEngine<P> {
             chain_config.base_fee_per_gas,
         );
 
+        // Restore current_block from persistent storage if available
+        // This is critical for correct block validation after node restart
+        let current_block = match provider.get_current_block() {
+            Ok(Some(block)) => {
+                tracing::info!(
+                    current_block = block,
+                    "Restored current block from persistent storage"
+                );
+                block
+            }
+            Ok(None) => {
+                tracing::info!("No persisted current block found, starting from 0");
+                0
+            }
+            Err(e) => {
+                tracing::warn!(
+                    error = %e,
+                    "Failed to read current block from storage, starting from 0"
+                );
+                0
+            }
+        };
+
         let database = CipherBftDatabase::new(provider.clone());
         let state_manager = StateManager::new(provider);
 
@@ -209,7 +236,7 @@ impl<P: Provider + Clone> ExecutionEngine<P> {
             evm_config,
             staking_precompile,
             block_hashes: RwLock::new(lru::LruCache::new(BLOCK_HASH_CACHE_SIZE)),
-            current_block: 0,
+            current_block,
         }
     }
 
@@ -505,9 +532,24 @@ impl<P: Provider + Clone> ExecutionLayer for ExecutionEngine<P> {
                 .unwrap_or(B256::ZERO)
         };
 
-        // Update current block number
+        // Update current block number and persist to storage
         self.current_block = input.block_number;
 
+        // Persist current_block to storage for recovery after restart
+        if let Err(e) = self
+            .database
+            .provider()
+            .set_current_block(input.block_number)
+        {
+            tracing::error!(
+                block_number = input.block_number,
+                error = %e,
+                "Failed to persist current block number"
+            );
+            // Continue execution - we don't want to fail the block for persistence errors
+            // The worst case is having to re-execute some blocks after restart
+        }
+
         tracing::info!(
             block_number = input.block_number,
             gas_used,

crates/execution/src/lib.rs

@@ -65,6 +65,8 @@ pub mod types;
 
 // Re-export main types for convenience
 pub use bridge::{BatchFetcher, ExecutionBridge};
+#[cfg(feature = "mdbx")]
+pub use database::MdbxProvider;
 pub use database::{Account, CipherBftDatabase, InMemoryProvider, Provider};
 pub use engine::{ExecutionEngine, ExecutionLayer as ExecutionLayerTrait};
 pub use error::{DatabaseError, ExecutionError, Result};

crates/node/Cargo.toml

@@ -16,7 +16,7 @@ cipherbft-types = { path = "../types" }
 cipherbft-crypto = { path = "../crypto" }
 cipherbft-data-chain = { path = "../data-chain" }
 cipherbft-storage = { path = "../storage", features = ["mdbx"] }
-cipherbft-execution = { path = "../execution" }
+cipherbft-execution = { path = "../execution", features = ["mdbx"] }
 cipherbft-consensus = { path = "../consensus", features = ["malachite"] }
 cipherbft-rpc = { path = "../rpc" }
 cipherbft-mempool = { path = "../mempool" }