Lower gas limit for failed estimates

Cargo.lock

@@ -1644,6 +1644,15 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
 
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -2399,6 +2408,20 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9"
 
+[[package]]
+name = "generator"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d18470a76cb7f8ff746cf1f7470914f900252ec36bbc40b569d74b1258446827"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "log",
+ "rustversion",
+ "windows",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -3165,6 +3188,19 @@ version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
+[[package]]
+name = "loom"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
+dependencies = [
+ "cfg-if",
+ "generator",
+ "scoped-tls",
+ "tracing",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "lru"
 version = "0.13.0"
@@ -3247,6 +3283,25 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "moka"
+version = "0.12.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9321642ca94a4282428e6ea4af8cc2ca4eac48ac7a6a4ea8f33f76d0ce70926"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "loom",
+ "parking_lot",
+ "portable-atomic",
+ "rustc_version 0.4.1",
+ "smallvec",
+ "tagptr",
+ "thiserror 1.0.69",
+ "uuid",
+]
+
 [[package]]
 name = "native-tls"
 version = "0.2.14"
@@ -3646,6 +3701,12 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
 [[package]]
 name = "potential_utf"
 version = "0.1.2"
@@ -4029,6 +4090,8 @@ name = "revive-dt-common"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "moka",
+ "once_cell",
  "semver 1.0.26",
  "tokio",
 ]
@@ -4424,6 +4487,12 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -5276,6 +5345,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -5808,6 +5883,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
+[[package]]
+name = "uuid"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
+dependencies = [
+ "getrandom 0.3.3",
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.1"
@@ -6069,6 +6155,28 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core",
+ "windows-future",
+ "windows-link",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.61.2"
@@ -6082,6 +6190,17 @@ dependencies = [
  "windows-strings 0.4.2",
 ]
 
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core",
+ "windows-link",
+ "windows-threading",
+]
+
 [[package]]
 name = "windows-implement"
 version = "0.60.0"
@@ -6106,9 +6225,19 @@ dependencies = [
 
 [[package]]
 name = "windows-link"
-version = "0.1.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core",
+ "windows-link",
+]
 
 [[package]]
 name = "windows-registry"
@@ -6198,6 +6327,15 @@ dependencies = [
  "windows_x86_64_msvc 0.53.0",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"

Cargo.toml

@@ -29,6 +29,7 @@ clap = { version = "4", features = ["derive"] }
 foundry-compilers-artifacts = { version = "0.18.0" }
 futures = { version = "0.3.31" }
 hex = "0.4.3"
+moka = "0.12.10"
 reqwest = { version = "0.12.15", features = ["json"] }
 once_cell = "1.21"
 semver = { version = "1.0", features = ["serde"] }

crates/common/Cargo.toml

@@ -10,5 +10,7 @@ rust-version.workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
+moka = { workspace = true, features = ["sync"] }
+once_cell = { workspace = true }
 semver = { workspace = true }
 tokio = { workspace = true, default-features = false, features = ["time"] }

crates/common/src/cached_fs/mod.rs

@@ -0,0 +1,73 @@
+//! This module implements a cached file system allowing for results to be stored in-memory rather
+//! rather being queried from the file system again.
+
+use std::fs;
+use std::io::{Error, Result};
+use std::path::{Path, PathBuf};
+
+use moka::sync::Cache;
+use once_cell::sync::Lazy;
+
+pub fn read(path: impl AsRef<Path>) -> Result<Vec<u8>> {
+    static READ_CACHE: Lazy<Cache<PathBuf, Vec<u8>>> = Lazy::new(|| Cache::new(10_000));
+
+    let path = path.as_ref().canonicalize()?;
+    match READ_CACHE.get(path.as_path()) {
+        Some(content) => Ok(content),
+        None => {
+            let content = fs::read(path.as_path())?;
+            READ_CACHE.insert(path, content.clone());
+            Ok(content)
+        }
+    }
+}
+
+pub fn read_to_string(path: impl AsRef<Path>) -> Result<String> {
+    let content = read(path)?;
+    String::from_utf8(content).map_err(|_| {
+        Error::new(
+            std::io::ErrorKind::InvalidData,
+            "The contents of the file are not valid UTF8",
+        )
+    })
+}
+
+pub fn read_dir(path: impl AsRef<Path>) -> Result<Box<dyn Iterator<Item = Result<PathBuf>>>> {
+    static READ_DIR_CACHE: Lazy<Cache<PathBuf, Vec<PathBuf>>> = Lazy::new(|| Cache::new(10_000));
+
+    let path = path.as_ref().canonicalize()?;
+    match READ_DIR_CACHE.get(path.as_path()) {
+        Some(entries) => Ok(Box::new(entries.into_iter().map(Ok)) as Box<_>),
+        None => {
+            let entries = fs::read_dir(path.as_path())?
+                .flat_map(|maybe_entry| maybe_entry.map(|entry| entry.path()))
+                .collect();
+            READ_DIR_CACHE.insert(path.clone(), entries);
+            Ok(read_dir(path).unwrap())
+        }
+    }
+}
+
+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/iterators/files_with_extension_iterator.rs

@@ -19,6 +19,11 @@ pub struct FilesWithExtensionIterator {
     /// this vector then they will be returned when the [`Iterator::next`] method is called. If not
     /// then we visit one of the next directories to visit.
     files_matching_allowed_extensions: Vec<PathBuf>,
+
+    /// This option controls if the the cached file system should be used or not. This could be
+    /// better for certain cases where the entries in the directories do not change and therefore
+    /// caching can be used.
+    use_cached_fs: bool,
 }
 
 impl FilesWithExtensionIterator {
@@ -27,6 +32,7 @@ impl FilesWithExtensionIterator {
             allowed_extensions: Default::default(),
             directories_to_search: vec![root_directory.as_ref().to_path_buf()],
             files_matching_allowed_extensions: Default::default(),
+            use_cached_fs: Default::default(),
         }
     }
 
@@ -37,6 +43,11 @@ impl FilesWithExtensionIterator {
         self.allowed_extensions.insert(allowed_extension.into());
         self
     }
+
+    pub fn with_use_cached_fs(mut self, use_cached_fs: bool) -> Self {
+        self.use_cached_fs = use_cached_fs;
+        self
+    }
 }
 
 impl Iterator for FilesWithExtensionIterator {
@@ -49,16 +60,19 @@ impl Iterator for FilesWithExtensionIterator {
 
         let directory_to_search = self.directories_to_search.pop()?;
 
-        // Read all of the entries in the directory. If we failed to read this dir's entires then we
+        let iterator = if self.use_cached_fs {
-        // elect to just ignore it and look in the next directory, we do that by calling the next
+            let Ok(dir_entries) = crate::cached_fs::read_dir(directory_to_search.as_path()) else {
-        // method again on the iterator, which is an intentional decision that we made here instead
+                return self.next();
-        // of panicking.
+            };
+            Box::new(dir_entries) as Box<dyn Iterator<Item = std::io::Result<PathBuf>>>
+        } else {
             let Ok(dir_entries) = std::fs::read_dir(directory_to_search) else {
                 return self.next();
             };
+            Box::new(dir_entries.map(|maybe_entry| maybe_entry.map(|entry| entry.path()))) as Box<_>
+        };
 
-        for entry in dir_entries.flatten() {
+        for entry_path in iterator.flatten() {
-            let entry_path = entry.path();
             if entry_path.is_dir() {
                 self.directories_to_search.push(entry_path)
             } else if entry_path.is_file()

crates/common/src/lib.rs

@@ -1,6 +1,7 @@
 //! This crate provides common concepts, functionality, types, macros, and more that other crates in
 //! the workspace can benefit from.
 
+pub mod cached_fs;
 pub mod fs;
 pub mod futures;
 pub mod iterators;

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/lib.rs

@@ -5,7 +5,6 @@
 
 use std::{
     collections::HashMap,
-    fs::read_to_string,
     hash::Hash,
     path::{Path, PathBuf},
 };
@@ -16,6 +15,7 @@ use semver::Version;
 use serde::{Deserialize, Serialize};
 
 use revive_common::EVMVersion;
+use revive_dt_common::cached_fs::read_to_string;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 

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,14 +749,28 @@ 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| {
                 compiler.with_library(&path, library_ident.as_str(), *library_address)
             });
     }
 
-    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/corpus.rs

@@ -3,6 +3,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use revive_dt_common::cached_fs::read_dir;
 use serde::{Deserialize, Serialize};
 
 use crate::metadata::MetadataFile;
@@ -54,7 +55,7 @@ impl Corpus {
 /// `path` is expected to be a directory.
 pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
     if path.is_dir() {
-        let dir_entry = match std::fs::read_dir(path) {
+        let dir_entry = match read_dir(path) {
             Ok(dir_entry) => dir_entry,
             Err(error) => {
                 tracing::error!("failed to read dir '{}': {error}", path.display());
@@ -62,8 +63,8 @@ pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
             }
         };
 
-        for entry in dir_entry {
+        for path in dir_entry {
-            let entry = match entry {
+            let path = match path {
                 Ok(entry) => entry,
                 Err(error) => {
                     tracing::error!("error reading dir entry: {error}");
@@ -71,7 +72,6 @@ pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
                 }
             };
 
-            let path = entry.path();
             if path.is_dir() {
                 collect_metadata(&path, tests);
                 continue;

crates/format/src/metadata.rs

@@ -1,17 +1,19 @@
 use std::{
     cmp::Ordering,
-    collections::BTreeMap,
+    collections::{BTreeMap, HashSet},
     fmt::Display,
-    fs::{File, read_to_string},
+    fs::File,
     ops::Deref,
     path::{Path, PathBuf},
     str::FromStr,
 };
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use revive_common::EVMVersion;
-use revive_dt_common::{iterators::FilesWithExtensionIterator, macros::define_wrapper_type};
+use revive_dt_common::{
+    cached_fs::read_to_string, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
+};
 
 use crate::{
     case::Case,
@@ -65,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>,
@@ -88,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),
@@ -259,12 +266,45 @@ impl Metadata {
             Ok(Box::new(std::iter::once(metadata_file_path.clone())))
         } else {
             Ok(Box::new(
-                FilesWithExtensionIterator::new(self.directory()?).with_allowed_extension("sol"),
+                FilesWithExtensionIterator::new(self.directory()?)
+                    .with_allowed_extension("sol")
+                    .with_use_cached_fs(true),
             ))
         }
     }
 }
 
+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/node/src/pool.rs

@@ -1,11 +1,12 @@
 //! This crate implements concurrent handling of testing node.
 
 use std::{
-    fs::read_to_string,
     sync::atomic::{AtomicUsize, Ordering},
     thread,
 };
 
+use revive_dt_common::cached_fs::read_to_string;
+
 use anyhow::Context;
 use revive_dt_config::Arguments;
 

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,