Update the kitchensink tests

.gitignore

@@ -8,6 +8,4 @@ node_modules
 # added to the .gitignore file.
 *.log
 
-profile.json.gz
+profile.json.gz
-resolc-compiler-tests
-workdir

Cargo.lock

@@ -4518,6 +4518,7 @@ dependencies = [
  "clap",
  "futures",
  "indexmap 2.10.0",
+ "once_cell",
  "revive-dt-common",
  "revive-dt-compiler",
  "revive-dt-config",
@@ -4529,6 +4530,7 @@ dependencies = [
  "serde",
  "serde_json",
  "temp-dir",
+ "tempfile",
  "tokio",
  "tracing",
  "tracing-appender",

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())
+    for entry in read_dir(path.as_ref())? {
-        .with_context(|| format!("Failed to read directory: {}", path.as_ref().display()))?
+        let entry = entry?;
-    {
-        let entry = entry.with_context(|| {
-            format!(
-                "Failed to read an entry in directory: {}",
-                path.as_ref().display()
-            )
-        })?;
         let entry_path = entry.path();
 
         if entry_path.is_file() {
-            remove_file(&entry_path)
+            remove_file(entry_path)?
-                .with_context(|| format!("Failed to remove file: {}", entry_path.display()))?
         } else {
-            remove_dir_all(&entry_path)
+            remove_dir_all(entry_path)?
-                .with_context(|| format!("Failed to remove directory: {}", entry_path.display()))?
         }
     }
     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()
+        match future().await? {
-            .await
-            .context("Polled future returned an error during polling loop")?
-        {
             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/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> {
+    pub fn all() -> impl Iterator<Item = Mode> {
-        static ALL_MODES: LazyLock<Vec<Mode>> = LazyLock::new(|| {
+        ModePipeline::test_cases().flat_map(|pipeline| {
-            ModePipeline::test_cases()
+            ModeOptimizerSetting::test_cases().map(move |optimize_setting| Mode {
-                .flat_map(|pipeline| {
+                pipeline,
-                    ModeOptimizerSetting::test_cases().map(move |optimize_setting| Mode {
+                optimize_setting,
-                        pipeline,
+                version: None,
-                        optimize_setting,
+            })
-                        version: None,
+        })
-                    })
-                })
-                .collect::<Vec<_>>()
-        });
-        ALL_MODES.iter()
     }
 
     /// 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,7 +13,6 @@ use std::{
 
 use alloy::json_abi::JsonAbi;
 use alloy_primitives::Address;
-use anyhow::{Context, Result};
 use semver::Version;
 use serde::{Deserialize, Serialize};
 
@@ -28,36 +29,36 @@ pub mod revive_resolc;
 pub mod solc;
 
 /// A common interface for all supported Solidity compilers.
-pub trait SolidityCompiler: Sized {
+pub trait SolidityCompiler {
-    /// Instantiates a new compiler object.
+    /// Extra options specific to the compiler.
-    ///
+    type Options: Default + PartialEq + Eq + Hash;
-    /// Based on the given [`Arguments`] 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(
-        config: &Arguments,
-        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;
 
     /// The low-level compiler interface.
-    fn build(&self, input: CompilerInput) -> impl Future<Output = Result<CompilerOutput>>;
+    fn build(
-
-    /// Does the compiler support the provided mode and version settings.
-    fn supports_mode(
         &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>,
@@ -78,12 +79,21 @@ pub struct CompilerOutput {
 }
 
 /// A generic builder style interface for configuring the supported compiler options.
-#[derive(Default)]
+pub struct Compiler<T: SolidityCompiler> {
-pub struct Compiler {
     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 {
@@ -96,6 +106,7 @@ impl Compiler {
                 libraries: Default::default(),
                 revert_string_handling: Default::default(),
             },
+            additional_options: T::Options::default(),
         }
     }
 
@@ -124,11 +135,10 @@ impl Compiler {
         self
     }
 
-    pub fn with_source(mut self, path: impl AsRef<Path>) -> Result<Self> {
+    pub fn with_source(mut self, path: impl AsRef<Path>) -> anyhow::Result<Self> {
-        self.input.sources.insert(
+        self.input
-            path.as_ref().to_path_buf(),
+            .sources
-            read_to_string(path.as_ref()).context("Failed to read the contract source")?,
+            .insert(path.as_ref().to_path_buf(), read_to_string(path.as_ref())?);
-        );
         Ok(self)
     }
 
@@ -154,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)
     }
@@ -162,12 +177,17 @@ impl Compiler {
         callback(self)
     }
 
-    pub async fn try_build(self, compiler: &impl SolidityCompiler) -> Result<CompilerOutput> {
+    pub async fn try_build(
-        compiler.build(self.input).await
+        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 {
+    pub fn input(&self) -> CompilerInput {
-        &self.input
+        self.input.clone()
     }
 }
 

crates/compiler/src/revive_resolc.rs

@@ -3,8 +3,8 @@
 
 use std::{
     path::PathBuf,
-    process::Stdio,
+    process::{Command, Stdio},
-    sync::{Arc, LazyLock},
+    sync::LazyLock,
 };
 
 use dashmap::DashMap;
@@ -16,61 +16,26 @@ use revive_solc_json_interface::{
     SolcStandardJsonOutput,
 };
 
-use crate::{
+use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
-    CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler, solc::Solc,
-};
 
 use alloy::json_abi::JsonAbi;
-use anyhow::{Context, 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.
+// TODO: I believe that we need to also pass the solc compiler to resolc so that resolc uses the
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+// specified solc compiler. I believe that currently we completely ignore the specified solc binary
-pub struct Resolc(Arc<ResolcInner>);
+// 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)]
+/// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
-struct ResolcInner {
+#[derive(Debug)]
-    /// The internal solc compiler that the resolc compiler uses as a compiler frontend.
+pub struct Resolc {
-    solc: Solc,
     /// Path to the `resolc` executable
     resolc_path: PathBuf,
 }
 
 impl SolidityCompiler for Resolc {
-    async fn new(
+    type Options = Vec<String>;
-        config: &Arguments,
-        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 solc = Solc::new(config, 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: config.resolc.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
-    }
 
     #[tracing::instrument(level = "debug", ret)]
     async fn build(
@@ -87,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:?}"
@@ -134,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())
@@ -153,28 +119,18 @@ impl SolidityCompiler for Resolc {
                     .join(","),
             );
         }
-        let mut child = command
+        let mut child = command.spawn()?;
-            .spawn()
-            .with_context(|| format!("Failed to spawn resolc at {}", self.path().display()))?;
 
         let stdin_pipe = child.stdin.as_mut().expect("stdin must be piped");
-        let serialized_input = serde_json::to_vec(&input)
+        let serialized_input = serde_json::to_vec(&input)?;
-            .context("Failed to serialize Standard JSON input for resolc")?;
+        stdin_pipe.write_all(&serialized_input).await?;
-        stdin_pipe
-            .write_all(&serialized_input)
-            .await
-            .context("Failed to write Standard JSON to resolc stdin")?;
 
-        let output = child
+        let output = child.wait_with_output().await?;
-            .wait_with_output()
-            .await
-            .context("Failed while waiting for resolc process to finish")?;
         let stdout = output.stdout;
         let stderr = output.stderr;
 
         if !output.status.success() {
-            let json_in = serde_json::to_string_pretty(&input)
+            let json_in = serde_json::to_string_pretty(&input)?;
-                .context("Failed to pretty-print Standard JSON input for logging")?;
             let message = String::from_utf8_lossy(&stderr);
             tracing::error!(
                 status = %output.status,
@@ -185,14 +141,12 @@ impl SolidityCompiler for Resolc {
             anyhow::bail!("Compilation failed with an error: {message}");
         }
 
-        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout)
+        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout).map_err(|e| {
-            .map_err(|e| {
+            anyhow::anyhow!(
-                anyhow::anyhow!(
+                "failed to parse resolc JSON output: {e}\nstderr: {}",
-                    "failed to parse resolc JSON output: {e}\nstderr: {}",
+                String::from_utf8_lossy(&stderr)
-                    String::from_utf8_lossy(&stderr)
+            )
-                )
+        })?;
-            })
-            .context("Failed to parse resolc standard JSON output")?;
 
         tracing::debug!(
             output = %serde_json::to_string(&parsed).unwrap(),
@@ -219,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()?;
-            let source_path = PathBuf::from(source_path)
-                .canonicalize()
-                .with_context(|| format!("Failed to canonicalize path {src_for_msg}"))?;
 
             let map = compiler_output.contracts.entry(source_path).or_default();
             for (contract_name, contract_information) in contracts.into_iter() {
@@ -230,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 abi = contract_information
-                    let metadata = contract_information
+                    .metadata
-                        .metadata
+                    .as_ref()
-                        .as_ref()
+                    .and_then(|metadata| metadata.as_object())
-                        .context("No metadata found for the contract")?;
+                    .and_then(|metadata| metadata.get("solc_metadata"))
-                    let solc_metadata_str = match metadata {
+                    .and_then(|solc_metadata| solc_metadata.as_str())
-                        serde_json::Value::String(solc_metadata_str) => solc_metadata_str.as_str(),
+                    .and_then(|metadata| serde_json::from_str::<serde_json::Value>(metadata).ok())
-                        serde_json::Value::Object(metadata_object) => {
+                    .and_then(|metadata| {
-                            let solc_metadata_value = metadata_object
+                        metadata.get("output").and_then(|output| {
-                                .get("solc_metadata")
+                            output
-                                .context("Contract doesn't have a 'solc_metadata' field")?;
+                                .get("abi")
-                            solc_metadata_value
+                                .and_then(|abi| serde_json::from_value::<JsonAbi>(abi.clone()).ok())
-                                .as_str()
+                        })
-                                .context("The 'solc_metadata' field is not a string")?
+                    })
-                        }
+                    .context(
-                        serde_json::Value::Null
+                        "Unexpected - Failed to get the ABI for a contract compiled with resolc",
-                        | 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")?
-                };
                 map.insert(contract_name, (bytecode.object, abi));
             }
         }
@@ -272,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,
+        _compiler_version: &Version,
-        optimize_setting: ModeOptimizerSetting,
+        _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,8 +3,8 @@
 
 use std::{
     path::PathBuf,
-    process::Stdio,
+    process::{Command, Stdio},
-    sync::{Arc, LazyLock},
+    sync::LazyLock,
 };
 
 use dashmap::DashMap;
@@ -12,9 +12,10 @@ use revive_dt_common::types::VersionOrRequirement;
 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, Result};
+use anyhow::Context;
 use foundry_compilers_artifacts::{
     output_selection::{
         BytecodeOutputSelection, ContractOutputSelection, EvmOutputSelection, OutputSelection,
@@ -25,54 +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)]
+#[derive(Debug)]
-pub struct Solc(Arc<SolcInner>);
+pub struct Solc {
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct SolcInner {
-    /// The path of the solidity compiler executable that this object uses.
     solc_path: PathBuf,
-    /// The version of the solidity compiler executable that this object uses.
-    solc_version: Version,
 }
 
 impl SolidityCompiler for Solc {
-    async fn new(
+    type Options = ();
-        config: &Arguments,
-        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<Version, Solc>> = LazyLock::new(Default::default);
-
-        // 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(|| config.solc.clone().into());
-        let (version, path) = download_solc(config.directory(), version, false)
-            .await
-            .context("Failed to download/get path to solc binary")?;
-
-        Ok(COMPILERS_CACHE
-            .entry(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
-    }
 
     #[tracing::instrument(level = "debug", ret)]
     async fn build(
@@ -87,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,
         };
@@ -152,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())
@@ -171,25 +134,15 @@ impl SolidityCompiler for Solc {
                     .join(","),
             );
         }
-        let mut child = command
+        let mut child = command.spawn()?;
-            .spawn()
-            .with_context(|| format!("Failed to spawn solc at {}", self.path().display()))?;
 
         let stdin = child.stdin.as_mut().expect("should be piped");
-        let serialized_input = serde_json::to_vec(&input)
+        let serialized_input = serde_json::to_vec(&input)?;
-            .context("Failed to serialize Standard JSON input for solc")?;
+        stdin.write_all(&serialized_input).await?;
-        stdin
+        let output = child.wait_with_output().await?;
-            .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")?;
 
         if !output.status.success() {
-            let json_in = serde_json::to_string_pretty(&input)
+            let json_in = serde_json::to_string_pretty(&input)?;
-                .context("Failed to pretty-print Standard JSON input for logging")?;
             let message = String::from_utf8_lossy(&output.stderr);
             tracing::error!(
                 status = %output.status,
@@ -200,14 +153,12 @@ impl SolidityCompiler for Solc {
             anyhow::bail!("Compilation failed with an error: {message}");
         }
 
-        let parsed = serde_json::from_slice::<SolcOutput>(&output.stdout)
+        let parsed = serde_json::from_slice::<SolcOutput>(&output.stdout).map_err(|e| {
-            .map_err(|e| {
+            anyhow::anyhow!(
-                anyhow::anyhow!(
+                "failed to parse resolc JSON output: {e}\nstderr: {}",
-                    "failed to parse resolc JSON output: {e}\nstderr: {}",
+                String::from_utf8_lossy(&output.stdout)
-                    String::from_utf8_lossy(&output.stdout)
+            )
-                )
+        })?;
-            })
-            .context("Failed to parse solc standard JSON output")?;
 
         // Detecting if the compiler output contained errors and reporting them through logs and
         // errors instead of returning the compiler output that might contain errors.
@@ -227,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(|| {
+                .entry(contract_path.canonicalize()?)
-                    format!(
-                        "Failed to canonicalize contract path {}",
-                        contract_path.display()
-                    )
-                })?)
                 .or_default();
             for (contract_name, contract_info) in contracts.into_iter() {
                 let source_code = contract_info
@@ -253,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 {
+#[cfg(test)]
-    fn compiler_supports_yul(&self) -> bool {
+mod test {
-        const SOLC_VERSION_SUPPORTING_VIA_YUL_IR: Version = Version::new(0, 8, 13);
+    use super::*;
-        self.version() >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
+
+    #[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,6 +1,5 @@
 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::Arguments;
 use semver::Version;
@@ -9,17 +8,17 @@ use semver::Version;
 async fn contracts_can_be_compiled_with_solc() {
     // Arrange
     let args = Arguments::default();
-    let solc = Solc::new(&args, VersionOrRequirement::Version(Version::new(0, 8, 30)))
+    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
@@ -50,17 +49,17 @@ async fn contracts_can_be_compiled_with_solc() {
 async fn contracts_can_be_compiled_with_resolc() {
     // Arrange
     let args = Arguments::default();
-    let resolc = Resolc::new(&args, VersionOrRequirement::Version(Version::new(0, 8, 30)))
+    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/src/lib.rs

@@ -84,6 +84,10 @@ pub struct Arguments {
     #[arg(short, long = "follower", default_value = "kitchensink")]
     pub follower: TestingPlatform,
 
+    /// Only compile against this testing platform (doesn't execute the tests).
+    #[arg(long = "compile-only")]
+    pub compile_only: Option<TestingPlatform>,
+
     /// Determines the amount of nodes that will be spawned for each chain.
     #[arg(long, default_value = "1")]
     pub number_of_nodes: usize,

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 }
@@ -36,6 +37,7 @@ 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,
@@ -10,13 +9,13 @@ use std::{
 
 use futures::FutureExt;
 use revive_dt_common::iterators::FilesWithExtensionIterator;
-use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
+use revive_dt_compiler::{Compiler, CompilerInput, 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 anyhow::{Error, Result};
-use revive_dt_report::ExecutionSpecificReporter;
+use once_cell::sync::Lazy;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use tokio::sync::{Mutex, RwLock};
@@ -24,29 +23,15 @@ use tracing::{Instrument, debug, debug_span, instrument};
 
 use crate::Platform;
 
-pub struct CachedCompiler<'a> {
+pub struct CachedCompiler(ArtifactsCache);
-    /// The cache that stores the compiled contracts.
-    artifacts_cache: ArtifactsCache,
 
-    /// This is a mechanism that the cached compiler uses so that if multiple compilation requests
+impl CachedCompiler {
-    /// 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> {
     pub async fn new(path: impl AsRef<Path>, invalidate_cache: bool) -> Result<Self> {
         let mut cache = ArtifactsCache::new(path);
         if invalidate_cache {
-            cache = cache
+            cache = cache.with_invalidated_cache().await?;
-                .with_invalidated_cache()
-                .await
-                .context("Failed to invalidate compilation cache directory")?;
         }
-        Ok(Self {
+        Ok(Self(cache))
-            artifacts_cache: cache,
-            cache_key_lock: Default::default(),
-        })
     }
 
     /// Compiles or gets the compilation artifacts from the cache.
@@ -55,7 +40,7 @@ impl<'a> CachedCompiler<'a> {
         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 +48,70 @@ impl<'a> CachedCompiler<'a> {
     )]
     pub async fn compile_contracts<P: Platform>(
         &self,
-        metadata: &'a Metadata,
+        metadata: &Metadata,
-        metadata_file_path: &'a Path,
+        metadata_file_path: impl AsRef<Path>,
-        mode: Cow<'a, Mode>,
+        mode: &Mode,
+        config: &Arguments,
         deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-        compiler: &P::Compiler,
+        compilation_success_report_callback: impl Fn(
-        reporter: &ExecutionSpecificReporter,
+            Version,
-    ) -> Result<CompilerOutput> {
+            PathBuf,
+            bool,
+            Option<CompilerInput>,
+            CompilerOutput,
+        ) + Clone,
+        compilation_failure_report_callback: impl Fn(
+            Option<Version>,
+            Option<PathBuf>,
+            Option<CompilerInput>,
+            String,
+        ),
+    ) -> 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
+        .inspect_err(|err| {
+            compilation_failure_report_callback(None, None, None, err.to_string())
+        })?;
+        let compiler_version = <P::Compiler as SolidityCompiler>::new(compiler_path.clone())
+            .version()
+            .await
+            .inspect_err(|err| {
+                compilation_failure_report_callback(
+                    None,
+                    Some(compiler_path.clone()),
+                    None,
+                    err.to_string(),
+                )
+            })?;
+
         let cache_key = CacheKey {
-            platform_key: P::config_id(),
+            platform_key: P::config_id().to_string(),
-            compiler_version: compiler.version().clone(),
+            compiler_version: compiler_version.clone(),
-            metadata_file_path,
+            metadata_file_path: metadata_file_path.as_ref().to_path_buf(),
             solc_mode: mode.clone(),
         };
 
         let compilation_callback = || {
+            let compiler_path = compiler_path.clone();
+            let compiler_version = compiler_version.clone();
+            let compilation_success_report_callback = compilation_success_report_callback.clone();
             async move {
                 compile_contracts::<P>(
-                    metadata
+                    metadata.directory()?,
-                        .directory()
+                    compiler_path,
-                        .context("Failed to get metadata directory while preparing compilation")?,
+                    compiler_version,
-                    metadata
+                    metadata.files_to_compile()?,
-                        .files_to_compile()
+                    mode,
-                        .context("Failed to enumerate files to compile from metadata")?,
-                    &mode,
                     deployed_libraries,
-                    compiler,
+                    compilation_success_report_callback,
-                    reporter,
+                    compilation_failure_report_callback,
                 )
                 .map(|compilation_result| compilation_result.map(CacheValue::new))
                 .await
@@ -109,10 +131,7 @@ impl<'a> CachedCompiler<'a> {
             Some(_) => {
                 debug!("Deployed libraries defined, recompilation must take place");
                 debug!("Cache miss");
-                compilation_callback()
+                compilation_callback().await?.compiler_output
-                    .await
-                    .context("Compilation callback for deployed libraries failed")?
-                    .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 +141,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) => {
+                    Some(value) => value,
-                        drop(read_guard);
-                        value
-                    }
                     None => {
                         drop(read_guard);
-                        self.cache_key_lock
+                        CACHE_KEY_LOCK
                             .write()
                             .await
                             .entry(cache_key.clone())
@@ -140,59 +156,54 @@ impl<'a> CachedCompiler<'a> {
                 };
                 let _guard = mutex.lock().await;
 
-                match self.artifacts_cache.get(&cache_key).await {
+                match self.0.get(&cache_key).await {
                     Some(cache_value) => {
-                        if deployed_libraries.is_some() {
+                        compilation_success_report_callback(
-                            reporter
+                            compiler_version.clone(),
-                                .report_post_link_contracts_compilation_succeeded_event(
+                            compiler_path,
-                                    compiler.version().clone(),
+                            true,
-                                    compiler.path(),
+                            None,
-                                    true,
+                            cache_value.compiler_output.clone(),
-                                    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 => {
+                    None => compilation_callback().await?.compiler_output,
-                        compilation_callback()
-                            .await
-                            .context("Compilation callback failed (cache miss path)")?
-                            .compiler_output
-                    }
                 }
             }
         };
 
-        Ok(compiled_contracts)
+        Ok((compiled_contracts, compiler_version))
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn compile_contracts<P: Platform>(
     metadata_directory: impl AsRef<Path>,
+    compiler_path: impl AsRef<Path>,
+    compiler_version: Version,
     mut files_to_compile: impl Iterator<Item = PathBuf>,
     mode: &Mode,
     deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-    compiler: &P::Compiler,
+    compilation_success_report_callback: impl Fn(
-    reporter: &ExecutionSpecificReporter,
+        Version,
+        PathBuf,
+        bool,
+        Option<CompilerInput>,
+        CompilerOutput,
+    ),
+    compilation_failure_report_callback: impl Fn(
+        Option<Version>,
+        Option<PathBuf>,
+        Option<CompilerInput>,
+        String,
+    ),
 ) -> 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()
+    let compiler = Compiler::<P::Compiler>::new()
         .with_allow_path(metadata_directory)
         // Handling the modes
         .with_optimization(mode.optimize_setting)
@@ -200,6 +211,14 @@ async fn compile_contracts<P: Platform>(
         // Adding the contract sources to the compiler.
         .try_then(|compiler| {
             files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
+        })
+        .inspect_err(|err| {
+            compilation_failure_report_callback(
+                Some(compiler_version.clone()),
+                Some(compiler_path.as_ref().to_path_buf()),
+                None,
+                err.to_string(),
+            )
         })?
         // Adding the deployed libraries to the compiler.
         .then(|compiler| {
@@ -217,55 +236,26 @@ async fn compile_contracts<P: Platform>(
                 })
         });
 
-    let input = compilation.input().clone();
+    let compiler_input = compiler.input();
-    let output = compilation.try_build(compiler).await;
+    let compiler_output = compiler
-
+        .try_build(compiler_path.as_ref())
-    match (output.as_ref(), deployed_libraries.is_some()) {
+        .await
-        (Ok(output), true) => {
+        .inspect_err(|err| {
-            reporter
+            compilation_failure_report_callback(
-                .report_post_link_contracts_compilation_succeeded_event(
+                Some(compiler_version.clone()),
-                    compiler.version().clone(),
+                Some(compiler_path.as_ref().to_path_buf()),
-                    compiler.path(),
+                Some(compiler_input.clone()),
-                    false,
+                err.to_string(),
-                    input,
+            )
-                    output.clone(),
+        })?;
-                )
+    compilation_success_report_callback(
-                .expect("Can't happen");
+        compiler_version,
-        }
+        compiler_path.as_ref().to_path_buf(),
-        (Ok(output), false) => {
+        false,
-            reporter
+        Some(compiler_input),
-                .report_pre_link_contracts_compilation_succeeded_event(
+        compiler_output.clone(),
-                    compiler.version().clone(),
+    );
-                    compiler.path(),
+    Ok(compiler_output)
-                    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
 }
 
 struct ArtifactsCache {
@@ -283,24 +273,19 @@ impl ArtifactsCache {
     pub async fn with_invalidated_cache(self) -> Result<Self> {
         cacache::clear(self.path.as_path())
             .await
-            .map_err(Into::<Error>::into)
+            .map_err(Into::<Error>::into)?;
-            .with_context(|| format!("Failed to clear cache at {}", self.path.display()))?;
         Ok(self)
     }
 
     #[instrument(level = "debug", skip_all, err)]
-    pub async fn insert(&self, key: &CacheKey<'_>, value: &CacheValue) -> Result<()> {
+    pub async fn insert(&self, key: &CacheKey, value: &CacheValue) -> Result<()> {
-        let key = bson::to_vec(key).context("Failed to serialize cache key (bson)")?;
+        let key = bson::to_vec(key)?;
-        let value = bson::to_vec(value).context("Failed to serialize cache value (bson)")?;
+        let value = bson::to_vec(value)?;
-        cacache::write(self.path.as_path(), key.encode_hex(), value)
+        cacache::write(self.path.as_path(), key.encode_hex(), value).await?;
-            .await
-            .with_context(|| {
-                format!("Failed to write cache entry under {}", self.path.display())
-            })?;
         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 +297,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 +315,20 @@ impl ArtifactsCache {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-struct CacheKey<'a> {
+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

@@ -86,22 +86,18 @@ where
     ) -> anyhow::Result<StepOutput> {
         match step {
             Step::FunctionCall(input) => {
-                let (receipt, geth_trace, diff_mode) = self
+                let (receipt, geth_trace, diff_mode) =
-                    .handle_input(metadata, input, node)
+                    self.handle_input(metadata, input, node).await?;
-                    .await
-                    .context("Failed to handle function call step")?;
                 Ok(StepOutput::FunctionCall(receipt, geth_trace, diff_mode))
             }
             Step::BalanceAssertion(balance_assertion) => {
                 self.handle_balance_assertion(metadata, balance_assertion, node)
-                    .await
+                    .await?;
-                    .context("Failed to handle balance assertion step")?;
                 Ok(StepOutput::BalanceAssertion)
             }
             Step::StorageEmptyAssertion(storage_empty) => {
                 self.handle_storage_empty(metadata, storage_empty, node)
-                    .await
+                    .await?;
-                    .context("Failed to handle storage empty assertion step")?;
                 Ok(StepOutput::StorageEmptyAssertion)
             }
         }
@@ -117,23 +113,18 @@ where
     ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
         let deployment_receipts = self
             .handle_input_contract_deployment(metadata, input, node)
-            .await
+            .await?;
-            .context("Failed during contract deployment phase of input handling")?;
         let execution_receipt = self
             .handle_input_execution(input, deployment_receipts, node)
-            .await
+            .await?;
-            .context("Failed during transaction execution phase of input handling")?;
         let tracing_result = self
             .handle_input_call_frame_tracing(&execution_receipt, node)
-            .await
+            .await?;
-            .context("Failed during callframe tracing phase of input handling")?;
+        self.handle_input_variable_assignment(input, &tracing_result)?;
-        self.handle_input_variable_assignment(input, &tracing_result)
-            .context("Failed to assign variables from callframe output")?;
         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 +136,9 @@ where
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
         self.handle_balance_assertion_contract_deployment(metadata, balance_assertion, node)
-            .await
+            .await?;
-            .context("Failed to deploy contract for balance assertion")?;
         self.handle_balance_assertion_execution(balance_assertion, node)
-            .await
+            .await?;
-            .context("Failed to execute balance assertion")?;
         Ok(())
     }
 
@@ -161,11 +150,9 @@ where
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
         self.handle_storage_empty_assertion_contract_deployment(metadata, storage_empty, node)
-            .await
+            .await?;
-            .context("Failed to deploy contract for storage empty assertion")?;
         self.handle_storage_empty_assertion_execution(storage_empty, node)
-            .await
+            .await?;
-            .context("Failed to execute storage empty assertion")?;
         Ok(())
     }
 
@@ -204,8 +191,7 @@ where
                     value,
                     node,
                 )
-                .await
+                .await?
-                .context("Failed to get or deploy contract instance during input execution")?
             {
                 receipts.insert(instance.clone(), receipt);
             }
@@ -227,7 +213,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 +385,7 @@ where
             let actual = &tracing_result.output.as_ref().unwrap_or_default();
             if !expected
                 .is_equivalent(actual, resolver, resolution_context)
-                .await
+                .await?
-                .context("Failed to resolve calldata equivalence for return data assertion")?
             {
                 tracing::error!(
                     ?execution_receipt,
@@ -463,8 +448,7 @@ where
                     let expected = Calldata::new_compound([expected]);
                     if !expected
                         .is_equivalent(&actual.0, resolver, resolution_context)
-                        .await
+                        .await?
-                        .context("Failed to resolve event topic equivalence")?
                     {
                         tracing::error!(
                             event_idx,
@@ -484,8 +468,7 @@ where
                 let actual = &actual_event.data().data;
                 if !expected
                     .is_equivalent(&actual.0, resolver, resolution_context)
-                    .await
+                    .await?
-                    .context("Failed to resolve event value equivalence")?
                 {
                     tracing::error!(
                         event_idx,
@@ -518,12 +501,8 @@ where
 
         let trace = node
             .trace_transaction(execution_receipt, trace_options)
-            .await
+            .await?;
-            .context("Failed to obtain geth prestate tracer output")?;
+        let diff = node.state_diff(execution_receipt).await?;
-        let diff = node
-            .state_diff(execution_receipt)
-            .await
-            .context("Failed to obtain state diff for transaction")?;
 
         Ok((trace, diff))
     }

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 {
+    fn config_id() -> TestingPlatform {
-        &TestingPlatform::Geth
+        TestingPlatform::Geth
     }
 }
 
@@ -41,7 +41,7 @@ impl Platform for Kitchensink {
     type Blockchain = KitchensinkNode;
     type Compiler = revive_resolc::Resolc;
 
-    fn config_id() -> &'static TestingPlatform {
+    fn config_id() -> TestingPlatform {
-        &TestingPlatform::Kitchensink
+        TestingPlatform::Kitchensink
     }
 }

crates/core/src/main.rs

@@ -1,7 +1,6 @@
 mod cached_compiler;
 
 use std::{
-    borrow::Cow,
     collections::{BTreeMap, HashMap},
     io::{BufWriter, Write, stderr},
     path::Path,
@@ -17,20 +16,19 @@ use anyhow::Context;
 use clap::Parser;
 use futures::stream;
 use futures::{Stream, StreamExt};
-use indexmap::{IndexMap, indexmap};
+use indexmap::IndexMap;
 use revive_dt_node_interaction::EthereumNode;
 use revive_dt_report::{
     NodeDesignation, ReportAggregator, Reporter, ReporterEvent, TestCaseStatus,
     TestSpecificReporter, TestSpecifier,
 };
-use serde_json::{Value, json};
 use temp_dir::TempDir;
-use tokio::try_join;
+use tokio::{join, try_join};
-use tracing::{debug, error, info, info_span, instrument};
+use tracing::{debug, info, info_span, instrument};
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
-use revive_dt_common::{iterators::EitherIter, types::Mode};
+use revive_dt_common::types::Mode;
 use revive_dt_compiler::{CompilerOutput, SolidityCompiler};
 use revive_dt_config::*;
 use revive_dt_core::{
@@ -50,8 +48,19 @@ use crate::cached_compiler::CachedCompiler;
 
 static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 
+/// this represents a single "test"; a mode, path and collection of cases.
+#[derive(Clone, Debug)]
+struct Test<'a> {
+    metadata: &'a MetadataFile,
+    metadata_file_path: &'a Path,
+    mode: Mode,
+    case_idx: CaseIdx,
+    case: &'a Case,
+    reporter: TestSpecificReporter,
+}
+
 fn main() -> anyhow::Result<()> {
-    let (args, _guard) = init_cli().context("Failed to initialize CLI and tracing subscriber")?;
+    let (args, _guard) = init_cli()?;
     info!(
         leader = args.leader.to_string(),
         follower = args.follower.to_string(),
@@ -65,8 +74,7 @@ fn main() -> anyhow::Result<()> {
 
     let number_of_threads = args.number_of_threads;
     let body = async move {
-        let tests = collect_corpora(&args)
+        let tests = collect_corpora(&args)?
-            .context("Failed to collect corpus files from provided arguments")?
             .into_iter()
             .inspect(|(corpus, _)| {
                 reporter
@@ -84,9 +92,12 @@ fn main() -> anyhow::Result<()> {
             })
             .collect::<Vec<_>>();
 
-        execute_corpus(&args, &tests, reporter, report_aggregator_task)
+        match &args.compile_only {
-            .await
+            Some(platform) => {
-            .context("Failed to execute corpus")?;
+                compile_corpus(&args, &tests, platform, reporter, report_aggregator_task).await
+            }
+            None => execute_corpus(&args, &tests, reporter, report_aggregator_task).await?,
+        }
         Ok(())
     };
 
@@ -171,22 +182,8 @@ where
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let leader_nodes =
+    let tests = prepare_tests::<L, F>(args, metadata_files, reporter.clone());
-        NodePool::<L::Blockchain>::new(args).context("Failed to initialize leader node pool")?;
+    let driver_task = start_driver_task::<L, F>(args, tests).await?;
-    let follower_nodes =
-        NodePool::<F::Blockchain>::new(args).context("Failed to initialize follower node pool")?;
-
-    let tests_stream = tests_stream(
-        args,
-        metadata_files.iter(),
-        &leader_nodes,
-        &follower_nodes,
-        reporter.clone(),
-    )
-    .await;
-    let driver_task = start_driver_task::<L, F>(args, tests_stream)
-        .await
-        .context("Failed to start driver task")?;
     let cli_reporting_task = start_cli_reporting_task(reporter);
 
     let (_, _, rtn) = tokio::join!(cli_reporting_task, driver_task, report_aggregator_task);
@@ -195,21 +192,19 @@ where
     Ok(())
 }
 
-async fn tests_stream<'a, L, F>(
+fn prepare_tests<'a, L, F>(
     args: &Arguments,
-    metadata_files: impl IntoIterator<Item = &'a MetadataFile> + Clone,
+    metadata_files: &'a [MetadataFile],
-    leader_node_pool: &'a NodePool<L::Blockchain>,
-    follower_node_pool: &'a NodePool<F::Blockchain>,
     reporter: Reporter,
-) -> impl Stream<Item = Test<'a, L, F>>
+) -> impl Stream<Item = Test<'a>>
 where
     L: Platform,
     F: Platform,
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let tests = metadata_files
+    let filtered_tests = metadata_files
-        .into_iter()
+        .iter()
         .flat_map(|metadata_file| {
             metadata_file
                 .cases
@@ -219,128 +214,243 @@ where
         })
         // Flatten over the modes, prefer the case modes over the metadata file modes.
         .flat_map(|(metadata_file, case_idx, case)| {
-            let reporter = reporter.clone();
+            case.modes
-
+                .as_ref()
-            let modes = case.modes.as_ref().or(metadata_file.modes.as_ref());
+                .or(metadata_file.modes.as_ref())
-            let modes = match modes {
+                .map(|modes| ParsedMode::many_to_modes(modes.iter()).collect::<Vec<_>>())
-                Some(modes) => EitherIter::A(
+                .unwrap_or(Mode::all().collect())
-                    ParsedMode::many_to_modes(modes.iter()).map(Cow::<'static, _>::Owned),
+                .into_iter()
-                ),
+                .map(move |mode| (metadata_file, case_idx, case, mode))
-                None => EitherIter::B(Mode::all().map(Cow::<'static, _>::Borrowed)),
-            };
-
-            modes.into_iter().map(move |mode| {
-                (
-                    metadata_file,
-                    case_idx,
-                    case,
-                    mode.clone(),
-                    reporter.test_specific_reporter(Arc::new(TestSpecifier {
-                        solc_mode: mode.as_ref().clone(),
-                        metadata_file_path: metadata_file.metadata_file_path.clone(),
-                        case_idx: CaseIdx::new(case_idx),
-                    })),
-                )
-            })
         })
-        .collect::<Vec<_>>();
+        .map(move |(metadata_file, case_idx, case, mode)| Test {
+            metadata: metadata_file,
+            metadata_file_path: metadata_file.metadata_file_path.as_path(),
+            mode: mode.clone(),
+            case_idx: CaseIdx::new(case_idx),
+            case,
+            reporter: reporter.test_specific_reporter(Arc::new(TestSpecifier {
+                solc_mode: mode.clone(),
+                metadata_file_path: metadata_file.metadata_file_path.clone(),
+                case_idx: CaseIdx::new(case_idx),
+            })),
+        })
+        .inspect(|test| {
+            test.reporter
+                .report_test_case_discovery_event()
+                .expect("Can't fail")
+        })
+        .collect::<Vec<_>>()
+        .into_iter()
+        // Filter the test out if the leader and follower do not support the target.
+        .filter(|test| {
+            let leader_support =
+                <L::Blockchain as Node>::matches_target(test.metadata.targets.as_deref());
+            let follower_support =
+                <F::Blockchain as Node>::matches_target(test.metadata.targets.as_deref());
+            let is_allowed = leader_support && follower_support;
 
-    // Note: before we do any kind of filtering or process the iterator in any way, we need to
+            if !is_allowed {
-    // inform the report aggregator of all of the cases that were found as it keeps a state of the
+                debug!(
-    // test cases for its internal use.
+                    file_path = %test.metadata.relative_path().display(),
-    for (_, _, _, _, reporter) in tests.iter() {
+                    leader_support,
-        reporter
+                    follower_support,
-            .report_test_case_discovery_event()
+                    "Target is not supported, throwing metadata file out"
-            .expect("Can't fail")
+                );
-    }
+                test
+                    .reporter
+                    .report_test_ignored_event(
+                        "Either the leader or the follower do not support the target desired by the test",
+                        IndexMap::from_iter([
+                            (
+                                "test_desired_targets".to_string(),
+                                serde_json::to_value(test.metadata.targets.as_ref())
+                                    .expect("Can't fail")
+                            ),
+                            (
+                                "leader_support".to_string(),
+                                serde_json::to_value(leader_support)
+                                    .expect("Can't fail")
+                            ),
+                            (
+                                "follower_support".to_string(),
+                                serde_json::to_value(follower_support)
+                                    .expect("Can't fail")
+                            )
+                        ])
+                    )
+                    .expect("Can't fail");
+            }
 
-    stream::iter(tests.into_iter())
+            is_allowed
-        .filter_map(
+        })
-            move |(metadata_file, case_idx, case, mode, reporter)| async move {
+        // Filter the test out if the metadata file is ignored.
-                let leader_compiler = <L::Compiler as SolidityCompiler>::new(
+        .filter(|test| {
-                    args,
+            if test.metadata.ignore.is_some_and(|ignore| ignore) {
-                    mode.version.clone().map(Into::into),
+                debug!(
-                )
+                    file_path = %test.metadata.relative_path().display(),
-                .await
+                    "Metadata file is ignored, throwing case out"
-                .inspect_err(|err| error!(?err, "Failed to instantiate the leader compiler"))
+                );
-                .ok()?;
+                test
-
+                    .reporter
-                let follower_compiler = <F::Compiler as SolidityCompiler>::new(
+                    .report_test_ignored_event(
-                    args,
+                        "Metadata file is ignored, therefore all cases are ignored",
-                    mode.version.clone().map(Into::into),
+                        IndexMap::new(),
-                )
+                    )
-                .await
+                    .expect("Can't fail");
-                .inspect_err(|err| error!(?err, "Failed to instantiate the follower compiler"))
+                false
-                .ok()?;
+            } else {
-
+                true
-                let leader_node = leader_node_pool.round_robbin();
-                let follower_node = follower_node_pool.round_robbin();
-
-                Some(Test::<L, F> {
-                    metadata: metadata_file,
-                    metadata_file_path: metadata_file.metadata_file_path.as_path(),
-                    mode: mode.clone(),
-                    case_idx: CaseIdx::new(case_idx),
-                    case,
-                    leader_node,
-                    follower_node,
-                    leader_compiler,
-                    follower_compiler,
-                    reporter,
-                })
-            },
-        )
-        .filter_map(move |test| async move {
-            match test.check_compatibility() {
-                Ok(()) => Some(test),
-                Err((reason, additional_information)) => {
-                    debug!(
-                        metadata_file_path = %test.metadata.metadata_file_path.display(),
-                        case_idx = %test.case_idx,
-                        mode = %test.mode,
-                        reason,
-                        additional_information =
-                            serde_json::to_string(&additional_information).unwrap(),
-
-                        "Ignoring Test Case"
-                    );
-                    test.reporter
-                        .report_test_ignored_event(
-                            reason.to_string(),
-                            additional_information
-                                .into_iter()
-                                .map(|(k, v)| (k.into(), v))
-                                .collect::<IndexMap<_, _>>(),
-                        )
-                        .expect("Can't fail");
-                    None
-                }
             }
         })
+        // Filter the test case if the case is ignored.
+        .filter(|test| {
+            if test.case.ignore.is_some_and(|ignore| ignore) {
+                debug!(
+                    file_path = %test.metadata.relative_path().display(),
+                    case_idx = %test.case_idx,
+                    "Case is ignored, throwing case out"
+                );
+                test
+                    .reporter
+                    .report_test_ignored_event(
+                        "Case is ignored",
+                        IndexMap::new(),
+                    )
+                    .expect("Can't fail");
+                false
+            } else {
+                true
+            }
+        })
+        // Filtering based on the EVM version compatibility
+        .filter(|test| {
+            if let Some(evm_version_requirement) = test.metadata.required_evm_version {
+                let leader_compatibility = evm_version_requirement
+                    .matches(&<L::Blockchain as revive_dt_node::Node>::evm_version());
+                let follower_compatibility = evm_version_requirement
+                    .matches(&<F::Blockchain as revive_dt_node::Node>::evm_version());
+                let is_allowed = leader_compatibility && follower_compatibility;
+
+                if !is_allowed {
+                    debug!(
+                        file_path = %test.metadata.relative_path().display(),
+                        case_idx = %test.case_idx,
+                        leader_compatibility,
+                        follower_compatibility,
+                        "EVM Version is incompatible, throwing case out"
+                    );
+                    test
+                        .reporter
+                        .report_test_ignored_event(
+                            "EVM version is incompatible with either the leader or the follower",
+                            IndexMap::from_iter([
+                                (
+                                    "test_desired_evm_version".to_string(),
+                                    serde_json::to_value(test.metadata.required_evm_version)
+                                        .expect("Can't fail")
+                                ),
+                                (
+                                    "leader_compatibility".to_string(),
+                                    serde_json::to_value(leader_compatibility)
+                                        .expect("Can't fail")
+                                ),
+                                (
+                                    "follower_compatibility".to_string(),
+                                    serde_json::to_value(follower_compatibility)
+                                        .expect("Can't fail")
+                                )
+                            ])
+                        )
+                        .expect("Can't fail");
+                }
+
+                is_allowed
+            } else {
+                true
+            }
+        });
+
+    stream::iter(filtered_tests)
+        // Filter based on the compiler compatibility
+        .filter_map(move |test| async move {
+            let leader_support = does_compiler_support_mode::<L>(args, &test.mode)
+                .await
+                .ok()
+                .unwrap_or(false);
+            let follower_support = does_compiler_support_mode::<F>(args, &test.mode)
+                .await
+                .ok()
+                .unwrap_or(false);
+            let is_allowed = leader_support && follower_support;
+
+            if !is_allowed {
+                debug!(
+                    file_path = %test.metadata.relative_path().display(),
+                    leader_support,
+                    follower_support,
+                    "Compilers do not support this, throwing case out"
+                );
+                test
+                    .reporter
+                    .report_test_ignored_event(
+                        "Compilers do not support this mode either for the leader or for the follower.",
+                        IndexMap::from_iter([
+                            (
+                                "leader_support".to_string(),
+                                serde_json::to_value(leader_support)
+                                    .expect("Can't fail")
+                            ),
+                            (
+                                "follower_support".to_string(),
+                                serde_json::to_value(follower_support)
+                                    .expect("Can't fail")
+                            )
+                        ])
+                    )
+                    .expect("Can't fail");
+            }
+
+            is_allowed.then_some(test)
+        })
+}
+
+async fn does_compiler_support_mode<P: Platform>(
+    args: &Arguments,
+    mode: &Mode,
+) -> anyhow::Result<bool> {
+    let compiler_version_or_requirement = mode.compiler_version_to_use(args.solc.clone());
+    let compiler_path =
+        P::Compiler::get_compiler_executable(args, compiler_version_or_requirement).await?;
+    let compiler_version = P::Compiler::new(compiler_path.clone()).version().await?;
+
+    Ok(P::Compiler::supports_mode(
+        &compiler_version,
+        mode.optimize_setting,
+        mode.pipeline,
+    ))
 }
 
 async fn start_driver_task<'a, L, F>(
     args: &Arguments,
-    tests: impl Stream<Item = Test<'a, L, F>>,
+    tests: impl Stream<Item = Test<'a>>,
 ) -> anyhow::Result<impl Future<Output = ()>>
 where
     L: Platform,
     F: Platform,
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
-    L::Compiler: 'a,
-    F::Compiler: 'a,
 {
     info!("Starting driver task");
 
+    let leader_nodes = Arc::new(NodePool::<L::Blockchain>::new(args)?);
+    let follower_nodes = Arc::new(NodePool::<F::Blockchain>::new(args)?);
     let number_concurrent_tasks = args.number_of_concurrent_tasks();
     let cached_compiler = Arc::new(
         CachedCompiler::new(
             args.directory().join("compilation_cache"),
             args.invalidate_compilation_cache,
         )
-        .await
+        .await?,
-        .context("Failed to initialize cached compiler")?,
     );
 
     Ok(tests.for_each_concurrent(
@@ -353,33 +463,45 @@ where
         // this number will automatically be low enough to address (2). The user can override this.
         Some(number_concurrent_tasks),
         move |test| {
+            let leader_nodes = leader_nodes.clone();
+            let follower_nodes = follower_nodes.clone();
             let cached_compiler = cached_compiler.clone();
 
             async move {
+                let leader_node = leader_nodes.round_robbin();
+                let follower_node = follower_nodes.round_robbin();
+
                 test.reporter
                     .report_leader_node_assigned_event(
-                        test.leader_node.id(),
+                        leader_node.id(),
-                        *L::config_id(),
+                        L::config_id(),
-                        test.leader_node.connection_string(),
+                        leader_node.connection_string(),
                     )
                     .expect("Can't fail");
                 test.reporter
                     .report_follower_node_assigned_event(
-                        test.follower_node.id(),
+                        follower_node.id(),
-                        *F::config_id(),
+                        F::config_id(),
-                        test.follower_node.connection_string(),
+                        follower_node.connection_string(),
                     )
                     .expect("Can't fail");
 
                 let reporter = test.reporter.clone();
-                let result = handle_case_driver::<L, F>(test, cached_compiler).await;
+                let result = handle_case_driver::<L, F>(
+                    test,
+                    args,
+                    cached_compiler,
+                    leader_node,
+                    follower_node,
+                )
+                .await;
 
                 match result {
                     Ok(steps_executed) => reporter
                         .report_test_succeeded_event(steps_executed)
                         .expect("Can't fail"),
                     Err(error) => reporter
-                        .report_test_failed_event(format!("{error:#}"))
+                        .report_test_failed_event(error.to_string())
                         .expect("Can't fail"),
                 }
             }
@@ -424,30 +546,22 @@ async fn start_cli_reporting_task(reporter: Reporter) {
                     number_of_successes += 1;
                     writeln!(
                         buf,
-                        "{}{}Case Succeeded{} - Steps Executed: {}{}",
+                        "{}{}Case Succeeded{}{} - Steps Executed: {}",
-                        GREEN, BOLD, BOLD_RESET, steps_executed, COLOR_RESET
+                        GREEN, BOLD, BOLD_RESET, COLOR_RESET, steps_executed
                     )
                 }
                 TestCaseStatus::Failed { reason } => {
                     number_of_failures += 1;
                     writeln!(
                         buf,
-                        "{}{}Case Failed{} - Reason: {}{}",
+                        "{}{}Case Failed{}{} - Reason: {}",
-                        RED,
+                        RED, BOLD, BOLD_RESET, COLOR_RESET, reason
-                        BOLD,
-                        BOLD_RESET,
-                        reason.trim(),
-                        COLOR_RESET,
                     )
                 }
                 TestCaseStatus::Ignored { reason, .. } => writeln!(
                     buf,
-                    "{}{}Case Ignored{} - Reason: {}{}",
+                    "{}{}Case Ignored{}{} - Reason: {}",
-                    GREY,
+                    GREY, BOLD, BOLD_RESET, COLOR_RESET, reason
-                    BOLD,
-                    BOLD_RESET,
-                    reason.trim(),
-                    COLOR_RESET,
                 ),
             };
         }
@@ -479,62 +593,105 @@ async fn start_cli_reporting_task(reporter: Reporter) {
         mode = %test.mode,
         case_idx = %test.case_idx,
         case_name = test.case.name.as_deref().unwrap_or("Unnamed Case"),
-        leader_node = test.leader_node.id(),
+        leader_node = leader_node.id(),
-        follower_node = test.follower_node.id(),
+        follower_node = follower_node.id(),
     )
 )]
-async fn handle_case_driver<'a, L, F>(
+async fn handle_case_driver<L, F>(
-    test: Test<'a, L, F>,
+    test: Test<'_>,
-    cached_compiler: Arc<CachedCompiler<'a>>,
+    config: &Arguments,
+    cached_compiler: Arc<CachedCompiler>,
+    leader_node: &L::Blockchain,
+    follower_node: &F::Blockchain,
 ) -> anyhow::Result<usize>
 where
     L: Platform,
     F: Platform,
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
-    L::Compiler: 'a,
-    F::Compiler: 'a,
 {
     let leader_reporter = test
         .reporter
-        .execution_specific_reporter(test.leader_node.id(), NodeDesignation::Leader);
+        .execution_specific_reporter(leader_node.id(), NodeDesignation::Leader);
     let follower_reporter = test
         .reporter
-        .execution_specific_reporter(test.follower_node.id(), NodeDesignation::Follower);
+        .execution_specific_reporter(follower_node.id(), NodeDesignation::Follower);
 
     let (
-        CompilerOutput {
+        (
-            contracts: leader_pre_link_contracts,
+            CompilerOutput {
-        },
+                contracts: leader_pre_link_contracts,
-        CompilerOutput {
+            },
-            contracts: follower_pre_link_contracts,
+            _,
-        },
+        ),
+        (
+            CompilerOutput {
+                contracts: follower_pre_link_contracts,
+            },
+            _,
+        ),
     ) = try_join!(
         cached_compiler.compile_contracts::<L>(
             test.metadata,
             test.metadata_file_path,
-            test.mode.clone(),
+            &test.mode,
+            config,
             None,
-            &test.leader_compiler,
+            |compiler_version, compiler_path, is_cached, compiler_input, compiler_output| {
-            &leader_reporter,
+                leader_reporter
+                    .report_pre_link_contracts_compilation_succeeded_event(
+                        compiler_version,
+                        compiler_path,
+                        is_cached,
+                        compiler_input,
+                        compiler_output,
+                    )
+                    .expect("Can't fail")
+            },
+            |compiler_version, compiler_path, compiler_input, failure_reason| {
+                leader_reporter
+                    .report_pre_link_contracts_compilation_failed_event(
+                        compiler_version,
+                        compiler_path,
+                        compiler_input,
+                        failure_reason,
+                    )
+                    .expect("Can't fail")
+            }
         ),
         cached_compiler.compile_contracts::<F>(
             test.metadata,
             test.metadata_file_path,
-            test.mode.clone(),
+            &test.mode,
+            config,
             None,
-            &test.follower_compiler,
+            |compiler_version, compiler_path, is_cached, compiler_input, compiler_output| {
-            &follower_reporter
+                follower_reporter
+                    .report_pre_link_contracts_compilation_succeeded_event(
+                        compiler_version,
+                        compiler_path,
+                        is_cached,
+                        compiler_input,
+                        compiler_output,
+                    )
+                    .expect("Can't fail")
+            },
+            |compiler_version, compiler_path, compiler_input, failure_reason| {
+                follower_reporter
+                    .report_pre_link_contracts_compilation_failed_event(
+                        compiler_version,
+                        compiler_path,
+                        compiler_input,
+                        failure_reason,
+                    )
+                    .expect("Can't fail")
+            }
         )
-    )
+    )?;
-    .context("Failed to compile pre-link contracts for leader/follower in parallel")?;
 
     let mut leader_deployed_libraries = None::<HashMap<_, _>>;
     let mut follower_deployed_libraries = None::<HashMap<_, _>>;
-    let mut contract_sources = test
+    let mut contract_sources = test.metadata.contract_sources()?;
-        .metadata
-        .contract_sources()
-        .context("Failed to retrieve contract sources from metadata")?;
     for library_instance in test
         .metadata
         .libraries
@@ -597,8 +754,8 @@ where
         );
 
         let (leader_receipt, follower_receipt) = try_join!(
-            test.leader_node.execute_transaction(leader_tx),
+            leader_node.execute_transaction(leader_tx),
-            test.follower_node.execute_transaction(follower_tx)
+            follower_node.execute_transaction(follower_tx)
         )?;
 
         debug!(
@@ -656,40 +813,85 @@ where
     }
 
     let (
-        CompilerOutput {
+        (
-            contracts: leader_post_link_contracts,
+            CompilerOutput {
-        },
+                contracts: leader_post_link_contracts,
-        CompilerOutput {
+            },
-            contracts: follower_post_link_contracts,
+            leader_compiler_version,
-        },
+        ),
+        (
+            CompilerOutput {
+                contracts: follower_post_link_contracts,
+            },
+            follower_compiler_version,
+        ),
     ) = try_join!(
         cached_compiler.compile_contracts::<L>(
             test.metadata,
             test.metadata_file_path,
-            test.mode.clone(),
+            &test.mode,
+            config,
             leader_deployed_libraries.as_ref(),
-            &test.leader_compiler,
+            |compiler_version, compiler_path, is_cached, compiler_input, compiler_output| {
-            &leader_reporter,
+                leader_reporter
+                    .report_post_link_contracts_compilation_succeeded_event(
+                        compiler_version,
+                        compiler_path,
+                        is_cached,
+                        compiler_input,
+                        compiler_output,
+                    )
+                    .expect("Can't fail")
+            },
+            |compiler_version, compiler_path, compiler_input, failure_reason| {
+                leader_reporter
+                    .report_post_link_contracts_compilation_failed_event(
+                        compiler_version,
+                        compiler_path,
+                        compiler_input,
+                        failure_reason,
+                    )
+                    .expect("Can't fail")
+            }
         ),
         cached_compiler.compile_contracts::<F>(
             test.metadata,
             test.metadata_file_path,
-            test.mode.clone(),
+            &test.mode,
+            config,
             follower_deployed_libraries.as_ref(),
-            &test.follower_compiler,
+            |compiler_version, compiler_path, is_cached, compiler_input, compiler_output| {
-            &follower_reporter
+                follower_reporter
+                    .report_post_link_contracts_compilation_succeeded_event(
+                        compiler_version,
+                        compiler_path,
+                        is_cached,
+                        compiler_input,
+                        compiler_output,
+                    )
+                    .expect("Can't fail")
+            },
+            |compiler_version, compiler_path, compiler_input, failure_reason| {
+                follower_reporter
+                    .report_post_link_contracts_compilation_failed_event(
+                        compiler_version,
+                        compiler_path,
+                        compiler_input,
+                        failure_reason,
+                    )
+                    .expect("Can't fail")
+            }
         )
-    )
+    )?;
-    .context("Failed to compile post-link contracts for leader/follower in parallel")?;
 
     let leader_state = CaseState::<L>::new(
-        test.leader_compiler.version().clone(),
+        leader_compiler_version,
         leader_post_link_contracts,
         leader_deployed_libraries.unwrap_or_default(),
         leader_reporter,
     );
     let follower_state = CaseState::<F>::new(
-        test.follower_compiler.version().clone(),
+        follower_compiler_version,
         follower_post_link_contracts,
         follower_deployed_libraries.unwrap_or_default(),
         follower_reporter,
@@ -698,8 +900,8 @@ where
     let mut driver = CaseDriver::<L, F>::new(
         test.metadata,
         test.case,
-        test.leader_node,
+        leader_node,
-        test.follower_node,
+        follower_node,
         leader_state,
         follower_state,
     );
@@ -728,121 +930,60 @@ async fn execute_corpus(
     Ok(())
 }
 
-/// this represents a single "test"; a mode, path and collection of cases.
+async fn compile_corpus(
-#[derive(Clone)]
+    config: &Arguments,
-struct Test<'a, L: Platform, F: Platform> {
+    tests: &[MetadataFile],
-    metadata: &'a MetadataFile,
+    platform: &TestingPlatform,
-    metadata_file_path: &'a Path,
+    _: Reporter,
-    mode: Cow<'a, Mode>,
+    report_aggregator_task: impl Future<Output = anyhow::Result<()>>,
-    case_idx: CaseIdx,
+) {
-    case: &'a Case,
+    let tests = tests.iter().flat_map(|metadata| {
-    leader_node: &'a <L as Platform>::Blockchain,
+        metadata
-    follower_node: &'a <F as Platform>::Blockchain,
+            .solc_modes()
-    leader_compiler: L::Compiler,
+            .into_iter()
-    follower_compiler: F::Compiler,
+            .map(move |solc_mode| (metadata, solc_mode))
-    reporter: TestSpecificReporter,
+    });
+
+    let file = tempfile::NamedTempFile::new().expect("Failed to create temp file");
+    let cached_compiler = CachedCompiler::new(file.path(), false)
+        .await
+        .map(Arc::new)
+        .expect("Failed to create the cached compiler");
+
+    let compilation_task =
+        futures::stream::iter(tests).for_each_concurrent(None, |(metadata, mode)| {
+            let cached_compiler = cached_compiler.clone();
+
+            async move {
+                match platform {
+                    TestingPlatform::Geth => {
+                        let _ = cached_compiler
+                            .compile_contracts::<Geth>(
+                                metadata,
+                                metadata.metadata_file_path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                                |_, _, _, _, _| {},
+                                |_, _, _, _| {},
+                            )
+                            .await;
+                    }
+                    TestingPlatform::Kitchensink => {
+                        let _ = cached_compiler
+                            .compile_contracts::<Kitchensink>(
+                                metadata,
+                                metadata.metadata_file_path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                                |_, _, _, _, _| {},
+                                |_, _, _, _| {},
+                            )
+                            .await;
+                    }
+                }
+            }
+        });
+    let _ = join!(compilation_task, report_aggregator_task);
 }
-
-impl<'a, L: Platform, F: Platform> Test<'a, L, F> {
-    /// Checks if this test can be ran with the current configuration.
-    pub fn check_compatibility(&self) -> TestCheckFunctionResult {
-        self.check_metadata_file_ignored()?;
-        self.check_case_file_ignored()?;
-        self.check_target_compatibility()?;
-        self.check_evm_version_compatibility()?;
-        self.check_compiler_compatibility()?;
-        Ok(())
-    }
-
-    /// Checks if the metadata file is ignored or not.
-    fn check_metadata_file_ignored(&self) -> TestCheckFunctionResult {
-        if self.metadata.ignore.is_some_and(|ignore| ignore) {
-            Err(("Metadata file is ignored.", indexmap! {}))
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Checks if the case file is ignored or not.
-    fn check_case_file_ignored(&self) -> TestCheckFunctionResult {
-        if self.case.ignore.is_some_and(|ignore| ignore) {
-            Err(("Case is ignored.", indexmap! {}))
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Checks if the leader and the follower both support the desired targets in the metadata file.
-    fn check_target_compatibility(&self) -> TestCheckFunctionResult {
-        let leader_support =
-            <L::Blockchain as Node>::matches_target(self.metadata.targets.as_deref());
-        let follower_support =
-            <F::Blockchain as Node>::matches_target(self.metadata.targets.as_deref());
-        let is_allowed = leader_support && follower_support;
-
-        if is_allowed {
-            Ok(())
-        } else {
-            Err((
-                "Either the leader or the follower do not support the target desired by the test.",
-                indexmap! {
-                    "test_desired_targets" => json!(self.metadata.targets.as_ref()),
-                    "leader_support" => json!(leader_support),
-                    "follower_support" => json!(follower_support),
-                },
-            ))
-        }
-    }
-
-    // Checks for the compatibility of the EVM version with the leader and follower nodes.
-    fn check_evm_version_compatibility(&self) -> TestCheckFunctionResult {
-        let Some(evm_version_requirement) = self.metadata.required_evm_version else {
-            return Ok(());
-        };
-
-        let leader_support = evm_version_requirement
-            .matches(&<L::Blockchain as revive_dt_node::Node>::evm_version());
-        let follower_support = evm_version_requirement
-            .matches(&<F::Blockchain as revive_dt_node::Node>::evm_version());
-        let is_allowed = leader_support && follower_support;
-
-        if is_allowed {
-            Ok(())
-        } else {
-            Err((
-                "EVM version is incompatible with either the leader or the follower.",
-                indexmap! {
-                    "test_desired_evm_version" => json!(self.metadata.required_evm_version),
-                    "leader_support" => json!(leader_support),
-                    "follower_support" => json!(follower_support),
-                },
-            ))
-        }
-    }
-
-    /// Checks if the leader and follower compilers support the mode that the test is for.
-    fn check_compiler_compatibility(&self) -> TestCheckFunctionResult {
-        let leader_support = self
-            .leader_compiler
-            .supports_mode(self.mode.optimize_setting, self.mode.pipeline);
-        let follower_support = self
-            .follower_compiler
-            .supports_mode(self.mode.optimize_setting, self.mode.pipeline);
-        let is_allowed = leader_support && follower_support;
-
-        if is_allowed {
-            Ok(())
-        } else {
-            Err((
-                "Compilers do not support this mode either for the leader or for the follower.",
-                indexmap! {
-                    "mode" => json!(self.mode),
-                    "leader_support" => json!(leader_support),
-                    "follower_support" => json!(follower_support),
-                },
-            ))
-        }
-    }
-}
-
-type TestCheckFunctionResult = Result<(), (&'static str, IndexMap<&'static str, Value>)>;

crates/format/src/case.rs

@@ -64,7 +64,7 @@ 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(),
         }
     }
 }

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))
+            .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();
 
         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

@@ -268,11 +268,7 @@ impl Input {
     ) -> anyhow::Result<Bytes> {
         match self.method {
             Method::Deployer | Method::Fallback => {
-                let calldata = self
+                let calldata = self.calldata.calldata(resolver, context).await?;
-                    .calldata
-                    .calldata(resolver, context)
-                    .await
-                    .context("Failed to produce calldata for deployer/fallback method")?;
 
                 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 =
+                let selector = if function_name.contains('(') && function_name.contains(')') {
-                    if function_name.contains('(') && function_name.contains(')') {
+                    Function::parse(function_name)
-                        Function::parse(function_name)
                         .context(
                             "Failed to parse the provided function name into a function signature",
                         )?
                         .selector()
-                    } else {
+                } else {
-                        abi.functions()
+                    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
+                    .await?;
-                    .context("Failed to append encoded argument to calldata buffer")?;
 
                 Ok(calldata.into())
             }
@@ -335,10 +325,7 @@ impl Input {
         resolver: &impl ResolverApi,
         context: ResolutionContext<'_>,
     ) -> anyhow::Result<TransactionRequest> {
-        let input_data = self
+        let input_data = self.encoded_input(resolver, context).await?;
-            .encoded_input(resolver, context)
-            .await
-            .context("Failed to encode input bytes for transaction request")?;
         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
+                    .await?;
-                    .context("Failed to resolve one or more calldata arguments")?;
 
                 buffer.extend(resolved.into_iter().flatten());
             }
@@ -492,10 +478,7 @@ impl Calldata {
                             std::borrow::Cow::Borrowed(other)
                         };
 
-                        let this = this
+                        let this = this.resolve(resolver, context).await?;
-                            .resolve(resolver, context)
-                            .await
-                            .context("Failed to resolve calldata item during equivalence check")?;
                         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(
+                        None => resolver.last_block_number().await?,
-                            "Failed to query last block number while resolving $BLOCK_HASH",
-                        )?,
                     };
                     let desired_block_number = current_block_number.saturating_sub(offset);
 
-                    let block_hash = resolver
+                    let block_hash = resolver.block_hash(desired_block_number.into()).await?;
-                        .block_hash(desired_block_number.into())
-                        .await
-                        .context("Failed to resolve block hash for desired block number")?;
 
                     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(
+                        None => resolver.last_block_number().await?,
-                            "Failed to query last block number while resolving $BLOCK_NUMBER",
-                        )?,
                     };
                     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
+            let absolute_path = directory.join(contract_source_path).canonicalize()?;
-                .join(contract_source_path)
-                .canonicalize()
-                .map_err(|error| {
-                    anyhow::anyhow!(
-                        "Failed to canonicalize contract source path '{}': {error}",
-                        directory.join(contract_source_path).display()
-                    )
-                })?;
             let contract_ident = contract_ident.clone();
 
             sources.insert(

crates/format/src/mode.rs

@@ -1,6 +1,4 @@
-use anyhow::Context;
 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(
+            Some(m) => Some(ModePipeline::from_str(m.as_str())?),
-                ModePipeline::from_str(m.as_str())
-                    .context("Failed to parse mode pipeline from string")?,
-            ),
             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(
+            Some(m) => Some(ModeOptimizerSetting::from_str(m.as_str())?),
-                ModeOptimizerSetting::from_str(m.as_str())
-                    .context("Failed to parse optimizer setting from string")?,
-            ),
             None => None,
         };
 
         let version = match caps.name("version") {
-            Some(m) => Some(
+            Some(m) => Some(semver::VersionReq::parse(m.as_str()).map_err(|e| {
-                semver::VersionReq::parse(m.as_str())
+                anyhow::anyhow!("Cannot parse the version requirement '{}': {e}", 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")?,
-            ),
             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

@@ -101,13 +101,10 @@ impl GethNode {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
-        create_dir_all(&self.base_directory)
+        create_dir_all(&self.base_directory)?;
-            .context("Failed to create base directory for geth node")?;
+        create_dir_all(&self.logs_directory)?;
-        create_dir_all(&self.logs_directory)
-            .context("Failed to create logs directory for geth node")?;
 
-        let mut genesis = serde_json::from_str::<Genesis>(&genesis)
+        let mut genesis = serde_json::from_str::<Genesis>(&genesis)?;
-            .context("Failed to deserialize geth genesis JSON")?;
         for signer_address in
             <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
         {
@@ -119,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(
+        serde_json::to_writer(File::create(&genesis_path)?, &genesis)?;
-            File::create(&genesis_path).context("Failed to create geth genesis file")?,
-            &genesis,
-        )
-        .context("Failed to serialize geth genesis JSON to file")?;
 
         let mut child = Command::new(&self.geth)
             .arg("--state.scheme")
@@ -134,22 +127,16 @@ impl GethNode {
             .arg(genesis_path)
             .stderr(Stdio::piped())
             .stdout(Stdio::null())
-            .spawn()
+            .spawn()?;
-            .context("Failed to spawn geth --init process")?;
 
         let mut stderr = String::new();
         child
             .stderr
             .take()
             .expect("should be piped")
-            .read_to_string(&mut stderr)
+            .read_to_string(&mut stderr)?;
-            .context("Failed to read geth --init stderr")?;
 
-        if !child
+        if !child.wait()?.success() {
-            .wait()
-            .context("Failed waiting for geth --init process to finish")?
-            .success()
-        {
             anyhow::bail!("failed to initialize geth node #{:?}: {stderr}", &self.id);
         }
 
@@ -174,11 +161,8 @@ impl GethNode {
 
         let stdout_logs_file = open_options
             .clone()
-            .open(self.geth_stdout_log_file_path())
+            .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())?;
-        let stderr_logs_file = open_options
-            .open(self.geth_stderr_log_file_path())
-            .context("Failed to open geth stderr logs file")?;
         self.handle = Command::new(&self.geth)
             .arg("--dev")
             .arg("--datadir")
@@ -198,24 +182,14 @@ impl GethNode {
             .arg("full")
             .arg("--gcmode")
             .arg("archive")
-            .stderr(
+            .stderr(stderr_logs_file.try_clone()?)
-                stderr_logs_file
+            .stdout(stdout_logs_file.try_clone()?)
-                    .try_clone()
+            .spawn()?
-                    .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")?
             .into();
 
         if let Err(error) = self.wait_ready() {
             tracing::error!(?error, "Failed to start geth, shutting down gracefully");
-            self.shutdown()
+            self.shutdown()?;
-                .context("Failed to gracefully shutdown after geth start error")?;
             return Err(error);
         }
 
@@ -237,8 +211,7 @@ impl GethNode {
             .write(false)
             .append(false)
             .truncate(false)
-            .open(self.geth_stderr_log_file_path())
+            .open(self.geth_stderr_log_file_path())?;
-            .context("Failed to open geth stderr logs file for readiness check")?;
 
         let maximum_wait_time = Duration::from_millis(self.start_timeout);
         let mut stderr = BufReader::new(logs_file).lines();
@@ -304,18 +277,11 @@ impl EthereumNode for GethNode {
         &self,
         transaction: TransactionRequest,
     ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let provider = self
+        let provider = self.provider().await?;
-            .provider()
-            .await
-            .context("Failed to create provider for transaction submission")?;
 
-        let pending_transaction = provider
+        let pending_transaction = provider.send_transaction(transaction).await.inspect_err(
-            .send_transaction(transaction)
+            |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
-            .await
+        )?;
-            .inspect_err(
-                |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
-            )
-            .context("Failed to submit transaction to geth node")?;
         let transaction_hash = *pending_transaction.tx_hash();
 
         // The following is a fix for the "transaction indexing is in progress" error that we used
@@ -369,11 +335,7 @@ impl EthereumNode for GethNode {
         transaction: &TransactionReceipt,
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let provider = Arc::new(
+        let provider = Arc::new(self.provider().await?);
-            self.provider()
-                .await
-                .context("Failed to create provider for tracing")?,
-        );
         poll(
             Self::TRACE_POLLING_DURATION,
             PollingWaitBehavior::Constant(Duration::from_millis(200)),
@@ -409,10 +371,8 @@ impl EthereumNode for GethNode {
         });
         match self
             .trace_transaction(transaction, trace_options)
-            .await
+            .await?
-            .context("Failed to trace transaction for prestate diff")?
+            .try_into_pre_state_frame()?
-            .try_into_pre_state_frame()
-            .context("Failed to convert trace into pre-state frame")?
         {
             PreStateFrame::Diff(diff) => Ok(diff),
             _ => anyhow::bail!("expected a diff mode trace"),
@@ -422,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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_balance(address)
             .await
             .map_err(Into::into)
@@ -436,8 +395,7 @@ impl EthereumNode for GethNode {
         keys: Vec<StorageKey>,
     ) -> anyhow::Result<EIP1186AccountProofResponse> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_proof(address, keys)
             .latest()
             .await
@@ -449,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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_chain_id()
             .await
             .map_err(Into::into)
@@ -459,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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_transaction_receipt(*tx_hash)
             .await?
             .context("Failed to get the transaction receipt")
@@ -470,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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the geth block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Geth block, perhaps there are 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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the geth block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Geth block, perhaps there are 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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the geth block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Geth block, perhaps there are 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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the geth block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
             .and_then(|block| {
                 block
                     .header
@@ -523,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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the geth block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Geth block, perhaps there are 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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the geth block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Geth block, perhaps there are 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
+            .await?
-            .context("Failed to get the Geth provider")?
             .get_block_number()
             .await
             .map_err(Into::into)
@@ -633,10 +576,8 @@ impl Node for GethNode {
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::null())
-            .spawn()
+            .spawn()?
-            .context("Failed to spawn geth --version process")?
+            .wait_with_output()?
-            .wait_with_output()
-            .context("Failed to wait for geth --version output")?
             .stdout;
         Ok(String::from_utf8_lossy(&output).into())
     }

crates/node/src/kitchensink.rs

@@ -96,10 +96,8 @@ impl KitchensinkNode {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
-        create_dir_all(&self.base_directory)
+        create_dir_all(&self.base_directory)?;
-            .context("Failed to create base directory for kitchensink node")?;
+        create_dir_all(&self.logs_directory)?;
-        create_dir_all(&self.logs_directory)
-            .context("Failed to create logs directory for kitchensink node")?;
 
         let template_chainspec_path = self.base_directory.join(Self::CHAIN_SPEC_JSON_FILE);
 
@@ -128,10 +126,8 @@ impl KitchensinkNode {
             );
         }
 
-        let content = String::from_utf8(output.stdout)
+        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)?;
-        let mut chainspec_json: JsonValue =
-            serde_json::from_str(&content).context("Failed to parse substrate chain spec JSON")?;
 
         let existing_chainspec_balances =
             chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
@@ -153,8 +149,7 @@ impl KitchensinkNode {
             })
             .collect();
         let mut eth_balances = {
-            let mut genesis = serde_json::from_str::<Genesis>(genesis)
+            let mut genesis = serde_json::from_str::<Genesis>(genesis)?;
-                .context("Failed to deserialize EVM genesis JSON for kitchensink")?;
             for signer_address in
                 <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
             {
@@ -165,8 +160,7 @@ impl KitchensinkNode {
                     .entry(signer_address)
                     .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
             }
-            self.extract_balance_from_genesis_file(&genesis)
+            self.extract_balance_from_genesis_file(&genesis)?
-                .context("Failed to extract balances from EVM genesis JSON")?
         };
         merged_balances.append(&mut eth_balances);
 
@@ -174,11 +168,9 @@ impl KitchensinkNode {
             json!(merged_balances);
 
         serde_json::to_writer_pretty(
-            std::fs::File::create(&template_chainspec_path)
+            std::fs::File::create(&template_chainspec_path)?,
-                .context("Failed to create kitchensink template chainspec file")?,
             &chainspec_json,
-        )
+        )?;
-        .context("Failed to write kitchensink template chainspec JSON")?;
         Ok(self)
     }
 
@@ -204,12 +196,10 @@ impl KitchensinkNode {
         // Start Substrate node
         let kitchensink_stdout_logs_file = open_options
             .clone()
-            .open(self.kitchensink_stdout_log_file_path())
+            .open(self.kitchensink_stdout_log_file_path())?;
-            .context("Failed to open kitchensink stdout logs file")?;
         let kitchensink_stderr_logs_file = open_options
             .clone()
-            .open(self.kitchensink_stderr_log_file_path())
+            .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 {
@@ -233,18 +223,9 @@ impl KitchensinkNode {
             .arg("--rpc-max-connections")
             .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::SUBSTRATE_LOG_ENV)
-            .stdout(
+            .stdout(kitchensink_stdout_logs_file.try_clone()?)
-                kitchensink_stdout_logs_file
+            .stderr(kitchensink_stderr_logs_file.try_clone()?)
-                    .try_clone()
+            .spawn()?
-                    .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")?
             .into();
 
         // Give the node a moment to boot
@@ -253,18 +234,14 @@ impl KitchensinkNode {
             Self::SUBSTRATE_READY_MARKER,
             Duration::from_secs(60),
         ) {
-            self.shutdown()
+            self.shutdown()?;
-                .context("Failed to gracefully shutdown after substrate start error")?;
             return Err(error);
         };
 
         let eth_proxy_stdout_logs_file = open_options
             .clone()
-            .open(self.proxy_stdout_log_file_path())
+            .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())?;
-        let eth_proxy_stderr_logs_file = open_options
-            .open(self.proxy_stderr_log_file_path())
-            .context("Failed to open eth-proxy stderr logs file")?;
         self.process_proxy = Command::new(&self.eth_proxy_binary)
             .arg("--dev")
             .arg("--rpc-port")
@@ -274,18 +251,9 @@ impl KitchensinkNode {
             .arg("--rpc-max-connections")
             .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::PROXY_LOG_ENV)
-            .stdout(
+            .stdout(eth_proxy_stdout_logs_file.try_clone()?)
-                eth_proxy_stdout_logs_file
+            .stderr(eth_proxy_stderr_logs_file.try_clone()?)
-                    .try_clone()
+            .spawn()?
-                    .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")?
             .into();
 
         if let Err(error) = Self::wait_ready(
@@ -293,8 +261,7 @@ impl KitchensinkNode {
             Self::ETH_PROXY_READY_MARKER,
             Duration::from_secs(60),
         ) {
-            self.shutdown()
+            self.shutdown()?;
-                .context("Failed to gracefully shutdown after eth-proxy start error")?;
             return Err(error);
         };
 
@@ -419,14 +386,11 @@ impl EthereumNode for KitchensinkNode {
     ) -> anyhow::Result<TransactionReceipt> {
         let receipt = self
             .provider()
-            .await
+            .await?
-            .context("Failed to create provider for transaction submission")?
             .send_transaction(transaction)
-            .await
+            .await?
-            .context("Failed to submit transaction to kitchensink proxy")?
             .get_receipt()
-            .await
+            .await?;
-            .context("Failed to fetch transaction receipt from kitchensink proxy")?;
         Ok(receipt)
     }
 
@@ -436,12 +400,11 @@ impl EthereumNode for KitchensinkNode {
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
         let tx_hash = transaction.transaction_hash;
-        self.provider()
+        Ok(self
-            .await
+            .provider()
-            .context("Failed to create provider for debug tracing")?
+            .await?
             .debug_trace_transaction(tx_hash, trace_options)
-            .await
+            .await?)
-            .context("Failed to obtain debug trace from kitchensink proxy")
     }
 
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
@@ -462,8 +425,7 @@ impl EthereumNode for KitchensinkNode {
 
     async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_balance(address)
             .await
             .map_err(Into::into)
@@ -475,8 +437,7 @@ impl EthereumNode for KitchensinkNode {
         keys: Vec<StorageKey>,
     ) -> anyhow::Result<EIP1186AccountProofResponse> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_proof(address, keys)
             .latest()
             .await
@@ -487,8 +448,7 @@ impl EthereumNode for KitchensinkNode {
 impl ResolverApi for KitchensinkNode {
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_chain_id()
             .await
             .map_err(Into::into)
@@ -496,8 +456,7 @@ impl ResolverApi for KitchensinkNode {
 
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_transaction_receipt(*tx_hash)
             .await?
             .context("Failed to get the transaction receipt")
@@ -506,45 +465,37 @@ impl ResolverApi for KitchensinkNode {
 
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the kitchensink block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
             .map(|block| block.header.gas_limit as _)
     }
 
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the kitchensink block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
             .map(|block| block.header.beneficiary)
     }
 
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the kitchensink block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Kitchensink block, perhaps the chain 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
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the kitchensink block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
             .and_then(|block| {
                 block
                     .header
@@ -555,30 +506,25 @@ impl ResolverApi for KitchensinkNode {
 
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the kitchensink block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
             .map(|block| block.header.hash)
     }
 
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_block_by_number(number)
-            .await
+            .await?
-            .context("Failed to get the kitchensink block")?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
             .map(|block| block.header.timestamp)
     }
 
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
-            .await
+            .await?
-            .context("Failed to get the Kitchensink provider")?
             .get_block_number()
             .await
             .map_err(Into::into)
@@ -665,10 +611,8 @@ impl Node for KitchensinkNode {
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::null())
-            .spawn()
+            .spawn()?
-            .context("Failed to spawn kitchensink --version")?
+            .wait_with_output()?
-            .wait_with_output()
-            .context("Failed to wait for kitchensink --version")?
             .stdout;
         Ok(String::from_utf8_lossy(&output).into())
     }

crates/node/src/pool.rs

@@ -44,10 +44,8 @@ where
             nodes.push(
                 handle
                     .join()
-                    .map_err(|error| anyhow::anyhow!("failed to spawn node: {:?}", error))
+                    .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}"))?,
-                    .map_err(|error| anyhow::anyhow!("node failed to spawn: {error}"))
-                    .context("Node failed to spawn")?,
             );
         }
 
@@ -71,8 +69,7 @@ fn spawn_node<T: Node + Send>(args: &Arguments, genesis: String) -> anyhow::Resu
         connection_string = node.connection_string(),
         "Spawning node"
     );
-    node.spawn(genesis)
+    node.spawn(genesis)?;
-        .context("Failed to spawn node process")?;
     info!(
         id = node.id(),
         connection_string = node.connection_string(),

crates/report/src/aggregator.rs

@@ -9,7 +9,7 @@ use std::{
 };
 
 use alloy_primitives::Address;
-use anyhow::{Context as _, Result};
+use anyhow::Result;
 use indexmap::IndexMap;
 use revive_dt_compiler::{CompilerInput, CompilerOutput, Mode};
 use revive_dt_config::{Arguments, TestingPlatform};
@@ -113,10 +113,7 @@ impl ReportAggregator {
         debug!("Report aggregation completed");
 
         let file_name = {
-            let current_timestamp = SystemTime::now()
+            let current_timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
-                .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
@@ -127,16 +124,8 @@ impl ReportAggregator {
             .write(true)
             .truncate(true)
             .read(false)
-            .open(&file_path)
+            .open(file_path)?;
-            .with_context(|| {
+        serde_json::to_writer_pretty(file, &self.report)?;
-                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(())
     }
@@ -340,13 +329,21 @@ impl ReportAggregator {
         &mut self,
         event: PreLinkContractsCompilationFailedEvent,
     ) {
+        let include_input = self.report.config.report_include_compiler_input;
+
         let execution_information = self.execution_information(&event.execution_specifier);
 
+        let compiler_input = if include_input {
+            event.compiler_input
+        } else {
+            None
+        };
+
         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,
+            compiler_input,
         });
     }
 
@@ -354,13 +351,21 @@ impl ReportAggregator {
         &mut self,
         event: PostLinkContractsCompilationFailedEvent,
     ) {
+        let include_input = self.report.config.report_include_compiler_input;
+
         let execution_information = self.execution_information(&event.execution_specifier);
 
+        let compiler_input = if include_input {
+            event.compiler_input
+        } else {
+            None
+        };
+
         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,
+            compiler_input,
         });
     }
 

crates/report/src/runner_event.rs

@@ -4,7 +4,6 @@
 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;
@@ -631,8 +630,7 @@ define_event! {
 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)
+        self.report_subscribe_to_events_event(tx)?;
-            .context("Failed to send subscribe request to reporter task")?;
         rx.await.map_err(Into::into)
     }
 }

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;
 
 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(|| {
+    create_dir_all(target_directory)?;
-        format!(
+    download_to_file(&target_file, downloader).await?;
-            "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()
-            )
-        })?;
     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
+        let mut permissions = file.metadata()?.permissions();
-            .metadata()
-            .with_context(|| format!("Failed to read metadata for {}", path.display()))?
-            .permissions();
         permissions.set_mode(permissions.mode() | 0o111);
-        file.set_permissions(permissions).with_context(|| {
+        file.set_permissions(permissions)?;
-            format!("Failed to set executable permissions on {}", path.display())
-        })?;
     }
 
     let mut file = BufWriter::new(file);
-    file.write_all(
+    file.write_all(&downloader.download().await?)?;
-        &downloader
+    file.flush()?;
-            .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()))?;
     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()
+        .spawn()?
-        .with_context(|| {
+        .wait()?;
-            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()
-            )
-        })?;
 
     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;
 
 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)
+        let body: List = reqwest::get(url).await?.json().await?;
-            .await
-            .with_context(|| format!("Failed to GET solc list from {url}"))?
-            .json()
-            .await
-            .with_context(|| format!("Failed to deserialize solc list JSON from {url}"))?;
 
         LIST_CACHE.lock().unwrap().insert(url, body.clone());
 
@@ -74,8 +68,7 @@ impl SolcDownloader {
             }),
             VersionOrRequirement::Requirement(requirement) => {
                 let Some(version) = List::download(list)
-                    .await
+                    .await?
-                    .with_context(|| format!("Failed to download solc builds list from {list}"))?
                     .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)
+        let builds = List::download(self.list).await?.builds;
-            .await
-            .with_context(|| format!("Failed to download solc builds list from {}", self.list))?
-            .builds;
         let build = builds
             .iter()
             .find(|build| build.version == self.version)
-            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", 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
-                )
-            })?;
 
         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)
+        let file = reqwest::get(url).await?.bytes().await?.to_vec();
-            .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();
 
         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;
 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

@@ -1,102 +0,0 @@
-#!/bin/bash
-
-# Revive Differential Tests - Quick Start Script
-# This script clones the test repository, sets up the corpus file, and runs the tool
-
-set -e  # Exit on any error
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Configuration
-TEST_REPO_URL="https://github.com/paritytech/resolc-compiler-tests"
-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 ""
-
-# Check if test repo already exists
-if [ -d "$TEST_REPO_DIR" ]; then
-    echo -e "${YELLOW}Test repository already exists. Pulling latest changes...${NC}"
-    cd "$TEST_REPO_DIR"
-    git pull
-    cd ..
-else
-    echo -e "${GREEN}Cloning test repository...${NC}"
-    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/")
-
-cat > "$CORPUS_FILE" << EOF
-{
-  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
-  "path": "$ABSOLUTE_PATH"
-}
-EOF
-
-echo -e "${GREEN}Corpus file created: $CORPUS_FILE${NC}"
-
-# Create workdir if it doesn't exist
-mkdir -p "$WORKDIR"
-
-echo -e "${GREEN}Starting differential tests...${NC}"
-echo "This may take a while..."
-echo ""
-
-# Run the tool
-RUST_LOG="error" cargo run --release -- \
-    --corpus "$CORPUS_FILE" \
-    --workdir "$WORKDIR" \
-    --number-of-nodes 5 \
-    --kitchensink "$SUBSTRATE_NODE_BIN" \
-    --revive-dev-node "$REVIVE_DEV_NODE_BIN" \
-    --eth_proxy "$ETH_RPC_BIN" \
-    > logs.log \
-    2> output.log
-
-echo -e "${GREEN}=== Test run completed! ===${NC}"