fix(levm): don't read from parent block when processing withdrawals (#2556)

**Motivation**
When processing withdrawals with levm, accounts that are not cached are
fetched directly from the `Store` (aka our DB) using the block's parent
hash instead of using the `StoreWrapper` api that already knows which
block's state to read accounts from (as we do for all other DB reads).
This works fine when executing one block at a time as the block that the
StoreWrapper reads from is the block's parent. But when we execute
blocks in batch, the StoreWrapper reads from the parent of the first
block in the batch, as changes from the following blocks will be
recorded in the cache, so when processing withdrawals we may not have
the state of the current block's parent in the Store.
This PR fixes this issue by using the `StoreWrapper` to read uncached
accounts from the batch's parent block instead of looking for an
accounts in a parent state that may not exist. It also removes the
method `get_account_info_by_hash` so we don't run into the same issue in
the future
<!-- Why does this pull request exist? What are its goals? -->

**Description**
* Remove misleading method `get_account_info_by_hash` from levm Database
trait (this can lead us to read state from a block that is not the
designated parent block and which's state may not exist leading to
Inconsistent Trie errors)
* Remove the argument `parent_block_hash` from `process_withdrawals`
<!-- A clear and concise general description of the changes this PR
introduces -->

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

Closes #issue_number

Author: fmoletta

crates/blockchain/payload.rs

@@ -294,7 +294,7 @@ impl Blockchain {
             .unwrap_or(&binding);
         context
             .vm
-            .process_withdrawals(withdrawals, &context.payload.header)
+            .process_withdrawals(withdrawals)
             .map_err(EvmError::from)
     }
 

crates/vm/backends/levm/db.rs

@@ -1,4 +1,3 @@
-use ethrex_common::types::AccountInfo;
 use ethrex_common::U256 as CoreU256;
 use ethrex_common::{Address as CoreAddress, H256 as CoreH256};
 use ethrex_levm::constants::EMPTY_CODE_HASH;
@@ -75,25 +74,6 @@ impl LevmDatabase for DatabaseLogger {
         self.store.get_chain_config()
     }
 
-    fn get_account_info_by_hash(
-        &self,
-        block_hash: ethrex_common::types::BlockHash,
-        address: CoreAddress,
-    ) -> Result<Option<AccountInfo>, DatabaseError> {
-        let account = self.store.get_account_info_by_hash(block_hash, address)?;
-        {
-            if let Some(acc) = account.clone() {
-                let mut code_accessed = self
-                    .code_accessed
-                    .lock()
-                    .map_err(|_| DatabaseError::Custom("Could not lock mutex".to_string()))?;
-                code_accessed.push(acc.code_hash);
-            }
-        }
-
-        Ok(account)
-    }
-
     fn get_account_code(&self, code_hash: CoreH256) -> Result<Option<bytes::Bytes>, DatabaseError> {
         {
             let mut code_accessed = self
@@ -163,16 +143,6 @@ impl LevmDatabase for StoreWrapper {
         self.store.get_chain_config().unwrap()
     }
 
-    fn get_account_info_by_hash(
-        &self,
-        block_hash: ethrex_common::types::BlockHash,
-        address: CoreAddress,
-    ) -> Result<Option<AccountInfo>, DatabaseError> {
-        self.store
-            .get_account_info_by_hash(block_hash, address)
-            .map_err(|e| DatabaseError::Custom(e.to_string()))
-    }
-
     fn get_account_code(&self, code_hash: CoreH256) -> Result<Option<bytes::Bytes>, DatabaseError> {
         self.store
             .get_account_code(code_hash)
@@ -230,14 +200,6 @@ impl LevmDatabase for ExecutionDB {
         self.get_chain_config()
     }
 
-    fn get_account_info_by_hash(
-        &self,
-        _block_hash: ethrex_common::types::BlockHash,
-        address: CoreAddress,
-    ) -> Result<Option<ethrex_common::types::AccountInfo>, DatabaseError> {
-        Ok(self.accounts.get(&address).cloned())
-    }
-
     fn get_account_code(&self, code_hash: CoreH256) -> Result<Option<bytes::Bytes>, DatabaseError> {
         Ok(self.code.get(&code_hash).cloned())
     }

crates/vm/backends/levm/mod.rs

@@ -20,7 +20,7 @@ use ethrex_common::{
 use ethrex_levm::{
     errors::{ExecutionReport, TxResult, VMError},
     vm::{EVMConfig, GeneralizedDatabase, Substate, VM},
-    Account, AccountInfo as LevmAccountInfo, Environment,
+    Account, Environment,
 };
 use ethrex_storage::error::StoreError;
 use ethrex_storage::{hash_address, hash_key, AccountUpdate, Store};
@@ -79,7 +79,7 @@ impl LEVM {
         }
 
         if let Some(withdrawals) = &block.body.withdrawals {
-            Self::process_withdrawals(db, withdrawals, block.header.parent_hash)?;
+            Self::process_withdrawals(db, withdrawals)?;
         }
 
         cfg_if::cfg_if! {
@@ -243,7 +243,6 @@ impl LEVM {
     pub fn process_withdrawals(
         db: &mut GeneralizedDatabase,
         withdrawals: &[Withdrawal],
-        parent_hash: H256,
     ) -> Result<(), ethrex_storage::error::StoreError> {
         // For every withdrawal we increment the target account's balance
         for (address, increment) in withdrawals
@@ -253,23 +252,13 @@ impl LEVM {
         {
             // We check if it was in block_cache, if not, we get it from DB.
             let mut account = db.cache.get(&address).cloned().unwrap_or({
-                let acc_info = db
+                let info = db
                     .store
-                    .get_account_info_by_hash(parent_hash, address)
-                    .map_err(|e| StoreError::Custom(e.to_string()))?
-                    .unwrap_or_default();
-                let acc_code = db
-                    .store
-                    .get_account_code(acc_info.code_hash)
-                    .map_err(|e| StoreError::Custom(e.to_string()))?
-                    .unwrap_or_default();
+                    .get_account_info(address)
+                    .map_err(|e| StoreError::Custom(e.to_string()))?;
 
                 Account {
-                    info: LevmAccountInfo {
-                        balance: acc_info.balance,
-                        bytecode: acc_code,
-                        nonce: acc_info.nonce,
-                    },
+                    info,
                     // This is the added_storage for the withdrawal.
                     // If not involved in the TX, there won't be any updates in the storage
                     storage: HashMap::new(),

crates/vm/backends/mod.rs

@@ -201,16 +201,10 @@ impl Evm {
 
     /// Wraps the [REVM::process_withdrawals] and [LEVM::process_withdrawals].
     /// Applies the withdrawals to the state or the block_chache if using [LEVM].
-    pub fn process_withdrawals(
-        &mut self,
-        withdrawals: &[Withdrawal],
-        block_header: &BlockHeader,
-    ) -> Result<(), StoreError> {
+    pub fn process_withdrawals(&mut self, withdrawals: &[Withdrawal]) -> Result<(), StoreError> {
         match self {
             Evm::REVM { state } => REVM::process_withdrawals(state, withdrawals),
-            Evm::LEVM { db } => {
-                LEVM::process_withdrawals(db, withdrawals, block_header.parent_hash)
-            }
+            Evm::LEVM { db } => LEVM::process_withdrawals(db, withdrawals),
         }
     }
 

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

@@ -1,10 +1,7 @@
 use crate::account::AccountInfo;
 use bytes::Bytes;
 use error::DatabaseError;
-use ethrex_common::{
-    types::{BlockHash, ChainConfig},
-    Address, H256, U256,
-};
+use ethrex_common::{types::ChainConfig, Address, H256, U256};
 
 pub mod cache;
 pub use cache::CacheDB;
@@ -16,10 +13,5 @@ pub trait Database: Send + Sync {
     fn get_block_hash(&self, block_number: u64) -> Result<Option<H256>, DatabaseError>;
     fn account_exists(&self, address: Address) -> bool;
     fn get_chain_config(&self) -> ChainConfig;
-    fn get_account_info_by_hash(
-        &self,
-        block_hash: BlockHash,
-        address: Address,
-    ) -> Result<Option<ethrex_common::types::AccountInfo>, DatabaseError>;
     fn get_account_code(&self, code_hash: H256) -> Result<Option<Bytes>, DatabaseError>;
 }