Lower gas limit for failed estimates

crates/common/src/cached_fs/mod.rs

@@ -47,3 +47,27 @@ pub fn read_dir(path: impl AsRef<Path>) -> Result<Box<dyn Iterator<Item = Result
         }
     }
 }
+
+pub trait PathExt {
+    fn cached_canonicalize(&self) -> Result<PathBuf>;
+}
+
+impl<T> PathExt for T
+where
+    T: AsRef<Path>,
+{
+    fn cached_canonicalize(&self) -> Result<PathBuf> {
+        static CANONICALIZATION_CACHE: Lazy<Cache<PathBuf, PathBuf>> =
+            Lazy::new(|| Cache::new(10_000));
+
+        let path = self.as_ref().to_path_buf();
+        match CANONICALIZATION_CACHE.get(&path) {
+            Some(canonicalized) => Ok(canonicalized),
+            None => {
+                let canonicalized = path.canonicalize()?;
+                CANONICALIZATION_CACHE.insert(path, canonicalized.clone());
+                Ok(canonicalized)
+            }
+        }
+    }
+}

crates/common/src/types/version_or_requirement.rs

@@ -1,6 +1,9 @@
+use std::{fmt::Display, str::FromStr};
+
+use anyhow::{Error, bail};
 use semver::{Version, VersionReq};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum VersionOrRequirement {
     Version(Version),
     Requirement(VersionReq),
@@ -39,3 +42,26 @@ impl TryFrom<VersionOrRequirement> for VersionReq {
         Ok(requirement)
     }
 }
+
+impl FromStr for VersionOrRequirement {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Ok(version) = Version::parse(s) {
+            Ok(Self::Version(version))
+        } else if let Ok(version_req) = VersionReq::parse(s) {
+            Ok(Self::Requirement(version_req))
+        } else {
+            bail!("Not a valid version or version requirement")
+        }
+    }
+}
+
+impl Display for VersionOrRequirement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            VersionOrRequirement::Version(version) => version.fmt(f),
+            VersionOrRequirement::Requirement(version_req) => version_req.fmt(f),
+        }
+    }
+}

crates/compiler/src/revive_resolc.rs

@@ -2,6 +2,7 @@
 //! compiling contracts to PolkaVM (PVM) bytecode.
 
 use std::{
+    os::unix::process::CommandExt,
     path::PathBuf,
     process::{Command, Stdio},
 };
@@ -92,11 +93,14 @@ impl SolidityCompiler for Resolc {
         };
 
         let mut command = AsyncCommand::new(&self.resolc_path);
+        unsafe {
             command
                 .stdin(Stdio::piped())
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped())
-            .arg("--standard-json");
+                .arg("--standard-json")
+                .pre_exec(|| Ok(()))
+        };
 
         if let Some(ref base_path) = base_path {
             command.arg("--base-path").arg(base_path);
@@ -215,12 +219,15 @@ impl SolidityCompiler for Resolc {
         // Logic for parsing the resolc version from the following string:
         // Solidity frontend for the revive compiler version 0.3.0+commit.b238913.llvm-18.1.8
 
-        let output = Command::new(self.resolc_path.as_path())
+        let output = unsafe {
+            Command::new(self.resolc_path.as_path())
                 .arg("--version")
                 .stdout(Stdio::piped())
+                .pre_exec(|| Ok(()))
                 .spawn()?
                 .wait_with_output()?
-            .stdout;
+                .stdout
+        };
         let output = String::from_utf8_lossy(&output);
         let version_string = output
             .split("version ")

crates/compiler/src/solc.rs

@@ -2,6 +2,7 @@
 //! compiling contracts to EVM bytecode.
 
 use std::{
+    os::unix::process::CommandExt,
     path::PathBuf,
     process::{Command, Stdio},
 };
@@ -31,7 +32,7 @@ pub struct Solc {
 impl SolidityCompiler for Solc {
     type Options = ();
 
-    #[tracing::instrument(level = "debug", ret)]
+    #[tracing::instrument(level = "info", ret)]
     async fn build(
         &self,
         CompilerInput {
@@ -102,11 +103,14 @@ impl SolidityCompiler for Solc {
         };
 
         let mut command = AsyncCommand::new(&self.solc_path);
+        unsafe {
             command
                 .stdin(Stdio::piped())
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped())
-            .arg("--standard-json");
+                .arg("--standard-json")
+                .pre_exec(|| Ok(()))
+        };
 
         if let Some(ref base_path) = base_path {
             command.arg("--base-path").arg(base_path);
@@ -120,12 +124,20 @@ impl SolidityCompiler for Solc {
                     .join(","),
             );
         }
-        let mut child = command.spawn()?;
+        let mut child = command
+            .spawn()
+            .inspect_err(|err| tracing::error!(%err, "Failed to spawn the solc command"))?;
 
         let stdin = child.stdin.as_mut().expect("should be piped");
         let serialized_input = serde_json::to_vec(&input)?;
-        stdin.write_all(&serialized_input).await?;
+        stdin
-        let output = child.wait_with_output().await?;
+            .write_all(&serialized_input)
+            .await
+            .inspect_err(|err| tracing::error!(%err, "Failed to write standard JSON to stdin"))?;
+        let output = child
+            .wait_with_output()
+            .await
+            .inspect_err(|err| tracing::error!(%err, "Failed to get the output of solc"))?;
 
         if !output.status.success() {
             let json_in = serde_json::to_string_pretty(&input)?;
@@ -162,9 +174,12 @@ impl SolidityCompiler for Solc {
 
         let mut compiler_output = CompilerOutput::default();
         for (contract_path, contracts) in parsed.contracts {
-            let map = compiler_output
+            let map =
+                compiler_output
                     .contracts
-                .entry(contract_path.canonicalize()?)
+                    .entry(contract_path.canonicalize().inspect_err(
+                        |err| tracing::error!(%err, "Canonicalization of path failed"),
+                    )?)
                     .or_default();
             for (contract_name, contract_info) in contracts.into_iter() {
                 let source_code = contract_info
@@ -205,10 +220,13 @@ impl SolidityCompiler for Solc {
         // Version: 0.8.30+commit.73712a01.Darwin.appleclang
         // ```
 
-        let child = Command::new(self.solc_path.as_path())
+        let child = unsafe {
+            Command::new(self.solc_path.as_path())
                 .arg("--version")
                 .stdout(Stdio::piped())
-            .spawn()?;
+                .pre_exec(|| Ok(()))
+                .spawn()?
+        };
         let output = child.wait_with_output()?;
         let output = String::from_utf8_lossy(&output.stdout);
         let version_line = output

crates/core/src/main.rs

@@ -19,7 +19,7 @@ use revive_dt_node_interaction::EthereumNode;
 use semver::Version;
 use temp_dir::TempDir;
 use tokio::sync::{Mutex, RwLock, mpsc};
-use tracing::{Instrument, Level};
+use tracing::{Instrument, Level, instrument};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
 use revive_dt_compiler::SolidityCompiler;
@@ -34,7 +34,7 @@ use revive_dt_format::{
     corpus::Corpus,
     input::{Input, Step},
     metadata::{ContractInstance, ContractPathAndIdent, Metadata, MetadataFile},
-    mode::SolcMode,
+    mode::{Mode, SolcMode},
 };
 use revive_dt_node::pool::NodePool;
 use revive_dt_report::reporter::{Report, Span};
@@ -172,8 +172,7 @@ where
                     .iter()
                     .enumerate()
                     .flat_map(move |(case_idx, case)| {
-                        metadata
+                        SolcMode::ALL
-                            .solc_modes()
                             .into_iter()
                             .map(move |solc_mode| (path, metadata, case_idx, case, solc_mode))
                     })
@@ -226,6 +225,27 @@ where
             }
             None => true,
         })
+        .flat_map(|(path, metadata, case_idx, case, solc_mode)| {
+            if let Some(ref case_modes) = case.modes {
+                case_modes
+                    .iter()
+                    .filter_map(Mode::as_solc_mode)
+                    .filter(|case_mode| case_mode.matches(&solc_mode))
+                    .map(|case_mode| (path, metadata, case_idx, case, case_mode.clone()))
+                    .collect::<Vec<_>>()
+                    .into_iter()
+            } else if let Some(ref metadata_modes) = metadata.modes {
+                metadata_modes
+                    .iter()
+                    .filter_map(Mode::as_solc_mode)
+                    .filter(|metadata_mode| metadata_mode.matches(&solc_mode))
+                    .map(|metadata_mode| (path, metadata, case_idx, case, metadata_mode.clone()))
+                    .collect::<Vec<_>>()
+                    .into_iter()
+            } else {
+                vec![(path, metadata, case_idx, case, solc_mode)].into_iter()
+            }
+        })
         .map(|(metadata_file_path, metadata, case_idx, case, solc_mode)| {
             Test {
                 metadata: metadata.clone(),
@@ -278,7 +298,7 @@ where
                     "Running driver",
                     metadata_file_path = %test.path.display(),
                     case_idx = ?test.case_idx,
-                    solc_mode = ?test.mode,
+                    solc_mode = %test.mode,
                 );
 
                 let result = handle_case_driver::<L, F>(
@@ -309,7 +329,7 @@ async fn start_reporter_task(mut report_rx: mpsc::UnboundedReceiver<(Test, CaseR
 
     const GREEN: &str = "\x1B[32m";
     const RED: &str = "\x1B[31m";
-    const COLOUR_RESET: &str = "\x1B[0m";
+    const COLOR_RESET: &str = "\x1B[0m";
     const BOLD: &str = "\x1B[1m";
     const BOLD_RESET: &str = "\x1B[22m";
 
@@ -328,13 +348,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:{COLOR_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:{COLOR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
                 );
                 failures.push((test, err));
             }
@@ -357,14 +377,14 @@ 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:{COLOR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode}) ----\n\n{err}\n"
             );
         }
     }
 
     // Summary at the end.
     eprintln!(
-        "{} cases: {GREEN}{number_of_successes}{COLOUR_RESET} cases succeeded, {RED}{number_of_failures}{COLOUR_RESET} cases failed in {} seconds",
+        "{} cases: {GREEN}{number_of_successes}{COLOR_RESET} cases succeeded, {RED}{number_of_failures}{COLOR_RESET} cases failed in {} seconds",
         number_of_successes + number_of_failures,
         elapsed.as_secs()
     );
@@ -674,6 +694,16 @@ async fn get_or_build_contracts<P: Platform>(
     Ok(compiled_contracts.clone())
 }
 
+#[instrument(
+    level = "info",
+    skip_all,
+    fields(
+        metadata_file_path = %metadata_file_path.display(),
+        mode = %mode,
+        deployed_libraries = deployed_libraries.len(),
+    ),
+    err
+)]
 async fn compile_contracts<P: Platform>(
     metadata: &Metadata,
     metadata_file_path: &Path,
@@ -684,18 +714,25 @@ async fn compile_contracts<P: Platform>(
     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()?;
+    let compiler_version = P::Compiler::new(compiler_path.clone())
+        .version()
+        .inspect_err(|err| tracing::error!(%err, "Failed to get compiler version"))?;
 
     tracing::info!(
         %compiler_version,
         metadata_file_path = %metadata_file_path.display(),
-        mode = ?mode,
+        mode = %mode,
         "Compiling contracts"
     );
 
     let compiler = Compiler::<P::Compiler>::new()
-        .with_allow_path(metadata.directory()?)
+        .with_allow_path(
-        .with_optimization(mode.solc_optimize());
+            metadata
+                .directory()
+                .inspect_err(|err| tracing::error!(%err, "Failed to get the metadata directory"))?,
+        )
+        .with_optimization(mode.optimize)
+        .with_via_ir(mode.via_ir);
     let mut compiler = metadata
         .files_to_compile()?
         .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
@@ -712,7 +749,10 @@ async fn compile_contracts<P: Platform>(
         // 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()?)
+        compiler =
+            FilesWithExtensionIterator::new(metadata.directory().inspect_err(
+                |err| tracing::error!(%err, "Failed to get the metadata directory"),
+            )?)
             .with_allowed_extension("sol")
             .with_use_cached_fs(true)
             .fold(compiler, |compiler, path| {
@@ -720,7 +760,17 @@ async fn compile_contracts<P: Platform>(
             });
     }
 
-    let compiler_output = compiler.try_build(compiler_path).await?;
+    let compiler_output = compiler
+        .try_build(compiler_path)
+        .await
+        .inspect_err(|err| tracing::error!(%err, "Contract compilation failed"))?;
+
+    tracing::info!(
+        %compiler_version,
+        metadata_file_path = %metadata_file_path.display(),
+        mode = %mode,
+        "Compiled contracts"
+    );
 
     Ok((compiler_version, compiler_output))
 }

crates/format/src/case.rs

@@ -1,9 +1,12 @@
+use std::collections::HashSet;
+
 use serde::{Deserialize, Serialize};
 
 use revive_dt_common::macros::define_wrapper_type;
 
 use crate::{
     input::{Expected, Step},
+    metadata::{deserialize_compilation_modes, serialize_compilation_modes},
     mode::Mode,
 };
 
@@ -15,8 +18,13 @@ pub struct Case {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(
-    pub modes: Option<Vec<Mode>>,
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "deserialize_compilation_modes",
+        serialize_with = "serialize_compilation_modes"
+    )]
+    pub modes: Option<HashSet<Mode>>,
 
     #[serde(rename = "inputs")]
     pub steps: Vec<Step>,
@@ -32,7 +40,6 @@ pub struct Case {
 }
 
 impl Case {
-    #[allow(irrefutable_let_patterns)]
     pub fn steps_iterator(&self) -> impl Iterator<Item = Step> {
         let steps_len = self.steps.len();
         self.steps

crates/format/src/metadata.rs

@@ -1,6 +1,6 @@
 use std::{
     cmp::Ordering,
-    collections::BTreeMap,
+    collections::{BTreeMap, HashSet},
     fmt::Display,
     fs::File,
     ops::Deref,
@@ -8,7 +8,7 @@ use std::{
     str::FromStr,
 };
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use revive_common::EVMVersion;
 use revive_dt_common::{
@@ -67,8 +67,13 @@ pub struct Metadata {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(
-    pub modes: Option<Vec<Mode>>,
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "deserialize_compilation_modes",
+        serialize_with = "serialize_compilation_modes"
+    )]
+    pub modes: Option<HashSet<Mode>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub file_path: Option<PathBuf>,
@@ -90,7 +95,7 @@ impl Metadata {
     pub fn solc_modes(&self) -> Vec<SolcMode> {
         self.modes
             .to_owned()
-            .unwrap_or_else(|| vec![Mode::Solidity(Default::default())])
+            .unwrap_or_else(|| SolcMode::ALL.map(Mode::Solidity).iter().cloned().collect())
             .iter()
             .filter_map(|mode| match mode {
                 Mode::Solidity(solc_mode) => Some(solc_mode),
@@ -269,6 +274,37 @@ impl Metadata {
     }
 }
 
+pub fn deserialize_compilation_modes<'de, D>(
+    deserializer: D,
+) -> Result<Option<HashSet<Mode>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let maybe_strings = Option::<Vec<String>>::deserialize(deserializer)?;
+    Ok(maybe_strings.map(|strings| {
+        strings
+            .into_iter()
+            .flat_map(Mode::parse_from_string)
+            .collect()
+    }))
+}
+
+pub fn serialize_compilation_modes<S>(
+    value: &Option<HashSet<Mode>>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match value {
+        None => serializer.serialize_none(),
+        Some(modes) => {
+            let strings: Vec<String> = modes.iter().cloned().map(Into::<String>::into).collect();
+            serializer.serialize_some(&strings)
+        }
+    }
+}
+
 define_wrapper_type!(
     /// Represents a contract instance found a metadata file.
     ///

crates/format/src/mode.rs

@@ -1,123 +1,393 @@
+use std::{fmt::Display, str::FromStr};
+
 use revive_dt_common::types::VersionOrRequirement;
 use semver::Version;
-use serde::de::Deserializer;
+use serde::Serialize;
-use serde::{Deserialize, Serialize};
 
-/// Specifies the compilation mode of the test artifact.
+/// Specifies a compilation mode for the test artifact that it requires. This is used as a filter
-#[derive(Hash, Debug, Clone, Eq, PartialEq)]
+/// when used in the [`Metadata`] and is used as a directive when used in the core crate.
+///
+/// [`Metadata`]: crate::metadata::Metadata
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Mode {
+    /// A compilation mode that's been parsed from a String and into its contents.
     Solidity(SolcMode),
+    /// An unknown compilation mode.
     Unknown(String),
 }
 
-/// Specify Solidity specific compiler options.
+impl From<Mode> for String {
-#[derive(Hash, Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
+    fn from(value: Mode) -> Self {
+        value.to_string()
+    }
+}
+
+impl Display for Mode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Mode::Solidity(mode) => mode.fmt(f),
+            Mode::Unknown(string) => string.fmt(f),
+        }
+    }
+}
+
+impl Mode {
+    pub fn parse_from_string(str: impl AsRef<str>) -> Vec<Self> {
+        let mut chars = str.as_ref().chars().peekable();
+
+        let compile_via_ir = match chars.next() {
+            Some('Y') => true,
+            Some('E') => false,
+            _ => {
+                tracing::warn!("Encountered an unknown mode {}", str.as_ref());
+                return vec![Self::Unknown(str.as_ref().to_string())];
+            }
+        };
+
+        let optimize_flag = match chars.peek() {
+            Some('+') => {
+                let _ = chars.next();
+                Some(true)
+            }
+            Some('-') => {
+                let _ = chars.next();
+                Some(false)
+            }
+            _ => None,
+        };
+
+        let mut chars = chars.skip_while(|char| *char == ' ').peekable();
+
+        let version_requirement = match chars.peek() {
+            Some('=' | '>' | '<' | '~' | '^' | '*' | '0'..='9') => {
+                let version_requirement = chars.take_while(|char| *char != ' ').collect::<String>();
+                let Ok(version_requirement) = VersionOrRequirement::from_str(&version_requirement)
+                else {
+                    return vec![Self::Unknown(str.as_ref().to_string())];
+                };
+                Some(version_requirement)
+            }
+            _ => None,
+        };
+
+        match optimize_flag {
+            Some(flag) => {
+                vec![Self::Solidity(SolcMode {
+                    via_ir: compile_via_ir,
+                    optimize: flag,
+                    compiler_version_requirement: version_requirement,
+                })]
+            }
+            None => {
+                vec![
+                    Self::Solidity(SolcMode {
+                        via_ir: compile_via_ir,
+                        optimize: true,
+                        compiler_version_requirement: version_requirement.clone(),
+                    }),
+                    Self::Solidity(SolcMode {
+                        via_ir: compile_via_ir,
+                        optimize: false,
+                        compiler_version_requirement: version_requirement,
+                    }),
+                ]
+            }
+        }
+    }
+
+    pub fn matches(&self, other: &Self) -> bool {
+        match (self, other) {
+            (
+                Mode::Solidity(SolcMode {
+                    via_ir: self_via_ir,
+                    optimize: self_optimize,
+                    compiler_version_requirement: self_compiler_version_requirement,
+                }),
+                Mode::Solidity(SolcMode {
+                    via_ir: other_via_ir,
+                    optimize: other_optimize,
+                    compiler_version_requirement: other_compiler_version_requirement,
+                }),
+            ) => {
+                let mut matches = true;
+                matches &= self_via_ir == other_via_ir;
+                matches &= self_optimize == other_optimize;
+                match (
+                    self_compiler_version_requirement,
+                    other_compiler_version_requirement,
+                ) {
+                    (
+                        Some(VersionOrRequirement::Version(self_version)),
+                        Some(VersionOrRequirement::Version(other_version)),
+                    ) => {
+                        matches &= self_version == other_version;
+                    }
+                    (
+                        Some(VersionOrRequirement::Version(version)),
+                        Some(VersionOrRequirement::Requirement(requirement)),
+                    )
+                    | (
+                        Some(VersionOrRequirement::Requirement(requirement)),
+                        Some(VersionOrRequirement::Version(version)),
+                    ) => matches &= requirement.matches(version),
+                    (
+                        Some(VersionOrRequirement::Requirement(..)),
+                        Some(VersionOrRequirement::Requirement(..)),
+                    ) => matches = false,
+                    (Some(_), None) | (None, Some(_)) | (None, None) => {}
+                }
+                matches
+            }
+            (Mode::Solidity { .. }, Mode::Unknown(_))
+            | (Mode::Unknown(_), Mode::Solidity { .. })
+            | (Mode::Unknown(_), Mode::Unknown(_)) => false,
+        }
+    }
+
+    pub fn as_solc_mode(&self) -> Option<&SolcMode> {
+        if let Self::Solidity(mode) = self {
+            Some(mode)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+#[serde(into = "String")]
 pub struct SolcMode {
-    pub solc_version: Option<semver::VersionReq>,
+    pub via_ir: bool,
-    solc_optimize: Option<bool>,
+    pub optimize: bool,
-    pub llvm_optimizer_settings: Vec<String>,
+    pub compiler_version_requirement: Option<VersionOrRequirement>,
-    mode_string: String,
 }
 
 impl SolcMode {
-    /// Try to parse a mode string into a solc mode.
+    pub const ALL: [Self; 4] = [
-    /// Returns `None` if the string wasn't a solc YUL mode string.
+        SolcMode {
-    ///
+            via_ir: false,
-    /// The mode string is expected to start with the `Y` ID (YUL ID),
+            optimize: false,
-    /// optionally followed by `+` or `-` for the solc optimizer settings.
+            compiler_version_requirement: None,
-    ///
+        },
-    /// Options can be separated by a whitespace contain the following
+        SolcMode {
-    /// - A solc `SemVer version requirement` string
+            via_ir: false,
-    /// - One or more `-OX` where X is a supposed to be an LLVM opt mode
+            optimize: true,
-    pub fn parse_from_mode_string(mode_string: &str) -> Option<Self> {
+            compiler_version_requirement: None,
-        let mut result = Self {
+        },
-            mode_string: mode_string.to_string(),
+        SolcMode {
-            ..Default::default()
+            via_ir: true,
-        };
+            optimize: false,
+            compiler_version_requirement: None,
+        },
+        SolcMode {
+            via_ir: true,
+            optimize: true,
+            compiler_version_requirement: None,
+        },
+    ];
 
-        let mut parts = mode_string.trim().split(" ");
+    pub fn matches(&self, other: &Self) -> bool {
-
+        Mode::Solidity(self.clone()).matches(&Mode::Solidity(other.clone()))
-        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());
-        };
-
-        // 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);
-            }
-        }
-
-        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 {
+        match self.compiler_version_requirement {
-            Some(ref requirement) => requirement.clone().into(),
+            Some(ref requirement) => requirement.clone(),
             None => default.into(),
         }
     }
 }
 
-impl<'de> Deserialize<'de> for Mode {
+impl Display for SolcMode {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    where
+        let Self {
-        D: Deserializer<'de>,
+            via_ir,
-    {
+            optimize,
-        let mode_string = String::deserialize(deserializer)?;
+            compiler_version_requirement,
+        } = self;
 
-        if let Some(solc_mode) = SolcMode::parse_from_mode_string(&mode_string) {
+        if *via_ir {
-            return Ok(Self::Solidity(solc_mode));
+            write!(f, "Y")?;
+        } else {
+            write!(f, "E")?;
         }
 
-        Ok(Self::Unknown(mode_string))
+        if *optimize {
+            write!(f, "+")?;
+        } else {
+            write!(f, "-")?;
+        }
+
+        if let Some(req) = compiler_version_requirement {
+            write!(f, " {req}")?;
+        }
+
+        Ok(())
     }
 }
 
-impl Serialize for Mode {
+impl From<SolcMode> for String {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    fn from(value: SolcMode) -> Self {
-    where
+        value.to_string()
-        S: serde::Serializer,
+    }
-    {
+}
-        let string = match self {
+
-            Mode::Solidity(solc_mode) => &solc_mode.mode_string,
+#[cfg(test)]
-            Mode::Unknown(string) => string,
+mod test {
-        };
+    use semver::Version;
-        string.serialize(serializer)
+
+    use super::*;
+
+    #[test]
+    fn mode_can_be_parsed_as_expected() {
+        // Arrange
+        let fixtures = [
+            (
+                "Y",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: true,
+                        compiler_version_requirement: None,
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: false,
+                        compiler_version_requirement: None,
+                    }),
+                ],
+            ),
+            (
+                "Y+",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: true,
+                    optimize: true,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "Y-",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: true,
+                    optimize: false,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "E",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: false,
+                        optimize: true,
+                        compiler_version_requirement: None,
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: false,
+                        optimize: false,
+                        compiler_version_requirement: None,
+                    }),
+                ],
+            ),
+            (
+                "E+",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: false,
+                    optimize: true,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "E-",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: false,
+                    optimize: false,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "Y >=0.8.3",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: true,
+                        compiler_version_requirement: Some(VersionOrRequirement::Requirement(
+                            ">=0.8.3".parse().unwrap(),
+                        )),
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: false,
+                        compiler_version_requirement: Some(VersionOrRequirement::Requirement(
+                            ">=0.8.3".parse().unwrap(),
+                        )),
+                    }),
+                ],
+            ),
+            (
+                "Y 0.8.3",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: true,
+                        compiler_version_requirement: Some(VersionOrRequirement::Version(
+                            Version {
+                                major: 0,
+                                minor: 8,
+                                patch: 3,
+                                pre: Default::default(),
+                                build: Default::default(),
+                            },
+                        )),
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: false,
+                        compiler_version_requirement: Some(VersionOrRequirement::Version(
+                            Version {
+                                major: 0,
+                                minor: 8,
+                                patch: 3,
+                                pre: Default::default(),
+                                build: Default::default(),
+                            },
+                        )),
+                    }),
+                ],
+            ),
+        ];
+
+        for (string, expectation) in fixtures {
+            // Act
+            let actual = Mode::parse_from_string(string);
+
+            // Assert
+            assert_eq!(
+                actual, expectation,
+                "Parsed {string} into {actual:?} but expected {expectation:?}"
+            )
+        }
+    }
+
+    #[test]
+    #[allow(clippy::uninlined_format_args)]
+    fn mode_matches_as_expected() {
+        // Arrange
+        let fixtures = [("Y+", "Y+", true), ("Y+ >=0.8.3", "Y+", true)];
+
+        for (self_mode, other_mode, expected_result) in fixtures {
+            let self_mode = Mode::parse_from_string(self_mode).pop().unwrap();
+            let other_mode = Mode::parse_from_string(other_mode).pop().unwrap();
+
+            // Act
+            let actual = self_mode.matches(&other_mode);
+
+            // Assert
+            assert_eq!(
+                actual, expected_result,
+                "Match of {} and {} failed. Expected {} but got {}",
+                self_mode, other_mode, expected_result, actual
+            );
+        }
     }
 }

crates/node/src/geth.rs

@@ -33,7 +33,7 @@ use alloy::{
 };
 use anyhow::Context;
 use revive_common::EVMVersion;
-use tracing::{Instrument, Level};
+use tracing::Instrument;
 
 use revive_dt_common::{fs::clear_directory, futures::poll};
 use revive_dt_config::Arguments;
@@ -48,7 +48,7 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Implements helpers to initialize, spawn and wait the node.
 ///
-/// Assumes dev mode and IPC only (`P2P`, `http`` etc. are kept disabled).
+/// Assumes dev mode and IPC only (`P2P`, `http` etc. are kept disabled).
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
@@ -228,12 +228,12 @@ impl GethNode {
         }
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = "trace")]
     fn geth_stdout_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::GETH_STDOUT_LOG_FILE_NAME)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = "trace")]
     fn geth_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
     }
@@ -257,13 +257,18 @@ 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,
+                    100_000_000_000,
+                    1_000_000_000,
+                ))
                 .filler(ChainIdFiller::default())
                 .filler(NonceFiller::new(nonce_manager))
                 .wallet(wallet)
                 .connect(&connection_string)
                 .await
                 .map_err(Into::into)
+                .inspect_err(|err| tracing::error!(%err, "Failed to create the alloy provider"))
         })
     }
 }
@@ -277,27 +282,26 @@ impl EthereumNode for GethNode {
         let span = tracing::debug_span!("Submitting transaction", ?transaction);
         let _guard = span.enter();
 
-        let provider = Arc::new(self.provider().await?);
+        let provider = self.provider().await.map(Arc::new)?;
         let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();
 
-        // The following is a fix for the "transaction indexing is in progress" error that we
+        // The following is a fix for the "transaction indexing is in progress" error that we used
-        // used to get. You can find more information on this in the following GH issue in geth
+        // to get. You can find more information on this in the following GH issue in geth
         // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
         // before we can get the receipt of the transaction it needs to have been indexed by the
-        // node's indexer. Just because the transaction has been confirmed it doesn't mean that
+        // node's indexer. Just because the transaction has been confirmed it doesn't mean that it
-        // it has been indexed. When we call alloy's `get_receipt` it checks if the transaction
+        // has been indexed. When we call alloy's `get_receipt` it checks if the transaction was
-        // was confirmed. If it has been, then it will call `eth_getTransactionReceipt` method
+        // confirmed. If it has been, then it will call `eth_getTransactionReceipt` method which
-        // which _might_ return the above error if the tx has not yet been indexed yet. So, we
+        // _might_ return the above error if the tx has not yet been indexed yet. So, we need to
-        // need to implement a retry mechanism for the receipt to keep retrying to get it until
+        // implement a retry mechanism for the receipt to keep retrying to get it until it
-        // it eventually works, but we only do that if the error we get back is the "transaction
+        // eventually works, but we only do that if the error we get back is the "transaction
         // indexing is in progress" error or if the receipt is None.
         //
         // Getting the transaction indexed and taking a receipt can take a long time especially
-        // when a lot of transactions are being submitted to the node. Thus, while initially we
+        // when a lot of transactions are being submitted to the node. Thus, while initially we only
-        // only allowed for 60 seconds of waiting with a 1 second delay in polling, we need to
+        // allowed for 60 seconds of waiting with a 1 second delay in polling, we need to allow for
-        // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
+        // a larger wait time. Therefore, in here we allow for 5 minutes of waiting with exponential
-        // with exponential backoff each time we attempt to get the receipt and find that it's
+        // backoff each time we attempt to get the receipt and find that it's not available.
-        // not available.
         poll(
             Self::RECEIPT_POLLING_DURATION,
             Default::default(),
@@ -323,6 +327,7 @@ impl EthereumNode for GethNode {
             ?transaction_hash
         ))
         .await
+        .inspect(|receipt| tracing::info!(gas_used = receipt.gas_used, "Gas used on transaction"))
     }
 
     #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]

crates/report/src/reporter.rs

@@ -13,7 +13,7 @@ use std::{
 
 use anyhow::Context;
 use revive_dt_compiler::{CompilerInput, CompilerOutput};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 
 use revive_dt_config::{Arguments, TestingPlatform};
 use revive_dt_format::{corpus::Corpus, mode::SolcMode};
@@ -23,7 +23,7 @@ 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,7 +41,7 @@ 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,
@@ -56,7 +56,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 +65,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,