refactor anvil Env and reduce changes in tx processing

Author: klkvr

crates/anvil/src/config.rs

@@ -45,7 +45,7 @@ use op_revm::OpTransaction;
 use parking_lot::RwLock;
 use rand::thread_rng;
 use revm::{
-    context::{BlockEnv, TxEnv},
+    context::{BlockEnv, CfgEnv, TxEnv},
     context_interface::block::BlobExcessGasAndPrice,
     primitives::hardfork::SpecId,
 };
@@ -1024,7 +1024,8 @@ impl NodeConfig {
     pub(crate) async fn setup(&mut self) -> Result<mem::Backend> {
         // configure the revm environment
 
-        let mut cfg = Env::default_with_spec_id(self.get_hardfork().into()).evm_env.cfg_env;
+        let mut cfg = CfgEnv::default();
+        cfg.spec = self.get_hardfork().into();
 
         cfg.chain_id = self.get_chain_id();
         cfg.limit_contract_code_size = self.code_size_limit;
@@ -1039,7 +1040,7 @@ impl NodeConfig {
         }
 
         let spec_id = cfg.spec;
-        let mut env = Env::from(
+        let mut env = Env::new(
             cfg,
             BlockEnv {
                 gas_limit: self.gas_limit(),
@@ -1390,7 +1391,7 @@ async fn derive_block_and_transactions(
         ForkChoice::Block(block_number) => {
             let block_number = *block_number;
             if block_number >= 0 {
-                return Ok((block_number as u64, None))
+                return Ok((block_number as u64, None));
             }
             // subtract from latest block number
             let latest = provider.get_block_number().await?;

crates/anvil/src/eth/backend/env.rs

@@ -1,11 +1,8 @@
 use alloy_evm::EvmEnv;
 use foundry_evm::EnvMut;
 use foundry_evm_core::AsEnvMut;
-use op_revm::{transaction::deposit::DepositTransactionParts, OpTransaction};
-use revm::{
-    context::{BlockEnv, CfgEnv, TxEnv},
-    primitives::hardfork::SpecId,
-};
+use op_revm::OpTransaction;
+use revm::context::{BlockEnv, CfgEnv, TxEnv};
 
 /// Helper container type for [`EvmEnv`] and [`OpTransaction<TxEnd>`].
 #[derive(Clone, Debug, Default)]
@@ -17,33 +14,9 @@ pub struct Env {
 
 /// Helper container type for [`EvmEnv`] and [`OpTransaction<TxEnv>`].
 impl Env {
-    pub fn default_with_spec_id(spec_id: SpecId) -> Self {
-        let mut cfg = CfgEnv::default();
-        cfg.spec = spec_id;
-
-        Self::from(cfg, BlockEnv::default(), OpTransaction::default())
-    }
-
-    pub fn from(cfg: CfgEnv, block: BlockEnv, tx: OpTransaction<TxEnv>) -> Self {
+    pub fn new(cfg: CfgEnv, block: BlockEnv, tx: OpTransaction<TxEnv>) -> Self {
         Self { evm_env: EvmEnv { cfg_env: cfg, block_env: block }, tx, is_optimism: false }
     }
-
-    pub fn new_with_spec_id(
-        cfg: CfgEnv,
-        block: BlockEnv,
-        tx: OpTransaction<TxEnv>,
-        spec_id: SpecId,
-    ) -> Self {
-        let mut cfg = cfg;
-        cfg.spec = spec_id;
-
-        Self::from(cfg, block, tx)
-    }
-
-    pub fn with_deposit(mut self, deposit: DepositTransactionParts) -> Self {
-        self.tx.deposit = deposit;
-        self
-    }
 }
 
 impl AsEnvMut for Env {

crates/anvil/src/eth/backend/executor.rs

@@ -26,9 +26,7 @@ use anvil_core::eth::{
 };
 use foundry_evm::{backend::DatabaseError, traces::CallTraceNode};
 use foundry_evm_core::{either_evm::EitherEvm, evm::FoundryPrecompiles};
-use op_revm::{
-    transaction::deposit::DEPOSIT_TRANSACTION_TYPE, L1BlockInfo, OpContext, OpTransactionError,
-};
+use op_revm::{L1BlockInfo, OpContext};
 use revm::{
     context::{Block as RevmBlock, BlockEnv, CfgEnv, Evm as RevmEvm, JournalTr},
     context_interface::result::{EVMError, ExecutionResult, Output},
@@ -114,6 +112,7 @@ pub struct TransactionExecutor<'a, Db: ?Sized, V: TransactionValidator> {
     pub blob_gas_used: u64,
     pub enable_steps_tracing: bool,
     pub odyssey: bool,
+    pub optimism: bool,
     pub print_logs: bool,
     pub print_traces: bool,
     /// Precompiles to inject to the EVM.
@@ -248,13 +247,15 @@ impl<DB: Db + ?Sized, V: TransactionValidator> TransactionExecutor<'_, DB, V> {
     }
 
     fn env_for(&self, tx: &PendingTransaction) -> Env {
-        let op_tx = tx.to_revm_tx_env();
+        let mut tx_env = tx.to_revm_tx_env();
 
-        let mut env = Env::from(self.cfg_env.clone(), self.block_env.clone(), op_tx.clone());
-        if env.tx.base.tx_type == DEPOSIT_TRANSACTION_TYPE {
-            env = env.with_deposit(op_tx.deposit);
+        if self.optimism {
+            tx_env.enveloped_tx = Some(alloy_rlp::encode(&tx.transaction.transaction).into());
         }
 
+        let mut env = Env::new(self.cfg_env.clone(), self.block_env.clone(), op_tx);
+        env.is_optimism = self.optimism;
+
         env
     }
 }
@@ -308,7 +309,7 @@ impl<DB: Db + ?Sized, V: TransactionValidator> Iterator for &mut TransactionExec
             &env,
         ) {
             warn!(target: "backend", "Skipping invalid tx execution [{:?}] {}", transaction.hash(), err);
-            return Some(TransactionExecutionOutcome::Invalid(transaction, err))
+            return Some(TransactionExecutionOutcome::Invalid(transaction, err));
         }
 
         let nonce = account.nonce;
@@ -324,32 +325,35 @@ impl<DB: Db + ?Sized, V: TransactionValidator> Iterator for &mut TransactionExec
             inspector = inspector.with_trace_printer();
         }
 
-        let mut evm = evm_with_inspector(
-            &mut *self.db,
-            &env,
-            &mut inspector,
-            transaction.tx_type() == DEPOSIT_TRANSACTION_TYPE,
-        );
-        trace!(target: "backend", "[{:?}] executing", transaction.hash());
-        let exec_result = match evm.transact_commit(env.tx) {
-            Ok(exec_result) => exec_result,
-            Err(err) => {
-                warn!(target: "backend", "[{:?}] failed to execute: {:?}", transaction.hash(), err);
-                match err {
-                    EVMError::Database(err) => {
-                        return Some(TransactionExecutionOutcome::DatabaseError(transaction, err))
-                    }
-                    EVMError::Transaction(err) => {
-                        let err = match err {
-                            OpTransactionError::Base(err) => err.into(),
-                            OpTransactionError::HaltedDepositPostRegolith |
-                            OpTransactionError::DepositSystemTxPostRegolith => {
-                                InvalidTransactionError::DepositTxErrorPostRegolith
-                            }
-                        };
-                        return Some(TransactionExecutionOutcome::Invalid(transaction, err))
+        let exec_result = {
+            let mut evm = new_evm_with_inspector(&mut *self.db, &env, &mut inspector);
+            // if let Some(factory) = &self.precompile_factory {
+            //     inject_precompiles(&mut evm, factory.precompiles());
+            // }
+
+            trace!(target: "backend", "[{:?}] executing", transaction.hash());
+            // transact and commit the transaction
+            match evm.transact_commit(env.tx) {
+                Ok(exec_result) => exec_result,
+                Err(err) => {
+                    warn!(target: "backend", "[{:?}] failed to execute: {:?}", transaction.hash(), err);
+                    match err {
+                        EVMError::Database(err) => {
+                            return Some(TransactionExecutionOutcome::DatabaseError(
+                                transaction,
+                                err,
+                            ))
+                        }
+                        EVMError::Transaction(err) => {
+                            return Some(TransactionExecutionOutcome::Invalid(
+                                transaction,
+                                err.into(),
+                            ))
+                        }
+                        // This will correspond to prevrandao not set, and it should never happen.
+                        // If it does, it's a bug.
+                        e => panic!("failed to execute transaction: {e}"),
                     }
-                    e => panic!("failed to execute transaction: {e}"),
                 }
             }
         };
@@ -413,17 +417,16 @@ fn build_logs_bloom(logs: Vec<Log>, bloom: &mut Bloom) {
 }
 
 /// Creates a database with given database and inspector, optionally enabling odyssey features.
-pub fn evm_with_inspector<DB, I>(
+pub fn new_evm_with_inspector<DB, I>(
     db: DB,
     env: &Env,
     inspector: I,
-    is_optimism: bool,
 ) -> EitherEvm<DB, I, FoundryPrecompiles>
 where
     DB: Database<Error = DatabaseError>,
     I: Inspector<EthEvmContext<DB>> + Inspector<OpContext<DB>>,
 {
-    if is_optimism {
+    if env.is_optimism {
         let op_context = OpContext {
             journaled_state: {
                 let mut journal = Journal::new(db);
@@ -476,17 +479,16 @@ where
 }
 
 /// Creates a new EVM with the given inspector and wraps the database in a `WrapDatabaseRef`.
-pub fn evm_with_inspector_ref<'db, DB, I>(
+pub fn new_evm_with_inspector_ref<'db, DB, I>(
     db: &'db DB,
     env: &Env,
     inspector: &'db mut I,
-    is_optimism: bool,
 ) -> EitherEvm<WrapDatabaseRef<&'db DB>, &'db mut I, FoundryPrecompiles>
 where
     DB: DatabaseRef<Error = DatabaseError> + 'db + ?Sized,
     I: Inspector<EthEvmContext<WrapDatabaseRef<&'db DB>>>
         + Inspector<OpContext<WrapDatabaseRef<&'db DB>>>,
     WrapDatabaseRef<&'db DB>: Database<Error = DatabaseError>,
 {
-    evm_with_inspector(WrapDatabaseRef(db), env, inspector, is_optimism)
+    new_evm_with_inspector(WrapDatabaseRef(db), env, inspector)
 }

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

@@ -1,7 +1,6 @@
 //! In-memory blockchain backend.
 
 use self::state::trie_storage;
-use super::executor::evm_with_inspector_ref;
 use crate::{
     config::PruneStateHistoryConfig,
     eth::{
@@ -124,6 +123,8 @@ use std::{
 use storage::{Blockchain, MinedTransaction, DEFAULT_HISTORY_LIMIT};
 use tokio::sync::RwLock as AsyncRwLock;
 
+use super::executor::new_evm_with_inspector_ref;
+
 pub mod cache;
 pub mod fork_db;
 pub mod in_memory_db;
@@ -1069,7 +1070,7 @@ impl Backend {
         WrapDatabaseRef<&'db dyn DatabaseRef<Error = DatabaseError>>:
             Database<Error = DatabaseError>,
     {
-        evm_with_inspector_ref(db, env, inspector, self.is_optimism())
+        new_evm_with_inspector_ref(db, env, inspector)
         // TODO(yash): inject precompiles
         // if let Some(factory) = &self.precompile_factory {
         //     inject_precompiles(&mut evm, factory.precompiles());
@@ -1158,6 +1159,7 @@ impl Backend {
             print_traces: self.print_traces,
             precompile_factory: self.precompile_factory.clone(),
             odyssey: self.odyssey,
+            optimism: self.is_optimism(),
         };
 
         // create a new pending block
@@ -1241,6 +1243,7 @@ impl Backend {
                     print_traces: self.print_traces,
                     odyssey: self.odyssey,
                     precompile_factory: self.precompile_factory.clone(),
+                    optimism: self.is_optimism(),
                 };
                 let executed_tx = executor.execute();
 

crates/anvil/src/eth/error.rs

@@ -338,6 +338,16 @@ impl From<InvalidTransaction> for InvalidTransactionError {
         }
     }
 }
+
+impl From<OpTransactionError> for InvalidTransactionError {
+    fn from(value: OpTransactionError) -> Self {
+        match value {
+            OpTransactionError::Base(err) => err.into(),
+            OpTransactionError::DepositSystemTxPostRegolith |
+            OpTransactionError::HaltedDepositPostRegolith => Self::DepositTxErrorPostRegolith,
+        }
+    }
+}
 /// Helper trait to easily convert results to rpc results
 pub(crate) trait ToRpcResponseResult {
     fn to_rpc_result(self) -> ResponseResult;