wip

Author: klkvr

Cargo.lock

@@ -189,16 +189,17 @@ foundry-linking = { path = "crates/linking" }
 # solc & compilation utilities
 foundry-block-explorers = { version = "0.11.0", default-features = false }
 foundry-compilers = { version = "0.13.3", default-features = false }
-foundry-fork-db = "0.12"
+foundry-fork-db = { git = "https://github.com/foundry-rs/foundry-fork-db", rev = "e60b89c" }
 solang-parser = "=0.3.3"
 solar-parse = { version = "=0.1.1", default-features = false }
 
 ## revm
-revm = { version = "19.4.0", default-features = false }
+revm = { version = "20.0.0-alpha.3", default-features = false }
 revm-primitives = { version = "15.1.0", default-features = false }
 revm-inspectors = { version = "0.16.0", features = ["serde"] }
 
 ## alloy
+alloy-evm = { path = "../evm/crates/evm" }
 alloy-consensus = { version = "0.12.1", default-features = false }
 alloy-contract = { version = "0.12.1", default-features = false }
 alloy-eips = { version = "0.12.1", default-features = false }
@@ -316,6 +317,8 @@ vergen = { version = "8", default-features = false }
 yansi = { version = "1.0", features = ["detect-tty", "detect-env"] }
 
 [patch.crates-io]
+revm = { git = "https://github.com/bluealloy/revm", rev = "9e39df5" }
+revm-inspectors = { git = "https://github.com/paradigmxyz/revm-inspectors", rev = "2a365e3" }
 ## alloy-core
 # alloy-dyn-abi = { path = "../../alloy-rs/core/crates/dyn-abi" }
 # alloy-json-abi = { path = "../../alloy-rs/core/crates/json-abi" }

Cargo.toml

@@ -33,7 +33,7 @@ use foundry_evm_core::{
     abi::Vm::stopExpectSafeMemoryCall,
     backend::{DatabaseError, DatabaseExt, RevertDiagnostic},
     constants::{CHEATCODE_ADDRESS, HARDHAT_CONSOLE_ADDRESS, MAGIC_ASSUME},
-    utils::new_evm_with_existing_context,
+    utils::new_evm_with_context,
     InspectorExt,
 };
 use foundry_evm_traces::{TracingInspector, TracingInspectorConfig};
@@ -161,7 +161,7 @@ where
         l1_block_info,
     };
 
-    let mut evm = new_evm_with_existing_context(inner, &mut *inspector);
+    let mut evm = new_evm_with_context(inner, &mut *inspector);
 
     let res = f(&mut evm)?;
 
@@ -1368,7 +1368,7 @@ impl Inspector<&mut dyn DatabaseExt> for Cheatcodes {
                             outcome.result.output = error.abi_encode().into();
                             outcome
                         }
-                    }
+                    };
                 } else {
                     // Call didn't revert, reset `assume_no_revert` state.
                     self.assume_no_revert = None;
@@ -1820,7 +1820,7 @@ impl Cheatcodes {
         let (key, target_address) = if interpreter.current_opcode() == op::SLOAD {
             (try_or_return!(interpreter.stack().peek(0)), interpreter.contract().target_address)
         } else {
-            return
+            return;
         };
 
         let Ok(value) = ecx.sload(target_address, key) else {

crates/cheatcodes/src/inspector.rs

@@ -19,6 +19,7 @@ foundry-common.workspace = true
 foundry-config.workspace = true
 foundry-evm-abi.workspace = true
 
+alloy-evm.workspace = true
 alloy-dyn-abi = { workspace = true, features = ["arbitrary", "eip712"] }
 alloy-genesis.workspace = true
 alloy-json-abi.workspace = true
@@ -43,7 +44,6 @@ revm = { workspace = true, features = [
     "optional_block_gas_limit",
     "optional_no_base_fee",
     "arbitrary",
-    "optimism",
     "c-kzg",
     "blst",
 ] }

crates/evm/core/Cargo.toml

@@ -1,25 +1,22 @@
 //! A wrapper around `Backend` that is clone-on-write used for fuzzing.
 
-use super::BackendError;
+use super::{BackendError, JournaledState};
 use crate::{
     backend::{
         diagnostic::RevertDiagnostic, Backend, DatabaseExt, LocalForkId, RevertStateSnapshotAction,
-    },
-    fork::{CreateFork, ForkId},
-    InspectorExt,
+    }, fork::{CreateFork, ForkId}, AsEnvMut, Env, EnvMut, InspectorExt
 };
 use alloy_genesis::GenesisAccount;
 use alloy_primitives::{Address, B256, U256};
 use alloy_rpc_types::TransactionRequest;
 use eyre::WrapErr;
 use foundry_fork_db::DatabaseError;
 use revm::{
-    db::DatabaseRef,
-    primitives::{
-        Account, AccountInfo, Bytecode, Env, EnvWithHandlerCfg, HashMap as Map, ResultAndState,
-        SpecId,
-    },
-    Database, DatabaseCommit, JournaledState,
+    context::{result::ResultAndState, JournalInit},
+    database::DatabaseRef,
+    primitives::{hardfork::SpecId, HashMap as Map},
+    state::{Account, AccountInfo, Bytecode},
+    Database, DatabaseCommit, ExecuteEvm,
 };
 use std::{borrow::Cow, collections::BTreeMap};
 
@@ -64,7 +61,7 @@ impl<'a> CowBackend<'a> {
     #[instrument(name = "inspect", level = "debug", skip_all)]
     pub fn inspect<I: InspectorExt>(
         &mut self,
-        env: &mut EnvWithHandlerCfg,
+        env: &mut Env,
         inspector: &mut I,
     ) -> eyre::Result<ResultAndState> {
         // this is a new call to inspect with a new env, so even if we've cloned the backend
@@ -73,9 +70,9 @@ impl<'a> CowBackend<'a> {
         self.spec_id = env.handler_cfg.spec_id;
         let mut evm = crate::utils::new_evm_with_inspector(self, env.clone(), inspector);
 
-        let res = evm.transact().wrap_err("EVM error")?;
+        let res = evm.replay().wrap_err("EVM error")?;
 
-        env.env = evm.context.evm.inner.env;
+        *env = evm.data.ctx.as_env_mut().to_owned();
 
         Ok(res)
     }
@@ -90,45 +87,47 @@ impl<'a> CowBackend<'a> {
     /// Returns a mutable instance of the Backend.
     ///
     /// If this is the first time this is called, the backed is cloned and initialized.
-    fn backend_mut(&mut self, env: &Env) -> &mut Backend {
+    fn backend_mut(&mut self, env: EnvMut<'_>) -> &mut Backend {
+        let env = env.as_env_mut().to_owned();
         if !self.is_initialized {
             let backend = self.backend.to_mut();
-            let env = EnvWithHandlerCfg::new_with_spec_id(Box::new(env.clone()), self.spec_id);
+            let mut env = env.to_owned();
+            env.evm_env.spec = self.spec_id;
             backend.initialize(&env);
             self.is_initialized = true;
-            return backend
+            return backend;
         }
         self.backend.to_mut()
     }
 
     /// Returns a mutable instance of the Backend if it is initialized.
     fn initialized_backend_mut(&mut self) -> Option<&mut Backend> {
         if self.is_initialized {
-            return Some(self.backend.to_mut())
+            return Some(self.backend.to_mut());
         }
         None
     }
 }
 
 impl DatabaseExt for CowBackend<'_> {
-    fn snapshot_state(&mut self, journaled_state: &JournaledState, env: &Env) -> U256 {
+    fn snapshot_state(&mut self, journaled_state: &JournaledState<'_>, env: &Env) -> U256 {
         self.backend_mut(env).snapshot_state(journaled_state, env)
     }
 
     fn revert_state(
         &mut self,
         id: U256,
-        journaled_state: &JournaledState,
-        current: &mut Env,
+        journaled_state: &JournaledState<'_>,
+        current: EnvMut<'_>,
         action: RevertStateSnapshotAction,
-    ) -> Option<JournaledState> {
+    ) -> Option<JournalInit> {
         self.backend_mut(current).revert_state(id, journaled_state, current, action)
     }
 
     fn delete_state_snapshot(&mut self, id: U256) -> bool {
         // delete state snapshot requires a previous snapshot to be initialized
         if let Some(backend) = self.initialized_backend_mut() {
-            return backend.delete_state_snapshot(id)
+            return backend.delete_state_snapshot(id);
         }
         false
     }
@@ -154,38 +153,38 @@ impl DatabaseExt for CowBackend<'_> {
     fn select_fork(
         &mut self,
         id: LocalForkId,
-        env: &mut Env,
-        journaled_state: &mut JournaledState,
+        env: EnvMut<'_>,
+        journaled_state: &mut JournaledState<'_>,
     ) -> eyre::Result<()> {
-        self.backend_mut(env).select_fork(id, env, journaled_state)
+        self.backend_mut(&mut env).select_fork(id, env, journaled_state)
     }
 
     fn roll_fork(
         &mut self,
         id: Option<LocalForkId>,
         block_number: u64,
-        env: &mut Env,
-        journaled_state: &mut JournaledState,
+        env: EnvMut<'_>,
+        journaled_state: &mut JournaledState<'_>,
     ) -> eyre::Result<()> {
-        self.backend_mut(env).roll_fork(id, block_number, env, journaled_state)
+        self.backend_mut(env.as_env_mut()).roll_fork(id, block_number, env, journaled_state)
     }
 
     fn roll_fork_to_transaction(
         &mut self,
         id: Option<LocalForkId>,
         transaction: B256,
-        env: &mut Env,
-        journaled_state: &mut JournaledState,
+        mut env: EnvMut<'_>,
+        journaled_state: &mut JournaledState<'_>,
     ) -> eyre::Result<()> {
-        self.backend_mut(env).roll_fork_to_transaction(id, transaction, env, journaled_state)
+        self.backend_mut(env.as_env_mut()).roll_fork_to_transaction(id, transaction, env, journaled_state)
     }
 
     fn transact(
         &mut self,
         id: Option<LocalForkId>,
         transaction: B256,
         env: Env,
-        journaled_state: &mut JournaledState,
+        journaled_state: &mut JournaledState<'_>,
         inspector: &mut dyn InspectorExt,
     ) -> eyre::Result<()> {
         self.backend_mut(&env).transact(id, transaction, env, journaled_state, inspector)
@@ -195,7 +194,7 @@ impl DatabaseExt for CowBackend<'_> {
         &mut self,
         transaction: &TransactionRequest,
         env: Env,
-        journaled_state: &mut JournaledState,
+        journaled_state: &mut JournaledState<'_>,
         inspector: &mut dyn InspectorExt,
     ) -> eyre::Result<()> {
         self.backend_mut(&env).transact_from_tx(transaction, env, journaled_state, inspector)
@@ -220,15 +219,15 @@ impl DatabaseExt for CowBackend<'_> {
     fn diagnose_revert(
         &self,
         callee: Address,
-        journaled_state: &JournaledState,
+        journaled_state: &JournaledState<'_>,
     ) -> Option<RevertDiagnostic> {
         self.backend.diagnose_revert(callee, journaled_state)
     }
 
     fn load_allocs(
         &mut self,
         allocs: &BTreeMap<Address, GenesisAccount>,
-        journaled_state: &mut JournaledState,
+        journaled_state: &mut JournaledState<'_>,
     ) -> Result<(), BackendError> {
         self.backend_mut(&Env::default()).load_allocs(allocs, journaled_state)
     }
@@ -237,7 +236,7 @@ impl DatabaseExt for CowBackend<'_> {
         &mut self,
         source: &GenesisAccount,
         target: &Address,
-        journaled_state: &mut JournaledState,
+        journaled_state: &mut JournaledState<'_>,
     ) -> Result<(), BackendError> {
         self.backend_mut(&Env::default()).clone_account(source, target, journaled_state)
     }

crates/evm/core/src/backend/cow.rs

@@ -1,7 +1,7 @@
 use alloy_primitives::Address;
 pub use foundry_fork_db::{DatabaseError, DatabaseResult};
-use revm::primitives::EVMError;
-use std::convert::Infallible;
+use revm::context::result::EVMError;
+use std::{convert::Infallible, fmt::Display};
 
 pub type BackendResult<T> = Result<T, BackendError>;
 
@@ -53,8 +53,8 @@ impl From<Infallible> for BackendError {
 }
 
 // Note: this is mostly necessary to use some revm internals that return an [EVMError]
-impl<T: Into<Self>> From<EVMError<T>> for BackendError {
-    fn from(err: EVMError<T>) -> Self {
+impl<T: Into<Self>, TxError: Display> From<EVMError<T, TxError>> for BackendError {
+    fn from(err: EVMError<T, TxError>) -> Self {
         match err {
             EVMError::Database(err) => err.into(),
             EVMError::Custom(err) => Self::msg(err),

crates/evm/core/src/backend/error.rs

@@ -4,8 +4,9 @@ use crate::state_snapshot::StateSnapshots;
 use alloy_primitives::{Address, B256, U256};
 use foundry_fork_db::DatabaseError;
 use revm::{
-    db::{CacheDB, DatabaseRef, EmptyDB},
-    primitives::{Account, AccountInfo, Bytecode, HashMap as Map},
+    database::{CacheDB, DatabaseRef, EmptyDB},
+    primitives::HashMap as Map,
+    state::{Account, AccountInfo, Bytecode},
     Database, DatabaseCommit,
 };