chore: use alloy-evm::apply_state_overrides (#11083)

* chore: use alloy-evm::apply_state_overrides

* clippy

Author: Soubhik-10

crates/anvil/src/eth/api.rs

@@ -1,5 +1,5 @@
 use super::{
-    backend::mem::{BlockRequest, DatabaseRef, State, state},
+    backend::mem::{BlockRequest, DatabaseRef, State},
     sign::build_typed_transaction,
 };
 use crate::{
@@ -35,7 +35,7 @@ use alloy_consensus::{
 };
 use alloy_dyn_abi::TypedData;
 use alloy_eips::eip2718::Encodable2718;
-use alloy_evm::overrides::OverrideBlockHashes;
+use alloy_evm::overrides::{OverrideBlockHashes, apply_state_overrides};
 use alloy_network::{
     AnyRpcBlock, AnyRpcTransaction, BlockResponse, Ethereum, NetworkWallet, TransactionBuilder,
     TransactionResponse, eip2718::Decodable2718,
@@ -2960,7 +2960,7 @@ impl EthApi {
                 .with_database_at(Some(block_request), |state, mut block| {
                     let mut cache_db = CacheDB::new(state);
                     if let Some(state_overrides) = overrides.state {
-                        state::apply_state_overrides(
+                        apply_state_overrides(
                             state_overrides.into_iter().collect(),
                             &mut cache_db,
                         )?;

crates/anvil/src/eth/backend/mem/mod.rs

@@ -42,7 +42,10 @@ use alloy_consensus::{
 };
 use alloy_eips::{eip1559::BaseFeeParams, eip4844::kzg_to_versioned_hash, eip7840::BlobParams};
 use alloy_evm::{
-    Database, Evm, eth::EthEvmContext, overrides::OverrideBlockHashes, precompiles::PrecompilesMap,
+    Database, Evm,
+    eth::EthEvmContext,
+    overrides::{OverrideBlockHashes, apply_state_overrides},
+    precompiles::PrecompilesMap,
 };
 use alloy_network::{
     AnyHeader, AnyRpcBlock, AnyRpcHeader, AnyRpcTransaction, AnyTxEnvelope, AnyTxType,
@@ -1481,7 +1484,7 @@ impl Backend {
             let (exit, out, gas, state) = {
                 let mut cache_db = CacheDB::new(state);
                 if let Some(state_overrides) = overrides.state {
-                    state::apply_state_overrides(state_overrides.into_iter().collect(), &mut cache_db)?;
+                    apply_state_overrides(state_overrides.into_iter().collect(), &mut cache_db)?;
                 }
                 if let Some(block_overrides) = overrides.block {
                     cache_db.apply_block_overrides(*block_overrides, &mut block);
@@ -1660,7 +1663,7 @@ impl Backend {
 
                 // apply state overrides before executing the transactions
                 if let Some(state_overrides) = state_overrides {
-                    state::apply_state_overrides(state_overrides, &mut cache_db)?;
+                    apply_state_overrides(state_overrides, &mut cache_db)?;
                 }
                 if let Some(block_overrides) = block_overrides {
                     cache_db.apply_block_overrides(block_overrides, &mut block_env);
@@ -1891,7 +1894,7 @@ impl Backend {
 
             let mut cache_db = CacheDB::new(state);
             if let Some(state_overrides) = state_overrides {
-                state::apply_state_overrides(state_overrides, &mut cache_db)?;
+                apply_state_overrides(state_overrides, &mut cache_db)?;
             }
             if let Some(block_overrides) = block_overrides {
                 cache_db.apply_block_overrides(block_overrides, &mut block);

crates/anvil/src/eth/backend/mem/state.rs

@@ -1,16 +1,9 @@
 //! Support for generating the state root for memdb storage
 
-use crate::eth::error::BlockchainError;
 use alloy_primitives::{Address, B256, U256, keccak256, map::HashMap};
 use alloy_rlp::Encodable;
-use alloy_rpc_types::state::StateOverride;
 use alloy_trie::{HashBuilder, Nibbles};
-use foundry_evm::backend::DatabaseError;
-use revm::{
-    bytecode::Bytecode,
-    database::{CacheDB, DatabaseRef, DbAccount},
-    state::AccountInfo,
-};
+use revm::{database::DbAccount, state::AccountInfo};
 
 pub fn build_root(values: impl IntoIterator<Item = (Nibbles, Vec<u8>)>) -> B256 {
     let mut builder = HashBuilder::default();
@@ -68,55 +61,3 @@ pub fn trie_account_rlp(info: &AccountInfo, storage: &HashMap<U256, U256>) -> Ve
 
     out
 }
-
-/// Applies the given state overrides to the given CacheDB
-pub fn apply_state_overrides<D>(
-    overrides: StateOverride,
-    cache_db: &mut CacheDB<D>,
-) -> Result<(), BlockchainError>
-where
-    D: DatabaseRef<Error = DatabaseError>,
-{
-    for (account, account_overrides) in &overrides {
-        let mut account_info = cache_db.basic_ref(*account)?.unwrap_or_default();
-
-        if let Some(nonce) = account_overrides.nonce {
-            account_info.nonce = nonce;
-        }
-        if let Some(code) = &account_overrides.code {
-            account_info.code = Some(Bytecode::new_raw(code.to_vec().into()));
-        }
-        if let Some(balance) = account_overrides.balance {
-            account_info.balance = balance;
-        }
-
-        cache_db.insert_account_info(*account, account_info);
-
-        // We ensure that not both state and state_diff are set.
-        // If state is set, we must mark the account as "NewlyCreated", so that the old storage
-        // isn't read from
-        match (&account_overrides.state, &account_overrides.state_diff) {
-            (Some(_), Some(_)) => {
-                return Err(BlockchainError::StateOverrideError(
-                    "state and state_diff can't be used together".to_string(),
-                ));
-            }
-            (None, None) => (),
-            (Some(new_account_state), None) => {
-                cache_db.replace_account_storage(
-                    *account,
-                    new_account_state
-                        .iter()
-                        .map(|(key, value)| ((*key).into(), (*value).into()))
-                        .collect(),
-                )?;
-            }
-            (None, Some(account_state_diff)) => {
-                for (key, value) in account_state_diff {
-                    cache_db.insert_account_storage(*account, (*key).into(), (*value).into())?;
-                }
-            }
-        };
-    }
-    Ok(())
-}

crates/anvil/src/eth/error.rs

@@ -1,6 +1,7 @@
 //! Aggregated error type for this module
 
 use crate::eth::pool::transactions::PoolTransaction;
+use alloy_evm::overrides::StateOverrideError;
 use alloy_primitives::{B256, Bytes, SignatureError};
 use alloy_rpc_types::BlockNumberOrTag;
 use alloy_signer::Error as SignerError;
@@ -190,6 +191,21 @@ impl From<WalletError> for BlockchainError {
     }
 }
 
+impl<E> From<StateOverrideError<E>> for BlockchainError
+where
+    E: Into<Self>,
+{
+    fn from(value: StateOverrideError<E>) -> Self {
+        match value {
+            StateOverrideError::InvalidBytecode(err) => Self::StateOverrideError(err.to_string()),
+            StateOverrideError::BothStateAndStateDiff(addr) => Self::StateOverrideError(format!(
+                "state and state_diff can't be used together for account {addr}",
+            )),
+            StateOverrideError::Database(err) => err.into(),
+        }
+    }
+}
+
 /// Errors that can occur in the transaction pool
 #[derive(Debug, thiserror::Error)]
 pub enum PoolError {