Update the readme

* Fix the OS FD error

* Cache the compiler versions

* Allow for auto display impl in declare wrapper type macro

* Better logging and fix concurrency issues

* Fix tests

* Format

* Make the code even more concurrent

.github/workflows/test.yml

@@ -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

.gitignore

@@ -3,3 +3,9 @@
 .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
+
+profile.json.gz

Cargo.toml

@@ -8,9 +8,10 @@ authors = ["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" }
@@ -24,32 +25,44 @@ 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"] }
+dashmap = { version = "6.1.0" }
+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"
+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",
+    "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 = [
+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 = { version = "0.1.41" }
+tracing-appender = { version = "0.2.3" }
 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" }
@@ -57,7 +70,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",
@@ -68,9 +81,15 @@ features = [
     "rpc-types",
     "signer-local",
     "std",
+    "network",
+    "serde",
+    "rpc-types-eth",
+    "genesis",
 ]
 
 [profile.bench]
 inherits = "release"
 lto = true
 codegen-units = 1
+
+[workspace.lints.clippy]

README.md

@@ -1,34 +1,210 @@
-# revive-differential-tests
+<div align="center">
+  <h1><code>Revive Differential Tests</code></h1>
 
-The revive differential testing framework allows to define smart contract tests in a declarative manner in order to compile and execute them against different Ethereum-compatible blockchain implmentations. This is useful to:
+  <p>
-- Analyze observable differences in contract compilation and execution across different blockchain implementations, including contract storage, account balances, transaction output and emitted events on a per-transaction base.
+    <strong>Differential testing for Ethereum-compatible smart contract stacks</strong>
-- Collect and compare benchmark metrics such as code size, gas usage or transaction throughput per seconds (TPS) of different blockchain implementations.
+  </p>
-- Ensure reproducible contract builds across multiple compiler implementations or multiple host platforms.
+</div>
-- Implement end-to-end regression tests for Ethereum-compatible smart contract stacks.
 
-# Declarative test format
+This project compiles and executes declarative smart-contract tests against multiple platforms, then compares behavior (status, return data, events, and state diffs). Today it supports:
 
-For now, the format used to write tests is the [matter-labs era compiler format](https://github.com/matter-labs/era-compiler-tests?tab=readme-ov-file#matter-labs-simplecomplex-format). This allows us to re-use many tests from their corpora.
+- Geth (EVM reference implementation)
+- Revive Kitchensink (Substrate-based PolkaVM + `eth-rpc` proxy)
 
-# The `retester` utility
+Use it to:
 
-The `retester` helper utilty is used to run the tests. To get an idea of what `retester` can do, please consults its command line help: 
+- Detect observable differences between platforms (execution success, logs, state changes)
+- Ensure reproducible builds across compilers/hosts
+- Run end-to-end regression suites
 
-```
+This framework uses the [MatterLabs tests format](https://github.com/matter-labs/era-compiler-tests/tree/main/solidity) for declarative tests which is composed of the following:
-cargo run -p revive-dt-core -- --help
+
+- Metadata files, this is akin to a module of tests in Rust.
+- Each metadata file contains multiple cases, a case is akin to a Rust test where a module can contain multiple tests.
+- Each case contains multiple steps and assertions, this is akin to any Rust test that contains multiple statements.
+
+Metadata files are JSON files, but Solidity files can also be metadata files if they include inline metadata provided as a comment at the top of the contract.
+
+All of the steps contained within each test case are either:
+
+- Transactions that need to be submitted and assertions to run on the submitted transactions.
+- Assertions on the state of the chain (e.g., account balances, storage, etc...)
+
+All of the transactions submitted by the this tool to the test nodes follow a similar logic to what wallets do. We first use alloy to estimate the transaction fees, then we attach that to the transaction and submit it to the node and then await the transaction receipt.
+
+This repository contains none of the tests and only contains the testing framework or the test runner. The tests can be found in the [`resolc-compiler-tests`](https://github.com/paritytech/resolc-compiler-tests) repository which is a clone of [MatterLab's test suite](https://github.com/matter-labs/era-compiler-tests) with some modifications and adjustments made to suit our use case.
+
+## Requirements
+
+This section describes the required dependencies that this framework requires to run. Compiling this framework is pretty straightforward and no additional dependencies beyond what's specified in the `Cargo.toml` file should be required.
+
+- Stable Rust
+- Geth - When doing differential testing against the PVM we submit transactions to a Geth node and to Kitchensink to compare them.
+- Kitchensink - When doing differential testing against the PVM we submit transactions to a Geth node and to Kitchensink to compare them.
+- ETH-RPC - All communication with Kitchensink is done through the ETH RPC.
+- Solc - This is actually a transitive dependency, while this tool doesn't require solc as it downloads the versions that it requires, resolc requires that Solc is installed and available in the path.
+- Resolc - This is required to compile the contracts to PolkaVM bytecode.
+
+All of the above need to be installed and available in the path in order for the tool to work.
+
+## Running The Tool
+
+This tool is being updated quite frequently. Therefore, it's recommended that you don't install the tool and then run it, but rather that you run it from the root of the directory using `cargo run --release`. The help command of the tool gives you all of the information you need to know about each of the options and flags that the tool offers.
+
+```bash
+$ cargo run --release -- --help
+Usage: retester [OPTIONS]
+
+Options:
+  -s, --solc <SOLC>
+          The `solc` version to use if the test didn't specify it explicitly
+
+          [default: 0.8.29]
+
+      --wasm
+          Use the Wasm compiler versions
+
+  -r, --resolc <RESOLC>
+          The path to the `resolc` executable to be tested.
+
+          By default it uses the `resolc` binary found in `$PATH`.
+
+          If `--wasm` is set, this should point to the resolc Wasm ile.
+
+          [default: resolc]
+
+  -c, --corpus <CORPUS>
+          A list of test corpus JSON files to be tested
+
+  -w, --workdir <WORKING_DIRECTORY>
+          A place to store temporary artifacts during test execution.
+
+          Creates a temporary dir if not specified.
+
+  -g, --geth <GETH>
+          The path to the `geth` executable.
+
+          By default it uses `geth` binary found in `$PATH`.
+
+          [default: geth]
+
+      --geth-start-timeout <GETH_START_TIMEOUT>
+          The maximum time in milliseconds to wait for geth to start
+
+          [default: 5000]
+
+      --genesis <GENESIS_FILE>
+          Configure nodes according to this genesis.json file
+
+          [default: genesis.json]
+
+  -a, --account <ACCOUNT>
+          The signing account private key
+
+          [default: 0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d]
+
+      --private-keys-count <PRIVATE_KEYS_TO_ADD>
+          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
+
+          [default: 100000]
+
+  -l, --leader <LEADER>
+          The differential testing leader node implementation
+
+          [default: geth]
+
+          Possible values:
+          - geth:        The go-ethereum reference full node EVM implementation
+          - kitchensink: The kitchensink runtime provides the PolkaVM (PVM) based node implentation
+
+  -f, --follower <FOLLOWER>
+          The differential testing follower node implementation
+
+          [default: kitchensink]
+
+          Possible values:
+          - geth:        The go-ethereum reference full node EVM implementation
+          - kitchensink: The kitchensink runtime provides the PolkaVM (PVM) based node implentation
+
+      --compile-only <COMPILE_ONLY>
+          Only compile against this testing platform (doesn't execute the tests)
+
+          Possible values:
+          - geth:        The go-ethereum reference full node EVM implementation
+          - kitchensink: The kitchensink runtime provides the PolkaVM (PVM) based node implentation
+
+      --number-of-nodes <NUMBER_OF_NODES>
+          Determines the amount of nodes that will be spawned for each chain
+
+          [default: 1]
+
+      --number-of-threads <NUMBER_OF_THREADS>
+          Determines the amount of tokio worker threads that will will be used
+
+          [default: 16]
+
+      --number-concurrent-tasks <NUMBER_CONCURRENT_TASKS>
+          Determines the amount of concurrent tasks that will be spawned to run tests. Defaults to 10 x the number of nodes
+
+  -e, --extract-problems
+          Extract problems back to the test corpus
+
+  -k, --kitchensink <KITCHENSINK>
+          The path to the `kitchensink` executable.
+
+          By default it uses `substrate-node` binary found in `$PATH`.
+
+          [default: substrate-node]
+
+  -p, --eth_proxy <ETH_PROXY>
+          The path to the `eth_proxy` executable.
+
+          By default it uses `eth-rpc` binary found in `$PATH`.
+
+          [default: eth-rpc]
+
+  -i, --invalidate-compilation-cache
+          Controls if the compilation cache should be invalidated or not
+
+  -h, --help
+          Print help (see a summary with '-h')
 ```
 
-For example, to run the [complex Solidity tests](https://github.com/matter-labs/era-compiler-tests/tree/main/solidity/complex), define a corpus structure as follows:
+To run tests with this tool you need a corpus JSON file that defines the tests included in the corpus. The simplest corpus file looks like the following:
 
 ```json
 {
-    "name": "ML Solidity Complex",
+  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
-    "path": "/path/to/era-compiler-tests/solidity/complex"
+  "path": "resolc-compiler-tests/fixtures/solidity"
 }
 ```
 
-Assuming this to be saved in a `ml-solidity-complex.json` file, the following command will try to compile and execute the tests found inside the corpus:
+> [!NOTE]  
+> Note that the tests can be found in the [`resolc-compiler-tests`](https://github.com/paritytech/resolc-compiler-tests) repository.
+
+The above corpus file instructs the tool to look for all of the test cases contained within all of the metadata files of the specified directory.
+
+The simplest command to run this tool is the following:
 
 ```bash
-RUST_LOG=debug cargo r --release -p revive-dt-core  -- --corpus ml-solidity-complex.json 
+RUST_LOG="info" cargo run --release -- \
+    --corpus path_to_your_corpus_file.json \
+    --workdir path_to_a_temporary_directory_to_cache_things_in \
+    --number-of-nodes 5 \
+    > logs.log \
+    2> output.log
+```
+
+The above command will run the tool executing every one of the tests discovered in the path specified in the corpus file. All of the logs from the execution will be persisted in the `logs.log` file and all of the output of the tool will be persisted to the `output.log` file. If all that you're looking for is to run the tool and check which tests succeeded and failed, then the `output.log` file is what you need to be looking at. However, if you're contributing the to the tool then the `logs.log` file will be very valuable.
+
+If you only want to run a subset of tests, then you can specify that in your corpus file. The following is an example:
+
+```json
+{
+  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
+  "paths": [
+    "path/to/a/single/metadata/file/I/want/to/run.json",
+    "path/to/a/directory/to/find/all/metadata/files/within"
+  ]
+}
 ```

assets/test_metadata.json

@@ -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"
+}

clippy.toml

@@ -0,0 +1 @@
+

crates/common/Cargo.toml

@@ -0,0 +1,20 @@
+[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"] }
+
+[lints]
+workspace = true

crates/common/src/cached_fs/mod.rs

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

crates/common/src/fs/clear_dir.rs

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

crates/common/src/fs/mod.rs

@@ -0,0 +1,3 @@
+mod clear_dir;
+
+pub use clear_dir::*;

crates/common/src/futures/mod.rs

@@ -0,0 +1,3 @@
+mod poll;
+
+pub use poll::*;

crates/common/src/futures/poll.rs

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

crates/common/src/iterators/files_with_extension_iterator.rs

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

crates/common/src/iterators/mod.rs

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

crates/common/src/lib.rs

@@ -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;

crates/common/src/macros/define_wrapper_type.rs

@@ -0,0 +1,129 @@
+#[macro_export]
+macro_rules! impl_for_wrapper {
+    (Display, $ident: ident) => {
+        impl std::fmt::Display for $ident {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                std::fmt::Display::fmt(&self.0, f)
+            }
+        }
+    };
+}
+
+/// 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)
+
+        $(
+            impl $($trait_ident: ident),*
+        )?
+
+        ;
+    ) => {
+        $(#[$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
+            }
+        }
+
+        $(
+            $(
+                $crate::macros::impl_for_wrapper!($trait_ident, $ident);
+            )*
+        )?
+    };
+}
+
+/// 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, impl_for_wrapper};

crates/common/src/macros/mod.rs

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

crates/common/src/types/mod.rs

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

crates/common/src/types/mode.rs

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

crates/common/src/types/version_or_requirement.rs

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

crates/compiler/Cargo.toml

@@ -9,11 +9,22 @@ 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 }
+dashmap = { workspace = true }
+foundry-compilers-artifacts = { workspace = true }
 semver = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 tracing = { workspace = true }
+tokio = { workspace = true }
+
+[lints]
+workspace = true

crates/compiler/src/constants.rs

@@ -0,0 +1,4 @@
+use semver::Version;
+
+/// This is the first version of solc that supports the `--via-ir` flag / "viaIR" input JSON.
+pub const SOLC_VERSION_SUPPORTING_VIA_YUL_IR: Version = Version::new(0, 8, 13);

crates/compiler/src/lib.rs

@@ -3,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) -> impl Future<Output = anyhow::Result<Version>>;
+
+    /// Does the compiler support the provided mode and version settings?
+    fn supports_mode(
+        compiler_version: &Version,
+        optimize_setting: ModeOptimizerSetting,
+        pipeline: ModePipeline,
+    ) -> bool;
 }
 
 /// The generic compilation input configuration.
-#[derive(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(),
+                optimization: Default::default(),
+                evm_version: Default::default(),
+                allow_paths: Default::default(),
+                base_path: Default::default(),
                 sources: Default::default(),
-                settings: SolcStandardJsonInputSettings::new(
+                libraries: Default::default(),
-                    None,
+                revert_string_handling: Default::default(),
-                    Default::default(),
-                    None,
-                    SolcStandardJsonInputSettingsSelection::new_required(),
-                    SolcStandardJsonInputSettingsOptimizer::new(
-                        false,
-                        None,
-                        &Version::new(0, 0, 0),
-                        false,
-                    ),
-                    None,
-                    None,
-                ),
             },
-            extra_options: Default::default(),
+            additional_options: T::Options::default(),
-            allow_paths: Default::default(),
-            base_path: None,
         }
     }
 
-    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,
+}

crates/compiler/src/revive_resolc.rs

@@ -4,13 +4,32 @@
 use std::{
     path::PathBuf,
     process::{Command, Stdio},
+    sync::LazyLock,
 };
 
-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use dashmap::DashMap;
+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 +38,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);
             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 +220,72 @@ impl SolidityCompiler for Resolc {
 
         Ok(PathBuf::from("resolc"))
     }
+
+    async fn version(&self) -> anyhow::Result<semver::Version> {
+        /// This is a cache of the path of the compiler to the version number of the compiler. We
+        /// choose to cache the version in this way rather than through a field on the struct since
+        /// compiler objects are being created all the time from the path and the compiler object is
+        /// not reused over time.
+        static VERSION_CACHE: LazyLock<DashMap<PathBuf, Version>> = LazyLock::new(Default::default);
+
+        match VERSION_CACHE.entry(self.resolc_path.clone()) {
+            dashmap::Entry::Occupied(occupied_entry) => Ok(occupied_entry.get().clone()),
+            dashmap::Entry::Vacant(vacant_entry) => {
+                let output = Command::new(self.resolc_path.as_path())
+                    .arg("--version")
+                    .stdout(Stdio::piped())
+                    .spawn()?
+                    .wait_with_output()?
+                    .stdout;
+
+                let output = String::from_utf8_lossy(&output);
+                let version_string = output
+                    .split("version ")
+                    .nth(1)
+                    .context("Version parsing failed")?
+                    .split("+")
+                    .next()
+                    .context("Version parsing failed")?;
+
+                let version = Version::parse(version_string)?;
+
+                vacant_entry.insert(version.clone());
+
+                Ok(version)
+            }
+        }
+    }
+
+    fn supports_mode(
+        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().await;
+
+        // Assert
+        let _ = version.expect("Failed to get version");
+    }
 }

crates/compiler/src/solc.rs

@@ -4,12 +4,29 @@
 use std::{
     path::PathBuf,
     process::{Command, Stdio},
+    sync::LazyLock,
 };
 
-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use dashmap::DashMap;
+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 +34,275 @@ 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().await? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
+
+        // Be careful to entirely omit the viaIR field if the compiler does not support it,
+        // as it will error if you provide fields it does not know about. Because
+        // `supports_mode` is called prior to instantiating a compiler, we should never
+        // ask for something which is invalid.
+        let via_ir = match (pipeline, 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);
-            tracing::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)
     }
+
+    async fn version(&self) -> anyhow::Result<semver::Version> {
+        /// This is a cache of the path of the compiler to the version number of the compiler. We
+        /// choose to cache the version in this way rather than through a field on the struct since
+        /// compiler objects are being created all the time from the path and the compiler object is
+        /// not reused over time.
+        static VERSION_CACHE: LazyLock<DashMap<PathBuf, Version>> = LazyLock::new(Default::default);
+
+        match VERSION_CACHE.entry(self.solc_path.clone()) {
+            dashmap::Entry::Occupied(occupied_entry) => Ok(occupied_entry.get().clone()),
+            dashmap::Entry::Vacant(vacant_entry) => {
+                // The following is the parsing code for the version from the solc version strings
+                // which look like the following:
+                // ```
+                // solc, the solidity compiler commandline interface
+                // Version: 0.8.30+commit.73712a01.Darwin.appleclang
+                // ```
+                let child = Command::new(self.solc_path.as_path())
+                    .arg("--version")
+                    .stdout(Stdio::piped())
+                    .spawn()?;
+                let output = child.wait_with_output()?;
+                let output = String::from_utf8_lossy(&output.stdout);
+                let version_line = output
+                    .split("Version: ")
+                    .nth(1)
+                    .context("Version parsing failed")?;
+                let version_string = version_line
+                    .split("+")
+                    .next()
+                    .context("Version parsing failed")?;
+
+                let version = Version::parse(version_string)?;
+
+                vacant_entry.insert(version.clone());
+
+                Ok(version)
+            }
+        }
+    }
+
+    fn supports_mode(
+        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();
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 7, 6))
+            .await
+            .unwrap();
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version().await;
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 7, 6)
+        )
+    }
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained1() {
+        // Arrange
+        let args = Arguments::default();
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
+            .await
+            .unwrap();
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version().await;
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 4, 21)
+        )
+    }
 }

crates/compiler/tests/assets/array_one_element/callable.sol

@@ -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];
+    }
+}

crates/compiler/tests/assets/array_one_element/main.sol

@@ -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);
+    }
+}

crates/compiler/tests/assets/array_one_element/test.json

@@ -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"
+    }
+}

crates/compiler/tests/lib.rs

@@ -0,0 +1,87 @@
+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();
+
+    // 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"));
+}

crates/config/Cargo.toml

@@ -15,3 +15,5 @@ semver = { workspace = true }
 temp-dir = { workspace = true }
 serde = { workspace = true }
 
+[lints]
+workspace = true

crates/config/src/lib.rs

@@ -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.

crates/core/Cargo.toml

@@ -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,10 +23,21 @@ revive-dt-report = { workspace = true }
 
 alloy = { workspace = true }
 anyhow = { workspace = true }
+bson = { workspace = true }
+cacache = { workspace = true }
 clap = { workspace = true }
+futures = { workspace = true }
+indexmap = { workspace = true }
+once_cell = { workspace = true }
+tokio = { workspace = true }
 tracing = { workspace = true }
+tracing-appender = { workspace = true }
 tracing-subscriber = { workspace = true }
-rayon = { workspace = true }
+semver = { workspace = true }
-revive-solc-json-interface = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 temp-dir = { workspace = true }
+tempfile = { workspace = true }
+
+[lints]
+workspace = true

crates/core/src/cached_compiler.rs

@@ -0,0 +1,262 @@
+//! 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()
+            .await?;
+
+        let cache_key = CacheKey {
+            platform_key: P::config_id().to_string(),
+            compiler_version: compiler_version.clone(),
+            metadata_file_path: metadata_file_path.as_ref().to_path_buf(),
+            solc_mode: mode.clone(),
+        };
+
+        let compilation_callback = || {
+            async move {
+                compile_contracts::<P>(
+                    metadata.directory()?,
+                    compiler_path,
+                    metadata.files_to_compile()?,
+                    mode,
+                    deployed_libraries,
+                )
+                .map(|compilation_result| compilation_result.map(CacheValue::new))
+                .await
+            }
+            .instrument(debug_span!(
+                "Running compilation for the cache key",
+                cache_key.platform_key = %cache_key.platform_key,
+                cache_key.compiler_version = %cache_key.compiler_version,
+                cache_key.metadata_file_path = %cache_key.metadata_file_path.display(),
+                cache_key.solc_mode = %cache_key.solc_mode,
+            ))
+        };
+
+        let compiled_contracts = match deployed_libraries {
+            // If deployed libraries have been specified then we will re-compile the contract as it
+            // means that linking is required in this case.
+            Some(_) => {
+                debug!("Deployed libraries defined, recompilation must take place");
+                debug!("Cache miss");
+                compilation_callback().await?.compiler_output
+            }
+            // If no deployed libraries are specified then we can follow the cached flow and attempt
+            // to lookup the compilation artifacts in the cache.
+            None => {
+                debug!("Deployed libraries undefined, attempting to make use of cache");
+
+                // Lock this specific cache key such that we do not get inconsistent state. We want
+                // that when multiple cases come in asking for the compilation artifacts then they
+                // don't all trigger a compilation if there's a cache miss. Hence, the lock here.
+                let read_guard = CACHE_KEY_LOCK.read().await;
+                let mutex = match read_guard.get(&cache_key).cloned() {
+                    Some(value) => value,
+                    None => {
+                        drop(read_guard);
+                        CACHE_KEY_LOCK
+                            .write()
+                            .await
+                            .entry(cache_key.clone())
+                            .or_default()
+                            .clone()
+                    }
+                };
+                let _guard = mutex.lock().await;
+
+                self.0
+                    .get_or_insert_with(&cache_key, compilation_callback)
+                    .await
+                    .map(|value| value.compiler_output)?
+            }
+        };
+
+        Ok((compiled_contracts, compiler_version))
+    }
+}
+
+async fn compile_contracts<P: Platform>(
+    metadata_directory: impl AsRef<Path>,
+    compiler_path: impl AsRef<Path>,
+    mut files_to_compile: impl Iterator<Item = PathBuf>,
+    mode: &Mode,
+    deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+) -> Result<CompilerOutput> {
+    let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
+        .with_allowed_extension("sol")
+        .with_use_cached_fs(true)
+        .collect::<Vec<_>>();
+
+    Compiler::<P::Compiler>::new()
+        .with_allow_path(metadata_directory)
+        // Handling the modes
+        .with_optimization(mode.optimize_setting)
+        .with_pipeline(mode.pipeline)
+        // Adding the contract sources to the compiler.
+        .try_then(|compiler| {
+            files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
+        })?
+        // Adding the deployed libraries to the compiler.
+        .then(|compiler| {
+            deployed_libraries
+                .iter()
+                .flat_map(|value| value.iter())
+                .map(|(instance, (ident, address, abi))| (instance, ident, address, abi))
+                .flat_map(|(_, ident, address, _)| {
+                    all_sources_in_dir
+                        .iter()
+                        .map(move |path| (ident, address, path))
+                })
+                .fold(compiler, |compiler, (ident, address, path)| {
+                    compiler.with_library(path, ident.as_str(), *address)
+                })
+        })
+        .try_build(compiler_path)
+        .await
+}
+
+struct ArtifactsCache {
+    path: PathBuf,
+}
+
+impl ArtifactsCache {
+    pub fn new(path: impl AsRef<Path>) -> Self {
+        Self {
+            path: path.as_ref().to_path_buf(),
+        }
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn with_invalidated_cache(self) -> Result<Self> {
+        cacache::clear(self.path.as_path())
+            .await
+            .map_err(Into::<Error>::into)?;
+        Ok(self)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn insert(&self, key: &CacheKey, value: &CacheValue) -> Result<()> {
+        let key = bson::to_vec(key)?;
+        let value = bson::to_vec(value)?;
+        cacache::write(self.path.as_path(), key.encode_hex(), value).await?;
+        Ok(())
+    }
+
+    pub async fn get(&self, key: &CacheKey) -> Option<CacheValue> {
+        let key = bson::to_vec(key).ok()?;
+        let value = cacache::read(self.path.as_path(), key.encode_hex())
+            .await
+            .ok()?;
+        let value = bson::from_slice::<CacheValue>(&value).ok()?;
+        Some(value)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn get_or_insert_with(
+        &self,
+        key: &CacheKey,
+        callback: impl AsyncFnOnce() -> Result<CacheValue>,
+    ) -> Result<CacheValue> {
+        match self.get(key).await {
+            Some(value) => {
+                debug!("Cache hit");
+                Ok(value)
+            }
+            None => {
+                debug!("Cache miss");
+                let value = callback().await?;
+                self.insert(key, &value).await?;
+                Ok(value)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+struct CacheKey {
+    /// The platform name that this artifact was compiled for. For example, this could be EVM or
+    /// PVM.
+    platform_key: String,
+
+    /// The version of the compiler that was used to compile the artifacts.
+    compiler_version: Version,
+
+    /// The path of the metadata file that the compilation artifacts are for.
+    metadata_file_path: PathBuf,
+
+    /// The mode that the compilation artifacts where compiled with.
+    solc_mode: Mode,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct CacheValue {
+    /// The compiler output from the compilation run.
+    compiler_output: CompilerOutput,
+}
+
+impl CacheValue {
+    pub fn new(compiler_output: CompilerOutput) -> Self {
+        Self { compiler_output }
+    }
+}

crates/core/src/lib.rs

@@ -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 {

crates/core/src/main.rs

@@ -1,48 +1,113 @@
-use std::{collections::HashMap, sync::LazyLock};
+mod cached_compiler;
 
+use std::{
+    collections::{BTreeMap, HashMap},
+    io::{BufWriter, Write, stderr},
+    path::Path,
+    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;
+use futures::{Stream, StreamExt};
+use indexmap::IndexMap;
+use revive_dt_node_interaction::EthereumNode;
+use temp_dir::TempDir;
+use tokio::{sync::mpsc, try_join};
+use tracing::{debug, info, info_span, instrument};
+use tracing_appender::non_blocking::WorkerGuard;
+use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
+use revive_dt_common::types::Mode;
+use revive_dt_compiler::{CompilerOutput, SolidityCompiler};
 use revive_dt_config::*;
 use revive_dt_core::{
     Geth, Kitchensink, Platform,
-    driver::{Driver, State},
+    driver::{CaseDriver, CaseState},
 };
-use revive_dt_format::{corpus::Corpus, metadata::MetadataFile};
+use revive_dt_format::{
-use revive_dt_node::pool::NodePool;
+    case::{Case, CaseIdx},
+    corpus::Corpus,
+    input::{Input, Step},
+    metadata::{ContractPathAndIdent, MetadataFile},
+    mode::ParsedMode,
+};
+use revive_dt_node::{Node, pool::NodePool};
 use revive_dt_report::reporter::{Report, Span};
-use temp_dir::TempDir;
+
-use tracing::Level;
+use crate::cached_compiler::CachedCompiler;
-use tracing_subscriber::{EnvFilter, FmtSubscriber, fmt::format::FmtSpan};
 
 static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 
-fn main() -> anyhow::Result<()> {
+/// this represents a single "test"; a mode, path and collection of cases.
-    let args = init_cli()?;
+#[derive(Clone, Debug)]
-
+struct Test<'a> {
-    for (corpus, tests) in collect_corpora(&args)? {
+    metadata: &'a MetadataFile,
-        let span = Span::new(corpus, args.clone())?;
+    metadata_file_path: &'a Path,
-
+    mode: Mode,
-        match &args.compile_only {
+    case_idx: CaseIdx,
-            Some(platform) => compile_corpus(&args, &tests, platform, span),
+    case: &'a Case,
-            None => execute_corpus(&args, &tests, span)?,
-        }
-
-        Report::save()?;
-    }
-
-    Ok(())
 }
 
-fn init_cli() -> anyhow::Result<Arguments> {
+/// This represents the results that we gather from running test cases.
+type CaseResult = Result<usize, anyhow::Error>;
+
+fn main() -> anyhow::Result<()> {
+    let (args, _guard) = init_cli()?;
+    info!(
+        leader = args.leader.to_string(),
+        follower = args.follower.to_string(),
+        working_directory = %args.directory().display(),
+        number_of_nodes = args.number_of_nodes,
+        invalidate_compilation_cache = args.invalidate_compilation_cache,
+        "Differential testing tool has been initialized"
+    );
+
+    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).await,
+                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, WorkerGuard)> {
+    let (writer, guard) = tracing_appender::non_blocking::NonBlockingBuilder::default()
+        .lossy(false)
+        // Assuming that each line contains 255 characters and that each character is one byte, then
+        // this means that our buffer is about 4GBs large.
+        .buffered_lines_limit(0x1000000)
+        .thread_name("buffered writer")
+        .finish(std::io::stdout());
+
     let subscriber = FmtSubscriber::builder()
-        .with_thread_ids(true)
+        .with_writer(writer)
-        .with_thread_names(true)
+        .with_thread_ids(false)
+        .with_thread_names(false)
         .with_env_filter(EnvFilter::from_default_env())
-        .with_span_events(FmtSpan::ENTER | FmtSpan::CLOSE)
+        .with_ansi(false)
         .pretty()
         .finish();
     tracing::subscriber::set_global_default(subscriber)?;
+    info!("Differential testing tool is starting");
 
     let mut args = Arguments::parse();
 
@@ -60,89 +125,568 @@ fn init_cli() -> anyhow::Result<Arguments> {
             args.temp_dir = Some(&TEMP_DIR);
         }
     }
-    tracing::info!("workdir: {}", args.directory().display());
 
-    ThreadPoolBuilder::new()
+    Ok((args, guard))
-        .num_threads(args.workers)
-        .build_global()?;
-
-    Ok(args)
 }
 
+#[instrument(level = "debug", name = "Collecting Corpora", skip_all)]
 fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<MetadataFile>>> {
     let mut corpora = HashMap::new();
 
     for path in &args.corpus {
+        let span = info_span!("Processing corpus file", path = %path.display());
+        let _guard = span.enter();
+
         let corpus = Corpus::try_from_path(path)?;
-        tracing::info!("found corpus: {}", path.display());
+        info!(
+            name = corpus.name(),
+            number_of_contained_paths = corpus.path_count(),
+            "Deserialized corpus file"
+        );
         let tests = corpus.enumerate_tests();
-        tracing::info!("corpus '{}' contains {} tests", &corpus.name, tests.len());
         corpora.insert(corpus, tests);
     }
 
     Ok(corpora)
 }
 
-fn run_driver<L, F>(args: &Arguments, tests: &[MetadataFile], 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(
+    let tests = prepare_tests::<L, F>(args, metadata_files);
-        |MetadataFile {
+    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx).await?;
-             content: metadata,
+    let status_reporter_task = start_reporter_task(report_rx);
-             path: metadata_file_path,
-         }| {
-            // Starting a new tracing span for this metadata file. This allows our logs to be clear
-            // about which metadata file the logs belong to. We can add other information into this
-            // as well to be able to associate the logs with the correct metadata file and case
-            // that's being executed.
-            let tracing_span = tracing::span!(
-                Level::INFO,
-                "Running driver",
-                metadata_file_path = metadata_file_path.display().to_string(),
-            );
-            let _guard = tracing_span.enter();
 
-            let mut driver = Driver::<L, F>::new(
+    tokio::join!(status_reporter_task, driver_task);
-                metadata,
-                args,
-                leader_nodes.round_robbin(),
-                follower_nodes.round_robbin(),
-            );
-
-            match driver.execute(span) {
-                Ok(_) => {
-                    tracing::info!(
-                        "metadata {} success",
-                        metadata.directory().as_ref().unwrap().display()
-                    );
-                }
-                Err(error) => {
-                    tracing::warn!(
-                        "metadata {} failure: {error:?}",
-                        metadata.file_path.as_ref().unwrap().display()
-                    );
-                }
-            }
-        },
-    );
 
     Ok(())
 }
 
-fn execute_corpus(args: &Arguments, tests: &[MetadataFile], span: Span) -> anyhow::Result<()> {
+fn prepare_tests<'a, L, F>(
+    args: &Arguments,
+    metadata_files: &'a [MetadataFile],
+) -> impl Stream<Item = Test<'a>>
+where
+    L: Platform,
+    F: Platform,
+    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+{
+    let filtered_tests = metadata_files
+        .iter()
+        .flat_map(|metadata_file| {
+            metadata_file
+                .cases
+                .iter()
+                .enumerate()
+                .map(move |(case_idx, case)| (metadata_file, case_idx, case))
+        })
+        // Flatten over the modes, prefer the case modes over the metadata file modes.
+        .flat_map(|(metadata_file, case_idx, case)| {
+            case.modes
+                .as_ref()
+                .or(metadata_file.modes.as_ref())
+                .map(|modes| ParsedMode::many_to_modes(modes.iter()).collect::<Vec<_>>())
+                .unwrap_or(Mode::all().collect())
+                .into_iter()
+                .map(move |mode| (metadata_file, case_idx, case, mode))
+        })
+        .fold(
+            IndexMap::<_, BTreeMap<_, Vec<_>>>::new(),
+            |mut map, (metadata_file, case_idx, case, mode)| {
+                let test = Test {
+                    metadata: metadata_file,
+                    metadata_file_path: metadata_file.metadata_file_path.as_path(),
+                    mode: mode.clone(),
+                    case_idx: CaseIdx::new(case_idx),
+                    case,
+                };
+                map.entry(mode)
+                    .or_default()
+                    .entry(test.case_idx)
+                    .or_default()
+                    .push(test);
+                map
+            },
+        )
+        .into_values()
+        .flatten()
+        .flat_map(|(_, value)| value.into_iter())
+        // Filter the test out if the leader and follower do not support the target.
+        .filter(|test| {
+            let leader_support =
+                <L::Blockchain as Node>::matches_target(test.metadata.targets.as_deref());
+            let follower_support =
+                <F::Blockchain as Node>::matches_target(test.metadata.targets.as_deref());
+            let is_allowed = leader_support && follower_support;
+
+            if !is_allowed {
+                debug!(
+                    file_path = %test.metadata.relative_path().display(),
+                    leader_support,
+                    follower_support,
+                    "Target is not supported, throwing metadata file out"
+                )
+            }
+
+            is_allowed
+        })
+        // Filter the test out if the metadata file is ignored.
+        .filter(|test| {
+            if test.metadata.ignore.is_some_and(|ignore| ignore) {
+                debug!(
+                    file_path = %test.metadata.relative_path().display(),
+                    "Metadata file is ignored, throwing case out"
+                );
+                false
+            } else {
+                true
+            }
+        })
+        // Filter the test case if the case is ignored.
+        .filter(|test| {
+            if test.case.ignore.is_some_and(|ignore| ignore) {
+                debug!(
+                    file_path = %test.metadata.relative_path().display(),
+                    case_idx = %test.case_idx,
+                    "Case is ignored, throwing case out"
+                );
+                false
+            } else {
+                true
+            }
+        })
+        // Filtering based on the EVM version compatibility
+        .filter(|test| {
+            if let Some(evm_version_requirement) = test.metadata.required_evm_version {
+                let leader_compatibility = evm_version_requirement
+                    .matches(&<L::Blockchain as revive_dt_node::Node>::evm_version());
+                let follower_compatibility = evm_version_requirement
+                    .matches(&<F::Blockchain as revive_dt_node::Node>::evm_version());
+                let is_allowed = leader_compatibility && follower_compatibility;
+
+                if !is_allowed {
+                    debug!(
+                        file_path = %test.metadata.relative_path().display(),
+                        case_idx = %test.case_idx,
+                        leader_compatibility,
+                        follower_compatibility,
+                        "EVM Version is incompatible, throwing case out"
+                    );
+                }
+
+                is_allowed
+            } else {
+                true
+            }
+        });
+
+    stream::iter(filtered_tests)
+        // Filter based on the compiler compatibility
+        .filter_map(move |test| async move {
+            let leader_support = does_compiler_support_mode::<L>(args, &test.mode)
+                .await
+                .ok()
+                .unwrap_or(false);
+            let follower_support = does_compiler_support_mode::<F>(args, &test.mode)
+                .await
+                .ok()
+                .unwrap_or(false);
+            let is_allowed = leader_support && follower_support;
+
+            if !is_allowed {
+                debug!(
+                    file_path = %test.metadata.relative_path().display(),
+                    leader_support,
+                    follower_support,
+                    "Compilers do not support this, throwing case out"
+                );
+            }
+
+            is_allowed.then_some(test)
+        })
+}
+
+async fn does_compiler_support_mode<P: Platform>(
+    args: &Arguments,
+    mode: &Mode,
+) -> anyhow::Result<bool> {
+    let compiler_version_or_requirement = mode.compiler_version_to_use(args.solc.clone());
+    let compiler_path =
+        P::Compiler::get_compiler_executable(args, compiler_version_or_requirement).await?;
+    let compiler_version = P::Compiler::new(compiler_path.clone()).version().await?;
+
+    Ok(P::Compiler::supports_mode(
+        &compiler_version,
+        mode.optimize_setting,
+        mode.pipeline,
+    ))
+}
+
+async fn start_driver_task<'a, L, F>(
+    args: &Arguments,
+    tests: impl Stream<Item = Test<'a>>,
+    span: Span,
+    report_tx: mpsc::UnboundedSender<(Test<'a>, 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 result = handle_case_driver::<L, F>(
+                    test.metadata_file_path,
+                    test.metadata,
+                    test.case_idx,
+                    test.case,
+                    test.mode.clone(),
+                    args,
+                    cached_compiler,
+                    leader_node,
+                    follower_node,
+                    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.
+    let mut buf = BufWriter::new(stderr());
+    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.metadata_file_path.display();
+        let test_mode = test.mode.clone();
+
+        match case_result {
+            Ok(_inputs) => {
+                number_of_successes += 1;
+                let _ = writeln!(
+                    buf,
+                    "{GREEN}Case Succeeded:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
+                );
+            }
+            Err(err) => {
+                number_of_failures += 1;
+                let _ = writeln!(
+                    buf,
+                    "{RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
+                );
+                failures.push((test, err));
+            }
+        }
+    }
+
+    let _ = writeln!(buf,);
+    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() {
+        let _ = writeln!(buf, "{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.metadata_file_path.display();
+            let test_mode = test.mode.clone();
+
+            let _ = writeln!(
+                buf,
+                "---- {RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode}) ----\n\n{err}\n"
+            );
+        }
+    }
+
+    // Summary at the end.
+    let _ = writeln!(
+        buf,
+        "{} 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)]
+#[instrument(
+    level = "info",
+    name = "Handling Case"
+    skip_all,
+    fields(
+        metadata_file_path = %metadata.relative_path().display(),
+        mode = %mode,
+        %case_idx,
+        case_name = case.name.as_deref().unwrap_or("Unnamed Case"),
+        leader_node = leader_node.id(),
+        follower_node = follower_node.id(),
+    )
+)]
+async fn handle_case_driver<L, F>(
+    metadata_file_path: &Path,
+    metadata: &MetadataFile,
+    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 (
+        (
+            CompilerOutput {
+                contracts: leader_pre_link_contracts,
+            },
+            _,
+        ),
+        (
+            CompilerOutput {
+                contracts: follower_pre_link_contracts,
+            },
+            _,
+        ),
+    ) = try_join!(
+        cached_compiler.compile_contracts::<L>(metadata, metadata_file_path, &mode, config, None),
+        cached_compiler.compile_contracts::<F>(metadata, metadata_file_path, &mode, config, None)
+    )?;
+
+    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())
+    {
+        debug!(%library_instance, "Deploying Library Instance");
+
+        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) => {
+                anyhow::bail!("Failed to hex-decode the byte code {}", error)
+            }
+        };
+        let follower_code = match alloy::hex::decode(follower_code) {
+            Ok(code) => code,
+            Err(error) => {
+                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, follower_receipt) = try_join!(
+            leader_node.execute_transaction(leader_tx),
+            follower_node.execute_transaction(follower_tx)
+        )?;
+
+        debug!(
+            ?library_instance,
+            library_address = ?leader_receipt.contract_address,
+            "Deployed library to leader"
+        );
+        debug!(
+            ?library_instance,
+            library_address = ?follower_receipt.contract_address,
+            "Deployed library to follower"
+        );
+
+        let leader_library_address = leader_receipt
+            .contract_address
+            .context("Contract deployment didn't return an address")?;
+        let follower_library_address = follower_receipt
+            .contract_address
+            .context("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 (
+        (
+            CompilerOutput {
+                contracts: leader_post_link_contracts,
+            },
+            leader_compiler_version,
+        ),
+        (
+            CompilerOutput {
+                contracts: follower_post_link_contracts,
+            },
+            follower_compiler_version,
+        ),
+    ) = try_join!(
+        cached_compiler.compile_contracts::<L>(
+            metadata,
+            metadata_file_path,
+            &mode,
+            config,
+            leader_deployed_libraries.as_ref()
+        ),
+        cached_compiler.compile_contracts::<F>(
+            metadata,
+            metadata_file_path,
+            &mode,
+            config,
+            follower_deployed_libraries.as_ref()
+        )
+    )?;
+
+    let leader_state = CaseState::<L>::new(
+        leader_compiler_version,
+        leader_post_link_contracts,
+        leader_deployed_libraries.unwrap_or_default(),
+    );
+    let follower_state = CaseState::<F>::new(
+        follower_compiler_version,
+        follower_post_link_contracts,
+        follower_deployed_libraries.unwrap_or_default(),
+    );
+
+    let mut driver = CaseDriver::<L, F>::new(
+        metadata,
+        case,
+        leader_node,
+        follower_node,
+        leader_state,
+        follower_state,
+    );
+    driver
+        .execute()
+        .await
+        .inspect(|steps_executed| info!(steps_executed, "Case succeeded"))
+}
+
+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!(),
     }
@@ -150,24 +694,55 @@ fn execute_corpus(args: &Arguments, tests: &[MetadataFile], span: Span) -> anyho
     Ok(())
 }
 
-fn compile_corpus(
+async fn compile_corpus(
     config: &Arguments,
     tests: &[MetadataFile],
     platform: &TestingPlatform,
-    span: Span,
+    _: Span,
 ) {
-    tests.par_iter().for_each(|metadata| {
+    let tests = tests.iter().flat_map(|metadata| {
-        for mode in &metadata.solc_modes() {
+        metadata
-            match platform {
+            .solc_modes()
-                TestingPlatform::Geth => {
+            .into_iter()
-                    let mut state = State::<Geth>::new(config, span);
+            .map(move |solc_mode| (metadata, solc_mode))
-                    let _ = state.build_contracts(mode, metadata);
-                }
-                TestingPlatform::Kitchensink => {
-                    let mut state = State::<Kitchensink>::new(config, span);
-                    let _ = state.build_contracts(mode, metadata);
-                }
-            };
-        }
     });
+
+    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 _ = cached_compiler
+                            .compile_contracts::<Geth>(
+                                metadata,
+                                metadata.metadata_file_path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                            )
+                            .await;
+                    }
+                    TestingPlatform::Kitchensink => {
+                        let _ = cached_compiler
+                            .compile_contracts::<Kitchensink>(
+                                metadata,
+                                metadata.metadata_file_path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                            )
+                            .await;
+                    }
+                }
+            }
+        })
+        .await;
 }

crates/format/Cargo.toml

@@ -9,11 +9,23 @@ 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 }
+futures = { workspace = true }
+regex = { workspace = true }
 tracing = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true }
+
+[lints]
+workspace = true

crates/format/src/case.rs

@@ -1,12 +1,76 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
-use crate::{input::Input, mode::Mode};
+use revive_dt_common::{macros::define_wrapper_type, types::Mode};
 
-#[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
+                }
+            })
+    }
+
+    pub fn solc_modes(&self) -> Vec<Mode> {
+        match &self.modes {
+            Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
+            None => Mode::all().collect(),
+        }
+    }
+}
+
+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 Display;
+);

crates/format/src/corpus.rs

@@ -3,65 +3,127 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use revive_dt_common::iterators::FilesWithExtensionIterator;
 use serde::{Deserialize, Serialize};
+use tracing::{debug, info};
 
-use crate::metadata::MetadataFile;
+use crate::metadata::{Metadata, MetadataFile};
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct Corpus {
+#[serde(untagged)]
-    pub name: String,
+pub enum Corpus {
-    pub path: PathBuf,
+    SinglePath { name: String, path: PathBuf },
+    MultiplePaths { name: String, paths: Vec<PathBuf> },
 }
 
 impl Corpus {
-    /// Try to read and parse the corpus definition file at given `path`.
+    pub fn try_from_path(file_path: impl AsRef<Path>) -> anyhow::Result<Self> {
-    pub fn try_from_path(path: &Path) -> anyhow::Result<Self> {
+        let mut corpus = File::open(file_path.as_ref())
-        let file = File::open(path)?;
+            .map_err(anyhow::Error::from)
-        Ok(serde_json::from_reader(file)?)
+            .and_then(|file| serde_json::from_reader::<_, Corpus>(file).map_err(Into::into))?;
+
+        for path in corpus.paths_iter_mut() {
+            *path = file_path
+                .as_ref()
+                .parent()
+                .ok_or_else(|| {
+                    anyhow::anyhow!("Corpus path '{}' does not point to a file", path.display())
+                })?
+                .canonicalize()
+                .map_err(|error| {
+                    anyhow::anyhow!(
+                        "Failed to canonicalize path to corpus '{}': {error}",
+                        path.display()
+                    )
+                })?
+                .join(path.as_path())
+        }
+
+        Ok(corpus)
     }
 
-    /// Scan the corpus base directory and return all tests found.
     pub fn enumerate_tests(&self) -> Vec<MetadataFile> {
-        let mut tests = Vec::new();
+        let mut tests = self
-        collect_metadata(&self.path, &mut tests);
+            .paths_iter()
+            .flat_map(|root_path| {
+                if !root_path.is_dir() {
+                    Box::new(std::iter::once(root_path.to_path_buf()))
+                        as Box<dyn Iterator<Item = _>>
+                } else {
+                    Box::new(
+                        FilesWithExtensionIterator::new(root_path)
+                            .with_use_cached_fs(true)
+                            .with_allowed_extension("sol")
+                            .with_allowed_extension("json"),
+                    )
+                }
+                .map(move |metadata_file_path| (root_path, metadata_file_path))
+            })
+            .filter_map(|(root_path, metadata_file_path)| {
+                Metadata::try_from_file(&metadata_file_path)
+                    .or_else(|| {
+                        debug!(
+                            discovered_from = %root_path.display(),
+                            metadata_file_path = %metadata_file_path.display(),
+                            "Skipping file since it doesn't contain valid metadata"
+                        );
+                        None
+                    })
+                    .map(|metadata| MetadataFile {
+                        metadata_file_path,
+                        corpus_file_path: root_path.to_path_buf(),
+                        content: metadata,
+                    })
+                    .inspect(|metadata_file| {
+                        debug!(
+                            metadata_file_path = %metadata_file.relative_path().display(),
+                            "Loaded metadata file"
+                        )
+                    })
+            })
+            .collect::<Vec<_>>();
+        tests.sort_by(|a, b| a.metadata_file_path.cmp(&b.metadata_file_path));
+        tests.dedup_by(|a, b| a.metadata_file_path == b.metadata_file_path);
+        info!(
+            len = tests.len(),
+            corpus_name = self.name(),
+            "Found tests in Corpus"
+        );
         tests
     }
-}
 
-/// Recursively walks `path` and parses any JSON or Solidity file into a test
+    pub fn name(&self) -> &str {
-/// definition [Metadata].
+        match self {
-///
+            Corpus::SinglePath { name, .. } | Corpus::MultiplePaths { name, .. } => name.as_str(),
-/// Found tests are inserted into `tests`.
-///
-/// `path` is expected to be a directory.
-pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
-    let dir_entry = match std::fs::read_dir(path) {
-        Ok(dir_entry) => dir_entry,
-        Err(error) => {
-            tracing::error!("failed to read dir '{}': {error}", path.display());
-            return;
         }
-    };
+    }
 
-    for entry in dir_entry {
+    pub fn paths_iter(&self) -> impl Iterator<Item = &Path> {
-        let entry = match entry {
+        match self {
-            Ok(entry) => entry,
+            Corpus::SinglePath { path, .. } => {
-            Err(error) => {
+                Box::new(std::iter::once(path.as_path())) as Box<dyn Iterator<Item = _>>
-                tracing::error!("error reading dir entry: {error}");
-                continue;
             }
-        };
+            Corpus::MultiplePaths { paths, .. } => {
-
+                Box::new(paths.iter().map(|path| path.as_path())) as Box<dyn Iterator<Item = _>>
-        let path = entry.path();
-        if path.is_dir() {
-            collect_metadata(&path, tests);
-            continue;
-        }
-
-        if path.is_file() {
-            if let Some(metadata) = MetadataFile::try_from_file(&path) {
-                tests.push(metadata)
             }
         }
     }
+
+    pub fn paths_iter_mut(&mut self) -> impl Iterator<Item = &mut PathBuf> {
+        match self {
+            Corpus::SinglePath { path, .. } => {
+                Box::new(std::iter::once(path)) as Box<dyn Iterator<Item = _>>
+            }
+            Corpus::MultiplePaths { paths, .. } => {
+                Box::new(paths.iter_mut()) as Box<dyn Iterator<Item = _>>
+            }
+        }
+    }
+
+    pub fn path_count(&self) -> usize {
+        match self {
+            Corpus::SinglePath { .. } => 1,
+            Corpus::MultiplePaths { paths, .. } => paths.len(),
+        }
+    }
 }

crates/format/src/lib.rs

@@ -5,3 +5,4 @@ pub mod corpus;
 pub mod input;
 pub mod metadata;
 pub mod mode;
+pub mod traits;

crates/format/src/metadata.rs

@@ -1,16 +1,23 @@
 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 tracing::error;
+
+use crate::{case::Case, mode::ParsedMode};
 
 pub const METADATA_FILE_EXTENSION: &str = "json";
 pub const SOLIDITY_CASE_FILE_EXTENSION: &str = "sol";
@@ -18,16 +25,26 @@ pub const SOLIDITY_CASE_COMMENT_MARKER: &str = "//!";
 
 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct MetadataFile {
-    pub path: PathBuf,
+    /// The path of the metadata file. This will either be a JSON or solidity file.
+    pub metadata_file_path: PathBuf,
+
+    /// This is the path contained within the corpus file. This could either be the path of some dir
+    /// or could be the actual metadata file path.
+    pub corpus_file_path: PathBuf,
+
+    /// The metadata contained within the file.
     pub content: Metadata,
 }
 
 impl MetadataFile {
-    pub fn try_from_file(path: &Path) -> Option<Self> {
+    pub fn relative_path(&self) -> &Path {
-        Metadata::try_from_file(path).map(|metadata| Self {
+        if self.corpus_file_path.is_file() {
-            path: path.to_owned(),
+            &self.corpus_file_path
-            content: metadata,
+        } else {
-        })
+            self.metadata_file_path
+                .strip_prefix(&self.corpus_file_path)
+                .unwrap()
+        }
     }
 }
 
@@ -39,32 +56,51 @@ impl Deref for MetadataFile {
     }
 }
 
-#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
+#[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) => {
-                    tracing::debug!("compiler: ignoring unknown mode '{mode}'");
-                    None
-                }
-            })
-            .cloned()
-            .collect()
     }
 
     /// Returns the base directory of this metadata.
@@ -77,28 +113,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)
@@ -113,10 +156,7 @@ impl Metadata {
     pub fn try_from_file(path: &Path) -> Option<Self> {
         assert!(path.is_file(), "not a file: {}", path.display());
 
-        let Some(file_extension) = path.extension() else {
+        let file_extension = path.extension()?;
-            tracing::debug!("skipping corpus file: {}", path.display());
-            return None;
-        };
 
         if file_extension == METADATA_FILE_EXTENSION {
             return Self::try_from_json(path);
@@ -126,18 +166,12 @@ impl Metadata {
             return Self::try_from_solidity(path);
         }
 
-        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| {
+            .inspect_err(|err| error!(path = %path.display(), %err, "Failed to open file"))
-                tracing::error!(
-                    "opening JSON test metadata file '{}' error: {error}",
-                    path.display()
-                );
-            })
             .ok()?;
 
         match serde_json::from_reader::<_, Metadata>(file) {
@@ -145,11 +179,8 @@ impl Metadata {
                 metadata.file_path = Some(path.to_path_buf());
                 Some(metadata)
             }
-            Err(error) => {
+            Err(err) => {
-                tracing::error!(
+                error!(path = %path.display(), %err, "Deserialization of metadata failed");
-                    "parsing JSON test metadata file '{}' error: {error}",
-                    path.display()
-                );
                 None
             }
         }
@@ -157,12 +188,7 @@ impl Metadata {
 
     fn try_from_solidity(path: &Path) -> Option<Self> {
         let spec = read_to_string(path)
-            .inspect_err(|error| {
+            .inspect_err(|err| error!(path = %path.display(), %err, "Failed to read file content"))
-                tracing::error!(
-                    "opening JSON test metadata file '{}' error: {error}",
-                    path.display()
-                );
-            })
             .ok()?
             .lines()
             .filter_map(|line| line.strip_prefix(SOLIDITY_CASE_COMMENT_MARKER))
@@ -178,21 +204,343 @@ 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) => {
+            Err(err) => {
-                tracing::error!(
+                error!(path = %path.display(), %err, "Failed to deserialize metadata");
-                    "parsing Solidity test metadata file '{}' error: '{error}' from data: {spec}",
-                    path.display()
-                );
                 None
             }
         }
     }
+
+    /// 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) impl Display;
+);
+
+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) impl Display;
+);
+
+/// 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");
+    }
 }

crates/format/src/mode.rs

@@ -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);
+
+        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 Display for ParsedMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut has_written = false;
+
+        if let Some(pipeline) = self.pipeline {
+            pipeline.fmt(f)?;
+            if let Some(optimize_flag) = self.optimize_flag {
+                f.write_str(if optimize_flag { "+" } else { "-" })?;
             }
+            has_written = true;
         }
 
-        None
+        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<'de> Deserialize<'de> for Mode {
+impl From<ParsedMode> for String {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    fn from(parsed_mode: ParsedMode) -> Self {
-    where
+        parsed_mode.to_string()
-        D: Deserializer<'de>,
+    }
-    {
+}
-        let mode_string = String::deserialize(deserializer)?;
+
-
+impl TryFrom<String> for ParsedMode {
-        if let Some(solc_mode) = SolcMode::parse_from_mode_string(&mode_string) {
+    type Error = anyhow::Error;
-            return Ok(Self::Solidity(solc_mode));
+    fn try_from(value: String) -> Result<Self, Self::Error> {
-        }
+        ParsedMode::from_str(&value)
-
+    }
-        Ok(Self::Unknown(mode_string))
+}
+
+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)
+                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
+            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)
+                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
+            let expected_set: HashSet<_> = expected.into_iter().map(|s| s.to_owned()).collect();
+            let actual_set: HashSet<_> = parsed.to_modes().map(|m| m.to_string()).collect();
+
+            assert_eq!(
+                expected_set, actual_set,
+                "Mode string '{actual}' did not expand to '{expected_set:?}': got '{actual_set:?}'"
+            );
+        }
     }
 }

crates/format/src/traits.rs

@@ -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
+    }
+}

crates/node-interaction/Cargo.toml

@@ -11,6 +11,6 @@ rust-version.workspace = true
 [dependencies]
 alloy = { workspace = true }
 anyhow = { workspace = true }
-tracing = { workspace = true }
+
-once_cell = { workspace = true }
+[lints]
-tokio = { workspace = true }
+workspace = true

crates/node-interaction/src/lib.rs

@@ -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>>;
 }

crates/node-interaction/src/nonce.rs

@@ -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}"))
-}

crates/node-interaction/src/tokio_runtime.rs

@@ -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 {
-                    tracing::error!("tokio transaction task failed: {error}");
-                }
-                if let Err(error) = trace_task.await {
-                    tracing::error!("tokio trace transaction task failed: {error}");
-                }
-                if let Err(error) = nonce_task.await {
-                    tracing::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(())
-}

crates/node-interaction/src/trace.rs

@@ -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}"))
-}

crates/node-interaction/src/transaction.rs

@@ -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}"))
-}

crates/node/Cargo.toml

@@ -12,10 +12,15 @@ rust-version.workspace = true
 anyhow = { workspace = true }
 alloy = { 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,7 @@ sp-runtime = { workspace = true }
 
 [dev-dependencies]
 temp-dir = { workspace = true }
+tokio = { workspace = true }
+
+[lints]
+workspace = true

crates/node/src/common.rs

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

crates/node/src/constants.rs

@@ -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);

crates/node/src/geth.rs

@@ -1,35 +1,49 @@
 //! The go-ethereum node implementation.
 
 use std::{
-    collections::HashMap,
+    fs::{File, OpenOptions, create_dir_all, remove_dir_all},
-    fs::{File, 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,
+    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 anyhow::Context;
+use revive_common::EVMVersion;
+use tracing::{Instrument, instrument};
+
+use revive_dt_common::{
+    fs::clear_directory,
+    futures::{PollingWaitBehavior, poll},
 };
 use revive_dt_config::Arguments;
-use revive_dt_node_interaction::{
+use revive_dt_format::traits::ResolverApi;
-    EthereumNode, nonce::fetch_onchain_nonce, trace::trace_transaction,
+use revive_dt_node_interaction::EthereumNode;
-    transaction::execute_transaction,
-};
 
-use crate::Node;
+use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
 
 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 
@@ -41,22 +55,30 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
-pub struct Instance {
+#[allow(clippy::type_complexity)]
+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,
+    wallet: Arc<EthereumWallet>,
-    nonces: Mutex<HashMap<Address, u64>>,
+    nonce_manager: CachedNonceManager,
+    chain_id_filler: ChainIdFiller,
+    /// 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";
@@ -64,14 +86,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.
+    #[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)
@@ -96,111 +145,233 @@ impl Instance {
 
     /// Spawn the go-ethereum node child process.
     ///
-    /// [Instance::init] must be called priorly.
+    /// [Instance::init] must be called prior.
+    #[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.
+    #[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 maximum_wait_time = Duration::from_millis(self.start_timeout);
-        let mut stderr = BufReader::new(child.stderr.take().expect("should be piped")).lines();
-        let error = loop {
-            let Some(Ok(line)) = stderr.next() else {
-                break "child process stderr reading error".to_string();
-            };
-            if line.contains(Self::ERROR_MARKER) {
-                break 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();
+        let logs_file = OpenOptions::new()
-                return Ok(self);
+            .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(logs_file).lines();
+        let mut lines = vec![];
+        loop {
+            if let Some(Ok(line)) = stderr.next() {
+                if line.contains(Self::ERROR_MARKER) {
+                    anyhow::bail!("Failed to start geth {line}");
+                }
+                if line.contains(Self::READY_MARKER) {
+                    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();
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-        anyhow::bail!("geth node #{} spawn error: {error}", self.id)
+    fn geth_stdout_log_file_path(&self) -> PathBuf {
+        self.logs_directory.join(Self::GETH_STDOUT_LOG_FILE_NAME)
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    fn geth_stderr_log_file_path(&self) -> PathBuf {
+        self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
+    }
+
+    async fn provider(
+        &self,
+    ) -> anyhow::Result<FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>>
+    {
+        ProviderBuilder::new()
+            .disable_recommended_fillers()
+            .filler(FallbackGasFiller::new(
+                25_000_000,
+                1_000_000_000,
+                1_000_000_000,
+            ))
+            .filler(self.chain_id_filler.clone())
+            .filler(NonceFiller::new(self.nonce_manager.clone()))
+            .wallet(self.wallet.clone())
+            .connect(&self.connection_string)
+            .await
+            .map_err(Into::into)
     }
 }
 
-impl EthereumNode for Instance {
+impl EthereumNode for GethNode {
-    fn execute_transaction(
+    #[instrument(
+        level = "info",
+        skip_all,
+        fields(geth_node_id = self.id, connection_string = self.connection_string),
+        err,
+    )]
+    async fn execute_transaction(
         &self,
         transaction: TransactionRequest,
     ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let connection_string = self.connection_string();
+        let provider = self.provider().await?;
-        let wallet = self.wallet.clone();
 
-        tracing::debug!("Submitting transaction: {transaction:#?}");
+        let pending_transaction = provider.send_transaction(transaction).await.inspect_err(
+            |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
+        )?;
+        let transaction_hash = *pending_transaction.tx_hash();
 
-        execute_transaction(Box::pin(async move {
+        // The following is a fix for the "transaction indexing is in progress" error that we used
-            Ok(ProviderBuilder::new()
+        // to get. You can find more information on this in the following GH issue in geth
-                .wallet(wallet)
+        // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
-                .connect(&connection_string)
+        // before we can get the receipt of the transaction it needs to have been indexed by the
-                .await?
+        // node's indexer. Just because the transaction has been confirmed it doesn't mean that it
-                .send_transaction(transaction)
+        // has been indexed. When we call alloy's `get_receipt` it checks if the transaction was
-                .await?
+        // confirmed. If it has been, then it will call `eth_getTransactionReceipt` method which
-                .get_receipt()
+        // _might_ return the above error if the tx has not yet been indexed yet. So, we need to
-                .await?)
+        // 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.
+        let provider = Arc::new(provider);
+        poll(
+            Self::RECEIPT_POLLING_DURATION,
+            PollingWaitBehavior::Constant(Duration::from_millis(200)),
+            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(
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    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,
+            PollingWaitBehavior::Constant(Duration::from_millis(200)),
+            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
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    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),
@@ -208,53 +379,197 @@ impl EthereumNode for Instance {
         }
     }
 
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64> {
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-        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)?;
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-
+    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 {
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
+        self.provider()
+            .await?
+            .get_chain_id()
+            .await
+            .map_err(Into::into)
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
+        self.provider()
+            .await?
+            .get_transaction_receipt(*tx_hash)
+            .await?
+            .context("Failed to get the transaction receipt")
+            .map(|receipt| receipt.effective_gas_price)
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .map(|block| block.header.gas_limit as _)
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .map(|block| block.header.beneficiary)
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
+        self.provider()
+            .await?
+            .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))
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
+        self.provider()
+            .await?
+            .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")
+            })
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    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)
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    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)
+    }
+
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    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: Arc::new(wallet),
-            nonces: Mutex::new(HashMap::new()),
+            chain_id_filler: Default::default(),
+            nonce_manager: Default::default(),
+            // 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),
         }
     }
 
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    fn id(&self) -> usize {
+        self.id as _
+    }
+
+    #[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<()> {
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    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(())
     }
 
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
-        self.init(genesis)?.spawn_process()?.wait_ready()?;
+        self.init(genesis)?.spawn_process()?;
         Ok(())
     }
 
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.geth)
             .arg("--version")
@@ -266,27 +581,35 @@ impl Node for Instance {
             .stdout;
         Ok(String::from_utf8_lossy(&output).into())
     }
+
+    fn matches_target(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 {
+    #[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();
@@ -296,26 +619,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)
+    }
 }

crates/node/src/lib.rs

@@ -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;
@@ -15,6 +18,9 @@ pub trait Node: EthereumNode {
     /// Create a new uninitialized instance.
     fn new(config: &Arguments) -> Self;
 
+    /// Returns the identifier of the node.
+    fn id(&self) -> usize;
+
     /// Spawns a node configured according to the genesis json.
     ///
     /// Blocking until it's ready to accept transactions.
@@ -23,11 +29,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(targets: Option<&[String]>) -> bool;
+
+    /// Returns the EVM version of the node.
+    fn evm_version() -> EVMVersion;
 }

crates/node/src/pool.rs

@@ -1,11 +1,12 @@
 //! This crate implements concurrent handling of testing node.
 
 use std::{
-    fs::read_to_string,
     sync::atomic::{AtomicUsize, Ordering},
     thread,
 };
 
+use revive_dt_common::cached_fs::read_to_string;
+
 use anyhow::Context;
 use revive_dt_config::Arguments;
 
@@ -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,6 @@ where
 
 fn spawn_node<T: Node + Send>(args: &Arguments, genesis: String) -> anyhow::Result<T> {
     let mut node = T::new(args);
-    tracing::info!("starting node: {}", node.connection_string());
     node.spawn(genesis)?;
     Ok(node)
 }

crates/report/Cargo.toml

@@ -8,11 +8,14 @@ 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 }
-tracing = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-revive-solc-json-interface = { workspace = true }
+
+[lints]
+workspace = true

crates/report/src/analyzer.rs

@@ -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);
             }
         }
     }

crates/report/src/reporter.rs

@@ -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,8 +185,6 @@ impl Report {
         let file = File::create(&path).context(path.display().to_string())?;
         serde_json::to_writer_pretty(file, &self)?;
 
-        tracing::info!("report written to: {}", path.display());
-
         Ok(())
     }
 }

crates/solc-binaries/Cargo.toml

@@ -9,10 +9,16 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
+revive-dt-common = { workspace = true }
+
 anyhow = { workspace = true }
 hex = { workspace = true }
 tracing = { workspace = true }
+tokio = { workspace = true }
 reqwest = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 sha2 = { workspace = true }
+
+[lints]
+workspace = true

crates/solc-binaries/src/cache.rs

@@ -6,41 +6,40 @@ 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) {
         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<()> {
-    tracing::info!("caching file: {}", path.display());
-
     let Ok(file) = File::create_new(path) else {
-        tracing::debug!("cache file already exists: {}", path.display());
         return Ok(());
     };
 
@@ -52,7 +51,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);
 

crates/solc-binaries/src/download.rs

@@ -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,90 @@ 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>,
-            version,
+        target: &'static str,
-            target,
+        list: &'static str,
-            list,
+    ) -> 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>> {
-        tracing::info!("downloading solc: {self:?}");
+        let builds = List::download(self.list).await?.builds;
-        let expected_digest = List::download(self.list)?
+        let build = builds
-            .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 +133,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();
     }
 }

crates/solc-binaries/src/lib.rs

@@ -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
 }

genesis.json

@@ -33,9 +33,5 @@
     "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "timestamp": "0x00",
-    "alloc": {
+    "alloc": {}
-        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
-            "balance": "1000000000000000000"
-        }
-    }
 }