Simple REVM test runner (#788)

* refactor: nuke `evm-adapters`

* refactor: simple revm test runner

Current features:

- Can run unit tests
- Works with both revert-type tests and DSTest-type tests
- Collects logs, albeit not for reverting tests
- Integrated with config and CLI flags

Disabled features:

- Gas reports
- Tracing
- Cheatcodes
- Fuzzing
- Log decoding
- Forking mode
- Hardhat-style `console.log`, since those require
  us to decode calls to a specific address (HH does
  not emit logs)
- The debugger

In addition to this, I've disabled some tests that
could never pass under the current circumstances,
but that should be adjusted and re-enabled when their
respective features are implemented (such as fuzz tests)

* refactor: adjust CLI to new runner API

* feat: log collector inspector

* feat: hardhat logs

* chore: lint

* refactor: extract hh log converter to helper fn

* refactor: return single test result if setup fails

* build: use upstream revm

chore: renuke `evm-adapters`

Author: onbjerg

Cargo.lock

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-    "evm-adapters",
     "utils",
     "cast",
     "forge",
@@ -18,11 +17,6 @@ codegen-units = 1
 panic = "abort"
 debug = true
 
-## Patch sputnik with more recent primitive types
-# https://github.com/rust-blockchain/evm/pulls
-[patch."https://github.com/rust-blockchain/evm"]
-evm = { git = "https://github.com/gakonst/evm", branch = "bump-primitive-types" }
-
 ## Patch ethers-rs with a local checkout then run `cargo update -p ethers`
 #[patch."https://github.com/gakonst/ethers-rs"]
 #ethers = { path = "../ethers-rs" }

Cargo.toml

@@ -26,8 +26,8 @@ foundry-utils = { path = "../utils" }
 forge = { path = "../forge" }
 foundry-config = { path = "../config" }
 cast = { path = "../cast" }
-evm-adapters = { path = "../evm-adapters" }
-ui = { path = "../ui" }
+# TODO: Re-enable when ported
+#ui = { path = "../ui" }
 dunce = "1.0.2"
 # ethers = "0.5"
 ethers = { git = "https://github.com/gakonst/ethers-rs", default-features = false }
@@ -46,9 +46,6 @@ rayon = "1.5.1"
 serde = "1.0.133"
 futures = "0.3.17"
 
-## EVM Implementations
-# evm = { version = "0.30.1" }
-sputnik = { package = "evm", git = "https://github.com/rust-blockchain/evm", default-features = false, features = ["std"], optional = true }
 proptest = "1.0.0"
 glob = "0.3.0"
 semver = "1.0.5"
@@ -68,17 +65,11 @@ pretty_assertions = "1.0.0"
 toml = "0.5"
 
 [features]
-default = ["sputnik-evm", "rustls"]
+default = ["rustls"]
 solc-asm = ["ethers/solc-sha2-asm"]
 rustls = ["ethers/rustls"]
 openssl = ["ethers/openssl"]
 
-sputnik-evm = [
-    "sputnik",
-    "evm-adapters/sputnik",
-    "evm-adapters/sputnik-helpers",
-]
-
 integration-tests = []
 
 [[bin]]

cli/Cargo.toml

@@ -47,7 +47,8 @@ pub mod init;
 pub mod inspect;
 pub mod install;
 pub mod remappings;
-pub mod run;
+// TODO: Re-enable when ported
+//pub mod run;
 pub mod snapshot;
 pub mod test;
 pub mod tree;

cli/src/cmd/mod.rs

@@ -7,11 +7,12 @@ use crate::{
 };
 use ansi_term::Colour;
 use clap::{AppSettings, Parser};
-use ethers::solc::{ArtifactOutput, ProjectCompileOutput};
-use evm_adapters::{
-    call_tracing::ExecutionInfo, evm_opts::EvmOpts, gas_report::GasReport, sputnik::helpers::vm,
+use ethers::{
+    abi::RawLog,
+    contract::EthLogDecode,
+    solc::{ArtifactOutput, ProjectCompileOutput},
 };
-use forge::{MultiContractRunnerBuilder, TestFilter, TestResult};
+use forge::{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};
@@ -187,13 +188,11 @@ impl Cmd for TestArgs {
         let output = super::compile(&project, false, false)?;
 
         // prepare the test builder
-        let mut evm_cfg = crate::utils::sputnik_cfg(&config.evm_version);
-        evm_cfg.create_contract_limit = None;
-
+        let mut evm_spec = crate::utils::evm_spec(&config.evm_version);
         let builder = MultiContractRunnerBuilder::default()
             .fuzzer(fuzzer)
             .initial_balance(evm_opts.initial_balance)
-            .evm_cfg(evm_cfg)
+            .evm_spec(evm_spec)
             .sender(evm_opts.sender);
 
         test(
@@ -347,11 +346,12 @@ fn test<A: ArtifactOutput + 'static>(
         println!("{}", res);
         Ok(TestOutcome::new(results, allow_failure))
     } else {
-        // Dapptools-style printing of test results
-        let mut gas_report = GasReport::new(gas_reports.1);
+        // TODO: Re-enable when ported
+        //let mut gas_report = GasReport::new(gas_reports.1);
         let (tx, rx) = channel::<(String, BTreeMap<String, TestResult>)>();
         let known_contracts = runner.known_contracts.clone();
-        let execution_info = runner.execution_info.clone();
+        // TODO: Re-enable when ported
+        //let execution_info = runner.execution_info.clone();
 
         let handle = thread::spawn(move || {
             while let Ok((contract_name, tests)) = rx.recv() {
@@ -366,13 +366,19 @@ fn test<A: ArtifactOutput + 'static>(
                     // output does not look like 1 big block.
                     let mut add_newline = false;
                     if verbosity > 1 && !result.logs.is_empty() {
-                        add_newline = true;
-                        println!("Logs:");
-                        for log in &result.logs {
-                            println!("  {}", log);
+                        // 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();
+
+                        if !console_logs.is_empty() {
+                            println!("Logs:");
+                            for log in console_logs {
+                                println!("  {}", log);
+                            }
                         }
                     }
-                    if verbosity > 2 {
+                    // TODO: Re-enable this when traces are ported
+                    /*if verbosity > 2 {
                         if let (Some(traces), Some(identified_contracts)) =
                             (&result.traces, &result.identified_contracts)
                         {
@@ -427,7 +433,7 @@ fn test<A: ArtifactOutput + 'static>(
                                 }
                             }
                         }
-                    }
+                    }*/
                     if add_newline {
                         println!();
                     }
@@ -439,7 +445,8 @@ fn test<A: ArtifactOutput + 'static>(
 
         handle.join().unwrap();
 
-        if gas_reporting {
+        // TODO: Re-enable when ported
+        /*if gas_reporting {
             for tests in results.values() {
                 for result in tests.values() {
                     if let (Some(traces), Some(identified_contracts)) =
@@ -451,7 +458,45 @@ fn test<A: ArtifactOutput + 'static>(
             }
             gas_report.finalize();
             println!("{}", gas_report);
-        }
+        }*/
         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

@@ -36,9 +36,10 @@ fn main() -> eyre::Result<()> {
                 cmd.run()?;
             }
         }
-        Subcommands::Run(cmd) => {
-            cmd.run()?;
-        }
+        // TODO: Re-enable when ported
+        //Subcommands::Run(cmd) => {
+        //    cmd.run()?;
+        //}
         Subcommands::VerifyContract(args) => {
             utils::block_on(cmd::verify::run_verify(&args))?;
         }

cli/src/forge.rs

@@ -1,7 +1,6 @@
 //! cli arguments for configuring the evm settings
 use clap::Parser;
 use ethers::types::{Address, U256};
-use evm_adapters::evm_opts::EvmType;
 use foundry_config::{
     figment::{
         self,
@@ -27,7 +26,7 @@ use serde::Serialize;
 //
 // ```ignore
 // use foundry_config::Config;
-// use evm_adapter::EvmOpts;
+// use forge::executor::opts::EvmOpts;
 // # fn t(args: EvmArgs) {
 // let figment = Config::figment_with_root(".").merge(args);
 // let opts = figment.extract::<EvmOpts>().unwrap()
@@ -40,14 +39,6 @@ pub struct EvmArgs {
     #[serde(flatten)]
     pub env: EnvArgs,
 
-    #[clap(
-        long,
-        short,
-        help = "the EVM type you want to use (e.g. sputnik)",
-        default_value = "sputnik"
-    )]
-    pub evm_type: EvmType,
-
     #[clap(help = "fetch state over a remote instead of starting from empty state", long, short)]
     #[clap(alias = "rpc-url")]
     #[serde(rename = "eth_rpc_url", skip_serializing_if = "Option::is_none")]
@@ -153,5 +144,4 @@ pub struct EnvArgs {
     #[clap(help = "the block.gaslimit value during EVM execution", long)]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub block_gas_limit: Option<u64>,
-    // TODO: Add configuration option for base fee.
 }

cli/src/opts/evm.rs

@@ -13,7 +13,6 @@ use crate::cmd::{
     inspect,
     install::InstallArgs,
     remappings::RemappingArgs,
-    run::RunArgs,
     snapshot, test, tree,
     verify::{VerifyArgs, VerifyCheckArgs},
 };
@@ -47,10 +46,10 @@ pub enum Subcommands {
     #[clap(alias = "b")]
     Build(BuildArgs),
 
-    #[clap(about = "Run a single smart contract as a script")]
-    #[clap(alias = "r")]
-    Run(RunArgs),
-
+    // TODO: Re-enable when ported
+    //#[clap(about = "Run a single smart contract as a script")]
+    //#[clap(alias = "r")]
+    //Run(RunArgs),
     #[clap(alias = "u", about = "Fetches all upstream lib changes")]
     Update {
         #[clap(

cli/src/opts/forge.rs

@@ -1,9 +1,8 @@
 use std::{future::Future, path::Path, str::FromStr, time::Duration};
 
 use ethers::{solc::EvmVersion, types::U256};
-#[cfg(feature = "sputnik-evm")]
-use sputnik::Config;
 
+use forge::executor::SpecId;
 // reexport all `foundry_config::utils`
 #[doc(hidden)]
 pub use foundry_config::utils::*;
@@ -58,12 +57,11 @@ pub fn subscriber() {
         .init();
 }
 
-#[cfg(feature = "sputnik-evm")]
-pub fn sputnik_cfg(evm: &EvmVersion) -> Config {
+pub fn evm_spec(evm: &EvmVersion) -> SpecId {
     match evm {
-        EvmVersion::Istanbul => Config::istanbul(),
-        EvmVersion::Berlin => Config::berlin(),
-        EvmVersion::London => Config::london(),
+        EvmVersion::Istanbul => SpecId::ISTANBUL,
+        EvmVersion::Berlin => SpecId::BERLIN,
+        EvmVersion::London => SpecId::LONDON,
         _ => panic!("Unsupported EVM version"),
     }
 }

cli/src/utils.rs

@@ -1,7 +1,7 @@
 //! Contains various tests for checking forge's commands
 use ansi_term::Colour;
 use ethers::solc::{artifacts::Metadata, ConfigurableContractArtifact};
-use evm_adapters::evm_opts::{EvmOpts, EvmType};
+use forge::executor::opts::EvmOpts;
 use foundry_cli_test_utils::{
     ethers_solc::{remappings::Remapping, PathStyle},
     forgetest, forgetest_ignore, forgetest_init, pretty_eq,
@@ -11,11 +11,7 @@ use foundry_config::{
     parse_with_profile, BasicConfig, Config, OptimizerDetails, SolidityErrorCode,
 };
 use pretty_assertions::assert_eq;
-use std::{
-    env::{self},
-    fs,
-    str::FromStr,
-};
+use std::{env, fs, str::FromStr};
 
 // import forge utils as mod
 #[allow(unused)]
@@ -245,9 +241,7 @@ forgetest_init!(can_get_evm_opts, |prj: TestProject, mut cmd: TestCommand| {
     assert!(config.ffi);
 
     cmd.set_env("FOUNDRY_ETH_RPC_URL", url);
-    let figment = Config::figment_with_root(prj.root())
-        .merge(("evm_type", EvmType::Sputnik))
-        .merge(("debug", false));
+    let figment = Config::figment_with_root(prj.root()).merge(("debug", false));
     let evm_opts: EvmOpts = figment.extract().unwrap();
     assert_eq!(evm_opts.fork_url, Some(url.to_string()));
 });