refactor(levm): use ethrex account types in LEVM (#2629)

**Motivation**

- Stop using the Account and AccountInfo types defined in LEVM and start
using the ones defined in the L1 client.
- Biggest changes are that AccountInfo no longer has code, so we can't
use it with that purpose and also we don't have our struct StorageSlot
anymore, so we have to keep track of original values somewhere else.


**Description**

- Now we use the structs of the L1 client but they are different from
the ones that we used so I had to make changes:
- `get_account_info` is now `get_account` because we also need the code
of the account and `AccountInfo` has the `code_hash` only. This makes
changes on every structure that implements `LevmDatabase` trait.
- Now that we don't have `StorageSlot` that had the `current_value` and
`original_value` of a storage slot (`original_value` being the value
pre-tx) I had to make some changes to logic and store those original
values into an auxiliary `HashMap` on `VM`.
- Added new function `get_original_storage()` for getting the original
storage value.
- Make some tiny changes in SSTORE, mostly organize it better.

Storage changes deep description:
- Now every time we want to get the `original_value` we will look up in
the original values stored in the VM struct. These intends to store the
storage values previous to starting the execution of a particular
transaction. For efficiency and performance, we only update this new
field when actually getting the original value.
- Let me clarify: At the beginning of the transaction the `CacheDB`
could have a lot of accounts with their storage but the
`VM.storage_original_values`will start empty on every transaction. When
`SSTORE` opcode is executed and we actually care for the original value
of a storage slot we will look at `storage_original_values` and it won’t
find it (the first time), so then it will see what the value in the
`CacheDB` is, and if it’s not there it will finally check on the actual
`Database`. After retrieving the value, it will be added to
`storage_original_values` , but ONLY the FIRST time. That means that if
the value keeps on changing the `original_value` won’t change because
once it’s added it’s not modified.

<!-- Link to issues: Resolves #111, Resolves #222 -->

Closes #issue_number

Author: JereSalo

cmd/ef_tests/state/report.rs

@@ -1,10 +1,10 @@
 use crate::runner::{EFTestRunnerError, InternalError};
 use colored::Colorize;
-use ethrex_common::{types::Fork, Address, H256};
-use ethrex_levm::{
-    errors::{ExecutionReport, TxResult, VMError},
-    Account,
+use ethrex_common::{
+    types::{Account, Fork},
+    Address, H256,
 };
+use ethrex_levm::errors::{ExecutionReport, TxResult, VMError};
 use ethrex_storage::{error::StoreError, AccountUpdate};
 use itertools::Itertools;
 use revm::primitives::{EVMError, ExecutionResult as RevmExecutionResult};
@@ -664,14 +664,14 @@ impl fmt::Display for ComparisonReport {
                         base_account.info.balance, new_info.balance
                     )?;
 
-                    if base_account.info.bytecode_hash() != new_info.code_hash {
+                    if base_account.info.code_hash != new_info.code_hash {
                         writeln!(
                             f,
                             "\t\t\t\t\tCode: {} -> {}",
-                            if base_account.info.bytecode.is_empty() {
+                            if base_account.code.is_empty() {
                                 "empty".to_string()
                             } else {
-                                hex::encode(&base_account.info.bytecode)
+                                hex::encode(&base_account.code)
                             },
                             account_update
                                 .code
@@ -691,7 +691,7 @@ impl fmt::Display for ComparisonReport {
                     writeln!(
                         f,
                         "\t\t\t\t\tStorage slot: {key:#x}: {} -> {}",
-                        initial_value.original_value, value
+                        initial_value, value
                     )?;
                 }
             }

cmd/ef_tests/state/runner/levm_runner.rs

@@ -198,29 +198,29 @@ pub fn prepare_vm_for_tx<'a>(
 pub fn ensure_pre_state(evm: &VM, test: &EFTest) -> Result<(), EFTestRunnerError> {
     let world_state = &evm.db.store;
     for (address, pre_value) in &test.pre.0 {
-        let account = world_state.get_account_info(*address).map_err(|e| {
+        let account = world_state.get_account(*address).map_err(|e| {
             EFTestRunnerError::Internal(InternalError::Custom(format!(
                 "Failed to get account info when ensuring pre state: {}",
                 e
             )))
         })?;
         ensure_pre_state_condition(
-            account.nonce == pre_value.nonce,
+            account.info.nonce == pre_value.nonce,
             format!(
                 "Nonce mismatch for account {:#x}: expected {}, got {}",
-                address, pre_value.nonce, account.nonce
+                address, pre_value.nonce, account.info.nonce
             ),
         )?;
         ensure_pre_state_condition(
-            account.balance == pre_value.balance,
+            account.info.balance == pre_value.balance,
             format!(
                 "Balance mismatch for account {:#x}: expected {}, got {}",
-                address, pre_value.balance, account.balance
+                address, pre_value.balance, account.info.balance
             ),
         )?;
         for (k, v) in &pre_value.storage {
             let storage_slot = world_state
-                .get_storage_slot(*address, H256::from_slice(&k.to_big_endian()))
+                .get_storage_value(*address, H256::from_slice(&k.to_big_endian()))
                 .unwrap();
             ensure_pre_state_condition(
                 &storage_slot == v,
@@ -231,12 +231,12 @@ pub fn ensure_pre_state(evm: &VM, test: &EFTest) -> Result<(), EFTestRunnerError
             )?;
         }
         ensure_pre_state_condition(
-            keccak(account.bytecode.clone()) == keccak(pre_value.code.as_ref()),
+            account.info.code_hash == keccak(pre_value.code.as_ref()),
             format!(
                 "Code hash mismatch for account {:#x}: expected {}, got {}",
                 address,
                 keccak(pre_value.code.as_ref()),
-                keccak(account.bytecode)
+                account.info.code_hash
             ),
         )?;
     }

cmd/ef_tests/state/runner/mod.rs

@@ -6,7 +6,7 @@ use crate::{
 };
 use clap::Parser;
 use colored::Colorize;
-use ethrex_common::Address;
+use ethrex_common::{types::Account, Address};
 use ethrex_levm::errors::{ExecutionReport, VMError};
 use ethrex_vm::SpecId;
 use serde::{Deserialize, Serialize};
@@ -24,11 +24,7 @@ pub enum EFTestRunnerError {
     #[error("Failed to ensure pre-state: {0}")]
     FailedToEnsurePreState(String),
     #[error("Failed to ensure post-state: {1}")]
-    FailedToEnsurePostState(
-        ExecutionReport,
-        String,
-        HashMap<Address, ethrex_levm::Account>,
-    ),
+    FailedToEnsurePostState(ExecutionReport, String, HashMap<Address, Account>),
     #[error("VM run mismatch: {0}")]
     VMExecutionMismatch(String),
     #[error("Exception does not match the expected: {0}")]

cmd/ef_tests/state/runner/revm_runner.rs

@@ -6,13 +6,10 @@ use crate::{
 };
 use bytes::Bytes;
 use ethrex_common::{
-    types::{Fork, TxKind},
+    types::{Account, Fork, TxKind},
     Address, H256,
 };
-use ethrex_levm::{
-    errors::{ExecutionReport, TxResult},
-    Account, StorageSlot,
-};
+use ethrex_levm::errors::{ExecutionReport, TxResult};
 use ethrex_storage::{error::StoreError, AccountUpdate};
 use ethrex_vm::{
     self,
@@ -362,13 +359,7 @@ pub async fn compare_levm_revm_account_updates(
             let account_storage = pre_state_value
                 .storage
                 .iter()
-                .map(|(key, value)| {
-                    let storage_slot = StorageSlot {
-                        original_value: *value,
-                        current_value: *value,
-                    };
-                    (H256::from_slice(&key.to_big_endian()), storage_slot)
-                })
+                .map(|(key, value)| (H256::from_slice(&key.to_big_endian()), *value))
                 .collect();
             let account = Account::new(
                 pre_state_value.balance,

crates/common/types/account.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use bytes::Bytes;
 use ethereum_types::{H256, U256};
 use ethrex_trie::Trie;
+use keccak_hash::keccak;
 use serde::{Deserialize, Serialize};
 use sha3::{Digest as _, Keccak256};
 
@@ -169,6 +170,43 @@ impl From<&GenesisAccount> for AccountState {
     }
 }
 
+impl Account {
+    pub fn new(balance: U256, code: Bytes, nonce: u64, storage: HashMap<H256, U256>) -> Self {
+        Self {
+            info: AccountInfo {
+                balance,
+                code_hash: keccak(code.as_ref()).0.into(),
+                nonce,
+            },
+            code,
+            storage,
+        }
+    }
+
+    pub fn has_nonce(&self) -> bool {
+        self.info.nonce != 0
+    }
+
+    pub fn has_code(&self) -> bool {
+        self.info.code_hash != *EMPTY_KECCACK_HASH
+    }
+
+    pub fn has_code_or_nonce(&self) -> bool {
+        self.has_code() || self.has_nonce()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.info.balance.is_zero()
+            && self.info.nonce == 0
+            && self.info.code_hash == *EMPTY_KECCACK_HASH
+    }
+
+    pub fn set_code(&mut self, code: Bytes) {
+        self.info.code_hash = keccak(code.as_ref()).0.into();
+        self.code = code;
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::str::FromStr;

crates/l2/prover/bench/src/rpc/db.rs

@@ -1,4 +1,3 @@
-use std::cell::RefCell;
 use std::collections::HashMap;
 
 use crate::constants::{CANCUN_CONFIG, RPC_RATE_LIMIT};
@@ -9,8 +8,8 @@ use ethrex_common::{
     types::{AccountInfo, AccountState, Block, Fork, TxKind},
     Address, H256, U256,
 };
+use ethrex_levm::db::gen_db::GeneralizedDatabase;
 use ethrex_levm::db::Database as LevmDatabase;
-use ethrex_levm::vm::GeneralizedDatabase;
 use ethrex_storage::{hash_address, hash_key};
 use ethrex_trie::{Node, PathRLP, Trie};
 use ethrex_vm::backends::levm::{CacheDB, LEVM};
@@ -445,10 +444,11 @@ impl LevmDatabase for RpcDB {
         Ok(None) // code is stored in account info
     }
 
-    fn get_account_info(
+    fn get_account(
         &self,
         address: Address,
-    ) -> std::result::Result<ethrex_levm::AccountInfo, ethrex_levm::db::error::DatabaseError> {
+    ) -> std::result::Result<ethrex_common::types::Account, ethrex_levm::db::error::DatabaseError>
+    {
         let cache = self.cache.lock().unwrap();
         let account = if let Some(account) = cache.get(&address).cloned() {
             account
@@ -466,17 +466,18 @@ impl LevmDatabase for RpcDB {
             ..
         } = account
         {
-            Ok(ethrex_levm::AccountInfo {
-                bytecode: code.clone().unwrap_or_default(),
-                balance: account_state.balance,
-                nonce: account_state.nonce,
-            })
+            Ok(ethrex_common::types::Account::new(
+                account_state.balance,
+                code.clone().unwrap_or_default(),
+                account_state.nonce,
+                HashMap::new(),
+            ))
         } else {
-            Ok(ethrex_levm::AccountInfo::default())
+            Ok(ethrex_common::types::Account::default())
         }
     }
 
-    fn get_storage_slot(&self, address: Address, key: H256) -> Result<U256, DatabaseError> {
+    fn get_storage_value(&self, address: Address, key: H256) -> Result<U256, DatabaseError> {
         let account = self
             .fetch_accounts_blocking(&[(address, vec![key])], false)
             .map_err(|e| DatabaseError::Custom(format!("Failed to fetch account info: {e}")))?

crates/vm/backends/levm/db.rs

@@ -1,3 +1,4 @@
+use ethrex_common::types::Account;
 use ethrex_common::U256 as CoreU256;
 use ethrex_common::{Address as CoreAddress, H256 as CoreH256};
 use ethrex_levm::constants::EMPTY_CODE_HASH;
@@ -30,10 +31,7 @@ impl DatabaseLogger {
 }
 
 impl LevmDatabase for DatabaseLogger {
-    fn get_account_info(
-        &self,
-        address: CoreAddress,
-    ) -> Result<ethrex_levm::AccountInfo, DatabaseError> {
+    fn get_account(&self, address: CoreAddress) -> Result<Account, DatabaseError> {
         self.state_accessed
             .lock()
             .map_err(|_| DatabaseError::Custom("Could not lock mutex".to_string()))?
@@ -42,14 +40,14 @@ impl LevmDatabase for DatabaseLogger {
         self.store
             .lock()
             .map_err(|_| DatabaseError::Custom("Could not lock mutex".to_string()))?
-            .get_account_info(address)
+            .get_account(address)
     }
 
     fn account_exists(&self, address: CoreAddress) -> bool {
         self.store.lock().unwrap().account_exists(address)
     }
 
-    fn get_storage_slot(
+    fn get_storage_value(
         &self,
         address: CoreAddress,
         key: CoreH256,
@@ -63,7 +61,7 @@ impl LevmDatabase for DatabaseLogger {
         self.store
             .lock()
             .map_err(|_| DatabaseError::Custom("Could not lock mutex".to_string()))?
-            .get_storage_slot(address, key)
+            .get_storage_value(address, key)
     }
 
     fn get_block_hash(&self, block_number: u64) -> Result<Option<CoreH256>, DatabaseError> {
@@ -101,10 +99,7 @@ impl LevmDatabase for DatabaseLogger {
 }
 
 impl LevmDatabase for StoreWrapper {
-    fn get_account_info(
-        &self,
-        address: CoreAddress,
-    ) -> Result<ethrex_levm::AccountInfo, DatabaseError> {
+    fn get_account(&self, address: CoreAddress) -> Result<Account, DatabaseError> {
         let acc_info = self
             .store
             .get_account_info_by_hash(self.block_hash, address)
@@ -117,11 +112,12 @@ impl LevmDatabase for StoreWrapper {
             .map_err(|e| DatabaseError::Custom(e.to_string()))?
             .unwrap_or_default();
 
-        Ok(ethrex_levm::account::AccountInfo {
-            balance: acc_info.balance,
-            nonce: acc_info.nonce,
-            bytecode: acc_code,
-        })
+        Ok(Account::new(
+            acc_info.balance,
+            acc_code,
+            acc_info.nonce,
+            HashMap::new(),
+        ))
     }
 
     fn account_exists(&self, address: CoreAddress) -> bool {
@@ -133,7 +129,7 @@ impl LevmDatabase for StoreWrapper {
         acc_info.is_some()
     }
 
-    fn get_storage_slot(
+    fn get_storage_value(
         &self,
         address: CoreAddress,
         key: CoreH256,
@@ -165,12 +161,9 @@ impl LevmDatabase for StoreWrapper {
 }
 
 impl LevmDatabase for ExecutionDB {
-    fn get_account_info(
-        &self,
-        address: CoreAddress,
-    ) -> Result<ethrex_levm::AccountInfo, DatabaseError> {
+    fn get_account(&self, address: CoreAddress) -> Result<Account, DatabaseError> {
         let Some(acc_info) = self.accounts.get(&address) else {
-            return Ok(ethrex_levm::AccountInfo::default());
+            return Ok(Account::default());
         };
 
         let acc_code = if acc_info.code_hash != EMPTY_CODE_HASH {
@@ -184,11 +177,12 @@ impl LevmDatabase for ExecutionDB {
             &bytes::Bytes::new()
         };
 
-        Ok(ethrex_levm::AccountInfo {
-            balance: acc_info.balance,
-            bytecode: acc_code.clone(),
-            nonce: acc_info.nonce,
-        })
+        Ok(Account::new(
+            acc_info.balance,
+            acc_code.clone(),
+            acc_info.nonce,
+            HashMap::new(),
+        ))
     }
 
     fn account_exists(&self, address: CoreAddress) -> bool {
@@ -199,7 +193,7 @@ impl LevmDatabase for ExecutionDB {
         Ok(self.block_hashes.get(&block_number).cloned())
     }
 
-    fn get_storage_slot(
+    fn get_storage_value(
         &self,
         address: CoreAddress,
         key: CoreH256,