refactor(l1,levm): simplify vm database trait.

crates/blockchain/Cargo.toml

@@ -12,6 +12,7 @@ ethrex-rlp.workspace = true
 ethrex-common.workspace = true
 ethrex-storage.workspace = true
 ethrex-vm.workspace = true
+ethrex-levm.workspace = true
 secp256k1.workspace = true
 
 thiserror.workspace = true

crates/blockchain/blockchain.rs

@@ -29,7 +29,7 @@ use ethrex_storage::{
     AccountUpdatesList, Store, UpdateBatch, error::StoreError, hash_address, hash_key,
 };
 use ethrex_vm::backends::levm::db::DatabaseLogger;
-use ethrex_vm::{BlockExecutionResult, DynVmDatabase, Evm, EvmError};
+use ethrex_vm::{BlockExecutionResult, Evm, EvmError};
 use mempool::Mempool;
 use payload::PayloadOrTask;
 use std::collections::{BTreeMap, HashMap};
@@ -216,8 +216,7 @@ impl Blockchain {
 
         for block in blocks {
             let parent_hash = block.header.parent_hash;
-            let vm_db: DynVmDatabase =
-                Box::new(StoreVmDatabase::new(self.storage.clone(), parent_hash));
+            let vm_db = StoreVmDatabase::new(self.storage.clone(), parent_hash);
             let logger = Arc::new(DatabaseLogger::new(Arc::new(Mutex::new(Box::new(vm_db)))));
             let mut vm = match self.options.r#type {
                 BlockchainType::L1 => Evm::new_from_db_for_l1(logger.clone()),
@@ -916,9 +915,11 @@ impl Blockchain {
     }
 
     pub fn new_evm(&self, vm_db: StoreVmDatabase) -> Result<Evm, EvmError> {
+        use std::sync::Arc;
+        let store = Arc::new(vm_db);
         let evm = match self.options.r#type {
-            BlockchainType::L1 => Evm::new_for_l1(vm_db),
-            BlockchainType::L2 => Evm::new_for_l2(vm_db)?,
+            BlockchainType::L1 => Evm::new_from_db_for_l1(store),
+            BlockchainType::L2 => Evm::new_from_db_for_l2(store),
         };
         Ok(evm)
     }

crates/blockchain/payload.rs

@@ -235,8 +235,8 @@ impl PayloadBuildContext {
 
         let vm_db = StoreVmDatabase::new(storage.clone(), payload.header.parent_hash);
         let vm = match blockchain_type {
-            BlockchainType::L1 => Evm::new_for_l1(vm_db),
-            BlockchainType::L2 => Evm::new_for_l2(vm_db)?,
+            BlockchainType::L1 => Evm::new_from_db_for_l1(Arc::new(vm_db)),
+            BlockchainType::L2 => Evm::new_from_db_for_l2(Arc::new(vm_db)),
         };
 
         Ok(PayloadBuildContext {

crates/blockchain/vm.rs

@@ -2,10 +2,11 @@ use bytes::Bytes;
 use ethrex_common::{
     Address, H256, U256,
     constants::EMPTY_KECCACK_HASH,
-    types::{AccountInfo, BlockHash, BlockNumber, ChainConfig},
+    types::{AccountState, BlockHash, BlockNumber, ChainConfig},
 };
+use ethrex_levm::db::Database as LevmDatabase;
+use ethrex_levm::errors::DatabaseError;
 use ethrex_storage::Store;
-use ethrex_vm::{EvmError, VmDatabase};
 use std::{cmp::Ordering, collections::HashMap};
 use tracing::instrument;
 
@@ -41,23 +42,25 @@ impl StoreVmDatabase {
     }
 }
 
-impl VmDatabase for StoreVmDatabase {
+impl LevmDatabase for StoreVmDatabase {
     #[instrument(level = "trace", name = "Account read", skip_all)]
-    fn get_account_info(&self, address: Address) -> Result<Option<AccountInfo>, EvmError> {
+    fn get_account_state(&self, address: Address) -> Result<AccountState, DatabaseError> {
         self.store
-            .get_account_info_by_hash(self.block_hash, address)
-            .map_err(|e| EvmError::DB(e.to_string()))
+            .get_account_state_by_hash(self.block_hash, address)
+            .map(|opt| opt.unwrap_or_default())
+            .map_err(|e| DatabaseError::Custom(e.to_string()))
     }
 
     #[instrument(level = "trace", name = "Storage read", skip_all)]
-    fn get_storage_slot(&self, address: Address, key: H256) -> Result<Option<U256>, EvmError> {
+    fn get_storage_value(&self, address: Address, key: H256) -> Result<U256, DatabaseError> {
         self.store
             .get_storage_at_hash(self.block_hash, address, key)
-            .map_err(|e| EvmError::DB(e.to_string()))
+            .map(|opt| opt.unwrap_or_default())
+            .map_err(|e| DatabaseError::Custom(e.to_string()))
     }
 
     #[instrument(level = "trace", name = "Block hash read", skip_all)]
-    fn get_block_hash(&self, block_number: u64) -> Result<H256, EvmError> {
+    fn get_block_hash(&self, block_number: u64) -> Result<H256, DatabaseError> {
         // Check if we have it cached
         if let Some(block_hash) = self.block_hash_cache.get(&block_number) {
             return Ok(*block_hash);
@@ -66,24 +69,25 @@ impl VmDatabase for StoreVmDatabase {
         if self
             .store
             .is_canonical_sync(self.block_hash)
-            .map_err(|err| EvmError::DB(err.to_string()))?
+            .map_err(|err| DatabaseError::Custom(err.to_string()))?
         {
             if let Some(hash) = self
                 .store
                 .get_canonical_block_hash_sync(block_number)
-                .map_err(|err| EvmError::DB(err.to_string()))?
+                .map_err(|err| DatabaseError::Custom(err.to_string()))?
             {
                 return Ok(hash);
             }
         // If our block is not canonical then we must look for the target in our block's ancestors
         } else {
             for ancestor_res in self.store.ancestors(self.block_hash) {
-                let (hash, ancestor) = ancestor_res.map_err(|e| EvmError::DB(e.to_string()))?;
+                let (hash, ancestor) =
+                    ancestor_res.map_err(|e| DatabaseError::Custom(e.to_string()))?;
                 match ancestor.number.cmp(&block_number) {
                     Ordering::Greater => continue,
                     Ordering::Equal => return Ok(hash),
                     Ordering::Less => {
-                        return Err(EvmError::DB(format!(
+                        return Err(DatabaseError::Custom(format!(
                             "Block number requested {block_number} is higher than the current block number {}",
                             ancestor.number
                         )));
@@ -92,28 +96,28 @@ impl VmDatabase for StoreVmDatabase {
             }
         }
         // Block not found
-        Err(EvmError::DB(format!(
+        Err(DatabaseError::Custom(format!(
             "Block hash not found for block number {block_number}"
         )))
     }
 
-    fn get_chain_config(&self) -> Result<ChainConfig, EvmError> {
+    fn get_chain_config(&self) -> Result<ChainConfig, DatabaseError> {
         self.store
             .get_chain_config()
-            .map_err(|e| EvmError::DB(e.to_string()))
+            .map_err(|e| DatabaseError::Custom(e.to_string()))
     }
 
     #[instrument(level = "trace", name = "Account code read", skip_all)]
-    fn get_account_code(&self, code_hash: H256) -> Result<Bytes, EvmError> {
+    fn get_account_code(&self, code_hash: H256) -> Result<Bytes, DatabaseError> {
         if code_hash == *EMPTY_KECCACK_HASH {
             return Ok(Bytes::new());
         }
         match self.store.get_account_code(code_hash) {
             Ok(Some(code)) => Ok(code),
-            Ok(None) => Err(EvmError::DB(format!(
+            Ok(None) => Err(DatabaseError::Custom(format!(
                 "Code not found for hash: {code_hash:?}",
             ))),
-            Err(e) => Err(EvmError::DB(e.to_string())),
+            Err(e) => Err(DatabaseError::Custom(e.to_string())),
         }
     }
 }

crates/common/trie/trie.rs

@@ -261,6 +261,11 @@ impl Trie {
         all_nodes: &BTreeMap<H256, Vec<u8>>,
         root_hash: H256,
     ) -> Result<NodeRef, TrieError> {
+        // If the root hash is of the empty trie then we can get away by setting the NodeRef to default
+        if root_hash == *EMPTY_TRIE_HASH {
+            return Ok(NodeRef::default());
+        }
+
         let root_rlp = all_nodes
             .get(&root_hash)
             .ok_or(TrieError::InconsistentTree)?;

crates/common/types/block_execution_witness.rs

@@ -6,7 +6,7 @@ use crate::types::Block;
 use crate::{
     H160,
     constants::EMPTY_KECCACK_HASH,
-    types::{AccountInfo, AccountState, AccountUpdate, BlockHeader, ChainConfig},
+    types::{AccountState, AccountUpdate, BlockHeader, ChainConfig},
     utils::{decode_hex, keccak},
 };
 use bytes::Bytes;
@@ -357,10 +357,10 @@ impl GuestProgramState {
 
     /// Retrieves the account info based on what is stored in the state trie.
     /// Returns an error if the state trie is not rebuilt or if decoding the account state fails.
-    pub fn get_account_info(
+    pub fn get_account_state(
         &mut self,
         address: Address,
-    ) -> Result<Option<AccountInfo>, GuestProgramStateError> {
+    ) -> Result<Option<AccountState>, GuestProgramStateError> {
         let state_trie = self
             .state_trie
             .as_ref()
@@ -380,11 +380,7 @@ impl GuestProgramState {
             GuestProgramStateError::Database("Failed to get decode account from trie".to_string())
         })?;
 
-        Ok(Some(AccountInfo {
-            balance: state.balance,
-            code_hash: state.code_hash,
-            nonce: state.nonce,
-        }))
+        Ok(Some(state))
     }
 
     /// Fetches the block hash for a specific block number.

crates/l2/common/Cargo.toml

@@ -12,6 +12,7 @@ ethrex-rlp.workspace = true
 ethrex-storage.workspace = true
 ethrex-trie.workspace = true
 ethrex-vm.workspace = true
+ethrex-levm.workspace = true
 bytes.workspace = true
 thiserror.workspace = true
 serde.workspace = true

crates/l2/common/src/state_diff.rs

@@ -6,10 +6,11 @@ use ethrex_common::types::{
     AccountInfo, AccountState, AccountUpdate, BlockHeader, PrivilegedL2Transaction, TxKind,
     code_hash,
 };
+use ethrex_levm::db::Database as LevmDatabase;
 use ethrex_rlp::decode::RLPDecode;
 use ethrex_storage::{error::StoreError, hash_address};
 use ethrex_trie::{Trie, TrieError};
-use ethrex_vm::{EvmError, VmDatabase};
+use ethrex_vm::EvmError;
 use serde::{Deserialize, Serialize};
 
 use crate::{l1_messages::L1Message, privileged_transactions::PrivilegedTransactionLog};
@@ -536,16 +537,15 @@ impl Decoder {
 /// Calculates nonce_diff between current and previous block.
 pub fn get_nonce_diff(
     account_update: &AccountUpdate,
-    db: &impl VmDatabase,
+    db: &impl LevmDatabase,
 ) -> Result<u16, StateDiffError> {
     // Get previous account_info either from store or cache
-    let account_info = db.get_account_info(account_update.address)?;
+    let account_state = db
+        .get_account_state(account_update.address)
+        .map_err(EvmError::from)?;
 
     // Get previous nonce
-    let prev_nonce = match account_info {
-        Some(info) => info.nonce,
-        None => 0,
-    };
+    let prev_nonce = account_state.nonce;
 
     // Get current nonce
     let new_nonce = if let Some(info) = account_update.info.clone() {
@@ -567,7 +567,7 @@ pub fn get_nonce_diff(
 /// Prepare the state diff for the block.
 pub fn prepare_state_diff(
     last_header: BlockHeader,
-    db: &impl VmDatabase,
+    db: &impl LevmDatabase,
     l1messages: &[L1Message],
     privileged_transactions: &[PrivilegedL2Transaction],
     account_updates: Vec<AccountUpdate>,

crates/l2/prover/src/guest_program/src/execution.rs

@@ -17,8 +17,9 @@ use ethrex_common::{
 };
 #[cfg(feature = "l2")]
 use ethrex_l2_common::l1_messages::L1Message;
-use ethrex_vm::{Evm, EvmError, GuestProgramStateWrapper, VmDatabase};
+use ethrex_vm::{Evm, EvmError, GuestProgramStateWrapper};
 use std::collections::{BTreeMap, HashMap};
+use std::sync::Arc;
 
 #[cfg(feature = "l2")]
 use ethrex_common::types::{
@@ -320,9 +321,9 @@ fn execute_stateless(
 
         // Execute block
         #[cfg(feature = "l2")]
-        let mut vm = Evm::new_for_l2(wrapped_db.clone())?;
+        let mut vm = Evm::new_from_db_for_l2(Arc::new(wrapped_db.clone()));
         #[cfg(not(feature = "l2"))]
-        let mut vm = Evm::new_for_l1(wrapped_db.clone());
+        let mut vm = Evm::new_from_db_for_l1(Arc::new(wrapped_db.clone()));
         let result = vm
             .execute_block(block)
             .map_err(StatelessExecutionError::EvmError)?;