Merge remote-tracking branch 'origin/main' into feature/fix-os-fd-errors

crates/common/Cargo.toml

@@ -13,4 +13,5 @@ anyhow = { workspace = true }
 moka = { workspace = true, features = ["sync"] }
 once_cell = { workspace = true }
 semver = { workspace = true }
+serde = { workspace = true }
 tokio = { workspace = true, default-features = false, features = ["time"] }

crates/common/src/types/mod.rs

@@ -1,3 +1,5 @@
+mod mode;
 mod version_or_requirement;
 
+pub use mode::*;
 pub use version_or_requirement::*;

crates/common/src/types/mode.rs

@@ -0,0 +1,167 @@
+use crate::types::VersionOrRequirement;
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use std::fmt::Display;
+use std::str::FromStr;
+
+/// This represents a mode that a given test should be run with, if possible.
+///
+/// We obtain this by taking a [`ParsedMode`], which may be looser or more strict
+/// in its requirements, and then expanding it out into a list of [`Mode`]s.
+///
+/// Use [`ParsedMode::to_test_modes()`] to do this.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct Mode {
+    pub pipeline: ModePipeline,
+    pub optimize_setting: ModeOptimizerSetting,
+    pub version: Option<semver::VersionReq>,
+}
+
+impl Display for Mode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.pipeline.fmt(f)?;
+        f.write_str(" ")?;
+        self.optimize_setting.fmt(f)?;
+
+        if let Some(version) = &self.version {
+            f.write_str(" ")?;
+            version.fmt(f)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Mode {
+    /// Return all of the available mode combinations.
+    pub fn all() -> impl Iterator<Item = Mode> {
+        ModePipeline::test_cases().flat_map(|pipeline| {
+            ModeOptimizerSetting::test_cases().map(move |optimize_setting| Mode {
+                pipeline,
+                optimize_setting,
+                version: None,
+            })
+        })
+    }
+
+    /// Resolves the [`Mode`]'s solidity version requirement into a [`VersionOrRequirement`] if
+    /// the requirement is present on the object. Otherwise, the passed default version is used.
+    pub fn compiler_version_to_use(&self, default: Version) -> VersionOrRequirement {
+        match self.version {
+            Some(ref requirement) => requirement.clone().into(),
+            None => default.into(),
+        }
+    }
+}
+
+/// What do we want the compiler to do?
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+pub enum ModePipeline {
+    /// Compile Solidity code via Yul IR
+    ViaYulIR,
+    /// Compile Solidity direct to assembly
+    ViaEVMAssembly,
+}
+
+impl FromStr for ModePipeline {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            // via Yul IR
+            "Y" => Ok(ModePipeline::ViaYulIR),
+            // Don't go via Yul IR
+            "E" => Ok(ModePipeline::ViaEVMAssembly),
+            // Anything else that we see isn't a mode at all
+            _ => Err(anyhow::anyhow!(
+                "Unsupported pipeline '{s}': expected 'Y' or 'E'"
+            )),
+        }
+    }
+}
+
+impl Display for ModePipeline {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ModePipeline::ViaYulIR => f.write_str("Y"),
+            ModePipeline::ViaEVMAssembly => f.write_str("E"),
+        }
+    }
+}
+
+impl ModePipeline {
+    /// Should we go via Yul IR?
+    pub fn via_yul_ir(&self) -> bool {
+        matches!(self, ModePipeline::ViaYulIR)
+    }
+
+    /// An iterator over the available pipelines that we'd like to test,
+    /// when an explicit pipeline was not specified.
+    pub fn test_cases() -> impl Iterator<Item = ModePipeline> + Clone {
+        [ModePipeline::ViaYulIR, ModePipeline::ViaEVMAssembly].into_iter()
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+pub enum ModeOptimizerSetting {
+    /// 0 / -: Don't apply any optimizations
+    M0,
+    /// 1: Apply less than default optimizations
+    M1,
+    /// 2: Apply the default optimizations
+    M2,
+    /// 3 / +: Apply aggressive optimizations
+    M3,
+    /// s: Optimize for size
+    Ms,
+    /// z: Aggressively optimize for size
+    Mz,
+}
+
+impl FromStr for ModeOptimizerSetting {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "M0" => Ok(ModeOptimizerSetting::M0),
+            "M1" => Ok(ModeOptimizerSetting::M1),
+            "M2" => Ok(ModeOptimizerSetting::M2),
+            "M3" => Ok(ModeOptimizerSetting::M3),
+            "Ms" => Ok(ModeOptimizerSetting::Ms),
+            "Mz" => Ok(ModeOptimizerSetting::Mz),
+            _ => Err(anyhow::anyhow!(
+                "Unsupported optimizer setting '{s}': expected 'M0', 'M1', 'M2', 'M3', 'Ms' or 'Mz'"
+            )),
+        }
+    }
+}
+
+impl Display for ModeOptimizerSetting {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ModeOptimizerSetting::M0 => f.write_str("M0"),
+            ModeOptimizerSetting::M1 => f.write_str("M1"),
+            ModeOptimizerSetting::M2 => f.write_str("M2"),
+            ModeOptimizerSetting::M3 => f.write_str("M3"),
+            ModeOptimizerSetting::Ms => f.write_str("Ms"),
+            ModeOptimizerSetting::Mz => f.write_str("Mz"),
+        }
+    }
+}
+
+impl ModeOptimizerSetting {
+    /// An iterator over the available optimizer settings that we'd like to test,
+    /// when an explicit optimizer setting was not specified.
+    pub fn test_cases() -> impl Iterator<Item = ModeOptimizerSetting> + Clone {
+        [
+            // No optimizations:
+            ModeOptimizerSetting::M0,
+            // Aggressive optimizations:
+            ModeOptimizerSetting::M3,
+        ]
+        .into_iter()
+    }
+
+    /// Are any optimizations enabled?
+    pub fn optimizations_enabled(&self) -> bool {
+        !matches!(self, ModeOptimizerSetting::M0)
+    }
+}

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,
@@ -19,6 +21,9 @@ use revive_dt_common::cached_fs::read_to_string;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 
+// Re-export this as it's a part of the compiler interface.
+pub use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
+
 pub mod revive_js;
 pub mod revive_resolc;
 pub mod solc;
@@ -43,13 +48,20 @@ pub trait SolidityCompiler {
     ) -> impl Future<Output = anyhow::Result<PathBuf>>;
 
     fn version(&self) -> 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(Debug, Clone, Serialize, Deserialize)]
 pub struct CompilerInput {
-    pub enable_optimization: Option<bool>,
-    pub via_ir: Option<bool>,
+    pub pipeline: Option<ModePipeline>,
+    pub optimization: Option<ModeOptimizerSetting>,
     pub evm_version: Option<EVMVersion>,
     pub allow_paths: Vec<PathBuf>,
     pub base_path: Option<PathBuf>,
@@ -85,8 +97,8 @@ where
     pub fn new() -> Self {
         Self {
             input: CompilerInput {
-                enable_optimization: Default::default(),
-                via_ir: Default::default(),
+                pipeline: Default::default(),
+                optimization: Default::default(),
                 evm_version: Default::default(),
                 allow_paths: Default::default(),
                 base_path: Default::default(),
@@ -98,13 +110,13 @@ where
         }
     }
 
-    pub fn with_optimization(mut self, value: impl Into<Option<bool>>) -> Self {
-        self.input.enable_optimization = value.into();
+    pub fn with_optimization(mut self, value: impl Into<Option<ModeOptimizerSetting>>) -> Self {
+        self.input.optimization = value.into();
         self
     }
 
-    pub fn with_via_ir(mut self, value: impl Into<Option<bool>>) -> Self {
-        self.input.via_ir = value.into();
+    pub fn with_pipeline(mut self, value: impl Into<Option<ModePipeline>>) -> Self {
+        self.input.pipeline = value.into();
         self
     }
 
@@ -157,6 +169,14 @@ where
         self
     }
 
+    pub fn then(self, callback: impl FnOnce(Self) -> Self) -> Self {
+        callback(self)
+    }
+
+    pub fn try_then<E>(self, callback: impl FnOnce(Self) -> Result<Self, E>) -> Result<Self, E> {
+        callback(self)
+    }
+
     pub async fn try_build(
         self,
         compiler_path: impl AsRef<Path>,

crates/compiler/src/revive_resolc.rs

@@ -15,7 +15,8 @@ use revive_solc_json_interface::{
     SolcStandardJsonOutput,
 };
 
-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
+use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 
 use alloy::json_abi::JsonAbi;
 use anyhow::Context;
@@ -40,9 +41,8 @@ impl SolidityCompiler for Resolc {
     async fn build(
         &self,
         CompilerInput {
-            enable_optimization,
-            // Ignored and not honored since this is required for the resolc compilation.
-            via_ir: _via_ir,
+            pipeline,
+            optimization,
             evm_version,
             allow_paths,
             base_path,
@@ -54,6 +54,12 @@ impl SolidityCompiler for Resolc {
         }: CompilerInput,
         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:?}"
+            );
+        }
+
         let input = SolcStandardJsonInput {
             language: SolcStandardJsonInputLanguage::Solidity,
             sources: sources
@@ -82,7 +88,9 @@ impl SolidityCompiler for Resolc {
                 output_selection: Some(SolcStandardJsonInputSettingsSelection::new_required()),
                 via_ir: Some(true),
                 optimizer: SolcStandardJsonInputSettingsOptimizer::new(
-                    enable_optimization.unwrap_or(false),
+                    optimization
+                        .unwrap_or(ModeOptimizerSetting::M0)
+                        .optimizations_enabled(),
                     None,
                     &Version::new(0, 0, 0),
                     false,
@@ -239,6 +247,18 @@ impl SolidityCompiler for Resolc {
 
         Version::parse(version_string).map_err(Into::into)
     }
+
+    fn supports_mode(
+        compiler_version: &Version,
+        _optimize_setting: ModeOptimizerSetting,
+        pipeline: ModePipeline,
+    ) -> bool {
+        // 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.
+        pipeline == ModePipeline::ViaYulIR
+            && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
+    }
 }
 
 #[cfg(test)]

crates/compiler/src/solc.rs

@@ -11,7 +11,8 @@ use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
 
-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
+use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 
 use anyhow::Context;
 use foundry_compilers_artifacts::{
@@ -36,8 +37,8 @@ impl SolidityCompiler for Solc {
     async fn build(
         &self,
         CompilerInput {
-            enable_optimization,
-            via_ir,
+            pipeline,
+            optimization,
             evm_version,
             allow_paths,
             base_path,
@@ -47,6 +48,17 @@ impl SolidityCompiler for Solc {
         }: CompilerInput,
         _: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {
+        let compiler_supports_via_ir = self.version()? >= 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, compiler_supports_via_ir) {
+            (pipeline, true) => pipeline.map(|p| p.via_yul_ir()),
+            (_pipeline, false) => None,
+        };
+
         let input = SolcInput {
             language: SolcLanguage::Solidity,
             sources: Sources(
@@ -57,7 +69,7 @@ impl SolidityCompiler for Solc {
             ),
             settings: Settings {
                 optimizer: Optimizer {
-                    enabled: enable_optimization,
+                    enabled: optimization.map(|o| o.optimizations_enabled()),
                     details: Some(Default::default()),
                     ..Default::default()
                 },
@@ -229,6 +241,18 @@ impl SolidityCompiler for Solc {
 
         Version::parse(version_string).map_err(Into::into)
     }
+
+    fn supports_mode(
+        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
+                && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR)
+    }
 }
 
 #[cfg(test)]

crates/config/src/lib.rs

@@ -58,10 +58,6 @@ pub struct Arguments {
     #[arg(long = "geth-start-timeout", default_value = "5000")]
     pub geth_start_timeout: u64,
 
-    /// The test network chain ID.
-    #[arg(short, long = "network-id", default_value = "420420420")]
-    pub network_id: u64,
-
     /// Configure nodes according to this genesis.json file.
     #[arg(long = "genesis", default_value = "genesis.json")]
     pub genesis_file: PathBuf,
@@ -124,6 +120,10 @@ pub struct Arguments {
     /// By default it uses `eth-rpc` binary found in `$PATH`.
     #[arg(short = 'p', long = "eth_proxy", default_value = "eth-rpc")]
     pub eth_proxy: PathBuf,
+
+    /// Controls if the compilation cache should be invalidated or not.
+    #[arg(short, long)]
+    pub invalidate_compilation_cache: bool,
 }
 
 impl Arguments {

crates/core/Cargo.toml

@@ -23,12 +23,17 @@ revive-dt-report = { workspace = true }
 
 alloy = { workspace = true }
 anyhow = { workspace = true }
+bson = { workspace = true }
+cacache = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }
 indexmap = { workspace = true }
+once_cell = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 semver = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 temp-dir = { workspace = true }
+tempfile = { workspace = true }

crates/core/src/cached_compiler.rs

@@ -0,0 +1,261 @@
+//! A wrapper around the compiler which allows for caching of compilation artifacts so that they can
+//! be reused between runs.
+
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use futures::FutureExt;
+use revive_dt_common::iterators::FilesWithExtensionIterator;
+use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
+use revive_dt_config::Arguments;
+use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
+
+use alloy::{hex::ToHexExt, json_abi::JsonAbi, primitives::Address};
+use anyhow::{Error, Result};
+use once_cell::sync::Lazy;
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use tokio::sync::{Mutex, RwLock};
+use tracing::{Instrument, debug, debug_span, instrument};
+
+use crate::Platform;
+
+pub struct CachedCompiler(ArtifactsCache);
+
+impl CachedCompiler {
+    pub async fn new(path: impl AsRef<Path>, invalidate_cache: bool) -> Result<Self> {
+        let mut cache = ArtifactsCache::new(path);
+        if invalidate_cache {
+            cache = cache.with_invalidated_cache().await?;
+        }
+        Ok(Self(cache))
+    }
+
+    /// Compiles or gets the compilation artifacts from the cache.
+    #[instrument(
+        level = "debug",
+        skip_all,
+        fields(
+            metadata_file_path = %metadata_file_path.as_ref().display(),
+            %mode,
+            platform = P::config_id().to_string()
+        ),
+        err
+    )]
+    pub async fn compile_contracts<P: Platform>(
+        &self,
+        metadata: &Metadata,
+        metadata_file_path: impl AsRef<Path>,
+        mode: &Mode,
+        config: &Arguments,
+        deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+    ) -> Result<(CompilerOutput, Version)> {
+        static CACHE_KEY_LOCK: Lazy<RwLock<HashMap<CacheKey, Arc<Mutex<()>>>>> =
+            Lazy::new(Default::default);
+
+        let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
+        let compiler_path = <P::Compiler as SolidityCompiler>::get_compiler_executable(
+            config,
+            compiler_version_or_requirement,
+        )
+        .await?;
+        let compiler_version =
+            <P::Compiler as SolidityCompiler>::new(compiler_path.clone()).version()?;
+
+        let cache_key = CacheKey {
+            platform_key: P::config_id().to_string(),
+            compiler_version: compiler_version.clone(),
+            metadata_file_path: metadata_file_path.as_ref().to_path_buf(),
+            solc_mode: mode.clone(),
+        };
+
+        let compilation_callback = || {
+            async move {
+                compile_contracts::<P>(
+                    metadata.directory()?,
+                    compiler_path,
+                    metadata.files_to_compile()?,
+                    mode,
+                    deployed_libraries,
+                )
+                .map(|compilation_result| compilation_result.map(CacheValue::new))
+                .await
+            }
+            .instrument(debug_span!(
+                "Running compilation for the cache key",
+                cache_key.platform_key = %cache_key.platform_key,
+                cache_key.compiler_version = %cache_key.compiler_version,
+                cache_key.metadata_file_path = %cache_key.metadata_file_path.display(),
+                cache_key.solc_mode = %cache_key.solc_mode,
+            ))
+        };
+
+        let compiled_contracts = match deployed_libraries {
+            // If deployed libraries have been specified then we will re-compile the contract as it
+            // means that linking is required in this case.
+            Some(_) => {
+                debug!("Deployed libraries defined, recompilation must take place");
+                debug!("Cache miss");
+                compilation_callback().await?.compiler_output
+            }
+            // If no deployed libraries are specified then we can follow the cached flow and attempt
+            // to lookup the compilation artifacts in the cache.
+            None => {
+                debug!("Deployed libraries undefined, attempting to make use of cache");
+
+                // 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 = CACHE_KEY_LOCK.read().await;
+                let mutex = match read_guard.get(&cache_key).cloned() {
+                    Some(value) => value,
+                    None => {
+                        drop(read_guard);
+                        CACHE_KEY_LOCK
+                            .write()
+                            .await
+                            .entry(cache_key.clone())
+                            .or_default()
+                            .clone()
+                    }
+                };
+                let _guard = mutex.lock().await;
+
+                self.0
+                    .get_or_insert_with(&cache_key, compilation_callback)
+                    .await
+                    .map(|value| value.compiler_output)?
+            }
+        };
+
+        Ok((compiled_contracts, compiler_version))
+    }
+}
+
+async fn compile_contracts<P: Platform>(
+    metadata_directory: impl AsRef<Path>,
+    compiler_path: impl AsRef<Path>,
+    mut files_to_compile: impl Iterator<Item = PathBuf>,
+    mode: &Mode,
+    deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+) -> Result<CompilerOutput> {
+    let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
+        .with_allowed_extension("sol")
+        .with_use_cached_fs(true)
+        .collect::<Vec<_>>();
+
+    Compiler::<P::Compiler>::new()
+        .with_allow_path(metadata_directory)
+        // Handling the modes
+        .with_optimization(mode.optimize_setting)
+        .with_pipeline(mode.pipeline)
+        // Adding the contract sources to the compiler.
+        .try_then(|compiler| {
+            files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
+        })?
+        // Adding the deployed libraries to the compiler.
+        .then(|compiler| {
+            deployed_libraries
+                .iter()
+                .flat_map(|value| value.iter())
+                .map(|(instance, (ident, address, abi))| (instance, ident, address, abi))
+                .flat_map(|(_, ident, address, _)| {
+                    all_sources_in_dir
+                        .iter()
+                        .map(move |path| (ident, address, path))
+                })
+                .fold(compiler, |compiler, (ident, address, path)| {
+                    compiler.with_library(path, ident.as_str(), *address)
+                })
+        })
+        .try_build(compiler_path)
+        .await
+}
+
+struct ArtifactsCache {
+    path: PathBuf,
+}
+
+impl ArtifactsCache {
+    pub fn new(path: impl AsRef<Path>) -> Self {
+        Self {
+            path: path.as_ref().to_path_buf(),
+        }
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn with_invalidated_cache(self) -> Result<Self> {
+        cacache::clear(self.path.as_path())
+            .await
+            .map_err(Into::<Error>::into)?;
+        Ok(self)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn insert(&self, key: &CacheKey, value: &CacheValue) -> Result<()> {
+        let key = bson::to_vec(key)?;
+        let value = bson::to_vec(value)?;
+        cacache::write(self.path.as_path(), key.encode_hex(), value).await?;
+        Ok(())
+    }
+
+    pub async fn get(&self, key: &CacheKey) -> Option<CacheValue> {
+        let key = bson::to_vec(key).ok()?;
+        let value = cacache::read(self.path.as_path(), key.encode_hex())
+            .await
+            .ok()?;
+        let value = bson::from_slice::<CacheValue>(&value).ok()?;
+        Some(value)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn get_or_insert_with(
+        &self,
+        key: &CacheKey,
+        callback: impl AsyncFnOnce() -> Result<CacheValue>,
+    ) -> Result<CacheValue> {
+        match self.get(key).await {
+            Some(value) => {
+                debug!("Cache hit");
+                Ok(value)
+            }
+            None => {
+                debug!("Cache miss");
+                let value = callback().await?;
+                self.insert(key, &value).await?;
+                Ok(value)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+struct CacheKey {
+    /// The platform name that this artifact was compiled for. For example, this could be EVM or
+    /// PVM.
+    platform_key: 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: PathBuf,
+
+    /// The mode that the compilation artifacts where compiled with.
+    solc_mode: Mode,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct CacheValue {
+    /// The compiler output from the compilation run.
+    compiler_output: CompilerOutput,
+}
+
+impl CacheValue {
+    pub fn new(compiler_output: CompilerOutput) -> Self {
+        Self { compiler_output }
+    }
+}

crates/core/src/driver/mod.rs

@@ -31,7 +31,7 @@ use revive_dt_format::input::{
     BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method,
     StorageEmptyAssertion,
 };
-use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
+use revive_dt_format::metadata::{ContractIdent, ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Step, metadata::Metadata};
 use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
@@ -44,7 +44,7 @@ pub struct CaseState<T: Platform> {
     compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
 
     /// This map stores the contracts deployments for this case.
-    deployed_contracts: HashMap<ContractInstance, (Address, JsonAbi)>,
+    deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
 
     /// This map stores the variables used for each one of the cases contained in the metadata
     /// file.
@@ -63,7 +63,7 @@ where
     pub fn new(
         compiler_version: Version,
         compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
-        deployed_contracts: HashMap<ContractInstance, (Address, JsonAbi)>,
+        deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
     ) -> Self {
         Self {
             compiled_contracts,
@@ -155,17 +155,10 @@ where
     async fn handle_input_contract_deployment(
         &mut self,
         metadata: &Metadata,
-        case_idx: CaseIdx,
+        _: CaseIdx,
         input: &Input,
         node: &T::Blockchain,
     ) -> anyhow::Result<HashMap<ContractInstance, TransactionReceipt>> {
-        let span = tracing::debug_span!(
-            "Handling contract deployment",
-            ?case_idx,
-            instance = ?input.instance
-        );
-        let _guard = span.enter();
-
         let mut instances_we_must_deploy = IndexMap::<ContractInstance, bool>::new();
         for instance in input.find_all_contract_instances().into_iter() {
             if !self.deployed_contracts.contains_key(&instance) {
@@ -316,9 +309,6 @@ where
         resolver: &impl ResolverApi,
         tracing_result: &CallFrame,
     ) -> anyhow::Result<()> {
-        let span = tracing::info_span!("Handling input expectations");
-        let _guard = span.enter();
-
         // Resolving the `input.expected` into a series of expectations that we can then assert on.
         let mut expectations = match input {
             Input {
@@ -508,9 +498,6 @@ where
         execution_receipt: TransactionReceipt,
         node: &T::Blockchain,
     ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
-        let span = tracing::info_span!("Handling input diff");
-        let _guard = span.enter();
-
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
             disable_code: None,
@@ -662,7 +649,7 @@ where
         value: Option<EtherValue>,
         node: &T::Blockchain,
     ) -> anyhow::Result<(Address, JsonAbi, Option<TransactionReceipt>)> {
-        if let Some((address, abi)) = self.deployed_contracts.get(contract_instance) {
+        if let Some((_, address, abi)) = self.deployed_contracts.get(contract_instance) {
             return Ok((*address, abi.clone(), None));
         }
 
@@ -746,8 +733,10 @@ where
             "Deployed contract"
         );
 
-        self.deployed_contracts
-            .insert(contract_instance.clone(), (address, abi.clone()));
+        self.deployed_contracts.insert(
+            contract_instance.clone(),
+            (contract_ident, address, abi.clone()),
+        );
 
         Ok((address, abi, Some(receipt)))
     }

crates/core/src/main.rs

@@ -1,3 +1,5 @@
+mod cached_compiler;
+
 use std::{
     collections::HashMap,
     path::{Path, PathBuf},
@@ -6,24 +8,21 @@ use std::{
 };
 
 use alloy::{
-    json_abi::JsonAbi,
     network::{Ethereum, TransactionBuilder},
-    primitives::Address,
     rpc::types::TransactionRequest,
 };
 use anyhow::Context;
 use clap::Parser;
-use futures::StreamExt;
-use revive_dt_common::iterators::FilesWithExtensionIterator;
+use futures::stream::futures_unordered::FuturesUnordered;
+use futures::{Stream, StreamExt};
 use revive_dt_node_interaction::EthereumNode;
-use semver::Version;
 use temp_dir::TempDir;
-use tokio::sync::{Mutex, RwLock, mpsc};
+use tokio::sync::mpsc;
 use tracing::{Instrument, Level};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
+use revive_dt_common::types::Mode;
 use revive_dt_compiler::SolidityCompiler;
-use revive_dt_compiler::{Compiler, CompilerOutput};
 use revive_dt_config::*;
 use revive_dt_core::{
     Geth, Kitchensink, Platform,
@@ -33,30 +32,22 @@ use revive_dt_format::{
     case::{Case, CaseIdx},
     corpus::Corpus,
     input::{Input, Step},
-    metadata::{ContractInstance, ContractPathAndIdent, Metadata, MetadataFile},
-    mode::SolcMode,
+    metadata::{ContractPathAndIdent, Metadata, MetadataFile},
 };
 use revive_dt_node::pool::NodePool;
 use revive_dt_report::reporter::{Report, Span};
 
-static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
+use crate::cached_compiler::CachedCompiler;
 
-type CompilationCache = Arc<
-    RwLock<
-        HashMap<
-            (PathBuf, SolcMode, TestingPlatform),
-            Arc<Mutex<Option<Arc<(Version, CompilerOutput)>>>>,
-        >,
-    >,
->;
+static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 
 /// this represents a single "test"; a mode, path and collection of cases.
 #[derive(Clone)]
 struct Test {
     metadata: Metadata,
     path: PathBuf,
-    mode: SolcMode,
-    case_idx: usize,
+    mode: Mode,
+    case_idx: CaseIdx,
     case: Case,
 }
 
@@ -124,7 +115,7 @@ fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<Metad
         let corpus = Corpus::try_from_path(path)?;
         tracing::info!("found corpus: {}", path.display());
         let tests = corpus.enumerate_tests();
-        tracing::info!("corpus '{}' contains {} tests", &corpus.name, tests.len());
+        tracing::info!("corpus '{}' contains {} tests", &corpus.name(), tests.len());
         corpora.insert(corpus, tests);
     }
 
@@ -144,8 +135,8 @@ where
 {
     let (report_tx, report_rx) = mpsc::unbounded_channel::<(Test, CaseResult)>();
 
-    let tests = prepare_tests::<L, F>(metadata_files);
-    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx)?;
+    let tests = prepare_tests::<L, F>(args, metadata_files);
+    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx).await?;
     let status_reporter_task = start_reporter_task(report_rx);
 
     tokio::join!(status_reporter_task, driver_task);
@@ -153,7 +144,10 @@ where
     Ok(())
 }
 
-fn prepare_tests<L, F>(metadata_files: &[MetadataFile]) -> impl Iterator<Item = Test>
+fn prepare_tests<L, F>(
+    args: &Arguments,
+    metadata_files: &[MetadataFile],
+) -> impl Stream<Item = Test>
 where
     L: Platform,
     F: Platform,
@@ -231,15 +225,52 @@ where
                 metadata: metadata.clone(),
                 path: metadata_file_path.to_path_buf(),
                 mode: solc_mode,
-                case_idx,
+                case_idx: case_idx.into(),
                 case: case.clone(),
             }
         })
+        .map(async |test| test)
+        .collect::<FuturesUnordered<_>>()
+        .filter_map(async move |test| {
+            // Check that both compilers support this test, else we skip it
+            let is_supported = does_compiler_support_mode::<L>(args, &test.mode).await.ok().unwrap_or(false) &&
+                does_compiler_support_mode::<F>(args, &test.mode).await.ok().unwrap_or(false);
+
+            // We filter_map to avoid needing to clone `test`, but return it as-is.
+            if is_supported {
+                Some(test)
+            } else {
+                tracing::warn!(
+                    metadata_file_path = %test.path.display(),
+                    case_idx = %test.case_idx,
+                    case_name = ?test.case.name,
+                    mode = %test.mode,
+                    "Skipping test as one or both of the compilers don't support it"
+                );
+                None
+            }
+        })
 }
 
-fn start_driver_task<L, F>(
+async fn does_compiler_support_mode<P: Platform>(
     args: &Arguments,
-    tests: impl Iterator<Item = Test>,
+    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()?;
+
+    Ok(P::Compiler::supports_mode(
+        &compiler_version,
+        mode.optimize_setting,
+        mode.pipeline,
+    ))
+}
+
+async fn start_driver_task<L, F>(
+    args: &Arguments,
+    tests: impl Stream<Item = Test>,
     span: Span,
     report_tx: mpsc::UnboundedSender<(Test, CaseResult)>,
 ) -> anyhow::Result<impl Future<Output = ()>>
@@ -251,10 +282,16 @@ where
 {
     let leader_nodes = Arc::new(NodePool::<L::Blockchain>::new(args)?);
     let follower_nodes = Arc::new(NodePool::<F::Blockchain>::new(args)?);
-    let compilation_cache = Arc::new(RwLock::new(HashMap::new()));
     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?,
+    );
 
-    Ok(futures::stream::iter(tests).for_each_concurrent(
+    Ok(tests.for_each_concurrent(
         // We want to limit the concurrent tasks here because:
         //
         // 1. We don't want to overwhelm the nodes with too many requests, leading to responses timing out.
@@ -266,8 +303,8 @@ where
         move |test| {
             let leader_nodes = leader_nodes.clone();
             let follower_nodes = follower_nodes.clone();
-            let compilation_cache = compilation_cache.clone();
             let report_tx = report_tx.clone();
+            let cached_compiler = cached_compiler.clone();
 
             async move {
                 let leader_node = leader_nodes.round_robbin();
@@ -284,11 +321,11 @@ where
                 let result = handle_case_driver::<L, F>(
                     &test.path,
                     &test.metadata,
-                    test.case_idx.into(),
+                    test.case_idx,
                     &test.case,
                     test.mode.clone(),
                     args,
-                    compilation_cache.clone(),
+                    cached_compiler,
                     leader_node,
                     follower_node,
                     span,
@@ -328,13 +365,13 @@ async fn start_reporter_task(mut report_rx: mpsc::UnboundedReceiver<(Test, CaseR
             Ok(_inputs) => {
                 number_of_successes += 1;
                 eprintln!(
-                    "{GREEN}Case Succeeded:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?})"
+                    "{GREEN}Case Succeeded:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
                 );
             }
             Err(err) => {
                 number_of_failures += 1;
                 eprintln!(
-                    "{RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?})"
+                    "{RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
                 );
                 failures.push((test, err));
             }
@@ -357,7 +394,7 @@ async fn start_reporter_task(mut report_rx: mpsc::UnboundedReceiver<(Test, CaseR
             let test_mode = test.mode.clone();
 
             eprintln!(
-                "---- {RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?}) ----\n\n{err}\n"
+                "---- {RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode}) ----\n\n{err}\n"
             );
         }
     }
@@ -376,9 +413,9 @@ async fn handle_case_driver<L, F>(
     metadata: &Metadata,
     case_idx: CaseIdx,
     case: &Case,
-    mode: SolcMode,
+    mode: Mode,
     config: &Arguments,
-    compilation_cache: CompilationCache,
+    cached_compiler: Arc<CachedCompiler>,
     leader_node: &L::Blockchain,
     follower_node: &F::Blockchain,
     _: Span,
@@ -389,27 +426,19 @@ where
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let leader_pre_link_contracts = get_or_build_contracts::<L>(
-        metadata,
-        metadata_file_path,
-        mode.clone(),
-        config,
-        compilation_cache.clone(),
-        &HashMap::new(),
-    )
-    .await?;
-    let follower_pre_link_contracts = get_or_build_contracts::<F>(
-        metadata,
-        metadata_file_path,
-        mode.clone(),
-        config,
-        compilation_cache.clone(),
-        &HashMap::new(),
-    )
-    .await?;
+    let leader_pre_link_contracts = cached_compiler
+        .compile_contracts::<L>(metadata, metadata_file_path, &mode, config, None)
+        .await?
+        .0
+        .contracts;
+    let follower_pre_link_contracts = cached_compiler
+        .compile_contracts::<F>(metadata, metadata_file_path, &mode, config, None)
+        .await?
+        .0
+        .contracts;
 
-    let mut leader_deployed_libraries = HashMap::new();
-    let mut follower_deployed_libraries = HashMap::new();
+    let mut leader_deployed_libraries = None::<HashMap<_, _>>;
+    let mut follower_deployed_libraries = None::<HashMap<_, _>>;
     let mut contract_sources = metadata.contract_sources()?;
     for library_instance in metadata
         .libraries
@@ -425,14 +454,10 @@ where
             .context("Failed to find the contract source")?;
 
         let (leader_code, leader_abi) = leader_pre_link_contracts
-            .1
-            .contracts
             .get(&library_source_path)
             .and_then(|contracts| contracts.get(library_ident.as_str()))
             .context("Declared library was not compiled")?;
         let (follower_code, follower_abi) = follower_pre_link_contracts
-            .1
-            .contracts
             .get(&library_source_path)
             .and_then(|contracts| contracts.get(library_ident.as_str()))
             .context("Declared library was not compiled")?;
@@ -525,81 +550,52 @@ where
             anyhow::bail!("Contract deployment didn't return an address");
         };
 
-        leader_deployed_libraries.insert(
+        leader_deployed_libraries.get_or_insert_default().insert(
             library_instance.clone(),
-            (leader_library_address, leader_abi.clone()),
+            (
+                library_ident.clone(),
+                leader_library_address,
+                leader_abi.clone(),
+            ),
         );
-        follower_deployed_libraries.insert(
+        follower_deployed_libraries.get_or_insert_default().insert(
             library_instance.clone(),
-            (follower_library_address, follower_abi.clone()),
+            (
+                library_ident,
+                follower_library_address,
+                follower_abi.clone(),
+            ),
         );
     }
 
-    let metadata_file_contains_libraries = metadata
-        .libraries
-        .iter()
-        .flat_map(|map| map.iter())
-        .flat_map(|(_, value)| value.iter())
-        .next()
-        .is_some();
-    let compiled_contracts_require_linking = leader_pre_link_contracts
-        .1
-        .contracts
-        .values()
-        .chain(follower_pre_link_contracts.1.contracts.values())
-        .flat_map(|value| value.values())
-        .any(|(code, _)| !code.chars().all(|char| char.is_ascii_hexdigit()));
-    let (leader_compiled_contracts, follower_compiled_contracts) =
-        if metadata_file_contains_libraries && compiled_contracts_require_linking {
-            let leader_key = (
-                metadata_file_path.to_path_buf(),
-                mode.clone(),
-                L::config_id(),
-            );
-            let follower_key = (
-                metadata_file_path.to_path_buf(),
-                mode.clone(),
-                F::config_id(),
-            );
-            {
-                let mut cache = compilation_cache.write().await;
-                cache.remove(&leader_key);
-                cache.remove(&follower_key);
-            }
-
-            let leader_post_link_contracts = get_or_build_contracts::<L>(
-                metadata,
-                metadata_file_path,
-                mode.clone(),
-                config,
-                compilation_cache.clone(),
-                &leader_deployed_libraries,
-            )
-            .await?;
-            let follower_post_link_contracts = get_or_build_contracts::<F>(
-                metadata,
-                metadata_file_path,
-                mode.clone(),
-                config,
-                compilation_cache,
-                &follower_deployed_libraries,
-            )
-            .await?;
-
-            (leader_post_link_contracts, follower_post_link_contracts)
-        } else {
-            (leader_pre_link_contracts, follower_pre_link_contracts)
-        };
+    let (leader_post_link_contracts, leader_compiler_version) = cached_compiler
+        .compile_contracts::<L>(
+            metadata,
+            metadata_file_path,
+            &mode,
+            config,
+            leader_deployed_libraries.as_ref(),
+        )
+        .await?;
+    let (follower_post_link_contracts, follower_compiler_version) = cached_compiler
+        .compile_contracts::<F>(
+            metadata,
+            metadata_file_path,
+            &mode,
+            config,
+            follower_deployed_libraries.as_ref(),
+        )
+        .await?;
 
     let leader_state = CaseState::<L>::new(
-        leader_compiled_contracts.0.clone(),
-        leader_compiled_contracts.1.contracts.clone(),
-        leader_deployed_libraries,
+        leader_compiler_version,
+        leader_post_link_contracts.contracts,
+        leader_deployed_libraries.unwrap_or_default(),
     );
     let follower_state = CaseState::<F>::new(
-        follower_compiled_contracts.0.clone(),
-        follower_compiled_contracts.1.contracts.clone(),
-        follower_deployed_libraries,
+        follower_compiler_version,
+        follower_post_link_contracts.contracts,
+        follower_deployed_libraries.unwrap_or_default(),
     );
 
     let mut driver = CaseDriver::<L, F>::new(
@@ -614,117 +610,6 @@ where
     driver.execute().await
 }
 
-async fn get_or_build_contracts<P: Platform>(
-    metadata: &Metadata,
-    metadata_file_path: &Path,
-    mode: SolcMode,
-    config: &Arguments,
-    compilation_cache: CompilationCache,
-    deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
-) -> anyhow::Result<Arc<(Version, CompilerOutput)>> {
-    let key = (
-        metadata_file_path.to_path_buf(),
-        mode.clone(),
-        P::config_id(),
-    );
-    if let Some(compilation_artifact) = compilation_cache.read().await.get(&key).cloned() {
-        let mut compilation_artifact = compilation_artifact.lock().await;
-        match *compilation_artifact {
-            Some(ref compiled_contracts) => {
-                tracing::debug!(?key, "Compiled contracts cache hit");
-                return Ok(compiled_contracts.clone());
-            }
-            None => {
-                tracing::debug!(?key, "Compiled contracts cache miss");
-                let compiled_contracts = Arc::new(
-                    compile_contracts::<P>(
-                        metadata,
-                        metadata_file_path,
-                        &mode,
-                        config,
-                        deployed_libraries,
-                    )
-                    .await?,
-                );
-                *compilation_artifact = Some(compiled_contracts.clone());
-                return Ok(compiled_contracts.clone());
-            }
-        }
-    };
-
-    tracing::debug!(?key, "Compiled contracts cache miss");
-    let mutex = {
-        let mut compilation_cache = compilation_cache.write().await;
-        let mutex = Arc::new(Mutex::new(None));
-        compilation_cache.insert(key, mutex.clone());
-        mutex
-    };
-    let mut compilation_artifact = mutex.lock().await;
-    let compiled_contracts = Arc::new(
-        compile_contracts::<P>(
-            metadata,
-            metadata_file_path,
-            &mode,
-            config,
-            deployed_libraries,
-        )
-        .await?,
-    );
-    *compilation_artifact = Some(compiled_contracts.clone());
-    Ok(compiled_contracts.clone())
-}
-
-async fn compile_contracts<P: Platform>(
-    metadata: &Metadata,
-    metadata_file_path: &Path,
-    mode: &SolcMode,
-    config: &Arguments,
-    deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
-) -> anyhow::Result<(Version, CompilerOutput)> {
-    let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
-    let compiler_path =
-        P::Compiler::get_compiler_executable(config, compiler_version_or_requirement).await?;
-    let compiler_version = P::Compiler::new(compiler_path.clone()).version()?;
-
-    tracing::info!(
-        %compiler_version,
-        metadata_file_path = %metadata_file_path.display(),
-        mode = ?mode,
-        "Compiling contracts"
-    );
-
-    let compiler = Compiler::<P::Compiler>::new()
-        .with_allow_path(metadata.directory()?)
-        .with_optimization(mode.solc_optimize());
-    let mut compiler = metadata
-        .files_to_compile()?
-        .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
-    for (library_instance, (library_address, _)) in deployed_libraries.iter() {
-        let library_ident = &metadata
-            .contracts
-            .as_ref()
-            .and_then(|contracts| contracts.get(library_instance))
-            .expect("Impossible for library to not be found in contracts")
-            .contract_ident;
-
-        // Note the following: we need to tell solc which files require the libraries to be linked
-        // into them. We do not have access to this information and therefore we choose an easier,
-        // yet more compute intensive route, of telling solc that all of the files need to link the
-        // library and it will only perform the linking for the files that do actually need the
-        // library.
-        compiler = FilesWithExtensionIterator::new(metadata.directory()?)
-            .with_allowed_extension("sol")
-            .with_use_cached_fs(true)
-            .fold(compiler, |compiler, path| {
-                compiler.with_library(&path, library_ident.as_str(), *library_address)
-            });
-    }
-
-    let compiler_output = compiler.try_build(compiler_path).await?;
-
-    Ok((compiler_version, compiler_output))
-}
-
 async fn execute_corpus(
     args: &Arguments,
     tests: &[MetadataFile],
@@ -756,28 +641,40 @@ async fn compile_corpus(
             .map(move |solc_mode| (metadata, solc_mode))
     });
 
+    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");
+
     futures::stream::iter(tests)
-        .for_each_concurrent(None, |(metadata, mode)| async move {
-            match platform {
-                TestingPlatform::Geth => {
-                    let _ = compile_contracts::<Geth>(
-                        &metadata.content,
-                        &metadata.path,
-                        &mode,
-                        config,
-                        &Default::default(),
-                    )
-                    .await;
-                }
-                TestingPlatform::Kitchensink => {
-                    let _ = compile_contracts::<Geth>(
-                        &metadata.content,
-                        &metadata.path,
-                        &mode,
-                        config,
-                        &Default::default(),
-                    )
-                    .await;
+        .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.path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                            )
+                            .await;
+                    }
+                    TestingPlatform::Kitchensink => {
+                        let _ = cached_compiler
+                            .compile_contracts::<Kitchensink>(
+                                metadata,
+                                metadata.path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                            )
+                            .await;
+                    }
                 }
             }
         })

crates/format/Cargo.toml

@@ -17,6 +17,7 @@ alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
+regex = { workspace = true }
 tracing = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }

crates/format/src/case.rs

@@ -4,7 +4,7 @@ use revive_dt_common::macros::define_wrapper_type;
 
 use crate::{
     input::{Expected, Step},
-    mode::Mode,
+    mode::ParsedMode,
 };
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
@@ -16,7 +16,7 @@ pub struct Case {
     pub comment: Option<String>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub modes: Option<Vec<Mode>>,
+    pub modes: Option<Vec<ParsedMode>>,
 
     #[serde(rename = "inputs")]
     pub steps: Vec<Step>,
@@ -67,3 +67,9 @@ define_wrapper_type!(
     #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
     pub struct CaseIdx(usize);
 );
+
+impl std::fmt::Display for CaseIdx {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}

crates/format/src/corpus.rs

@@ -8,43 +8,74 @@ use serde::{Deserialize, Serialize};
 
 use crate::metadata::MetadataFile;
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq, Hash)]
-pub struct Corpus {
-    pub name: String,
-    pub path: PathBuf,
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Corpus {
+    SinglePath { name: String, path: PathBuf },
+    MultiplePaths { name: String, paths: Vec<PathBuf> },
 }
 
 impl Corpus {
-    /// Try to read and parse the corpus definition file at given `path`.
-    pub fn try_from_path(path: &Path) -> anyhow::Result<Self> {
-        let file = File::open(path)?;
-        let mut corpus: Corpus = serde_json::from_reader(file)?;
+    pub fn try_from_path(file_path: impl AsRef<Path>) -> anyhow::Result<Self> {
+        let mut corpus = File::open(file_path.as_ref())
+            .map_err(Into::<anyhow::Error>::into)
+            .and_then(|file| serde_json::from_reader::<_, Corpus>(file).map_err(Into::into))?;
 
-        // Ensure that the path mentioned in the corpus is relative to the corpus file.
-        // Canonicalizing also helps make the path in any errors unambiguous.
-        corpus.path = path
-            .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(corpus.path);
+        for path in corpus.paths_iter_mut() {
+            *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)
     }
 
-    /// Scan the corpus base directory and return all tests found.
     pub fn enumerate_tests(&self) -> Vec<MetadataFile> {
         let mut tests = Vec::new();
-        collect_metadata(&self.path, &mut tests);
+        for path in self.paths_iter() {
+            collect_metadata(path, &mut tests);
+        }
         tests
     }
+
+    pub fn name(&self) -> &str {
+        match self {
+            Corpus::SinglePath { name, .. } | Corpus::MultiplePaths { name, .. } => name.as_str(),
+        }
+    }
+
+    pub fn paths_iter(&self) -> impl Iterator<Item = &Path> {
+        match self {
+            Corpus::SinglePath { path, .. } => {
+                Box::new(std::iter::once(path.as_path())) as Box<dyn Iterator<Item = _>>
+            }
+            Corpus::MultiplePaths { paths, .. } => {
+                Box::new(paths.iter().map(|path| path.as_path())) as Box<dyn Iterator<Item = _>>
+            }
+        }
+    }
+
+    pub fn paths_iter_mut(&mut self) -> impl Iterator<Item = &mut PathBuf> {
+        match self {
+            Corpus::SinglePath { path, .. } => {
+                Box::new(std::iter::once(path)) as Box<dyn Iterator<Item = _>>
+            }
+            Corpus::MultiplePaths { paths, .. } => {
+                Box::new(paths.iter_mut()) as Box<dyn Iterator<Item = _>>
+            }
+        }
+    }
 }
 
 /// Recursively walks `path` and parses any JSON or Solidity file into a test

crates/format/src/input.rs

@@ -739,12 +739,14 @@ impl<'de> Deserialize<'de> for EtherValue {
 #[cfg(test)]
 mod tests {
 
-    use super::*;
     use alloy::{eips::BlockNumberOrTag, json_abi::JsonAbi};
     use alloy_primitives::{BlockHash, BlockNumber, BlockTimestamp, ChainId, TxHash, address};
     use alloy_sol_types::SolValue;
     use std::collections::HashMap;
 
+    use super::*;
+    use crate::metadata::ContractIdent;
+
     struct MockResolver;
 
     impl ResolverApi for MockResolver {
@@ -818,11 +820,11 @@ mod tests {
         let mut contracts = HashMap::new();
         contracts.insert(
             ContractInstance::new("Contract"),
-            (Address::ZERO, parsed_abi),
+            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
         );
 
         let resolver = MockResolver;
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
         let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
@@ -862,11 +864,11 @@ mod tests {
         let mut contracts = HashMap::new();
         contracts.insert(
             ContractInstance::new("Contract"),
-            (Address::ZERO, parsed_abi),
+            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
         );
 
         let resolver = MockResolver;
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
         let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
@@ -909,11 +911,11 @@ mod tests {
         let mut contracts = HashMap::new();
         contracts.insert(
             ContractInstance::new("Contract"),
-            (Address::ZERO, parsed_abi),
+            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
         );
 
         let resolver = MockResolver;
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
         let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
@@ -927,10 +929,10 @@ mod tests {
 
     async fn resolve_calldata_item(
         input: &str,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        deployed_contracts: &HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
         resolver: &impl ResolverApi,
     ) -> anyhow::Result<U256> {
-        let context = ResolutionContext::new_from_parts(deployed_contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(deployed_contracts);
         CalldataItem::new(input).resolve(resolver, context).await
     }
 

crates/format/src/metadata.rs

@@ -13,12 +13,10 @@ use serde::{Deserialize, Serialize};
 use revive_common::EVMVersion;
 use revive_dt_common::{
     cached_fs::read_to_string, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
+    types::Mode,
 };
 
-use crate::{
-    case::Case,
-    mode::{Mode, SolcMode},
-};
+use crate::{case::Case, mode::ParsedMode};
 
 pub const METADATA_FILE_EXTENSION: &str = "json";
 pub const SOLIDITY_CASE_FILE_EXTENSION: &str = "sol";
@@ -68,7 +66,7 @@ pub struct Metadata {
     pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub modes: Option<Vec<Mode>>,
+    pub modes: Option<Vec<ParsedMode>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub file_path: Option<PathBuf>,
@@ -86,21 +84,12 @@ pub struct Metadata {
 }
 
 impl Metadata {
-    /// Returns the solc modes of this metadata, inserting a default mode if not present.
-    pub fn solc_modes(&self) -> Vec<SolcMode> {
-        self.modes
-            .to_owned()
-            .unwrap_or_else(|| vec![Mode::Solidity(Default::default())])
-            .iter()
-            .filter_map(|mode| match mode {
-                Mode::Solidity(solc_mode) => Some(solc_mode),
-                Mode::Unknown(mode) => {
-                    tracing::debug!("compiler: ignoring unknown mode '{mode}'");
-                    None
-                }
-            })
-            .cloned()
-            .collect()
+    /// Returns the modes that we should test from this metadata.
+    pub fn solc_modes(&self) -> Vec<Mode> {
+        match &self.modes {
+            Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
+            None => Mode::all().collect(),
+        }
     }
 
     /// Returns the base directory of this metadata.

crates/format/src/mode.rs

@@ -1,123 +1,262 @@
-use revive_dt_common::types::VersionOrRequirement;
-use semver::Version;
-use serde::de::Deserializer;
+use regex::Regex;
+use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::fmt::Display;
+use std::str::FromStr;
+use std::sync::LazyLock;
 
-/// Specifies the compilation mode of the test artifact.
-#[derive(Hash, Debug, Clone, Eq, PartialEq)]
-pub enum Mode {
-    Solidity(SolcMode),
-    Unknown(String),
+/// This represents a mode that has been parsed from test metadata.
+///
+/// Mode strings can take the following form (in pseudo-regex):
+///
+/// ```text
+/// [YEILV][+-]? (M[0123sz])? <semver>?
+/// ```
+///
+/// We can parse valid mode strings into [`ParsedMode`] using [`ParsedMode::from_str`].
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[serde(try_from = "String", into = "String")]
+pub struct ParsedMode {
+    pub pipeline: Option<ModePipeline>,
+    pub optimize_flag: Option<bool>,
+    pub optimize_setting: Option<ModeOptimizerSetting>,
+    pub version: Option<semver::VersionReq>,
 }
 
-/// Specify Solidity specific compiler options.
-#[derive(Hash, Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
-pub struct SolcMode {
-    pub solc_version: Option<semver::VersionReq>,
-    solc_optimize: Option<bool>,
-    pub llvm_optimizer_settings: Vec<String>,
-    mode_string: String,
-}
+impl FromStr for ParsedMode {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        static REGEX: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"(?x)
+                ^
+                (?:(?P<pipeline>[YEILV])(?P<optimize_flag>[+-])?)? # Pipeline to use eg Y, E+, E-
+                \s*
+                (?P<optimize_setting>M[a-zA-Z0-9])?                # Optimize setting eg M0, Ms, Mz
+                \s*
+                (?P<version>[>=<]*\d+(?:\.\d+)*)?                  # Optional semver version eg >=0.8.0, 0.7, <0.8
+                $
+            ").unwrap()
+        });
 
-impl SolcMode {
-    /// Try to parse a mode string into a solc mode.
-    /// Returns `None` if the string wasn't a solc YUL mode string.
-    ///
-    /// The mode string is expected to start with the `Y` ID (YUL ID),
-    /// optionally followed by `+` or `-` for the solc optimizer settings.
-    ///
-    /// Options can be separated by a whitespace contain the following
-    /// - A solc `SemVer version requirement` string
-    /// - One or more `-OX` where X is a supposed to be an LLVM opt mode
-    pub fn parse_from_mode_string(mode_string: &str) -> Option<Self> {
-        let mut result = Self {
-            mode_string: mode_string.to_string(),
-            ..Default::default()
+        let Some(caps) = REGEX.captures(s) else {
+            anyhow::bail!("Cannot parse mode '{s}' from string");
         };
 
-        let mut parts = mode_string.trim().split(" ");
-
-        match parts.next()? {
-            "Y" => {}
-            "Y+" => result.solc_optimize = Some(true),
-            "Y-" => result.solc_optimize = Some(false),
-            _ => return None,
-        }
-
-        for part in parts {
-            if let Ok(solc_version) = semver::VersionReq::parse(part) {
-                result.solc_version = Some(solc_version);
-                continue;
-            }
-            if let Some(level) = part.strip_prefix("-O") {
-                result.llvm_optimizer_settings.push(level.to_string());
-                continue;
-            }
-            panic!("the YUL mode string {mode_string} failed to parse, invalid part: {part}")
-        }
-
-        Some(result)
-    }
-
-    /// Returns whether to enable the solc optimizer.
-    pub fn solc_optimize(&self) -> bool {
-        self.solc_optimize.unwrap_or(true)
-    }
-
-    /// Calculate the latest matching solc patch version. Returns:
-    /// - `latest_supported` if no version request was specified.
-    /// - A matching version with the same minor version as `latest_supported`, if any.
-    /// - `None` if no minor version of the `latest_supported` version matches.
-    pub fn last_patch_version(&self, latest_supported: &Version) -> Option<Version> {
-        let Some(version_req) = self.solc_version.as_ref() else {
-            return Some(latest_supported.to_owned());
+        let pipeline = match caps.name("pipeline") {
+            Some(m) => Some(ModePipeline::from_str(m.as_str())?),
+            None => None,
         };
 
-        // lgtm
-        for patch in (0..latest_supported.patch + 1).rev() {
-            let version = Version::new(0, latest_supported.minor, patch);
-            if version_req.matches(&version) {
-                return Some(version);
-            }
-        }
+        let optimize_flag = caps.name("optimize_flag").map(|m| m.as_str() == "+");
 
-        None
-    }
-
-    /// Resolves the [`SolcMode`]'s solidity version requirement into a [`VersionOrRequirement`] if
-    /// the requirement is present on the object. Otherwise, the passed default version is used.
-    pub fn compiler_version_to_use(&self, default: Version) -> VersionOrRequirement {
-        match self.solc_version {
-            Some(ref requirement) => requirement.clone().into(),
-            None => default.into(),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for Mode {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let mode_string = String::deserialize(deserializer)?;
-
-        if let Some(solc_mode) = SolcMode::parse_from_mode_string(&mode_string) {
-            return Ok(Self::Solidity(solc_mode));
-        }
-
-        Ok(Self::Unknown(mode_string))
-    }
-}
-
-impl Serialize for Mode {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let string = match self {
-            Mode::Solidity(solc_mode) => &solc_mode.mode_string,
-            Mode::Unknown(string) => string,
+        let optimize_setting = match caps.name("optimize_setting") {
+            Some(m) => Some(ModeOptimizerSetting::from_str(m.as_str())?),
+            None => None,
         };
-        string.serialize(serializer)
+
+        let version = match caps.name("version") {
+            Some(m) => Some(semver::VersionReq::parse(m.as_str()).map_err(|e| {
+                anyhow::anyhow!("Cannot parse the version requirement '{}': {e}", m.as_str())
+            })?),
+            None => None,
+        };
+
+        Ok(ParsedMode {
+            pipeline,
+            optimize_flag,
+            optimize_setting,
+            version,
+        })
+    }
+}
+
+impl Display for ParsedMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut has_written = false;
+
+        if let Some(pipeline) = self.pipeline {
+            pipeline.fmt(f)?;
+            if let Some(optimize_flag) = self.optimize_flag {
+                f.write_str(if optimize_flag { "+" } else { "-" })?;
+            }
+            has_written = true;
+        }
+
+        if let Some(optimize_setting) = self.optimize_setting {
+            if has_written {
+                f.write_str(" ")?;
+            }
+            optimize_setting.fmt(f)?;
+            has_written = true;
+        }
+
+        if let Some(version) = &self.version {
+            if has_written {
+                f.write_str(" ")?;
+            }
+            version.fmt(f)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl From<ParsedMode> for String {
+    fn from(parsed_mode: ParsedMode) -> Self {
+        parsed_mode.to_string()
+    }
+}
+
+impl TryFrom<String> for ParsedMode {
+    type Error = anyhow::Error;
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        ParsedMode::from_str(&value)
+    }
+}
+
+impl ParsedMode {
+    /// This takes a [`ParsedMode`] and expands it into a list of [`Mode`]s that we should try.
+    pub fn to_modes(&self) -> impl Iterator<Item = Mode> {
+        let pipeline_iter = self.pipeline.as_ref().map_or_else(
+            || EitherIter::A(ModePipeline::test_cases()),
+            |p| EitherIter::B(std::iter::once(*p)),
+        );
+
+        let optimize_flag_setting = self.optimize_flag.map(|flag| {
+            if flag {
+                ModeOptimizerSetting::M3
+            } else {
+                ModeOptimizerSetting::M0
+            }
+        });
+
+        let optimize_flag_iter = match optimize_flag_setting {
+            Some(setting) => EitherIter::A(std::iter::once(setting)),
+            None => EitherIter::B(ModeOptimizerSetting::test_cases()),
+        };
+
+        let optimize_settings_iter = self.optimize_setting.as_ref().map_or_else(
+            || EitherIter::A(optimize_flag_iter),
+            |s| EitherIter::B(std::iter::once(*s)),
+        );
+
+        pipeline_iter.flat_map(move |pipeline| {
+            optimize_settings_iter
+                .clone()
+                .map(move |optimize_setting| Mode {
+                    pipeline,
+                    optimize_setting,
+                    version: self.version.clone(),
+                })
+        })
+    }
+
+    /// Return a set of [`Mode`]s that correspond to the given [`ParsedMode`]s.
+    /// This avoids any duplicate entries.
+    pub fn many_to_modes<'a>(
+        parsed: impl Iterator<Item = &'a ParsedMode>,
+    ) -> impl Iterator<Item = Mode> {
+        let modes: HashSet<_> = parsed.flat_map(|p| p.to_modes()).collect();
+        modes.into_iter()
+    }
+}
+
+/// 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::*;
+
+    #[test]
+    fn test_parsed_mode_from_str() {
+        let strings = vec![
+            ("Mz", "Mz"),
+            ("Y", "Y"),
+            ("Y+", "Y+"),
+            ("Y-", "Y-"),
+            ("E", "E"),
+            ("E+", "E+"),
+            ("E-", "E-"),
+            ("Y M0", "Y M0"),
+            ("Y M1", "Y M1"),
+            ("Y M2", "Y M2"),
+            ("Y M3", "Y M3"),
+            ("Y Ms", "Y Ms"),
+            ("Y Mz", "Y Mz"),
+            ("E M0", "E M0"),
+            ("E M1", "E M1"),
+            ("E M2", "E M2"),
+            ("E M3", "E M3"),
+            ("E Ms", "E Ms"),
+            ("E Mz", "E Mz"),
+            // When stringifying semver again, 0.8.0 becomes ^0.8.0 (same meaning)
+            ("Y 0.8.0", "Y ^0.8.0"),
+            ("E+ 0.8.0", "E+ ^0.8.0"),
+            ("Y M3 >=0.8.0", "Y M3 >=0.8.0"),
+            ("E Mz <0.7.0", "E Mz <0.7.0"),
+            // We can parse +- _and_ M1/M2 but the latter takes priority.
+            ("Y+ M1 0.8.0", "Y+ M1 ^0.8.0"),
+            ("E- M2 0.7.0", "E- M2 ^0.7.0"),
+            // We don't see this in the wild but it is parsed.
+            ("<=0.8", "<=0.8"),
+        ];
+
+        for (actual, expected) in strings {
+            let parsed = ParsedMode::from_str(actual)
+                .expect(format!("Failed to parse mode string '{actual}'").as_str());
+            assert_eq!(
+                expected,
+                parsed.to_string(),
+                "Mode string '{actual}' did not parse to '{expected}': got '{parsed}'"
+            );
+        }
+    }
+
+    #[test]
+    fn test_parsed_mode_to_test_modes() {
+        let strings = vec![
+            ("Mz", vec!["Y Mz", "E Mz"]),
+            ("Y", vec!["Y M0", "Y M3"]),
+            ("E", vec!["E M0", "E M3"]),
+            ("Y+", vec!["Y M3"]),
+            ("Y-", vec!["Y M0"]),
+            ("Y <=0.8", vec!["Y M0 <=0.8", "Y M3 <=0.8"]),
+            (
+                "<=0.8",
+                vec!["Y M0 <=0.8", "Y M3 <=0.8", "E M0 <=0.8", "E M3 <=0.8"],
+            ),
+        ];
+
+        for (actual, expected) in strings {
+            let parsed = ParsedMode::from_str(actual)
+                .expect(format!("Failed to parse mode string '{actual}'").as_str());
+            let expected_set: HashSet<_> = expected.into_iter().map(|s| s.to_owned()).collect();
+            let actual_set: HashSet<_> = parsed.to_modes().map(|m| m.to_string()).collect();
+
+            assert_eq!(
+                expected_set, actual_set,
+                "Mode string '{actual}' did not expand to '{expected_set:?}': got '{actual_set:?}'"
+            );
+        }
     }
 }

crates/format/src/traits.rs

@@ -6,7 +6,7 @@ use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId
 use alloy_primitives::TxHash;
 use anyhow::Result;
 
-use crate::metadata::ContractInstance;
+use crate::metadata::{ContractIdent, ContractInstance};
 
 /// A trait of the interface are required to implement to be used by the resolution logic that this
 /// crate implements to go from string calldata and into the bytes calldata.
@@ -48,7 +48,7 @@ pub trait ResolverApi {
 /// Contextual information required by the code that's performing the resolution.
 pub struct ResolutionContext<'a> {
     /// When provided the contracts provided here will be used for resolutions.
-    deployed_contracts: Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>,
+    deployed_contracts: Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
 
     /// When provided the variables in here will be used for performing resolutions.
     variables: Option<&'a HashMap<String, U256>>,
@@ -66,7 +66,9 @@ impl<'a> ResolutionContext<'a> {
     }
 
     pub fn new_from_parts(
-        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+        deployed_contracts: impl Into<
+            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+        >,
         variables: impl Into<Option<&'a HashMap<String, U256>>>,
         block_number: impl Into<Option<&'a BlockNumber>>,
         transaction_hash: impl Into<Option<&'a TxHash>>,
@@ -81,7 +83,9 @@ impl<'a> ResolutionContext<'a> {
 
     pub fn with_deployed_contracts(
         mut self,
-        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+        deployed_contracts: impl Into<
+            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+        >,
     ) -> Self {
         self.deployed_contracts = deployed_contracts.into();
         self
@@ -122,17 +126,20 @@ impl<'a> ResolutionContext<'a> {
         }
     }
 
-    pub fn deployed_contract(&self, instance: &ContractInstance) -> Option<&(Address, JsonAbi)> {
+    pub fn deployed_contract(
+        &self,
+        instance: &ContractInstance,
+    ) -> Option<&(ContractIdent, Address, JsonAbi)> {
         self.deployed_contracts
             .and_then(|deployed_contracts| deployed_contracts.get(instance))
     }
 
     pub fn deployed_contract_address(&self, instance: &ContractInstance) -> Option<&Address> {
-        self.deployed_contract(instance).map(|(a, _)| a)
+        self.deployed_contract(instance).map(|(_, a, _)| a)
     }
 
     pub fn deployed_contract_abi(&self, instance: &ContractInstance) -> Option<&JsonAbi> {
-        self.deployed_contract(instance).map(|(_, a)| a)
+        self.deployed_contract(instance).map(|(_, _, a)| a)
     }
 
     pub fn variable(&self, name: impl AsRef<str>) -> Option<&U256> {

crates/node/src/geth.rs

@@ -60,7 +60,6 @@ pub struct GethNode {
     geth: PathBuf,
     id: u32,
     handle: Option<Child>,
-    network_id: u64,
     start_timeout: u64,
     wallet: EthereumWallet,
     nonce_manager: CachedNonceManager,
@@ -165,8 +164,6 @@ impl GethNode {
             .arg(&self.data_directory)
             .arg("--ipcpath")
             .arg(&self.connection_string)
-            .arg("--networkid")
-            .arg(self.network_id.to_string())
             .arg("--nodiscover")
             .arg("--maxpeers")
             .arg("0")
@@ -213,6 +210,7 @@ impl GethNode {
 
         let maximum_wait_time = Duration::from_millis(self.start_timeout);
         let mut stderr = BufReader::new(logs_file).lines();
+        let mut lines = vec![];
         loop {
             if let Some(Ok(line)) = stderr.next() {
                 if line.contains(Self::ERROR_MARKER) {
@@ -221,9 +219,14 @@ impl GethNode {
                 if line.contains(Self::READY_MARKER) {
                     return Ok(self);
                 }
+                lines.push(line);
             }
             if Instant::now().duration_since(start_time) > maximum_wait_time {
-                anyhow::bail!("Timeout in starting geth");
+                anyhow::bail!(
+                    "Timeout in starting geth: took longer than {}ms. stdout:\n\n{}\n",
+                    self.start_timeout,
+                    lines.join("\n")
+                );
             }
         }
     }
@@ -257,7 +260,11 @@ impl GethNode {
         Box::pin(async move {
             ProviderBuilder::new()
                 .disable_recommended_fillers()
-                .filler(FallbackGasFiller::new(500_000_000, 500_000_000, 1))
+                .filler(FallbackGasFiller::new(
+                    25_000_000,
+                    1_000_000_000,
+                    1_000_000_000,
+                ))
                 .filler(ChainIdFiller::default())
                 .filler(NonceFiller::new(nonce_manager))
                 .wallet(wallet)
@@ -274,9 +281,6 @@ impl EthereumNode for GethNode {
         &self,
         transaction: TransactionRequest,
     ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let span = tracing::debug_span!("Submitting transaction", ?transaction);
-        let _guard = span.enter();
-
         let provider = Arc::new(self.provider().await?);
         let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();
 
@@ -517,7 +521,6 @@ impl Node for GethNode {
             geth: config.geth.clone(),
             id,
             handle: None,
-            network_id: config.network_id,
             start_timeout: config.geth_start_timeout,
             wallet,
             // We know that we only need to be storing 2 files so we can specify that when creating

crates/node/src/kitchensink.rs

@@ -367,9 +367,9 @@ impl KitchensinkNode {
                 .disable_recommended_fillers()
                 .network::<KitchenSinkNetwork>()
                 .filler(FallbackGasFiller::new(
-                    30_000_000,
-                    200_000_000_000,
-                    3_000_000_000,
+                    25_000_000,
+                    1_000_000_000,
+                    1_000_000_000,
                 ))
                 .filler(ChainIdFiller::default())
                 .filler(NonceFiller::new(nonce_manager))

crates/report/Cargo.toml

@@ -8,6 +8,7 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
+revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
 revive-dt-compiler = { workspace = true }

crates/report/src/reporter.rs

@@ -12,18 +12,19 @@ use std::{
 };
 
 use anyhow::Context;
-use revive_dt_compiler::{CompilerInput, CompilerOutput};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 
+use revive_dt_common::types::Mode;
+use revive_dt_compiler::{CompilerInput, CompilerOutput};
 use revive_dt_config::{Arguments, TestingPlatform};
-use revive_dt_format::{corpus::Corpus, mode::SolcMode};
+use revive_dt_format::corpus::Corpus;
 
 use crate::analyzer::CompilerStatistics;
 
 pub(crate) static REPORTER: OnceLock<Mutex<Report>> = OnceLock::new();
 
 /// The `Report` datastructure stores all relevant inforamtion required for generating reports.
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize)]
 pub struct Report {
     /// The configuration used during the test.
     pub config: Arguments,
@@ -41,14 +42,14 @@ pub struct Report {
 }
 
 /// Contains a compiled contract.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct CompilationTask {
     /// The observed compiler input.
     pub json_input: CompilerInput,
     /// The observed compiler output.
     pub json_output: Option<CompilerOutput>,
     /// The observed compiler mode.
-    pub mode: SolcMode,
+    pub mode: Mode,
     /// The observed compiler version.
     pub compiler_version: String,
     /// The observed error, if any.
@@ -56,7 +57,7 @@ pub struct CompilationTask {
 }
 
 /// Represents a report about a compilation task.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct CompilationResult {
     /// The observed compilation task.
     pub compilation_task: CompilationTask,
@@ -65,7 +66,7 @@ pub struct CompilationResult {
 }
 
 /// The [Span] struct indicates the context of what is being reported.
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize)]
 pub struct Span {
     /// The corpus index this belongs to.
     corpus: usize,