REVM cheatcodes (#841)

* feat: add `InspectorStack`

Adds `InspectorStack`, an inspector that calls a stack
of other inspectors sequentially.

Closes #752

* feat: port cheatcodes to revm

* feat: port `expectCall` cheatcode

* feat: extract labels from cheatcode inspector

* feat: port `expectEmit` cheatcode

* refactor: move log decoding into `forge` crate

* chore: remove unused evm patch

* test: re-enable debug logs test

* fix: record reads on `SSTORE` ops

* refactor: rename `record` to `start_record`

* docs: clarify why `DUMMY_CALL_OUTPUT` is 320 bytes

* fix: handle `expectRevert` with no return data

* build: bump revm

* chore: remove outdated todo

* refactor: use static dispatch in `InspectorStack`

* build: use k256

* fix: make gas usage not so crazy

Author: onbjerg

Cargo.lock

@@ -12,7 +12,10 @@ use ethers::{
     contract::EthLogDecode,
     solc::{ArtifactOutput, ProjectCompileOutput},
 };
-use forge::{executor::opts::EvmOpts, MultiContractRunnerBuilder, TestFilter, TestResult};
+use forge::{
+    decode::decode_console_logs, executor::opts::EvmOpts, MultiContractRunnerBuilder, TestFilter,
+    TestResult,
+};
 use foundry_config::{figment::Figment, Config};
 use regex::Regex;
 use std::{collections::BTreeMap, str::FromStr, sync::mpsc::channel, thread};
@@ -367,9 +370,7 @@ fn test<A: ArtifactOutput + 'static>(
                     let mut add_newline = false;
                     if verbosity > 1 && !result.logs.is_empty() {
                         // We only decode logs from Hardhat and DS-style console events
-                        let console_logs: Vec<String> =
-                            result.logs.iter().filter_map(decode_console_log).collect();
-
+                        let console_logs = decode_console_logs(&result.logs);
                         if !console_logs.is_empty() {
                             println!("Logs:");
                             for log in console_logs {
@@ -462,41 +463,3 @@ fn test<A: ArtifactOutput + 'static>(
         Ok(TestOutcome::new(results, allow_failure))
     }
 }
-
-fn decode_console_log(log: &RawLog) -> Option<String> {
-    use forge::abi::ConsoleEvents::{self, *};
-
-    let decoded = match ConsoleEvents::decode_log(log).ok()? {
-        LogsFilter(inner) => format!("{}", inner.0),
-        LogBytesFilter(inner) => format!("{}", inner.0),
-        LogNamedAddressFilter(inner) => format!("{}: {:?}", inner.key, inner.val),
-        LogNamedBytes32Filter(inner) => {
-            format!("{}: 0x{}", inner.key, hex::encode(inner.val))
-        }
-        LogNamedDecimalIntFilter(inner) => {
-            let (sign, val) = inner.val.into_sign_and_abs();
-            format!(
-                "{}: {}{}",
-                inner.key,
-                sign,
-                ethers::utils::format_units(val, inner.decimals.as_u32()).unwrap()
-            )
-        }
-        LogNamedDecimalUintFilter(inner) => {
-            format!(
-                "{}: {}",
-                inner.key,
-                ethers::utils::format_units(inner.val, inner.decimals.as_u32()).unwrap()
-            )
-        }
-        LogNamedIntFilter(inner) => format!("{}: {:?}", inner.key, inner.val),
-        LogNamedUintFilter(inner) => format!("{}: {:?}", inner.key, inner.val),
-        LogNamedBytesFilter(inner) => {
-            format!("{}: 0x{}", inner.key, hex::encode(inner.val))
-        }
-        LogNamedStringFilter(inner) => format!("{}: {}", inner.key, inner.val),
-
-        e => e.to_string(),
-    };
-    Some(decoded)
-}

cli/src/cmd/test.rs

@@ -25,7 +25,7 @@ rlp = "0.5.1"
 
 bytes = "1.1.0"
 thiserror = "1.0.29"
-revm = { package = "revm", git = "https://github.com/bluealloy/revm", branch = "main" }
+revm = { package = "revm", git = "https://github.com/onbjerg/revm", branch = "onbjerg/blockhashes", default-features = false, features = ["std", "k256"] }
 hashbrown = "0.12"
 once_cell = "1.9.0"
 

forge/Cargo.toml

@@ -0,0 +1,48 @@
+//! Various utilities to decode test results
+use crate::abi::ConsoleEvents::{self, *};
+use ethers::{abi::RawLog, contract::EthLogDecode};
+
+/// Decode a set of logs, only returning logs from DSTest logging events and Hardhat's `console.log`
+pub fn decode_console_logs(logs: &[RawLog]) -> Vec<String> {
+    logs.iter().filter_map(decode_console_log).collect()
+}
+
+/// Decode a single log.
+///
+/// This function returns [None] if it is not a DSTest log or the result of a Hardhat
+/// `console.log`.
+pub fn decode_console_log(log: &RawLog) -> Option<String> {
+    let decoded = match ConsoleEvents::decode_log(log).ok()? {
+        LogsFilter(inner) => format!("{}", inner.0),
+        LogBytesFilter(inner) => format!("{}", inner.0),
+        LogNamedAddressFilter(inner) => format!("{}: {:?}", inner.key, inner.val),
+        LogNamedBytes32Filter(inner) => {
+            format!("{}: 0x{}", inner.key, hex::encode(inner.val))
+        }
+        LogNamedDecimalIntFilter(inner) => {
+            let (sign, val) = inner.val.into_sign_and_abs();
+            format!(
+                "{}: {}{}",
+                inner.key,
+                sign,
+                ethers::utils::format_units(val, inner.decimals.as_u32()).unwrap()
+            )
+        }
+        LogNamedDecimalUintFilter(inner) => {
+            format!(
+                "{}: {}",
+                inner.key,
+                ethers::utils::format_units(inner.val, inner.decimals.as_u32()).unwrap()
+            )
+        }
+        LogNamedIntFilter(inner) => format!("{}: {:?}", inner.key, inner.val),
+        LogNamedUintFilter(inner) => format!("{}: {:?}", inner.key, inner.val),
+        LogNamedBytesFilter(inner) => {
+            format!("{}: 0x{}", inner.key, hex::encode(inner.val))
+        }
+        LogNamedStringFilter(inner) => format!("{}: {}", inner.key, inner.val),
+
+        e => e.to_string(),
+    };
+    Some(decoded)
+}

forge/src/decode.rs

@@ -2,6 +2,47 @@ use ethers::types::{Address, Selector};
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
 
+/// The cheatcode handler address.
+///
+/// This is the same address as the one used in DappTools's HEVM.
+pub static CHEATCODE_ADDRESS: Lazy<Address> = Lazy::new(|| {
+    Address::from_slice(&hex::decode("7109709ECfa91a80626fF3989D68f67F5b1DD12D").unwrap())
+});
+
+// Bindings for cheatcodes
+ethers::contract::abigen!(
+    HEVM,
+    r#"[
+            roll(uint256)
+            warp(uint256)
+            fee(uint256)
+            store(address,bytes32,bytes32)
+            load(address,bytes32)(bytes32)
+            ffi(string[])(bytes)
+            addr(uint256)(address)
+            sign(uint256,bytes32)(uint8,bytes32,bytes32)
+            prank(address)
+            startPrank(address)
+            prank(address,address)
+            startPrank(address,address)
+            stopPrank()
+            deal(address,uint256)
+            etch(address,bytes)
+            expectRevert(bytes)
+            expectRevert(bytes4)
+            record()
+            accesses(address)(bytes32[],bytes32[])
+            expectEmit(bool,bool,bool,bool)
+            mockCall(address,bytes,bytes)
+            clearMockedCalls()
+            expectCall(address,bytes)
+            getCode(string)
+            label(address,string)
+            assume(bool)
+    ]"#,
+);
+pub use hevm_mod::{HEVMCalls, HEVM_ABI};
+
 /// The Hardhat console address.
 ///
 /// See: https://github.com/nomiclabs/hardhat/blob/master/packages/hardhat-core/console.sol

forge/src/executor/abi.rs

@@ -1,46 +1,44 @@
 use revm::{db::EmptyDB, Env, SpecId};
 
-use super::Executor;
+use super::{inspector::InspectorStackConfig, Executor};
 
 #[derive(Default)]
 pub struct ExecutorBuilder {
-    /// Whether or not cheatcodes are enabled
-    cheatcodes: bool,
-    /// Whether or not the FFI cheatcode is enabled
-    ffi: bool,
     /// The execution environment configuration.
-    config: Env,
+    env: Env,
+    /// The configuration used to build an [InspectorStack].
+    inspector_config: InspectorStackConfig,
 }
 
 impl ExecutorBuilder {
     #[must_use]
     pub fn new() -> Self {
-        Self { cheatcodes: false, ffi: false, config: Env::default() }
+        Default::default()
     }
 
     /// Enables cheatcodes on the executor.
     #[must_use]
     pub fn with_cheatcodes(mut self, ffi: bool) -> Self {
-        self.cheatcodes = true;
-        self.ffi = ffi;
+        self.inspector_config.cheatcodes = true;
+        self.inspector_config.ffi = ffi;
         self
     }
 
     pub fn with_spec(mut self, spec: SpecId) -> Self {
-        self.config.cfg.spec_id = spec;
+        self.env.cfg.spec_id = spec;
         self
     }
 
     /// Configure the execution environment (gas limit, chain spec, ...)
     #[must_use]
-    pub fn with_config(mut self, config: Env) -> Self {
-        self.config = config;
+    pub fn with_config(mut self, env: Env) -> Self {
+        self.env = env;
         self
     }
 
     /// Builds the executor as configured.
     pub fn build(self) -> Executor<EmptyDB> {
-        Executor::new(EmptyDB(), self.config)
+        Executor::new(EmptyDB(), self.env, self.inspector_config)
     }
 
     // TODO: add with_traces

forge/src/executor/builder.rs

@@ -1,7 +1,5 @@
 mod strategies;
 
-// TODO Port when we have cheatcodes again
-//use crate::{Evm, ASSUME_MAGIC_RETURN_CODE};
 use crate::executor::{Executor, RawCallResult};
 use ethers::{
     abi::{Abi, Function},
@@ -11,10 +9,13 @@ use revm::{db::DatabaseRef, Return};
 use strategies::fuzz_calldata;
 
 pub use proptest::test_runner::{Config as FuzzConfig, Reason};
-use proptest::test_runner::{TestError, TestRunner};
+use proptest::test_runner::{TestCaseError, TestError, TestRunner};
 use serde::{Deserialize, Serialize};
 use std::cell::RefCell;
 
+/// Magic return code for the `assume` cheatcode
+pub const ASSUME_MAGIC_RETURN_CODE: &[u8] = "FOUNDRY::ASSUME".as_bytes();
+
 /// Wrapper around an [`Executor`] which provides fuzzing support using [`proptest`](https://docs.rs/proptest/1.0.0/proptest/).
 ///
 /// After instantiation, calling `fuzz` will proceed to hammer the deployed smart contract with
@@ -69,13 +70,12 @@ where
                     .expect("could not make raw evm call");
 
                 // When assume cheat code is triggered return a special string "FOUNDRY::ASSUME"
-                // TODO: Re-implement when cheatcodes are ported
-                /*if returndata.as_ref() == ASSUME_MAGIC_RETURN_CODE {
-                    let _ = return_reason.borrow_mut().insert(reason);
+                if result.as_ref() == ASSUME_MAGIC_RETURN_CODE {
+                    *return_reason.borrow_mut() = Some(status);
                     let err = "ASSUME: Too many rejects";
-                    let _ = revert_reason.borrow_mut().insert(err.to_string());
-                    return Err(TestCaseError::Reject(err.into()));
-                }*/
+                    *revert_reason.borrow_mut() = Some(err.to_string());
+                    return Err(TestCaseError::Reject(err.into()))
+                }
 
                 let success = self.executor.is_success(
                     address,