Correct the key and value encoding for the cache

Implement a persistent compilation cache
Merge branch 'main' into feature/cached-compiler-artifacts
2026-04-22 21:57:58 +00:00 · 2025-08-16 18:18:43 +03:00 · 2025-08-16 17:11:04 +03:00 · 2025-08-16 14:57:45 +03:00 · 2025-08-16 14:55:02 +03:00 · 2025-08-16 11:38:17 +00:00
63 changed files with 8266 additions and 1590 deletions
@@ -101,7 +101,33 @@ jobs:
        run: |
          sudo add-apt-repository -y ppa:ethereum/ethereum
          sudo apt-get update
-          sudo apt-get install -y ethereum protobuf-compiler
+          sudo apt-get install -y protobuf-compiler
          sudo apt-get install -y solc
          # We were facing some issues in CI with the 1.16.* versions of geth, and specifically on
          # Ubuntu. Eventually, we found out that the last version of geth that worked in our CI was
          # version 1.15.11. Thus, this is the version that we want to use in CI. The PPA sadly does
          # not have historic versions of Geth and therefore we need to resort to downloading pre
          # built binaries for Geth and the surrounding tools which is what the following parts of 
          # the script do.
          sudo apt-get install -y wget ca-certificates tar
          ARCH=$(uname -m)
          if [ "$ARCH" = "x86_64" ]; then
            URL="https://gethstore.blob.core.windows.net/builds/geth-alltools-linux-amd64-1.15.11-36b2371c.tar.gz"
          elif [ "$ARCH" = "aarch64" ]; then
            URL="https://gethstore.blob.core.windows.net/builds/geth-alltools-linux-arm64-1.15.11-36b2371c.tar.gz"
          else
            echo "Unsupported architecture: $ARCH"
            exit 1
          fi
          wget -qO- "$URL" | sudo tar xz -C /usr/local/bin --strip-components=1
          geth --version
          curl -sL https://github.com/paritytech/revive/releases/download/v0.3.0/resolc-x86_64-unknown-linux-musl -o resolc
          chmod +x resolc
          sudo mv resolc /usr/local/bin
      - name: Install Geth on macOS
        if: matrix.os == 'macos-14'
@@ -109,6 +135,12 @@ jobs:
          brew tap ethereum/ethereum
          brew install ethereum protobuf
          brew install solidity
          curl -sL https://github.com/paritytech/revive/releases/download/v0.3.0/resolc-universal-apple-darwin -o resolc
          chmod +x resolc
          sudo mv resolc /usr/local/bin
      - name: Machete
        uses: bnjbvr/cargo-machete@v0.7.1
@@ -124,5 +156,8 @@ jobs:
      - name: Check eth-rpc version
        run: eth-rpc --version
      - name: Check resolc version
        run: resolc --version
      - name: Test cargo workspace
        run: make test
@@ -3,3 +3,7 @@
 .DS_Store
 node_modules
 /*.json
 # We do not want to commit any log files that we produce from running the code locally so this is 
 # added to the .gitignore file.
 *.log
@@ -4,15 +4,14 @@ members = ["crates/*"]
 [workspace.package]
 version = "0.1.0"
-authors = [
+authors = ["Parity Technologies <admin@parity.io>"]
    "Parity Technologies <admin@parity.io>",
 ]
 license = "MIT/Apache-2.0"
 edition = "2024"
 repository = "https://github.com/paritytech/revive-differential-testing.git"
-rust-version = "1.85.0"
+rust-version = "1.87.0"
 [workspace.dependencies]
 revive-dt-common = { version = "0.1.0", path = "crates/common" }
 revive-dt-compiler = { version = "0.1.0", path = "crates/compiler" }
 revive-dt-config = { version = "0.1.0", path = "crates/config" }
 revive-dt-core = { version = "0.1.0", path = "crates/core" }
@@ -23,24 +22,45 @@ revive-dt-node-pool = { version = "0.1.0", path = "crates/node-pool" }
 revive-dt-report = { version = "0.1.0", path = "crates/report" }
 revive-dt-solc-binaries = { version = "0.1.0", path = "crates/solc-binaries" }
 alloy-primitives = "1.2.1"
 alloy-sol-types = "1.2.1"
 anyhow = "1.0"
 bson = { version = "2.15.0" }
 cacache = { version = "13.1.0" }
 clap = { version = "4", features = ["derive"] }
-env_logger = "0.11.8"
+foundry-compilers-artifacts = { version = "0.18.0" }
 futures = { version = "0.3.31" }
 hex = "0.4.3"
-reqwest = { version = "0.12.15", features = ["blocking", "json"] }
+regex = "1"
-log = "0.4.27"
+moka = "0.12.10"
 reqwest = { version = "0.12.15", features = ["json"] }
 once_cell = "1.21"
 rayon = { version = "1.10" }
 semver = { version = "1.0", features = ["serde"] }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
-serde_json = { version = "1.0", default-features = false, features = ["arbitrary_precision", "std"] }
+serde_json = { version = "1.0", default-features = false, features = [
    "arbitrary_precision",
    "std",
    "unbounded_depth",
 ] }
 sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"
 sp-runtime = "41.1.0"
 temp-dir = { version = "0.1.16" }
 tempfile = "3.3"
-tokio = { version = "1", default-features = false, features = ["rt-multi-thread"] }
+thiserror = "2"
 tokio = { version = "1.47.0", default-features = false, features = [
    "rt-multi-thread",
    "process",
    "rt",
 ] }
 uuid = { version = "1.8", features = ["v4"] }
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", default-features = false, features = [
    "fmt",
    "json",
    "env-filter",
 ] }
 indexmap = { version = "2.10.0", default-features = false }
 # revive compiler
 revive-solc-json-interface = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
@@ -48,7 +68,7 @@ revive-common = { git = "https://github.com/paritytech/revive", rev = "3389865af
 revive-differential = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
 [workspace.dependencies.alloy]
-version = "1.0"
+version = "1.0.22"
 default-features = false
 features = [
    "json-abi",
@@ -59,6 +79,10 @@ features = [
    "rpc-types",
    "signer-local",
    "std",
    "network",
    "serde",
    "rpc-types-eth",
    "genesis",
 ]
 [profile.bench]
@@ -0,0 +1,337 @@
 {
    "modes": [
        "Y >=0.8.9",
        "E"
    ],
    "cases": [
        {
            "name": "first",
            "inputs": [
                {
                    "address": "0xdeadbeef00000000000000000000000000000042",
                    "expected_balance": "1233"
                },
                {
                    "address": "0xdeadbeef00000000000000000000000000000042",
                    "is_storage_empty": true
                },
                {
                    "address": "0xdeadbeef00000000000000000000000000000042",
                    "is_storage_empty": false
                },
                {
                    "instance": "WBTC_1",
                    "method": "#deployer",
                    "calldata": [
                        "0x40",
                        "0x80",
                        "4",
                        "0x5742544300000000000000000000000000000000000000000000000000000000",
                        "14",
                        "0x5772617070656420425443000000000000000000000000000000000000000000"
                    ],
                    "expected": [
                        "WBTC_1.address"
                    ]
                },
                {
                    "instance": "WBTC_2",
                    "method": "#deployer",
                    "calldata": [
                        "0x40",
                        "0x80",
                        "4",
                        "0x5742544300000000000000000000000000000000000000000000000000000000",
                        "14",
                        "0x5772617070656420425443000000000000000000000000000000000000000000"
                    ],
                    "expected": [
                        "WBTC_2.address"
                    ]
                },
                {
                    "instance": "Mooniswap",
                    "method": "#deployer",
                    "calldata": [
                        "0x0000000000000000000000000000000000000000000000000000000000000060",
                        "0x00000000000000000000000000000000000000000000000000000000000000c0",
                        "0x0000000000000000000000000000000000000000000000000000000000000100",
                        "0x0000000000000000000000000000000000000000000000000000000000000002",
                        "WBTC_1.address",
                        "WBTC_2.address",
                        "4",
                        "0x5742544300000000000000000000000000000000000000000000000000000000",
                        "14",
                        "0x5772617070656420425443000000000000000000000000000000000000000000"
                    ],
                    "expected": {
                        "return_data": [
                            "Mooniswap.address"
                        ],
                        "events": [
                            {
                                "topics": [
                                    "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",
                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
                                    "0xdeadbeef01000000000000000000000000000000"
                                ],
                                "values": []
                            }
                        ],
                        "exception": false
                    }
                },
                {
                    "instance": "WBTC_1",
                    "method": "_mint",
                    "calldata": [
                        "0xdeadbeef00000000000000000000000000000042",
                        "1000000000"
                    ],
                    "expected": {
                        "return_data": [],
                        "events": [
                            {
                                "topics": [
                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
                                    "0xdeadbeef00000000000000000000000000000042"
                                ],
                                "values": [
                                    "1000000000"
                                ]
                            }
                        ],
                        "exception": false
                    }
                },
                {
                    "instance": "WBTC_2",
                    "method": "_mint",
                    "calldata": [
                        "0xdeadbeef00000000000000000000000000000042",
                        "1000000000"
                    ],
                    "expected": {
                        "return_data": [],
                        "events": [
                            {
                                "topics": [
                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
                                    "0xdeadbeef00000000000000000000000000000042"
                                ],
                                "values": [
                                    "1000000000"
                                ]
                            }
                        ],
                        "exception": false
                    }
                },
                {
                    "instance": "WBTC_1",
                    "caller": "0xdeadbeef00000000000000000000000000000042",
                    "method": "approve",
                    "calldata": [
                        "Mooniswap.address",
                        "500000000"
                    ],
                    "expected": {
                        "return_data": [
                            "0x0000000000000000000000000000000000000000000000000000000000000001"
                        ],
                        "events": [
                            {
                                "topics": [
                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
                                    "0xdeadbeef00000000000000000000000000000042",
                                    "Mooniswap.address"
                                ],
                                "values": [
                                    "500000000"
                                ]
                            }
                        ],
                        "exception": false
                    }
                },
                {
                    "instance": "WBTC_2",
                    "caller": "0xdeadbeef00000000000000000000000000000042",
                    "method": "approve",
                    "calldata": [
                        "Mooniswap.address",
                        "500000000"
                    ],
                    "expected": {
                        "return_data": [
                            "0x0000000000000000000000000000000000000000000000000000000000000001"
                        ],
                        "events": [
                            {
                                "topics": [
                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
                                    "0xdeadbeef00000000000000000000000000000042",
                                    "Mooniswap.address"
                                ],
                                "values": [
                                    "500000000"
                                ]
                            }
                        ],
                        "exception": false
                    }
                },
                {
                    "instance": "Mooniswap",
                    "caller": "0xdeadbeef00000000000000000000000000000042",
                    "method": "deposit",
                    "calldata": [
                        "0x0000000000000000000000000000000000000000000000000000000000000040",
                        "0x00000000000000000000000000000000000000000000000000000000000000a0",
                        "0x0000000000000000000000000000000000000000000000000000000000000002",
                        "10000000",
                        "10000000",
                        "0x0000000000000000000000000000000000000000000000000000000000000002",
                        "1000000",
                        "1000000"
                    ],
                    "expected": {
                        "return_data": [
                            "10000000"
                        ],
                        "events": [
                            {
                                "topics": [
                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
                                    "Mooniswap.address"
                                ],
                                "values": [
                                    "1000"
                                ]
                            },
                            {
                                "topics": [
                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                                    "0xdeadbeef00000000000000000000000000000042",
                                    "Mooniswap.address"
                                ],
                                "values": [
                                    "10000000"
                                ]
                            },
                            {
                                "topics": [
                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
                                    "0xdeadbeef00000000000000000000000000000042",
                                    "Mooniswap.address"
                                ],
                                "values": [
                                    "490000000"
                                ]
                            },
                            {
                                "topics": [
                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                                    "0xdeadbeef00000000000000000000000000000042",
                                    "Mooniswap.address"
                                ],
                                "values": [
                                    "10000000"
                                ]
                            },
                            {
                                "topics": [
                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
                                    "0xdeadbeef00000000000000000000000000000042",
                                    "Mooniswap.address"
                                ],
                                "values": [
                                    "490000000"
                                ]
                            },
                            {
                                "topics": [
                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
                                    "0xdeadbeef00000000000000000000000000000042"
                                ],
                                "values": [
                                    "10000000"
                                ]
                            },
                            {
                                "topics": [
                                    "0x2da466a7b24304f47e87fa2e1e5a81b9831ce54fec19055ce277ca2f39ba42c4",
                                    "0xdeadbeef00000000000000000000000000000042"
                                ],
                                "values": [
                                    "10000000"
                                ]
                            }
                        ],
                        "exception": false
                    }
                },
                {
                    "instance": "Mooniswap",
                    "caller": "0xdeadbeef00000000000000000000000000000042",
                    "method": "swap",
                    "calldata": [
                        "WBTC_1.address",
                        "WBTC_2.address",
                        "5000",
                        "5000",
                        "0"
                    ]
                }
            ],
            "expected": {
                "return_data": [
                    "5000"
                ],
                "events": [
                    {
                        "topics": [
                            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                            "0xdeadbeef00000000000000000000000000000042",
                            "Mooniswap.address"
                        ],
                        "values": [
                            "5000"
                        ]
                    },
                    {
                        "topics": [
                            "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
                            "0xdeadbeef00000000000000000000000000000042",
                            "Mooniswap.address"
                        ],
                        "values": [
                            "489995000"
                        ]
                    }
                ],
                "exception": false
            }
        }
    ],
    "contracts": {
        "Mooniswap": "Mooniswap.sol:Mooniswap",
        "WBTC_1": "ERC20/ERC20.sol:ERC20",
        "WBTC_2": "ERC20/ERC20.sol:ERC20",
        "VirtualBalance": "Mooniswap.sol:VirtualBalance",
        "Math": "math/Math.sol:Math"
    },
    "libraries": {
        "Mooniswap.sol": {
            "VirtualBalance": "VirtualBalance"
        },
        "math/Math.sol": {
            "Math": "Math"
        }
    },
    "group": "Real life"
 }
@@ -0,0 +1,17 @@
 [package]
 name = "revive-dt-common"
 description = "A library containing common concepts that other crates in the workspace can rely on"
 version.workspace = true
 authors.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 moka = { workspace = true, features = ["sync"] }
 once_cell = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 tokio = { workspace = true, default-features = false, features = ["time"] }
@@ -0,0 +1,49 @@
 //! 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())
        }
    }
 }
@@ -0,0 +1,22 @@
 use std::{
    fs::{read_dir, remove_dir_all, remove_file},
    path::Path,
 };
 use anyhow::Result;
 /// This method clears the passed directory of all of the files and directories contained within
 /// without deleting the directory.
 pub fn clear_directory(path: impl AsRef<Path>) -> Result<()> {
    for entry in read_dir(path.as_ref())? {
        let entry = entry?;
        let entry_path = entry.path();
        if entry_path.is_file() {
            remove_file(entry_path)?
        } else {
            remove_dir_all(entry_path)?
        }
    }
    Ok(())
 }
@@ -0,0 +1,3 @@
 mod clear_dir;
 pub use clear_dir::*;
@@ -0,0 +1,3 @@
 mod poll;
 pub use poll::*;
@@ -0,0 +1,69 @@
 use std::ops::ControlFlow;
 use std::time::Duration;
 use anyhow::{Result, anyhow};
 const EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION: Duration = Duration::from_secs(60);
 /// A function that polls for a fallible future for some period of time and errors if it fails to
 /// get a result after polling.
 ///
 /// Given a future that returns a [`Result<ControlFlow<O, ()>>`], this function calls the future
 /// repeatedly (with some wait period) until the future returns a [`ControlFlow::Break`] or until it
 /// returns an [`Err`] in which case the function stops polling and returns the error.
 ///
 /// If the future keeps returning [`ControlFlow::Continue`] and fails to return a [`Break`] within
 /// the permitted polling duration then this function returns an [`Err`]
 ///
 /// [`Break`]: ControlFlow::Break
 /// [`Continue`]: ControlFlow::Continue
 pub async fn poll<F, O>(
    polling_duration: Duration,
    polling_wait_behavior: PollingWaitBehavior,
    mut future: impl FnMut() -> F,
 ) -> Result<O>
 where
    F: Future<Output = Result<ControlFlow<O, ()>>>,
 {
    let mut retries = 0;
    let mut total_wait_duration = Duration::ZERO;
    let max_allowed_wait_duration = polling_duration;
    loop {
        if total_wait_duration >= max_allowed_wait_duration {
            break Err(anyhow!(
                "Polling failed after {} retries and a total of {:?} of wait time",
                retries,
                total_wait_duration
            ));
        }
        match future().await? {
            ControlFlow::Continue(()) => {
                let next_wait_duration = match polling_wait_behavior {
                    PollingWaitBehavior::Constant(duration) => duration,
                    PollingWaitBehavior::ExponentialBackoff => {
                        Duration::from_secs(2u64.pow(retries))
                            .min(EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION)
                    }
                };
                let next_wait_duration =
                    next_wait_duration.min(max_allowed_wait_duration - total_wait_duration);
                total_wait_duration += next_wait_duration;
                retries += 1;
                tokio::time::sleep(next_wait_duration).await;
            }
            ControlFlow::Break(output) => {
                break Ok(output);
            }
        }
    }
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub enum PollingWaitBehavior {
    Constant(Duration),
    #[default]
    ExponentialBackoff,
 }
@@ -0,0 +1,91 @@
 use std::{
    borrow::Cow,
    collections::HashSet,
    path::{Path, PathBuf},
 };
 /// An iterator that finds files of a certain extension in the provided directory. You can think of
 /// this a glob pattern similar to: `${path}/**/*.md`
 pub struct FilesWithExtensionIterator {
    /// The set of allowed extensions that that match the requirement and that should be returned
    /// when found.
    allowed_extensions: HashSet<Cow<'static, str>>,
    /// The set of directories to visit next. This iterator does BFS and so these directories will
    /// only be visited if we can't find any files in our state.
    directories_to_search: Vec<PathBuf>,
    /// The set of files matching the allowed extensions that were found. If there are entries in
    /// 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 {
    pub fn new(root_directory: impl AsRef<Path>) -> Self {
        Self {
            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(),
        }
    }
    pub fn with_allowed_extension(
        mut self,
        allowed_extension: impl Into<Cow<'static, str>>,
    ) -> Self {
        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 {
    type Item = PathBuf;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(file_path) = self.files_matching_allowed_extensions.pop() {
            return Some(file_path);
        };
        let directory_to_search = self.directories_to_search.pop()?;
        let iterator = if self.use_cached_fs {
            let Ok(dir_entries) = crate::cached_fs::read_dir(directory_to_search.as_path()) else {
                return self.next();
            };
            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_path in iterator.flatten() {
            if entry_path.is_dir() {
                self.directories_to_search.push(entry_path)
            } else if entry_path.is_file()
                && entry_path.extension().is_some_and(|ext| {
                    self.allowed_extensions
                        .iter()
                        .any(|allowed| ext.eq_ignore_ascii_case(allowed.as_ref()))
                })
            {
                self.files_matching_allowed_extensions.push(entry_path)
            }
        }
        self.next()
    }
 }
@@ -0,0 +1,3 @@
 mod files_with_extension_iterator;
 pub use files_with_extension_iterator::*;
@@ -0,0 +1,9 @@
 //! 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;
 pub mod macros;
 pub mod types;
@@ -0,0 +1,106 @@
 /// Defines wrappers around types.
 ///
 /// For example, the macro invocation seen below:
 ///
 /// ```rust,ignore
 /// define_wrapper_type!(CaseId => usize);
 /// ```
 ///
 /// Would define a wrapper type that looks like the following:
 ///
 /// ```rust,ignore
 /// pub struct CaseId(usize);
 /// ```
 ///
 /// And would also implement a number of methods on this type making it easier to use.
 ///
 /// These wrapper types become very useful as they make the code a lot easier to read.
 ///
 /// Take the following as an example:
 ///
 /// ```rust,ignore
 /// struct State {
 ///     contracts: HashMap<usize, HashMap<String, Vec<u8>>>
 /// }
 /// ```
 ///
 /// In the above code it's hard to understand what the various types refer to or what to expect them
 /// to contain.
 ///
 /// With these wrapper types we're able to create code that's self-documenting in that the types
 /// tell us what the code is referring to. The above code is transformed into
 ///
 /// ```rust,ignore
 /// struct State {
 ///     contracts: HashMap<CaseId, HashMap<ContractName, ContractByteCode>>
 /// }
 /// ```
 ///
 /// Note that we follow the same syntax for defining wrapper structs but we do not permit the use of
 /// generics.
 #[macro_export]
 macro_rules! define_wrapper_type {
    (
        $(#[$meta: meta])*
        $vis:vis struct $ident: ident($ty: ty);
    ) => {
        $(#[$meta])*
        $vis struct $ident($ty);
        impl $ident {
            pub fn new(value: impl Into<$ty>) -> Self {
                Self(value.into())
            }
            pub fn into_inner(self) -> $ty {
                self.0
            }
            pub fn as_inner(&self) -> &$ty {
                &self.0
            }
        }
        impl AsRef<$ty> for $ident {
            fn as_ref(&self) -> &$ty {
                &self.0
            }
        }
        impl AsMut<$ty> for $ident {
            fn as_mut(&mut self) -> &mut $ty {
                &mut self.0
            }
        }
        impl std::ops::Deref for $ident {
            type Target = $ty;
            fn deref(&self) -> &Self::Target {
                &self.0
            }
        }
        impl std::ops::DerefMut for $ident {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.0
            }
        }
        impl From<$ty> for $ident {
            fn from(value: $ty) -> Self {
                Self(value)
            }
        }
        impl From<$ident> for $ty {
            fn from(value: $ident) -> Self {
                value.0
            }
        }
    };
 }
 /// Technically not needed but this allows for the macro to be found in the `macros` module of the
 /// crate in addition to being found in the root of the crate.
 pub use define_wrapper_type;
@@ -0,0 +1,3 @@
 mod define_wrapper_type;
 pub use define_wrapper_type::*;
@@ -0,0 +1,5 @@
 mod mode;
 mod version_or_requirement;
 pub use mode::*;
 pub use version_or_requirement::*;
@@ -0,0 +1,167 @@
 use crate::types::VersionOrRequirement;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 use std::str::FromStr;
 /// This represents a mode that a given test should be run with, if possible.
 ///
 /// We obtain this by taking a [`ParsedMode`], which may be looser or more strict
 /// in its requirements, and then expanding it out into a list of [`Mode`]s.
 ///
 /// Use [`ParsedMode::to_test_modes()`] to do this.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Mode {
    pub pipeline: ModePipeline,
    pub optimize_setting: ModeOptimizerSetting,
    pub version: Option<semver::VersionReq>,
 }
 impl Display for Mode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.pipeline.fmt(f)?;
        f.write_str(" ")?;
        self.optimize_setting.fmt(f)?;
        if let Some(version) = &self.version {
            f.write_str(" ")?;
            version.fmt(f)?;
        }
        Ok(())
    }
 }
 impl Mode {
    /// Return all of the available mode combinations.
    pub fn all() -> impl Iterator<Item = Mode> {
        ModePipeline::test_cases().flat_map(|pipeline| {
            ModeOptimizerSetting::test_cases().map(move |optimize_setting| Mode {
                pipeline,
                optimize_setting,
                version: None,
            })
        })
    }
    /// Resolves the [`Mode`]'s solidity version requirement into a [`VersionOrRequirement`] if
    /// the requirement is present on the object. Otherwise, the passed default version is used.
    pub fn compiler_version_to_use(&self, default: Version) -> VersionOrRequirement {
        match self.version {
            Some(ref requirement) => requirement.clone().into(),
            None => default.into(),
        }
    }
 }
 /// What do we want the compiler to do?
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
 pub enum ModePipeline {
    /// Compile Solidity code via Yul IR
    ViaYulIR,
    /// Compile Solidity direct to assembly
    ViaEVMAssembly,
 }
 impl FromStr for ModePipeline {
    type Err = anyhow::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            // via Yul IR
            "Y" => Ok(ModePipeline::ViaYulIR),
            // Don't go via Yul IR
            "E" => Ok(ModePipeline::ViaEVMAssembly),
            // Anything else that we see isn't a mode at all
            _ => Err(anyhow::anyhow!(
                "Unsupported pipeline '{s}': expected 'Y' or 'E'"
            )),
        }
    }
 }
 impl Display for ModePipeline {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ModePipeline::ViaYulIR => f.write_str("Y"),
            ModePipeline::ViaEVMAssembly => f.write_str("E"),
        }
    }
 }
 impl ModePipeline {
    /// Should we go via Yul IR?
    pub fn via_yul_ir(&self) -> bool {
        matches!(self, ModePipeline::ViaYulIR)
    }
    /// An iterator over the available pipelines that we'd like to test,
    /// when an explicit pipeline was not specified.
    pub fn test_cases() -> impl Iterator<Item = ModePipeline> + Clone {
        [ModePipeline::ViaYulIR, ModePipeline::ViaEVMAssembly].into_iter()
    }
 }
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
 pub enum ModeOptimizerSetting {
    /// 0 / -: Don't apply any optimizations
    M0,
    /// 1: Apply less than default optimizations
    M1,
    /// 2: Apply the default optimizations
    M2,
    /// 3 / +: Apply aggressive optimizations
    M3,
    /// s: Optimize for size
    Ms,
    /// z: Aggressively optimize for size
    Mz,
 }
 impl FromStr for ModeOptimizerSetting {
    type Err = anyhow::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "M0" => Ok(ModeOptimizerSetting::M0),
            "M1" => Ok(ModeOptimizerSetting::M1),
            "M2" => Ok(ModeOptimizerSetting::M2),
            "M3" => Ok(ModeOptimizerSetting::M3),
            "Ms" => Ok(ModeOptimizerSetting::Ms),
            "Mz" => Ok(ModeOptimizerSetting::Mz),
            _ => Err(anyhow::anyhow!(
                "Unsupported optimizer setting '{s}': expected 'M0', 'M1', 'M2', 'M3', 'Ms' or 'Mz'"
            )),
        }
    }
 }
 impl Display for ModeOptimizerSetting {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ModeOptimizerSetting::M0 => f.write_str("M0"),
            ModeOptimizerSetting::M1 => f.write_str("M1"),
            ModeOptimizerSetting::M2 => f.write_str("M2"),
            ModeOptimizerSetting::M3 => f.write_str("M3"),
            ModeOptimizerSetting::Ms => f.write_str("Ms"),
            ModeOptimizerSetting::Mz => f.write_str("Mz"),
        }
    }
 }
 impl ModeOptimizerSetting {
    /// An iterator over the available optimizer settings that we'd like to test,
    /// when an explicit optimizer setting was not specified.
    pub fn test_cases() -> impl Iterator<Item = ModeOptimizerSetting> + Clone {
        [
            // No optimizations:
            ModeOptimizerSetting::M0,
            // Aggressive optimizations:
            ModeOptimizerSetting::M3,
        ]
        .into_iter()
    }
    /// Are any optimizations enabled?
    pub fn optimizations_enabled(&self) -> bool {
        !matches!(self, ModeOptimizerSetting::M0)
    }
 }
@@ -0,0 +1,41 @@
 use semver::{Version, VersionReq};
 #[derive(Clone, Debug)]
 pub enum VersionOrRequirement {
    Version(Version),
    Requirement(VersionReq),
 }
 impl From<Version> for VersionOrRequirement {
    fn from(value: Version) -> Self {
        Self::Version(value)
    }
 }
 impl From<VersionReq> for VersionOrRequirement {
    fn from(value: VersionReq) -> Self {
        Self::Requirement(value)
    }
 }
 impl TryFrom<VersionOrRequirement> for Version {
    type Error = anyhow::Error;
    fn try_from(value: VersionOrRequirement) -> Result<Self, Self::Error> {
        let VersionOrRequirement::Version(version) = value else {
            anyhow::bail!("Version or requirement was not a version");
        };
        Ok(version)
    }
 }
 impl TryFrom<VersionOrRequirement> for VersionReq {
    type Error = anyhow::Error;
    fn try_from(value: VersionOrRequirement) -> Result<Self, Self::Error> {
        let VersionOrRequirement::Requirement(requirement) = value else {
            anyhow::bail!("Version or requirement was not a requirement");
        };
        Ok(requirement)
    }
 }
@@ -9,11 +9,18 @@ repository.workspace = true
 rust-version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 revive-solc-json-interface = { workspace = true }
 revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-solc-binaries = { workspace = true }
 revive-common = { workspace = true }
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
 foundry-compilers-artifacts = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 tokio = { workspace = true }
@@ -0,0 +1,4 @@
 use semver::Version;
 /// This is the first version of solc that supports the `--via-ir` flag / "viaIR" input JSON.
 pub const SOLC_VERSION_SUPPORTING_VIA_YUL_IR: Version = Version::new(0, 8, 13);
@@ -3,21 +3,26 @@
 //! - Polkadot revive resolc compiler
 //! - Polkadot revive Wasm compiler
 mod constants;
 use std::{
-    fs::read_to_string,
+    collections::HashMap,
    hash::Hash,
    path::{Path, PathBuf},
 };
-use revive_dt_config::Arguments;
+use alloy::json_abi::JsonAbi;
 use alloy_primitives::Address;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use revive_common::EVMVersion;
-use revive_solc_json_interface::{
+use revive_dt_common::cached_fs::read_to_string;
-    SolcStandardJsonInput, SolcStandardJsonInputLanguage, SolcStandardJsonInputSettings,
+use revive_dt_common::types::VersionOrRequirement;
-    SolcStandardJsonInputSettingsOptimizer, SolcStandardJsonInputSettingsSelection,
+use revive_dt_config::Arguments;
-    SolcStandardJsonOutput,
+
-};
+// Re-export this as it's a part of the compiler interface.
-use semver::Version;
+pub use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
 pub mod revive_js;
 pub mod revive_resolc;
@@ -31,60 +36,52 @@ pub trait SolidityCompiler {
    /// The low-level compiler interface.
    fn build(
        &self,
-        input: CompilerInput<Self::Options>,
+        input: CompilerInput,
-    ) -> anyhow::Result<CompilerOutput<Self::Options>>;
+        additional_options: Self::Options,
    ) -> impl Future<Output = anyhow::Result<CompilerOutput>>;
    fn new(solc_executable: PathBuf) -> Self;
-    fn get_compiler_executable(config: &Arguments, version: Version) -> anyhow::Result<PathBuf>;
+    fn get_compiler_executable(
        config: &Arguments,
        version: impl Into<VersionOrRequirement>,
    ) -> impl Future<Output = anyhow::Result<PathBuf>>;
    fn version(&self) -> anyhow::Result<Version>;
    /// Does the compiler support the provided mode and version settings?
    fn supports_mode(
        compiler_version: &Version,
        optimize_setting: ModeOptimizerSetting,
        pipeline: ModePipeline,
    ) -> bool;
 }
 /// The generic compilation input configuration.
-#[derive(Debug)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CompilerInput<T: PartialEq + Eq + Hash> {
+pub struct CompilerInput {
-    pub extra_options: T,
+    pub pipeline: Option<ModePipeline>,
-    pub input: SolcStandardJsonInput,
+    pub optimization: Option<ModeOptimizerSetting>,
    pub evm_version: Option<EVMVersion>,
    pub allow_paths: Vec<PathBuf>,
    pub base_path: Option<PathBuf>,
    pub sources: HashMap<PathBuf, String>,
    pub libraries: HashMap<PathBuf, HashMap<String, Address>>,
    pub revert_string_handling: Option<RevertString>,
 }
 /// The generic compilation output configuration.
-pub struct CompilerOutput<T: PartialEq + Eq + Hash> {
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-    /// The solc standard JSON input.
+pub struct CompilerOutput {
-    pub input: CompilerInput<T>,
+    /// The compiled contracts. The bytecode of the contract is kept as a string incase linking is
-    /// The produced solc standard JSON output.
+    /// required and the compiled source has placeholders.
-    pub output: SolcStandardJsonOutput,
+    pub contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
    /// The error message in case the compiler returns abnormally.
    pub error: Option<String>,
 }
-impl<T> PartialEq for CompilerInput<T>
+/// A generic builder style interface for configuring the supported compiler options.
 where
    T: PartialEq + Eq + Hash,
 {
    fn eq(&self, other: &Self) -> bool {
        let self_input = serde_json::to_vec(&self.input).unwrap_or_default();
        let other_input = serde_json::to_vec(&self.input).unwrap_or_default();
        self.extra_options.eq(&other.extra_options) && self_input == other_input
    }
 }
 impl<T> Eq for CompilerInput<T> where T: PartialEq + Eq + Hash {}
 impl<T> Hash for CompilerInput<T>
 where
    T: PartialEq + Eq + Hash,
 {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.extra_options.hash(state);
        state.write(&serde_json::to_vec(&self.input).unwrap_or_default());
    }
 }
 /// A generic builder style interface for configuring all compiler options.
 pub struct Compiler<T: SolidityCompiler> {
-    input: SolcStandardJsonInput,
+    input: CompilerInput,
-    extra_options: T::Options,
+    additional_options: T::Options,
    allow_paths: Vec<String>,
    base_path: Option<String>,
 }
 impl Default for Compiler<solc::Solc> {
@@ -99,71 +96,109 @@ where
 {
    pub fn new() -> Self {
        Self {
-            input: SolcStandardJsonInput {
+            input: CompilerInput {
-                language: SolcStandardJsonInputLanguage::Solidity,
+                pipeline: Default::default(),
-                sources: Default::default(),
+                optimization: Default::default(),
-                settings: SolcStandardJsonInputSettings::new(
+                evm_version: Default::default(),
                    None,
                    Default::default(),
                    None,
                    SolcStandardJsonInputSettingsSelection::new_required(),
                    SolcStandardJsonInputSettingsOptimizer::new(
                        false,
                        None,
                        &Version::new(0, 0, 0),
                        false,
                    ),
                    None,
                    None,
                ),
            },
            extra_options: Default::default(),
                allow_paths: Default::default(),
-            base_path: None,
+                base_path: Default::default(),
                sources: Default::default(),
                libraries: Default::default(),
                revert_string_handling: Default::default(),
            },
            additional_options: T::Options::default(),
        }
    }
-    pub fn solc_optimizer(mut self, enabled: bool) -> Self {
+    pub fn with_optimization(mut self, value: impl Into<Option<ModeOptimizerSetting>>) -> Self {
-        self.input.settings.optimizer.enabled = enabled;
+        self.input.optimization = value.into();
        self
    }
-    pub fn with_source(mut self, path: &Path) -> anyhow::Result<Self> {
+    pub fn with_pipeline(mut self, value: impl Into<Option<ModePipeline>>) -> Self {
        self.input.pipeline = value.into();
        self
    }
    pub fn with_evm_version(mut self, version: impl Into<Option<EVMVersion>>) -> Self {
        self.input.evm_version = version.into();
        self
    }
    pub fn with_allow_path(mut self, path: impl AsRef<Path>) -> Self {
        self.input.allow_paths.push(path.as_ref().into());
        self
    }
    pub fn with_base_path(mut self, path: impl Into<Option<PathBuf>>) -> Self {
        self.input.base_path = path.into();
        self
    }
    pub fn with_source(mut self, path: impl AsRef<Path>) -> anyhow::Result<Self> {
        self.input
            .sources
-            .insert(path.display().to_string(), read_to_string(path)?.into());
+            .insert(path.as_ref().to_path_buf(), read_to_string(path.as_ref())?);
        Ok(self)
    }
-    pub fn evm_version(mut self, evm_version: EVMVersion) -> Self {
+    pub fn with_library(
-        self.input.settings.evm_version = Some(evm_version);
+        mut self,
        path: impl AsRef<Path>,
        name: impl AsRef<str>,
        address: Address,
    ) -> Self {
        self.input
            .libraries
            .entry(path.as_ref().to_path_buf())
            .or_default()
            .insert(name.as_ref().into(), address);
        self
    }
-    pub fn extra_options(mut self, extra_options: T::Options) -> Self {
+    pub fn with_revert_string_handling(
-        self.extra_options = extra_options;
+        mut self,
        revert_string_handling: impl Into<Option<RevertString>>,
    ) -> Self {
        self.input.revert_string_handling = revert_string_handling.into();
        self
    }
-    pub fn allow_path(mut self, path: String) -> Self {
+    pub fn with_additional_options(mut self, options: impl Into<T::Options>) -> Self {
-        self.allow_paths.push(path);
+        self.additional_options = options.into();
        self
    }
-    pub fn base_path(mut self, base_path: String) -> Self {
+    pub fn then(self, callback: impl FnOnce(Self) -> Self) -> Self {
-        self.base_path = Some(base_path);
+        callback(self)
        self
    }
-    pub fn try_build(self, solc_path: PathBuf) -> anyhow::Result<CompilerOutput<T::Options>> {
+    pub fn try_then<E>(self, callback: impl FnOnce(Self) -> Result<Self, E>) -> Result<Self, E> {
-        T::new(solc_path).build(CompilerInput {
+        callback(self)
            extra_options: self.extra_options,
            input: self.input,
        })
    }
-    /// Returns the compiler JSON input.
+    pub async fn try_build(
-    pub fn input(&self) -> SolcStandardJsonInput {
+        self,
        compiler_path: impl AsRef<Path>,
    ) -> anyhow::Result<CompilerOutput> {
        T::new(compiler_path.as_ref().to_path_buf())
            .build(self.input, self.additional_options)
            .await
    }
    pub fn input(&self) -> CompilerInput {
        self.input.clone()
    }
 }
 /// Defines how the compiler should handle revert strings.
 #[derive(
    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
 )]
 pub enum RevertString {
    #[default]
    Default,
    Debug,
    Strip,
    VerboseDebug,
 }
@@ -6,11 +6,28 @@ use std::{
    process::{Command, Stdio},
 };
-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
-use revive_solc_json_interface::SolcStandardJsonOutput;
+use revive_solc_json_interface::{
    SolcStandardJsonInput, SolcStandardJsonInputLanguage, SolcStandardJsonInputSettings,
    SolcStandardJsonInputSettingsOptimizer, SolcStandardJsonInputSettingsSelection,
    SolcStandardJsonOutput,
 };
 use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 use alloy::json_abi::JsonAbi;
 use anyhow::Context;
 use semver::Version;
 use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
 // TODO: I believe that we need to also pass the solc compiler to resolc so that resolc uses the
 // specified solc compiler. I believe that currently we completely ignore the specified solc binary
 // when invoking resolc which doesn't seem right if we're using solc as a compiler frontend.
 /// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
 #[derive(Debug)]
 pub struct Resolc {
    /// Path to the `resolc` executable
    resolc_path: PathBuf,
@@ -19,63 +36,181 @@ pub struct Resolc {
 impl SolidityCompiler for Resolc {
    type Options = Vec<String>;
-    fn build(
+    #[tracing::instrument(level = "debug", ret)]
    async fn build(
        &self,
-        input: CompilerInput<Self::Options>,
+        CompilerInput {
-    ) -> anyhow::Result<CompilerOutput<Self::Options>> {
+            pipeline,
-        let mut child = Command::new(&self.resolc_path)
+            optimization,
-            .arg("--standard-json")
+            evm_version,
-            .args(&input.extra_options)
+            allow_paths,
            base_path,
            sources,
            libraries,
            // TODO: this is currently not being handled since there is no way to pass it into
            // resolc. So, we need to go back to this later once it's supported.
            revert_string_handling: _,
        }: CompilerInput,
        additional_options: Self::Options,
    ) -> anyhow::Result<CompilerOutput> {
        if !matches!(pipeline, None | Some(ModePipeline::ViaYulIR)) {
            anyhow::bail!(
                "Resolc only supports the Y (via Yul IR) pipeline, but the provided pipeline is {pipeline:?}"
            );
        }
        let input = SolcStandardJsonInput {
            language: SolcStandardJsonInputLanguage::Solidity,
            sources: sources
                .into_iter()
                .map(|(path, source)| (path.display().to_string(), source.into()))
                .collect(),
            settings: SolcStandardJsonInputSettings {
                evm_version,
                libraries: Some(
                    libraries
                        .into_iter()
                        .map(|(source_code, libraries_map)| {
                            (
                                source_code.display().to_string(),
                                libraries_map
                                    .into_iter()
                                    .map(|(library_ident, library_address)| {
                                        (library_ident, library_address.to_string())
                                    })
                                    .collect(),
                            )
                        })
                        .collect(),
                ),
                remappings: None,
                output_selection: Some(SolcStandardJsonInputSettingsSelection::new_required()),
                via_ir: Some(true),
                optimizer: SolcStandardJsonInputSettingsOptimizer::new(
                    optimization
                        .unwrap_or(ModeOptimizerSetting::M0)
                        .optimizations_enabled(),
                    None,
                    &Version::new(0, 0, 0),
                    false,
                ),
                metadata: None,
                polkavm: None,
            },
        };
        let mut command = AsyncCommand::new(&self.resolc_path);
        command
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
-            .spawn()?;
+            .arg("--standard-json");
        if let Some(ref base_path) = base_path {
            command.arg("--base-path").arg(base_path);
        }
        if !allow_paths.is_empty() {
            command.arg("--allow-paths").arg(
                allow_paths
                    .iter()
                    .map(|path| path.display().to_string())
                    .collect::<Vec<_>>()
                    .join(","),
            );
        }
        let mut child = command.spawn()?;
        let stdin_pipe = child.stdin.as_mut().expect("stdin must be piped");
-        serde_json::to_writer(stdin_pipe, &input.input)?;
+        let serialized_input = serde_json::to_vec(&input)?;
        stdin_pipe.write_all(&serialized_input).await?;
-        let json_in = serde_json::to_string_pretty(&input.input)?;
+        let output = child.wait_with_output().await?;
        let output = child.wait_with_output()?;
        let stdout = output.stdout;
        let stderr = output.stderr;
        if !output.status.success() {
            let json_in = serde_json::to_string_pretty(&input)?;
            let message = String::from_utf8_lossy(&stderr);
-            log::error!(
+            tracing::error!(
-                "resolc failed exit={} stderr={} JSON-in={} ",
+                status = %output.status,
-                output.status,
+                message = %message,
-                &message,
+                json_input = json_in,
-                json_in,
+                "Compilation using resolc failed"
            );
-            return Ok(CompilerOutput {
+            anyhow::bail!("Compilation failed with an error: {message}");
                input,
                output: Default::default(),
                error: Some(message.into()),
            });
        }
-        let parsed: SolcStandardJsonOutput = serde_json::from_slice(&stdout).map_err(|e| {
+        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout).map_err(|e| {
            anyhow::anyhow!(
                "failed to parse resolc JSON output: {e}\nstderr: {}",
                String::from_utf8_lossy(&stderr)
            )
        })?;
-        Ok(CompilerOutput {
+        tracing::debug!(
-            input,
+            output = %serde_json::to_string(&parsed).unwrap(),
-            output: parsed,
+            "Compiled successfully"
-            error: None,
+        );
        // Detecting if the compiler output contained errors and reporting them through logs and
        // errors instead of returning the compiler output that might contain errors.
        for error in parsed.errors.iter().flatten() {
            if error.severity == "error" {
                tracing::error!(
                    ?error,
                    ?input,
                    output = %serde_json::to_string(&parsed).unwrap(),
                    "Encountered an error in the compilation"
                );
                anyhow::bail!("Encountered an error in the compilation: {error}")
            }
        }
        let Some(contracts) = parsed.contracts else {
            anyhow::bail!("Unexpected error - resolc output doesn't have a contracts section");
        };
        let mut compiler_output = CompilerOutput::default();
        for (source_path, contracts) in contracts.into_iter() {
            let source_path = PathBuf::from(source_path).canonicalize()?;
            let map = compiler_output.contracts.entry(source_path).or_default();
            for (contract_name, contract_information) in contracts.into_iter() {
                let bytecode = contract_information
                    .evm
                    .and_then(|evm| evm.bytecode.clone())
                    .context("Unexpected - Contract compiled with resolc has no bytecode")?;
                let abi = contract_information
                    .metadata
                    .as_ref()
                    .and_then(|metadata| metadata.as_object())
                    .and_then(|metadata| metadata.get("solc_metadata"))
                    .and_then(|solc_metadata| solc_metadata.as_str())
                    .and_then(|metadata| serde_json::from_str::<serde_json::Value>(metadata).ok())
                    .and_then(|metadata| {
                        metadata.get("output").and_then(|output| {
                            output
                                .get("abi")
                                .and_then(|abi| serde_json::from_value::<JsonAbi>(abi.clone()).ok())
                        })
                    })
                    .context(
                        "Unexpected - Failed to get the ABI for a contract compiled with resolc",
                    )?;
                map.insert(contract_name, (bytecode.object, abi));
            }
        }
        Ok(compiler_output)
    }
    fn new(resolc_path: PathBuf) -> Self {
        Resolc { resolc_path }
    }
-    fn get_compiler_executable(
+    async fn get_compiler_executable(
        config: &Arguments,
-        _version: semver::Version,
+        _version: impl Into<VersionOrRequirement>,
    ) -> anyhow::Result<PathBuf> {
        if !config.resolc.as_os_str().is_empty() {
            return Ok(config.resolc.clone());
@@ -83,4 +218,59 @@ impl SolidityCompiler for Resolc {
        Ok(PathBuf::from("resolc"))
    }
    fn version(&self) -> anyhow::Result<semver::Version> {
        // 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())
            .arg("--version")
            .stdout(Stdio::piped())
            .spawn()?
            .wait_with_output()?
            .stdout;
        let output = String::from_utf8_lossy(&output);
        let version_string = output
            .split("version ")
            .nth(1)
            .context("Version parsing failed")?
            .split("+")
            .next()
            .context("Version parsing failed")?;
        Version::parse(version_string).map_err(Into::into)
    }
    fn supports_mode(
        compiler_version: &Version,
        _optimize_setting: ModeOptimizerSetting,
        pipeline: ModePipeline,
    ) -> bool {
        // We only support the Y (IE compile via Yul IR) mode here, which also means that we can
        // only use solc version 0.8.13 and above. We must always compile via Yul IR as resolc
        // needs this to translate to LLVM IR and then RISCV.
        pipeline == ModePipeline::ViaYulIR
            && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
    }
 }
 #[cfg(test)]
 mod test {
    use super::*;
    #[tokio::test]
    async fn compiler_version_can_be_obtained() {
        // Arrange
        let args = Arguments::default();
        let path = Resolc::get_compiler_executable(&args, Version::new(0, 7, 6))
            .await
            .unwrap();
        let compiler = Resolc::new(path);
        // Act
        let version = compiler.version();
        // Assert
        let _ = version.expect("Failed to get version");
    }
 }
@@ -6,10 +6,25 @@ use std::{
    process::{Command, Stdio},
 };
-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
 use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 use anyhow::Context;
 use foundry_compilers_artifacts::{
    output_selection::{
        BytecodeOutputSelection, ContractOutputSelection, EvmOutputSelection, OutputSelection,
    },
    solc::CompilerOutput as SolcOutput,
    solc::*,
 };
 use semver::Version;
 use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
 #[derive(Debug)]
 pub struct Solc {
    solc_path: PathBuf,
 }
@@ -17,47 +32,265 @@ pub struct Solc {
 impl SolidityCompiler for Solc {
    type Options = ();
-    fn build(
+    #[tracing::instrument(level = "debug", ret)]
    async fn build(
        &self,
-        input: CompilerInput<Self::Options>,
+        CompilerInput {
-    ) -> anyhow::Result<CompilerOutput<Self::Options>> {
+            pipeline,
-        let mut child = Command::new(&self.solc_path)
+            optimization,
            evm_version,
            allow_paths,
            base_path,
            sources,
            libraries,
            revert_string_handling,
        }: CompilerInput,
        _: Self::Options,
    ) -> anyhow::Result<CompilerOutput> {
        let compiler_supports_via_ir = self.version()? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
        // Be careful to entirely omit the viaIR field if the compiler does not support it,
        // as it will error if you provide fields it does not know about. Because
        // `supports_mode` is called prior to instantiating a compiler, we should never
        // ask for something which is invalid.
        let via_ir = match (pipeline, compiler_supports_via_ir) {
            (pipeline, true) => pipeline.map(|p| p.via_yul_ir()),
            (_pipeline, false) => None,
        };
        let input = SolcInput {
            language: SolcLanguage::Solidity,
            sources: Sources(
                sources
                    .into_iter()
                    .map(|(source_path, source_code)| (source_path, Source::new(source_code)))
                    .collect(),
            ),
            settings: Settings {
                optimizer: Optimizer {
                    enabled: optimization.map(|o| o.optimizations_enabled()),
                    details: Some(Default::default()),
                    ..Default::default()
                },
                output_selection: OutputSelection::common_output_selection(
                    [
                        ContractOutputSelection::Abi,
                        ContractOutputSelection::Evm(EvmOutputSelection::ByteCode(
                            BytecodeOutputSelection::Object,
                        )),
                    ]
                    .into_iter()
                    .map(|item| item.to_string()),
                ),
                evm_version: evm_version.map(|version| version.to_string().parse().unwrap()),
                via_ir,
                libraries: Libraries {
                    libs: libraries
                        .into_iter()
                        .map(|(file_path, libraries)| {
                            (
                                file_path,
                                libraries
                                    .into_iter()
                                    .map(|(library_name, library_address)| {
                                        (library_name, library_address.to_string())
                                    })
                                    .collect(),
                            )
                        })
                        .collect(),
                },
                debug: revert_string_handling.map(|revert_string_handling| DebuggingSettings {
                    revert_strings: match revert_string_handling {
                        crate::RevertString::Default => Some(RevertStrings::Default),
                        crate::RevertString::Debug => Some(RevertStrings::Debug),
                        crate::RevertString::Strip => Some(RevertStrings::Strip),
                        crate::RevertString::VerboseDebug => Some(RevertStrings::VerboseDebug),
                    },
                    debug_info: Default::default(),
                }),
                ..Default::default()
            },
        };
        let mut command = AsyncCommand::new(&self.solc_path);
        command
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
-            .arg("--standard-json")
+            .arg("--standard-json");
-            .spawn()?;
+
        if let Some(ref base_path) = base_path {
            command.arg("--base-path").arg(base_path);
        }
        if !allow_paths.is_empty() {
            command.arg("--allow-paths").arg(
                allow_paths
                    .iter()
                    .map(|path| path.display().to_string())
                    .collect::<Vec<_>>()
                    .join(","),
            );
        }
        let mut child = command.spawn()?;
        let stdin = child.stdin.as_mut().expect("should be piped");
-        serde_json::to_writer(stdin, &input.input)?;
+        let serialized_input = serde_json::to_vec(&input)?;
-        let output = child.wait_with_output()?;
+        stdin.write_all(&serialized_input).await?;
        let output = child.wait_with_output().await?;
        if !output.status.success() {
            let json_in = serde_json::to_string_pretty(&input)?;
            let message = String::from_utf8_lossy(&output.stderr);
-            log::error!("solc failed exit={} stderr={}", output.status, &message);
+            tracing::error!(
-            return Ok(CompilerOutput {
+                status = %output.status,
-                input,
+                message = %message,
-                output: Default::default(),
+                json_input = json_in,
-                error: Some(message.into()),
+                "Compilation using solc failed"
-            });
+            );
            anyhow::bail!("Compilation failed with an error: {message}");
        }
-        Ok(CompilerOutput {
+        let parsed = serde_json::from_slice::<SolcOutput>(&output.stdout).map_err(|e| {
-            input,
+            anyhow::anyhow!(
-            output: serde_json::from_slice(&output.stdout)?,
+                "failed to parse resolc JSON output: {e}\nstderr: {}",
-            error: None,
+                String::from_utf8_lossy(&output.stdout)
            )
        })?;
        // Detecting if the compiler output contained errors and reporting them through logs and
        // errors instead of returning the compiler output that might contain errors.
        for error in parsed.errors.iter() {
            if error.severity == Severity::Error {
                tracing::error!(?error, ?input, "Encountered an error in the compilation");
                anyhow::bail!("Encountered an error in the compilation: {error}")
            }
        }
        tracing::debug!(
            output = %String::from_utf8_lossy(&output.stdout).to_string(),
            "Compiled successfully"
        );
        let mut compiler_output = CompilerOutput::default();
        for (contract_path, contracts) in parsed.contracts {
            let map = compiler_output
                .contracts
                .entry(contract_path.canonicalize()?)
                .or_default();
            for (contract_name, contract_info) in contracts.into_iter() {
                let source_code = contract_info
                    .evm
                    .and_then(|evm| evm.bytecode)
                    .map(|bytecode| match bytecode.object {
                        BytecodeObject::Bytecode(bytecode) => bytecode.to_string(),
                        BytecodeObject::Unlinked(unlinked) => unlinked,
                    })
                    .context("Unexpected - contract compiled with solc has no source code")?;
                let abi = contract_info
                    .abi
                    .context("Unexpected - contract compiled with solc as no ABI")?;
                map.insert(contract_name, (source_code, abi));
            }
        }
        Ok(compiler_output)
    }
    fn new(solc_path: PathBuf) -> Self {
        Self { solc_path }
    }
-    fn get_compiler_executable(
+    async fn get_compiler_executable(
        config: &Arguments,
-        version: semver::Version,
+        version: impl Into<VersionOrRequirement>,
    ) -> anyhow::Result<PathBuf> {
-        let path = download_solc(config.directory(), version, config.wasm)?;
+        let path = download_solc(config.directory(), version, config.wasm).await?;
        Ok(path)
    }
    fn version(&self) -> anyhow::Result<semver::Version> {
        // The following is the parsing code for the version from the solc version strings which
        // look like the following:
        // ```
        // solc, the solidity compiler commandline interface
        // Version: 0.8.30+commit.73712a01.Darwin.appleclang
        // ```
        let child = Command::new(self.solc_path.as_path())
            .arg("--version")
            .stdout(Stdio::piped())
            .spawn()?;
        let output = child.wait_with_output()?;
        let output = String::from_utf8_lossy(&output.stdout);
        let version_line = output
            .split("Version: ")
            .nth(1)
            .context("Version parsing failed")?;
        let version_string = version_line
            .split("+")
            .next()
            .context("Version parsing failed")?;
        Version::parse(version_string).map_err(Into::into)
    }
    fn supports_mode(
        compiler_version: &Version,
        _optimize_setting: ModeOptimizerSetting,
        pipeline: ModePipeline,
    ) -> bool {
        // solc 0.8.13 and above supports --via-ir, and less than that does not. Thus, we support mode E
        // (ie no Yul IR) in either case, but only support Y (via Yul IR) if the compiler is new enough.
        pipeline == ModePipeline::ViaEVMAssembly
            || (pipeline == ModePipeline::ViaYulIR
                && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR)
    }
 }
 #[cfg(test)]
 mod test {
    use super::*;
    #[tokio::test]
    async fn compiler_version_can_be_obtained() {
        // Arrange
        let args = Arguments::default();
        println!("Getting compiler path");
        let path = Solc::get_compiler_executable(&args, Version::new(0, 7, 6))
            .await
            .unwrap();
        println!("Got compiler path");
        let compiler = Solc::new(path);
        // Act
        let version = compiler.version();
        // Assert
        assert_eq!(
            version.expect("Failed to get version"),
            Version::new(0, 7, 6)
        )
    }
    #[tokio::test]
    async fn compiler_version_can_be_obtained1() {
        // Arrange
        let args = Arguments::default();
        println!("Getting compiler path");
        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
            .await
            .unwrap();
        println!("Got compiler path");
        let compiler = Solc::new(path);
        // Act
        let version = compiler.version();
        // Assert
        assert_eq!(
            version.expect("Failed to get version"),
            Version::new(0, 4, 21)
        )
    }
 }
@@ -0,0 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.6.9;
 contract Callable {
    function f(uint[1] memory p1) public pure returns(uint) {
        return p1[0];
    }
 }
@@ -0,0 +1,13 @@
 // SPDX-License-Identifier: MIT
 // Report https://linear.app/matterlabs/issue/CPR-269/call-with-calldata-variable-bug
 pragma solidity >=0.6.9;
 import "./callable.sol";
 contract Main {
    function main(uint[1] calldata p1, Callable callable) public returns(uint) {
        return callable.f(p1);
    }
 }
@@ -0,0 +1,21 @@
 { "cases": [ {
    "name": "first",
    "inputs": [
        {
            "instance": "Main",
            "method": "main",
            "calldata": [
                "1",
                "Callable.address"
            ]
        }
    ],
    "expected": [
        "1"
    ]
 } ],
    "contracts": {
        "Main": "main.sol:Main",
        "Callable": "callable.sol:Callable"
    }
 }
@@ -0,0 +1,88 @@
 use std::path::PathBuf;
 use revive_dt_compiler::{Compiler, SolidityCompiler, revive_resolc::Resolc, solc::Solc};
 use revive_dt_config::Arguments;
 use semver::Version;
 #[tokio::test]
 async fn contracts_can_be_compiled_with_solc() {
    // Arrange
    let args = Arguments::default();
    let compiler_path = Solc::get_compiler_executable(&args, Version::new(0, 8, 30))
        .await
        .unwrap();
    println!("About to assert");
    // Act
    let output = Compiler::<Solc>::new()
        .with_source("./tests/assets/array_one_element/callable.sol")
        .unwrap()
        .with_source("./tests/assets/array_one_element/main.sol")
        .unwrap()
        .try_build(compiler_path)
        .await;
    // Assert
    let output = output.expect("Failed to compile");
    assert_eq!(output.contracts.len(), 2);
    let main_file_contracts = output
        .contracts
        .get(
            &PathBuf::from("./tests/assets/array_one_element/main.sol")
                .canonicalize()
                .unwrap(),
        )
        .unwrap();
    let callable_file_contracts = output
        .contracts
        .get(
            &PathBuf::from("./tests/assets/array_one_element/callable.sol")
                .canonicalize()
                .unwrap(),
        )
        .unwrap();
    assert!(main_file_contracts.contains_key("Main"));
    assert!(callable_file_contracts.contains_key("Callable"));
 }
 #[tokio::test]
 async fn contracts_can_be_compiled_with_resolc() {
    // Arrange
    let args = Arguments::default();
    let compiler_path = Resolc::get_compiler_executable(&args, Version::new(0, 8, 30))
        .await
        .unwrap();
    // Act
    let output = Compiler::<Resolc>::new()
        .with_source("./tests/assets/array_one_element/callable.sol")
        .unwrap()
        .with_source("./tests/assets/array_one_element/main.sol")
        .unwrap()
        .try_build(compiler_path)
        .await;
    // Assert
    let output = output.expect("Failed to compile");
    assert_eq!(output.contracts.len(), 2);
    let main_file_contracts = output
        .contracts
        .get(
            &PathBuf::from("./tests/assets/array_one_element/main.sol")
                .canonicalize()
                .unwrap(),
        )
        .unwrap();
    let callable_file_contracts = output
        .contracts
        .get(
            &PathBuf::from("./tests/assets/array_one_element/callable.sol")
                .canonicalize()
                .unwrap(),
        )
        .unwrap();
    assert!(main_file_contracts.contains_key("Main"));
    assert!(callable_file_contracts.contains_key("Callable"));
 }
@@ -1,8 +1,9 @@
-//! The global configuration used accross all revive differential testing crates.
+//! The global configuration used across all revive differential testing crates.
 use std::{
    fmt::Display,
    path::{Path, PathBuf},
    sync::LazyLock,
 };
 use alloy::{network::EthereumWallet, signers::local::PrivateKeySigner};
@@ -54,13 +55,9 @@ pub struct Arguments {
    pub geth: PathBuf,
    /// The maximum time in milliseconds to wait for geth to start.
-    #[arg(long = "geth-start-timeout", default_value = "2000")]
+    #[arg(long = "geth-start-timeout", default_value = "5000")]
    pub geth_start_timeout: u64,
    /// The test network chain ID.
    #[arg(short, long = "network-id", default_value = "420420420")]
    pub network_id: u64,
    /// Configure nodes according to this genesis.json file.
    #[arg(long = "genesis", default_value = "genesis.json")]
    pub genesis_file: PathBuf,
@@ -73,6 +70,12 @@ pub struct Arguments {
    )]
    pub account: String,
    /// This argument controls which private keys the nodes should have access to and be added to
    /// its wallet signers. With a value of N, private keys (0, N] will be added to the signer set
    /// of the node.
    #[arg(long = "private-keys-count", default_value_t = 100_000)]
    pub private_keys_to_add: usize,
    /// The differential testing leader node implementation.
    #[arg(short, long = "leader", default_value = "geth")]
    pub leader: TestingPlatform,
@@ -85,9 +88,22 @@ pub struct Arguments {
    #[arg(long = "compile-only")]
    pub compile_only: Option<TestingPlatform>,
-    /// Determines the amount of tests that are executed in parallel.
+    /// Determines the amount of nodes that will be spawned for each chain.
-    #[arg(long = "workers", default_value = "12")]
+    #[arg(long, default_value = "1")]
-    pub workers: usize,
+    pub number_of_nodes: usize,
    /// Determines the amount of tokio worker threads that will will be used.
    #[arg(
        long,
        default_value_t = std::thread::available_parallelism()
            .map(|n| n.get())
            .unwrap_or(1)
    )]
    pub number_of_threads: usize,
    /// Determines the amount of concurrent tasks that will be spawned to run tests. Defaults to 10 x the number of nodes.
    #[arg(long)]
    pub number_concurrent_tasks: Option<usize>,
    /// Extract problems back to the test corpus.
    #[arg(short, long = "extract-problems")]
@@ -104,6 +120,10 @@ pub struct Arguments {
    /// By default it uses `eth-rpc` binary found in `$PATH`.
    #[arg(short = 'p', long = "eth_proxy", default_value = "eth-rpc")]
    pub eth_proxy: PathBuf,
    /// Controls if the compilation cache should be invalidated or not.
    #[arg(short, long)]
    pub invalidate_compilation_cache: bool,
 }
 impl Arguments {
@@ -123,6 +143,13 @@ impl Arguments {
        panic!("should have a workdir configured")
    }
    /// Return the number of concurrent tasks to run. This is provided via the
    /// `--number-concurrent-tasks` argument, and otherwise defaults to --number-of-nodes * 20.
    pub fn number_of_concurrent_tasks(&self) -> usize {
        self.number_concurrent_tasks
            .unwrap_or(20 * self.number_of_nodes)
    }
    /// Try to parse `self.account` into a [PrivateKeySigner],
    /// panicing on error.
    pub fn wallet(&self) -> EthereumWallet {
@@ -138,14 +165,23 @@ impl Arguments {
 impl Default for Arguments {
    fn default() -> Self {
-        Arguments::parse_from(["retester"])
+        static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
        let default = Arguments::parse_from(["retester"]);
        Arguments {
            temp_dir: Some(&TEMP_DIR),
            ..default
        }
    }
 }
 /// The Solidity compatible node implementation.
 ///
 /// This describes the solutions to be tested against on a high level.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, ValueEnum, Serialize, Deserialize)]
+#[derive(
    Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, ValueEnum, Serialize, Deserialize,
 )]
 #[clap(rename_all = "lower")]
 pub enum TestingPlatform {
    /// The go-ethereum reference full node EVM implementation.
@@ -13,6 +13,7 @@ name = "retester"
 path = "src/main.rs"
 [dependencies]
 revive-dt-common = { workspace = true }
 revive-dt-compiler = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
@@ -22,9 +23,17 @@ revive-dt-report = { workspace = true }
 alloy = { workspace = true }
 anyhow = { workspace = true }
 bson = { workspace = true }
 cacache = { workspace = true }
 clap = { workspace = true }
-log = { workspace = true }
+futures = { workspace = true }
-env_logger = { workspace = true }
+indexmap = { workspace = true }
-rayon = { workspace = true }
+once_cell = { workspace = true }
-revive-solc-json-interface = { workspace = true }
+tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 temp-dir = { workspace = true }
 tempfile = { workspace = true }
@@ -0,0 +1,261 @@
 //! A wrapper around the compiler which allows for caching of compilation artifacts so that they can
 //! be reused between runs.
 use std::{
    collections::HashMap,
    path::{Path, PathBuf},
    sync::Arc,
 };
 use futures::FutureExt;
 use revive_dt_common::iterators::FilesWithExtensionIterator;
 use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
 use revive_dt_config::Arguments;
 use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
 use alloy::{hex::ToHexExt, json_abi::JsonAbi, primitives::Address};
 use anyhow::{Error, Result};
 use once_cell::sync::Lazy;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use tokio::sync::{Mutex, RwLock};
 use tracing::{Instrument, debug, debug_span, instrument};
 use crate::Platform;
 pub struct CachedCompiler(ArtifactsCache);
 impl CachedCompiler {
    pub async fn new(path: impl AsRef<Path>, invalidate_cache: bool) -> Result<Self> {
        let mut cache = ArtifactsCache::new(path);
        if invalidate_cache {
            cache = cache.with_invalidated_cache().await?;
        }
        Ok(Self(cache))
    }
    /// Compiles or gets the compilation artifacts from the cache.
    #[instrument(
        level = "debug",
        skip_all,
        fields(
            metadata_file_path = %metadata_file_path.as_ref().display(),
            %mode,
            platform = P::config_id().to_string()
        ),
        err
    )]
    pub async fn compile_contracts<P: Platform>(
        &self,
        metadata: &Metadata,
        metadata_file_path: impl AsRef<Path>,
        mode: &Mode,
        config: &Arguments,
        deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
    ) -> Result<(CompilerOutput, Version)> {
        static CACHE_KEY_LOCK: Lazy<RwLock<HashMap<CacheKey, Arc<Mutex<()>>>>> =
            Lazy::new(Default::default);
        let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
        let compiler_path = <P::Compiler as SolidityCompiler>::get_compiler_executable(
            config,
            compiler_version_or_requirement,
        )
        .await?;
        let compiler_version =
            <P::Compiler as SolidityCompiler>::new(compiler_path.clone()).version()?;
        let cache_key = CacheKey {
            platform_key: P::config_id().to_string(),
            compiler_version: compiler_version.clone(),
            metadata_file_path: metadata_file_path.as_ref().to_path_buf(),
            solc_mode: mode.clone(),
        };
        let compilation_callback = || {
            async move {
                compile_contracts::<P>(
                    metadata.directory()?,
                    compiler_path,
                    metadata.files_to_compile()?,
                    mode,
                    deployed_libraries,
                )
                .map(|compilation_result| compilation_result.map(CacheValue::new))
                .await
            }
            .instrument(debug_span!(
                "Running compilation for the cache key",
                cache_key.platform_key = %cache_key.platform_key,
                cache_key.compiler_version = %cache_key.compiler_version,
                cache_key.metadata_file_path = %cache_key.metadata_file_path.display(),
                cache_key.solc_mode = %cache_key.solc_mode,
            ))
        };
        let compiled_contracts = match deployed_libraries {
            // If deployed libraries have been specified then we will re-compile the contract as it
            // means that linking is required in this case.
            Some(_) => {
                debug!("Deployed libraries defined, recompilation must take place");
                debug!("Cache miss");
                compilation_callback().await?.compiler_output
            }
            // If no deployed libraries are specified then we can follow the cached flow and attempt
            // to lookup the compilation artifacts in the cache.
            None => {
                debug!("Deployed libraries undefined, attempting to make use of cache");
                // Lock this specific cache key such that we do not get inconsistent state. We want
                // that when multiple cases come in asking for the compilation artifacts then they
                // don't all trigger a compilation if there's a cache miss. Hence, the lock here.
                let read_guard = CACHE_KEY_LOCK.read().await;
                let mutex = match read_guard.get(&cache_key).cloned() {
                    Some(value) => value,
                    None => {
                        drop(read_guard);
                        CACHE_KEY_LOCK
                            .write()
                            .await
                            .entry(cache_key.clone())
                            .or_default()
                            .clone()
                    }
                };
                let _guard = mutex.lock().await;
                self.0
                    .get_or_insert_with(&cache_key, compilation_callback)
                    .await
                    .map(|value| value.compiler_output)?
            }
        };
        Ok((compiled_contracts, compiler_version))
    }
 }
 async fn compile_contracts<P: Platform>(
    metadata_directory: impl AsRef<Path>,
    compiler_path: impl AsRef<Path>,
    mut files_to_compile: impl Iterator<Item = PathBuf>,
    mode: &Mode,
    deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
 ) -> Result<CompilerOutput> {
    let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
        .with_allowed_extension("sol")
        .with_use_cached_fs(true)
        .collect::<Vec<_>>();
    Compiler::<P::Compiler>::new()
        .with_allow_path(metadata_directory)
        // Handling the modes
        .with_optimization(mode.optimize_setting)
        .with_pipeline(mode.pipeline)
        // Adding the contract sources to the compiler.
        .try_then(|compiler| {
            files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
        })?
        // Adding the deployed libraries to the compiler.
        .then(|compiler| {
            deployed_libraries
                .iter()
                .flat_map(|value| value.iter())
                .map(|(instance, (ident, address, abi))| (instance, ident, address, abi))
                .flat_map(|(_, ident, address, _)| {
                    all_sources_in_dir
                        .iter()
                        .map(move |path| (ident, address, path))
                })
                .fold(compiler, |compiler, (ident, address, path)| {
                    compiler.with_library(path, ident.as_str(), *address)
                })
        })
        .try_build(compiler_path)
        .await
 }
 struct ArtifactsCache {
    path: PathBuf,
 }
 impl ArtifactsCache {
    pub fn new(path: impl AsRef<Path>) -> Self {
        Self {
            path: path.as_ref().to_path_buf(),
        }
    }
    #[instrument(level = "debug", skip_all, err)]
    pub async fn with_invalidated_cache(self) -> Result<Self> {
        cacache::clear(self.path.as_path())
            .await
            .map_err(Into::<Error>::into)?;
        Ok(self)
    }
    #[instrument(level = "debug", skip_all, err)]
    pub async fn insert(&self, key: &CacheKey, value: &CacheValue) -> Result<()> {
        let key = bson::to_vec(key)?;
        let value = bson::to_vec(value)?;
        cacache::write(self.path.as_path(), key.encode_hex(), value).await?;
        Ok(())
    }
    pub async fn get(&self, key: &CacheKey) -> Option<CacheValue> {
        let key = bson::to_vec(key).ok()?;
        let value = cacache::read(self.path.as_path(), key.encode_hex())
            .await
            .ok()?;
        let value = bson::from_slice::<CacheValue>(&value).ok()?;
        Some(value)
    }
    #[instrument(level = "debug", skip_all, err)]
    pub async fn get_or_insert_with(
        &self,
        key: &CacheKey,
        callback: impl AsyncFnOnce() -> Result<CacheValue>,
    ) -> Result<CacheValue> {
        match self.get(key).await {
            Some(value) => {
                debug!("Cache hit");
                Ok(value)
            }
            None => {
                debug!("Cache miss");
                let value = callback().await?;
                self.insert(key, &value).await?;
                Ok(value)
            }
        }
    }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 struct CacheKey {
    /// The platform name that this artifact was compiled for. For example, this could be EVM or
    /// PVM.
    platform_key: String,
    /// The version of the compiler that was used to compile the artifacts.
    compiler_version: Version,
    /// The path of the metadata file that the compilation artifacts are for.
    metadata_file_path: PathBuf,
    /// The mode that the compilation artifacts where compiled with.
    solc_mode: Mode,
 }
 #[derive(Clone, Debug, Serialize, Deserialize)]
 struct CacheValue {
    /// The compiler output from the compilation run.
    compiler_output: CompilerOutput,
 }
 impl CacheValue {
    pub fn new(compiler_output: CompilerOutput) -> Self {
        Self { compiler_output }
    }
 }
@@ -1,11 +1,12 @@
 //! The revive differential testing core library.
 //!
 //! This crate defines the testing configuration and
-//! provides a helper utilty to execute tests.
+//! provides a helper utility to execute tests.
 use revive_dt_compiler::{SolidityCompiler, revive_resolc, solc};
 use revive_dt_config::TestingPlatform;
-use revive_dt_node::{geth, kitchensink::KitchensinkNode};
+use revive_dt_format::traits::ResolverApi;
 use revive_dt_node::{Node, geth, kitchensink::KitchensinkNode};
 use revive_dt_node_interaction::EthereumNode;
 pub mod driver;
@@ -14,7 +15,7 @@ pub mod driver;
 ///
 /// For this we need a blockchain node implementation and a compiler.
 pub trait Platform {
-    type Blockchain: EthereumNode;
+    type Blockchain: EthereumNode + Node + ResolverApi;
    type Compiler: SolidityCompiler;
    /// Returns the matching [TestingPlatform] of the [revive_dt_config::Arguments].
@@ -25,7 +26,7 @@ pub trait Platform {
 pub struct Geth;
 impl Platform for Geth {
-    type Blockchain = geth::Instance;
+    type Blockchain = geth::GethNode;
    type Compiler = solc::Solc;
    fn config_id() -> TestingPlatform {
@@ -1,39 +1,91 @@
-use std::{collections::HashMap, sync::LazyLock};
+mod cached_compiler;
 use std::{
    collections::HashMap,
    path::{Path, PathBuf},
    sync::{Arc, LazyLock},
    time::Instant,
 };
 use alloy::{
    network::{Ethereum, TransactionBuilder},
    rpc::types::TransactionRequest,
 };
 use anyhow::Context;
 use clap::Parser;
-use rayon::{ThreadPoolBuilder, prelude::*};
+use futures::stream::futures_unordered::FuturesUnordered;
 use futures::{Stream, StreamExt};
 use revive_dt_node_interaction::EthereumNode;
 use temp_dir::TempDir;
 use tokio::sync::mpsc;
 use tracing::{Instrument, Level};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 use revive_dt_common::types::Mode;
 use revive_dt_compiler::SolidityCompiler;
 use revive_dt_config::*;
 use revive_dt_core::{
    Geth, Kitchensink, Platform,
-    driver::{Driver, State},
+    driver::{CaseDriver, CaseState},
 };
 use revive_dt_format::{
    case::{Case, CaseIdx},
    corpus::Corpus,
    input::{Input, Step},
    metadata::{ContractPathAndIdent, Metadata, MetadataFile},
 };
 use revive_dt_format::{corpus::Corpus, metadata::Metadata};
 use revive_dt_node::pool::NodePool;
 use revive_dt_report::reporter::{Report, Span};
-use temp_dir::TempDir;
+
 use crate::cached_compiler::CachedCompiler;
 static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 /// this represents a single "test"; a mode, path and collection of cases.
 #[derive(Clone)]
 struct Test {
    metadata: Metadata,
    path: PathBuf,
    mode: Mode,
    case_idx: CaseIdx,
    case: Case,
 }
 /// This represents the results that we gather from running test cases.
 type CaseResult = Result<usize, anyhow::Error>;
 fn main() -> anyhow::Result<()> {
    let args = init_cli()?;
    let body = async {
        for (corpus, tests) in collect_corpora(&args)? {
            let span = Span::new(corpus, args.clone())?;
            match &args.compile_only {
-            Some(platform) => compile_corpus(&args, &tests, platform, span),
+                Some(platform) => compile_corpus(&args, &tests, platform, span).await,
-            None => execute_corpus(&args, &tests, span)?,
+                None => execute_corpus(&args, &tests, span).await?,
            }
            Report::save()?;
        }
        Ok(())
    };
    tokio::runtime::Builder::new_multi_thread()
        .worker_threads(args.number_of_threads)
        .enable_all()
        .build()
        .expect("Failed building the Runtime")
        .block_on(body)
 }
 fn init_cli() -> anyhow::Result<Arguments> {
-    env_logger::init();
+    let subscriber = FmtSubscriber::builder()
        .with_thread_ids(true)
        .with_thread_names(true)
        .with_env_filter(EnvFilter::from_default_env())
        .with_ansi(false)
        .pretty()
        .finish();
    tracing::subscriber::set_global_default(subscriber)?;
    let mut args = Arguments::parse();
@@ -51,73 +103,524 @@ fn init_cli() -> anyhow::Result<Arguments> {
            args.temp_dir = Some(&TEMP_DIR);
        }
    }
-    log::info!("workdir: {}", args.directory().display());
+    tracing::info!("workdir: {}", args.directory().display());
    ThreadPoolBuilder::new()
        .num_threads(args.workers)
        .build_global()?;
    Ok(args)
 }
-fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<Metadata>>> {
+fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<MetadataFile>>> {
    let mut corpora = HashMap::new();
    for path in &args.corpus {
        let corpus = Corpus::try_from_path(path)?;
-        log::info!("found corpus: {}", path.display());
+        tracing::info!("found corpus: {}", path.display());
        let tests = corpus.enumerate_tests();
-        log::info!("corpus '{}' contains {} tests", &corpus.name, tests.len());
+        tracing::info!("corpus '{}' contains {} tests", &corpus.name, tests.len());
        corpora.insert(corpus, tests);
    }
    Ok(corpora)
 }
-fn run_driver<L, F>(args: &Arguments, tests: &[Metadata], span: Span) -> anyhow::Result<()>
+async fn run_driver<L, F>(
    args: &Arguments,
    metadata_files: &[MetadataFile],
    span: Span,
 ) -> anyhow::Result<()>
 where
    L: Platform,
    F: Platform,
    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let leader_nodes = NodePool::<L::Blockchain>::new(args)?;
+    let (report_tx, report_rx) = mpsc::unbounded_channel::<(Test, CaseResult)>();
    let follower_nodes = NodePool::<F::Blockchain>::new(args)?;
-    tests.par_iter().for_each(|metadata| {
+    let tests = prepare_tests::<L, F>(args, metadata_files);
-        let mut driver = Driver::<L, F>::new(
+    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx).await?;
-            metadata,
+    let status_reporter_task = start_reporter_task(report_rx);
            args,
            leader_nodes.round_robbin(),
            follower_nodes.round_robbin(),
        );
-        match driver.execute(span) {
+    tokio::join!(status_reporter_task, driver_task);
            Ok(_) => {
                log::info!(
                    "metadata {} success",
                    metadata.directory().as_ref().unwrap().display()
                );
            }
            Err(error) => {
                log::warn!(
                    "metadata {} failure: {error:?}",
                    metadata.file_path.as_ref().unwrap().display()
                );
            }
        }
    });
    Ok(())
 }
-fn execute_corpus(args: &Arguments, tests: &[Metadata], span: Span) -> anyhow::Result<()> {
+fn prepare_tests<L, F>(
    args: &Arguments,
    metadata_files: &[MetadataFile],
 ) -> impl Stream<Item = Test>
 where
    L: Platform,
    F: Platform,
    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
    metadata_files
        .iter()
        .flat_map(
            |MetadataFile {
                 path,
                 content: metadata,
             }| {
                metadata
                    .cases
                    .iter()
                    .enumerate()
                    .flat_map(move |(case_idx, case)| {
                        metadata
                            .solc_modes()
                            .into_iter()
                            .map(move |solc_mode| (path, metadata, case_idx, case, solc_mode))
                    })
            },
        )
        .filter(
            |(metadata_file_path, metadata, _, _, _)| match metadata.ignore {
                Some(true) => {
                    tracing::warn!(
                        metadata_file_path = %metadata_file_path.display(),
                        "Ignoring metadata file"
                    );
                    false
                }
                Some(false) | None => true,
            },
        )
        .filter(
            |(metadata_file_path, _, case_idx, case, _)| match case.ignore {
                Some(true) => {
                    tracing::warn!(
                        metadata_file_path = %metadata_file_path.display(),
                        case_idx,
                        case_name = ?case.name,
                        "Ignoring case"
                    );
                    false
                }
                Some(false) | None => true,
            },
        )
        .filter(|(metadata_file_path, metadata, ..)| match metadata.required_evm_version {
            Some(evm_version_requirement) => {
                let is_allowed = evm_version_requirement
                    .matches(&<L::Blockchain as revive_dt_node::Node>::evm_version())
                    && evm_version_requirement
                        .matches(&<F::Blockchain as revive_dt_node::Node>::evm_version());
                if !is_allowed {
                    tracing::warn!(
                        metadata_file_path = %metadata_file_path.display(),
                        leader_evm_version = %<L::Blockchain as revive_dt_node::Node>::evm_version(),
                        follower_evm_version = %<F::Blockchain as revive_dt_node::Node>::evm_version(),
                        version_requirement = %evm_version_requirement,
                        "Skipped test since the EVM version requirement was not fulfilled."
                    );
                }
                is_allowed
            }
            None => true,
        })
        .map(|(metadata_file_path, metadata, case_idx, case, solc_mode)| {
            Test {
                metadata: metadata.clone(),
                path: metadata_file_path.to_path_buf(),
                mode: solc_mode,
                case_idx: case_idx.into(),
                case: case.clone(),
            }
        })
        .map(async |test| test)
        .collect::<FuturesUnordered<_>>()
        .filter_map(async move |test| {
            // Check that both compilers support this test, else we skip it
            let is_supported = does_compiler_support_mode::<L>(args, &test.mode).await.ok().unwrap_or(false) &&
                does_compiler_support_mode::<F>(args, &test.mode).await.ok().unwrap_or(false);
            // We filter_map to avoid needing to clone `test`, but return it as-is.
            if is_supported {
                Some(test)
            } else {
                tracing::warn!(
                    metadata_file_path = %test.path.display(),
                    case_idx = %test.case_idx,
                    case_name = ?test.case.name,
                    mode = %test.mode,
                    "Skipping test as one or both of the compilers don't support it"
                );
                None
            }
        })
 }
 async fn does_compiler_support_mode<P: Platform>(
    args: &Arguments,
    mode: &Mode,
 ) -> anyhow::Result<bool> {
    let compiler_version_or_requirement = mode.compiler_version_to_use(args.solc.clone());
    let compiler_path =
        P::Compiler::get_compiler_executable(args, compiler_version_or_requirement).await?;
    let compiler_version = P::Compiler::new(compiler_path.clone()).version()?;
    Ok(P::Compiler::supports_mode(
        &compiler_version,
        mode.optimize_setting,
        mode.pipeline,
    ))
 }
 async fn start_driver_task<L, F>(
    args: &Arguments,
    tests: impl Stream<Item = Test>,
    span: Span,
    report_tx: mpsc::UnboundedSender<(Test, CaseResult)>,
 ) -> anyhow::Result<impl Future<Output = ()>>
 where
    L: Platform,
    F: Platform,
    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
    let leader_nodes = Arc::new(NodePool::<L::Blockchain>::new(args)?);
    let follower_nodes = Arc::new(NodePool::<F::Blockchain>::new(args)?);
    let number_concurrent_tasks = args.number_of_concurrent_tasks();
    let cached_compiler = Arc::new(
        CachedCompiler::new(
            args.directory().join("compilation_cache"),
            args.invalidate_compilation_cache,
        )
        .await?,
    );
    Ok(tests.for_each_concurrent(
        // We want to limit the concurrent tasks here because:
        //
        // 1. We don't want to overwhelm the nodes with too many requests, leading to responses timing out.
        // 2. We don't want to open too many files at once, leading to the OS running out of file descriptors.
        //
        // By default, we allow maximum of 10 ongoing requests per node in order to limit (1), and assume that
        // this number will automatically be low enough to address (2). The user can override this.
        Some(number_concurrent_tasks),
        move |test| {
            let leader_nodes = leader_nodes.clone();
            let follower_nodes = follower_nodes.clone();
            let report_tx = report_tx.clone();
            let cached_compiler = cached_compiler.clone();
            async move {
                let leader_node = leader_nodes.round_robbin();
                let follower_node = follower_nodes.round_robbin();
                let tracing_span = tracing::span!(
                    Level::INFO,
                    "Running driver",
                    metadata_file_path = %test.path.display(),
                    case_idx = ?test.case_idx,
                    solc_mode = ?test.mode,
                );
                let result = handle_case_driver::<L, F>(
                    &test.path,
                    &test.metadata,
                    test.case_idx,
                    &test.case,
                    test.mode.clone(),
                    args,
                    cached_compiler,
                    leader_node,
                    follower_node,
                    span,
                )
                .instrument(tracing_span)
                .await;
                report_tx
                    .send((test, result))
                    .expect("Failed to send report");
            }
        },
    ))
 }
 async fn start_reporter_task(mut report_rx: mpsc::UnboundedReceiver<(Test, CaseResult)>) {
    let start = Instant::now();
    const GREEN: &str = "\x1B[32m";
    const RED: &str = "\x1B[31m";
    const COLOUR_RESET: &str = "\x1B[0m";
    const BOLD: &str = "\x1B[1m";
    const BOLD_RESET: &str = "\x1B[22m";
    let mut number_of_successes = 0;
    let mut number_of_failures = 0;
    let mut failures = vec![];
    // Wait for reports to come from our test runner. When the channel closes, this ends.
    while let Some((test, case_result)) = report_rx.recv().await {
        let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
        let case_idx = test.case_idx;
        let test_path = test.path.display();
        let test_mode = test.mode.clone();
        match case_result {
            Ok(_inputs) => {
                number_of_successes += 1;
                eprintln!(
                    "{GREEN}Case Succeeded:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
                );
            }
            Err(err) => {
                number_of_failures += 1;
                eprintln!(
                    "{RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
                );
                failures.push((test, err));
            }
        }
    }
    eprintln!();
    let elapsed = start.elapsed();
    // Now, log the failures with more complete errors at the bottom, like `cargo test` does, so
    // that we don't have to scroll through the entire output to find them.
    if !failures.is_empty() {
        eprintln!("{BOLD}Failures:{BOLD_RESET}\n");
        for failure in failures {
            let (test, err) = failure;
            let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
            let case_idx = test.case_idx;
            let test_path = test.path.display();
            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"
            );
        }
    }
    // Summary at the end.
    eprintln!(
        "{} cases: {GREEN}{number_of_successes}{COLOUR_RESET} cases succeeded, {RED}{number_of_failures}{COLOUR_RESET} cases failed in {} seconds",
        number_of_successes + number_of_failures,
        elapsed.as_secs()
    );
 }
 #[allow(clippy::too_many_arguments)]
 async fn handle_case_driver<L, F>(
    metadata_file_path: &Path,
    metadata: &Metadata,
    case_idx: CaseIdx,
    case: &Case,
    mode: Mode,
    config: &Arguments,
    cached_compiler: Arc<CachedCompiler>,
    leader_node: &L::Blockchain,
    follower_node: &F::Blockchain,
    _: Span,
 ) -> anyhow::Result<usize>
 where
    L: Platform,
    F: Platform,
    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
    let leader_pre_link_contracts = cached_compiler
        .compile_contracts::<L>(metadata, metadata_file_path, &mode, config, None)
        .await?
        .0
        .contracts;
    let follower_pre_link_contracts = cached_compiler
        .compile_contracts::<F>(metadata, metadata_file_path, &mode, config, None)
        .await?
        .0
        .contracts;
    let mut leader_deployed_libraries = None::<HashMap<_, _>>;
    let mut follower_deployed_libraries = None::<HashMap<_, _>>;
    let mut contract_sources = metadata.contract_sources()?;
    for library_instance in metadata
        .libraries
        .iter()
        .flatten()
        .flat_map(|(_, map)| map.values())
    {
        let ContractPathAndIdent {
            contract_source_path: library_source_path,
            contract_ident: library_ident,
        } = contract_sources
            .remove(library_instance)
            .context("Failed to find the contract source")?;
        let (leader_code, leader_abi) = leader_pre_link_contracts
            .get(&library_source_path)
            .and_then(|contracts| contracts.get(library_ident.as_str()))
            .context("Declared library was not compiled")?;
        let (follower_code, follower_abi) = follower_pre_link_contracts
            .get(&library_source_path)
            .and_then(|contracts| contracts.get(library_ident.as_str()))
            .context("Declared library was not compiled")?;
        let leader_code = match alloy::hex::decode(leader_code) {
            Ok(code) => code,
            Err(error) => {
                tracing::error!(
                    ?error,
                    contract_source_path = library_source_path.display().to_string(),
                    contract_ident = library_ident.as_ref(),
                    "Failed to hex-decode byte code - This could possibly mean that the bytecode requires linking"
                );
                anyhow::bail!("Failed to hex-decode the byte code {}", error)
            }
        };
        let follower_code = match alloy::hex::decode(follower_code) {
            Ok(code) => code,
            Err(error) => {
                tracing::error!(
                    ?error,
                    contract_source_path = library_source_path.display().to_string(),
                    contract_ident = library_ident.as_ref(),
                    "Failed to hex-decode byte code - This could possibly mean that the bytecode requires linking"
                );
                anyhow::bail!("Failed to hex-decode the byte code {}", error)
            }
        };
        // Getting the deployer address from the cases themselves. This is to ensure that we're
        // doing the deployments from different accounts and therefore we're not slowed down by
        // the nonce.
        let deployer_address = case
            .steps
            .iter()
            .filter_map(|step| match step {
                Step::FunctionCall(input) => Some(input.caller),
                Step::BalanceAssertion(..) => None,
                Step::StorageEmptyAssertion(..) => None,
            })
            .next()
            .unwrap_or(Input::default_caller());
        let leader_tx = TransactionBuilder::<Ethereum>::with_deploy_code(
            TransactionRequest::default().from(deployer_address),
            leader_code,
        );
        let follower_tx = TransactionBuilder::<Ethereum>::with_deploy_code(
            TransactionRequest::default().from(deployer_address),
            follower_code,
        );
        let leader_receipt = match leader_node.execute_transaction(leader_tx).await {
            Ok(receipt) => receipt,
            Err(error) => {
                tracing::error!(
                    node = std::any::type_name::<L>(),
                    ?error,
                    "Contract deployment transaction failed."
                );
                return Err(error);
            }
        };
        let follower_receipt = match follower_node.execute_transaction(follower_tx).await {
            Ok(receipt) => receipt,
            Err(error) => {
                tracing::error!(
                    node = std::any::type_name::<F>(),
                    ?error,
                    "Contract deployment transaction failed."
                );
                return Err(error);
            }
        };
        tracing::info!(
            ?library_instance,
            library_address = ?leader_receipt.contract_address,
            "Deployed library to leader"
        );
        tracing::info!(
            ?library_instance,
            library_address = ?follower_receipt.contract_address,
            "Deployed library to follower"
        );
        let Some(leader_library_address) = leader_receipt.contract_address else {
            anyhow::bail!("Contract deployment didn't return an address");
        };
        let Some(follower_library_address) = follower_receipt.contract_address else {
            anyhow::bail!("Contract deployment didn't return an address");
        };
        leader_deployed_libraries.get_or_insert_default().insert(
            library_instance.clone(),
            (
                library_ident.clone(),
                leader_library_address,
                leader_abi.clone(),
            ),
        );
        follower_deployed_libraries.get_or_insert_default().insert(
            library_instance.clone(),
            (
                library_ident,
                follower_library_address,
                follower_abi.clone(),
            ),
        );
    }
    let (leader_post_link_contracts, leader_compiler_version) = cached_compiler
        .compile_contracts::<L>(
            metadata,
            metadata_file_path,
            &mode,
            config,
            leader_deployed_libraries.as_ref(),
        )
        .await?;
    let (follower_post_link_contracts, follower_compiler_version) = cached_compiler
        .compile_contracts::<F>(
            metadata,
            metadata_file_path,
            &mode,
            config,
            follower_deployed_libraries.as_ref(),
        )
        .await?;
    let leader_state = CaseState::<L>::new(
        leader_compiler_version,
        leader_post_link_contracts.contracts,
        leader_deployed_libraries.unwrap_or_default(),
    );
    let follower_state = CaseState::<F>::new(
        follower_compiler_version,
        follower_post_link_contracts.contracts,
        follower_deployed_libraries.unwrap_or_default(),
    );
    let mut driver = CaseDriver::<L, F>::new(
        metadata,
        case,
        case_idx,
        leader_node,
        follower_node,
        leader_state,
        follower_state,
    );
    driver.execute().await
 }
 async fn execute_corpus(
    args: &Arguments,
    tests: &[MetadataFile],
    span: Span,
 ) -> anyhow::Result<()> {
    match (&args.leader, &args.follower) {
        (TestingPlatform::Geth, TestingPlatform::Kitchensink) => {
-            run_driver::<Geth, Kitchensink>(args, tests, span)?
+            run_driver::<Geth, Kitchensink>(args, tests, span).await?
        }
        (TestingPlatform::Geth, TestingPlatform::Geth) => {
-            run_driver::<Geth, Geth>(args, tests, span)?
+            run_driver::<Geth, Geth>(args, tests, span).await?
        }
        _ => unimplemented!(),
    }
@@ -125,19 +628,55 @@ fn execute_corpus(args: &Arguments, tests: &[Metadata], span: Span) -> anyhow::R
    Ok(())
 }
-fn compile_corpus(config: &Arguments, tests: &[Metadata], platform: &TestingPlatform, span: Span) {
+async fn compile_corpus(
-    tests.par_iter().for_each(|metadata| {
+    config: &Arguments,
-        for mode in &metadata.solc_modes() {
+    tests: &[MetadataFile],
    platform: &TestingPlatform,
    _: Span,
 ) {
    let tests = tests.iter().flat_map(|metadata| {
        metadata
            .solc_modes()
            .into_iter()
            .map(move |solc_mode| (metadata, solc_mode))
    });
    let file = tempfile::NamedTempFile::new().expect("Failed to create temp file");
    let cached_compiler = CachedCompiler::new(file.path(), false)
        .await
        .map(Arc::new)
        .expect("Failed to create the cached compiler");
    futures::stream::iter(tests)
        .for_each_concurrent(None, |(metadata, mode)| {
            let cached_compiler = cached_compiler.clone();
            async move {
                match platform {
                    TestingPlatform::Geth => {
-                    let mut state = State::<Geth>::new(config, span);
+                        let _ = cached_compiler
-                    let _ = state.build_contracts(mode, metadata);
+                            .compile_contracts::<Geth>(
                                metadata,
                                metadata.path.as_path(),
                                &mode,
                                config,
                                None,
                            )
                            .await;
                    }
                    TestingPlatform::Kitchensink => {
-                    let mut state = State::<Kitchensink>::new(config, span);
+                        let _ = cached_compiler
-                    let _ = state.build_contracts(mode, metadata);
+                            .compile_contracts::<Kitchensink>(
                                metadata,
                                metadata.path.as_path(),
                                &mode,
                                config,
                                None,
                            )
                            .await;
                    }
            };
                }
-    });
+            }
        })
        .await;
 }
@@ -9,9 +9,19 @@ repository.workspace = true
 rust-version.workspace = true
 [dependencies]
 revive-dt-common = { workspace = true }
 revive-common = { workspace = true }
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
-log = { workspace = true }
+regex = { workspace = true }
 tracing = { workspace = true }
 semver = { workspace = true }
-serde = { workspace = true, features = [ "derive" ] }
+serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 [dev-dependencies]
 tokio = { workspace = true }
@@ -1,12 +1,75 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
-use crate::{input::Input, mode::Mode};
+use revive_dt_common::macros::define_wrapper_type;
-#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
+use crate::{
    input::{Expected, Step},
    mode::ParsedMode,
 };
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Case {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
-    pub modes: Option<Vec<Mode>>,
+
-    pub inputs: Vec<Input>,
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub modes: Option<Vec<ParsedMode>>,
    #[serde(rename = "inputs")]
    pub steps: Vec<Step>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expected: Option<Expected>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ignore: Option<bool>,
 }
 impl Case {
    #[allow(irrefutable_let_patterns)]
    pub fn steps_iterator(&self) -> impl Iterator<Item = Step> {
        let steps_len = self.steps.len();
        self.steps
            .clone()
            .into_iter()
            .enumerate()
            .map(move |(idx, mut step)| {
                let Step::FunctionCall(ref mut input) = step else {
                    return step;
                };
                if idx + 1 == steps_len {
                    if input.expected.is_none() {
                        input.expected = self.expected.clone();
                    }
                    // TODO: What does it mean for us to have an `expected` field on the case itself
                    // but the final input also has an expected field that doesn't match the one on
                    // the case? What are we supposed to do with that final expected field on the
                    // case?
                    step
                } else {
                    step
                }
            })
    }
 }
 define_wrapper_type!(
    /// A wrapper type for the index of test cases found in metadata file.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct CaseIdx(usize);
 );
 impl std::fmt::Display for CaseIdx {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
 }
@@ -3,9 +3,10 @@ use std::{
    path::{Path, PathBuf},
 };
 use revive_dt_common::cached_fs::read_dir;
 use serde::{Deserialize, Serialize};
-use crate::metadata::Metadata;
+use crate::metadata::MetadataFile;
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub struct Corpus {
@@ -17,11 +18,29 @@ impl Corpus {
    /// Try to read and parse the corpus definition file at given `path`.
    pub fn try_from_path(path: &Path) -> anyhow::Result<Self> {
        let file = File::open(path)?;
-        Ok(serde_json::from_reader(file)?)
+        let mut corpus: Corpus = serde_json::from_reader(file)?;
        // Ensure that the path mentioned in the corpus is relative to the corpus file.
        // Canonicalizing also helps make the path in any errors unambiguous.
        corpus.path = path
            .parent()
            .ok_or_else(|| {
                anyhow::anyhow!("Corpus path '{}' does not point to a file", path.display())
            })?
            .canonicalize()
            .map_err(|error| {
                anyhow::anyhow!(
                    "Failed to canonicalize path to corpus '{}': {error}",
                    path.display()
                )
            })?
            .join(corpus.path);
        Ok(corpus)
    }
    /// Scan the corpus base directory and return all tests found.
-    pub fn enumerate_tests(&self) -> Vec<Metadata> {
+    pub fn enumerate_tests(&self) -> Vec<MetadataFile> {
        let mut tests = Vec::new();
        collect_metadata(&self.path, &mut tests);
        tests
@@ -34,34 +53,47 @@ impl Corpus {
 /// Found tests are inserted into `tests`.
 ///
 /// `path` is expected to be a directory.
-pub fn collect_metadata(path: &Path, tests: &mut Vec<Metadata>) {
+pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
-    let dir_entry = match std::fs::read_dir(path) {
+    if path.is_dir() {
        let dir_entry = match read_dir(path) {
            Ok(dir_entry) => dir_entry,
            Err(error) => {
-            log::error!("failed to read dir '{}': {error}", path.display());
+                tracing::error!("failed to read dir '{}': {error}", path.display());
                return;
            }
        };
-    for entry in dir_entry {
+        for path in dir_entry {
-        let entry = match entry {
+            let path = match path {
                Ok(entry) => entry,
                Err(error) => {
-                log::error!("error reading dir entry: {error}");
+                    tracing::error!("error reading dir entry: {error}");
                    continue;
                }
            };
        let path = entry.path();
            if path.is_dir() {
                collect_metadata(&path, tests);
                continue;
            }
            if path.is_file() {
-            if let Some(metadata) = Metadata::try_from_file(&path) {
+                if let Some(metadata) = MetadataFile::try_from_file(&path) {
                    tests.push(metadata)
                }
            }
        }
    } else {
        let Some(extension) = path.extension() else {
            tracing::error!("Failed to get file extension");
            return;
        };
        if extension.eq_ignore_ascii_case("sol") || extension.eq_ignore_ascii_case("json") {
            if let Some(metadata) = MetadataFile::try_from_file(path) {
                tests.push(metadata)
            }
        } else {
            tracing::error!(?extension, "Unsupported file extension");
        }
    }
 }
@@ -5,3 +5,4 @@ pub mod corpus;
 pub mod input;
 pub mod metadata;
 pub mod mode;
 pub mod traits;
@@ -1,46 +1,95 @@
 use std::{
    cmp::Ordering,
    collections::BTreeMap,
-    fs::{File, read_to_string},
+    fmt::Display,
    fs::File,
    ops::Deref,
    path::{Path, PathBuf},
    str::FromStr,
 };
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
-use crate::{
+use revive_common::EVMVersion;
-    case::Case,
+use revive_dt_common::{
-    mode::{Mode, SolcMode},
+    cached_fs::read_to_string, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
    types::Mode,
 };
 use crate::{case::Case, mode::ParsedMode};
 pub const METADATA_FILE_EXTENSION: &str = "json";
 pub const SOLIDITY_CASE_FILE_EXTENSION: &str = "sol";
 pub const SOLIDITY_CASE_COMMENT_MARKER: &str = "//!";
 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct MetadataFile {
    pub path: PathBuf,
    pub content: Metadata,
 }
 impl MetadataFile {
    pub fn try_from_file(path: &Path) -> Option<Self> {
        Metadata::try_from_file(path).map(|metadata| Self {
            path: path.to_owned(),
            content: metadata,
        })
    }
 }
 impl Deref for MetadataFile {
    type Target = Metadata;
    fn deref(&self) -> &Self::Target {
        &self.content
    }
 }
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Metadata {
-    pub cases: Vec<Case>,
+    /// A comment on the test case that's added for human-readability.
-    pub contracts: Option<BTreeMap<String, String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
-    pub libraries: Option<BTreeMap<String, BTreeMap<String, String>>>,
+    pub comment: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ignore: Option<bool>,
-    pub modes: Option<Vec<Mode>>,
+
    #[serde(skip_serializing_if = "Option::is_none")]
    pub targets: Option<Vec<String>>,
    pub cases: Vec<Case>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdent>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modes: Option<Vec<ParsedMode>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_path: Option<PathBuf>,
    /// This field specifies an EVM version requirement that the test case has where the test might
    /// be run of the evm version of the nodes match the evm version specified here.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub required_evm_version: Option<EvmVersionRequirement>,
    /// A set of compilation directives that will be passed to the compiler whenever the contracts for
    /// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
    /// just a filter for when a test can run whereas this is an instruction to the compiler.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub compiler_directives: Option<CompilationDirectives>,
 }
 impl Metadata {
-    /// Returns the solc modes of this metadata, inserting a default mode if not present.
+    /// Returns the modes that we should test from this metadata.
-    pub fn solc_modes(&self) -> Vec<SolcMode> {
+    pub fn solc_modes(&self) -> Vec<Mode> {
-        self.modes
+        match &self.modes {
-            .to_owned()
+            Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
-            .unwrap_or_else(|| vec![Mode::Solidity(Default::default())])
+            None => Mode::all().collect(),
            .iter()
            .filter_map(|mode| match mode {
                Mode::Solidity(solc_mode) => Some(solc_mode),
                Mode::Unknown(mode) => {
                    log::debug!("compiler: ignoring unknown mode '{mode}'");
                    None
        }
            })
            .cloned()
            .collect()
    }
    /// Returns the base directory of this metadata.
@@ -53,28 +102,35 @@ impl Metadata {
            .to_path_buf())
    }
-    /// Extract the contract sources.
+    /// Returns the contract sources with canonicalized paths for the files
-    ///
+    pub fn contract_sources(
-    /// Returns a mapping of contract IDs to their source path and contract name.
+        &self,
-    pub fn contract_sources(&self) -> anyhow::Result<BTreeMap<String, (PathBuf, String)>> {
+    ) -> anyhow::Result<BTreeMap<ContractInstance, ContractPathAndIdent>> {
        let directory = self.directory()?;
        let mut sources = BTreeMap::new();
        let Some(contracts) = &self.contracts else {
            return Ok(sources);
        };
-        for (id, contract) in contracts {
+        for (
-            // TODO: broken if a colon is in the dir name..
+            alias,
-            let mut parts = contract.split(':');
+            ContractPathAndIdent {
-            let (Some(file_name), Some(contract_name)) = (parts.next(), parts.next()) else {
+                contract_source_path,
-                anyhow::bail!("metadata contains invalid contract: {contract}");
+                contract_ident,
-            };
+            },
-            let file = directory.to_path_buf().join(file_name);
+        ) in contracts
-            if !file.is_file() {
+        {
-                anyhow::bail!("contract {id} is not a file: {}", file.display());
+            let alias = alias.clone();
-            }
+            let absolute_path = directory.join(contract_source_path).canonicalize()?;
            let contract_ident = contract_ident.clone();
-            sources.insert(id.clone(), (file, contract_name.to_string()));
+            sources.insert(
                alias,
                ContractPathAndIdent {
                    contract_source_path: absolute_path,
                    contract_ident,
                },
            );
        }
        Ok(sources)
@@ -90,7 +146,7 @@ impl Metadata {
        assert!(path.is_file(), "not a file: {}", path.display());
        let Some(file_extension) = path.extension() else {
-            log::debug!("skipping corpus file: {}", path.display());
+            tracing::debug!("skipping corpus file: {}", path.display());
            return None;
        };
@@ -102,14 +158,14 @@ impl Metadata {
            return Self::try_from_solidity(path);
        }
-        log::debug!("ignoring invalid corpus file: {}", path.display());
+        tracing::debug!("ignoring invalid corpus file: {}", path.display());
        None
    }
    fn try_from_json(path: &Path) -> Option<Self> {
        let file = File::open(path)
            .inspect_err(|error| {
-                log::error!(
+                tracing::error!(
                    "opening JSON test metadata file '{}' error: {error}",
                    path.display()
                );
@@ -122,7 +178,7 @@ impl Metadata {
                Some(metadata)
            }
            Err(error) => {
-                log::error!(
+                tracing::error!(
                    "parsing JSON test metadata file '{}' error: {error}",
                    path.display()
                );
@@ -134,7 +190,7 @@ impl Metadata {
    fn try_from_solidity(path: &Path) -> Option<Self> {
        let spec = read_to_string(path)
            .inspect_err(|error| {
-                log::error!(
+                tracing::error!(
                    "opening JSON test metadata file '{}' error: {error}",
                    path.display()
                );
@@ -154,16 +210,20 @@ impl Metadata {
        match serde_json::from_str::<Self>(&spec) {
            Ok(mut metadata) => {
                metadata.file_path = Some(path.to_path_buf());
-                let name = path
+                metadata.contracts = Some(
-                    .file_name()
+                    [(
-                    .expect("this should be the path to a Solidity file")
+                        ContractInstance::new("Test"),
-                    .to_str()
+                        ContractPathAndIdent {
-                    .expect("the file name should be valid UTF-8k");
+                            contract_source_path: path.to_path_buf(),
-                metadata.contracts = Some([(String::from("Test"), format!("{name}:Test"))].into());
+                            contract_ident: ContractIdent::new("Test"),
                        },
                    )]
                    .into(),
                );
                Some(metadata)
            }
            Err(error) => {
-                log::error!(
+                tracing::error!(
                    "parsing Solidity test metadata file '{}' error: '{error}' from data: {spec}",
                    path.display()
                );
@@ -171,4 +231,325 @@ impl Metadata {
            }
        }
    }
    /// Returns an iterator over all of the solidity files that needs to be compiled for this
    /// [`Metadata`] object
    ///
    /// Note: if the metadata is contained within a solidity file then this is the only file that
    /// we wish to compile since this is a self-contained test. Otherwise, if it's a JSON file
    /// then we need to compile all of the contracts that are in the directory since imports are
    /// allowed in there.
    pub fn files_to_compile(&self) -> anyhow::Result<Box<dyn Iterator<Item = PathBuf>>> {
        let Some(ref metadata_file_path) = self.file_path else {
            anyhow::bail!("The metadata file path is not defined");
        };
        if metadata_file_path
            .extension()
            .is_some_and(|extension| extension.eq_ignore_ascii_case("sol"))
        {
            Ok(Box::new(std::iter::once(metadata_file_path.clone())))
        } else {
            Ok(Box::new(
                FilesWithExtensionIterator::new(self.directory()?)
                    .with_allowed_extension("sol")
                    .with_use_cached_fs(true),
            ))
        }
    }
 }
 define_wrapper_type!(
    /// Represents a contract instance found a metadata file.
    ///
    /// Typically, this is used as the key to the "contracts" field of metadata files.
    #[derive(
        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
    )]
    #[serde(transparent)]
    pub struct ContractInstance(String);
 );
 define_wrapper_type!(
    /// Represents a contract identifier found a metadata file.
    ///
    /// A contract identifier is the name of the contract in the source code.
    #[derive(
        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
    )]
    #[serde(transparent)]
    pub struct ContractIdent(String);
 );
 /// Represents an identifier used for contracts.
 ///
 /// The type supports serialization from and into the following string format:
 ///
 /// ```text
 /// ${path}:${contract_ident}
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 #[serde(try_from = "String", into = "String")]
 pub struct ContractPathAndIdent {
    /// The path of the contract source code relative to the directory containing the metadata file.
    pub contract_source_path: PathBuf,
    /// The identifier of the contract.
    pub contract_ident: ContractIdent,
 }
 impl Display for ContractPathAndIdent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}:{}",
            self.contract_source_path.display(),
            self.contract_ident.as_ref()
        )
    }
 }
 impl FromStr for ContractPathAndIdent {
    type Err = anyhow::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let mut splitted_string = s.split(":").peekable();
        let mut path = None::<String>;
        let mut identifier = None::<String>;
        loop {
            let Some(next_item) = splitted_string.next() else {
                break;
            };
            if splitted_string.peek().is_some() {
                match path {
                    Some(ref mut path) => {
                        path.push(':');
                        path.push_str(next_item);
                    }
                    None => path = Some(next_item.to_owned()),
                }
            } else {
                identifier = Some(next_item.to_owned())
            }
        }
        match (path, identifier) {
            (Some(path), Some(identifier)) => Ok(Self {
                contract_source_path: PathBuf::from(path),
                contract_ident: ContractIdent::new(identifier),
            }),
            (None, Some(path)) | (Some(path), None) => {
                let Some(identifier) = path.split(".").next().map(ToOwned::to_owned) else {
                    anyhow::bail!("Failed to find identifier");
                };
                Ok(Self {
                    contract_source_path: PathBuf::from(path),
                    contract_ident: ContractIdent::new(identifier),
                })
            }
            (None, None) => anyhow::bail!("Failed to find the path and identifier"),
        }
    }
 }
 impl TryFrom<String> for ContractPathAndIdent {
    type Error = anyhow::Error;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        Self::from_str(&value)
    }
 }
 impl From<ContractPathAndIdent> for String {
    fn from(value: ContractPathAndIdent) -> Self {
        value.to_string()
    }
 }
 /// An EVM version requirement that the test case has. This gets serialized and
 /// deserialized from and into [`String`].
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 #[serde(try_from = "String", into = "String")]
 pub struct EvmVersionRequirement {
    ordering: Ordering,
    or_equal: bool,
    evm_version: EVMVersion,
 }
 impl EvmVersionRequirement {
    pub fn new_greater_than_or_equals(version: EVMVersion) -> Self {
        Self {
            ordering: Ordering::Greater,
            or_equal: true,
            evm_version: version,
        }
    }
    pub fn new_greater_than(version: EVMVersion) -> Self {
        Self {
            ordering: Ordering::Greater,
            or_equal: false,
            evm_version: version,
        }
    }
    pub fn new_equals(version: EVMVersion) -> Self {
        Self {
            ordering: Ordering::Equal,
            or_equal: false,
            evm_version: version,
        }
    }
    pub fn new_less_than(version: EVMVersion) -> Self {
        Self {
            ordering: Ordering::Less,
            or_equal: false,
            evm_version: version,
        }
    }
    pub fn new_less_than_or_equals(version: EVMVersion) -> Self {
        Self {
            ordering: Ordering::Less,
            or_equal: true,
            evm_version: version,
        }
    }
    pub fn matches(&self, other: &EVMVersion) -> bool {
        let ordering = other.cmp(&self.evm_version);
        ordering == self.ordering || (self.or_equal && matches!(ordering, Ordering::Equal))
    }
 }
 impl Display for EvmVersionRequirement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let Self {
            ordering,
            or_equal,
            evm_version,
        } = self;
        match ordering {
            Ordering::Less => write!(f, "<")?,
            Ordering::Equal => write!(f, "=")?,
            Ordering::Greater => write!(f, ">")?,
        }
        if *or_equal && !matches!(ordering, Ordering::Equal) {
            write!(f, "=")?;
        }
        write!(f, "{evm_version}")
    }
 }
 impl FromStr for EvmVersionRequirement {
    type Err = anyhow::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.as_bytes() {
            [b'>', b'=', remaining @ ..] => Ok(Self {
                ordering: Ordering::Greater,
                or_equal: true,
                evm_version: str::from_utf8(remaining)?.try_into()?,
            }),
            [b'>', remaining @ ..] => Ok(Self {
                ordering: Ordering::Greater,
                or_equal: false,
                evm_version: str::from_utf8(remaining)?.try_into()?,
            }),
            [b'<', b'=', remaining @ ..] => Ok(Self {
                ordering: Ordering::Less,
                or_equal: true,
                evm_version: str::from_utf8(remaining)?.try_into()?,
            }),
            [b'<', remaining @ ..] => Ok(Self {
                ordering: Ordering::Less,
                or_equal: false,
                evm_version: str::from_utf8(remaining)?.try_into()?,
            }),
            [b'=', remaining @ ..] => Ok(Self {
                ordering: Ordering::Equal,
                or_equal: false,
                evm_version: str::from_utf8(remaining)?.try_into()?,
            }),
            _ => anyhow::bail!("Invalid EVM version requirement {s}"),
        }
    }
 }
 impl TryFrom<String> for EvmVersionRequirement {
    type Error = anyhow::Error;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        value.parse()
    }
 }
 impl From<EvmVersionRequirement> for String {
    fn from(value: EvmVersionRequirement) -> Self {
        value.to_string()
    }
 }
 /// A set of compilation directives that will be passed to the compiler whenever the contracts for
 /// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
 /// just a filter for when a test can run whereas this is an instruction to the compiler.
 /// Defines how the compiler should handle revert strings.
 #[derive(
    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
 )]
 pub struct CompilationDirectives {
    /// Defines how the revert strings should be handled.
    pub revert_string_handling: Option<RevertString>,
 }
 /// Defines how the compiler should handle revert strings.
 #[derive(
    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
 )]
 #[serde(rename_all = "camelCase")]
 pub enum RevertString {
    #[default]
    Default,
    Debug,
    Strip,
    VerboseDebug,
 }
 #[cfg(test)]
 mod test {
    use super::*;
    #[test]
    fn contract_identifier_respects_roundtrip_property() {
        // Arrange
        let string = "ERC20/ERC20.sol:ERC20";
        // Act
        let identifier = ContractPathAndIdent::from_str(string);
        // Assert
        let identifier = identifier.expect("Failed to parse");
        assert_eq!(
            identifier.contract_source_path.display().to_string(),
            "ERC20/ERC20.sol"
        );
        assert_eq!(identifier.contract_ident, "ERC20".to_owned().into());
        // Act
        let reserialized = identifier.to_string();
        // Assert
        assert_eq!(string, reserialized);
    }
    #[test]
    fn complex_metadata_file_can_be_deserialized() {
        // Arrange
        const JSON: &str = include_str!("../../../assets/test_metadata.json");
        // Act
        let metadata = serde_json::from_str::<Metadata>(JSON);
        // Assert
        metadata.expect("Failed to deserialize metadata");
    }
 }
@@ -1,96 +1,262 @@
-use semver::Version;
+use regex::Regex;
-use serde::de::Deserializer;
+use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::fmt::Display;
 use std::str::FromStr;
 use std::sync::LazyLock;
-/// Specifies the compilation mode of the test artifact.
+/// This represents a mode that has been parsed from test metadata.
-#[derive(Hash, Debug, Clone, Eq, PartialEq)]
+///
-pub enum Mode {
+/// Mode strings can take the following form (in pseudo-regex):
-    Solidity(SolcMode),
+///
-    Unknown(String),
+/// ```text
 /// [YEILV][+-]? (M[0123sz])? <semver>?
 /// ```
 ///
 /// We can parse valid mode strings into [`ParsedMode`] using [`ParsedMode::from_str`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
 #[serde(try_from = "String", into = "String")]
 pub struct ParsedMode {
    pub pipeline: Option<ModePipeline>,
    pub optimize_flag: Option<bool>,
    pub optimize_setting: Option<ModeOptimizerSetting>,
    pub version: Option<semver::VersionReq>,
 }
-/// Specify Solidity specific compiler options.
+impl FromStr for ParsedMode {
-#[derive(Hash, Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
+    type Err = anyhow::Error;
-pub struct SolcMode {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
-    pub solc_version: Option<semver::VersionReq>,
+        static REGEX: LazyLock<Regex> = LazyLock::new(|| {
-    solc_optimize: Option<bool>,
+            Regex::new(r"(?x)
-    pub llvm_optimizer_settings: Vec<String>,
+                ^
-}
+                (?:(?P<pipeline>[YEILV])(?P<optimize_flag>[+-])?)? # Pipeline to use eg Y, E+, E-
                \s*
                (?P<optimize_setting>M[a-zA-Z0-9])?                # Optimize setting eg M0, Ms, Mz
                \s*
                (?P<version>[>=<]*\d+(?:\.\d+)*)?                  # Optional semver version eg >=0.8.0, 0.7, <0.8
                $
            ").unwrap()
        });
-impl SolcMode {
+        let Some(caps) = REGEX.captures(s) else {
-    /// Try to parse a mode string into a solc mode.
+            anyhow::bail!("Cannot parse mode '{s}' from string");
    /// Returns `None` if the string wasn't a solc YUL mode string.
    ///
    /// The mode string is expected to start with the `Y` ID (YUL ID),
    /// optionally followed by `+` or `-` for the solc optimizer settings.
    ///
    /// Options can be separated by a whitespace contain the following
    /// - A solc `SemVer version requirement` string
    /// - One or more `-OX` where X is a supposed to be an LLVM opt mode
    pub fn parse_from_mode_string(mode_string: &str) -> Option<Self> {
        let mut result = Self::default();
        let mut parts = mode_string.trim().split(" ");
        match parts.next()? {
            "Y" => {}
            "Y+" => result.solc_optimize = Some(true),
            "Y-" => result.solc_optimize = Some(false),
            _ => return None,
        }
        for part in parts {
            if let Ok(solc_version) = semver::VersionReq::parse(part) {
                result.solc_version = Some(solc_version);
                continue;
            }
            if let Some(level) = part.strip_prefix("-O") {
                result.llvm_optimizer_settings.push(level.to_string());
                continue;
            }
            panic!("the YUL mode string {mode_string} failed to parse, invalid part: {part}")
        }
        Some(result)
    }
    /// Returns whether to enable the solc optimizer.
    pub fn solc_optimize(&self) -> bool {
        self.solc_optimize.unwrap_or(true)
    }
    /// Calculate the latest matching solc patch version. Returns:
    /// - `latest_supported` if no version request was specified.
    /// - A matching version with the same minor version as `latest_supported`, if any.
    /// - `None` if no minor version of the `latest_supported` version matches.
    pub fn last_patch_version(&self, latest_supported: &Version) -> Option<Version> {
        let Some(version_req) = self.solc_version.as_ref() else {
            return Some(latest_supported.to_owned());
        };
-        // lgtm
+        let pipeline = match caps.name("pipeline") {
-        for patch in (0..latest_supported.patch + 1).rev() {
+            Some(m) => Some(ModePipeline::from_str(m.as_str())?),
-            let version = Version::new(0, latest_supported.minor, patch);
+            None => None,
-            if version_req.matches(&version) {
+        };
                return Some(version);
            }
        }
-        None
+        let optimize_flag = caps.name("optimize_flag").map(|m| m.as_str() == "+");
        let optimize_setting = match caps.name("optimize_setting") {
            Some(m) => Some(ModeOptimizerSetting::from_str(m.as_str())?),
            None => None,
        };
        let version = match caps.name("version") {
            Some(m) => Some(semver::VersionReq::parse(m.as_str()).map_err(|e| {
                anyhow::anyhow!("Cannot parse the version requirement '{}': {e}", m.as_str())
            })?),
            None => None,
        };
        Ok(ParsedMode {
            pipeline,
            optimize_flag,
            optimize_setting,
            version,
        })
    }
 }
-impl<'de> Deserialize<'de> for Mode {
+impl Display for ParsedMode {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    where
+        let mut has_written = false;
        D: Deserializer<'de>,
    {
        let mode_string = String::deserialize(deserializer)?;
-        if let Some(solc_mode) = SolcMode::parse_from_mode_string(&mode_string) {
+        if let Some(pipeline) = self.pipeline {
-            return Ok(Self::Solidity(solc_mode));
+            pipeline.fmt(f)?;
            if let Some(optimize_flag) = self.optimize_flag {
                f.write_str(if optimize_flag { "+" } else { "-" })?;
            }
            has_written = true;
        }
-        Ok(Self::Unknown(mode_string))
+        if let Some(optimize_setting) = self.optimize_setting {
            if has_written {
                f.write_str(" ")?;
            }
            optimize_setting.fmt(f)?;
            has_written = true;
        }
        if let Some(version) = &self.version {
            if has_written {
                f.write_str(" ")?;
            }
            version.fmt(f)?;
        }
        Ok(())
    }
 }
 impl From<ParsedMode> for String {
    fn from(parsed_mode: ParsedMode) -> Self {
        parsed_mode.to_string()
    }
 }
 impl TryFrom<String> for ParsedMode {
    type Error = anyhow::Error;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        ParsedMode::from_str(&value)
    }
 }
 impl ParsedMode {
    /// This takes a [`ParsedMode`] and expands it into a list of [`Mode`]s that we should try.
    pub fn to_modes(&self) -> impl Iterator<Item = Mode> {
        let pipeline_iter = self.pipeline.as_ref().map_or_else(
            || EitherIter::A(ModePipeline::test_cases()),
            |p| EitherIter::B(std::iter::once(*p)),
        );
        let optimize_flag_setting = self.optimize_flag.map(|flag| {
            if flag {
                ModeOptimizerSetting::M3
            } else {
                ModeOptimizerSetting::M0
            }
        });
        let optimize_flag_iter = match optimize_flag_setting {
            Some(setting) => EitherIter::A(std::iter::once(setting)),
            None => EitherIter::B(ModeOptimizerSetting::test_cases()),
        };
        let optimize_settings_iter = self.optimize_setting.as_ref().map_or_else(
            || EitherIter::A(optimize_flag_iter),
            |s| EitherIter::B(std::iter::once(*s)),
        );
        pipeline_iter.flat_map(move |pipeline| {
            optimize_settings_iter
                .clone()
                .map(move |optimize_setting| Mode {
                    pipeline,
                    optimize_setting,
                    version: self.version.clone(),
                })
        })
    }
    /// Return a set of [`Mode`]s that correspond to the given [`ParsedMode`]s.
    /// This avoids any duplicate entries.
    pub fn many_to_modes<'a>(
        parsed: impl Iterator<Item = &'a ParsedMode>,
    ) -> impl Iterator<Item = Mode> {
        let modes: HashSet<_> = parsed.flat_map(|p| p.to_modes()).collect();
        modes.into_iter()
    }
 }
 /// An iterator that could be either of two iterators.
 #[derive(Clone, Debug)]
 enum EitherIter<A, B> {
    A(A),
    B(B),
 }
 impl<A, B> Iterator for EitherIter<A, B>
 where
    A: Iterator,
    B: Iterator<Item = A::Item>,
 {
    type Item = A::Item;
    fn next(&mut self) -> Option<Self::Item> {
        match self {
            EitherIter::A(iter) => iter.next(),
            EitherIter::B(iter) => iter.next(),
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn test_parsed_mode_from_str() {
        let strings = vec![
            ("Mz", "Mz"),
            ("Y", "Y"),
            ("Y+", "Y+"),
            ("Y-", "Y-"),
            ("E", "E"),
            ("E+", "E+"),
            ("E-", "E-"),
            ("Y M0", "Y M0"),
            ("Y M1", "Y M1"),
            ("Y M2", "Y M2"),
            ("Y M3", "Y M3"),
            ("Y Ms", "Y Ms"),
            ("Y Mz", "Y Mz"),
            ("E M0", "E M0"),
            ("E M1", "E M1"),
            ("E M2", "E M2"),
            ("E M3", "E M3"),
            ("E Ms", "E Ms"),
            ("E Mz", "E Mz"),
            // When stringifying semver again, 0.8.0 becomes ^0.8.0 (same meaning)
            ("Y 0.8.0", "Y ^0.8.0"),
            ("E+ 0.8.0", "E+ ^0.8.0"),
            ("Y M3 >=0.8.0", "Y M3 >=0.8.0"),
            ("E Mz <0.7.0", "E Mz <0.7.0"),
            // We can parse +- _and_ M1/M2 but the latter takes priority.
            ("Y+ M1 0.8.0", "Y+ M1 ^0.8.0"),
            ("E- M2 0.7.0", "E- M2 ^0.7.0"),
            // We don't see this in the wild but it is parsed.
            ("<=0.8", "<=0.8"),
        ];
        for (actual, expected) in strings {
            let parsed = ParsedMode::from_str(actual)
                .expect(format!("Failed to parse mode string '{actual}'").as_str());
            assert_eq!(
                expected,
                parsed.to_string(),
                "Mode string '{actual}' did not parse to '{expected}': got '{parsed}'"
            );
        }
    }
    #[test]
    fn test_parsed_mode_to_test_modes() {
        let strings = vec![
            ("Mz", vec!["Y Mz", "E Mz"]),
            ("Y", vec!["Y M0", "Y M3"]),
            ("E", vec!["E M0", "E M3"]),
            ("Y+", vec!["Y M3"]),
            ("Y-", vec!["Y M0"]),
            ("Y <=0.8", vec!["Y M0 <=0.8", "Y M3 <=0.8"]),
            (
                "<=0.8",
                vec!["Y M0 <=0.8", "Y M3 <=0.8", "E M0 <=0.8", "E M3 <=0.8"],
            ),
        ];
        for (actual, expected) in strings {
            let parsed = ParsedMode::from_str(actual)
                .expect(format!("Failed to parse mode string '{actual}'").as_str());
            let expected_set: HashSet<_> = expected.into_iter().map(|s| s.to_owned()).collect();
            let actual_set: HashSet<_> = parsed.to_modes().map(|m| m.to_string()).collect();
            assert_eq!(
                expected_set, actual_set,
                "Mode string '{actual}' did not expand to '{expected_set:?}': got '{actual_set:?}'"
            );
        }
    }
 }
@@ -0,0 +1,157 @@
 use std::collections::HashMap;
 use alloy::eips::BlockNumberOrTag;
 use alloy::json_abi::JsonAbi;
 use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
 use alloy_primitives::TxHash;
 use anyhow::Result;
 use crate::metadata::{ContractIdent, ContractInstance};
 /// A trait of the interface are required to implement to be used by the resolution logic that this
 /// crate implements to go from string calldata and into the bytes calldata.
 pub trait ResolverApi {
    /// Returns the ID of the chain that the node is on.
    fn chain_id(&self) -> impl Future<Output = Result<ChainId>>;
    /// Returns the gas price for the specified transaction.
    fn transaction_gas_price(&self, tx_hash: &TxHash) -> impl Future<Output = Result<u128>>;
    // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
    // when we implement the changes to the gas we need to adjust this to be a u64.
    /// Returns the gas limit of the specified block.
    fn block_gas_limit(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<u128>>;
    /// Returns the coinbase of the specified block.
    fn block_coinbase(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<Address>>;
    /// Returns the difficulty of the specified block.
    fn block_difficulty(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<U256>>;
    /// Returns the base fee of the specified block.
    fn block_base_fee(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<u64>>;
    /// Returns the hash of the specified block.
    fn block_hash(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<BlockHash>>;
    /// Returns the timestamp of the specified block,
    fn block_timestamp(
        &self,
        number: BlockNumberOrTag,
    ) -> impl Future<Output = Result<BlockTimestamp>>;
    /// Returns the number of the last block.
    fn last_block_number(&self) -> impl Future<Output = Result<BlockNumber>>;
 }
 #[derive(Clone, Copy, Debug, Default)]
 /// Contextual information required by the code that's performing the resolution.
 pub struct ResolutionContext<'a> {
    /// When provided the contracts provided here will be used for resolutions.
    deployed_contracts: Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
    /// When provided the variables in here will be used for performing resolutions.
    variables: Option<&'a HashMap<String, U256>>,
    /// When provided this block number will be treated as the tip of the chain.
    block_number: Option<&'a BlockNumber>,
    /// When provided the resolver will use this transaction hash for all of its resolutions.
    transaction_hash: Option<&'a TxHash>,
 }
 impl<'a> ResolutionContext<'a> {
    pub fn new() -> Self {
        Default::default()
    }
    pub fn new_from_parts(
        deployed_contracts: impl Into<
            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
        >,
        variables: impl Into<Option<&'a HashMap<String, U256>>>,
        block_number: impl Into<Option<&'a BlockNumber>>,
        transaction_hash: impl Into<Option<&'a TxHash>>,
    ) -> Self {
        Self {
            deployed_contracts: deployed_contracts.into(),
            variables: variables.into(),
            block_number: block_number.into(),
            transaction_hash: transaction_hash.into(),
        }
    }
    pub fn with_deployed_contracts(
        mut self,
        deployed_contracts: impl Into<
            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
        >,
    ) -> Self {
        self.deployed_contracts = deployed_contracts.into();
        self
    }
    pub fn with_variables(
        mut self,
        variables: impl Into<Option<&'a HashMap<String, U256>>>,
    ) -> Self {
        self.variables = variables.into();
        self
    }
    pub fn with_block_number(mut self, block_number: impl Into<Option<&'a BlockNumber>>) -> Self {
        self.block_number = block_number.into();
        self
    }
    pub fn with_transaction_hash(
        mut self,
        transaction_hash: impl Into<Option<&'a TxHash>>,
    ) -> Self {
        self.transaction_hash = transaction_hash.into();
        self
    }
    pub fn resolve_block_number(&self, number: BlockNumberOrTag) -> BlockNumberOrTag {
        match self.block_number {
            Some(block_number) => match number {
                BlockNumberOrTag::Latest => BlockNumberOrTag::Number(*block_number),
                n @ (BlockNumberOrTag::Finalized
                | BlockNumberOrTag::Safe
                | BlockNumberOrTag::Earliest
                | BlockNumberOrTag::Pending
                | BlockNumberOrTag::Number(_)) => n,
            },
            None => number,
        }
    }
    pub fn deployed_contract(
        &self,
        instance: &ContractInstance,
    ) -> Option<&(ContractIdent, Address, JsonAbi)> {
        self.deployed_contracts
            .and_then(|deployed_contracts| deployed_contracts.get(instance))
    }
    pub fn deployed_contract_address(&self, instance: &ContractInstance) -> Option<&Address> {
        self.deployed_contract(instance).map(|(_, a, _)| a)
    }
    pub fn deployed_contract_abi(&self, instance: &ContractInstance) -> Option<&JsonAbi> {
        self.deployed_contract(instance).map(|(_, _, a)| a)
    }
    pub fn variable(&self, name: impl AsRef<str>) -> Option<&U256> {
        self.variables
            .and_then(|variables| variables.get(name.as_ref()))
    }
    pub fn tip_block_number(&self) -> Option<&'a BlockNumber> {
        self.block_number
    }
    pub fn transaction_hash(&self) -> Option<&'a TxHash> {
        self.transaction_hash
    }
 }
@@ -11,6 +11,3 @@ rust-version.workspace = true
 [dependencies]
 alloy = { workspace = true }
 anyhow = { workspace = true }
 log = { workspace = true }
 once_cell = { workspace = true }
 tokio = { workspace = true }
@@ -1,14 +1,9 @@
 //! This crate implements all node interactions.
-use alloy::primitives::Address;
+use alloy::primitives::{Address, StorageKey, U256};
-use alloy::rpc::types::trace::geth::{DiffMode, GethTrace};
+use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
-use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
+use alloy::rpc::types::{EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest};
-use tokio_runtime::TO_TOKIO;
+use anyhow::Result;
 pub mod nonce;
 mod tokio_runtime;
 pub mod trace;
 pub mod transaction;
 /// An interface for all interactions with Ethereum compatible nodes.
 pub trait EthereumNode {
@@ -16,14 +11,25 @@ pub trait EthereumNode {
    fn execute_transaction(
        &self,
        transaction: TransactionRequest,
-    ) -> anyhow::Result<TransactionReceipt>;
+    ) -> impl Future<Output = Result<TransactionReceipt>>;
    /// Trace the transaction in the [TransactionReceipt] and return a [GethTrace].
-    fn trace_transaction(&self, transaction: TransactionReceipt) -> anyhow::Result<GethTrace>;
+    fn trace_transaction(
        &self,
        receipt: &TransactionReceipt,
        trace_options: GethDebugTracingOptions,
    ) -> impl Future<Output = Result<GethTrace>>;
    /// Returns the state diff of the transaction hash in the [TransactionReceipt].
-    fn state_diff(&self, transaction: TransactionReceipt) -> anyhow::Result<DiffMode>;
+    fn state_diff(&self, receipt: &TransactionReceipt) -> impl Future<Output = Result<DiffMode>>;
-    /// Returns the next available nonce for the given [Address].
+    /// Returns the balance of the provided [`Address`] back.
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64>;
+    fn balance_of(&self, address: Address) -> impl Future<Output = Result<U256>>;
    /// Returns the latest storage proof of the provided [`Address`]
    fn latest_state_proof(
        &self,
        address: Address,
        keys: Vec<StorageKey>,
    ) -> impl Future<Output = Result<EIP1186AccountProofResponse>>;
 }
@@ -1,55 +0,0 @@
 use std::pin::Pin;
 use alloy::{
    primitives::Address,
    providers::{Provider, ProviderBuilder},
 };
 use tokio::sync::oneshot;
 use crate::{TO_TOKIO, tokio_runtime::AsyncNodeInteraction};
 pub type Task = Pin<Box<dyn Future<Output = anyhow::Result<u64>> + Send>>;
 pub(crate) struct Nonce {
    sender: oneshot::Sender<anyhow::Result<u64>>,
    task: Task,
 }
 impl AsyncNodeInteraction for Nonce {
    type Output = anyhow::Result<u64>;
    fn split(
        self,
    ) -> (
        std::pin::Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    ) {
        (self.task, self.sender)
    }
 }
 /// This is like `trace_transaction`, just for nonces.
 pub fn fetch_onchain_nonce(
    connection: String,
    wallet: alloy::network::EthereumWallet,
    address: Address,
 ) -> anyhow::Result<u64> {
    let sender = TO_TOKIO.lock().unwrap().nonce_sender.clone();
    let (tx, rx) = oneshot::channel();
    let task: Task = Box::pin(async move {
        let provider = ProviderBuilder::new()
            .wallet(wallet)
            .connect(&connection)
            .await?;
        let onchain = provider.get_transaction_count(address).await?;
        Ok(onchain)
    });
    sender
        .blocking_send(Nonce { task, sender: tx })
        .expect("not in async context");
    rx.blocking_recv()
        .unwrap_or_else(|err| anyhow::bail!("nonce fetch failed: {err}"))
 }
@@ -1,87 +0,0 @@
 //! The alloy crate __requires__ a tokio runtime.
 //! We contain any async rust right here.
 use once_cell::sync::Lazy;
 use std::pin::Pin;
 use std::sync::Mutex;
 use std::thread;
 use tokio::runtime::Runtime;
 use tokio::spawn;
 use tokio::sync::{mpsc, oneshot};
 use tokio::task::JoinError;
 use crate::nonce::Nonce;
 use crate::trace::Trace;
 use crate::transaction::Transaction;
 pub(crate) static TO_TOKIO: Lazy<Mutex<TokioRuntime>> =
    Lazy::new(|| Mutex::new(TokioRuntime::spawn()));
 /// Common interface for executing async node interactions from a non-async context.
 #[allow(clippy::type_complexity)]
 pub(crate) trait AsyncNodeInteraction: Send + 'static {
    type Output: Send;
    //// Returns the task and the output sender.
    fn split(
        self,
    ) -> (
        Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    );
 }
 pub(crate) struct TokioRuntime {
    pub(crate) transaction_sender: mpsc::Sender<Transaction>,
    pub(crate) trace_sender: mpsc::Sender<Trace>,
    pub(crate) nonce_sender: mpsc::Sender<Nonce>,
 }
 impl TokioRuntime {
    fn spawn() -> Self {
        let rt = Runtime::new().expect("should be able to create the tokio runtime");
        let (transaction_sender, transaction_receiver) = mpsc::channel::<Transaction>(1024);
        let (trace_sender, trace_receiver) = mpsc::channel::<Trace>(1024);
        let (nonce_sender, nonce_receiver) = mpsc::channel::<Nonce>(1024);
        thread::spawn(move || {
            rt.block_on(async move {
                let transaction_task = spawn(interaction::<Transaction>(transaction_receiver));
                let trace_task = spawn(interaction::<Trace>(trace_receiver));
                let nonce_task = spawn(interaction::<Nonce>(nonce_receiver));
                if let Err(error) = transaction_task.await {
                    log::error!("tokio transaction task failed: {error}");
                }
                if let Err(error) = trace_task.await {
                    log::error!("tokio trace transaction task failed: {error}");
                }
                if let Err(error) = nonce_task.await {
                    log::error!("tokio nonce task failed: {error}");
                }
            });
        });
        Self {
            transaction_sender,
            trace_sender,
            nonce_sender,
        }
    }
 }
 async fn interaction<T>(mut receiver: mpsc::Receiver<T>) -> Result<(), JoinError>
 where
    T: AsyncNodeInteraction,
 {
    while let Some(task) = receiver.recv().await {
        spawn(async move {
            let (task, sender) = task.split();
            sender
                .send(task.await)
                .unwrap_or_else(|_| panic!("failed to send task output"));
        });
    }
    Ok(())
 }
@@ -1,43 +0,0 @@
 //! Trace transactions in a sync context.
 use std::pin::Pin;
 use alloy::rpc::types::trace::geth::GethTrace;
 use tokio::sync::oneshot;
 use crate::TO_TOKIO;
 use crate::tokio_runtime::AsyncNodeInteraction;
 pub type Task = Pin<Box<dyn Future<Output = anyhow::Result<GethTrace>> + Send>>;
 pub(crate) struct Trace {
    sender: oneshot::Sender<anyhow::Result<GethTrace>>,
    task: Task,
 }
 impl AsyncNodeInteraction for Trace {
    type Output = anyhow::Result<GethTrace>;
    fn split(
        self,
    ) -> (
        std::pin::Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    ) {
        (self.task, self.sender)
    }
 }
 /// Execute some [Task] that return a [GethTrace] result.
 pub fn trace_transaction(task: Task) -> anyhow::Result<GethTrace> {
    let task_sender = TO_TOKIO.lock().unwrap().trace_sender.clone();
    let (sender, receiver) = oneshot::channel();
    task_sender
        .blocking_send(Trace { task, sender })
        .expect("we are not calling this from an async context");
    receiver
        .blocking_recv()
        .unwrap_or_else(|error| anyhow::bail!("no trace received: {error}"))
 }
@@ -1,46 +0,0 @@
 //! Execute transactions in a sync context.
 use std::pin::Pin;
 use alloy::rpc::types::TransactionReceipt;
 use tokio::sync::oneshot;
 use crate::TO_TOKIO;
 use crate::tokio_runtime::AsyncNodeInteraction;
 pub type Task = Pin<Box<dyn Future<Output = anyhow::Result<TransactionReceipt>> + Send>>;
 pub(crate) struct Transaction {
    receipt_sender: oneshot::Sender<anyhow::Result<TransactionReceipt>>,
    task: Task,
 }
 impl AsyncNodeInteraction for Transaction {
    type Output = anyhow::Result<TransactionReceipt>;
    fn split(
        self,
    ) -> (
        Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    ) {
        (self.task, self.receipt_sender)
    }
 }
 /// Execute some [Task] that returns a [TransactionReceipt].
 pub fn execute_transaction(task: Task) -> anyhow::Result<TransactionReceipt> {
    let request_sender = TO_TOKIO.lock().unwrap().transaction_sender.clone();
    let (receipt_sender, receipt_receiver) = oneshot::channel();
    request_sender
        .blocking_send(Transaction {
            receipt_sender,
            task,
        })
        .expect("we are not calling this from an async context");
    receipt_receiver
        .blocking_recv()
        .unwrap_or_else(|error| anyhow::bail!("no receipt received: {error}"))
 }
@@ -11,11 +11,16 @@ rust-version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 alloy = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 tokio = { workspace = true }
-revive-dt-node-interaction = { workspace = true }
+revive-common = { workspace = true }
 revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
 revive-dt-node-interaction = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 sp-core = { workspace = true }
@@ -23,3 +28,4 @@ sp-runtime = { workspace = true }
 [dev-dependencies]
 temp-dir = { workspace = true }
 tokio = { workspace = true }
@@ -0,0 +1,78 @@
 use alloy::{
    network::{Network, TransactionBuilder},
    providers::{
        Provider, SendableTx,
        fillers::{GasFiller, TxFiller},
    },
    transports::TransportResult,
 };
 #[derive(Clone, Debug)]
 pub struct FallbackGasFiller {
    inner: GasFiller,
    default_gas_limit: u64,
    default_max_fee_per_gas: u128,
    default_priority_fee: u128,
 }
 impl FallbackGasFiller {
    pub fn new(
        default_gas_limit: u64,
        default_max_fee_per_gas: u128,
        default_priority_fee: u128,
    ) -> Self {
        Self {
            inner: GasFiller,
            default_gas_limit,
            default_max_fee_per_gas,
            default_priority_fee,
        }
    }
 }
 impl<N> TxFiller<N> for FallbackGasFiller
 where
    N: Network,
 {
    type Fillable = Option<<GasFiller as TxFiller<N>>::Fillable>;
    fn status(
        &self,
        tx: &<N as Network>::TransactionRequest,
    ) -> alloy::providers::fillers::FillerControlFlow {
        <GasFiller as TxFiller<N>>::status(&self.inner, tx)
    }
    fn fill_sync(&self, _: &mut alloy::providers::SendableTx<N>) {}
    async fn prepare<P: Provider<N>>(
        &self,
        provider: &P,
        tx: &<N as Network>::TransactionRequest,
    ) -> TransportResult<Self::Fillable> {
        // Try to fetch GasFiller’s “fillable” (gas_price, base_fee, estimate_gas, …)
        // If it errors (i.e. tx would revert under eth_estimateGas), swallow it.
        match self.inner.prepare(provider, tx).await {
            Ok(fill) => Ok(Some(fill)),
            Err(_) => Ok(None),
        }
    }
    async fn fill(
        &self,
        fillable: Self::Fillable,
        mut tx: alloy::providers::SendableTx<N>,
    ) -> TransportResult<SendableTx<N>> {
        if let Some(fill) = fillable {
            // our inner GasFiller succeeded — use it
            self.inner.fill(fill, tx).await
        } else {
            if let Some(builder) = tx.as_mut_builder() {
                builder.set_gas_limit(self.default_gas_limit);
                builder.set_max_fee_per_gas(self.default_max_fee_per_gas);
                builder.set_max_priority_fee_per_gas(self.default_priority_fee);
            }
            Ok(tx)
        }
    }
 }
@@ -0,0 +1,5 @@
 /// This constant defines how much Wei accounts are pre-seeded with in genesis.
 ///
 /// Note: After changing this number, check that the tests for kitchensink work as we encountered
 /// some issues with different values of the initial balance on Kitchensink.
 pub const INITIAL_BALANCE: u128 = 10u128.pow(37);
@@ -1,34 +1,46 @@
 //! The go-ethereum node implementation.
 use std::{
-    fs::{File, create_dir_all, remove_dir_all},
+    fs::{File, OpenOptions, create_dir_all, remove_dir_all},
    io::{BufRead, BufReader, Read, Write},
    ops::ControlFlow,
    path::PathBuf,
    process::{Child, Command, Stdio},
    sync::{
-        Mutex,
+        Arc,
        atomic::{AtomicU32, Ordering},
    },
    thread,
    time::{Duration, Instant},
 };
 use alloy::{
-    network::EthereumWallet,
+    eips::BlockNumberOrTag,
-    primitives::{Address, map::HashMap},
+    genesis::{Genesis, GenesisAccount},
-    providers::{Provider, ProviderBuilder, ext::DebugApi},
+    network::{Ethereum, EthereumWallet, NetworkWallet},
    primitives::{
        Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, StorageKey, TxHash, U256,
    },
    providers::{
        Provider, ProviderBuilder,
        ext::DebugApi,
        fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
    },
    rpc::types::{
-        TransactionReceipt, TransactionRequest,
+        EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
        trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
    },
    signers::local::PrivateKeySigner,
 };
-use revive_dt_config::Arguments;
+use anyhow::Context;
-use revive_dt_node_interaction::{
+use revive_common::EVMVersion;
-    EthereumNode, nonce::fetch_onchain_nonce, trace::trace_transaction,
+use tracing::{Instrument, Level};
    transaction::execute_transaction,
 };
-use crate::Node;
+use revive_dt_common::{fs::clear_directory, futures::poll};
 use revive_dt_config::Arguments;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::EthereumNode;
 use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
@@ -40,22 +52,28 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
-pub struct Instance {
+pub struct GethNode {
    connection_string: String,
    base_directory: PathBuf,
    data_directory: PathBuf,
    logs_directory: PathBuf,
    geth: PathBuf,
    id: u32,
    handle: Option<Child>,
    network_id: u64,
    start_timeout: u64,
    wallet: EthereumWallet,
-    nonces: Mutex<HashMap<Address, u64>>,
+    nonce_manager: CachedNonceManager,
    /// This vector stores [`File`] objects that we use for logging which we want to flush when the
    /// node object is dropped. We do not store them in a structured fashion at the moment (in
    /// separate fields) as the logic that we need to apply to them is all the same regardless of
    /// what it belongs to, we just want to flush them on [`Drop`] of the node.
    logs_file_to_flush: Vec<File>,
 }
-impl Instance {
+impl GethNode {
    const BASE_DIRECTORY: &str = "geth";
    const DATA_DIRECTORY: &str = "data";
    const LOGS_DIRECTORY: &str = "logs";
    const IPC_FILE: &str = "geth.ipc";
    const GENESIS_JSON_FILE: &str = "genesis.json";
@@ -63,14 +81,41 @@ impl Instance {
    const READY_MARKER: &str = "IPC endpoint opened";
    const ERROR_MARKER: &str = "Fatal:";
-    /// Create the node directory and call `geth init` to configure the genesis.
+    const GETH_STDOUT_LOG_FILE_NAME: &str = "node_stdout.log";
-    fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
+    const GETH_STDERR_LOG_FILE_NAME: &str = "node_stderr.log";
        create_dir_all(&self.base_directory)?;
    const TRANSACTION_INDEXING_ERROR: &str = "transaction indexing is in progress";
    const TRANSACTION_TRACING_ERROR: &str = "historical state not available in path scheme yet";
    const RECEIPT_POLLING_DURATION: Duration = Duration::from_secs(5 * 60);
    const TRACE_POLLING_DURATION: Duration = Duration::from_secs(60);
    /// Create the node directory and call `geth init` to configure the genesis.
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
        let _ = clear_directory(&self.base_directory);
        let _ = clear_directory(&self.logs_directory);
        create_dir_all(&self.base_directory)?;
        create_dir_all(&self.logs_directory)?;
        let mut genesis = serde_json::from_str::<Genesis>(&genesis)?;
        for signer_address in
            <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
        {
            // Note, the use of the entry API here means that we only modify the entries for any
            // account that is not in the `alloc` field of the genesis state.
            genesis
                .alloc
                .entry(signer_address)
                .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
        }
        let genesis_path = self.base_directory.join(Self::GENESIS_JSON_FILE);
-        File::create(&genesis_path)?.write_all(genesis.as_bytes())?;
+        serde_json::to_writer(File::create(&genesis_path)?, &genesis)?;
        let mut child = Command::new(&self.geth)
            .arg("--state.scheme")
            .arg("hash")
            .arg("init")
            .arg("--datadir")
            .arg(&self.data_directory)
@@ -95,109 +140,238 @@ impl Instance {
    /// Spawn the go-ethereum node child process.
    ///
-    /// [Instance::init] must be called priorly.
+    /// [Instance::init] must be called prior.
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn spawn_process(&mut self) -> anyhow::Result<&mut Self> {
        // This is the `OpenOptions` that we wish to use for all of the log files that we will be
        // opening in this method. We need to construct it in this way to:
        // 1. Be consistent
        // 2. Less verbose and more dry
        // 3. Because the builder pattern uses mutable references so we need to get around that.
        let open_options = {
            let mut options = OpenOptions::new();
            options.create(true).truncate(true).write(true);
            options
        };
        let stdout_logs_file = open_options
            .clone()
            .open(self.geth_stdout_log_file_path())?;
        let stderr_logs_file = open_options.open(self.geth_stderr_log_file_path())?;
        self.handle = Command::new(&self.geth)
            .arg("--dev")
            .arg("--datadir")
            .arg(&self.data_directory)
            .arg("--ipcpath")
            .arg(&self.connection_string)
            .arg("--networkid")
            .arg(self.network_id.to_string())
            .arg("--nodiscover")
            .arg("--maxpeers")
            .arg("0")
-            .stderr(Stdio::piped())
+            .arg("--txlookuplimit")
-            .stdout(Stdio::null())
+            .arg("0")
            .arg("--cache.blocklogs")
            .arg("512")
            .arg("--state.scheme")
            .arg("hash")
            .arg("--syncmode")
            .arg("full")
            .arg("--gcmode")
            .arg("archive")
            .stderr(stderr_logs_file.try_clone()?)
            .stdout(stdout_logs_file.try_clone()?)
            .spawn()?
            .into();
        if let Err(error) = self.wait_ready() {
            tracing::error!(?error, "Failed to start geth, shutting down gracefully");
            self.shutdown()?;
            return Err(error);
        }
        self.logs_file_to_flush
            .extend([stderr_logs_file, stdout_logs_file]);
        Ok(self)
    }
    /// Wait for the g-ethereum node child process getting ready.
    ///
    /// [Instance::spawn_process] must be called priorly.
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn wait_ready(&mut self) -> anyhow::Result<&mut Self> {
        // Thanks clippy but geth is a server; we don't `wait` but eventually kill it.
        #[allow(clippy::zombie_processes)]
        let mut child = self.handle.take().expect("should be spawned");
        let start_time = Instant::now();
        let logs_file = OpenOptions::new()
            .read(true)
            .write(false)
            .append(false)
            .truncate(false)
            .open(self.geth_stderr_log_file_path())?;
        let maximum_wait_time = Duration::from_millis(self.start_timeout);
-        let mut stderr = BufReader::new(child.stderr.take().expect("should be piped")).lines();
+        let mut stderr = BufReader::new(logs_file).lines();
-        let error = loop {
+        let mut lines = vec![];
-            let Some(Ok(line)) = stderr.next() else {
+        loop {
-                break "child process stderr reading error".to_string();
+            if let Some(Ok(line)) = stderr.next() {
            };
                if line.contains(Self::ERROR_MARKER) {
-                break line;
+                    anyhow::bail!("Failed to start geth {line}");
                }
                if line.contains(Self::READY_MARKER) {
                // Keep stderr alive
                // https://github.com/alloy-rs/alloy/issues/2091#issuecomment-2676134147
                thread::spawn(move || for _ in stderr.by_ref() {});
                self.handle = child.into();
                    return Ok(self);
                }
                lines.push(line);
            }
            if Instant::now().duration_since(start_time) > maximum_wait_time {
-                break "spawn timeout".to_string();
+                anyhow::bail!(
                    "Timeout in starting geth: took longer than {}ms. stdout:\n\n{}\n",
                    self.start_timeout,
                    lines.join("\n")
                );
            }
        }
        };
        let _ = child.kill();
        anyhow::bail!("geth node #{} spawn error: {error}", self.id)
    }
 }
-impl EthereumNode for Instance {
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
-    fn execute_transaction(
+    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)]
    fn geth_stderr_log_file_path(&self) -> PathBuf {
        self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
    }
    fn provider(
        &self,
-        transaction: TransactionRequest,
+    ) -> impl Future<
-    ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
+        Output = anyhow::Result<
            FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>,
        >,
    > + 'static {
        let connection_string = self.connection_string();
        let wallet = self.wallet.clone();
-        execute_transaction(Box::pin(async move {
+        // Note: We would like all providers to make use of the same nonce manager so that we have
-            Ok(ProviderBuilder::new()
+        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
        // its implementation and therefore it means that when we clone it then it still references
        // the same state.
        let nonce_manager = self.nonce_manager.clone();
        Box::pin(async move {
            ProviderBuilder::new()
                .disable_recommended_fillers()
                .filler(FallbackGasFiller::new(
                    25_000_000,
                    1_000_000_000,
                    1_000_000_000,
                ))
                .filler(ChainIdFiller::default())
                .filler(NonceFiller::new(nonce_manager))
                .wallet(wallet)
                .connect(&connection_string)
-                .await?
+                .await
-                .send_transaction(transaction)
+                .map_err(Into::into)
-                .await?
+        })
-                .get_receipt()
+    }
-                .await?)
+}
-        }))
+
 impl EthereumNode for GethNode {
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn execute_transaction(
        &self,
        transaction: TransactionRequest,
    ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
        let provider = Arc::new(self.provider().await?);
        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
        // used 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
        // it has been indexed. When we call alloy's `get_receipt` it checks if the transaction
        // was confirmed. If it has been, then it will call `eth_getTransactionReceipt` method
        // which _might_ return the above error if the tx has not yet been indexed yet. So, we
        // need to implement a retry mechanism for the receipt to keep retrying to get it until
        // it 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
        // only allowed for 60 seconds of waiting with a 1 second delay in polling, we need to
        // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
        // with exponential backoff each time we attempt to get the receipt and find that it's
        // not available.
        poll(
            Self::RECEIPT_POLLING_DURATION,
            Default::default(),
            move || {
                let provider = provider.clone();
                async move {
                    match provider.get_transaction_receipt(transaction_hash).await {
                        Ok(Some(receipt)) => Ok(ControlFlow::Break(receipt)),
                        Ok(None) => Ok(ControlFlow::Continue(())),
                        Err(error) => {
                            let error_string = error.to_string();
                            match error_string.contains(Self::TRANSACTION_INDEXING_ERROR) {
                                true => Ok(ControlFlow::Continue(())),
                                false => Err(error.into()),
                            }
                        }
                    }
                }
            },
        )
        .instrument(tracing::info_span!(
            "Awaiting transaction receipt",
            ?transaction_hash
        ))
        .await
    }
-    fn trace_transaction(
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn trace_transaction(
        &self,
-        transaction: TransactionReceipt,
+        transaction: &TransactionReceipt,
        trace_options: GethDebugTracingOptions,
    ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let connection_string = self.connection_string();
+        let provider = Arc::new(self.provider().await?);
        poll(
            Self::TRACE_POLLING_DURATION,
            Default::default(),
            move || {
                let provider = provider.clone();
                let trace_options = trace_options.clone();
                async move {
                    match provider
                        .debug_trace_transaction(transaction.transaction_hash, trace_options)
                        .await
                    {
                        Ok(trace) => Ok(ControlFlow::Break(trace)),
                        Err(error) => {
                            let error_string = error.to_string();
                            match error_string.contains(Self::TRANSACTION_TRACING_ERROR) {
                                true => Ok(ControlFlow::Continue(())),
                                false => Err(error.into()),
                            }
                        }
                    }
                }
            },
        )
        .await
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
            diff_mode: Some(true),
            disable_code: None,
            disable_storage: None,
        });
        let wallet = self.wallet.clone();
        trace_transaction(Box::pin(async move {
            Ok(ProviderBuilder::new()
                .wallet(wallet)
                .connect(&connection_string)
                .await?
                .debug_trace_transaction(transaction.transaction_hash, trace_options)
                .await?)
        }))
    }
    fn state_diff(
        &self,
        transaction: alloy::rpc::types::TransactionReceipt,
    ) -> anyhow::Result<DiffMode> {
        match self
-            .trace_transaction(transaction)?
+            .trace_transaction(transaction, trace_options)
            .await?
            .try_into_pre_state_frame()?
        {
            PreStateFrame::Diff(diff) => Ok(diff),
@@ -205,53 +379,191 @@ impl EthereumNode for Instance {
        }
    }
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64> {
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
-        let connection_string = self.connection_string.clone();
+    async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
-        let wallet = self.wallet.clone();
+        self.provider()
            .await?
            .get_balance(address)
            .await
            .map_err(Into::into)
    }
-        let onchain_nonce = fetch_onchain_nonce(connection_string, wallet, address)?;
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
-
+    async fn latest_state_proof(
-        let mut nonces = self.nonces.lock().unwrap();
+        &self,
-        let current = nonces.entry(address).or_insert(onchain_nonce);
+        address: Address,
-        let value = *current;
+        keys: Vec<StorageKey>,
-        *current += 1;
+    ) -> anyhow::Result<EIP1186AccountProofResponse> {
-        Ok(value)
+        self.provider()
            .await?
            .get_proof(address, keys)
            .latest()
            .await
            .map_err(Into::into)
    }
 }
-impl Node for Instance {
+impl ResolverApi for GethNode {
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
        self.provider()
            .await?
            .get_chain_id()
            .await
            .map_err(Into::into)
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
        self.provider()
            .await?
            .get_transaction_receipt(*tx_hash)
            .await?
            .context("Failed to get the transaction receipt")
            .map(|receipt| receipt.effective_gas_price)
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
        self.provider()
            .await?
            .get_block_by_number(number)
            .await?
            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
            .map(|block| block.header.gas_limit as _)
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
        self.provider()
            .await?
            .get_block_by_number(number)
            .await?
            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
            .map(|block| block.header.beneficiary)
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
        self.provider()
            .await?
            .get_block_by_number(number)
            .await?
            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
        self.provider()
            .await?
            .get_block_by_number(number)
            .await?
            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
            .and_then(|block| {
                block
                    .header
                    .base_fee_per_gas
                    .context("Failed to get the base fee per gas")
            })
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
        self.provider()
            .await?
            .get_block_by_number(number)
            .await?
            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
            .map(|block| block.header.hash)
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
        self.provider()
            .await?
            .get_block_by_number(number)
            .await?
            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
            .map(|block| block.header.timestamp)
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
        self.provider()
            .await?
            .get_block_number()
            .await
            .map_err(Into::into)
    }
 }
 impl Node for GethNode {
    fn new(config: &Arguments) -> Self {
        let geth_directory = config.directory().join(Self::BASE_DIRECTORY);
        let id = NODE_COUNT.fetch_add(1, Ordering::SeqCst);
        let base_directory = geth_directory.join(id.to_string());
        let mut wallet = config.wallet();
        for signer in (1..=config.private_keys_to_add)
            .map(|id| U256::from(id))
            .map(|id| id.to_be_bytes::<32>())
            .map(|id| PrivateKeySigner::from_bytes(&FixedBytes(id)).unwrap())
        {
            wallet.register_signer(signer);
        }
        Self {
            connection_string: base_directory.join(Self::IPC_FILE).display().to_string(),
            data_directory: base_directory.join(Self::DATA_DIRECTORY),
            logs_directory: base_directory.join(Self::LOGS_DIRECTORY),
            base_directory,
            geth: config.geth.clone(),
            id,
            handle: None,
            network_id: config.network_id,
            start_timeout: config.geth_start_timeout,
-            wallet: config.wallet(),
+            wallet,
-            nonces: Mutex::new(HashMap::new()),
+            // We know that we only need to be storing 2 files so we can specify that when creating
            // the vector. It's the stdout and stderr of the geth node.
            logs_file_to_flush: Vec::with_capacity(2),
            nonce_manager: Default::default(),
        }
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn connection_string(&self) -> String {
        self.connection_string.clone()
    }
-    fn shutdown(self) -> anyhow::Result<()> {
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    fn shutdown(&mut self) -> anyhow::Result<()> {
        // Terminate the processes in a graceful manner to allow for the output to be flushed.
        if let Some(mut child) = self.handle.take() {
            child
                .kill()
                .map_err(|error| anyhow::anyhow!("Failed to kill the geth process: {error:?}"))?;
        }
        // Flushing the files that we're using for keeping the logs before shutdown.
        for file in self.logs_file_to_flush.iter_mut() {
            file.flush()?
        }
        // Remove the node's database so that subsequent runs do not run on the same database. We
        // ignore the error just in case the directory didn't exist in the first place and therefore
        // there's nothing to be deleted.
        let _ = remove_dir_all(self.base_directory.join(Self::DATA_DIRECTORY));
        Ok(())
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
-        self.init(genesis)?.spawn_process()?.wait_ready()?;
+        self.init(genesis)?.spawn_process()?;
        Ok(())
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    fn version(&self) -> anyhow::Result<String> {
        let output = Command::new(&self.geth)
            .arg("--version")
@@ -263,27 +575,36 @@ impl Node for Instance {
            .stdout;
        Ok(String::from_utf8_lossy(&output).into())
    }
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn matches_target(&self, targets: Option<&[String]>) -> bool {
        match targets {
            None => true,
            Some(targets) => targets.iter().any(|str| str.as_str() == "evm"),
        }
    }
    fn evm_version() -> EVMVersion {
        EVMVersion::Cancun
    }
 }
-impl Drop for Instance {
+impl Drop for GethNode {
    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn drop(&mut self) {
-        if let Some(child) = self.handle.as_mut() {
+        self.shutdown().expect("Failed to shutdown")
            let _ = child.kill();
        }
        if self.base_directory.exists() {
            let _ = remove_dir_all(&self.base_directory);
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use revive_dt_config::Arguments;
    use temp_dir::TempDir;
    use crate::{GENESIS_JSON, Node};
-    use super::Instance;
+    use super::*;
    fn test_config() -> (Arguments, TempDir) {
        let mut config = Arguments::default();
@@ -293,26 +614,125 @@ mod tests {
        (config, temp_dir)
    }
    fn new_node() -> (GethNode, TempDir) {
        let (args, temp_dir) = test_config();
        let mut node = GethNode::new(&args);
        node.init(GENESIS_JSON.to_owned())
            .expect("Failed to initialize the node")
            .spawn_process()
            .expect("Failed to spawn the node process");
        (node, temp_dir)
    }
    #[test]
    fn init_works() {
-        Instance::new(&test_config().0)
+        GethNode::new(&test_config().0)
            .init(GENESIS_JSON.to_string())
            .unwrap();
    }
    #[test]
    fn spawn_works() {
-        Instance::new(&test_config().0)
+        GethNode::new(&test_config().0)
            .spawn(GENESIS_JSON.to_string())
            .unwrap();
    }
    #[test]
    fn version_works() {
-        let version = Instance::new(&test_config().0).version().unwrap();
+        let version = GethNode::new(&test_config().0).version().unwrap();
        assert!(
            version.starts_with("geth version"),
            "expected version string, got: '{version}'"
        );
    }
    #[tokio::test]
    async fn can_get_chain_id_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let chain_id = node.chain_id().await;
        // Assert
        let chain_id = chain_id.expect("Failed to get the chain id");
        assert_eq!(chain_id, 420_420_420);
    }
    #[tokio::test]
    async fn can_get_gas_limit_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let gas_limit = node.block_gas_limit(BlockNumberOrTag::Latest).await;
        // Assert
        let gas_limit = gas_limit.expect("Failed to get the gas limit");
        assert_eq!(gas_limit, u32::MAX as u128)
    }
    #[tokio::test]
    async fn can_get_coinbase_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let coinbase = node.block_coinbase(BlockNumberOrTag::Latest).await;
        // Assert
        let coinbase = coinbase.expect("Failed to get the coinbase");
        assert_eq!(coinbase, Address::new([0xFF; 20]))
    }
    #[tokio::test]
    async fn can_get_block_difficulty_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let block_difficulty = node.block_difficulty(BlockNumberOrTag::Latest).await;
        // Assert
        let block_difficulty = block_difficulty.expect("Failed to get the block difficulty");
        assert_eq!(block_difficulty, U256::ZERO)
    }
    #[tokio::test]
    async fn can_get_block_hash_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let block_hash = node.block_hash(BlockNumberOrTag::Latest).await;
        // Assert
        let _ = block_hash.expect("Failed to get the block hash");
    }
    #[tokio::test]
    async fn can_get_block_timestamp_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let block_timestamp = node.block_timestamp(BlockNumberOrTag::Latest).await;
        // Assert
        let _ = block_timestamp.expect("Failed to get the block timestamp");
    }
    #[tokio::test]
    async fn can_get_block_number_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let block_number = node.last_block_number().await;
        // Assert
        let block_number = block_number.expect("Failed to get the block number");
        assert_eq!(block_number, 0)
    }
 }
@@ -1,8 +1,11 @@
 //! This crate implements the testing nodes.
 use revive_common::EVMVersion;
 use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;
 pub mod common;
 pub mod constants;
 pub mod geth;
 pub mod kitchensink;
 pub mod pool;
@@ -23,11 +26,18 @@ pub trait Node: EthereumNode {
    /// Prune the node instance and related data.
    ///
    /// Blocking until it's completely stopped.
-    fn shutdown(self) -> anyhow::Result<()>;
+    fn shutdown(&mut self) -> anyhow::Result<()>;
    /// Returns the nodes connection string.
    fn connection_string(&self) -> String;
    /// Returns the node version.
    fn version(&self) -> anyhow::Result<String>;
    /// Given a list of targets from the metadata file, this function determines if the metadata
    /// file can be ran on this node or not.
    fn matches_target(&self, targets: Option<&[String]>) -> bool;
    /// Returns the EVM version of the node.
    fn evm_version() -> EVMVersion;
 }
@@ -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;
@@ -24,7 +25,7 @@ where
 {
    /// Create a new Pool. This will start as many nodes as there are workers in `config`.
    pub fn new(config: &Arguments) -> anyhow::Result<Self> {
-        let nodes = config.workers;
+        let nodes = config.number_of_nodes;
        let genesis = read_to_string(&config.genesis_file).context(format!(
            "can not read genesis file: {}",
            config.genesis_file.display()
@@ -62,7 +63,7 @@ where
 fn spawn_node<T: Node + Send>(args: &Arguments, genesis: String) -> anyhow::Result<T> {
    let mut node = T::new(args);
-    log::info!("starting node: {}", node.connection_string());
+    tracing::info!("starting node: {}", node.connection_string());
    node.spawn(genesis)?;
    Ok(node)
 }
@@ -8,12 +8,12 @@ repository.workspace = true
 rust-version.workspace = true
 [dependencies]
 revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
 revive-dt-compiler = { workspace = true }
 anyhow = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 revive-solc-json-interface = { workspace = true }
@@ -1,5 +1,6 @@
 //! The report analyzer enriches the raw report data.
 use revive_dt_compiler::CompilerOutput;
 use serde::{Deserialize, Serialize};
 use crate::reporter::CompilationTask;
@@ -13,41 +14,27 @@ pub struct CompilerStatistics {
    pub mean_code_size: usize,
    /// The mean size of the optimized YUL IR.
    pub mean_yul_size: usize,
-    /// Is a proxy because the YUL also containes a lot of comments.
+    /// Is a proxy because the YUL also contains a lot of comments.
    pub yul_to_bytecode_size_ratio: f32,
 }
 impl CompilerStatistics {
    /// Cumulatively update the statistics with the next compiler task.
    pub fn sample(&mut self, compilation_task: &CompilationTask) {
-        let Some(output) = &compilation_task.json_output else {
+        let Some(CompilerOutput { contracts }) = &compilation_task.json_output else {
            return;
        };
        let Some(contracts) = &output.contracts else {
            return;
        };
        for (_solidity, contracts) in contracts.iter() {
-            for (_name, contract) in contracts.iter() {
+            for (_name, (bytecode, _)) in contracts.iter() {
                let Some(evm) = &contract.evm else {
                    continue;
                };
                let Some(deploy_code) = &evm.deployed_bytecode else {
                    continue;
                };
                // The EVM bytecode can be unlinked and thus is not necessarily a decodable hex
                // string; for our statistics this is a good enough approximation.
-                let bytecode_size = deploy_code.object.len() / 2;
+                let bytecode_size = bytecode.len() / 2;
-                let yul_size = contract
+                // TODO: for the time being we set the yul_size to be zero. We need to change this
-                    .ir_optimized
+                // when we overhaul the reporting.
                    .as_ref()
                    .expect("if the contract has a deploy code it should also have the opimized IR")
                    .len();
-                self.update_sizes(bytecode_size, yul_size);
+                self.update_sizes(bytecode_size, 0);
            }
        }
    }
@@ -12,18 +12,19 @@ use std::{
 };
 use anyhow::Context;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use revive_dt_common::types::Mode;
 use revive_dt_compiler::{CompilerInput, CompilerOutput};
 use revive_dt_config::{Arguments, TestingPlatform};
-use revive_dt_format::{corpus::Corpus, mode::SolcMode};
+use revive_dt_format::corpus::Corpus;
 use revive_solc_json_interface::{SolcStandardJsonInput, SolcStandardJsonOutput};
 use crate::analyzer::CompilerStatistics;
 pub(crate) static REPORTER: OnceLock<Mutex<Report>> = OnceLock::new();
 /// The `Report` datastructure stores all relevant inforamtion required for generating reports.
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize)]
 pub struct Report {
    /// The configuration used during the test.
    pub config: Arguments,
@@ -41,14 +42,14 @@ pub struct Report {
 }
 /// Contains a compiled contract.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct CompilationTask {
    /// The observed compiler input.
-    pub json_input: SolcStandardJsonInput,
+    pub json_input: CompilerInput,
    /// The observed compiler output.
-    pub json_output: Option<SolcStandardJsonOutput>,
+    pub json_output: Option<CompilerOutput>,
    /// The observed compiler mode.
-    pub mode: SolcMode,
+    pub mode: Mode,
    /// The observed compiler version.
    pub compiler_version: String,
    /// The observed error, if any.
@@ -56,7 +57,7 @@ pub struct CompilationTask {
 }
 /// Represents a report about a compilation task.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct CompilationResult {
    /// The observed compilation task.
    pub compilation_task: CompilationTask,
@@ -65,7 +66,7 @@ pub struct CompilationResult {
 }
 /// The [Span] struct indicates the context of what is being reported.
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize)]
 pub struct Span {
    /// The corpus index this belongs to.
    corpus: usize,
@@ -152,15 +153,7 @@ impl Report {
        for (platform, results) in self.compiler_results.iter() {
            for result in results {
                // ignore if there were no errors
-                if result.compilation_task.error.is_none()
+                if result.compilation_task.error.is_none() {
                    && result
                        .compilation_task
                        .json_output
                        .as_ref()
                        .and_then(|output| output.errors.as_ref())
                        .map(|errors| errors.is_empty())
                        .unwrap_or(true)
                {
                    continue;
                }
@@ -192,7 +185,7 @@ impl Report {
        let file = File::create(&path).context(path.display().to_string())?;
        serde_json::to_writer_pretty(file, &self)?;
-        log::info!("report written to: {}", path.display());
+        tracing::info!("report written to: {}", path.display());
        Ok(())
    }
@@ -9,9 +9,12 @@ repository.workspace = true
 rust-version.workspace = true
 [dependencies]
 revive-dt-common = { workspace = true }
 anyhow = { workspace = true }
 hex = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 tokio = { workspace = true }
 reqwest = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
@@ -6,41 +6,43 @@ use std::{
    io::{BufWriter, Write},
    os::unix::fs::PermissionsExt,
    path::{Path, PathBuf},
-    sync::{LazyLock, Mutex},
+    sync::LazyLock,
 };
-use crate::download::GHDownloader;
+use tokio::sync::Mutex;
 use crate::download::SolcDownloader;
 pub const SOLC_CACHE_DIRECTORY: &str = "solc";
 pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
-pub(crate) fn get_or_download(
+pub(crate) async fn get_or_download(
    working_directory: &Path,
-    downloader: &GHDownloader,
+    downloader: &SolcDownloader,
 ) -> anyhow::Result<PathBuf> {
    let target_directory = working_directory
        .join(SOLC_CACHE_DIRECTORY)
        .join(downloader.version.to_string());
    let target_file = target_directory.join(downloader.target);
-    let mut cache = SOLC_CACHER.lock().unwrap();
+    let mut cache = SOLC_CACHER.lock().await;
    if cache.contains(&target_file) {
-        log::debug!("using cached solc: {}", target_file.display());
+        tracing::debug!("using cached solc: {}", target_file.display());
        return Ok(target_file);
    }
    create_dir_all(target_directory)?;
-    download_to_file(&target_file, downloader)?;
+    download_to_file(&target_file, downloader).await?;
    cache.insert(target_file.clone());
    Ok(target_file)
 }
-fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()> {
+async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::Result<()> {
-    log::info!("caching file: {}", path.display());
+    tracing::info!("caching file: {}", path.display());
    let Ok(file) = File::create_new(path) else {
-        log::debug!("cache file already exists: {}", path.display());
+        tracing::debug!("cache file already exists: {}", path.display());
        return Ok(());
    };
@@ -52,7 +54,7 @@ fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()
    }
    let mut file = BufWriter::new(file);
-    file.write_all(&downloader.download()?)?;
+    file.write_all(&downloader.download().await?)?;
    file.flush()?;
    drop(file);
@@ -5,6 +5,8 @@ use std::{
    sync::{LazyLock, Mutex},
 };
 use revive_dt_common::types::VersionOrRequirement;
 use semver::Version;
 use sha2::{Digest, Sha256};
@@ -23,12 +25,12 @@ impl List {
    ///
    /// Caches the list retrieved from the `url` into [LIST_CACHE],
    /// subsequent calls with the same `url` will return the cached list.
-    pub fn download(url: &'static str) -> anyhow::Result<Self> {
+    pub async fn download(url: &'static str) -> anyhow::Result<Self> {
        if let Some(list) = LIST_CACHE.lock().unwrap().get(url) {
            return Ok(list.clone());
        }
-        let body: List = reqwest::blocking::get(url)?.json()?;
+        let body: List = reqwest::get(url).await?.json().await?;
        LIST_CACHE.lock().unwrap().insert(url, body.clone());
@@ -36,65 +38,91 @@ impl List {
    }
 }
-/// Download solc binaries from GitHub releases (IPFS links aren't reliable).
+/// Download solc binaries from the official SolidityLang site
 #[derive(Clone, Debug)]
-pub struct GHDownloader {
+pub struct SolcDownloader {
    pub version: Version,
    pub target: &'static str,
    pub list: &'static str,
 }
-impl GHDownloader {
+impl SolcDownloader {
-    pub const BASE_URL: &str = "https://github.com/ethereum/solidity/releases/download";
+    pub const BASE_URL: &str = "https://binaries.soliditylang.org";
-    pub const LINUX_NAME: &str = "solc-static-linux";
+    pub const LINUX_NAME: &str = "linux-amd64";
-    pub const MACOSX_NAME: &str = "solc-macos";
+    pub const MACOSX_NAME: &str = "macosx-amd64";
-    pub const WINDOWS_NAME: &str = "solc-windows.exe";
+    pub const WINDOWS_NAME: &str = "windows-amd64";
-    pub const WASM_NAME: &str = "soljson.js";
+    pub const WASM_NAME: &str = "wasm";
-    fn new(version: Version, target: &'static str, list: &'static str) -> Self {
+    async fn new(
-        Self {
+        version: impl Into<VersionOrRequirement>,
        target: &'static str,
        list: &'static str,
    ) -> anyhow::Result<Self> {
        let version_or_requirement = version.into();
        match version_or_requirement {
            VersionOrRequirement::Version(version) => Ok(Self {
                version,
                target,
                list,
            }),
            VersionOrRequirement::Requirement(requirement) => {
                let Some(version) = List::download(list)
                    .await?
                    .builds
                    .into_iter()
                    .map(|build| build.version)
                    .filter(|version| requirement.matches(version))
                    .max()
                else {
                    anyhow::bail!("Failed to find a version that satisfies {requirement:?}");
                };
                Ok(Self {
                    version,
                    target,
                    list,
                })
            }
        }
    }
-    pub fn linux(version: Version) -> Self {
+    pub async fn linux(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::LINUX_NAME, List::LINUX_URL)
+        Self::new(version, Self::LINUX_NAME, List::LINUX_URL).await
    }
-    pub fn macosx(version: Version) -> Self {
+    pub async fn macosx(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::MACOSX_NAME, List::MACOSX_URL)
+        Self::new(version, Self::MACOSX_NAME, List::MACOSX_URL).await
    }
-    pub fn windows(version: Version) -> Self {
+    pub async fn windows(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::WINDOWS_NAME, List::WINDOWS_URL)
+        Self::new(version, Self::WINDOWS_NAME, List::WINDOWS_URL).await
    }
-    pub fn wasm(version: Version) -> Self {
+    pub async fn wasm(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
-        Self::new(version, Self::WASM_NAME, List::WASM_URL)
+        Self::new(version, Self::WASM_NAME, List::WASM_URL).await
    }
    /// Returns the download link.
    pub fn url(&self) -> String {
        format!("{}/v{}/{}", Self::BASE_URL, &self.version, &self.target)
    }
    /// Download the solc binary.
    ///
    /// Errors out if the download fails or the digest of the downloaded file
    /// mismatches the expected digest from the release [List].
-    pub fn download(&self) -> anyhow::Result<Vec<u8>> {
+    pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
-        log::info!("downloading solc: {self:?}");
+        tracing::info!("downloading solc: {self:?}");
-        let expected_digest = List::download(self.list)?
+        let builds = List::download(self.list).await?.builds;
-            .builds
+        let build = builds
            .iter()
            .find(|build| build.version == self.version)
-            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))
+            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))?;
            .map(|b| b.sha256.strip_prefix("0x").unwrap_or(&b.sha256).to_string())?;
-        let file = reqwest::blocking::get(self.url())?.bytes()?.to_vec();
+        let path = build.path.clone();
        let expected_digest = build
            .sha256
            .strip_prefix("0x")
            .unwrap_or(&build.sha256)
            .to_string();
        let url = format!("{}/{}/{}", Self::BASE_URL, self.target, path.display());
        let file = reqwest::get(url).await?.bytes().await?.to_vec();
        if hex::encode(Sha256::digest(&file)) != expected_digest {
            anyhow::bail!("sha256 mismatch for solc version {}", self.version);
@@ -106,41 +134,58 @@ impl GHDownloader {
 #[cfg(test)]
 mod tests {
-    use crate::{download::GHDownloader, list::List};
+    use crate::{download::SolcDownloader, list::List};
-    #[test]
+    #[tokio::test]
-    fn try_get_windows() {
+    async fn try_get_windows() {
        let version = List::download(List::WINDOWS_URL)
            .await
            .unwrap()
-            .latest_release
+            .latest_release;
-            .into();
+        SolcDownloader::windows(version)
-        GHDownloader::windows(version).download().unwrap();
+            .await
            .unwrap()
            .download()
            .await
            .unwrap();
    }
-    #[test]
+    #[tokio::test]
-    fn try_get_macosx() {
+    async fn try_get_macosx() {
        let version = List::download(List::MACOSX_URL)
            .await
            .unwrap()
-            .latest_release
+            .latest_release;
-            .into();
+        SolcDownloader::macosx(version)
-        GHDownloader::macosx(version).download().unwrap();
+            .await
            .unwrap()
            .download()
            .await
            .unwrap();
    }
-    #[test]
+    #[tokio::test]
-    fn try_get_linux() {
+    async fn try_get_linux() {
        let version = List::download(List::LINUX_URL)
            .await
            .unwrap()
-            .latest_release
+            .latest_release;
-            .into();
+        SolcDownloader::linux(version)
-        GHDownloader::linux(version).download().unwrap();
+            .await
            .unwrap()
            .download()
            .await
            .unwrap();
    }
-    #[test]
+    #[tokio::test]
-    fn try_get_wasm() {
+    async fn try_get_wasm() {
-        let version = List::download(List::WASM_URL)
+        let version = List::download(List::WASM_URL).await.unwrap().latest_release;
        SolcDownloader::wasm(version)
            .await
            .unwrap()
-            .latest_release
+            .download()
-            .into();
+            .await
-        GHDownloader::wasm(version).download().unwrap();
+            .unwrap();
    }
 }
@@ -6,8 +6,9 @@
 use std::path::{Path, PathBuf};
 use cache::get_or_download;
-use download::GHDownloader;
+use download::SolcDownloader;
-use semver::Version;
+
 use revive_dt_common::types::VersionOrRequirement;
 pub mod cache;
 pub mod download;
@@ -18,22 +19,22 @@ pub mod list;
 ///
 /// Subsequent calls for the same version will use a cached artifact
 /// and not download it again.
-pub fn download_solc(
+pub async fn download_solc(
    cache_directory: &Path,
-    version: Version,
+    version: impl Into<VersionOrRequirement>,
    wasm: bool,
 ) -> anyhow::Result<PathBuf> {
    let downloader = if wasm {
-        GHDownloader::wasm(version)
+        SolcDownloader::wasm(version).await
    } else if cfg!(target_os = "linux") {
-        GHDownloader::linux(version)
+        SolcDownloader::linux(version).await
    } else if cfg!(target_os = "macos") {
-        GHDownloader::macosx(version)
+        SolcDownloader::macosx(version).await
    } else if cfg!(target_os = "windows") {
-        GHDownloader::windows(version)
+        SolcDownloader::windows(version).await
    } else {
        unimplemented!()
-    };
+    }?;
-    get_or_download(cache_directory, &downloader)
+    get_or_download(cache_directory, &downloader).await
 }
@@ -33,9 +33,5 @@
    "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "timestamp": "0x00",
-    "alloc": {
+    "alloc": {}
        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
            "balance": "1000000000000000000"
        }
    }
 }
Author	SHA1	Message	Date
Omar Abdulla	91773dd281	Correct the key and value encoding for the cache	2025-08-16 18:18:43 +03:00
Omar Abdulla	c34f5a3d95	Implement a persistent compilation cache	2025-08-16 17:11:04 +03:00
Omar Abdulla	19075f76e0	Merge branch 'main' into feature/cached-compiler-artifacts	2025-08-16 14:57:45 +03:00
Omar Abdulla	0038634695	WIP compilation cache	2025-08-16 14:55:02 +03:00
James Wilson	09d56f5177	Redo how we parse and use modes (#125 ) * WIP redo how we parse and use modes * test expanding, too * WIP integrate new Mode/ParsedMode into rest of code * First pass integrated new mode bits * fmt * clippy * Remove mode we no longer support from test metadata * Address nits * Add ability for compiler to opt out if it can't work with some Mode/version * Elide viaIR input if compiler does not support it * Improve test output a little; string modes and list ignored tests * Move Mode to common crate * constants.mod, and Display for CaseIdx to use it * fmt * Rename ModePipeline::E/Y * Re-arrange Mode things; ParsedMode in format and Mode etc in common * Move compile check to prepare_tests * Remove now-unused deps * clippy nits * Update fallback tx weights to avoid out of gas errors * Update kitchensink weights too and fmt * Bump default geth timeout to 10s * 30s timeout * Improve geth stdout logging on failure * fix line logging * remove --networkid and arg, back to 5s timeout for geth	2025-08-16 11:38:17 +00:00
Omar	a59e287fa1	Add a cached fs abstraction (#141 )	2025-08-14 15:21:05 +00:00
Omar	f2045db0e9	Add compiler directives to metadata (#139 )	2025-08-14 07:38:56 +00:00
Omar	5a11f44673	Misc features/improvements (#138 ) * Implement various needed features and improvements * Reorder the metadata struct * Format comments	2025-08-13 13:50:06 +00:00
James Wilson	46aea0890d	Split reporter and case runner, use channels to pass test reports (#137 ) * Use channels to send data to reporting thread and avoid hangs / mutex / duration. Limit max concurrent tasks to avoid too many open files * More appropriate name for dirver/reporter task fns * Back to parallelise individual cases, report individual cases, address grumbles * newline before 'Failures' title in report	2025-08-13 13:10:26 +00:00
Omar	9b40c9b9e3	Add an EVM version filter (#136 ) * Add an EVM version filter * Update naming	2025-08-12 10:19:59 +00:00
Omar	f67a9bf643	Refactor/ignore null values (#135 ) * Skip serialization of null values * Add support for comments in various steps	2025-08-12 08:55:21 +00:00
Omar	67d767ffde	Implement storage empty assertion (#134 )	2025-08-11 13:17:19 +00:00
Omar	f7fbe094ec	Balance assertions (#133 ) * Make metadata serializable * Refactor tests to use steps * Add a balance assertion test step * Test balance deserialization * Box the test steps * Permit size difference in step output	2025-08-11 12:11:16 +00:00
Omar	90b2dd4cfe	Make metadata serializable (#132 )	2025-08-10 21:57:41 +00:00
Omar	64d63ef999	Remove the provider cache (#121 ) * Remove the provider cache * Add timing information to the CLI report	2025-08-07 03:55:24 +00:00
Omar	757bfbe116	Add more resolvable variables (#120 ) * Allow resolution of base fee * Fix block difficulty resolution * Allow for the resolution of gas price	2025-08-06 15:17:36 +00:00
Omar	8619e7feb0	Fix the transaction tracing issues (#118 ) * Set the gc mode to archive in geth * Add a maximum to the exponential backoff wait duration * Edit the formatting of the CLI case reporter	2025-08-06 12:25:39 +00:00
Omar	edba49b301	Use SolidityLang for solc downloads (#117 )	2025-08-06 10:35:05 +00:00
Omar	9980926d40	Add a case ignore flag (#114 ) * Added a resolver tied to a specific block * Increase the number of private keys * Increase kitchensink wait time to 60 seconds * Add a case ignore flag	2025-08-04 16:40:53 +00:00
Omar	ff993d44a5	Added a resolver tied to a specific block (#111 ) * Added a resolver tied to a specific block * Increase the number of private keys * Increase kitchensink wait time to 60 seconds	2025-08-04 12:45:47 +00:00
Omar	8cbb1a9f77	Added basic console reporting (#110 ) * Added basic console reporting * Add some waiting period to the printing task * Print to the stderr and print logs to stdout	2025-08-04 06:05:49 +00:00
Omar	56c2fe8c0c	Parallelize Cases (#109 ) * Parallelize over cases * Rename the state and driver * Parallelize execution * Update the default config of the tool * Make codebase async * Fix machete * Fix tests & clear node directories before startup * Cleanup the cleanup logic * Rename geth node	2025-08-01 11:00:08 +00:00
Omar	330a773a1c	Add variables support (#96 )	2025-07-30 08:41:03 +00:00
Omar	f51693cb9f	Support multiple compiler versions (#92 ) * Allow for downloader to use version requirements. We will soon add support for the compiler version requirement from the metadata files to be honored. The compiler version is specified in the solc modes section of the file and its specified as a `VersionReq` and not as a version. Therefore, we need to have the ability to honor this version requirement and find the best version that satisfies the requirement. * Request `VersionOrRequirement` in compiler interface * Honor the compiler version requirement in metadata This commit honors the compiler version requirement listed in the solc modes of the metadata file. If this version requirement is provided then it overrides what was passed in the CLI. Otherwise, the CLI version will be used. * Make compiler IO completely generic. Before this commit, the types that were used for the compiler input and output were the resolc compiler types which was a leaky abstraction as we have traits to abstract the compilers away but we expose their internal types out to other crates. This commit did the following: 1. Made the compiler IO types fully generic so that all of the logic for constructing the map of compiled contracts is all done by the compiler implementation and not by the consuming code. 2. Changed the input types used for Solc to be the forge standard JSON types for Solc instead of resolc. * Fix machete * Add resolc to CI * Add resolc to CI * Add resolc to CI * Add resolc to CI	2025-07-30 04:56:23 +00:00
James Wilson	4db7009640	Ensure path in corpus is relative to corpus file (#85 )	2025-07-29 13:12:16 +00:00
Omar	5a36e242ec	Allow for files in corpus definitions (#87 ) * Allow for files to be specified in the corpus file * Attempt to improve the geth tx indexing issue. We're facing an issue where Geth transaction indexing can sometimes stall on some of the nodes we're running. The logs show that for all transactions we always need 1 second of waiting time. However, during certain runs we sometimes run into an issue with some of the nodes where it seems like their transaction indexer fails (either at the start or after some amount of time) which leads us to never get the receipts back from these specific nodes. This is not a load issue as it appears like all of the other nodes handle it just fine. However, it looks like once a node gets into this state it can not get out of it and its bricked for the entire run. This commit adds some more command line arguments to the geth command in hopes of improving this issue.	2025-07-29 13:02:53 +00:00
James Wilson	33329632b5	Increase geth instantiate timeout from 2s to 5s (#86 )	2025-07-29 10:34:31 +00:00
Omar	429f2e92a2	Fix contract discovery for simple tests (#83 )	2025-07-28 07:05:53 +00:00
Omar	65f41f2038	Correct the type of address in matterlabs events (#82 )	2025-07-28 05:01:52 +00:00
Omar	3ed8a1ca1c	Support compiler-version aware exceptions (#81 )	2025-07-25 14:23:17 +00:00
Omar	2923d675cd	Support Compile-time Linking (#79 ) * Use wrappers for libraries in metadata. * Create a unified way to access deployed contracts * Support linking at compile time	2025-07-25 07:03:21 +00:00
Omar	8f5bcf08ad	Support `Calldata` arithmetic (#77 ) * Re-order the input file. This commit reorders the input file such that we have a definitions section and an implementations section and such that the the order of the items in both sections is the same. * Implement a reverse polish calculator for calldata arithmetic	2025-07-24 15:35:25 +00:00
Omar	90fb89adc0	Add a `common` crate (#75 ) * Add a barebones common crate * Refactor some code into the common crate * Add a `ResolverApi` interface. This commit adds a `ResolverApi` trait to the `format` crate that can be implemented by any type that can act as a resolver. A resolver is able to provide information on the chain state. This chain state could be fresh or it could be cached (which is something that we will do in a future PR). This cleans up our crate graph so that `format` is not depending on the node interactions crate for the `EthereumNode` trait. * Cleanup the blocking executor	2025-07-24 12:42:45 +00:00
Omar	b03ad3027e	Pre-seed accounts with more ETH. (#73 ) * Pre-seed accounts with more ETH. This commit fixes and solves some issues around how much ETH we seed an account with in genesis. Currently, any account that the node has keys to sign for will be seeded with u128::MAX WEI in genesis. This also includes the default signer account. * Bump commit hash of polkadot SDK * Change how the cache key is computed * Revert "Change how the cache key is computed" This reverts commit `75afdd9cfd`. * Revert "Bump commit hash of polkadot SDK" This reverts commit `8aaa69780e`. * Add extra comments * Revert "Add extra comments" This reverts commit `bd4de2c83d`. * Update the initial balance	2025-07-24 08:46:14 +00:00
Omar	972f3b6d5b	Wait longer for geth receipts (#74 )	2025-07-24 04:40:19 +00:00
Omar	6f4aa731ab	Handle exceptions (#54 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order * Handle calldata better * Allow for the use of function signatures * Add support for exceptions * Cached nonce allocator * Fix tests * Add support for address replacement * Cleanup implementation * Cleanup mutability * Wire up address replacement with rest of code * Implement caller replacement * Switch to callframe trace for exceptions * Add a way to skip tests if they don't match the target * Handle values from the metadata files * Remove address replacement * Correct the arguments * Remove empty impl * Remove address replacement * Correct the arguments * Remove empty impl * Fix size_requirement underflow * Add support for wildcards in exceptions * Fix calldata construction of single calldata * Better handling for length in equivalency checks * Make initial balance a constant * Fix size_requirement underflow * Add support for wildcards in exceptions * Fix calldata construction of single calldata * Better handling for length in equivalency checks * Fix tests	2025-07-24 03:45:53 +00:00
Omar	589a5dc988	Handle calldata better (#49 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order * Handle calldata better * Remove todo	2025-07-22 03:39:35 +00:00
Omar	c6d55515be	Allow for the use of function signatures (#50 ) * Allow for the use of function signatures * Add test	2025-07-21 10:43:17 +00:00
Omar	a9970eb2bb	Refactor the input handling logic (#48 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order	2025-07-21 09:01:52 +00:00
Omar	2259942363	Cleanup execution logic (#45 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning * Fix the ABI finding logic * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Implement ABI fix in the compiler trait impl * Update the async runtime with syntactic sugar. * Fix tests * Fix doc test * Give nodes a standard way to get their alloy provider * Add ability to get the chain_id from node * Get kitchensink provider to use kitchensink network * Use provider method in tests * Add support for getting the gas limit from the node * Add a way to get the coinbase address * Add a way to get the block difficulty from the node * Add a way to get block info from the node * Expose APIs for getting the info of a specific block * Add resolution logic for other matterlabs variables * Fix tests * Add comment on alternative solutions * Change kitchensink gas limit assertion * Cleanup execution logic	2025-07-18 12:08:13 +00:00
Omar	0b97d7dc29	Support other matterlabs variables (#43 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Update the async runtime with syntactic sugar. * Fix tests * Fix doc test * Give nodes a standard way to get their alloy provider * Add ability to get the chain_id from node * Get kitchensink provider to use kitchensink network * Use provider method in tests * Add support for getting the gas limit from the node * Add a way to get the coinbase address * Add a way to get the block difficulty from the node * Add a way to get block info from the node * Expose APIs for getting the info of a specific block * Add resolution logic for other matterlabs variables * Fix tests * Add comment on alternative solutions * Change kitchensink gas limit assertion * Remove un-needed profile config	2025-07-18 12:06:40 +00:00
Omar	2bee2d5c8b	Fix the ABI finding logic (#38 ) * Fix the ABI finding logic * Implement ABI fix in the compiler trait impl	2025-07-18 11:22:51 +00:00
Omar	854e8d9690	Fix `deserialization error: invalid value: string "0x2d79dd80ff729c000"` (#34 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning	2025-07-18 11:22:13 +00:00
Omar	2d517784dd	Better logging for contract deployment (#46 ) * Log certain errors better * Remove unneeded code	2025-07-16 18:16:12 +00:00
Omar	baa11ad28f	Correctly identify which contracts to compile (#44 ) * Compile all contracts for a test file * Fix compilation errors related to paths * Set the base path if specified	2025-07-16 11:52:40 +00:00
Omar	c2e65f9e33	Fix function selector & argument encoding (#39 ) * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Fix tests	2025-07-15 20:00:10 +00:00
Omar	14888f9767	Update the async runtime (#42 ) * Update the async runtime with syntactic sugar. * Fix doc test * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Improve the comments * Update the release profile --------- Co-authored-by: xermicus <cyrill@parity.io>	2025-07-15 11:19:17 +00:00
Omar	3e99d1c2a5	Allow alloy to estimate tx gas (#37 )	2025-07-14 17:34:44 +00:00
Omar	4e234aa1bd	Remove code that was accidentally committed. (#41 ) * Remove code that was accidentally committed. * Remove unneeded dependency	2025-07-14 16:24:39 +00:00
Omar	b204de5484	Persist node logs (#36 ) * Persist node logs * Fix clippy lints * Delete the node's db on shutdown but persist logs * Fix tests * Separate stdout and stderr and use more consts. * More consistent handling of open options * Revert the use of subprocess * Remove outdated comment * Flush the log files on drop * Rename `log_files` -> `logs_file_to_flush`	2025-07-14 16:08:47 +00:00
Omar	5eb3a0e1b5	Fix for "transaction indexing is in progress" (#32 ) * Retry getting transaction receipt * Small fix to logging consistency * Introduce a custom kitchensink network * Fix formtting and clippy	2025-07-14 09:32:57 +00:00
Omar	772bd217c3	Fixing the CI on Ubuntu (#31 ) * pin the version of geth used in CI * pin the version of geth used in CI * temp: run on each push * pin the version of geth used in CI * Make geth installation arch dependent * Remove temp run on push to branch * Add a comment on the need for pre-built binaries	2025-07-14 09:17:13 +00:00
Omar	0513a4befb	Use `tracing` for logging. (#29 ) This commit updates how logging is done in the differential testing harness to use `tracing` instead of using the `log` crate. This allows us to be able to better associate logs with the cases being executed which makes it easier to debug and understand what the harness is doing.	2025-07-10 07:28:16 +00:00
activecoder10	de7c7d6703	Compute transaction input for executing transactions (#28 ) * Parsed ABI field in order to get method parameter * Added logic for ABI * Refactored dependencies * Small refactoring * Added unit tests for ABI parameter extraction logic * Fixed format issues * Fixed format * Added new changes to format * Added bail to stop execution when we have an error during deployment	2025-07-09 11:03:38 +00:00
		`@@ -0,0 +1,3 @@`
							`mod files_with_extension_iterator;`

							`pub use files_with_extension_iterator::*;`
		`@@ -0,0 +1,3 @@`
							`mod define_wrapper_type;`

							`pub use define_wrapper_type::*;`