perf(l1,l2): simple snapshot

crates/blockchain/blockchain.rs

@@ -7,7 +7,7 @@ mod smoke_test;
 pub mod tracing;
 pub mod vm;
 
-use ::tracing::info;
+use ::tracing::{error, info};
 use constants::MAX_INITCODE_SIZE;
 use error::MempoolError;
 use error::{ChainError, InvalidBlockError};
@@ -86,6 +86,7 @@ impl Blockchain {
         // Validate the block pre-execution
         validate_block(block, &parent_header, &chain_config, ELASTICITY_MULTIPLIER)?;
 
+        println!("{}", block.header.parent_hash);
         let vm_db = StoreVmDatabase::new(self.storage.clone(), block.header.parent_hash);
         let mut vm = Evm::new(self.evm_engine, vm_db);
         let execution_result = vm.execute_block(block)?;
@@ -127,7 +128,7 @@ impl Blockchain {
         account_updates: &[AccountUpdate],
     ) -> Result<(), ChainError> {
         // Apply the account updates over the last block's state and compute the new state root
-        let new_state_root = self
+        let (new_state_root, snapshot_updates) = self
             .storage
             .apply_account_updates(block.header.parent_hash, account_updates)
             .await?
@@ -143,7 +144,11 @@ impl Blockchain {
         self.storage
             .add_receipts(block.hash(), execution_result.receipts)
             .await
-            .map_err(ChainError::StoreError)
+            .map_err(ChainError::StoreError)?;
+        self.storage
+            .update_snapshot(snapshot_updates)
+            .map_err(ChainError::StoreError)?;
+        return Ok(());
     }
 
     pub async fn add_block(&self, block: &Block) -> Result<(), ChainError> {
@@ -160,6 +165,7 @@ impl Blockchain {
         let interval = stored.duration_since(since).as_millis() as f64;
         if interval != 0f64 {
             let as_gigas = block.header.gas_used as f64 / 10_f64.powf(9_f64);
+            info!("Gas used: {}", block.header.gas_used);
             let throughput = as_gigas / interval * 1000_f64;
             let execution_time = executed.duration_since(since).as_millis() as f64;
             let storage_time = stored.duration_since(executed).as_millis() as f64;
@@ -278,13 +284,12 @@ impl Blockchain {
         };
 
         // Apply the account updates over all blocks and compute the new state root
-        let new_state_root = self
+        let (new_state_root, snapshot_updates) = self
             .storage
             .apply_account_updates(first_block_header.parent_hash, &account_updates)
             .await
             .map_err(|e| (e.into(), None))?
             .ok_or((ChainError::ParentStateNotFound, None))?;
-
         // Check state root matches the one in block header
         validate_state_root(&last_block.header, new_state_root).map_err(|e| (e, None))?;
 
@@ -296,7 +301,9 @@ impl Blockchain {
             .add_receipts_for_blocks(all_receipts)
             .await
             .map_err(|e| (e.into(), None))?;
-
+        self.storage
+            .update_snapshot(snapshot_updates)
+            .map_err(|e| (e.into(), None))?;
         let elapsed_total = interval.elapsed().as_millis();
         let mut throughput = 0.0;
         if elapsed_total != 0 && total_gas_used != 0 {

crates/blockchain/payload.rs

@@ -536,11 +536,12 @@ impl Blockchain {
     ) -> Result<(), ChainError> {
         let account_updates = context.vm.get_state_transitions()?;
 
-        context.payload.header.state_root = context
+        let (root, _) = context
             .store
             .apply_account_updates(context.parent_hash(), &account_updates)
             .await?
             .unwrap_or_default();
+        context.payload.header.state_root = root;
         context.payload.header.transactions_root =
             compute_transactions_root(&context.payload.body.transactions);
         context.payload.header.receipts_root = compute_receipts_root(&context.receipts);

crates/blockchain/vm.rs

@@ -47,9 +47,11 @@ impl VmDatabase for StoreVmDatabase {
     }
 
     fn get_storage_slot(&self, address: Address, key: H256) -> Result<Option<U256>, EvmError> {
-        self.store
+        let value = self
+            .store
             .get_storage_at_hash(self.block_hash, address, key)
-            .map_err(|e| EvmError::DB(e.to_string()))
+            .map_err(|e| EvmError::DB(e.to_string()));
+        return value;
     }
 
     fn get_block_hash(&self, block_number: u64) -> Result<H256, EvmError> {

crates/storage/Cargo.toml

@@ -25,6 +25,7 @@ redb = { workspace = true, optional = true }
 # NOTE: intentionally avoiding the workspace dep as it brings "full" features, breaking the provers
 # We only need the runtime for the blocking databases to spawn blocking tasks
 tokio = { version = "1.41.1", optional = true, default-features = false, features = ["rt"] }
+quick_cache = "0.6.14"
 
 [features]
 default = []

crates/storage/api.rs

@@ -1,12 +1,17 @@
 use bytes::Bytes;
 use ethereum_types::{H256, U256};
 use ethrex_common::types::{
-    payload::PayloadBundle, AccountState, Block, BlockBody, BlockHash, BlockHeader, BlockNumber,
-    ChainConfig, Index, Receipt, Transaction,
+    payload::PayloadBundle, AccountInfo, AccountState, AccountUpdate, Block, BlockBody, BlockHash,
+    BlockHeader, BlockNumber, ChainConfig, Index, Receipt, Transaction,
 };
 use std::{collections::HashMap, fmt::Debug, panic::RefUnwindSafe};
 
-use crate::{error::StoreError, store::STATE_TRIE_SEGMENTS};
+use crate::{
+    error::StoreError,
+    rlp::Rlp,
+    store::{SnapshotUpdate, STATE_TRIE_SEGMENTS},
+    store_db::libmdbx::{AccountStorageKeyBytes, AccountStorageValueBytes},
+};
 use ethrex_trie::{Nibbles, Trie};
 
 // We need async_trait because the stabilized feature lacks support for object safety
@@ -417,4 +422,23 @@ pub trait StoreEngine: Debug + Send + Sync + RefUnwindSafe {
         &self,
         block_number: BlockNumber,
     ) -> Result<Option<BlockHash>, StoreError>;
+
+    fn write_block_snapshot(
+        &self,
+        storages_to_update: Vec<(Rlp<H256>, AccountStorageKeyBytes, AccountStorageValueBytes)>,
+        storages_to_remove: Vec<Rlp<H256>>,
+        states_to_remove: Vec<Rlp<H256>>,
+        states_to_update: Vec<(Rlp<H256>, Rlp<AccountState>)>,
+    ) -> Result<(), StoreError>;
+
+    fn state_snapshot_for_account(
+        &self,
+        hashed_address: &H256,
+    ) -> Result<Option<AccountState>, StoreError>;
+
+    fn storage_snapshot_for_hash(
+        &self,
+        account_hash: &H256,
+        hashed_key: &H256,
+    ) -> Result<Option<U256>, StoreError>;
 }

crates/storage/lib.rs

@@ -2,7 +2,7 @@ mod api;
 
 #[cfg(any(feature = "libmdbx", feature = "redb"))]
 mod rlp;
-mod store;
+pub mod store;
 mod store_db;
 mod trie_db;
 mod utils;

crates/storage/rlp.rs

@@ -43,7 +43,7 @@ pub type PayloadBundleRLP = Rlp<PayloadBundle>;
 // Wrapper for tuples. Used mostly for indexed keys.
 pub type TupleRLP<A, B> = Rlp<(A, B)>;
 
-#[derive(Clone, Debug)]
+#[derive(Eq, PartialEq, Hash, Clone, Debug)]
 pub struct Rlp<T>(Vec<u8>, PhantomData<T>);
 
 impl<T: RLPEncode> From<T> for Rlp<T> {

crates/storage/snapshot/cache.rs

@@ -0,0 +1,24 @@
+//! An in memory cache.
+
+use std::sync::Arc;
+
+use ethrex_common::{types::AccountState, H256, U256};
+use quick_cache::sync::Cache;
+
+/// In-memory cache.
+///
+/// Can be cloned freely.
+#[derive(Debug, Clone)]
+pub struct DiskCache {
+    pub accounts: Arc<Cache<H256, Option<AccountState>>>,
+    pub storages: Arc<Cache<(H256, H256), Option<U256>>>,
+}
+
+impl DiskCache {
+    pub fn new(max_capacity_accounts: usize, max_capacity_storage: usize) -> Self {
+        Self {
+            accounts: Arc::new(Cache::new(max_capacity_accounts)),
+            storages: Arc::new(Cache::new(max_capacity_storage)),
+        }
+    }
+}

crates/storage/snapshot/mod.rs

@@ -0,0 +1,2 @@
+pub mod cache;
+pub mod disklayer;