feat: introducing EvmWiring, a chain-specific configuration

bins/revme/src/cmd/evmrunner.rs

@@ -2,8 +2,8 @@ use revm::{
     db::BenchmarkDB,
     inspector_handle_register,
     inspectors::TracerEip3155,
-    primitives::{eof::EofDecodeError, Address, Bytecode, TxKind},
-    Evm,
+    primitives::{address, eof::EofDecodeError, Address, Bytecode, TxKind},
+    Database, Evm,
 };
 use std::io::Error as IoError;
 use std::path::PathBuf;
@@ -57,6 +57,8 @@ pub struct Cmd {
 impl Cmd {
     /// Run evm runner command.
     pub fn run(&self) -> Result<(), Errors> {
+        const CALLER: Address = address!("0000000000000000000000000000000000000001");
+
         let bytecode_str: Cow<'_, str> = if let Some(path) = &self.path {
             // check if path exists.
             if !path.exists() {
@@ -71,19 +73,21 @@ impl Cmd {
         let input = hex::decode(self.input.trim())
             .map_err(|_| Errors::InvalidInput)?
             .into();
+
+        let mut db = BenchmarkDB::new_bytecode(Bytecode::new_raw_checked(bytecode.into())?);
+
+        let nonce = db.basic(CALLER).unwrap().map_or(0, |account| account.nonce);
+
         // BenchmarkDB is dummy state that implements Database trait.
         // the bytecode is deployed at zero address.
         let mut evm = Evm::builder()
-            .with_db(BenchmarkDB::new_bytecode(Bytecode::new_raw_checked(
-                bytecode.into(),
-            )?))
+            .with_db(db)
             .modify_tx_env(|tx| {
                 // execution globals block hash/gas_limit/coinbase/timestamp..
-                tx.caller = "0x0000000000000000000000000000000000000001"
-                    .parse()
-                    .unwrap();
+                tx.caller = CALLER;
                 tx.transact_to = TxKind::Call(Address::ZERO);
                 tx.data = input;
+                tx.nonce = nonce;
             })
             .build();
 

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

@@ -28,6 +28,8 @@ use std::{
 use thiserror::Error;
 use walkdir::{DirEntry, WalkDir};
 
+type TestEvmWiring = revm::primitives::EthereumWiring;
+
 #[derive(Debug, Error)]
 #[error("Test {name} failed: {kind}")]
 pub struct TestError {
@@ -130,8 +132,8 @@ fn check_evm_execution<EXT>(
     test: &Test,
     expected_output: Option<&Bytes>,
     test_name: &str,
-    exec_result: &EVMResultGeneric<ExecutionResult, Infallible>,
-    evm: &Evm<'_, EXT, &mut State<EmptyDB>>,
+    exec_result: &EVMResultGeneric<ExecutionResult<TestEvmWiring>, TestEvmWiring, Infallible>,
+    evm: &Evm<'_, TestEvmWiring, EXT, &mut State<EmptyDB>>,
     print_json_outcome: bool,
 ) -> Result<(), TestError> {
     let logs_root = log_rlp_hash(exec_result.as_ref().map(|r| r.logs()).unwrap_or_default());
@@ -155,7 +157,7 @@ fn check_evm_execution<EXT>(
                     Err(e) => e.to_string(),
                 },
                 "postLogsHash": logs_root,
-                "fork": evm.handler.cfg().spec_id,
+                "fork": evm.handler.spec_id(),
                 "test": test_name,
                 "d": test.indexes.data,
                 "g": test.indexes.gas,
@@ -268,7 +270,7 @@ pub fn execute_test_suite(
             cache_state.insert_account_with_storage(address, acc_info, info.storage);
         }
 
-        let mut env = Box::<Env>::default();
+        let mut env = Box::<Env<TestEvmWiring>>::default();
         // for mainnet
         env.cfg.chain_id = 1;
         // env.cfg.spec_id is set down the road
@@ -336,6 +338,8 @@ pub fn execute_test_suite(
                     .get(test.indexes.data)
                     .unwrap()
                     .clone();
+
+                env.tx.nonce = u64::try_from(unit.transaction.nonce).unwrap();
                 env.tx.value = unit.transaction.value[test.indexes.value];
 
                 env.tx.access_list = unit
@@ -357,10 +361,7 @@ pub fn execute_test_suite(
                 env.tx.transact_to = to;
 
                 let mut cache = cache_state.clone();
-                cache.set_state_clear_flag(SpecId::enabled(
-                    spec_id,
-                    revm::primitives::SpecId::SPURIOUS_DRAGON,
-                ));
+                cache.set_state_clear_flag(SpecId::enabled(spec_id, SpecId::SPURIOUS_DRAGON));
                 let mut state = revm::db::State::builder()
                     .with_cached_prestate(cache)
                     .with_bundle_update()
@@ -426,10 +427,7 @@ pub fn execute_test_suite(
 
                 // re build to run with tracing
                 let mut cache = cache_state.clone();
-                cache.set_state_clear_flag(SpecId::enabled(
-                    spec_id,
-                    revm::primitives::SpecId::SPURIOUS_DRAGON,
-                ));
+                cache.set_state_clear_flag(SpecId::enabled(spec_id, SpecId::SPURIOUS_DRAGON));
                 let state = revm::db::State::builder()
                     .with_cached_prestate(cache)
                     .with_bundle_update()

crates/interpreter/Cargo.toml

@@ -24,6 +24,7 @@ all = "warn"
 [dependencies]
 revm-primitives = { path = "../primitives", version = "7.1.0", default-features = false }
 
+derive-where = { version = "1.2.7", default-features = false }
 paste = { version = "1.0", optional = true }
 phf = { version = "0.11", default-features = false, optional = true, features = [
     "macros",
@@ -51,14 +52,6 @@ portable = ["revm-primitives/portable"]
 parse = ["dep:paste", "dep:phf"]
 
 optimism = ["revm-primitives/optimism"]
-# Optimism default handler enabled Optimism handler register by default in EvmBuilder.
-optimism-default-handler = [
-    "optimism",
-    "revm-primitives/optimism-default-handler",
-]
-negate-optimism-default-handler = [
-    "revm-primitives/negate-optimism-default-handler",
-]
 
 dev = [
     "memory_limit",
@@ -68,6 +61,7 @@ dev = [
     "optional_gas_refund",
     "optional_no_base_fee",
     "optional_beneficiary_reward",
+    "optional_nonce_check",
 ]
 memory_limit = ["revm-primitives/memory_limit"]
 optional_balance_check = ["revm-primitives/optional_balance_check"]
@@ -76,5 +70,6 @@ optional_eip3607 = ["revm-primitives/optional_eip3607"]
 optional_gas_refund = ["revm-primitives/optional_gas_refund"]
 optional_no_base_fee = ["revm-primitives/optional_no_base_fee"]
 optional_beneficiary_reward = ["revm-primitives/optional_beneficiary_reward"]
+optional_nonce_check = ["revm-primitives/optional_nonce_check"]
 
 kzg-rs = ["revm-primitives/kzg-rs"]

crates/interpreter/src/gas/calc.rs

@@ -287,7 +287,7 @@ pub const fn selfdestruct_cost(spec_id: SpecId, res: SelfDestructResult) -> u64
 /// * Account access gas. after berlin it can be cold or warm.
 /// * Transfer value gas. If value is transferred and balance of target account is updated.
 /// * If account is not existing and needs to be created. After Spurious dragon
-/// this is only accounted if value is transferred.
+///   this is only accounted if value is transferred.
 #[inline]
 pub const fn call_cost(
     spec_id: SpecId,

crates/interpreter/src/host.rs

@@ -2,14 +2,18 @@ use crate::primitives::{Address, Bytes, Env, Log, B256, U256};
 
 mod dummy;
 pub use dummy::DummyHost;
+use revm_primitives::EvmWiring;
 
 /// EVM context host.
 pub trait Host {
+    /// Chain specification.
+    type EvmWiringT: EvmWiring;
+
     /// Returns a reference to the environment.
-    fn env(&self) -> &Env;
+    fn env(&self) -> &Env<Self::EvmWiringT>;
 
     /// Returns a mutable reference to the environment.
-    fn env_mut(&mut self) -> &mut Env;
+    fn env_mut(&mut self) -> &mut Env<Self::EvmWiringT>;
 
     /// Load an account.
     ///
@@ -84,13 +88,15 @@ pub struct SelfDestructResult {
 
 #[cfg(test)]
 mod tests {
+    use revm_primitives::{db::EmptyDB, EthereumWiring};
+
     use super::*;
 
     fn assert_host<H: Host + ?Sized>() {}
 
     #[test]
     fn object_safety() {
-        assert_host::<DummyHost>();
-        assert_host::<dyn Host>();
+        assert_host::<DummyHost<EthereumWiring<EmptyDB, ()>>>();
+        assert_host::<dyn Host<EvmWiringT = EthereumWiring<EmptyDB, ()>>>();
     }
 }

crates/interpreter/src/host/dummy.rs

@@ -1,27 +1,39 @@
+use derive_where::derive_where;
+
 use crate::{
-    primitives::{hash_map::Entry, Address, Bytes, Env, HashMap, Log, B256, KECCAK_EMPTY, U256},
+    primitives::{
+        hash_map::Entry, Address, Bytes, Env, EvmWiring, HashMap, Log, B256, KECCAK_EMPTY, U256,
+    },
     Host, SStoreResult, SelfDestructResult,
 };
 use std::vec::Vec;
 
 use super::LoadAccountResult;
 
 /// A dummy [Host] implementation.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct DummyHost {
-    pub env: Env,
+#[derive_where(Clone, Debug, Default; EvmWiringT::Block, EvmWiringT::Transaction)]
+pub struct DummyHost<EvmWiringT>
+where
+    EvmWiringT: EvmWiring,
+{
+    pub env: Env<EvmWiringT>,
     pub storage: HashMap<U256, U256>,
     pub transient_storage: HashMap<U256, U256>,
     pub log: Vec<Log>,
 }
 
-impl DummyHost {
+impl<EvmWiringT> DummyHost<EvmWiringT>
+where
+    EvmWiringT: EvmWiring,
+{
     /// Create a new dummy host with the given [`Env`].
     #[inline]
-    pub fn new(env: Env) -> Self {
+    pub fn new(env: Env<EvmWiringT>) -> Self {
         Self {
             env,
-            ..Default::default()
+            storage: HashMap::new(),
+            transient_storage: HashMap::new(),
+            log: Vec::new(),
         }
     }
 
@@ -33,14 +45,19 @@ impl DummyHost {
     }
 }
 
-impl Host for DummyHost {
+impl<EvmWiringT> Host for DummyHost<EvmWiringT>
+where
+    EvmWiringT: EvmWiring,
+{
+    type EvmWiringT = EvmWiringT;
+
     #[inline]
-    fn env(&self) -> &Env {
+    fn env(&self) -> &Env<Self::EvmWiringT> {
         &self.env
     }
 
     #[inline]
-    fn env_mut(&mut self) -> &mut Env {
+    fn env_mut(&mut self) -> &mut Env<Self::EvmWiringT> {
         &mut self.env
     }