feat: tweeks for v4.0 revm release (#1048)

* chore: docs and Eq added

* chore: add auto_impl to GetInspectors

* chore: add reset_handler

* fix build

* Modify env box

* Impl GetInspector and Generic Inspector

* Add Evn helpers with spec_id

* helpers env with spec

* Add derefs to CfgEnvWithSpecId

* helper function

* Remove cfg.optimism field

* Support Optimism by default if optimism feature is enabled

* Add optimism_default_handler

* Add optimism enable field

* Optimism in builder

* into_env_with_spec_id

* add db

* Add box

* fix doc

* fix tests and move it to proper place

* Rename EnvWithSpecId to EnvWithHandlerCfg

* fix compile

Author: rakita

Cargo.lock

@@ -129,7 +129,7 @@ fn check_evm_execution<EXT>(
                     "errorMsg": error.unwrap_or_default(),
                     "evmResult": exec_result.as_ref().err().map(|e| e.to_string()).unwrap_or("Ok".to_string()),
                     "postLogsHash": logs_root,
-                    "fork": evm.handler.spec_id(),
+                    "fork": evm.handler.cfg().spec_id,
                     "test": test_name,
                     "d": test.indexes.data,
                     "g": test.indexes.gas,
@@ -240,7 +240,7 @@ pub fn execute_test_suite(
             cache_state.insert_account_with_storage(address, acc_info, info.storage);
         }
 
-        let mut env = Env::default();
+        let mut env = Box::<Env>::default();
         // for mainnet
         env.cfg.chain_id = 1;
         // env.cfg.spec_id is set down the road

bins/revme/src/cmd/statetest/runner.rs

@@ -11,7 +11,7 @@ use revm_primitives::Bytes;
 ///
 /// * `result` - The result of the interpreter's execution, including output data and gas usage.
 /// * `memory_offset` - The range in memory where the output data is located.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CallOutcome {
     pub result: InterpreterResult,
     pub memory_offset: Range<usize>,

crates/interpreter/src/call_outcome.rs

@@ -5,7 +5,7 @@ use revm_primitives::{Address, Bytes};
 ///
 /// This struct holds the result of the operation along with an optional address.
 /// It provides methods to determine the next action based on the result of the operation.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CreateOutcome {
     // The result of the interpreter operation.
     pub result: InterpreterResult,

crates/interpreter/src/create_outcome.rs

@@ -54,7 +54,7 @@ pub struct Interpreter {
 }
 
 /// The result of an interpreter operation.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InterpreterResult {
     /// The result of the instruction execution.
     pub result: InstructionResult,

crates/interpreter/src/interpreter.rs

@@ -1,3 +1,7 @@
+pub mod handler_cfg;
+
+pub use handler_cfg::{CfgEnvWithHandlerCfg, EnvWithHandlerCfg, HandlerCfg};
+
 use crate::{
     alloc::vec::Vec, calc_blob_gasprice, Account, Address, Bytes, InvalidHeader,
     InvalidTransaction, Spec, SpecId, B256, GAS_PER_BLOB, KECCAK_EMPTY, MAX_BLOB_NUMBER_PER_BLOCK,
@@ -79,21 +83,6 @@ impl Env {
     /// Return initial spend gas (Gas needed to execute transaction).
     #[inline]
     pub fn validate_tx<SPEC: Spec>(&self) -> Result<(), InvalidTransaction> {
-        #[cfg(feature = "optimism")]
-        if self.cfg.optimism {
-            // Do not allow for a system transaction to be processed if Regolith is enabled.
-            if self.tx.optimism.is_system_transaction.unwrap_or(false)
-                && SPEC::enabled(SpecId::REGOLITH)
-            {
-                return Err(InvalidTransaction::DepositSystemTxPostRegolith);
-            }
-
-            // Do not perform any extra validation for deposit transactions, they are pre-verified on L1.
-            if self.tx.optimism.source_hash.is_some() {
-                return Ok(());
-            }
-        }
-
         // BASEFEE tx check
         if SPEC::enabled(SpecId::LONDON) {
             if let Some(priority_fee) = self.tx.gas_priority_fee {
@@ -204,13 +193,6 @@ impl Env {
             return Err(InvalidTransaction::RejectCallerWithCode);
         }
 
-        // On Optimism, deposit transactions do not have verification on the nonce
-        // nor the balance of the account.
-        #[cfg(feature = "optimism")]
-        if self.cfg.optimism && self.tx.optimism.source_hash.is_some() {
-            return Ok(());
-        }
-
         // Check that the transaction's nonce is correct
         if let Some(tx) = self.tx.nonce {
             let state = account.info.nonce;
@@ -310,14 +292,6 @@ pub struct CfgEnv {
     /// By default, it is set to `false`.
     #[cfg(feature = "optional_beneficiary_reward")]
     pub disable_beneficiary_reward: bool,
-    /// Enables Optimism's execution changes for deposit transactions and fee
-    /// collection. Hot toggling the optimism field gives applications built
-    /// on revm the ability to switch optimism execution on and off at runtime,
-    /// allowing for features like multichain fork testing. Setting this field
-    /// to false will disable all optimism execution changes regardless of
-    /// compilation with the optimism feature flag.
-    #[cfg(feature = "optimism")]
-    pub optimism: bool,
 }
 
 impl CfgEnv {
@@ -380,16 +354,6 @@ impl CfgEnv {
     pub fn is_beneficiary_reward_disabled(&self) -> bool {
         false
     }
-
-    #[cfg(feature = "optimism")]
-    pub fn is_optimism(&self) -> bool {
-        self.optimism
-    }
-
-    #[cfg(not(feature = "optimism"))]
-    pub fn is_optimism(&self) -> bool {
-        false
-    }
 }
 
 impl Default for CfgEnv {
@@ -414,8 +378,6 @@ impl Default for CfgEnv {
             disable_base_fee: false,
             #[cfg(feature = "optional_beneficiary_reward")]
             disable_beneficiary_reward: false,
-            #[cfg(feature = "optimism")]
-            optimism: false,
         }
     }
 }
@@ -737,52 +699,6 @@ pub enum AnalysisKind {
     Analyse,
 }
 
-#[cfg(test)]
-#[cfg(feature = "optimism")]
-mod op_tests {
-    use super::*;
-
-    #[test]
-    fn test_validate_sys_tx() {
-        // Set the optimism flag to true and mark
-        // the tx as a system transaction.
-        let mut env = Env::default();
-        env.cfg.optimism = true;
-        env.tx.optimism.is_system_transaction = Some(true);
-        assert_eq!(
-            env.validate_tx::<crate::RegolithSpec>(),
-            Err(InvalidTransaction::DepositSystemTxPostRegolith)
-        );
-
-        // Pre-regolith system transactions should be allowed.
-        assert!(env.validate_tx::<crate::BedrockSpec>().is_ok());
-    }
-
-    #[test]
-    fn test_validate_deposit_tx() {
-        // Set the optimism flag and source hash.
-        let mut env = Env::default();
-        env.cfg.optimism = true;
-        env.tx.optimism.source_hash = Some(B256::ZERO);
-        assert!(env.validate_tx::<crate::RegolithSpec>().is_ok());
-    }
-
-    #[test]
-    fn test_validate_tx_against_state_deposit_tx() {
-        // Set the optimism flag and source hash.
-
-        use crate::LatestSpec;
-        let mut env = Env::default();
-        env.cfg.optimism = true;
-        env.tx.optimism.source_hash = Some(B256::ZERO);
-
-        // Nonce and balance checks should be skipped for deposit transactions.
-        assert!(env
-            .validate_tx_against_state::<LatestSpec>(&mut Account::default())
-            .is_ok());
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/primitives/src/env.rs

@@ -0,0 +1,161 @@
+use super::{BlockEnv, CfgEnv, Env, SpecId, TxEnv};
+use alloc::boxed::Box;
+use core::ops::{Deref, DerefMut};
+
+/// Handler configuration fields. It is used to configure the handler.
+/// It contains specification id and the Optimism related field if
+/// optimism feature is enabled.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub struct HandlerCfg {
+    /// Specification identification.
+    pub spec_id: SpecId,
+    /// Optimism related field, it will append the Optimism handle register to the EVM.
+    #[cfg(feature = "optimism")]
+    pub is_optimism: bool,
+}
+
+impl HandlerCfg {
+    /// Creates new `HandlerCfg` instance.
+    pub fn new(spec_id: SpecId) -> Self {
+        Self {
+            spec_id,
+            #[cfg(feature = "optimism")]
+            is_optimism: false,
+        }
+    }
+
+    /// Creates new `HandlerCfg` instance with the optimism feature.
+    #[cfg(feature = "optimism")]
+    pub fn new_with_optimism(spec_id: SpecId, is_optimism: bool) -> Self {
+        Self {
+            spec_id,
+            is_optimism,
+        }
+    }
+
+    /// Returns true if the optimism feature is enabled and flag is set to true.
+    pub fn is_optimism(&self) -> bool {
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "optimism")] {
+                self.is_optimism
+            } else {
+                false
+            }
+        }
+    }
+}
+
+/// Configuration environment with the chain spec id.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct CfgEnvWithHandlerCfg {
+    /// Configuration environment.
+    pub cfg_env: CfgEnv,
+    /// Handler configuration fields.
+    pub handler_cfg: HandlerCfg,
+}
+
+impl CfgEnvWithHandlerCfg {
+    /// Returns new `CfgEnvWithHandlerCfg` instance.
+    pub fn new(cfg_env: CfgEnv, spec_id: SpecId) -> Self {
+        Self {
+            cfg_env,
+            handler_cfg: HandlerCfg {
+                spec_id,
+                #[cfg(feature = "optimism")]
+                is_optimism: false,
+            },
+        }
+    }
+
+    /// Enables the optimism feature.
+    #[cfg(feature = "optimism")]
+    pub fn enable_optimism(&mut self) {
+        self.handler_cfg.is_optimism = true;
+    }
+}
+
+impl DerefMut for CfgEnvWithHandlerCfg {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.cfg_env
+    }
+}
+
+impl Deref for CfgEnvWithHandlerCfg {
+    type Target = CfgEnv;
+
+    fn deref(&self) -> &Self::Target {
+        &self.cfg_env
+    }
+}
+
+/// Evm environment with the chain spec id.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct EnvWithHandlerCfg {
+    /// Evm enironment.
+    pub env: Box<Env>,
+    /// Handler configuration fields.
+    pub handler_cfg: HandlerCfg,
+}
+
+impl EnvWithHandlerCfg {
+    /// Returns new `EnvWithHandlerCfg` instance.
+    pub fn new(env: Box<Env>, spec_id: SpecId) -> Self {
+        Self {
+            env,
+            handler_cfg: HandlerCfg {
+                spec_id,
+                #[cfg(feature = "optimism")]
+                is_optimism: false,
+            },
+        }
+    }
+
+    /// Takes `CfgEnvWithHandlerCfg` and returns new `EnvWithHandlerCfg` instance.
+    pub fn new_with_cfg_env(cfg: CfgEnvWithHandlerCfg, block: BlockEnv, tx: TxEnv) -> Self {
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "optimism")] {
+                let mut new = Self::new(
+                    Box::new(Env {
+                        cfg: cfg.cfg_env,
+                        block,
+                        tx,
+                    }),
+                    cfg.handler_cfg.spec_id,
+                );
+                if cfg.handler_cfg.is_optimism {
+                    new.enable_optimism()
+                }
+                new
+            } else {
+            Self::new(
+                Box::new(Env {
+                    cfg: cfg.cfg_env,
+                    block,
+                    tx,
+                }),
+                cfg.handler_cfg.spec_id,
+            )
+            }
+        }
+    }
+
+    /// Enables the optimism handle register.
+    #[cfg(feature = "optimism")]
+    pub fn enable_optimism(&mut self) {
+        self.handler_cfg.is_optimism = true;
+    }
+}
+
+impl DerefMut for EnvWithHandlerCfg {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.env
+    }
+}
+
+impl Deref for EnvWithHandlerCfg {
+    type Target = Env;
+
+    fn deref(&self) -> &Self::Target {
+        &self.env
+    }
+}