feat(levm): cache refactor

cmd/ef_tests/levm/runner/levm_runner.rs

@@ -9,7 +9,7 @@ use ethrex_core::{
     H256, U256,
 };
 use ethrex_levm::{
-    db::Cache,
+    db::CacheDB,
     errors::{TransactionReport, VMError},
     vm::VM,
     Environment,
@@ -98,7 +98,7 @@ pub fn prepare_vm_for_tx(vector: &TestVector, test: &EFTest) -> Result<VM, EFTes
         test.transactions.get(vector).unwrap().value,
         test.transactions.get(vector).unwrap().data.clone(),
         db,
-        Cache::default(),
+        CacheDB::default(),
     )
     .map_err(|err| EFTestRunnerError::VMInitializationFailed(err.to_string()))
 }

crates/vm/levm/src/account.rs

@@ -1,7 +1,4 @@
-use crate::{
-    constants::EMPTY_CODE_HASH,
-    errors::{InternalError, VMError},
-};
+use crate::constants::EMPTY_CODE_HASH;
 use bytes::Bytes;
 use ethrex_core::{H256, U256};
 use keccak_hash::keccak;
@@ -19,6 +16,14 @@ impl AccountInfo {
     pub fn is_empty(&self) -> bool {
         self.balance.is_zero() && self.nonce == 0 && self.bytecode.is_empty()
     }
+
+    pub fn has_code(&self) -> bool {
+        !(self.bytecode.is_empty() || self.bytecode_hash() == EMPTY_CODE_HASH)
+    }
+
+    pub fn bytecode_hash(&self) -> H256 {
+        keccak(self.bytecode.as_ref()).0.into()
+    }
 }
 
 #[derive(Clone, Default, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -59,12 +64,12 @@ impl Account {
         }
     }
 
-    pub fn has_code(&self) -> Result<bool, VMError> {
-        Ok(!(self.info.bytecode.is_empty() || self.bytecode_hash() == EMPTY_CODE_HASH))
+    pub fn has_code(&self) -> bool {
+        self.info.has_code()
     }
 
     pub fn bytecode_hash(&self) -> H256 {
-        keccak(self.info.bytecode.as_ref()).0.into()
+        self.info.bytecode_hash()
     }
 
     pub fn is_empty(&self) -> bool {
@@ -90,14 +95,4 @@ impl Account {
         self.info.nonce = nonce;
         self
     }
-
-    // TODO: Replace nonce increments with this or cache's analog (currently does not have senders)
-    pub fn increment_nonce(&mut self) -> Result<(), VMError> {
-        self.info.nonce = self
-            .info
-            .nonce
-            .checked_add(1)
-            .ok_or(VMError::Internal(InternalError::NonceOverflowed))?;
-        Ok(())
-    }
 }

crates/vm/levm/src/constants.rs

@@ -1,5 +1,8 @@
 use ethrex_core::{H256, U256};
 
+pub const WORD_SIZE_IN_BYTES: U256 = U256([32, 0, 0, 0]);
+pub const WORD_SIZE_IN_BYTES_USIZE: usize = 32;
+
 pub const SUCCESS_FOR_CALL: i32 = 1;
 pub const REVERT_FOR_CALL: i32 = 0;
 pub const HALT_FOR_CALL: i32 = 2;
@@ -42,11 +45,6 @@ pub const TARGET_BLOB_GAS_PER_BLOCK: U256 = U256([393216, 0, 0, 0]); // TARGET_B
 pub const MIN_BASE_FEE_PER_BLOB_GAS: U256 = U256([1, 0, 0, 0]);
 pub const BLOB_BASE_FEE_UPDATE_FRACTION: U256 = U256([3338477, 0, 0, 0]);
 
-// Storage constants
-pub const COLD_STORAGE_ACCESS_COST: U256 = U256([2100, 0, 0, 0]);
-pub const WARM_ADDRESS_ACCESS_COST: U256 = U256([100, 0, 0, 0]);
-pub const BALANCE_COLD_ADDRESS_ACCESS_COST: U256 = U256([2600, 0, 0, 0]);
-
 // Block constants
 pub const LAST_AVAILABLE_BLOCK_LIMIT: U256 = U256([256, 0, 0, 0]);
 pub const MAX_BLOCK_GAS_LIMIT: U256 = U256([30_000_000, 0, 0, 0]);

crates/vm/levm/src/db/cache.rs

@@ -0,0 +1,35 @@
+use crate::Account;
+use ethrex_core::Address;
+use std::collections::HashMap;
+
+pub type CacheDB = HashMap<Address, Account>;
+
+pub fn get_account<'cache>(
+    cached_accounts: &'cache CacheDB,
+    address: &Address,
+) -> Option<&'cache Account> {
+    cached_accounts.get(address)
+}
+
+pub fn get_account_mut<'cache>(
+    cached_accounts: &'cache mut CacheDB,
+    address: &Address,
+) -> Option<&'cache mut Account> {
+    cached_accounts.get_mut(address)
+}
+
+pub fn insert_account(
+    cached_accounts: &mut CacheDB,
+    address: Address,
+    account: Account,
+) -> Option<Account> {
+    cached_accounts.insert(address, account)
+}
+
+pub fn remove_account(cached_accounts: &mut CacheDB, address: &Address) -> Option<Account> {
+    cached_accounts.remove(address)
+}
+
+pub fn is_account_cached(cached_accounts: &CacheDB, address: &Address) -> bool {
+    cached_accounts.contains_key(address)
+}

crates/vm/levm/src/db.rs → crates/vm/levm/src/db/mod.rs

@@ -1,10 +1,10 @@
-use crate::{
-    account::{Account, AccountInfo, StorageSlot},
-    errors::{InternalError, VMError},
-};
+use crate::account::{Account, AccountInfo, StorageSlot};
 use ethrex_core::{Address, H256, U256};
 use std::collections::HashMap;
 
+pub mod cache;
+pub use cache::CacheDB;
+
 pub trait Database {
     fn get_account_info(&self, address: Address) -> AccountInfo;
     fn get_storage_slot(&self, address: Address, key: H256) -> U256;
@@ -73,66 +73,3 @@ impl Database for Db {
         self.block_hashes.get(&block_number).cloned()
     }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq)]
-pub struct Cache {
-    pub accounts: HashMap<Address, Account>,
-}
-
-impl Cache {
-    pub fn get_account(&self, address: Address) -> Option<&Account> {
-        self.accounts.get(&address)
-    }
-
-    pub fn get_mut_account(&mut self, address: Address) -> Option<&mut Account> {
-        self.accounts.get_mut(&address)
-    }
-
-    pub fn get_storage_slot(&self, address: Address, key: H256) -> Option<StorageSlot> {
-        self.get_account(address)?.storage.get(&key).cloned()
-    }
-
-    pub fn add_account(&mut self, address: &Address, account: &Account) {
-        self.accounts.insert(*address, account.clone());
-    }
-
-    pub fn write_account_storage(
-        &mut self,
-        address: &Address,
-        key: H256,
-        slot: StorageSlot,
-    ) -> Result<(), VMError> {
-        self.accounts
-            .get_mut(address)
-            .ok_or(VMError::Internal(
-                InternalError::AccountShouldHaveBeenCached,
-            ))?
-            .storage
-            .insert(key, slot);
-        Ok(())
-    }
-
-    // TODO: Replace nonce increments with this (currently does not have senders)
-    pub fn increment_account_nonce(&mut self, address: &Address) -> Result<(), VMError> {
-        if let Some(account) = self.accounts.get_mut(address) {
-            account.info.nonce = account
-                .info
-                .nonce
-                .checked_add(1)
-                .ok_or(VMError::Internal(InternalError::NonceOverflowed))?;
-        }
-        Ok(())
-    }
-
-    pub fn is_account_cached(&self, address: &Address) -> bool {
-        self.accounts.contains_key(address)
-    }
-
-    pub fn is_slot_cached(&self, address: &Address, key: H256) -> bool {
-        self.is_account_cached(address)
-            && self
-                .get_account(*address)
-                .map(|account| account.storage.contains_key(&key))
-                .unwrap_or(false)
-    }
-}

crates/vm/levm/src/errors.rs

@@ -66,6 +66,10 @@ pub enum VMError {
     GasRefundsOverflow,
     #[error("Memory size overflows")]
     MemorySizeOverflow,
+    #[error("Nonce overflowed")]
+    NonceOverflow,
+    #[error("Nonce underflowed")]
+    NonceUnderflow,
     // OutOfGas
     #[error("Out Of Gas")]
     OutOfGas(#[from] OutOfGasError),
@@ -88,14 +92,12 @@ pub enum OutOfGasError {
     MaxGasLimitExceeded,
     #[error("Arithmetic operation divided by zero in gas calculation")]
     ArithmeticOperationDividedByZero,
+    #[error("Memory Expansion Cost Overflow")]
+    MemoryExpansionCostOverflow,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, thiserror::Error, Serialize, Deserialize)]
 pub enum InternalError {
-    #[error("Overflowed when incrementing nonce")]
-    NonceOverflowed,
-    #[error("Underflowed when incrementing nonce")]
-    NonceUnderflowed,
     #[error("Overflowed when incrementing program counter")]
     PCOverflowed,
     #[error("Underflowed when decrementing program counter")]