test

.gitignore

@@ -10,4 +10,4 @@ node_modules
 
 profile.json.gz
 resolc-compiler-tests
-workdir
+workdir

Cargo.lock

@@ -4501,12 +4501,9 @@ name = "revive-dt-config"
 version = "0.1.0"
 dependencies = [
  "alloy",
- "anyhow",
  "clap",
  "semver 1.0.26",
  "serde",
- "serde_json",
- "strum",
  "temp-dir",
 ]
 
@@ -4521,6 +4518,7 @@ dependencies = [
  "clap",
  "futures",
  "indexmap 2.10.0",
+ "once_cell",
  "revive-dt-common",
  "revive-dt-compiler",
  "revive-dt-config",
@@ -4531,6 +4529,8 @@ dependencies = [
  "semver 1.0.26",
  "serde",
  "serde_json",
+ "temp-dir",
+ "tempfile",
  "tokio",
  "tracing",
  "tracing-appender",
@@ -4588,20 +4588,13 @@ dependencies = [
 name = "revive-dt-report"
 version = "0.1.0"
 dependencies = [
- "alloy-primitives",
  "anyhow",
- "indexmap 2.10.0",
- "paste",
  "revive-dt-common",
  "revive-dt-compiler",
  "revive-dt-config",
  "revive-dt-format",
- "semver 1.0.26",
  "serde",
  "serde_json",
- "serde_with",
- "tokio",
- "tracing",
 ]
 
 [[package]]
@@ -4852,30 +4845,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "schemars"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
-dependencies = [
- "dyn-clone",
- "ref-cast",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "schemars"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
-dependencies = [
- "dyn-clone",
- "ref-cast",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "schnellru"
 version = "0.2.4"
@@ -5106,17 +5075,15 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.14.0"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2c45cd61fefa9db6f254525d46e392b852e0e61d9a1fd36e5bd183450a556d5"
+checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa"
 dependencies = [
  "base64 0.22.1",
  "chrono",
  "hex",
  "indexmap 1.9.3",
  "indexmap 2.10.0",
- "schemars 0.9.0",
- "schemars 1.0.4",
  "serde",
  "serde_derive",
  "serde_json",
@@ -5126,9 +5093,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.14.0"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de90945e6565ce0d9a25098082ed4ee4002e047cb59892c318d66821e14bb30f"
+checksum = "8d00caa5193a3c8362ac2b73be6b9e768aa5a4b2f721d8f4b339600c3cb51f8e"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -5692,9 +5659,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "strum"
-version = "0.27.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
 dependencies = [
  "strum_macros",
 ]

Cargo.toml

@@ -34,7 +34,6 @@ futures = { version = "0.3.31" }
 hex = "0.4.3"
 regex = "1"
 moka = "0.12.10"
-paste = "1.0.15"
 reqwest = { version = "0.12.15", features = ["json"] }
 once_cell = "1.21"
 semver = { version = "1.0", features = ["serde"] }
@@ -44,11 +43,9 @@ serde_json = { version = "1.0", default-features = false, features = [
     "std",
     "unbounded_depth",
 ] }
-serde_with = { version = "3.14.0" }
 sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"
 sp-runtime = "41.1.0"
-strum = { version = "0.27.2", features = ["derive"] }
 temp-dir = { version = "0.1.16" }
 tempfile = "3.3"
 thiserror = "2"

README.md

@@ -187,11 +187,10 @@ The above corpus file instructs the tool to look for all of the test cases conta
 The simplest command to run this tool is the following:
 
 ```bash
-RUST_LOG="info" cargo run --release -- execute-tests \
-    --follower geth \
+RUST_LOG="info" cargo run --release -- \
     --corpus path_to_your_corpus_file.json \
-    --working-directory path_to_a_temporary_directory_to_cache_things_in \
-    --concurrency.number-of-nodes 5 \
+    --workdir path_to_a_temporary_directory_to_cache_things_in \
+    --number-of-nodes 5 \
     > logs.log \
     2> output.log
 ```

crates/common/src/fs/clear_dir.rs

@@ -3,28 +3,19 @@ use std::{
     path::Path,
 };
 
-use anyhow::{Context, Result};
+use anyhow::Result;
 
 /// This method clears the passed directory of all of the files and directories contained within
 /// without deleting the directory.
 pub fn clear_directory(path: impl AsRef<Path>) -> Result<()> {
-    for entry in read_dir(path.as_ref())
-        .with_context(|| format!("Failed to read directory: {}", path.as_ref().display()))?
-    {
-        let entry = entry.with_context(|| {
-            format!(
-                "Failed to read an entry in directory: {}",
-                path.as_ref().display()
-            )
-        })?;
+    for entry in read_dir(path.as_ref())? {
+        let entry = entry?;
         let entry_path = entry.path();
 
         if entry_path.is_file() {
-            remove_file(&entry_path)
-                .with_context(|| format!("Failed to remove file: {}", entry_path.display()))?
+            remove_file(entry_path)?
         } else {
-            remove_dir_all(&entry_path)
-                .with_context(|| format!("Failed to remove directory: {}", entry_path.display()))?
+            remove_dir_all(entry_path)?
         }
     }
     Ok(())

crates/common/src/futures/poll.rs

@@ -1,7 +1,7 @@
 use std::ops::ControlFlow;
 use std::time::Duration;
 
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{Result, anyhow};
 
 const EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION: Duration = Duration::from_secs(60);
 
@@ -38,10 +38,7 @@ where
             ));
         }
 
-        match future()
-            .await
-            .context("Polled future returned an error during polling loop")?
-        {
+        match future().await? {
             ControlFlow::Continue(()) => {
                 let next_wait_duration = match polling_wait_behavior {
                     PollingWaitBehavior::Constant(duration) => duration,

crates/common/src/iterators/either_iter.rs

@@ -1,21 +0,0 @@
-/// An iterator that could be either of two iterators.
-#[derive(Clone, Debug)]
-pub enum EitherIter<A, B> {
-    A(A),
-    B(B),
-}
-
-impl<A, B, T> Iterator for EitherIter<A, B>
-where
-    A: Iterator<Item = T>,
-    B: Iterator<Item = T>,
-{
-    type Item = T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self {
-            EitherIter::A(iter) => iter.next(),
-            EitherIter::B(iter) => iter.next(),
-        }
-    }
-}

crates/common/src/iterators/mod.rs

@@ -1,5 +1,3 @@
-mod either_iter;
 mod files_with_extension_iterator;
 
-pub use either_iter::*;
 pub use files_with_extension_iterator::*;

crates/common/src/macros/define_wrapper_type.rs

@@ -1,23 +1,12 @@
 #[macro_export]
 macro_rules! impl_for_wrapper {
     (Display, $ident: ident) => {
-        #[automatically_derived]
         impl std::fmt::Display for $ident {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 std::fmt::Display::fmt(&self.0, f)
             }
         }
     };
-    (FromStr, $ident: ident) => {
-        #[automatically_derived]
-        impl std::str::FromStr for $ident {
-            type Err = anyhow::Error;
-
-            fn from_str(s: &str) -> anyhow::Result<Self> {
-                s.parse().map(Self).map_err(Into::into)
-            }
-        }
-    };
 }
 
 /// Defines wrappers around types.

crates/common/src/types/mode.rs

@@ -3,7 +3,6 @@ use semver::Version;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 use std::str::FromStr;
-use std::sync::LazyLock;
 
 /// This represents a mode that a given test should be run with, if possible.
 ///
@@ -35,19 +34,14 @@ impl Display for Mode {
 
 impl Mode {
     /// Return all of the available mode combinations.
-    pub fn all() -> impl Iterator<Item = &'static Mode> {
-        static ALL_MODES: LazyLock<Vec<Mode>> = LazyLock::new(|| {
-            ModePipeline::test_cases()
-                .flat_map(|pipeline| {
-                    ModeOptimizerSetting::test_cases().map(move |optimize_setting| Mode {
-                        pipeline,
-                        optimize_setting,
-                        version: None,
-                    })
-                })
-                .collect::<Vec<_>>()
-        });
-        ALL_MODES.iter()
+    pub fn all() -> impl Iterator<Item = Mode> {
+        ModePipeline::test_cases().flat_map(|pipeline| {
+            ModeOptimizerSetting::test_cases().map(move |optimize_setting| Mode {
+                pipeline,
+                optimize_setting,
+                version: None,
+            })
+        })
     }
 
     /// Resolves the [`Mode`]'s solidity version requirement into a [`VersionOrRequirement`] if

crates/compiler/src/constants.rs

@@ -0,0 +1,4 @@
+use semver::Version;
+
+/// This is the first version of solc that supports the `--via-ir` flag / "viaIR" input JSON.
+pub const SOLC_VERSION_SUPPORTING_VIA_YUL_IR: Version = Version::new(0, 8, 13);

crates/compiler/src/lib.rs

@@ -3,6 +3,8 @@
 //! - Polkadot revive resolc compiler
 //! - Polkadot revive Wasm compiler
 
+mod constants;
+
 use std::{
     collections::HashMap,
     hash::Hash,
@@ -11,14 +13,13 @@ use std::{
 
 use alloy::json_abi::JsonAbi;
 use alloy_primitives::Address;
-use anyhow::{Context as _, Result};
 use semver::Version;
 use serde::{Deserialize, Serialize};
 
 use revive_common::EVMVersion;
 use revive_dt_common::cached_fs::read_to_string;
 use revive_dt_common::types::VersionOrRequirement;
-use revive_dt_config::{ResolcConfiguration, SolcConfiguration, WorkingDirectoryConfiguration};
+use revive_dt_config::Arguments;
 
 // Re-export this as it's a part of the compiler interface.
 pub use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
@@ -28,38 +29,36 @@ pub mod revive_resolc;
 pub mod solc;
 
 /// A common interface for all supported Solidity compilers.
-pub trait SolidityCompiler: Sized {
-    /// Instantiates a new compiler object.
-    ///
-    /// Based on the given [`Context`] and [`VersionOrRequirement`] this function instantiates a
-    /// new compiler object. Certain implementations of this trait might choose to cache cache the
-    /// compiler objects and return the same ones over and over again.
-    fn new(
-        context: impl AsRef<SolcConfiguration>
-        + AsRef<ResolcConfiguration>
-        + AsRef<WorkingDirectoryConfiguration>,
-        version: impl Into<Option<VersionOrRequirement>>,
-    ) -> impl Future<Output = Result<Self>>;
-
-    /// Returns the version of the compiler.
-    fn version(&self) -> &Version;
-
-    /// Returns the path of the compiler executable.
-    fn path(&self) -> &Path;
+pub trait SolidityCompiler {
+    /// Extra options specific to the compiler.
+    type Options: Default + PartialEq + Eq + Hash;
 
     /// The low-level compiler interface.
-    fn build(&self, input: CompilerInput) -> impl Future<Output = Result<CompilerOutput>>;
-
-    /// Does the compiler support the provided mode and version settings.
-    fn supports_mode(
+    fn build(
         &self,
-        optimizer_setting: ModeOptimizerSetting,
+        input: CompilerInput,
+        additional_options: Self::Options,
+    ) -> impl Future<Output = anyhow::Result<CompilerOutput>>;
+
+    fn new(solc_executable: PathBuf) -> Self;
+
+    fn get_compiler_executable(
+        config: &Arguments,
+        version: impl Into<VersionOrRequirement>,
+    ) -> impl Future<Output = anyhow::Result<PathBuf>>;
+
+    fn version(&self) -> impl Future<Output = anyhow::Result<Version>>;
+
+    /// Does the compiler support the provided mode and version settings?
+    fn supports_mode(
+        compiler_version: &Version,
+        optimize_setting: ModeOptimizerSetting,
         pipeline: ModePipeline,
     ) -> bool;
 }
 
 /// The generic compilation input configuration.
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CompilerInput {
     pub pipeline: Option<ModePipeline>,
     pub optimization: Option<ModeOptimizerSetting>,
@@ -80,12 +79,21 @@ pub struct CompilerOutput {
 }
 
 /// A generic builder style interface for configuring the supported compiler options.
-#[derive(Default)]
-pub struct Compiler {
+pub struct Compiler<T: SolidityCompiler> {
     input: CompilerInput,
+    additional_options: T::Options,
 }
 
-impl Compiler {
+impl Default for Compiler<solc::Solc> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> Compiler<T>
+where
+    T: SolidityCompiler,
+{
     pub fn new() -> Self {
         Self {
             input: CompilerInput {
@@ -98,6 +106,7 @@ impl Compiler {
                 libraries: Default::default(),
                 revert_string_handling: Default::default(),
             },
+            additional_options: T::Options::default(),
         }
     }
 
@@ -126,11 +135,10 @@ impl Compiler {
         self
     }
 
-    pub fn with_source(mut self, path: impl AsRef<Path>) -> Result<Self> {
-        self.input.sources.insert(
-            path.as_ref().to_path_buf(),
-            read_to_string(path.as_ref()).context("Failed to read the contract source")?,
-        );
+    pub fn with_source(mut self, path: impl AsRef<Path>) -> anyhow::Result<Self> {
+        self.input
+            .sources
+            .insert(path.as_ref().to_path_buf(), read_to_string(path.as_ref())?);
         Ok(self)
     }
 
@@ -156,6 +164,11 @@ impl Compiler {
         self
     }
 
+    pub fn with_additional_options(mut self, options: impl Into<T::Options>) -> Self {
+        self.additional_options = options.into();
+        self
+    }
+
     pub fn then(self, callback: impl FnOnce(Self) -> Self) -> Self {
         callback(self)
     }
@@ -164,12 +177,17 @@ impl Compiler {
         callback(self)
     }
 
-    pub async fn try_build(self, compiler: &impl SolidityCompiler) -> Result<CompilerOutput> {
-        compiler.build(self.input).await
+    pub async fn try_build(
+        self,
+        compiler_path: impl AsRef<Path>,
+    ) -> anyhow::Result<CompilerOutput> {
+        T::new(compiler_path.as_ref().to_path_buf())
+            .build(self.input, self.additional_options)
+            .await
     }
 
-    pub fn input(&self) -> &CompilerInput {
-        &self.input
+    pub fn input(&self) -> CompilerInput {
+        self.input.clone()
     }
 }
 

crates/compiler/src/revive_resolc.rs

@@ -3,78 +3,39 @@
 
 use std::{
     path::PathBuf,
-    process::Stdio,
-    sync::{Arc, LazyLock},
+    process::{Command, Stdio},
+    sync::LazyLock,
 };
 
 use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
-use revive_dt_config::{ResolcConfiguration, SolcConfiguration, WorkingDirectoryConfiguration};
+use revive_dt_config::Arguments;
 use revive_solc_json_interface::{
     SolcStandardJsonInput, SolcStandardJsonInputLanguage, SolcStandardJsonInputSettings,
     SolcStandardJsonInputSettingsOptimizer, SolcStandardJsonInputSettingsSelection,
     SolcStandardJsonOutput,
 };
 
-use crate::{
-    CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler, solc::Solc,
-};
+use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 
 use alloy::json_abi::JsonAbi;
-use anyhow::{Context as _, Result};
+use anyhow::Context;
 use semver::Version;
 use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
 
-/// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Resolc(Arc<ResolcInner>);
+// TODO: I believe that we need to also pass the solc compiler to resolc so that resolc uses the
+// specified solc compiler. I believe that currently we completely ignore the specified solc binary
+// when invoking resolc which doesn't seem right if we're using solc as a compiler frontend.
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct ResolcInner {
-    /// The internal solc compiler that the resolc compiler uses as a compiler frontend.
-    solc: Solc,
+/// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
+#[derive(Debug)]
+pub struct Resolc {
     /// Path to the `resolc` executable
     resolc_path: PathBuf,
 }
 
 impl SolidityCompiler for Resolc {
-    async fn new(
-        context: impl AsRef<SolcConfiguration>
-        + AsRef<ResolcConfiguration>
-        + AsRef<WorkingDirectoryConfiguration>,
-        version: impl Into<Option<VersionOrRequirement>>,
-    ) -> Result<Self> {
-        /// This is a cache of all of the resolc compiler objects. Since we do not currently support
-        /// multiple resolc compiler versions, so our cache is just keyed by the solc compiler and
-        /// its version to the resolc compiler.
-        static COMPILERS_CACHE: LazyLock<DashMap<Solc, Resolc>> = LazyLock::new(Default::default);
-
-        let resolc_configuration = AsRef::<ResolcConfiguration>::as_ref(&context);
-
-        let solc = Solc::new(&context, version)
-            .await
-            .context("Failed to create the solc compiler frontend for resolc")?;
-
-        Ok(COMPILERS_CACHE
-            .entry(solc.clone())
-            .or_insert_with(|| {
-                Self(Arc::new(ResolcInner {
-                    solc,
-                    resolc_path: resolc_configuration.path.clone(),
-                }))
-            })
-            .clone())
-    }
-
-    fn version(&self) -> &Version {
-        // We currently return the solc compiler version since we do not support multiple resolc
-        // compiler versions.
-        self.0.solc.version()
-    }
-
-    fn path(&self) -> &std::path::Path {
-        &self.0.resolc_path
-    }
+    type Options = Vec<String>;
 
     #[tracing::instrument(level = "debug", ret)]
     async fn build(
@@ -91,7 +52,8 @@ impl SolidityCompiler for Resolc {
             // resolc. So, we need to go back to this later once it's supported.
             revert_string_handling: _,
         }: CompilerInput,
-    ) -> Result<CompilerOutput> {
+        additional_options: Self::Options,
+    ) -> anyhow::Result<CompilerOutput> {
         if !matches!(pipeline, None | Some(ModePipeline::ViaYulIR)) {
             anyhow::bail!(
                 "Resolc only supports the Y (via Yul IR) pipeline, but the provided pipeline is {pipeline:?}"
@@ -138,7 +100,7 @@ impl SolidityCompiler for Resolc {
             },
         };
 
-        let mut command = AsyncCommand::new(self.path());
+        let mut command = AsyncCommand::new(&self.resolc_path);
         command
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
@@ -157,28 +119,18 @@ impl SolidityCompiler for Resolc {
                     .join(","),
             );
         }
-        let mut child = command
-            .spawn()
-            .with_context(|| format!("Failed to spawn resolc at {}", self.path().display()))?;
+        let mut child = command.spawn()?;
 
         let stdin_pipe = child.stdin.as_mut().expect("stdin must be piped");
-        let serialized_input = serde_json::to_vec(&input)
-            .context("Failed to serialize Standard JSON input for resolc")?;
-        stdin_pipe
-            .write_all(&serialized_input)
-            .await
-            .context("Failed to write Standard JSON to resolc stdin")?;
+        let serialized_input = serde_json::to_vec(&input)?;
+        stdin_pipe.write_all(&serialized_input).await?;
 
-        let output = child
-            .wait_with_output()
-            .await
-            .context("Failed while waiting for resolc process to finish")?;
+        let output = child.wait_with_output().await?;
         let stdout = output.stdout;
         let stderr = output.stderr;
 
         if !output.status.success() {
-            let json_in = serde_json::to_string_pretty(&input)
-                .context("Failed to pretty-print Standard JSON input for logging")?;
+            let json_in = serde_json::to_string_pretty(&input)?;
             let message = String::from_utf8_lossy(&stderr);
             tracing::error!(
                 status = %output.status,
@@ -189,14 +141,12 @@ impl SolidityCompiler for Resolc {
             anyhow::bail!("Compilation failed with an error: {message}");
         }
 
-        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout)
-            .map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to parse resolc JSON output: {e}\nstderr: {}",
-                    String::from_utf8_lossy(&stderr)
-                )
-            })
-            .context("Failed to parse resolc standard JSON output")?;
+        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout).map_err(|e| {
+            anyhow::anyhow!(
+                "failed to parse resolc JSON output: {e}\nstderr: {}",
+                String::from_utf8_lossy(&stderr)
+            )
+        })?;
 
         tracing::debug!(
             output = %serde_json::to_string(&parsed).unwrap(),
@@ -223,10 +173,7 @@ impl SolidityCompiler for Resolc {
 
         let mut compiler_output = CompilerOutput::default();
         for (source_path, contracts) in contracts.into_iter() {
-            let src_for_msg = source_path.clone();
-            let source_path = PathBuf::from(source_path)
-                .canonicalize()
-                .with_context(|| format!("Failed to canonicalize path {src_for_msg}"))?;
+            let source_path = PathBuf::from(source_path).canonicalize()?;
 
             let map = compiler_output.contracts.entry(source_path).or_default();
             for (contract_name, contract_information) in contracts.into_iter() {
@@ -234,41 +181,23 @@ impl SolidityCompiler for Resolc {
                     .evm
                     .and_then(|evm| evm.bytecode.clone())
                     .context("Unexpected - Contract compiled with resolc has no bytecode")?;
-                let abi = {
-                    let metadata = contract_information
-                        .metadata
-                        .as_ref()
-                        .context("No metadata found for the contract")?;
-                    let solc_metadata_str = match metadata {
-                        serde_json::Value::String(solc_metadata_str) => solc_metadata_str.as_str(),
-                        serde_json::Value::Object(metadata_object) => {
-                            let solc_metadata_value = metadata_object
-                                .get("solc_metadata")
-                                .context("Contract doesn't have a 'solc_metadata' field")?;
-                            solc_metadata_value
-                                .as_str()
-                                .context("The 'solc_metadata' field is not a string")?
-                        }
-                        serde_json::Value::Null
-                        | serde_json::Value::Bool(_)
-                        | serde_json::Value::Number(_)
-                        | serde_json::Value::Array(_) => {
-                            anyhow::bail!("Unsupported type of metadata {metadata:?}")
-                        }
-                    };
-                    let solc_metadata =
-                        serde_json::from_str::<serde_json::Value>(solc_metadata_str).context(
-                            "Failed to deserialize the solc_metadata as a serde_json generic value",
-                        )?;
-                    let output_value = solc_metadata
-                        .get("output")
-                        .context("solc_metadata doesn't have an output field")?;
-                    let abi_value = output_value
-                        .get("abi")
-                        .context("solc_metadata output doesn't contain an abi field")?;
-                    serde_json::from_value::<JsonAbi>(abi_value.clone())
-                        .context("ABI found in solc_metadata output is not valid ABI")?
-                };
+                let abi = contract_information
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.as_object())
+                    .and_then(|metadata| metadata.get("solc_metadata"))
+                    .and_then(|solc_metadata| solc_metadata.as_str())
+                    .and_then(|metadata| serde_json::from_str::<serde_json::Value>(metadata).ok())
+                    .and_then(|metadata| {
+                        metadata.get("output").and_then(|output| {
+                            output
+                                .get("abi")
+                                .and_then(|abi| serde_json::from_value::<JsonAbi>(abi.clone()).ok())
+                        })
+                    })
+                    .context(
+                        "Unexpected - Failed to get the ABI for a contract compiled with resolc",
+                    )?;
                 map.insert(contract_name, (bytecode.object, abi));
             }
         }
@@ -276,11 +205,94 @@ impl SolidityCompiler for Resolc {
         Ok(compiler_output)
     }
 
+    fn new(resolc_path: PathBuf) -> Self {
+        Resolc { resolc_path }
+    }
+
+    async fn get_compiler_executable(
+        config: &Arguments,
+        _version: impl Into<VersionOrRequirement>,
+    ) -> anyhow::Result<PathBuf> {
+        if !config.resolc.as_os_str().is_empty() {
+            return Ok(config.resolc.clone());
+        }
+
+        Ok(PathBuf::from("resolc"))
+    }
+
+    async fn version(&self) -> anyhow::Result<semver::Version> {
+        /// This is a cache of the path of the compiler to the version number of the compiler. We
+        /// choose to cache the version in this way rather than through a field on the struct since
+        /// compiler objects are being created all the time from the path and the compiler object is
+        /// not reused over time.
+        static VERSION_CACHE: LazyLock<DashMap<PathBuf, Version>> = LazyLock::new(Default::default);
+
+        match VERSION_CACHE.entry(self.resolc_path.clone()) {
+            dashmap::Entry::Occupied(occupied_entry) => Ok(occupied_entry.get().clone()),
+            dashmap::Entry::Vacant(vacant_entry) => {
+                let output = Command::new(self.resolc_path.as_path())
+                    .arg("--version")
+                    .stdout(Stdio::piped())
+                    .spawn()?
+                    .wait_with_output()?
+                    .stdout;
+
+                let output = String::from_utf8_lossy(&output);
+                let version_string = output
+                    .split("version ")
+                    .nth(1)
+                    .context("Version parsing failed")?
+                    .split("+")
+                    .next()
+                    .context("Version parsing failed")?;
+
+                let version = Version::parse(version_string)?;
+
+                vacant_entry.insert(version.clone());
+
+                Ok(version)
+            }
+        }
+    }
+
     fn supports_mode(
-        &self,
-        optimize_setting: ModeOptimizerSetting,
+        _compiler_version: &Version,
+        _optimize_setting: ModeOptimizerSetting,
         pipeline: ModePipeline,
     ) -> bool {
-        pipeline == ModePipeline::ViaYulIR && self.0.solc.supports_mode(optimize_setting, pipeline)
+        // We only support the Y (IE compile via Yul IR) mode here, which also means that we can
+        // only use solc version 0.8.13 and above. We must always compile via Yul IR as resolc
+        // needs this to translate to LLVM IR and then RISCV.
+
+        // Note: the original implementation of this function looked like the following:
+        // ```
+        // pipeline == ModePipeline::ViaYulIR && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
+        // ```
+        // However, that implementation is sadly incorrect since the version that's passed into this
+        // function is not the version of solc but the version of resolc. This is despite the fact
+        // that resolc depends on Solc for the initial Yul codegen. Therefore, we have skipped the
+        // version check until we do a better integrations between resolc and solc.
+        pipeline == ModePipeline::ViaYulIR
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained() {
+        // Arrange
+        let args = Arguments::default();
+        let path = Resolc::get_compiler_executable(&args, Version::new(0, 7, 6))
+            .await
+            .unwrap();
+        let compiler = Resolc::new(path);
+
+        // Act
+        let version = compiler.version().await;
+
+        // Assert
+        let _ = version.expect("Failed to get version");
     }
 }

crates/compiler/src/solc.rs

@@ -3,18 +3,19 @@
 
 use std::{
     path::PathBuf,
-    process::Stdio,
-    sync::{Arc, LazyLock},
+    process::{Command, Stdio},
+    sync::LazyLock,
 };
 
 use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
-use revive_dt_config::{ResolcConfiguration, SolcConfiguration, WorkingDirectoryConfiguration};
+use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
 
+use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 
-use anyhow::{Context as _, Result};
+use anyhow::Context;
 use foundry_compilers_artifacts::{
     output_selection::{
         BytecodeOutputSelection, ContractOutputSelection, EvmOutputSelection, OutputSelection,
@@ -25,64 +26,13 @@ use foundry_compilers_artifacts::{
 use semver::Version;
 use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Solc(Arc<SolcInner>);
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct SolcInner {
-    /// The path of the solidity compiler executable that this object uses.
+#[derive(Debug)]
+pub struct Solc {
     solc_path: PathBuf,
-    /// The version of the solidity compiler executable that this object uses.
-    solc_version: Version,
 }
 
 impl SolidityCompiler for Solc {
-    async fn new(
-        context: impl AsRef<SolcConfiguration>
-        + AsRef<ResolcConfiguration>
-        + AsRef<WorkingDirectoryConfiguration>,
-        version: impl Into<Option<VersionOrRequirement>>,
-    ) -> Result<Self> {
-        // This is a cache for the compiler objects so that whenever the same compiler version is
-        // requested the same object is returned. We do this as we do not want to keep cloning the
-        // compiler around.
-        static COMPILERS_CACHE: LazyLock<DashMap<(PathBuf, Version), Solc>> =
-            LazyLock::new(Default::default);
-
-        let working_directory_configuration =
-            AsRef::<WorkingDirectoryConfiguration>::as_ref(&context);
-        let solc_configuration = AsRef::<SolcConfiguration>::as_ref(&context);
-
-        // We attempt to download the solc binary. Note the following: this call does the version
-        // resolution for us. Therefore, even if the download didn't proceed, this function will
-        // resolve the version requirement into a canonical version of the compiler. It's then up
-        // to us to either use the provided path or not.
-        let version = version
-            .into()
-            .unwrap_or_else(|| solc_configuration.version.clone().into());
-        let (version, path) =
-            download_solc(working_directory_configuration.as_path(), version, false)
-                .await
-                .context("Failed to download/get path to solc binary")?;
-
-        Ok(COMPILERS_CACHE
-            .entry((path.clone(), version.clone()))
-            .or_insert_with(|| {
-                Self(Arc::new(SolcInner {
-                    solc_path: path,
-                    solc_version: version,
-                }))
-            })
-            .clone())
-    }
-
-    fn version(&self) -> &Version {
-        &self.0.solc_version
-    }
-
-    fn path(&self) -> &std::path::Path {
-        &self.0.solc_path
-    }
+    type Options = ();
 
     #[tracing::instrument(level = "debug", ret)]
     async fn build(
@@ -97,12 +47,15 @@ impl SolidityCompiler for Solc {
             libraries,
             revert_string_handling,
         }: CompilerInput,
-    ) -> Result<CompilerOutput> {
+        _: Self::Options,
+    ) -> anyhow::Result<CompilerOutput> {
+        let compiler_supports_via_ir = self.version().await? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
+
         // Be careful to entirely omit the viaIR field if the compiler does not support it,
         // as it will error if you provide fields it does not know about. Because
         // `supports_mode` is called prior to instantiating a compiler, we should never
         // ask for something which is invalid.
-        let via_ir = match (pipeline, self.compiler_supports_yul()) {
+        let via_ir = match (pipeline, compiler_supports_via_ir) {
             (pipeline, true) => pipeline.map(|p| p.via_yul_ir()),
             (_pipeline, false) => None,
         };
@@ -162,7 +115,7 @@ impl SolidityCompiler for Solc {
             },
         };
 
-        let mut command = AsyncCommand::new(self.path());
+        let mut command = AsyncCommand::new(&self.solc_path);
         command
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
@@ -181,25 +134,15 @@ impl SolidityCompiler for Solc {
                     .join(","),
             );
         }
-        let mut child = command
-            .spawn()
-            .with_context(|| format!("Failed to spawn solc at {}", self.path().display()))?;
+        let mut child = command.spawn()?;
 
         let stdin = child.stdin.as_mut().expect("should be piped");
-        let serialized_input = serde_json::to_vec(&input)
-            .context("Failed to serialize Standard JSON input for solc")?;
-        stdin
-            .write_all(&serialized_input)
-            .await
-            .context("Failed to write Standard JSON to solc stdin")?;
-        let output = child
-            .wait_with_output()
-            .await
-            .context("Failed while waiting for solc process to finish")?;
+        let serialized_input = serde_json::to_vec(&input)?;
+        stdin.write_all(&serialized_input).await?;
+        let output = child.wait_with_output().await?;
 
         if !output.status.success() {
-            let json_in = serde_json::to_string_pretty(&input)
-                .context("Failed to pretty-print Standard JSON input for logging")?;
+            let json_in = serde_json::to_string_pretty(&input)?;
             let message = String::from_utf8_lossy(&output.stderr);
             tracing::error!(
                 status = %output.status,
@@ -210,14 +153,12 @@ impl SolidityCompiler for Solc {
             anyhow::bail!("Compilation failed with an error: {message}");
         }
 
-        let parsed = serde_json::from_slice::<SolcOutput>(&output.stdout)
-            .map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to parse resolc JSON output: {e}\nstderr: {}",
-                    String::from_utf8_lossy(&output.stdout)
-                )
-            })
-            .context("Failed to parse solc standard JSON output")?;
+        let parsed = serde_json::from_slice::<SolcOutput>(&output.stdout).map_err(|e| {
+            anyhow::anyhow!(
+                "failed to parse resolc JSON output: {e}\nstderr: {}",
+                String::from_utf8_lossy(&output.stdout)
+            )
+        })?;
 
         // Detecting if the compiler output contained errors and reporting them through logs and
         // errors instead of returning the compiler output that might contain errors.
@@ -237,12 +178,7 @@ impl SolidityCompiler for Solc {
         for (contract_path, contracts) in parsed.contracts {
             let map = compiler_output
                 .contracts
-                .entry(contract_path.canonicalize().with_context(|| {
-                    format!(
-                        "Failed to canonicalize contract path {}",
-                        contract_path.display()
-                    )
-                })?)
+                .entry(contract_path.canonicalize()?)
                 .or_default();
             for (contract_name, contract_info) in contracts.into_iter() {
                 let source_code = contract_info
@@ -263,21 +199,110 @@ impl SolidityCompiler for Solc {
         Ok(compiler_output)
     }
 
+    fn new(solc_path: PathBuf) -> Self {
+        Self { solc_path }
+    }
+
+    async fn get_compiler_executable(
+        config: &Arguments,
+        version: impl Into<VersionOrRequirement>,
+    ) -> anyhow::Result<PathBuf> {
+        let path = download_solc(config.directory(), version, config.wasm).await?;
+        Ok(path)
+    }
+
+    async fn version(&self) -> anyhow::Result<semver::Version> {
+        /// This is a cache of the path of the compiler to the version number of the compiler. We
+        /// choose to cache the version in this way rather than through a field on the struct since
+        /// compiler objects are being created all the time from the path and the compiler object is
+        /// not reused over time.
+        static VERSION_CACHE: LazyLock<DashMap<PathBuf, Version>> = LazyLock::new(Default::default);
+
+        match VERSION_CACHE.entry(self.solc_path.clone()) {
+            dashmap::Entry::Occupied(occupied_entry) => Ok(occupied_entry.get().clone()),
+            dashmap::Entry::Vacant(vacant_entry) => {
+                // The following is the parsing code for the version from the solc version strings
+                // which look like the following:
+                // ```
+                // solc, the solidity compiler commandline interface
+                // Version: 0.8.30+commit.73712a01.Darwin.appleclang
+                // ```
+                let child = Command::new(self.solc_path.as_path())
+                    .arg("--version")
+                    .stdout(Stdio::piped())
+                    .spawn()?;
+                let output = child.wait_with_output()?;
+                let output = String::from_utf8_lossy(&output.stdout);
+                let version_line = output
+                    .split("Version: ")
+                    .nth(1)
+                    .context("Version parsing failed")?;
+                let version_string = version_line
+                    .split("+")
+                    .next()
+                    .context("Version parsing failed")?;
+
+                let version = Version::parse(version_string)?;
+
+                vacant_entry.insert(version.clone());
+
+                Ok(version)
+            }
+        }
+    }
+
     fn supports_mode(
-        &self,
+        compiler_version: &Version,
         _optimize_setting: ModeOptimizerSetting,
         pipeline: ModePipeline,
     ) -> bool {
         // solc 0.8.13 and above supports --via-ir, and less than that does not. Thus, we support mode E
         // (ie no Yul IR) in either case, but only support Y (via Yul IR) if the compiler is new enough.
         pipeline == ModePipeline::ViaEVMAssembly
-            || (pipeline == ModePipeline::ViaYulIR && self.compiler_supports_yul())
+            || (pipeline == ModePipeline::ViaYulIR
+                && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR)
     }
 }
 
-impl Solc {
-    fn compiler_supports_yul(&self) -> bool {
-        const SOLC_VERSION_SUPPORTING_VIA_YUL_IR: Version = Version::new(0, 8, 13);
-        self.version() >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained() {
+        // Arrange
+        let args = Arguments::default();
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 7, 6))
+            .await
+            .unwrap();
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version().await;
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 7, 6)
+        )
+    }
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained1() {
+        // Arrange
+        let args = Arguments::default();
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
+            .await
+            .unwrap();
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version().await;
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 4, 21)
+        )
     }
 }

crates/compiler/tests/lib.rs

@@ -1,25 +1,24 @@
 use std::path::PathBuf;
 
-use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_compiler::{Compiler, SolidityCompiler, revive_resolc::Resolc, solc::Solc};
-use revive_dt_config::ExecutionContext;
+use revive_dt_config::Arguments;
 use semver::Version;
 
 #[tokio::test]
 async fn contracts_can_be_compiled_with_solc() {
     // Arrange
-    let args = ExecutionContext::default();
-    let solc = Solc::new(&args, VersionOrRequirement::Version(Version::new(0, 8, 30)))
+    let args = Arguments::default();
+    let compiler_path = Solc::get_compiler_executable(&args, Version::new(0, 8, 30))
         .await
         .unwrap();
 
     // Act
-    let output = Compiler::new()
+    let output = Compiler::<Solc>::new()
         .with_source("./tests/assets/array_one_element/callable.sol")
         .unwrap()
         .with_source("./tests/assets/array_one_element/main.sol")
         .unwrap()
-        .try_build(&solc)
+        .try_build(compiler_path)
         .await;
 
     // Assert
@@ -49,18 +48,18 @@ async fn contracts_can_be_compiled_with_solc() {
 #[tokio::test]
 async fn contracts_can_be_compiled_with_resolc() {
     // Arrange
-    let args = ExecutionContext::default();
-    let resolc = Resolc::new(&args, VersionOrRequirement::Version(Version::new(0, 8, 30)))
+    let args = Arguments::default();
+    let compiler_path = Resolc::get_compiler_executable(&args, Version::new(0, 8, 30))
         .await
         .unwrap();
 
     // Act
-    let output = Compiler::new()
+    let output = Compiler::<Resolc>::new()
         .with_source("./tests/assets/array_one_element/callable.sol")
         .unwrap()
         .with_source("./tests/assets/array_one_element/main.sol")
         .unwrap()
-        .try_build(&resolc)
+        .try_build(compiler_path)
         .await;
 
     // Assert

crates/config/Cargo.toml

@@ -10,13 +10,10 @@ rust-version.workspace = true
 
 [dependencies]
 alloy = { workspace = true }
-anyhow = { workspace = true }
 clap = { workspace = true }
 semver = { workspace = true }
 temp-dir = { workspace = true }
 serde = { workspace = true }
-serde_json = { workspace = true }
-strum = { workspace = true }
 
 [lints]
 workspace = true

crates/config/src/lib.rs

@@ -2,561 +2,199 @@
 
 use std::{
     fmt::Display,
-    fs::read_to_string,
-    ops::Deref,
     path::{Path, PathBuf},
-    str::FromStr,
-    sync::{Arc, LazyLock, OnceLock},
-    time::Duration,
+    sync::LazyLock,
 };
 
-use alloy::{
-    genesis::Genesis,
-    hex::ToHexExt,
-    network::EthereumWallet,
-    primitives::{FixedBytes, U256},
-    signers::local::PrivateKeySigner,
-};
-use clap::{Parser, ValueEnum, ValueHint};
+use alloy::{network::EthereumWallet, signers::local::PrivateKeySigner};
+use clap::{Parser, ValueEnum};
 use semver::Version;
-use serde::{Serialize, Serializer};
-use strum::{AsRefStr, Display, EnumString, IntoStaticStr};
+use serde::{Deserialize, Serialize};
 use temp_dir::TempDir;
 
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Debug, Parser, Clone, Serialize, Deserialize)]
 #[command(name = "retester")]
-pub enum Context {
-    /// Executes tests in the MatterLabs format differentially against a leader and a follower.
-    ExecuteTests(ExecutionContext),
-}
+pub struct Arguments {
+    /// The `solc` version to use if the test didn't specify it explicitly.
+    #[arg(long = "solc", short, default_value = "0.8.29")]
+    pub solc: Version,
 
-impl Context {
-    pub fn working_directory_configuration(&self) -> &WorkingDirectoryConfiguration {
-        self.as_ref()
-    }
+    /// Use the Wasm compiler versions.
+    #[arg(long = "wasm")]
+    pub wasm: bool,
 
-    pub fn report_configuration(&self) -> &ReportConfiguration {
-        self.as_ref()
-    }
-}
-
-impl AsRef<WorkingDirectoryConfiguration> for Context {
-    fn as_ref(&self) -> &WorkingDirectoryConfiguration {
-        match self {
-            Context::ExecuteTests(execution_context) => &execution_context.working_directory,
-        }
-    }
-}
-
-impl AsRef<ReportConfiguration> for Context {
-    fn as_ref(&self) -> &ReportConfiguration {
-        match self {
-            Context::ExecuteTests(execution_context) => &execution_context.report_configuration,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct ExecutionContext {
-    /// The working directory that the program will use for all of the temporary artifacts needed at
-    /// runtime.
+    /// The path to the `resolc` executable to be tested.
     ///
-    /// If not specified, then a temporary directory will be created and used by the program for all
-    /// temporary artifacts.
-    #[clap(
-        short,
-        long,
-        default_value = "",
-        value_hint = ValueHint::DirPath,
-    )]
-    pub working_directory: WorkingDirectoryConfiguration,
-
-    /// The differential testing leader node implementation.
-    #[arg(short, long = "leader", default_value_t = TestingPlatform::Geth)]
-    pub leader: TestingPlatform,
-
-    /// The differential testing follower node implementation.
-    #[arg(short, long = "follower", default_value_t = TestingPlatform::Kitchensink)]
-    pub follower: TestingPlatform,
+    /// By default it uses the `resolc` binary found in `$PATH`.
+    ///
+    /// If `--wasm` is set, this should point to the resolc Wasm ile.
+    #[arg(long = "resolc", short, default_value = "resolc")]
+    pub resolc: PathBuf,
 
     /// A list of test corpus JSON files to be tested.
     #[arg(long = "corpus", short)]
     pub corpus: Vec<PathBuf>,
 
-    /// Configuration parameters for the solc compiler.
-    #[clap(flatten, next_help_heading = "Solc Configuration")]
-    pub solc_configuration: SolcConfiguration,
-
-    /// Configuration parameters for the resolc compiler.
-    #[clap(flatten, next_help_heading = "Resolc Configuration")]
-    pub resolc_configuration: ResolcConfiguration,
-
-    /// Configuration parameters for the geth node.
-    #[clap(flatten, next_help_heading = "Geth Configuration")]
-    pub geth_configuration: GethConfiguration,
-
-    /// Configuration parameters for the Kitchensink.
-    #[clap(flatten, next_help_heading = "Kitchensink Configuration")]
-    pub kitchensink_configuration: KitchensinkConfiguration,
-
-    /// Configuration parameters for the Revive Dev Node.
-    #[clap(flatten, next_help_heading = "Revive Dev Node Configuration")]
-    pub revive_dev_node_configuration: ReviveDevNodeConfiguration,
-
-    /// Configuration parameters for the Eth Rpc.
-    #[clap(flatten, next_help_heading = "Eth RPC Configuration")]
-    pub eth_rpc_configuration: EthRpcConfiguration,
-
-    /// Configuration parameters for the genesis.
-    #[clap(flatten, next_help_heading = "Genesis Configuration")]
-    pub genesis_configuration: GenesisConfiguration,
-
-    /// Configuration parameters for the wallet.
-    #[clap(flatten, next_help_heading = "Wallet Configuration")]
-    pub wallet_configuration: WalletConfiguration,
-
-    /// Configuration parameters for concurrency.
-    #[clap(flatten, next_help_heading = "Concurrency Configuration")]
-    pub concurrency_configuration: ConcurrencyConfiguration,
-
-    /// Configuration parameters for the compilers and compilation.
-    #[clap(flatten, next_help_heading = "Compilation Configuration")]
-    pub compilation_configuration: CompilationConfiguration,
-
-    /// Configuration parameters for the report.
-    #[clap(flatten, next_help_heading = "Report Configuration")]
-    pub report_configuration: ReportConfiguration,
-}
-
-impl Default for ExecutionContext {
-    fn default() -> Self {
-        Self::parse_from(["execution-context"])
-    }
-}
-
-impl AsRef<WorkingDirectoryConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &WorkingDirectoryConfiguration {
-        &self.working_directory
-    }
-}
-
-impl AsRef<SolcConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &SolcConfiguration {
-        &self.solc_configuration
-    }
-}
-
-impl AsRef<ResolcConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &ResolcConfiguration {
-        &self.resolc_configuration
-    }
-}
-
-impl AsRef<GethConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &GethConfiguration {
-        &self.geth_configuration
-    }
-}
-
-impl AsRef<KitchensinkConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &KitchensinkConfiguration {
-        &self.kitchensink_configuration
-    }
-}
-
-impl AsRef<ReviveDevNodeConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &ReviveDevNodeConfiguration {
-        &self.revive_dev_node_configuration
-    }
-}
-
-impl AsRef<EthRpcConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &EthRpcConfiguration {
-        &self.eth_rpc_configuration
-    }
-}
-
-impl AsRef<GenesisConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &GenesisConfiguration {
-        &self.genesis_configuration
-    }
-}
-
-impl AsRef<WalletConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &WalletConfiguration {
-        &self.wallet_configuration
-    }
-}
-
-impl AsRef<ConcurrencyConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &ConcurrencyConfiguration {
-        &self.concurrency_configuration
-    }
-}
-
-impl AsRef<CompilationConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &CompilationConfiguration {
-        &self.compilation_configuration
-    }
-}
-
-impl AsRef<ReportConfiguration> for ExecutionContext {
-    fn as_ref(&self) -> &ReportConfiguration {
-        &self.report_configuration
-    }
-}
-
-/// A set of configuration parameters for Solc.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct SolcConfiguration {
-    /// Specifies the default version of the Solc compiler that should be used if there is no
-    /// override specified by one of the test cases.
-    #[clap(long = "solc.version", default_value = "0.8.29")]
-    pub version: Version,
-}
-
-/// A set of configuration parameters for Resolc.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct ResolcConfiguration {
-    /// Specifies the path of the resolc compiler to be used by the tool.
+    /// A place to store temporary artifacts during test execution.
     ///
-    /// If this is not specified, then the tool assumes that it should use the resolc binary that's
-    /// provided in the user's $PATH.
-    #[clap(id = "resolc.path", long = "resolc.path", default_value = "resolc")]
-    pub path: PathBuf,
-}
+    /// Creates a temporary dir if not specified.
+    #[arg(long = "workdir", short)]
+    pub working_directory: Option<PathBuf>,
 
-/// A set of configuration parameters for Geth.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct GethConfiguration {
-    /// Specifies the path of the geth node to be used by the tool.
+    /// Add a tempdir manually if `working_directory` was not given.
     ///
-    /// If this is not specified, then the tool assumes that it should use the geth binary that's
-    /// provided in the user's $PATH.
-    #[clap(id = "geth.path", long = "geth.path", default_value = "geth")]
-    pub path: PathBuf,
-
-    /// The amount of time to wait upon startup before considering that the node timed out.
-    #[clap(
-        id = "geth.start-timeout-ms",
-        long = "geth.start-timeout-ms",
-        default_value = "5000",
-        value_parser = parse_duration
-    )]
-    pub start_timeout_ms: Duration,
-}
-
-/// A set of configuration parameters for Kitchensink.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct KitchensinkConfiguration {
-    /// Specifies the path of the kitchensink node to be used by the tool.
-    ///
-    /// If this is not specified, then the tool assumes that it should use the kitchensink binary
-    /// that's provided in the user's $PATH.
-    #[clap(
-        id = "kitchensink.path",
-        long = "kitchensink.path",
-        default_value = "substrate-node"
-    )]
-    pub path: PathBuf,
-
-    /// The amount of time to wait upon startup before considering that the node timed out.
-    #[clap(
-        id = "kitchensink.start-timeout-ms",
-        long = "kitchensink.start-timeout-ms",
-        default_value = "5000",
-        value_parser = parse_duration
-    )]
-    pub start_timeout_ms: Duration,
-
-    /// This configures the tool to use Kitchensink instead of using the revive-dev-node.
-    #[clap(long = "kitchensink.dont-use-dev-node")]
-    pub use_kitchensink: bool,
-}
-
-/// A set of configuration parameters for the revive dev node.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct ReviveDevNodeConfiguration {
-    /// Specifies the path of the revive dev node to be used by the tool.
-    ///
-    /// If this is not specified, then the tool assumes that it should use the revive dev node binary
-    /// that's provided in the user's $PATH.
-    #[clap(
-        id = "revive-dev-node.path",
-        long = "revive-dev-node.path",
-        default_value = "revive-dev-node"
-    )]
-    pub path: PathBuf,
-
-    /// The amount of time to wait upon startup before considering that the node timed out.
-    #[clap(
-        id = "revive-dev-node.start-timeout-ms",
-        long = "revive-dev-node.start-timeout-ms",
-        default_value = "5000",
-        value_parser = parse_duration
-    )]
-    pub start_timeout_ms: Duration,
-}
-
-/// A set of configuration parameters for the ETH RPC.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct EthRpcConfiguration {
-    /// Specifies the path of the ETH RPC to be used by the tool.
-    ///
-    /// If this is not specified, then the tool assumes that it should use the ETH RPC binary
-    /// that's provided in the user's $PATH.
-    #[clap(id = "eth-rpc.path", long = "eth-rpc.path", default_value = "eth-rpc")]
-    pub path: PathBuf,
-
-    /// The amount of time to wait upon startup before considering that the node timed out.
-    #[clap(
-        id = "eth-rpc.start-timeout-ms",
-        long = "eth-rpc.start-timeout-ms",
-        default_value = "5000",
-        value_parser = parse_duration
-    )]
-    pub start_timeout_ms: Duration,
-}
-
-/// A set of configuration parameters for the genesis.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct GenesisConfiguration {
-    /// Specifies the path of the genesis file to use for the nodes that are started.
-    ///
-    /// This is expected to be the path of a JSON geth genesis file.
-    #[clap(id = "genesis.path", long = "genesis.path")]
-    path: Option<PathBuf>,
-
-    /// The genesis object found at the provided path.
+    /// We attach it here because [TempDir] prunes itself on drop.
     #[clap(skip)]
     #[serde(skip)]
-    genesis: OnceLock<Genesis>,
-}
+    pub temp_dir: Option<&'static TempDir>,
 
-impl GenesisConfiguration {
-    pub fn genesis(&self) -> anyhow::Result<&Genesis> {
-        static DEFAULT_GENESIS: LazyLock<Genesis> = LazyLock::new(|| {
-            let genesis = include_str!("../../../genesis.json");
-            serde_json::from_str(genesis).unwrap()
-        });
+    /// The path to the `geth` executable.
+    ///
+    /// By default it uses `geth` binary found in `$PATH`.
+    #[arg(short, long = "geth", default_value = "geth")]
+    pub geth: PathBuf,
 
-        match self.genesis.get() {
-            Some(genesis) => Ok(genesis),
-            None => {
-                let genesis = match self.path.as_ref() {
-                    Some(genesis_path) => {
-                        let genesis_content = read_to_string(genesis_path)?;
-                        serde_json::from_str(genesis_content.as_str())?
-                    }
-                    None => DEFAULT_GENESIS.clone(),
-                };
-                Ok(self.genesis.get_or_init(|| genesis))
-            }
-        }
-    }
-}
+    /// The maximum time in milliseconds to wait for geth to start.
+    #[arg(long = "geth-start-timeout", default_value = "5000")]
+    pub geth_start_timeout: u64,
 
-/// A set of configuration parameters for the wallet.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct WalletConfiguration {
-    /// The private key of the default signer.
-    #[clap(
-        long = "wallet.default-private-key",
+    /// Configure nodes according to this genesis.json file.
+    #[arg(long = "genesis", default_value = "genesis.json")]
+    pub genesis_file: PathBuf,
+
+    /// The signing account private key.
+    #[arg(
+        short,
+        long = "account",
         default_value = "0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d"
     )]
-    #[serde(serialize_with = "serialize_private_key")]
-    default_key: PrivateKeySigner,
+    pub account: String,
 
     /// This argument controls which private keys the nodes should have access to and be added to
     /// its wallet signers. With a value of N, private keys (0, N] will be added to the signer set
     /// of the node.
-    #[clap(long = "wallet.additional-keys", default_value_t = 100_000)]
-    additional_keys: usize,
+    #[arg(long = "private-keys-count", default_value_t = 100_000)]
+    pub private_keys_to_add: usize,
 
-    /// The wallet object that will be used.
-    #[clap(skip)]
-    #[serde(skip)]
-    wallet: OnceLock<Arc<EthereumWallet>>,
-}
+    /// The differential testing leader node implementation.
+    #[arg(short, long = "leader", default_value = "geth")]
+    pub leader: TestingPlatform,
 
-impl WalletConfiguration {
-    pub fn wallet(&self) -> Arc<EthereumWallet> {
-        self.wallet
-            .get_or_init(|| {
-                let mut wallet = EthereumWallet::new(self.default_key.clone());
-                for signer in (1..=self.additional_keys)
-                    .map(|id| U256::from(id))
-                    .map(|id| id.to_be_bytes::<32>())
-                    .map(|id| PrivateKeySigner::from_bytes(&FixedBytes(id)).unwrap())
-                {
-                    wallet.register_signer(signer);
-                }
-                Arc::new(wallet)
-            })
-            .clone()
-    }
-}
+    /// The differential testing follower node implementation.
+    #[arg(short, long = "follower", default_value = "kitchensink")]
+    pub follower: TestingPlatform,
 
-fn serialize_private_key<S>(value: &PrivateKeySigner, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    value.to_bytes().encode_hex().serialize(serializer)
-}
+    /// Only compile against this testing platform (doesn't execute the tests).
+    #[arg(long = "compile-only")]
+    pub compile_only: Option<TestingPlatform>,
 
-/// A set of configuration for concurrency.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct ConcurrencyConfiguration {
     /// Determines the amount of nodes that will be spawned for each chain.
-    #[clap(long = "concurrency.number-of-nodes", default_value_t = 5)]
+    #[arg(long, default_value = "1")]
     pub number_of_nodes: usize,
 
     /// Determines the amount of tokio worker threads that will will be used.
     #[arg(
-        long = "concurrency.number-of-threads",
+        long,
         default_value_t = std::thread::available_parallelism()
             .map(|n| n.get())
             .unwrap_or(1)
     )]
     pub number_of_threads: usize,
 
-    /// Determines the amount of concurrent tasks that will be spawned to run tests.
+    /// Determines the amount of concurrent tasks that will be spawned to run tests. Defaults to 10 x the number of nodes.
+    #[arg(long)]
+    pub number_concurrent_tasks: Option<usize>,
+
+    /// Extract problems back to the test corpus.
+    #[arg(short, long = "extract-problems")]
+    pub extract_problems: bool,
+
+    /// The path to the `kitchensink` executable.
     ///
-    /// Defaults to 10 x the number of nodes.
-    #[arg(long = "concurrency.number-of-concurrent-tasks")]
-    number_concurrent_tasks: Option<usize>,
+    /// By default it uses `substrate-node` binary found in `$PATH`.
+    #[arg(short, long = "kitchensink", default_value = "substrate-node")]
+    pub kitchensink: PathBuf,
 
-    /// Determines if the concurrency limit should be ignored or not.
-    #[arg(long = "concurrency.ignore-concurrency-limit")]
-    ignore_concurrency_limit: bool,
-}
+    /// The path to the `eth_proxy` executable.
+    ///
+    /// By default it uses `eth-rpc` binary found in `$PATH`.
+    #[arg(short = 'p', long = "eth_proxy", default_value = "eth-rpc")]
+    pub eth_proxy: PathBuf,
 
-impl ConcurrencyConfiguration {
-    pub fn concurrency_limit(&self) -> Option<usize> {
-        match self.ignore_concurrency_limit {
-            true => None,
-            false => Some(
-                self.number_concurrent_tasks
-                    .unwrap_or(20 * self.number_of_nodes),
-            ),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct CompilationConfiguration {
     /// Controls if the compilation cache should be invalidated or not.
-    #[arg(long = "compilation.invalidate-cache")]
+    #[arg(short, long)]
     pub invalidate_compilation_cache: bool,
 }
 
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct ReportConfiguration {
-    /// Controls if the compiler input is included in the final report.
-    #[clap(long = "report.include-compiler-input")]
-    pub include_compiler_input: bool,
-
-    /// Controls if the compiler output is included in the final report.
-    #[clap(long = "report.include-compiler-output")]
-    pub include_compiler_output: bool,
-}
-
-/// Represents the working directory that the program uses.
-#[derive(Debug, Clone)]
-pub enum WorkingDirectoryConfiguration {
-    /// A temporary directory is used as the working directory. This will be removed when dropped.
-    TemporaryDirectory(Arc<TempDir>),
-    /// A directory with a path is used as the working directory.
-    Path(PathBuf),
-}
-
-impl WorkingDirectoryConfiguration {
-    pub fn as_path(&self) -> &Path {
-        self.as_ref()
-    }
-}
-
-impl Deref for WorkingDirectoryConfiguration {
-    type Target = Path;
-
-    fn deref(&self) -> &Self::Target {
-        self.as_path()
-    }
-}
-
-impl AsRef<Path> for WorkingDirectoryConfiguration {
-    fn as_ref(&self) -> &Path {
-        match self {
-            WorkingDirectoryConfiguration::TemporaryDirectory(temp_dir) => temp_dir.path(),
-            WorkingDirectoryConfiguration::Path(path) => path.as_path(),
+impl Arguments {
+    /// Return the configured working directory with the following precedence:
+    /// 1. `self.working_directory` if it was provided.
+    /// 2. `self.temp_dir` if it it was provided
+    /// 3. Panic.
+    pub fn directory(&self) -> &Path {
+        if let Some(path) = &self.working_directory {
+            return path.as_path();
         }
+
+        if let Some(temp_dir) = &self.temp_dir {
+            return temp_dir.path();
+        }
+
+        panic!("should have a workdir configured")
+    }
+
+    /// Return the number of concurrent tasks to run. This is provided via the
+    /// `--number-concurrent-tasks` argument, and otherwise defaults to --number-of-nodes * 20.
+    pub fn number_of_concurrent_tasks(&self) -> usize {
+        self.number_concurrent_tasks
+            .unwrap_or(20 * self.number_of_nodes)
+    }
+
+    /// Try to parse `self.account` into a [PrivateKeySigner],
+    /// panicing on error.
+    pub fn wallet(&self) -> EthereumWallet {
+        let signer = self
+            .account
+            .parse::<PrivateKeySigner>()
+            .unwrap_or_else(|error| {
+                panic!("private key '{}' parsing error: {error}", self.account);
+            });
+        EthereumWallet::new(signer)
     }
 }
 
-impl Default for WorkingDirectoryConfiguration {
+impl Default for Arguments {
     fn default() -> Self {
-        TempDir::new()
-            .map(Arc::new)
-            .map(Self::TemporaryDirectory)
-            .expect("Failed to create the temporary directory")
-    }
-}
+        static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 
-impl FromStr for WorkingDirectoryConfiguration {
-    type Err = anyhow::Error;
+        let default = Arguments::parse_from(["retester"]);
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "" => Ok(Default::default()),
-            _ => Ok(Self::Path(PathBuf::from(s))),
+        Arguments {
+            temp_dir: Some(&TEMP_DIR),
+            ..default
         }
     }
 }
 
-impl Display for WorkingDirectoryConfiguration {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.as_path().display(), f)
-    }
-}
-
-impl Serialize for WorkingDirectoryConfiguration {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.as_path().serialize(serializer)
-    }
-}
-
-fn parse_duration(s: &str) -> anyhow::Result<Duration> {
-    u64::from_str(s)
-        .map(Duration::from_millis)
-        .map_err(Into::into)
-}
-
 /// The Solidity compatible node implementation.
 ///
 /// This describes the solutions to be tested against on a high level.
 #[derive(
-    Clone,
-    Copy,
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Hash,
-    Serialize,
-    ValueEnum,
-    EnumString,
-    Display,
-    AsRefStr,
-    IntoStaticStr,
+    Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, ValueEnum, Serialize, Deserialize,
 )]
-#[strum(serialize_all = "kebab-case")]
+#[clap(rename_all = "lower")]
 pub enum TestingPlatform {
     /// The go-ethereum reference full node EVM implementation.
     Geth,
-    /// The kitchensink runtime provides the PolkaVM (PVM) based node implementation.
+    /// The kitchensink runtime provides the PolkaVM (PVM) based node implentation.
     Kitchensink,
 }
+
+impl Display for TestingPlatform {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Geth => f.write_str("geth"),
+            Self::Kitchensink => f.write_str("revive"),
+        }
+    }
+}

crates/core/Cargo.toml

@@ -28,6 +28,7 @@ cacache = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }
 indexmap = { workspace = true }
+once_cell = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-appender = { workspace = true }
@@ -35,6 +36,8 @@ tracing-subscriber = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+temp-dir = { workspace = true }
+tempfile = { workspace = true }
 
 [lints]
 workspace = true

crates/core/src/cached_compiler.rs

@@ -2,7 +2,6 @@
 //! be reused between runs.
 
 use std::{
-    borrow::Cow,
     collections::HashMap,
     path::{Path, PathBuf},
     sync::Arc,
@@ -11,12 +10,12 @@ use std::{
 use futures::FutureExt;
 use revive_dt_common::iterators::FilesWithExtensionIterator;
 use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
-use revive_dt_config::TestingPlatform;
+use revive_dt_config::Arguments;
 use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
 
 use alloy::{hex::ToHexExt, json_abi::JsonAbi, primitives::Address};
-use anyhow::{Context as _, Error, Result};
-use revive_dt_report::ExecutionSpecificReporter;
+use anyhow::{Error, Result};
+use once_cell::sync::Lazy;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use tokio::sync::{Mutex, RwLock};
@@ -24,38 +23,23 @@ use tracing::{Instrument, debug, debug_span, instrument};
 
 use crate::Platform;
 
-pub struct CachedCompiler<'a> {
-    /// The cache that stores the compiled contracts.
-    artifacts_cache: ArtifactsCache,
+pub struct CachedCompiler(ArtifactsCache);
 
-    /// This is a mechanism that the cached compiler uses so that if multiple compilation requests
-    /// come in for the same contract we never compile all of them and only compile it once and all
-    /// other tasks that request this same compilation concurrently get the cached version.
-    cache_key_lock: RwLock<HashMap<CacheKey<'a>, Arc<Mutex<()>>>>,
-}
-
-impl<'a> CachedCompiler<'a> {
+impl CachedCompiler {
     pub async fn new(path: impl AsRef<Path>, invalidate_cache: bool) -> Result<Self> {
         let mut cache = ArtifactsCache::new(path);
         if invalidate_cache {
-            cache = cache
-                .with_invalidated_cache()
-                .await
-                .context("Failed to invalidate compilation cache directory")?;
+            cache = cache.with_invalidated_cache().await?;
         }
-        Ok(Self {
-            artifacts_cache: cache,
-            cache_key_lock: Default::default(),
-        })
+        Ok(Self(cache))
     }
 
     /// Compiles or gets the compilation artifacts from the cache.
-    #[allow(clippy::too_many_arguments)]
     #[instrument(
         level = "debug",
         skip_all,
         fields(
-            metadata_file_path = %metadata_file_path.display(),
+            metadata_file_path = %metadata_file_path.as_ref().display(),
             %mode,
             platform = P::config_id().to_string()
         ),
@@ -63,33 +47,40 @@ impl<'a> CachedCompiler<'a> {
     )]
     pub async fn compile_contracts<P: Platform>(
         &self,
-        metadata: &'a Metadata,
-        metadata_file_path: &'a Path,
-        mode: Cow<'a, Mode>,
+        metadata: &Metadata,
+        metadata_file_path: impl AsRef<Path>,
+        mode: &Mode,
+        config: &Arguments,
         deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-        compiler: &P::Compiler,
-        reporter: &ExecutionSpecificReporter,
-    ) -> Result<CompilerOutput> {
+    ) -> Result<(CompilerOutput, Version)> {
+        static CACHE_KEY_LOCK: Lazy<RwLock<HashMap<CacheKey, Arc<Mutex<()>>>>> =
+            Lazy::new(Default::default);
+
+        let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
+        let compiler_path = <P::Compiler as SolidityCompiler>::get_compiler_executable(
+            config,
+            compiler_version_or_requirement,
+        )
+        .await?;
+        let compiler_version = <P::Compiler as SolidityCompiler>::new(compiler_path.clone())
+            .version()
+            .await?;
+
         let cache_key = CacheKey {
-            platform_key: P::config_id(),
-            compiler_version: compiler.version().clone(),
-            metadata_file_path,
+            platform_key: P::config_id().to_string(),
+            compiler_version: compiler_version.clone(),
+            metadata_file_path: metadata_file_path.as_ref().to_path_buf(),
             solc_mode: mode.clone(),
         };
 
         let compilation_callback = || {
             async move {
                 compile_contracts::<P>(
-                    metadata
-                        .directory()
-                        .context("Failed to get metadata directory while preparing compilation")?,
-                    metadata
-                        .files_to_compile()
-                        .context("Failed to enumerate files to compile from metadata")?,
-                    &mode,
+                    metadata.directory()?,
+                    compiler_path,
+                    metadata.files_to_compile()?,
+                    mode,
                     deployed_libraries,
-                    compiler,
-                    reporter,
                 )
                 .map(|compilation_result| compilation_result.map(CacheValue::new))
                 .await
@@ -109,10 +100,7 @@ impl<'a> CachedCompiler<'a> {
             Some(_) => {
                 debug!("Deployed libraries defined, recompilation must take place");
                 debug!("Cache miss");
-                compilation_callback()
-                    .await
-                    .context("Compilation callback for deployed libraries failed")?
-                    .compiler_output
+                compilation_callback().await?.compiler_output
             }
             // If no deployed libraries are specified then we can follow the cached flow and attempt
             // to lookup the compilation artifacts in the cache.
@@ -122,15 +110,12 @@ impl<'a> CachedCompiler<'a> {
                 // Lock this specific cache key such that we do not get inconsistent state. We want
                 // that when multiple cases come in asking for the compilation artifacts then they
                 // don't all trigger a compilation if there's a cache miss. Hence, the lock here.
-                let read_guard = self.cache_key_lock.read().await;
+                let read_guard = CACHE_KEY_LOCK.read().await;
                 let mutex = match read_guard.get(&cache_key).cloned() {
-                    Some(value) => {
-                        drop(read_guard);
-                        value
-                    }
+                    Some(value) => value,
                     None => {
                         drop(read_guard);
-                        self.cache_key_lock
+                        CACHE_KEY_LOCK
                             .write()
                             .await
                             .entry(cache_key.clone())
@@ -140,59 +125,30 @@ impl<'a> CachedCompiler<'a> {
                 };
                 let _guard = mutex.lock().await;
 
-                match self.artifacts_cache.get(&cache_key).await {
-                    Some(cache_value) => {
-                        if deployed_libraries.is_some() {
-                            reporter
-                                .report_post_link_contracts_compilation_succeeded_event(
-                                    compiler.version().clone(),
-                                    compiler.path(),
-                                    true,
-                                    None,
-                                    cache_value.compiler_output.clone(),
-                                )
-                                .expect("Can't happen");
-                        } else {
-                            reporter
-                                .report_pre_link_contracts_compilation_succeeded_event(
-                                    compiler.version().clone(),
-                                    compiler.path(),
-                                    true,
-                                    None,
-                                    cache_value.compiler_output.clone(),
-                                )
-                                .expect("Can't happen");
-                        }
-                        cache_value.compiler_output
-                    }
-                    None => {
-                        compilation_callback()
-                            .await
-                            .context("Compilation callback failed (cache miss path)")?
-                            .compiler_output
-                    }
-                }
+                self.0
+                    .get_or_insert_with(&cache_key, compilation_callback)
+                    .await
+                    .map(|value| value.compiler_output)?
             }
         };
 
-        Ok(compiled_contracts)
+        Ok((compiled_contracts, compiler_version))
     }
 }
 
 async fn compile_contracts<P: Platform>(
     metadata_directory: impl AsRef<Path>,
+    compiler_path: impl AsRef<Path>,
     mut files_to_compile: impl Iterator<Item = PathBuf>,
     mode: &Mode,
     deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-    compiler: &P::Compiler,
-    reporter: &ExecutionSpecificReporter,
 ) -> Result<CompilerOutput> {
     let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
         .with_allowed_extension("sol")
         .with_use_cached_fs(true)
         .collect::<Vec<_>>();
 
-    let compilation = Compiler::new()
+    Compiler::<P::Compiler>::new()
         .with_allow_path(metadata_directory)
         // Handling the modes
         .with_optimization(mode.optimize_setting)
@@ -215,57 +171,9 @@ async fn compile_contracts<P: Platform>(
                 .fold(compiler, |compiler, (ident, address, path)| {
                     compiler.with_library(path, ident.as_str(), *address)
                 })
-        });
-
-    let input = compilation.input().clone();
-    let output = compilation.try_build(compiler).await;
-
-    match (output.as_ref(), deployed_libraries.is_some()) {
-        (Ok(output), true) => {
-            reporter
-                .report_post_link_contracts_compilation_succeeded_event(
-                    compiler.version().clone(),
-                    compiler.path(),
-                    false,
-                    input,
-                    output.clone(),
-                )
-                .expect("Can't happen");
-        }
-        (Ok(output), false) => {
-            reporter
-                .report_pre_link_contracts_compilation_succeeded_event(
-                    compiler.version().clone(),
-                    compiler.path(),
-                    false,
-                    input,
-                    output.clone(),
-                )
-                .expect("Can't happen");
-        }
-        (Err(err), true) => {
-            reporter
-                .report_post_link_contracts_compilation_failed_event(
-                    compiler.version().clone(),
-                    compiler.path().to_path_buf(),
-                    input,
-                    format!("{err:#}"),
-                )
-                .expect("Can't happen");
-        }
-        (Err(err), false) => {
-            reporter
-                .report_pre_link_contracts_compilation_failed_event(
-                    compiler.version().clone(),
-                    compiler.path().to_path_buf(),
-                    input,
-                    format!("{err:#}"),
-                )
-                .expect("Can't happen");
-        }
-    }
-
-    output
+        })
+        .try_build(compiler_path)
+        .await
 }
 
 struct ArtifactsCache {
@@ -283,24 +191,19 @@ impl ArtifactsCache {
     pub async fn with_invalidated_cache(self) -> Result<Self> {
         cacache::clear(self.path.as_path())
             .await
-            .map_err(Into::<Error>::into)
-            .with_context(|| format!("Failed to clear cache at {}", self.path.display()))?;
+            .map_err(Into::<Error>::into)?;
         Ok(self)
     }
 
     #[instrument(level = "debug", skip_all, err)]
-    pub async fn insert(&self, key: &CacheKey<'_>, value: &CacheValue) -> Result<()> {
-        let key = bson::to_vec(key).context("Failed to serialize cache key (bson)")?;
-        let value = bson::to_vec(value).context("Failed to serialize cache value (bson)")?;
-        cacache::write(self.path.as_path(), key.encode_hex(), value)
-            .await
-            .with_context(|| {
-                format!("Failed to write cache entry under {}", self.path.display())
-            })?;
+    pub async fn insert(&self, key: &CacheKey, value: &CacheValue) -> Result<()> {
+        let key = bson::to_vec(key)?;
+        let value = bson::to_vec(value)?;
+        cacache::write(self.path.as_path(), key.encode_hex(), value).await?;
         Ok(())
     }
 
-    pub async fn get(&self, key: &CacheKey<'_>) -> Option<CacheValue> {
+    pub async fn get(&self, key: &CacheKey) -> Option<CacheValue> {
         let key = bson::to_vec(key).ok()?;
         let value = cacache::read(self.path.as_path(), key.encode_hex())
             .await
@@ -312,7 +215,7 @@ impl ArtifactsCache {
     #[instrument(level = "debug", skip_all, err)]
     pub async fn get_or_insert_with(
         &self,
-        key: &CacheKey<'_>,
+        key: &CacheKey,
         callback: impl AsyncFnOnce() -> Result<CacheValue>,
     ) -> Result<CacheValue> {
         match self.get(key).await {
@@ -330,20 +233,20 @@ impl ArtifactsCache {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-struct CacheKey<'a> {
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+struct CacheKey {
     /// The platform name that this artifact was compiled for. For example, this could be EVM or
     /// PVM.
-    platform_key: &'a TestingPlatform,
+    platform_key: String,
 
     /// The version of the compiler that was used to compile the artifacts.
     compiler_version: Version,
 
     /// The path of the metadata file that the compilation artifacts are for.
-    metadata_file_path: &'a Path,
+    metadata_file_path: PathBuf,
 
     /// The mode that the compilation artifacts where compiled with.
-    solc_mode: Cow<'a, Mode>,
+    solc_mode: Mode,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]

crates/core/src/driver/mod.rs

@@ -18,11 +18,10 @@ use alloy::{
     primitives::Address,
     rpc::types::{TransactionRequest, trace::geth::DiffMode},
 };
-use anyhow::Context as _;
+use anyhow::Context;
 use futures::TryStreamExt;
 use indexmap::IndexMap;
 use revive_dt_format::traits::{ResolutionContext, ResolverApi};
-use revive_dt_report::ExecutionSpecificReporter;
 use semver::Version;
 
 use revive_dt_format::case::Case;
@@ -52,9 +51,6 @@ pub struct CaseState<T: Platform> {
     /// Stores the version used for the current case.
     compiler_version: Version,
 
-    /// The execution reporter.
-    execution_reporter: ExecutionSpecificReporter,
-
     phantom: PhantomData<T>,
 }
 
@@ -66,14 +62,12 @@ where
         compiler_version: Version,
         compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
         deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
-        execution_reporter: ExecutionSpecificReporter,
     ) -> Self {
         Self {
             compiled_contracts,
             deployed_contracts,
             variables: Default::default(),
             compiler_version,
-            execution_reporter,
             phantom: PhantomData,
         }
     }
@@ -86,22 +80,18 @@ where
     ) -> anyhow::Result<StepOutput> {
         match step {
             Step::FunctionCall(input) => {
-                let (receipt, geth_trace, diff_mode) = self
-                    .handle_input(metadata, input, node)
-                    .await
-                    .context("Failed to handle function call step")?;
+                let (receipt, geth_trace, diff_mode) =
+                    self.handle_input(metadata, input, node).await?;
                 Ok(StepOutput::FunctionCall(receipt, geth_trace, diff_mode))
             }
             Step::BalanceAssertion(balance_assertion) => {
                 self.handle_balance_assertion(metadata, balance_assertion, node)
-                    .await
-                    .context("Failed to handle balance assertion step")?;
+                    .await?;
                 Ok(StepOutput::BalanceAssertion)
             }
             Step::StorageEmptyAssertion(storage_empty) => {
                 self.handle_storage_empty(metadata, storage_empty, node)
-                    .await
-                    .context("Failed to handle storage empty assertion step")?;
+                    .await?;
                 Ok(StepOutput::StorageEmptyAssertion)
             }
         }
@@ -117,23 +107,18 @@ where
     ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
         let deployment_receipts = self
             .handle_input_contract_deployment(metadata, input, node)
-            .await
-            .context("Failed during contract deployment phase of input handling")?;
+            .await?;
         let execution_receipt = self
             .handle_input_execution(input, deployment_receipts, node)
-            .await
-            .context("Failed during transaction execution phase of input handling")?;
+            .await?;
         let tracing_result = self
             .handle_input_call_frame_tracing(&execution_receipt, node)
-            .await
-            .context("Failed during callframe tracing phase of input handling")?;
-        self.handle_input_variable_assignment(input, &tracing_result)
-            .context("Failed to assign variables from callframe output")?;
+            .await?;
+        self.handle_input_variable_assignment(input, &tracing_result)?;
         let (_, (geth_trace, diff_mode)) = try_join!(
             self.handle_input_expectations(input, &execution_receipt, node, &tracing_result),
             self.handle_input_diff(&execution_receipt, node)
-        )
-        .context("Failed while evaluating expectations and diffs in parallel")?;
+        )?;
         Ok((execution_receipt, geth_trace, diff_mode))
     }
 
@@ -145,11 +130,9 @@ where
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
         self.handle_balance_assertion_contract_deployment(metadata, balance_assertion, node)
-            .await
-            .context("Failed to deploy contract for balance assertion")?;
+            .await?;
         self.handle_balance_assertion_execution(balance_assertion, node)
-            .await
-            .context("Failed to execute balance assertion")?;
+            .await?;
         Ok(())
     }
 
@@ -161,11 +144,9 @@ where
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
         self.handle_storage_empty_assertion_contract_deployment(metadata, storage_empty, node)
-            .await
-            .context("Failed to deploy contract for storage empty assertion")?;
+            .await?;
         self.handle_storage_empty_assertion_execution(storage_empty, node)
-            .await
-            .context("Failed to execute storage empty assertion")?;
+            .await?;
         Ok(())
     }
 
@@ -204,8 +185,7 @@ where
                     value,
                     node,
                 )
-                .await
-                .context("Failed to get or deploy contract instance during input execution")?
+                .await?
             {
                 receipts.insert(instance.clone(), receipt);
             }
@@ -227,7 +207,7 @@ where
             // lookup the transaction receipt in this case and continue on.
             Method::Deployer => deployment_receipts
                 .remove(&input.instance)
-                .context("Failed to find deployment receipt for constructor call"),
+                .context("Failed to find deployment receipt"),
             Method::Fallback | Method::FunctionName(_) => {
                 let tx = match input
                     .legacy_transaction(node, self.default_resolution_context())
@@ -399,8 +379,7 @@ where
             let actual = &tracing_result.output.as_ref().unwrap_or_default();
             if !expected
                 .is_equivalent(actual, resolver, resolution_context)
-                .await
-                .context("Failed to resolve calldata equivalence for return data assertion")?
+                .await?
             {
                 tracing::error!(
                     ?execution_receipt,
@@ -463,8 +442,7 @@ where
                     let expected = Calldata::new_compound([expected]);
                     if !expected
                         .is_equivalent(&actual.0, resolver, resolution_context)
-                        .await
-                        .context("Failed to resolve event topic equivalence")?
+                        .await?
                     {
                         tracing::error!(
                             event_idx,
@@ -484,8 +462,7 @@ where
                 let actual = &actual_event.data().data;
                 if !expected
                     .is_equivalent(&actual.0, resolver, resolution_context)
-                    .await
-                    .context("Failed to resolve event value equivalence")?
+                    .await?
                 {
                     tracing::error!(
                         event_idx,
@@ -518,12 +495,8 @@ where
 
         let trace = node
             .trace_transaction(execution_receipt, trace_options)
-            .await
-            .context("Failed to obtain geth prestate tracer output")?;
-        let diff = node
-            .state_diff(execution_receipt)
-            .await
-            .context("Failed to obtain state diff for transaction")?;
+            .await?;
+        let diff = node.state_diff(execution_receipt).await?;
 
         Ok((trace, diff))
     }
@@ -745,8 +718,6 @@ where
             instance_address = ?address,
             "Deployed contract"
         );
-        self.execution_reporter
-            .report_contract_deployed_event(contract_instance.clone(), address)?;
 
         self.deployed_contracts.insert(
             contract_instance.clone(),

crates/core/src/lib.rs

@@ -19,7 +19,7 @@ pub trait Platform {
     type Compiler: SolidityCompiler;
 
     /// Returns the matching [TestingPlatform] of the [revive_dt_config::Arguments].
-    fn config_id() -> &'static TestingPlatform;
+    fn config_id() -> TestingPlatform;
 }
 
 #[derive(Default)]
@@ -29,8 +29,8 @@ impl Platform for Geth {
     type Blockchain = geth::GethNode;
     type Compiler = solc::Solc;
 
-    fn config_id() -> &'static TestingPlatform {
-        &TestingPlatform::Geth
+    fn config_id() -> TestingPlatform {
+        TestingPlatform::Geth
     }
 }
 
@@ -41,7 +41,7 @@ impl Platform for Kitchensink {
     type Blockchain = KitchensinkNode;
     type Compiler = revive_resolc::Resolc;
 
-    fn config_id() -> &'static TestingPlatform {
-        &TestingPlatform::Kitchensink
+    fn config_id() -> TestingPlatform {
+        TestingPlatform::Kitchensink
     }
 }

crates/format/src/case.rs

@@ -64,14 +64,13 @@ impl Case {
     pub fn solc_modes(&self) -> Vec<Mode> {
         match &self.modes {
             Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
-            None => Mode::all().cloned().collect(),
+            None => Mode::all().collect(),
         }
     }
 }
 
 define_wrapper_type!(
     /// A wrapper type for the index of test cases found in metadata file.
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-    #[serde(transparent)]
-    pub struct CaseIdx(usize) impl Display, FromStr;
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct CaseIdx(usize) impl Display;
 );

crates/format/src/corpus.rs

@@ -8,7 +8,6 @@ use serde::{Deserialize, Serialize};
 use tracing::{debug, info};
 
 use crate::metadata::{Metadata, MetadataFile};
-use anyhow::Context as _;
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -21,24 +20,23 @@ impl Corpus {
     pub fn try_from_path(file_path: impl AsRef<Path>) -> anyhow::Result<Self> {
         let mut corpus = File::open(file_path.as_ref())
             .map_err(anyhow::Error::from)
-            .and_then(|file| serde_json::from_reader::<_, Corpus>(file).map_err(Into::into))
-            .with_context(|| {
-                format!(
-                    "Failed to open and deserialize corpus file at {}",
-                    file_path.as_ref().display()
-                )
-            })?;
-
-        let corpus_directory = file_path
-            .as_ref()
-            .canonicalize()
-            .context("Failed to canonicalize the path to the corpus file")?
-            .parent()
-            .context("Corpus file has no parent")?
-            .to_path_buf();
+            .and_then(|file| serde_json::from_reader::<_, Corpus>(file).map_err(Into::into))?;
 
         for path in corpus.paths_iter_mut() {
-            *path = corpus_directory.join(path.as_path())
+            *path = file_path
+                .as_ref()
+                .parent()
+                .ok_or_else(|| {
+                    anyhow::anyhow!("Corpus path '{}' does not point to a file", path.display())
+                })?
+                .canonicalize()
+                .map_err(|error| {
+                    anyhow::anyhow!(
+                        "Failed to canonicalize path to corpus '{}': {error}",
+                        path.display()
+                    )
+                })?
+                .join(path.as_path())
         }
 
         Ok(corpus)

crates/format/src/input.rs

@@ -8,7 +8,7 @@ use alloy::{
     rpc::types::TransactionRequest,
 };
 use alloy_primitives::{FixedBytes, utils::parse_units};
-use anyhow::Context as _;
+use anyhow::Context;
 use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, stream};
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
@@ -268,11 +268,7 @@ impl Input {
     ) -> anyhow::Result<Bytes> {
         match self.method {
             Method::Deployer | Method::Fallback => {
-                let calldata = self
-                    .calldata
-                    .calldata(resolver, context)
-                    .await
-                    .context("Failed to produce calldata for deployer/fallback method")?;
+                let calldata = self.calldata.calldata(resolver, context).await?;
 
                 Ok(calldata.into())
             }
@@ -287,15 +283,14 @@ impl Input {
                 // Overloads are handled by providing the full function signature in the "function
                 // name".
                 // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
-                let selector =
-                    if function_name.contains('(') && function_name.contains(')') {
-                        Function::parse(function_name)
+                let selector = if function_name.contains('(') && function_name.contains(')') {
+                    Function::parse(function_name)
                         .context(
                             "Failed to parse the provided function name into a function signature",
                         )?
                         .selector()
-                    } else {
-                        abi.functions()
+                } else {
+                    abi.functions()
                         .find(|function| function.signature().starts_with(function_name))
                         .ok_or_else(|| {
                             anyhow::anyhow!(
@@ -303,13 +298,9 @@ impl Input {
                                 function_name,
                                 &self.instance
                             )
-                        })
-                        .with_context(|| format!(
-                            "Failed to resolve function selector for {:?} on instance {:?}",
-                            function_name, &self.instance
-                        ))?
+                        })?
                         .selector()
-                    };
+                };
 
                 // Allocating a vector that we will be using for the calldata. The vector size will be:
                 // 4 bytes for the function selector.
@@ -321,8 +312,7 @@ impl Input {
                 calldata.extend(selector.0);
                 self.calldata
                     .calldata_into_slice(&mut calldata, resolver, context)
-                    .await
-                    .context("Failed to append encoded argument to calldata buffer")?;
+                    .await?;
 
                 Ok(calldata.into())
             }
@@ -335,10 +325,7 @@ impl Input {
         resolver: &impl ResolverApi,
         context: ResolutionContext<'_>,
     ) -> anyhow::Result<TransactionRequest> {
-        let input_data = self
-            .encoded_input(resolver, context)
-            .await
-            .context("Failed to encode input bytes for transaction request")?;
+        let input_data = self.encoded_input(resolver, context).await?;
         let transaction_request = TransactionRequest::default().from(self.caller).value(
             self.value
                 .map(|value| value.into_inner())
@@ -450,8 +437,7 @@ impl Calldata {
                     })
                     .buffered(0xFF)
                     .try_collect::<Vec<_>>()
-                    .await
-                    .context("Failed to resolve one or more calldata arguments")?;
+                    .await?;
 
                 buffer.extend(resolved.into_iter().flatten());
             }
@@ -492,10 +478,7 @@ impl Calldata {
                             std::borrow::Cow::Borrowed(other)
                         };
 
-                        let this = this
-                            .resolve(resolver, context)
-                            .await
-                            .context("Failed to resolve calldata item during equivalence check")?;
+                        let this = this.resolve(resolver, context).await?;
                         let other = U256::from_be_slice(&other);
                         Ok(this == other)
                     })
@@ -681,24 +664,17 @@ impl<T: AsRef<str>> CalldataToken<T> {
 
                     let current_block_number = match context.tip_block_number() {
                         Some(block_number) => *block_number,
-                        None => resolver.last_block_number().await.context(
-                            "Failed to query last block number while resolving $BLOCK_HASH",
-                        )?,
+                        None => resolver.last_block_number().await?,
                     };
                     let desired_block_number = current_block_number.saturating_sub(offset);
 
-                    let block_hash = resolver
-                        .block_hash(desired_block_number.into())
-                        .await
-                        .context("Failed to resolve block hash for desired block number")?;
+                    let block_hash = resolver.block_hash(desired_block_number.into()).await?;
 
                     Ok(U256::from_be_bytes(block_hash.0))
                 } else if item == Self::BLOCK_NUMBER_VARIABLE {
                     let current_block_number = match context.tip_block_number() {
                         Some(block_number) => *block_number,
-                        None => resolver.last_block_number().await.context(
-                            "Failed to query last block number while resolving $BLOCK_NUMBER",
-                        )?,
+                        None => resolver.last_block_number().await?,
                     };
                     Ok(U256::from(current_block_number))
                 } else if item == Self::BLOCK_TIMESTAMP_VARIABLE {

crates/format/src/metadata.rs

@@ -99,7 +99,7 @@ impl Metadata {
     pub fn solc_modes(&self) -> Vec<Mode> {
         match &self.modes {
             Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
-            None => Mode::all().cloned().collect(),
+            None => Mode::all().collect(),
         }
     }
 
@@ -132,15 +132,7 @@ impl Metadata {
         ) in contracts
         {
             let alias = alias.clone();
-            let absolute_path = directory
-                .join(contract_source_path)
-                .canonicalize()
-                .map_err(|error| {
-                    anyhow::anyhow!(
-                        "Failed to canonicalize contract source path '{}': {error}",
-                        directory.join(contract_source_path).display()
-                    )
-                })?;
+            let absolute_path = directory.join(contract_source_path).canonicalize()?;
             let contract_ident = contract_ident.clone();
 
             sources.insert(

crates/format/src/mode.rs

@@ -1,6 +1,4 @@
-use anyhow::Context as _;
 use regex::Regex;
-use revive_dt_common::iterators::EitherIter;
 use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
@@ -46,34 +44,21 @@ impl FromStr for ParsedMode {
         };
 
         let pipeline = match caps.name("pipeline") {
-            Some(m) => Some(
-                ModePipeline::from_str(m.as_str())
-                    .context("Failed to parse mode pipeline from string")?,
-            ),
+            Some(m) => Some(ModePipeline::from_str(m.as_str())?),
             None => None,
         };
 
         let optimize_flag = caps.name("optimize_flag").map(|m| m.as_str() == "+");
 
         let optimize_setting = match caps.name("optimize_setting") {
-            Some(m) => Some(
-                ModeOptimizerSetting::from_str(m.as_str())
-                    .context("Failed to parse optimizer setting from string")?,
-            ),
+            Some(m) => Some(ModeOptimizerSetting::from_str(m.as_str())?),
             None => None,
         };
 
         let version = match caps.name("version") {
-            Some(m) => Some(
-                semver::VersionReq::parse(m.as_str())
-                    .map_err(|e| {
-                        anyhow::anyhow!(
-                            "Cannot parse the version requirement '{}': {e}",
-                            m.as_str()
-                        )
-                    })
-                    .context("Failed to parse semver requirement from mode string")?,
-            ),
+            Some(m) => Some(semver::VersionReq::parse(m.as_str()).map_err(|e| {
+                anyhow::anyhow!("Cannot parse the version requirement '{}': {e}", m.as_str())
+            })?),
             None => None,
         };
 
@@ -177,6 +162,27 @@ impl ParsedMode {
     }
 }
 
+/// An iterator that could be either of two iterators.
+#[derive(Clone, Debug)]
+enum EitherIter<A, B> {
+    A(A),
+    B(B),
+}
+
+impl<A, B> Iterator for EitherIter<A, B>
+where
+    A: Iterator,
+    B: Iterator<Item = A::Item>,
+{
+    type Item = A::Item;
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            EitherIter::A(iter) => iter.next(),
+            EitherIter::B(iter) => iter.next(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/node/src/geth.rs

@@ -17,7 +17,9 @@ use alloy::{
     eips::BlockNumberOrTag,
     genesis::{Genesis, GenesisAccount},
     network::{Ethereum, EthereumWallet, NetworkWallet},
-    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, StorageKey, TxHash, U256},
+    primitives::{
+        Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, StorageKey, TxHash, U256,
+    },
     providers::{
         Provider, ProviderBuilder,
         ext::DebugApi,
@@ -27,8 +29,9 @@ use alloy::{
         EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
         trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
     },
+    signers::local::PrivateKeySigner,
 };
-use anyhow::Context as _;
+use anyhow::Context;
 use revive_common::EVMVersion;
 use tracing::{Instrument, instrument};
 
@@ -36,7 +39,7 @@ use revive_dt_common::{
     fs::clear_directory,
     futures::{PollingWaitBehavior, poll},
 };
-use revive_dt_config::*;
+use revive_dt_config::Arguments;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::EthereumNode;
 
@@ -61,7 +64,7 @@ pub struct GethNode {
     geth: PathBuf,
     id: u32,
     handle: Option<Child>,
-    start_timeout: Duration,
+    start_timeout: u64,
     wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
     chain_id_filler: ChainIdFiller,
@@ -94,15 +97,14 @@ impl GethNode {
 
     /// Create the node directory and call `geth init` to configure the genesis.
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-    fn init(&mut self, mut genesis: Genesis) -> anyhow::Result<&mut Self> {
+    fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
-        create_dir_all(&self.base_directory)
-            .context("Failed to create base directory for geth node")?;
-        create_dir_all(&self.logs_directory)
-            .context("Failed to create logs directory for geth node")?;
+        create_dir_all(&self.base_directory)?;
+        create_dir_all(&self.logs_directory)?;
 
+        let mut genesis = serde_json::from_str::<Genesis>(&genesis)?;
         for signer_address in
             <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
         {
@@ -114,11 +116,7 @@ impl GethNode {
                 .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
         }
         let genesis_path = self.base_directory.join(Self::GENESIS_JSON_FILE);
-        serde_json::to_writer(
-            File::create(&genesis_path).context("Failed to create geth genesis file")?,
-            &genesis,
-        )
-        .context("Failed to serialize geth genesis JSON to file")?;
+        serde_json::to_writer(File::create(&genesis_path)?, &genesis)?;
 
         let mut child = Command::new(&self.geth)
             .arg("--state.scheme")
@@ -129,22 +127,16 @@ impl GethNode {
             .arg(genesis_path)
             .stderr(Stdio::piped())
             .stdout(Stdio::null())
-            .spawn()
-            .context("Failed to spawn geth --init process")?;
+            .spawn()?;
 
         let mut stderr = String::new();
         child
             .stderr
             .take()
             .expect("should be piped")
-            .read_to_string(&mut stderr)
-            .context("Failed to read geth --init stderr")?;
+            .read_to_string(&mut stderr)?;
 
-        if !child
-            .wait()
-            .context("Failed waiting for geth --init process to finish")?
-            .success()
-        {
+        if !child.wait()?.success() {
             anyhow::bail!("failed to initialize geth node #{:?}: {stderr}", &self.id);
         }
 
@@ -169,11 +161,8 @@ impl GethNode {
 
         let stdout_logs_file = open_options
             .clone()
-            .open(self.geth_stdout_log_file_path())
-            .context("Failed to open geth stdout logs file")?;
-        let stderr_logs_file = open_options
-            .open(self.geth_stderr_log_file_path())
-            .context("Failed to open geth stderr logs file")?;
+            .open(self.geth_stdout_log_file_path())?;
+        let stderr_logs_file = open_options.open(self.geth_stderr_log_file_path())?;
         self.handle = Command::new(&self.geth)
             .arg("--dev")
             .arg("--datadir")
@@ -193,24 +182,14 @@ impl GethNode {
             .arg("full")
             .arg("--gcmode")
             .arg("archive")
-            .stderr(
-                stderr_logs_file
-                    .try_clone()
-                    .context("Failed to clone geth stderr log file handle")?,
-            )
-            .stdout(
-                stdout_logs_file
-                    .try_clone()
-                    .context("Failed to clone geth stdout log file handle")?,
-            )
-            .spawn()
-            .context("Failed to spawn geth node process")?
+            .stderr(stderr_logs_file.try_clone()?)
+            .stdout(stdout_logs_file.try_clone()?)
+            .spawn()?
             .into();
 
         if let Err(error) = self.wait_ready() {
             tracing::error!(?error, "Failed to start geth, shutting down gracefully");
-            self.shutdown()
-                .context("Failed to gracefully shutdown after geth start error")?;
+            self.shutdown()?;
             return Err(error);
         }
 
@@ -232,10 +211,9 @@ impl GethNode {
             .write(false)
             .append(false)
             .truncate(false)
-            .open(self.geth_stderr_log_file_path())
-            .context("Failed to open geth stderr logs file for readiness check")?;
+            .open(self.geth_stderr_log_file_path())?;
 
-        let maximum_wait_time = self.start_timeout;
+        let maximum_wait_time = Duration::from_millis(self.start_timeout);
         let mut stderr = BufReader::new(logs_file).lines();
         let mut lines = vec![];
         loop {
@@ -251,7 +229,7 @@ impl GethNode {
             if Instant::now().duration_since(start_time) > maximum_wait_time {
                 anyhow::bail!(
                     "Timeout in starting geth: took longer than {}ms. stdout:\n\n{}\n",
-                    self.start_timeout.as_millis(),
+                    self.start_timeout,
                     lines.join("\n")
                 );
             }
@@ -299,18 +277,11 @@ impl EthereumNode for GethNode {
         &self,
         transaction: TransactionRequest,
     ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let provider = self
-            .provider()
-            .await
-            .context("Failed to create provider for transaction submission")?;
+        let provider = self.provider().await?;
 
-        let pending_transaction = provider
-            .send_transaction(transaction)
-            .await
-            .inspect_err(
-                |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
-            )
-            .context("Failed to submit transaction to geth node")?;
+        let pending_transaction = provider.send_transaction(transaction).await.inspect_err(
+            |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
+        )?;
         let transaction_hash = *pending_transaction.tx_hash();
 
         // The following is a fix for the "transaction indexing is in progress" error that we used
@@ -364,11 +335,7 @@ impl EthereumNode for GethNode {
         transaction: &TransactionReceipt,
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let provider = Arc::new(
-            self.provider()
-                .await
-                .context("Failed to create provider for tracing")?,
-        );
+        let provider = Arc::new(self.provider().await?);
         poll(
             Self::TRACE_POLLING_DURATION,
             PollingWaitBehavior::Constant(Duration::from_millis(200)),
@@ -404,10 +371,8 @@ impl EthereumNode for GethNode {
         });
         match self
             .trace_transaction(transaction, trace_options)
-            .await
-            .context("Failed to trace transaction for prestate diff")?
-            .try_into_pre_state_frame()
-            .context("Failed to convert trace into pre-state frame")?
+            .await?
+            .try_into_pre_state_frame()?
         {
             PreStateFrame::Diff(diff) => Ok(diff),
             _ => anyhow::bail!("expected a diff mode trace"),
@@ -417,8 +382,7 @@ impl EthereumNode for GethNode {
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_balance(address)
             .await
             .map_err(Into::into)
@@ -431,8 +395,7 @@ impl EthereumNode for GethNode {
         keys: Vec<StorageKey>,
     ) -> anyhow::Result<EIP1186AccountProofResponse> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_proof(address, keys)
             .latest()
             .await
@@ -444,8 +407,7 @@ impl ResolverApi for GethNode {
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_chain_id()
             .await
             .map_err(Into::into)
@@ -454,8 +416,7 @@ impl ResolverApi for GethNode {
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_transaction_receipt(*tx_hash)
             .await?
             .context("Failed to get the transaction receipt")
@@ -465,48 +426,40 @@ impl ResolverApi for GethNode {
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.gas_limit as _)
     }
 
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.beneficiary)
     }
 
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .and_then(|block| {
                 block
                     .header
@@ -518,32 +471,27 @@ impl ResolverApi for GethNode {
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.hash)
     }
 
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.timestamp)
     }
 
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_number()
             .await
             .map_err(Into::into)
@@ -551,40 +499,34 @@ impl ResolverApi for GethNode {
 }
 
 impl Node for GethNode {
-    fn new(
-        context: impl AsRef<WorkingDirectoryConfiguration>
-        + AsRef<ConcurrencyConfiguration>
-        + AsRef<GenesisConfiguration>
-        + AsRef<WalletConfiguration>
-        + AsRef<GethConfiguration>
-        + AsRef<KitchensinkConfiguration>
-        + AsRef<ReviveDevNodeConfiguration>
-        + AsRef<EthRpcConfiguration>
-        + Clone,
-    ) -> Self {
-        let working_directory_configuration =
-            AsRef::<WorkingDirectoryConfiguration>::as_ref(&context);
-        let wallet_configuration = AsRef::<WalletConfiguration>::as_ref(&context);
-        let geth_configuration = AsRef::<GethConfiguration>::as_ref(&context);
+    fn name() -> &'static str {
+        "geth"
+    }
 
-        let geth_directory = working_directory_configuration
-            .as_path()
-            .join(Self::BASE_DIRECTORY);
+    fn new(config: &Arguments) -> Self {
+        let geth_directory = config.directory().join(Self::BASE_DIRECTORY);
         let id = NODE_COUNT.fetch_add(1, Ordering::SeqCst);
         let base_directory = geth_directory.join(id.to_string());
 
-        let wallet = wallet_configuration.wallet();
+        let mut wallet = config.wallet();
+        for signer in (1..=config.private_keys_to_add)
+            .map(|id| U256::from(id))
+            .map(|id| id.to_be_bytes::<32>())
+            .map(|id| PrivateKeySigner::from_bytes(&FixedBytes(id)).unwrap())
+        {
+            wallet.register_signer(signer);
+        }
 
         Self {
             connection_string: base_directory.join(Self::IPC_FILE).display().to_string(),
             data_directory: base_directory.join(Self::DATA_DIRECTORY),
             logs_directory: base_directory.join(Self::LOGS_DIRECTORY),
             base_directory,
-            geth: geth_configuration.path.clone(),
+            geth: config.geth.clone(),
             id,
             handle: None,
-            start_timeout: geth_configuration.start_timeout_ms,
-            wallet: wallet.clone(),
+            start_timeout: config.geth_start_timeout,
+            wallet: Arc::new(wallet),
             chain_id_filler: Default::default(),
             nonce_manager: Default::default(),
             // We know that we only need to be storing 2 files so we can specify that when creating
@@ -626,7 +568,7 @@ impl Node for GethNode {
     }
 
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-    fn spawn(&mut self, genesis: Genesis) -> anyhow::Result<()> {
+    fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
         self.init(genesis)?.spawn_process()?;
         Ok(())
     }
@@ -638,10 +580,8 @@ impl Node for GethNode {
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::null())
-            .spawn()
-            .context("Failed to spawn geth --version process")?
-            .wait_with_output()
-            .context("Failed to wait for geth --version output")?
+            .spawn()?
+            .wait_with_output()?
             .stdout;
         Ok(String::from_utf8_lossy(&output).into())
     }
@@ -667,25 +607,49 @@ impl Drop for GethNode {
 
 #[cfg(test)]
 mod tests {
+    use revive_dt_config::Arguments;
+
+    use temp_dir::TempDir;
+
+    use crate::{GENESIS_JSON, Node};
+
     use super::*;
 
-    fn test_config() -> ExecutionContext {
-        ExecutionContext::default()
+    fn test_config() -> (Arguments, TempDir) {
+        let mut config = Arguments::default();
+        let temp_dir = TempDir::new().unwrap();
+        config.working_directory = temp_dir.path().to_path_buf().into();
+
+        (config, temp_dir)
     }
 
-    fn new_node() -> (ExecutionContext, GethNode) {
-        let context = test_config();
-        let mut node = GethNode::new(&context);
-        node.init(context.genesis_configuration.genesis().unwrap().clone())
+    fn new_node() -> (GethNode, TempDir) {
+        let (args, temp_dir) = test_config();
+        let mut node = GethNode::new(&args);
+        node.init(GENESIS_JSON.to_owned())
             .expect("Failed to initialize the node")
             .spawn_process()
             .expect("Failed to spawn the node process");
-        (context, node)
+        (node, temp_dir)
+    }
+
+    #[test]
+    fn init_works() {
+        GethNode::new(&test_config().0)
+            .init(GENESIS_JSON.to_string())
+            .unwrap();
+    }
+
+    #[test]
+    fn spawn_works() {
+        GethNode::new(&test_config().0)
+            .spawn(GENESIS_JSON.to_string())
+            .unwrap();
     }
 
     #[test]
     fn version_works() {
-        let version = GethNode::new(&test_config()).version().unwrap();
+        let version = GethNode::new(&test_config().0).version().unwrap();
         assert!(
             version.starts_with("geth version"),
             "expected version string, got: '{version}'"
@@ -695,7 +659,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_chain_id_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let (node, _temp_dir) = new_node();
 
         // Act
         let chain_id = node.chain_id().await;
@@ -708,7 +672,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_gas_limit_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let (node, _temp_dir) = new_node();
 
         // Act
         let gas_limit = node.block_gas_limit(BlockNumberOrTag::Latest).await;
@@ -721,7 +685,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_coinbase_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let (node, _temp_dir) = new_node();
 
         // Act
         let coinbase = node.block_coinbase(BlockNumberOrTag::Latest).await;
@@ -734,7 +698,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_block_difficulty_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let (node, _temp_dir) = new_node();
 
         // Act
         let block_difficulty = node.block_difficulty(BlockNumberOrTag::Latest).await;
@@ -747,7 +711,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_block_hash_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let (node, _temp_dir) = new_node();
 
         // Act
         let block_hash = node.block_hash(BlockNumberOrTag::Latest).await;
@@ -759,7 +723,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_block_timestamp_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let (node, _temp_dir) = new_node();
 
         // Act
         let block_timestamp = node.block_timestamp(BlockNumberOrTag::Latest).await;
@@ -771,7 +735,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_block_number_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let (node, _temp_dir) = new_node();
 
         // Act
         let block_number = node.last_block_number().await;

crates/node/src/kitchensink.rs

@@ -19,8 +19,8 @@ use alloy::{
         TransactionBuilderError, UnbuiltTransactionError,
     },
     primitives::{
-        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, StorageKey,
-        TxHash, U256,
+        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes,
+        StorageKey, TxHash, U256,
     },
     providers::{
         Provider, ProviderBuilder,
@@ -32,8 +32,9 @@ use alloy::{
         eth::{Block, Header, Transaction},
         trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
     },
+    signers::local::PrivateKeySigner,
 };
-use anyhow::Context as _;
+use anyhow::Context;
 use revive_common::EVMVersion;
 use revive_dt_common::fs::clear_directory;
 use revive_dt_format::traits::ResolverApi;
@@ -42,7 +43,7 @@ use serde_json::{Value as JsonValue, json};
 use sp_core::crypto::Ss58Codec;
 use sp_runtime::AccountId32;
 
-use revive_dt_config::*;
+use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;
 
 use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
@@ -53,7 +54,6 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 pub struct KitchensinkNode {
     id: u32,
     substrate_binary: PathBuf,
-    dev_node_binary: PathBuf,
     eth_proxy_binary: PathBuf,
     rpc_url: String,
     base_directory: PathBuf,
@@ -63,7 +63,6 @@ pub struct KitchensinkNode {
     wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
     chain_id_filler: ChainIdFiller,
-    use_kitchensink_not_dev_node: bool,
     /// This vector stores [`File`] objects that we use for logging which we want to flush when the
     /// node object is dropped. We do not store them in a structured fashion at the moment (in
     /// separate fields) as the logic that we need to apply to them is all the same regardless of
@@ -91,34 +90,26 @@ impl KitchensinkNode {
     const PROXY_STDOUT_LOG_FILE_NAME: &str = "proxy_stdout.log";
     const PROXY_STDERR_LOG_FILE_NAME: &str = "proxy_stderr.log";
 
-    fn init(&mut self, mut genesis: Genesis) -> anyhow::Result<&mut Self> {
+    fn init(&mut self, genesis: &str) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
-        create_dir_all(&self.base_directory)
-            .context("Failed to create base directory for kitchensink node")?;
-        create_dir_all(&self.logs_directory)
-            .context("Failed to create logs directory for kitchensink node")?;
+        create_dir_all(&self.base_directory)?;
+        create_dir_all(&self.logs_directory)?;
 
         let template_chainspec_path = self.base_directory.join(Self::CHAIN_SPEC_JSON_FILE);
 
         // Note: we do not pipe the logs of this process to a separate file since this is just a
         // once-off export of the default chain spec and not part of the long-running node process.
-        let output = if self.use_kitchensink_not_dev_node {
-            Command::new(&self.substrate_binary)
-                .arg("export-chain-spec")
-                .arg("--chain")
-                .arg("dev")
-                .output()
-                .context("Failed to export the chain-spec")?
-        } else {
-            Command::new(&self.dev_node_binary)
-                .arg("build-spec")
-                .arg("--chain")
-                .arg("dev")
-                .output()
-                .context("Failed to export the chain-spec")?
-        };
+        let output = Command::new(&self.substrate_binary)
+            .arg("export-chain-spec")
+            .arg("--chain")
+            .arg("dev")
+            .output()
+            .context(format!(
+                "Failed to export chain spec with {}",
+                self.substrate_binary.display()
+            ))?;
 
         if !output.status.success() {
             anyhow::bail!(
@@ -127,10 +118,8 @@ impl KitchensinkNode {
             );
         }
 
-        let content = String::from_utf8(output.stdout)
-            .context("Failed to decode substrate export-chain-spec output as UTF-8")?;
-        let mut chainspec_json: JsonValue =
-            serde_json::from_str(&content).context("Failed to parse substrate chain spec JSON")?;
+        let content = String::from_utf8(output.stdout)?;
+        let mut chainspec_json: JsonValue = serde_json::from_str(&content)?;
 
         let existing_chainspec_balances =
             chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
@@ -152,6 +141,7 @@ impl KitchensinkNode {
             })
             .collect();
         let mut eth_balances = {
+            let mut genesis = serde_json::from_str::<Genesis>(genesis)?;
             for signer_address in
                 <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
             {
@@ -162,8 +152,7 @@ impl KitchensinkNode {
                     .entry(signer_address)
                     .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
             }
-            self.extract_balance_from_genesis_file(&genesis)
-                .context("Failed to extract balances from EVM genesis JSON")?
+            self.extract_balance_from_genesis_file(&genesis)?
         };
         merged_balances.append(&mut eth_balances);
 
@@ -171,11 +160,9 @@ impl KitchensinkNode {
             json!(merged_balances);
 
         serde_json::to_writer_pretty(
-            std::fs::File::create(&template_chainspec_path)
-                .context("Failed to create kitchensink template chainspec file")?,
+            std::fs::File::create(&template_chainspec_path)?,
             &chainspec_json,
-        )
-        .context("Failed to write kitchensink template chainspec JSON")?;
+        )?;
         Ok(self)
     }
 
@@ -201,18 +188,11 @@ impl KitchensinkNode {
         // Start Substrate node
         let kitchensink_stdout_logs_file = open_options
             .clone()
-            .open(self.kitchensink_stdout_log_file_path())
-            .context("Failed to open kitchensink stdout logs file")?;
+            .open(self.kitchensink_stdout_log_file_path())?;
         let kitchensink_stderr_logs_file = open_options
             .clone()
-            .open(self.kitchensink_stderr_log_file_path())
-            .context("Failed to open kitchensink stderr logs file")?;
-        let node_binary_path = if self.use_kitchensink_not_dev_node {
-            self.substrate_binary.as_path()
-        } else {
-            self.dev_node_binary.as_path()
-        };
-        self.process_substrate = Command::new(node_binary_path)
+            .open(self.kitchensink_stderr_log_file_path())?;
+        self.process_substrate = Command::new(&self.substrate_binary)
             .arg("--dev")
             .arg("--chain")
             .arg(chainspec_path)
@@ -230,18 +210,9 @@ impl KitchensinkNode {
             .arg("--rpc-max-connections")
             .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::SUBSTRATE_LOG_ENV)
-            .stdout(
-                kitchensink_stdout_logs_file
-                    .try_clone()
-                    .context("Failed to clone kitchensink stdout log file handle")?,
-            )
-            .stderr(
-                kitchensink_stderr_logs_file
-                    .try_clone()
-                    .context("Failed to clone kitchensink stderr log file handle")?,
-            )
-            .spawn()
-            .context("Failed to spawn substrate node process")?
+            .stdout(kitchensink_stdout_logs_file.try_clone()?)
+            .stderr(kitchensink_stderr_logs_file.try_clone()?)
+            .spawn()?
             .into();
 
         // Give the node a moment to boot
@@ -250,18 +221,14 @@ impl KitchensinkNode {
             Self::SUBSTRATE_READY_MARKER,
             Duration::from_secs(60),
         ) {
-            self.shutdown()
-                .context("Failed to gracefully shutdown after substrate start error")?;
+            self.shutdown()?;
             return Err(error);
         };
 
         let eth_proxy_stdout_logs_file = open_options
             .clone()
-            .open(self.proxy_stdout_log_file_path())
-            .context("Failed to open eth-proxy stdout logs file")?;
-        let eth_proxy_stderr_logs_file = open_options
-            .open(self.proxy_stderr_log_file_path())
-            .context("Failed to open eth-proxy stderr logs file")?;
+            .open(self.proxy_stdout_log_file_path())?;
+        let eth_proxy_stderr_logs_file = open_options.open(self.proxy_stderr_log_file_path())?;
         self.process_proxy = Command::new(&self.eth_proxy_binary)
             .arg("--dev")
             .arg("--rpc-port")
@@ -271,18 +238,9 @@ impl KitchensinkNode {
             .arg("--rpc-max-connections")
             .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::PROXY_LOG_ENV)
-            .stdout(
-                eth_proxy_stdout_logs_file
-                    .try_clone()
-                    .context("Failed to clone eth-proxy stdout log file handle")?,
-            )
-            .stderr(
-                eth_proxy_stderr_logs_file
-                    .try_clone()
-                    .context("Failed to clone eth-proxy stderr log file handle")?,
-            )
-            .spawn()
-            .context("Failed to spawn eth-proxy process")?
+            .stdout(eth_proxy_stdout_logs_file.try_clone()?)
+            .stderr(eth_proxy_stderr_logs_file.try_clone()?)
+            .spawn()?
             .into();
 
         if let Err(error) = Self::wait_ready(
@@ -290,8 +248,7 @@ impl KitchensinkNode {
             Self::ETH_PROXY_READY_MARKER,
             Duration::from_secs(60),
         ) {
-            self.shutdown()
-                .context("Failed to gracefully shutdown after eth-proxy start error")?;
+            self.shutdown()?;
             return Err(error);
         };
 
@@ -416,14 +373,11 @@ impl EthereumNode for KitchensinkNode {
     ) -> anyhow::Result<TransactionReceipt> {
         let receipt = self
             .provider()
-            .await
-            .context("Failed to create provider for transaction submission")?
+            .await?
             .send_transaction(transaction)
-            .await
-            .context("Failed to submit transaction to kitchensink proxy")?
+            .await?
             .get_receipt()
-            .await
-            .context("Failed to fetch transaction receipt from kitchensink proxy")?;
+            .await?;
         Ok(receipt)
     }
 
@@ -433,12 +387,11 @@ impl EthereumNode for KitchensinkNode {
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
         let tx_hash = transaction.transaction_hash;
-        self.provider()
-            .await
-            .context("Failed to create provider for debug tracing")?
+        Ok(self
+            .provider()
+            .await?
             .debug_trace_transaction(tx_hash, trace_options)
-            .await
-            .context("Failed to obtain debug trace from kitchensink proxy")
+            .await?)
     }
 
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
@@ -459,8 +412,7 @@ impl EthereumNode for KitchensinkNode {
 
     async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_balance(address)
             .await
             .map_err(Into::into)
@@ -472,8 +424,7 @@ impl EthereumNode for KitchensinkNode {
         keys: Vec<StorageKey>,
     ) -> anyhow::Result<EIP1186AccountProofResponse> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_proof(address, keys)
             .latest()
             .await
@@ -484,8 +435,7 @@ impl EthereumNode for KitchensinkNode {
 impl ResolverApi for KitchensinkNode {
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_chain_id()
             .await
             .map_err(Into::into)
@@ -493,8 +443,7 @@ impl ResolverApi for KitchensinkNode {
 
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_transaction_receipt(*tx_hash)
             .await?
             .context("Failed to get the transaction receipt")
@@ -503,45 +452,37 @@ impl ResolverApi for KitchensinkNode {
 
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.gas_limit as _)
     }
 
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.beneficiary)
     }
 
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
     async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .and_then(|block| {
                 block
                     .header
@@ -552,30 +493,25 @@ impl ResolverApi for KitchensinkNode {
 
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.hash)
     }
 
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.timestamp)
     }
 
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_number()
             .await
             .map_err(Into::into)
@@ -583,47 +519,37 @@ impl ResolverApi for KitchensinkNode {
 }
 
 impl Node for KitchensinkNode {
-    fn new(
-        context: impl AsRef<WorkingDirectoryConfiguration>
-        + AsRef<ConcurrencyConfiguration>
-        + AsRef<GenesisConfiguration>
-        + AsRef<WalletConfiguration>
-        + AsRef<GethConfiguration>
-        + AsRef<KitchensinkConfiguration>
-        + AsRef<ReviveDevNodeConfiguration>
-        + AsRef<EthRpcConfiguration>
-        + Clone,
-    ) -> Self {
-        let kitchensink_configuration = AsRef::<KitchensinkConfiguration>::as_ref(&context);
-        let dev_node_configuration = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context);
-        let eth_rpc_configuration = AsRef::<EthRpcConfiguration>::as_ref(&context);
-        let working_directory_configuration =
-            AsRef::<WorkingDirectoryConfiguration>::as_ref(&context);
-        let wallet_configuration = AsRef::<WalletConfiguration>::as_ref(&context);
+    fn name() -> &'static str {
+        "kitchensink"
+    }
 
-        let kitchensink_directory = working_directory_configuration
-            .as_path()
-            .join(Self::BASE_DIRECTORY);
+    fn new(config: &Arguments) -> Self {
+        let kitchensink_directory = config.directory().join(Self::BASE_DIRECTORY);
         let id = NODE_COUNT.fetch_add(1, Ordering::SeqCst);
         let base_directory = kitchensink_directory.join(id.to_string());
         let logs_directory = base_directory.join(Self::LOGS_DIRECTORY);
 
-        let wallet = wallet_configuration.wallet();
+        let mut wallet = config.wallet();
+        for signer in (1..=config.private_keys_to_add)
+            .map(|id| U256::from(id))
+            .map(|id| id.to_be_bytes::<32>())
+            .map(|id| PrivateKeySigner::from_bytes(&FixedBytes(id)).unwrap())
+        {
+            wallet.register_signer(signer);
+        }
 
         Self {
             id,
-            substrate_binary: kitchensink_configuration.path.clone(),
-            dev_node_binary: dev_node_configuration.path.clone(),
-            eth_proxy_binary: eth_rpc_configuration.path.clone(),
+            substrate_binary: config.kitchensink.clone(),
+            eth_proxy_binary: config.eth_proxy.clone(),
             rpc_url: String::new(),
             base_directory,
             logs_directory,
             process_substrate: None,
             process_proxy: None,
-            wallet: wallet.clone(),
+            wallet: Arc::new(wallet),
             chain_id_filler: Default::default(),
             nonce_manager: Default::default(),
-            use_kitchensink_not_dev_node: kitchensink_configuration.use_kitchensink,
             // We know that we only need to be storing 4 files so we can specify that when creating
             // the vector. It's the stdout and stderr of the substrate-node and the eth-rpc.
             logs_file_to_flush: Vec::with_capacity(4),
@@ -664,8 +590,8 @@ impl Node for KitchensinkNode {
         Ok(())
     }
 
-    fn spawn(&mut self, genesis: Genesis) -> anyhow::Result<()> {
-        self.init(genesis)?.spawn_process()
+    fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
+        self.init(&genesis)?.spawn_process()
     }
 
     fn version(&self) -> anyhow::Result<String> {
@@ -674,10 +600,8 @@ impl Node for KitchensinkNode {
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::null())
-            .spawn()
-            .context("Failed to spawn kitchensink --version")?
-            .wait_with_output()
-            .context("Failed to wait for kitchensink --version")?
+            .spawn()?
+            .wait_with_output()?
             .stdout;
         Ok(String::from_utf8_lossy(&output).into())
     }
@@ -1130,20 +1054,24 @@ impl BlockHeader for KitchenSinkHeader {
 #[cfg(test)]
 mod tests {
     use alloy::rpc::types::TransactionRequest;
+    use revive_dt_config::Arguments;
+    use std::path::PathBuf;
     use std::sync::{LazyLock, Mutex};
 
     use std::fs;
 
     use super::*;
-    use crate::Node;
+    use crate::{GENESIS_JSON, Node};
 
-    fn test_config() -> ExecutionContext {
-        let mut context = ExecutionContext::default();
-        context.kitchensink_configuration.use_kitchensink = true;
-        context
+    fn test_config() -> Arguments {
+        Arguments {
+            kitchensink: PathBuf::from("substrate-node"),
+            eth_proxy: PathBuf::from("eth-rpc"),
+            ..Default::default()
+        }
     }
 
-    fn new_node() -> (ExecutionContext, KitchensinkNode) {
+    fn new_node() -> (KitchensinkNode, Arguments) {
         // Note: When we run the tests in the CI we found that if they're all
         // run in parallel then the CI is unable to start all of the nodes in
         // time and their start up times-out. Therefore, we want all of the
@@ -1162,36 +1090,32 @@ mod tests {
         static NODE_START_MUTEX: Mutex<()> = Mutex::new(());
         let _guard = NODE_START_MUTEX.lock().unwrap();
 
-        let context = test_config();
-        let mut node = KitchensinkNode::new(&context);
-        node.init(context.genesis_configuration.genesis().unwrap().clone())
+        let args = test_config();
+        let mut node = KitchensinkNode::new(&args);
+        node.init(GENESIS_JSON)
             .expect("Failed to initialize the node")
             .spawn_process()
             .expect("Failed to spawn the node process");
-        (context, node)
+        (node, args)
     }
 
     /// A shared node that multiple tests can use. It starts up once.
     fn shared_node() -> &'static KitchensinkNode {
-        static NODE: LazyLock<(ExecutionContext, KitchensinkNode)> = LazyLock::new(|| {
-            let (context, node) = new_node();
-            (context, node)
+        static NODE: LazyLock<(KitchensinkNode, Arguments)> = LazyLock::new(|| {
+            let (node, args) = new_node();
+            (node, args)
         });
-        &NODE.1
+        &NODE.0
     }
 
     #[tokio::test]
     async fn node_mines_simple_transfer_transaction_and_returns_receipt() {
         // Arrange
-        let (context, node) = new_node();
+        let (node, args) = new_node();
 
         let provider = node.provider().await.expect("Failed to create provider");
 
-        let account_address = context
-            .wallet_configuration
-            .wallet()
-            .default_signer()
-            .address();
+        let account_address = args.wallet().default_signer().address();
         let transaction = TransactionRequest::default()
             .to(account_address)
             .value(U256::from(100_000_000_000_000u128));
@@ -1225,9 +1149,7 @@ mod tests {
         let mut dummy_node = KitchensinkNode::new(&test_config());
 
         // Call `init()`
-        dummy_node
-            .init(serde_json::from_str(genesis_content).unwrap())
-            .expect("init failed");
+        dummy_node.init(genesis_content).expect("init failed");
 
         // Check that the patched chainspec file was generated
         let final_chainspec_path = dummy_node
@@ -1338,9 +1260,19 @@ mod tests {
     }
 
     #[test]
-    fn version_works() {
-        let node = shared_node();
+    fn spawn_works() {
+        let config = test_config();
 
+        let mut node = KitchensinkNode::new(&config);
+
+        node.spawn(GENESIS_JSON.to_string()).unwrap();
+    }
+
+    #[test]
+    fn version_works() {
+        let config = test_config();
+
+        let node = KitchensinkNode::new(&config);
         let version = node.version().unwrap();
 
         assert!(
@@ -1351,8 +1283,9 @@ mod tests {
 
     #[test]
     fn eth_rpc_version_works() {
-        let node = shared_node();
+        let config = test_config();
 
+        let node = KitchensinkNode::new(&config);
         let version = node.eth_rpc_version().unwrap();
 
         assert!(

crates/node/src/lib.rs

@@ -1,8 +1,7 @@
 //! This crate implements the testing nodes.
 
-use alloy::genesis::Genesis;
 use revive_common::EVMVersion;
-use revive_dt_config::*;
+use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;
 
 pub mod common;
@@ -11,20 +10,16 @@ pub mod geth;
 pub mod kitchensink;
 pub mod pool;
 
+/// The default genesis configuration.
+pub const GENESIS_JSON: &str = include_str!("../../../genesis.json");
+
 /// An abstract interface for testing nodes.
 pub trait Node: EthereumNode {
+    /// The name of the node implementation.
+    fn name() -> &'static str;
+
     /// Create a new uninitialized instance.
-    fn new(
-        context: impl AsRef<WorkingDirectoryConfiguration>
-        + AsRef<ConcurrencyConfiguration>
-        + AsRef<GenesisConfiguration>
-        + AsRef<WalletConfiguration>
-        + AsRef<GethConfiguration>
-        + AsRef<KitchensinkConfiguration>
-        + AsRef<ReviveDevNodeConfiguration>
-        + AsRef<EthRpcConfiguration>
-        + Clone,
-    ) -> Self;
+    fn new(config: &Arguments) -> Self;
 
     /// Returns the identifier of the node.
     fn id(&self) -> usize;
@@ -32,7 +27,7 @@ pub trait Node: EthereumNode {
     /// Spawns a node configured according to the genesis json.
     ///
     /// Blocking until it's ready to accept transactions.
-    fn spawn(&mut self, genesis: Genesis) -> anyhow::Result<()>;
+    fn spawn(&mut self, genesis: String) -> anyhow::Result<()>;
 
     /// Prune the node instance and related data.
     ///

crates/node/src/pool.rs

@@ -5,14 +5,10 @@ use std::{
     thread,
 };
 
-use alloy::genesis::Genesis;
-use anyhow::Context as _;
-use revive_dt_config::{
-    ConcurrencyConfiguration, EthRpcConfiguration, GenesisConfiguration, GethConfiguration,
-    KitchensinkConfiguration, ReviveDevNodeConfiguration, WalletConfiguration,
-    WorkingDirectoryConfiguration,
-};
-use tracing::info;
+use revive_dt_common::cached_fs::read_to_string;
+
+use anyhow::Context;
+use revive_dt_config::Arguments;
 
 use crate::Node;
 
@@ -28,31 +24,18 @@ where
     T: Node + Send + 'static,
 {
     /// Create a new Pool. This will start as many nodes as there are workers in `config`.
-    pub fn new(
-        context: impl AsRef<WorkingDirectoryConfiguration>
-        + AsRef<ConcurrencyConfiguration>
-        + AsRef<GenesisConfiguration>
-        + AsRef<WalletConfiguration>
-        + AsRef<GethConfiguration>
-        + AsRef<KitchensinkConfiguration>
-        + AsRef<ReviveDevNodeConfiguration>
-        + AsRef<EthRpcConfiguration>
-        + Send
-        + Sync
-        + Clone
-        + 'static,
-    ) -> anyhow::Result<Self> {
-        let concurrency_configuration = AsRef::<ConcurrencyConfiguration>::as_ref(&context);
-        let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-
-        let nodes = concurrency_configuration.number_of_nodes;
-        let genesis = genesis_configuration.genesis()?;
+    pub fn new(config: &Arguments) -> anyhow::Result<Self> {
+        let nodes = config.number_of_nodes;
+        let genesis = read_to_string(&config.genesis_file).context(format!(
+            "can not read genesis file: {}",
+            config.genesis_file.display()
+        ))?;
 
         let mut handles = Vec::with_capacity(nodes);
         for _ in 0..nodes {
-            let context = context.clone();
+            let config = config.clone();
             let genesis = genesis.clone();
-            handles.push(thread::spawn(move || spawn_node::<T>(context, genesis)));
+            handles.push(thread::spawn(move || spawn_node::<T>(&config, genesis)));
         }
 
         let mut nodes = Vec::with_capacity(nodes);
@@ -60,10 +43,8 @@ where
             nodes.push(
                 handle
                     .join()
-                    .map_err(|error| anyhow::anyhow!("failed to spawn node: {:?}", error))
-                    .context("Failed to join node spawn thread")?
-                    .map_err(|error| anyhow::anyhow!("node failed to spawn: {error}"))
-                    .context("Node failed to spawn")?,
+                    .map_err(|error| anyhow::anyhow!("failed to spawn node: {:?}", error))?
+                    .map_err(|error| anyhow::anyhow!("node failed to spawn: {error}"))?,
             );
         }
 
@@ -80,31 +61,8 @@ where
     }
 }
 
-fn spawn_node<T: Node + Send>(
-    context: impl AsRef<WorkingDirectoryConfiguration>
-    + AsRef<ConcurrencyConfiguration>
-    + AsRef<GenesisConfiguration>
-    + AsRef<WalletConfiguration>
-    + AsRef<GethConfiguration>
-    + AsRef<KitchensinkConfiguration>
-    + AsRef<ReviveDevNodeConfiguration>
-    + AsRef<EthRpcConfiguration>
-    + Clone
-    + 'static,
-    genesis: Genesis,
-) -> anyhow::Result<T> {
-    let mut node = T::new(context);
-    info!(
-        id = node.id(),
-        connection_string = node.connection_string(),
-        "Spawning node"
-    );
-    node.spawn(genesis)
-        .context("Failed to spawn node process")?;
-    info!(
-        id = node.id(),
-        connection_string = node.connection_string(),
-        "Spawned node"
-    );
+fn spawn_node<T: Node + Send>(args: &Arguments, genesis: String) -> anyhow::Result<T> {
+    let mut node = T::new(args);
+    node.spawn(genesis)?;
     Ok(node)
 }

crates/report/Cargo.toml

@@ -13,16 +13,9 @@ revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
 revive-dt-compiler = { workspace = true }
 
-alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
-paste = { workspace = true }
-indexmap = { workspace = true, features = ["serde"] }
-semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-serde_with = { workspace = true }
-tokio = { workspace = true }
-tracing = { workspace = true }
 
 [lints]
 workspace = true

crates/report/src/aggregator.rs

@@ -1,560 +0,0 @@
-//! Implementation of the report aggregator task which consumes the events sent by the various
-//! reporters and combines them into a single unified report.
-
-use std::{
-    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
-    fs::OpenOptions,
-    path::PathBuf,
-    time::{SystemTime, UNIX_EPOCH},
-};
-
-use alloy_primitives::Address;
-use anyhow::{Context as _, Result};
-use indexmap::IndexMap;
-use revive_dt_compiler::{CompilerInput, CompilerOutput, Mode};
-use revive_dt_config::{Context, TestingPlatform};
-use revive_dt_format::{case::CaseIdx, corpus::Corpus, metadata::ContractInstance};
-use semver::Version;
-use serde::Serialize;
-use serde_with::{DisplayFromStr, serde_as};
-use tokio::sync::{
-    broadcast::{Sender, channel},
-    mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel},
-};
-use tracing::debug;
-
-use crate::*;
-
-pub struct ReportAggregator {
-    /* Internal Report State */
-    report: Report,
-    remaining_cases: HashMap<MetadataFilePath, HashMap<Mode, HashSet<CaseIdx>>>,
-    /* Channels */
-    runner_tx: Option<UnboundedSender<RunnerEvent>>,
-    runner_rx: UnboundedReceiver<RunnerEvent>,
-    listener_tx: Sender<ReporterEvent>,
-}
-
-impl ReportAggregator {
-    pub fn new(context: Context) -> Self {
-        let (runner_tx, runner_rx) = unbounded_channel::<RunnerEvent>();
-        let (listener_tx, _) = channel::<ReporterEvent>(1024);
-        Self {
-            report: Report::new(context),
-            remaining_cases: Default::default(),
-            runner_tx: Some(runner_tx),
-            runner_rx,
-            listener_tx,
-        }
-    }
-
-    pub fn into_task(mut self) -> (Reporter, impl Future<Output = Result<()>>) {
-        let reporter = self
-            .runner_tx
-            .take()
-            .map(Into::into)
-            .expect("Can't fail since this can only be called once");
-        (reporter, async move { self.aggregate().await })
-    }
-
-    async fn aggregate(mut self) -> Result<()> {
-        debug!("Starting to aggregate report");
-
-        while let Some(event) = self.runner_rx.recv().await {
-            debug!(?event, "Received Event");
-            match event {
-                RunnerEvent::SubscribeToEvents(event) => {
-                    self.handle_subscribe_to_events_event(*event);
-                }
-                RunnerEvent::CorpusFileDiscovery(event) => {
-                    self.handle_corpus_file_discovered_event(*event)
-                }
-                RunnerEvent::MetadataFileDiscovery(event) => {
-                    self.handle_metadata_file_discovery_event(*event);
-                }
-                RunnerEvent::TestCaseDiscovery(event) => {
-                    self.handle_test_case_discovery(*event);
-                }
-                RunnerEvent::TestSucceeded(event) => {
-                    self.handle_test_succeeded_event(*event);
-                }
-                RunnerEvent::TestFailed(event) => {
-                    self.handle_test_failed_event(*event);
-                }
-                RunnerEvent::TestIgnored(event) => {
-                    self.handle_test_ignored_event(*event);
-                }
-                RunnerEvent::LeaderNodeAssigned(event) => {
-                    self.handle_leader_node_assigned_event(*event);
-                }
-                RunnerEvent::FollowerNodeAssigned(event) => {
-                    self.handle_follower_node_assigned_event(*event);
-                }
-                RunnerEvent::PreLinkContractsCompilationSucceeded(event) => {
-                    self.handle_pre_link_contracts_compilation_succeeded_event(*event)
-                }
-                RunnerEvent::PostLinkContractsCompilationSucceeded(event) => {
-                    self.handle_post_link_contracts_compilation_succeeded_event(*event)
-                }
-                RunnerEvent::PreLinkContractsCompilationFailed(event) => {
-                    self.handle_pre_link_contracts_compilation_failed_event(*event)
-                }
-                RunnerEvent::PostLinkContractsCompilationFailed(event) => {
-                    self.handle_post_link_contracts_compilation_failed_event(*event)
-                }
-                RunnerEvent::LibrariesDeployed(event) => {
-                    self.handle_libraries_deployed_event(*event);
-                }
-                RunnerEvent::ContractDeployed(event) => {
-                    self.handle_contract_deployed_event(*event);
-                }
-            }
-        }
-        debug!("Report aggregation completed");
-
-        let file_name = {
-            let current_timestamp = SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .context("System clock is before UNIX_EPOCH; cannot compute report timestamp")?
-                .as_secs();
-            let mut file_name = current_timestamp.to_string();
-            file_name.push_str(".json");
-            file_name
-        };
-        let file_path = self
-            .report
-            .context
-            .working_directory_configuration()
-            .as_path()
-            .join(file_name);
-        let file = OpenOptions::new()
-            .create(true)
-            .write(true)
-            .truncate(true)
-            .read(false)
-            .open(&file_path)
-            .with_context(|| {
-                format!(
-                    "Failed to open report file for writing: {}",
-                    file_path.display()
-                )
-            })?;
-        serde_json::to_writer_pretty(&file, &self.report).with_context(|| {
-            format!("Failed to serialize report JSON to {}", file_path.display())
-        })?;
-
-        Ok(())
-    }
-
-    fn handle_subscribe_to_events_event(&self, event: SubscribeToEventsEvent) {
-        let _ = event.tx.send(self.listener_tx.subscribe());
-    }
-
-    fn handle_corpus_file_discovered_event(&mut self, event: CorpusFileDiscoveryEvent) {
-        self.report.corpora.push(event.corpus);
-    }
-
-    fn handle_metadata_file_discovery_event(&mut self, event: MetadataFileDiscoveryEvent) {
-        self.report.metadata_files.insert(event.path.clone());
-    }
-
-    fn handle_test_case_discovery(&mut self, event: TestCaseDiscoveryEvent) {
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .insert(event.test_specifier.case_idx);
-    }
-
-    fn handle_test_succeeded_event(&mut self, event: TestSucceededEvent) {
-        // Remove this from the set of cases we're tracking since it has completed.
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .remove(&event.test_specifier.case_idx);
-
-        // Add information on the fact that the case was ignored to the report.
-        let test_case_report = self.test_case_report(&event.test_specifier);
-        test_case_report.status = Some(TestCaseStatus::Succeeded {
-            steps_executed: event.steps_executed,
-        });
-        self.handle_post_test_case_status_update(&event.test_specifier);
-    }
-
-    fn handle_test_failed_event(&mut self, event: TestFailedEvent) {
-        // Remove this from the set of cases we're tracking since it has completed.
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .remove(&event.test_specifier.case_idx);
-
-        // Add information on the fact that the case was ignored to the report.
-        let test_case_report = self.test_case_report(&event.test_specifier);
-        test_case_report.status = Some(TestCaseStatus::Failed {
-            reason: event.reason,
-        });
-        self.handle_post_test_case_status_update(&event.test_specifier);
-    }
-
-    fn handle_test_ignored_event(&mut self, event: TestIgnoredEvent) {
-        // Remove this from the set of cases we're tracking since it has completed.
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .remove(&event.test_specifier.case_idx);
-
-        // Add information on the fact that the case was ignored to the report.
-        let test_case_report = self.test_case_report(&event.test_specifier);
-        test_case_report.status = Some(TestCaseStatus::Ignored {
-            reason: event.reason,
-            additional_fields: event.additional_fields,
-        });
-        self.handle_post_test_case_status_update(&event.test_specifier);
-    }
-
-    fn handle_post_test_case_status_update(&mut self, specifier: &TestSpecifier) {
-        let remaining_cases = self
-            .remaining_cases
-            .entry(specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(specifier.solc_mode.clone())
-            .or_default();
-        if !remaining_cases.is_empty() {
-            return;
-        }
-
-        let case_status = self
-            .report
-            .test_case_information
-            .entry(specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(specifier.solc_mode.clone())
-            .or_default()
-            .iter()
-            .map(|(case_idx, case_report)| {
-                (
-                    *case_idx,
-                    case_report.status.clone().expect("Can't be uninitialized"),
-                )
-            })
-            .collect::<BTreeMap<_, _>>();
-        let event = ReporterEvent::MetadataFileSolcModeCombinationExecutionCompleted {
-            metadata_file_path: specifier.metadata_file_path.clone().into(),
-            mode: specifier.solc_mode.clone(),
-            case_status,
-        };
-
-        // According to the documentation on send, the sending fails if there are no more receiver
-        // handles. Therefore, this isn't an error that we want to bubble up or anything. If we fail
-        // to send then we ignore the error.
-        let _ = self.listener_tx.send(event);
-    }
-
-    fn handle_leader_node_assigned_event(&mut self, event: LeaderNodeAssignedEvent) {
-        let execution_information = self.execution_information(&ExecutionSpecifier {
-            test_specifier: event.test_specifier,
-            node_id: event.id,
-            node_designation: NodeDesignation::Leader,
-        });
-        execution_information.node = Some(TestCaseNodeInformation {
-            id: event.id,
-            platform: event.platform,
-            connection_string: event.connection_string,
-        });
-    }
-
-    fn handle_follower_node_assigned_event(&mut self, event: FollowerNodeAssignedEvent) {
-        let execution_information = self.execution_information(&ExecutionSpecifier {
-            test_specifier: event.test_specifier,
-            node_id: event.id,
-            node_designation: NodeDesignation::Follower,
-        });
-        execution_information.node = Some(TestCaseNodeInformation {
-            id: event.id,
-            platform: event.platform,
-            connection_string: event.connection_string,
-        });
-    }
-
-    fn handle_pre_link_contracts_compilation_succeeded_event(
-        &mut self,
-        event: PreLinkContractsCompilationSucceededEvent,
-    ) {
-        let include_input = self
-            .report
-            .context
-            .report_configuration()
-            .include_compiler_input;
-        let include_output = self
-            .report
-            .context
-            .report_configuration()
-            .include_compiler_output;
-
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        let compiler_input = if include_input {
-            event.compiler_input
-        } else {
-            None
-        };
-        let compiler_output = if include_output {
-            Some(event.compiler_output)
-        } else {
-            None
-        };
-
-        execution_information.pre_link_compilation_status = Some(CompilationStatus::Success {
-            is_cached: event.is_cached,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input,
-            compiler_output,
-        });
-    }
-
-    fn handle_post_link_contracts_compilation_succeeded_event(
-        &mut self,
-        event: PostLinkContractsCompilationSucceededEvent,
-    ) {
-        let include_input = self
-            .report
-            .context
-            .report_configuration()
-            .include_compiler_input;
-        let include_output = self
-            .report
-            .context
-            .report_configuration()
-            .include_compiler_output;
-
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        let compiler_input = if include_input {
-            event.compiler_input
-        } else {
-            None
-        };
-        let compiler_output = if include_output {
-            Some(event.compiler_output)
-        } else {
-            None
-        };
-
-        execution_information.post_link_compilation_status = Some(CompilationStatus::Success {
-            is_cached: event.is_cached,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input,
-            compiler_output,
-        });
-    }
-
-    fn handle_pre_link_contracts_compilation_failed_event(
-        &mut self,
-        event: PreLinkContractsCompilationFailedEvent,
-    ) {
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        execution_information.pre_link_compilation_status = Some(CompilationStatus::Failure {
-            reason: event.reason,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input: event.compiler_input,
-        });
-    }
-
-    fn handle_post_link_contracts_compilation_failed_event(
-        &mut self,
-        event: PostLinkContractsCompilationFailedEvent,
-    ) {
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        execution_information.post_link_compilation_status = Some(CompilationStatus::Failure {
-            reason: event.reason,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input: event.compiler_input,
-        });
-    }
-
-    fn handle_libraries_deployed_event(&mut self, event: LibrariesDeployedEvent) {
-        self.execution_information(&event.execution_specifier)
-            .deployed_libraries = Some(event.libraries);
-    }
-
-    fn handle_contract_deployed_event(&mut self, event: ContractDeployedEvent) {
-        self.execution_information(&event.execution_specifier)
-            .deployed_contracts
-            .get_or_insert_default()
-            .insert(event.contract_instance, event.address);
-    }
-
-    fn test_case_report(&mut self, specifier: &TestSpecifier) -> &mut TestCaseReport {
-        self.report
-            .test_case_information
-            .entry(specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(specifier.solc_mode.clone())
-            .or_default()
-            .entry(specifier.case_idx)
-            .or_default()
-    }
-
-    fn execution_information(
-        &mut self,
-        specifier: &ExecutionSpecifier,
-    ) -> &mut ExecutionInformation {
-        let test_case_report = self.test_case_report(&specifier.test_specifier);
-        match specifier.node_designation {
-            NodeDesignation::Leader => test_case_report
-                .leader_execution_information
-                .get_or_insert_default(),
-            NodeDesignation::Follower => test_case_report
-                .follower_execution_information
-                .get_or_insert_default(),
-        }
-    }
-}
-
-#[serde_as]
-#[derive(Clone, Debug, Serialize)]
-pub struct Report {
-    /// The context that the tool was started up with.
-    pub context: Context,
-    /// The list of corpus files that the tool found.
-    pub corpora: Vec<Corpus>,
-    /// The list of metadata files that were found by the tool.
-    pub metadata_files: BTreeSet<MetadataFilePath>,
-    /// Information relating to each test case.
-    #[serde_as(as = "BTreeMap<_, HashMap<DisplayFromStr, BTreeMap<DisplayFromStr, _>>>")]
-    pub test_case_information:
-        BTreeMap<MetadataFilePath, HashMap<Mode, BTreeMap<CaseIdx, TestCaseReport>>>,
-}
-
-impl Report {
-    pub fn new(context: Context) -> Self {
-        Self {
-            context,
-            corpora: Default::default(),
-            metadata_files: Default::default(),
-            test_case_information: Default::default(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Default)]
-pub struct TestCaseReport {
-    /// Information on the status of the test case and whether it succeeded, failed, or was ignored.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub status: Option<TestCaseStatus>,
-    /// Information related to the execution on the leader.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub leader_execution_information: Option<ExecutionInformation>,
-    /// Information related to the execution on the follower.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub follower_execution_information: Option<ExecutionInformation>,
-}
-
-/// Information related to the status of the test. Could be that the test succeeded, failed, or that
-/// it was ignored.
-#[derive(Clone, Debug, Serialize)]
-#[serde(tag = "status")]
-pub enum TestCaseStatus {
-    /// The test case succeeded.
-    Succeeded {
-        /// The number of steps of the case that were executed.
-        steps_executed: usize,
-    },
-    /// The test case failed.
-    Failed {
-        /// The reason for the failure of the test case.
-        reason: String,
-    },
-    /// The test case was ignored. This variant carries information related to why it was ignored.
-    Ignored {
-        /// The reason behind the test case being ignored.
-        reason: String,
-        /// Additional fields that describe more information on why the test case is ignored.
-        #[serde(flatten)]
-        additional_fields: IndexMap<String, serde_json::Value>,
-    },
-}
-
-/// Information related to the leader or follower node that's being used to execute the step.
-#[derive(Clone, Debug, Serialize)]
-pub struct TestCaseNodeInformation {
-    /// The ID of the node that this case is being executed on.
-    pub id: usize,
-    /// The platform of the node.
-    pub platform: TestingPlatform,
-    /// The connection string of the node.
-    pub connection_string: String,
-}
-
-/// Execution information tied to the leader or the follower.
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct ExecutionInformation {
-    /// Information related to the node assigned to this test case.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub node: Option<TestCaseNodeInformation>,
-    /// Information on the pre-link compiled contracts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pre_link_compilation_status: Option<CompilationStatus>,
-    /// Information on the post-link compiled contracts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub post_link_compilation_status: Option<CompilationStatus>,
-    /// Information on the deployed libraries.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub deployed_libraries: Option<BTreeMap<ContractInstance, Address>>,
-    /// Information on the deployed contracts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub deployed_contracts: Option<BTreeMap<ContractInstance, Address>>,
-}
-
-/// Information related to compilation
-#[derive(Clone, Debug, Serialize)]
-#[serde(tag = "status")]
-pub enum CompilationStatus {
-    /// The compilation was successful.
-    Success {
-        /// A flag with information on whether the compilation artifacts were cached or not.
-        is_cached: bool,
-        /// The version of the compiler used to compile the contracts.
-        compiler_version: Version,
-        /// The path of the compiler used to compile the contracts.
-        compiler_path: PathBuf,
-        /// The input provided to the compiler to compile the contracts. This is only included if
-        /// the appropriate flag is set in the CLI context and if the contracts were not cached and
-        /// the compiler was invoked.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_input: Option<CompilerInput>,
-        /// The output of the compiler. This is only included if the appropriate flag is set in the
-        /// CLI contexts.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_output: Option<CompilerOutput>,
-    },
-    /// The compilation failed.
-    Failure {
-        /// The failure reason.
-        reason: String,
-        /// The version of the compiler used to compile the contracts.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_version: Option<Version>,
-        /// The path of the compiler used to compile the contracts.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_path: Option<PathBuf>,
-        /// The input provided to the compiler to compile the contracts. This is only included if
-        /// the appropriate flag is set in the CLI context and if the contracts were not cached and
-        /// the compiler was invoked.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_input: Option<CompilerInput>,
-    },
-}

crates/report/src/analyzer.rs

@@ -0,0 +1,81 @@
+//! The report analyzer enriches the raw report data.
+
+use revive_dt_compiler::CompilerOutput;
+use serde::{Deserialize, Serialize};
+
+use crate::reporter::CompilationTask;
+
+/// Provides insights into how well the compilers perform.
+#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
+pub struct CompilerStatistics {
+    /// The sum of contracts observed.
+    pub n_contracts: usize,
+    /// The mean size of compiled contracts.
+    pub mean_code_size: usize,
+    /// The mean size of the optimized YUL IR.
+    pub mean_yul_size: usize,
+    /// Is a proxy because the YUL also contains a lot of comments.
+    pub yul_to_bytecode_size_ratio: f32,
+}
+
+impl CompilerStatistics {
+    /// Cumulatively update the statistics with the next compiler task.
+    pub fn sample(&mut self, compilation_task: &CompilationTask) {
+        let Some(CompilerOutput { contracts }) = &compilation_task.json_output else {
+            return;
+        };
+
+        for (_solidity, contracts) in contracts.iter() {
+            for (_name, (bytecode, _)) in contracts.iter() {
+                // The EVM bytecode can be unlinked and thus is not necessarily a decodable hex
+                // string; for our statistics this is a good enough approximation.
+                let bytecode_size = bytecode.len() / 2;
+
+                // TODO: for the time being we set the yul_size to be zero. We need to change this
+                // when we overhaul the reporting.
+
+                self.update_sizes(bytecode_size, 0);
+            }
+        }
+    }
+
+    /// Updates the size statistics cumulatively.
+    fn update_sizes(&mut self, bytecode_size: usize, yul_size: usize) {
+        let n_previous = self.n_contracts;
+        let n_current = self.n_contracts + 1;
+
+        self.n_contracts = n_current;
+
+        self.mean_code_size = (n_previous * self.mean_code_size + bytecode_size) / n_current;
+        self.mean_yul_size = (n_previous * self.mean_yul_size + yul_size) / n_current;
+
+        if self.mean_code_size > 0 {
+            self.yul_to_bytecode_size_ratio =
+                self.mean_yul_size as f32 / self.mean_code_size as f32;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CompilerStatistics;
+
+    #[test]
+    fn compiler_statistics() {
+        let mut received = CompilerStatistics::default();
+        received.update_sizes(0, 0);
+        received.update_sizes(3, 37);
+        received.update_sizes(123, 456);
+
+        let mean_code_size = 41; // rounding error from integer truncation
+        let mean_yul_size = 164;
+        let expected = CompilerStatistics {
+            n_contracts: 3,
+            mean_code_size,
+            mean_yul_size,
+            yul_to_bytecode_size_ratio: mean_yul_size as f32 / mean_code_size as f32,
+        };
+
+        assert_eq!(received, expected);
+    }
+}

crates/report/src/common.rs

@@ -1,43 +0,0 @@
-//! Common types and functions used throughout the crate.
-
-use std::{path::PathBuf, sync::Arc};
-
-use revive_dt_common::define_wrapper_type;
-use revive_dt_compiler::Mode;
-use revive_dt_format::{case::CaseIdx, input::StepIdx};
-use serde::{Deserialize, Serialize};
-
-define_wrapper_type!(
-    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-    #[serde(transparent)]
-    pub struct MetadataFilePath(PathBuf);
-);
-
-/// An absolute specifier for a test.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct TestSpecifier {
-    pub solc_mode: Mode,
-    pub metadata_file_path: PathBuf,
-    pub case_idx: CaseIdx,
-}
-
-/// An absolute path for a test that also includes information about the node that it's assigned to
-/// and whether it's the leader or follower.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct ExecutionSpecifier {
-    pub test_specifier: Arc<TestSpecifier>,
-    pub node_id: usize,
-    pub node_designation: NodeDesignation,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum NodeDesignation {
-    Leader,
-    Follower,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct StepExecutionSpecifier {
-    pub execution_specifier: Arc<ExecutionSpecifier>,
-    pub step_idx: StepIdx,
-}

crates/report/src/lib.rs

@@ -1,11 +1,4 @@
-//! This crate implements the reporting infrastructure for the differential testing tool.
+//! The revive differential tests reporting facility.
 
-mod aggregator;
-mod common;
-mod reporter_event;
-mod runner_event;
-
-pub use aggregator::*;
-pub use common::*;
-pub use reporter_event::*;
-pub use runner_event::*;
+pub mod analyzer;
+pub mod reporter;

crates/report/src/reporter.rs

@@ -0,0 +1,234 @@
+//! The reporter is the central place observing test execution by collecting data.
+//!
+//! The data collected gives useful insights into the outcome of the test run
+//! and helps identifying and reproducing failing cases.
+
+use std::{
+    collections::HashMap,
+    fs::{self, File, create_dir_all},
+    path::PathBuf,
+    sync::{Mutex, OnceLock},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use anyhow::Context;
+use serde::Serialize;
+
+use revive_dt_common::types::Mode;
+use revive_dt_compiler::{CompilerInput, CompilerOutput};
+use revive_dt_config::{Arguments, TestingPlatform};
+use revive_dt_format::corpus::Corpus;
+
+use crate::analyzer::CompilerStatistics;
+
+pub(crate) static REPORTER: OnceLock<Mutex<Report>> = OnceLock::new();
+
+/// The `Report` datastructure stores all relevant inforamtion required for generating reports.
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct Report {
+    /// The configuration used during the test.
+    pub config: Arguments,
+    /// The observed test corpora.
+    pub corpora: Vec<Corpus>,
+    /// The observed test definitions.
+    pub metadata_files: Vec<PathBuf>,
+    /// The observed compilation results.
+    pub compiler_results: HashMap<TestingPlatform, Vec<CompilationResult>>,
+    /// The observed compilation statistics.
+    pub compiler_statistics: HashMap<TestingPlatform, CompilerStatistics>,
+    /// The file name this is serialized to.
+    #[serde(skip)]
+    directory: PathBuf,
+}
+
+/// Contains a compiled contract.
+#[derive(Clone, Debug, Serialize)]
+pub struct CompilationTask {
+    /// The observed compiler input.
+    pub json_input: CompilerInput,
+    /// The observed compiler output.
+    pub json_output: Option<CompilerOutput>,
+    /// The observed compiler mode.
+    pub mode: Mode,
+    /// The observed compiler version.
+    pub compiler_version: String,
+    /// The observed error, if any.
+    pub error: Option<String>,
+}
+
+/// Represents a report about a compilation task.
+#[derive(Clone, Debug, Serialize)]
+pub struct CompilationResult {
+    /// The observed compilation task.
+    pub compilation_task: CompilationTask,
+    /// The linked span.
+    pub span: Span,
+}
+
+/// The [Span] struct indicates the context of what is being reported.
+#[derive(Clone, Copy, Debug, Serialize)]
+pub struct Span {
+    /// The corpus index this belongs to.
+    corpus: usize,
+    /// The metadata file this belongs to.
+    metadata_file: usize,
+    /// The index of the case definition this belongs to.
+    case: usize,
+    /// The index of the case input this belongs to.
+    input: usize,
+}
+
+impl Report {
+    /// The file name where this report will be written to.
+    pub const FILE_NAME: &str = "report.json";
+
+    /// The [Span] is expected to initialize the reporter by providing the config.
+    const INITIALIZED_VIA_SPAN: &str = "requires a Span which initializes the reporter";
+
+    /// Create a new [Report].
+    fn new(config: Arguments) -> anyhow::Result<Self> {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_millis();
+
+        let directory = config.directory().join("report").join(format!("{now}"));
+        if !directory.exists() {
+            create_dir_all(&directory)?;
+        }
+
+        Ok(Self {
+            config,
+            directory,
+            ..Default::default()
+        })
+    }
+
+    /// Add a compilation task to the report.
+    pub fn compilation(span: Span, platform: TestingPlatform, compilation_task: CompilationTask) {
+        let mut report = REPORTER
+            .get()
+            .expect(Report::INITIALIZED_VIA_SPAN)
+            .lock()
+            .unwrap();
+
+        report
+            .compiler_statistics
+            .entry(platform)
+            .or_default()
+            .sample(&compilation_task);
+
+        report
+            .compiler_results
+            .entry(platform)
+            .or_default()
+            .push(CompilationResult {
+                compilation_task,
+                span,
+            });
+    }
+
+    /// Write the report to disk.
+    pub fn save() -> anyhow::Result<()> {
+        let Some(reporter) = REPORTER.get() else {
+            return Ok(());
+        };
+        let report = reporter.lock().unwrap();
+
+        if let Err(error) = report.write_to_file() {
+            anyhow::bail!("can not write report: {error}");
+        }
+
+        if report.config.extract_problems {
+            if let Err(error) = report.save_compiler_problems() {
+                anyhow::bail!("can not write compiler problems: {error}");
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Write compiler problems to disk for later debugging.
+    pub fn save_compiler_problems(&self) -> anyhow::Result<()> {
+        for (platform, results) in self.compiler_results.iter() {
+            for result in results {
+                // ignore if there were no errors
+                if result.compilation_task.error.is_none() {
+                    continue;
+                }
+
+                let path = &self.metadata_files[result.span.metadata_file]
+                    .parent()
+                    .unwrap()
+                    .join(format!("{platform}_errors"));
+                if !path.exists() {
+                    create_dir_all(path)?;
+                }
+
+                if let Some(error) = result.compilation_task.error.as_ref() {
+                    fs::write(path.join("compiler_error.txt"), error)?;
+                }
+
+                if let Some(errors) = result.compilation_task.json_output.as_ref() {
+                    let file = File::create(path.join("compiler_output.txt"))?;
+                    serde_json::to_writer_pretty(file, &errors)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write_to_file(&self) -> anyhow::Result<()> {
+        let path = self.directory.join(Self::FILE_NAME);
+
+        let file = File::create(&path).context(path.display().to_string())?;
+        serde_json::to_writer_pretty(file, &self)?;
+
+        Ok(())
+    }
+}
+
+impl Span {
+    /// Create a new [Span] with case and input index at 0.
+    ///
+    /// Initializes the reporting facility on the first call.
+    pub fn new(corpus: Corpus, config: Arguments) -> anyhow::Result<Self> {
+        let report = Mutex::new(Report::new(config)?);
+        let mut reporter = REPORTER.get_or_init(|| report).lock().unwrap();
+        reporter.corpora.push(corpus);
+
+        Ok(Self {
+            corpus: reporter.corpora.len() - 1,
+            metadata_file: 0,
+            case: 0,
+            input: 0,
+        })
+    }
+
+    /// Advance to the next metadata file: Resets the case input index to 0.
+    pub fn next_metadata(&mut self, metadata_file: PathBuf) {
+        let mut reporter = REPORTER
+            .get()
+            .expect(Report::INITIALIZED_VIA_SPAN)
+            .lock()
+            .unwrap();
+
+        reporter.metadata_files.push(metadata_file);
+
+        self.metadata_file = reporter.metadata_files.len() - 1;
+        self.case = 0;
+        self.input = 0;
+    }
+
+    /// Advance to the next case: Increas the case index by one and resets the input index to 0.
+    pub fn next_case(&mut self) {
+        self.case += 1;
+        self.input = 0;
+    }
+
+    /// Advance to the next input.
+    pub fn next_input(&mut self) {
+        self.input += 1;
+    }
+}

crates/report/src/reporter_event.rs

@@ -1,22 +0,0 @@
-//! A reporter event sent by the report aggregator to the various listeners.
-
-use std::collections::BTreeMap;
-
-use revive_dt_compiler::Mode;
-use revive_dt_format::case::CaseIdx;
-
-use crate::{MetadataFilePath, TestCaseStatus};
-
-#[derive(Clone, Debug)]
-pub enum ReporterEvent {
-    /// An event sent by the reporter once an entire metadata file and solc mode combination has
-    /// finished execution.
-    MetadataFileSolcModeCombinationExecutionCompleted {
-        /// The path of the metadata file.
-        metadata_file_path: MetadataFilePath,
-        /// The Solc mode that this metadata file was executed in.
-        mode: Mode,
-        /// The status of each one of the cases.
-        case_status: BTreeMap<CaseIdx, TestCaseStatus>,
-    },
-}

crates/report/src/runner_event.rs

@@ -1,642 +0,0 @@
-//! The types associated with the events sent by the runner to the reporter.
-#![allow(dead_code)]
-
-use std::{collections::BTreeMap, path::PathBuf, sync::Arc};
-
-use alloy_primitives::Address;
-use anyhow::Context as _;
-use indexmap::IndexMap;
-use revive_dt_compiler::{CompilerInput, CompilerOutput};
-use revive_dt_config::TestingPlatform;
-use revive_dt_format::metadata::Metadata;
-use revive_dt_format::{corpus::Corpus, metadata::ContractInstance};
-use semver::Version;
-use tokio::sync::{broadcast, oneshot};
-
-use crate::{ExecutionSpecifier, ReporterEvent, TestSpecifier, common::MetadataFilePath};
-
-macro_rules! __report_gen_emit_test_specific {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )*
-        ;
-        $( $aname:ident : $aty:ty, )*
-    ) => {
-        paste::paste! {
-            pub fn [< report_ $variant_ident:snake _event >](
-                &self
-                $(, $bname: impl Into<$bty> )*
-                $(, $aname: impl Into<$aty> )*
-            ) -> anyhow::Result<()> {
-                self.report([< $variant_ident Event >] {
-                    $skip_field: self.test_specifier.clone()
-                    $(, $bname: $bname.into() )*
-                    $(, $aname: $aname.into() )*
-                })
-            }
-        }
-    };
-}
-
-macro_rules! __report_gen_emit_test_specific_by_parse {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )* ; $( $aname:ident : $aty:ty, )*
-    ) => {
-        __report_gen_emit_test_specific!(
-            $ident, $variant_ident, $skip_field;
-            $( $bname : $bty, )* ; $( $aname : $aty, )*
-        );
-    };
-}
-
-macro_rules! __report_gen_scan_before {
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        test_specifier : $skip_ty:ty,
-        $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_emit_test_specific_by_parse!(
-            $ident, $variant_ident, test_specifier;
-            $( $before : $bty, )* ; $( $after : $aty, )*
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        $name:ident : $ty:ty, $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_scan_before!(
-            $ident, $variant_ident;
-            $( $before : $bty, )* $name : $ty,
-            ;
-            $( $after : $aty, )*
-            ;
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        ;
-    ) => {};
-}
-
-macro_rules! __report_gen_for_variant {
-    (
-        $ident:ident,
-        $variant_ident:ident;
-    ) => {};
-    (
-        $ident:ident,
-        $variant_ident:ident;
-        $( $field_ident:ident : $field_ty:ty ),+ $(,)?
-    ) => {
-        __report_gen_scan_before!(
-            $ident, $variant_ident;
-            ;
-            $( $field_ident : $field_ty, )*
-            ;
-        );
-    };
-}
-
-macro_rules! __report_gen_emit_execution_specific {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )*
-        ;
-        $( $aname:ident : $aty:ty, )*
-    ) => {
-        paste::paste! {
-            pub fn [< report_ $variant_ident:snake _event >](
-                &self
-                $(, $bname: impl Into<$bty> )*
-                $(, $aname: impl Into<$aty> )*
-            ) -> anyhow::Result<()> {
-                self.report([< $variant_ident Event >] {
-                    $skip_field: self.execution_specifier.clone()
-                    $(, $bname: $bname.into() )*
-                    $(, $aname: $aname.into() )*
-                })
-            }
-        }
-    };
-}
-
-macro_rules! __report_gen_emit_execution_specific_by_parse {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )* ; $( $aname:ident : $aty:ty, )*
-    ) => {
-        __report_gen_emit_execution_specific!(
-            $ident, $variant_ident, $skip_field;
-            $( $bname : $bty, )* ; $( $aname : $aty, )*
-        );
-    };
-}
-
-macro_rules! __report_gen_scan_before_exec {
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        execution_specifier : $skip_ty:ty,
-        $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_emit_execution_specific_by_parse!(
-            $ident, $variant_ident, execution_specifier;
-            $( $before : $bty, )* ; $( $after : $aty, )*
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        $name:ident : $ty:ty, $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_scan_before_exec!(
-            $ident, $variant_ident;
-            $( $before : $bty, )* $name : $ty,
-            ;
-            $( $after : $aty, )*
-            ;
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        ;
-    ) => {};
-}
-
-macro_rules! __report_gen_for_variant_exec {
-    (
-        $ident:ident,
-        $variant_ident:ident;
-    ) => {};
-    (
-        $ident:ident,
-        $variant_ident:ident;
-        $( $field_ident:ident : $field_ty:ty ),+ $(,)?
-    ) => {
-        __report_gen_scan_before_exec!(
-            $ident, $variant_ident;
-            ;
-            $( $field_ident : $field_ty, )*
-            ;
-        );
-    };
-}
-
-macro_rules! __report_gen_emit_step_execution_specific {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )*
-        ;
-        $( $aname:ident : $aty:ty, )*
-    ) => {
-        paste::paste! {
-            pub fn [< report_ $variant_ident:snake _event >](
-                &self
-                $(, $bname: impl Into<$bty> )*
-                $(, $aname: impl Into<$aty> )*
-            ) -> anyhow::Result<()> {
-                self.report([< $variant_ident Event >] {
-                    $skip_field: self.step_specifier.clone()
-                    $(, $bname: $bname.into() )*
-                    $(, $aname: $aname.into() )*
-                })
-            }
-        }
-    };
-}
-
-macro_rules! __report_gen_emit_step_execution_specific_by_parse {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )* ; $( $aname:ident : $aty:ty, )*
-    ) => {
-        __report_gen_emit_step_execution_specific!(
-            $ident, $variant_ident, $skip_field;
-            $( $bname : $bty, )* ; $( $aname : $aty, )*
-        );
-    };
-}
-
-macro_rules! __report_gen_scan_before_step {
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        step_specifier : $skip_ty:ty,
-        $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_emit_step_execution_specific_by_parse!(
-            $ident, $variant_ident, step_specifier;
-            $( $before : $bty, )* ; $( $after : $aty, )*
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        $name:ident : $ty:ty, $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_scan_before_step!(
-            $ident, $variant_ident;
-            $( $before : $bty, )* $name : $ty,
-            ;
-            $( $after : $aty, )*
-            ;
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        ;
-    ) => {};
-}
-
-macro_rules! __report_gen_for_variant_step {
-    (
-        $ident:ident,
-        $variant_ident:ident;
-    ) => {};
-    (
-        $ident:ident,
-        $variant_ident:ident;
-        $( $field_ident:ident : $field_ty:ty ),+ $(,)?
-    ) => {
-        __report_gen_scan_before_step!(
-            $ident, $variant_ident;
-            ;
-            $( $field_ident : $field_ty, )*
-            ;
-        );
-    };
-}
-
-/// Defines the runner-event which is sent from the test runners to the report aggregator.
-///
-/// This macro defines a number of things related to the reporting infrastructure and the interface
-/// used. First of all, it defines the enum of all of the possible events that the runners can send
-/// to the aggregator. For each one of the variants it defines a separate struct for it to allow the
-/// variant field in the enum to be put in a [`Box`].
-///
-/// In addition to the above, it defines [`From`] implementations for the various event types for
-/// the [`RunnerEvent`] enum essentially allowing for events such as [`CorpusFileDiscoveryEvent`] to
-/// be converted into a [`RunnerEvent`].
-///
-/// In addition to the above, it also defines the [`RunnerEventReporter`] which is a wrapper around
-/// an [`UnboundedSender`] allowing for events to be sent to the report aggregator.
-///
-/// With the above description, we can see that this macro defines almost all of the interface of
-/// the reporting infrastructure, from the enum itself, to its associated types, and also to the
-/// reporter that's used to report events to the aggregator.
-///
-/// [`UnboundedSender`]: tokio::sync::mpsc::UnboundedSender
-macro_rules! define_event {
-    (
-        $(#[$enum_meta: meta])*
-        $vis: vis enum $ident: ident {
-            $(
-                $(#[$variant_meta: meta])*
-                $variant_ident: ident {
-                    $(
-                        $(#[$field_meta: meta])*
-                        $field_ident: ident: $field_ty: ty
-                    ),* $(,)?
-                }
-            ),* $(,)?
-        }
-    ) => {
-        paste::paste! {
-            $(#[$enum_meta])*
-            #[derive(Debug)]
-            $vis enum $ident {
-                $(
-                    $(#[$variant_meta])*
-                    $variant_ident(Box<[<$variant_ident Event>]>)
-                ),*
-            }
-
-            $(
-                #[derive(Debug)]
-                $(#[$variant_meta])*
-                $vis struct [<$variant_ident Event>] {
-                    $(
-                        $(#[$field_meta])*
-                        $vis $field_ident: $field_ty
-                    ),*
-                }
-            )*
-
-            $(
-                impl From<[<$variant_ident Event>]> for $ident {
-                    fn from(value: [<$variant_ident Event>]) -> Self {
-                        Self::$variant_ident(Box::new(value))
-                    }
-                }
-            )*
-
-            /// Provides a way to report events to the aggregator.
-            ///
-            /// Under the hood, this is a wrapper around an [`UnboundedSender`] which abstracts away
-            /// the fact that channels are used and that implements high-level methods for reporting
-            /// various events to the aggregator.
-            #[derive(Clone, Debug)]
-            pub struct [< $ident Reporter >]($vis tokio::sync::mpsc::UnboundedSender<$ident>);
-
-            impl From<tokio::sync::mpsc::UnboundedSender<$ident>> for [< $ident Reporter >] {
-                fn from(value: tokio::sync::mpsc::UnboundedSender<$ident>) -> Self {
-                    Self(value)
-                }
-            }
-
-            impl [< $ident Reporter >] {
-                pub fn test_specific_reporter(
-                    &self,
-                    test_specifier: impl Into<std::sync::Arc<crate::common::TestSpecifier>>
-                ) -> [< $ident TestSpecificReporter >] {
-                    [< $ident TestSpecificReporter >] {
-                        reporter: self.clone(),
-                        test_specifier: test_specifier.into(),
-                    }
-                }
-
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.0.send(event.into()).map_err(Into::into)
-                }
-
-                $(
-                    pub fn [< report_ $variant_ident:snake _event >](&self, $($field_ident: impl Into<$field_ty>),*) -> anyhow::Result<()> {
-                        self.report([< $variant_ident Event >] {
-                            $($field_ident: $field_ident.into()),*
-                        })
-                    }
-                )*
-            }
-
-            /// A reporter that's tied to a specific test case.
-            #[derive(Clone, Debug)]
-            pub struct [< $ident TestSpecificReporter >] {
-                $vis reporter: [< $ident Reporter >],
-                $vis test_specifier: std::sync::Arc<crate::common::TestSpecifier>,
-            }
-
-            impl [< $ident TestSpecificReporter >] {
-                pub fn execution_specific_reporter(
-                    &self,
-                    node_id: impl Into<usize>,
-                    node_designation: impl Into<$crate::common::NodeDesignation>
-                ) -> [< $ident ExecutionSpecificReporter >] {
-                    [< $ident ExecutionSpecificReporter >] {
-                        reporter: self.reporter.clone(),
-                        execution_specifier: Arc::new($crate::common::ExecutionSpecifier {
-                            test_specifier: self.test_specifier.clone(),
-                            node_id: node_id.into(),
-                            node_designation: node_designation.into(),
-                        })
-                    }
-                }
-
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.reporter.report(event)
-                }
-
-                $(
-                    __report_gen_for_variant! { $ident, $variant_ident; $( $field_ident : $field_ty ),* }
-                )*
-            }
-
-            /// A reporter that's tied to a specific execution of the test case such as execution on
-            /// a specific node like the leader or follower.
-            #[derive(Clone, Debug)]
-            pub struct [< $ident ExecutionSpecificReporter >] {
-                $vis reporter: [< $ident Reporter >],
-                $vis execution_specifier: std::sync::Arc<$crate::common::ExecutionSpecifier>,
-            }
-
-            impl [< $ident ExecutionSpecificReporter >] {
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.reporter.report(event)
-                }
-
-                $(
-                    __report_gen_for_variant_exec! { $ident, $variant_ident; $( $field_ident : $field_ty ),* }
-                )*
-            }
-
-            /// A reporter that's tied to a specific step execution
-            #[derive(Clone, Debug)]
-            pub struct [< $ident StepExecutionSpecificReporter >] {
-                $vis reporter: [< $ident Reporter >],
-                $vis step_specifier: std::sync::Arc<$crate::common::StepExecutionSpecifier>,
-            }
-
-            impl [< $ident StepExecutionSpecificReporter >] {
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.reporter.report(event)
-                }
-
-                $(
-                    __report_gen_for_variant_step! { $ident, $variant_ident; $( $field_ident : $field_ty ),* }
-                )*
-            }
-        }
-    };
-}
-
-define_event! {
-    /// An event type that's sent by the test runners/drivers to the report aggregator.
-    pub(crate) enum RunnerEvent {
-        /// An event emitted by the reporter when it wishes to listen to events emitted by the
-        /// aggregator.
-        SubscribeToEvents {
-            /// The channel that the aggregator is to send the receive side of the channel on.
-            tx: oneshot::Sender<broadcast::Receiver<ReporterEvent>>
-        },
-        /// An event emitted by runners when they've discovered a corpus file.
-        CorpusFileDiscovery {
-            /// The contents of the corpus file.
-            corpus: Corpus
-        },
-        /// An event emitted by runners when they've discovered a metadata file.
-        MetadataFileDiscovery {
-            /// The path of the metadata file discovered.
-            path: MetadataFilePath,
-            /// The content of the metadata file.
-            metadata: Metadata
-        },
-        /// An event emitted by the runners when they discover a test case.
-        TestCaseDiscovery {
-            /// A specifier for the test that was discovered.
-            test_specifier: Arc<TestSpecifier>,
-        },
-        /// An event emitted by the runners when a test case is ignored.
-        TestIgnored {
-            /// A specifier for the test that's been ignored.
-            test_specifier: Arc<TestSpecifier>,
-            /// A reason for the test to be ignored.
-            reason: String,
-            /// Additional fields that describe more information on why the test was ignored.
-            additional_fields: IndexMap<String, serde_json::Value>
-        },
-        /// An event emitted by the runners when a test case has succeeded.
-        TestSucceeded {
-            /// A specifier for the test that succeeded.
-            test_specifier: Arc<TestSpecifier>,
-            /// The number of steps of the case that were executed by the driver.
-            steps_executed: usize,
-        },
-        /// An event emitted by the runners when a test case has failed.
-        TestFailed {
-            /// A specifier for the test that succeeded.
-            test_specifier: Arc<TestSpecifier>,
-            /// A reason for the failure of the test.
-            reason: String,
-        },
-        /// An event emitted when the test case is assigned a leader node.
-        LeaderNodeAssigned {
-            /// A specifier for the test that the assignment is for.
-            test_specifier: Arc<TestSpecifier>,
-            /// The ID of the node that this case is being executed on.
-            id: usize,
-            /// The platform of the node.
-            platform: TestingPlatform,
-            /// The connection string of the node.
-            connection_string: String,
-        },
-        /// An event emitted when the test case is assigned a follower node.
-        FollowerNodeAssigned {
-            /// A specifier for the test that the assignment is for.
-            test_specifier: Arc<TestSpecifier>,
-            /// The ID of the node that this case is being executed on.
-            id: usize,
-            /// The platform of the node.
-            platform: TestingPlatform,
-            /// The connection string of the node.
-            connection_string: String,
-        },
-        /// An event emitted by the runners when the compilation of the contracts has succeeded
-        /// on the pre-link contracts.
-        PreLinkContractsCompilationSucceeded {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Version,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: PathBuf,
-            /// A flag of whether the contract bytecode and ABI were cached or if they were compiled
-            /// anew.
-            is_cached: bool,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The output of the compiler.
-            compiler_output: CompilerOutput
-        },
-        /// An event emitted by the runners when the compilation of the contracts has succeeded
-        /// on the post-link contracts.
-        PostLinkContractsCompilationSucceeded {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Version,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: PathBuf,
-            /// A flag of whether the contract bytecode and ABI were cached or if they were compiled
-            /// anew.
-            is_cached: bool,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The output of the compiler.
-            compiler_output: CompilerOutput
-        },
-        /// An event emitted by the runners when the compilation of the pre-link contract has
-        /// failed.
-        PreLinkContractsCompilationFailed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Option<Version>,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: Option<PathBuf>,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The failure reason.
-            reason: String,
-        },
-        /// An event emitted by the runners when the compilation of the post-link contract has
-        /// failed.
-        PostLinkContractsCompilationFailed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Option<Version>,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: Option<PathBuf>,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The failure reason.
-            reason: String,
-        },
-        /// An event emitted by the runners when a library has been deployed.
-        LibrariesDeployed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The addresses of the libraries that were deployed.
-            libraries: BTreeMap<ContractInstance, Address>
-        },
-        /// An event emitted by the runners when they've deployed a new contract.
-        ContractDeployed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The instance name of the contract.
-            contract_instance: ContractInstance,
-            /// The address of the contract.
-            address: Address
-        },
-    }
-}
-
-/// An extension to the [`Reporter`] implemented by the macro.
-impl RunnerEventReporter {
-    pub async fn subscribe(&self) -> anyhow::Result<broadcast::Receiver<ReporterEvent>> {
-        let (tx, rx) = oneshot::channel::<broadcast::Receiver<ReporterEvent>>();
-        self.report_subscribe_to_events_event(tx)
-            .context("Failed to send subscribe request to reporter task")?;
-        rx.await.map_err(Into::into)
-    }
-}
-
-pub type Reporter = RunnerEventReporter;
-pub type TestSpecificReporter = RunnerEventTestSpecificReporter;
-pub type ExecutionSpecificReporter = RunnerEventExecutionSpecificReporter;

crates/solc-binaries/src/cache.rs

@@ -9,11 +9,9 @@ use std::{
     sync::LazyLock,
 };
 
-use semver::Version;
 use tokio::sync::Mutex;
 
 use crate::download::SolcDownloader;
-use anyhow::Context as _;
 
 pub const SOLC_CACHE_DIRECTORY: &str = "solc";
 pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
@@ -21,7 +19,7 @@ pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new
 pub(crate) async fn get_or_download(
     working_directory: &Path,
     downloader: &SolcDownloader,
-) -> anyhow::Result<(Version, PathBuf)> {
+) -> anyhow::Result<PathBuf> {
     let target_directory = working_directory
         .join(SOLC_CACHE_DIRECTORY)
         .join(downloader.version.to_string());
@@ -30,26 +28,14 @@ pub(crate) async fn get_or_download(
     let mut cache = SOLC_CACHER.lock().await;
     if cache.contains(&target_file) {
         tracing::debug!("using cached solc: {}", target_file.display());
-        return Ok((downloader.version.clone(), target_file));
+        return Ok(target_file);
     }
 
-    create_dir_all(&target_directory).with_context(|| {
-        format!(
-            "Failed to create solc cache directory: {}",
-            target_directory.display()
-        )
-    })?;
-    download_to_file(&target_file, downloader)
-        .await
-        .with_context(|| {
-            format!(
-                "Failed to write downloaded solc to {}",
-                target_file.display()
-            )
-        })?;
+    create_dir_all(target_directory)?;
+    download_to_file(&target_file, downloader).await?;
     cache.insert(target_file.clone());
 
-    Ok((downloader.version.clone(), target_file))
+    Ok(target_file)
 }
 
 async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::Result<()> {
@@ -59,26 +45,14 @@ async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::R
 
     #[cfg(unix)]
     {
-        let mut permissions = file
-            .metadata()
-            .with_context(|| format!("Failed to read metadata for {}", path.display()))?
-            .permissions();
+        let mut permissions = file.metadata()?.permissions();
         permissions.set_mode(permissions.mode() | 0o111);
-        file.set_permissions(permissions).with_context(|| {
-            format!("Failed to set executable permissions on {}", path.display())
-        })?;
+        file.set_permissions(permissions)?;
     }
 
     let mut file = BufWriter::new(file);
-    file.write_all(
-        &downloader
-            .download()
-            .await
-            .context("Failed to download solc binary bytes")?,
-    )
-    .with_context(|| format!("Failed to write solc binary to {}", path.display()))?;
-    file.flush()
-        .with_context(|| format!("Failed to flush file {}", path.display()))?;
+    file.write_all(&downloader.download().await?)?;
+    file.flush()?;
     drop(file);
 
     #[cfg(target_os = "macos")]
@@ -89,20 +63,8 @@ async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::R
         .stderr(std::process::Stdio::null())
         .stdout(std::process::Stdio::null())
         .stdout(std::process::Stdio::null())
-        .spawn()
-        .with_context(|| {
-            format!(
-                "Failed to spawn xattr to remove quarantine attribute on {}",
-                path.display()
-            )
-        })?
-        .wait()
-        .with_context(|| {
-            format!(
-                "Failed waiting for xattr operation to complete on {}",
-                path.display()
-            )
-        })?;
+        .spawn()?
+        .wait()?;
 
     Ok(())
 }

crates/solc-binaries/src/download.rs

@@ -11,7 +11,6 @@ use semver::Version;
 use sha2::{Digest, Sha256};
 
 use crate::list::List;
-use anyhow::Context as _;
 
 pub static LIST_CACHE: LazyLock<Mutex<HashMap<&'static str, List>>> =
     LazyLock::new(Default::default);
@@ -31,12 +30,7 @@ impl List {
             return Ok(list.clone());
         }
 
-        let body: List = reqwest::get(url)
-            .await
-            .with_context(|| format!("Failed to GET solc list from {url}"))?
-            .json()
-            .await
-            .with_context(|| format!("Failed to deserialize solc list JSON from {url}"))?;
+        let body: List = reqwest::get(url).await?.json().await?;
 
         LIST_CACHE.lock().unwrap().insert(url, body.clone());
 
@@ -74,8 +68,7 @@ impl SolcDownloader {
             }),
             VersionOrRequirement::Requirement(requirement) => {
                 let Some(version) = List::download(list)
-                    .await
-                    .with_context(|| format!("Failed to download solc builds list from {list}"))?
+                    .await?
                     .builds
                     .into_iter()
                     .map(|build| build.version)
@@ -114,20 +107,11 @@ impl SolcDownloader {
     /// Errors out if the download fails or the digest of the downloaded file
     /// mismatches the expected digest from the release [List].
     pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
-        let builds = List::download(self.list)
-            .await
-            .with_context(|| format!("Failed to download solc builds list from {}", self.list))?
-            .builds;
+        let builds = List::download(self.list).await?.builds;
         let build = builds
             .iter()
             .find(|build| build.version == self.version)
-            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))
-            .with_context(|| {
-                format!(
-                    "Requested solc version {} was not found in builds list fetched from {}",
-                    self.version, self.list
-                )
-            })?;
+            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))?;
 
         let path = build.path.clone();
         let expected_digest = build
@@ -137,13 +121,7 @@ impl SolcDownloader {
             .to_string();
         let url = format!("{}/{}/{}", Self::BASE_URL, self.target, path.display());
 
-        let file = reqwest::get(&url)
-            .await
-            .with_context(|| format!("Failed to GET solc binary from {url}"))?
-            .bytes()
-            .await
-            .with_context(|| format!("Failed to read solc binary bytes from {url}"))?
-            .to_vec();
+        let file = reqwest::get(url).await?.bytes().await?.to_vec();
 
         if hex::encode(Sha256::digest(&file)) != expected_digest {
             anyhow::bail!("sha256 mismatch for solc version {}", self.version);

crates/solc-binaries/src/lib.rs

@@ -5,12 +5,10 @@
 
 use std::path::{Path, PathBuf};
 
-use anyhow::Context as _;
 use cache::get_or_download;
 use download::SolcDownloader;
 
 use revive_dt_common::types::VersionOrRequirement;
-use semver::Version;
 
 pub mod cache;
 pub mod download;
@@ -25,7 +23,7 @@ pub async fn download_solc(
     cache_directory: &Path,
     version: impl Into<VersionOrRequirement>,
     wasm: bool,
-) -> anyhow::Result<(Version, PathBuf)> {
+) -> anyhow::Result<PathBuf> {
     let downloader = if wasm {
         SolcDownloader::wasm(version).await
     } else if cfg!(target_os = "linux") {
@@ -36,8 +34,7 @@ pub async fn download_solc(
         SolcDownloader::windows(version).await
     } else {
         unimplemented!()
-    }
-    .context("Failed to initialize the Solc Downloader")?;
+    }?;
 
     get_or_download(cache_directory, &downloader).await
 }

run_tests.sh

@@ -17,14 +17,6 @@ TEST_REPO_DIR="resolc-compiler-tests"
 CORPUS_FILE="./corpus.json"
 WORKDIR="workdir"
 
-# Optional positional argument: path to polkadot-sdk directory
-POLKADOT_SDK_DIR="${1:-}"
-
-# Binary paths (default to names in $PATH)
-REVIVE_DEV_NODE_BIN="revive-dev-node"
-ETH_RPC_BIN="eth-rpc"
-SUBSTRATE_NODE_BIN="substrate-node"
-
 echo -e "${GREEN}=== Revive Differential Tests Quick Start ===${NC}"
 echo ""
 
@@ -39,38 +31,9 @@ else
     git clone "$TEST_REPO_URL"
 fi
 
-# If polkadot-sdk path is provided, verify and use binaries from there; build if needed
-if [ -n "$POLKADOT_SDK_DIR" ]; then
-    if [ ! -d "$POLKADOT_SDK_DIR" ]; then
-        echo -e "${RED}Provided polkadot-sdk directory does not exist: $POLKADOT_SDK_DIR${NC}"
-        exit 1
-    fi
-
-    POLKADOT_SDK_DIR=$(realpath "$POLKADOT_SDK_DIR")
-    echo -e "${GREEN}Using polkadot-sdk at: $POLKADOT_SDK_DIR${NC}"
-
-    REVIVE_DEV_NODE_BIN="$POLKADOT_SDK_DIR/target/release/revive-dev-node"
-    ETH_RPC_BIN="$POLKADOT_SDK_DIR/target/release/eth-rpc"
-    SUBSTRATE_NODE_BIN="$POLKADOT_SDK_DIR/target/release/substrate-node"
-
-    if [ ! -x "$REVIVE_DEV_NODE_BIN" ] || [ ! -x "$ETH_RPC_BIN" ] || [ ! -x "$SUBSTRATE_NODE_BIN" ]; then
-        echo -e "${YELLOW}Required binaries not found in release target. Building...${NC}"
-        (cd "$POLKADOT_SDK_DIR" && cargo build --release --package staging-node-cli --package pallet-revive-eth-rpc --package revive-dev-node)
-    fi
-
-    for bin in "$REVIVE_DEV_NODE_BIN" "$ETH_RPC_BIN" "$SUBSTRATE_NODE_BIN"; do
-        if [ ! -x "$bin" ]; then
-            echo -e "${RED}Expected binary not found after build: $bin${NC}"
-            exit 1
-        fi
-    done
-else
-    echo -e "${YELLOW}No polkadot-sdk path provided. Using binaries from $PATH.${NC}"
-fi
-
 # Create corpus file with absolute path resolved at runtime
 echo -e "${GREEN}Creating corpus file...${NC}"
-ABSOLUTE_PATH=$(realpath "$TEST_REPO_DIR/fixtures/solidity/")
+ABSOLUTE_PATH=$(realpath "$TEST_REPO_DIR/fixtures/solidity/simple/yul_instructions/codesize.sol")
 
 cat > "$CORPUS_FILE" << EOF
 {
@@ -89,14 +52,10 @@ echo "This may take a while..."
 echo ""
 
 # Run the tool
-RUST_LOG="error" cargo run --release -- execute-tests \
+RUST_LOG="error" cargo run --release -- \
+    --kitchensink "$(realpath ~/polkadot-sdk/target/debug/substrate-node)" \
+    --eth_proxy "$(realpath ~/polkadot-sdk/target/debug/eth-rpc)" \
     --corpus "$CORPUS_FILE" \
-    --working-directory "$WORKDIR" \
-    --concurrency.number-of-nodes 5 \
-    --kitchensink.path "$SUBSTRATE_NODE_BIN" \
-    --revive-dev-node.path "$REVIVE_DEV_NODE_BIN" \
-    --eth-rpc.path "$ETH_RPC_BIN" \
-    > logs.log \
-    2> output.log
+    --workdir "$WORKDIR" \
 
-echo -e "${GREEN}=== Test run completed! ===${NC}"
+echo -e "${GREEN}=== Test run completed! ===${NC}"