Correct the key and value encoding for the cache

.gitignore

@@ -7,5 +7,3 @@ node_modules
 # 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.lock

@@ -4482,7 +4482,6 @@ dependencies = [
  "alloy",
  "alloy-primitives",
  "anyhow",
- "dashmap",
  "foundry-compilers-artifacts",
  "revive-common",
  "revive-dt-common",
@@ -4533,7 +4532,6 @@ dependencies = [
  "tempfile",
  "tokio",
  "tracing",
- "tracing-appender",
  "tracing-subscriber",
 ]
 
@@ -4545,7 +4543,6 @@ dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
  "anyhow",
- "futures",
  "regex",
  "revive-common",
  "revive-dt-common",
@@ -4588,19 +4585,13 @@ dependencies = [
 name = "revive-dt-report"
 version = "0.1.0"
 dependencies = [
- "alloy-primitives",
  "anyhow",
- "indexmap 2.10.0",
- "paste",
  "revive-dt-common",
  "revive-dt-compiler",
  "revive-dt-config",
  "revive-dt-format",
- "semver 1.0.26",
  "serde",
  "serde_json",
- "serde_with",
- "tokio",
  "tracing",
 ]
 
@@ -4852,30 +4843,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "schemars"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
-dependencies = [
- "dyn-clone",
- "ref-cast",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "schemars"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
-dependencies = [
- "dyn-clone",
- "ref-cast",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "schnellru"
 version = "0.2.4"
@@ -5106,17 +5073,15 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.14.0"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2c45cd61fefa9db6f254525d46e392b852e0e61d9a1fd36e5bd183450a556d5"
+checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa"
 dependencies = [
  "base64 0.22.1",
  "chrono",
  "hex",
  "indexmap 1.9.3",
  "indexmap 2.10.0",
- "schemars 0.9.0",
- "schemars 1.0.4",
  "serde",
  "serde_derive",
  "serde_json",
@@ -5126,9 +5091,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.14.0"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de90945e6565ce0d9a25098082ed4ee4002e047cb59892c318d66821e14bb30f"
+checksum = "8d00caa5193a3c8362ac2b73be6b9e768aa5a4b2f721d8f4b339600c3cb51f8e"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -6143,18 +6108,6 @@ dependencies = [
  "tracing-core",
 ]
 
-[[package]]
-name = "tracing-appender"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3566e8ce28cc0a3fe42519fc80e6b4c943cc4c8cef275620eb8dac2d3d4e06cf"
-dependencies = [
- "crossbeam-channel",
- "thiserror 1.0.69",
- "time",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "tracing-attributes"
 version = "0.1.28"

Cargo.toml

@@ -28,13 +28,11 @@ 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"
 regex = "1"
 moka = "0.12.10"
-paste = "1.0.15"
 reqwest = { version = "0.12.15", features = ["json"] }
 once_cell = "1.21"
 semver = { version = "1.0", features = ["serde"] }
@@ -44,7 +42,6 @@ serde_json = { version = "1.0", default-features = false, features = [
     "std",
     "unbounded_depth",
 ] }
-serde_with = { version = "3.14.0" }
 sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"
 sp-runtime = "41.1.0"
@@ -57,8 +54,7 @@ tokio = { version = "1.47.0", default-features = false, features = [
     "rt",
 ] }
 uuid = { version = "1.8", features = ["v4"] }
-tracing = { version = "0.1.41" }
+tracing = "0.1.41"
-tracing-appender = { version = "0.2.3" }
 tracing-subscriber = { version = "0.3.19", default-features = false, features = [
     "fmt",
     "json",
@@ -93,5 +89,3 @@ features = [
 inherits = "release"
 lto = true
 codegen-units = 1
-
-[workspace.lints.clippy]

README.md

@@ -1,210 +1,34 @@
-<div align="center">
+# revive-differential-tests
-  <h1><code>Revive Differential Tests</code></h1>
 
-  <p>
+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:
-    <strong>Differential testing for Ethereum-compatible smart contract stacks</strong>
+- 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.
-  </p>
+- Collect and compare benchmark metrics such as code size, gas usage or transaction throughput per seconds (TPS) of different blockchain implementations.
-</div>
+- Ensure reproducible contract builds across multiple compiler implementations or multiple host platforms.
+- Implement end-to-end regression tests for Ethereum-compatible smart contract stacks.
 
-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:
+# Declarative test format
 
-- Geth (EVM reference implementation)
+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.
-- Revive Kitchensink (Substrate-based PolkaVM + `eth-rpc` proxy)
 
-Use it to:
+# The `retester` utility
 
-- Detect observable differences between platforms (execution success, logs, state changes)
+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: 
-- 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')
 ```
 
-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:
+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:
 
 ```json
 {
-  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
+    "name": "ML Solidity Complex",
-  "path": "resolc-compiler-tests/fixtures/solidity"
+    "path": "/path/to/era-compiler-tests/solidity/complex"
 }
 ```
 
-> [!NOTE]  
+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 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="info" cargo run --release -- \
+RUST_LOG=debug cargo r --release -p revive-dt-core  -- --corpus ml-solidity-complex.json 
-    --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"
-  ]
-}
 ```

clippy.toml

@@ -1 +0,0 @@
-

crates/common/Cargo.toml

@@ -15,6 +15,3 @@ once_cell = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 tokio = { workspace = true, default-features = false, features = ["time"] }
-
-[lints]
-workspace = true

crates/common/src/macros/define_wrapper_type.rs

@@ -1,25 +1,3 @@
-#[macro_export]
-macro_rules! impl_for_wrapper {
-    (Display, $ident: ident) => {
-        #[automatically_derived]
-        impl std::fmt::Display for $ident {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                std::fmt::Display::fmt(&self.0, f)
-            }
-        }
-    };
-    (FromStr, $ident: ident) => {
-        #[automatically_derived]
-        impl std::str::FromStr for $ident {
-            type Err = anyhow::Error;
-
-            fn from_str(s: &str) -> anyhow::Result<Self> {
-                s.parse().map(Self).map_err(Into::into)
-            }
-        }
-    };
-}
-
 /// Defines wrappers around types.
 ///
 /// For example, the macro invocation seen below:
@@ -64,13 +42,7 @@ macro_rules! impl_for_wrapper {
 macro_rules! define_wrapper_type {
     (
         $(#[$meta: meta])*
-        $vis:vis struct $ident: ident($ty: ty)
+        $vis:vis struct $ident: ident($ty: ty);
-
-        $(
-            impl $($trait_ident: ident),*
-        )?
-
-        ;
     ) => {
         $(#[$meta])*
         $vis struct $ident($ty);
@@ -126,15 +98,9 @@ macro_rules! define_wrapper_type {
                 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};
+pub use define_wrapper_type;

crates/compiler/Cargo.toml

@@ -18,13 +18,9 @@ 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/lib.rs

@@ -47,7 +47,7 @@ pub trait SolidityCompiler {
         version: impl Into<VersionOrRequirement>,
     ) -> impl Future<Output = anyhow::Result<PathBuf>>;
 
-    fn version(&self) -> impl Future<Output = anyhow::Result<Version>>;
+    fn version(&self) -> anyhow::Result<Version>;
 
     /// Does the compiler support the provided mode and version settings?
     fn supports_mode(

crates/compiler/src/revive_resolc.rs

@@ -4,10 +4,8 @@
 use std::{
     path::PathBuf,
     process::{Command, Stdio},
-    sync::LazyLock,
 };
 
-use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_solc_json_interface::{
@@ -16,6 +14,7 @@ use revive_solc_json_interface::{
     SolcStandardJsonOutput,
 };
 
+use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 
 use alloy::json_abi::JsonAbi;
@@ -220,23 +219,16 @@ impl SolidityCompiler for Resolc {
         Ok(PathBuf::from("resolc"))
     }
 
-    async fn version(&self) -> anyhow::Result<semver::Version> {
+    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
+        // Logic for parsing the resolc version from the following string:
-        /// choose to cache the version in this way rather than through a field on the struct since
+        // Solidity frontend for the revive compiler version 0.3.0+commit.b238913.llvm-18.1.8
-        /// 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 ")
@@ -246,33 +238,19 @@ impl SolidityCompiler for Resolc {
             .next()
             .context("Version parsing failed")?;
 
-                let version = Version::parse(version_string)?;
+        Version::parse(version_string).map_err(Into::into)
-
-                vacant_entry.insert(version.clone());
-
-                Ok(version)
-            }
-        }
     }
 
     fn supports_mode(
-        _compiler_version: &Version,
+        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.
-
-        // Note: the original implementation of this function looked like the following:
-        // ```
-        // pipeline == ModePipeline::ViaYulIR && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
-        // ```
-        // However, that implementation is sadly incorrect since the version that's passed into this
-        // function is not the version of solc but the version of resolc. This is despite the fact
-        // that resolc depends on Solc for the initial Yul codegen. Therefore, we have skipped the
-        // version check until we do a better integrations between resolc and solc.
         pipeline == ModePipeline::ViaYulIR
+            && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
     }
 }
 
@@ -290,7 +268,7 @@ mod test {
         let compiler = Resolc::new(path);
 
         // Act
-        let version = compiler.version().await;
+        let version = compiler.version();
 
         // Assert
         let _ = version.expect("Failed to get version");

crates/compiler/src/solc.rs

@@ -4,10 +4,8 @@
 use std::{
     path::PathBuf,
     process::{Command, Stdio},
-    sync::LazyLock,
 };
 
-use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
@@ -49,7 +47,7 @@ impl SolidityCompiler for Solc {
         }: CompilerInput,
         _: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {
-        let compiler_supports_via_ir = self.version().await? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
+        let compiler_supports_via_ir = self.version()? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 
         // Be careful to entirely omit the viaIR field if the compiler does not support it,
         // as it will error if you provide fields it does not know about. Because
@@ -211,22 +209,14 @@ impl SolidityCompiler for Solc {
         Ok(path)
     }
 
-    async fn version(&self) -> anyhow::Result<semver::Version> {
+    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
+        // The following is the parsing code for the version from the solc version strings which
-        /// choose to cache the version in this way rather than through a field on the struct since
+        // look like the following:
-        /// 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())
@@ -242,13 +232,7 @@ impl SolidityCompiler for Solc {
             .next()
             .context("Version parsing failed")?;
 
-                let version = Version::parse(version_string)?;
+        Version::parse(version_string).map_err(Into::into)
-
-                vacant_entry.insert(version.clone());
-
-                Ok(version)
-            }
-        }
     }
 
     fn supports_mode(
@@ -272,13 +256,15 @@ mod test {
     async fn compiler_version_can_be_obtained() {
         // Arrange
         let args = Arguments::default();
+        println!("Getting compiler path");
         let path = Solc::get_compiler_executable(&args, Version::new(0, 7, 6))
             .await
             .unwrap();
+        println!("Got compiler path");
         let compiler = Solc::new(path);
 
         // Act
-        let version = compiler.version().await;
+        let version = compiler.version();
 
         // Assert
         assert_eq!(
@@ -291,13 +277,15 @@ mod test {
     async fn compiler_version_can_be_obtained1() {
         // Arrange
         let args = Arguments::default();
+        println!("Getting compiler path");
         let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
             .await
             .unwrap();
+        println!("Got compiler path");
         let compiler = Solc::new(path);
 
         // Act
-        let version = compiler.version().await;
+        let version = compiler.version();
 
         // Assert
         assert_eq!(

crates/compiler/tests/lib.rs

@@ -11,6 +11,7 @@ async fn contracts_can_be_compiled_with_solc() {
     let compiler_path = Solc::get_compiler_executable(&args, Version::new(0, 8, 30))
         .await
         .unwrap();
+    println!("About to assert");
 
     // Act
     let output = Compiler::<Solc>::new()

crates/config/Cargo.toml

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

crates/config/src/lib.rs

@@ -115,18 +115,6 @@ pub struct Arguments {
     #[arg(short, long = "kitchensink", default_value = "substrate-node")]
     pub kitchensink: PathBuf,
 
-    /// The path to the `revive-dev-node` executable.
-    ///
-    /// By default it uses `revive-dev-node` binary found in `$PATH`.
-    #[arg(long = "revive-dev-node", default_value = "revive-dev-node")]
-    pub revive_dev_node: PathBuf,
-
-    /// By default the tool uses the revive-dev-node when it's running differential tests against
-    /// PolkaVM since the dev-node is much faster than kitchensink. This flag allows the caller to
-    /// configure the tool to use kitchensink rather than the dev-node.
-    #[arg(long)]
-    pub use_kitchensink_not_dev_node: bool,
-
     /// The path to the `eth_proxy` executable.
     ///
     /// By default it uses `eth-rpc` binary found in `$PATH`.
@@ -136,14 +124,6 @@ pub struct Arguments {
     /// Controls if the compilation cache should be invalidated or not.
     #[arg(short, long)]
     pub invalidate_compilation_cache: bool,
-
-    /// Controls if the compiler input is included in the final report.
-    #[clap(long = "report.include-compiler-input")]
-    pub report_include_compiler_input: bool,
-
-    /// Controls if the compiler output is included in the final report.
-    #[clap(long = "report.include-compiler-output")]
-    pub report_include_compiler_output: bool,
 }
 
 impl Arguments {

crates/core/Cargo.toml

@@ -31,13 +31,9 @@ indexmap = { workspace = true }
 once_cell = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
-tracing-appender = { workspace = true }
 tracing-subscriber = { workspace = true }
 semver = { 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

@@ -9,7 +9,7 @@ use std::{
 
 use futures::FutureExt;
 use revive_dt_common::iterators::FilesWithExtensionIterator;
-use revive_dt_compiler::{Compiler, CompilerInput, CompilerOutput, Mode, SolidityCompiler};
+use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
 use revive_dt_config::Arguments;
 use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
 
@@ -35,7 +35,6 @@ impl CachedCompiler {
     }
 
     /// Compiles or gets the compilation artifacts from the cache.
-    #[allow(clippy::too_many_arguments)]
     #[instrument(
         level = "debug",
         skip_all,
@@ -53,19 +52,6 @@ impl CachedCompiler {
         mode: &Mode,
         config: &Arguments,
         deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-        compilation_success_report_callback: impl Fn(
-            Version,
-            PathBuf,
-            bool,
-            Option<CompilerInput>,
-            CompilerOutput,
-        ) + Clone,
-        compilation_failure_report_callback: impl Fn(
-            Option<Version>,
-            Option<PathBuf>,
-            Option<CompilerInput>,
-            String,
-        ),
     ) -> Result<(CompilerOutput, Version)> {
         static CACHE_KEY_LOCK: Lazy<RwLock<HashMap<CacheKey, Arc<Mutex<()>>>>> =
             Lazy::new(Default::default);
@@ -75,21 +61,9 @@ impl CachedCompiler {
             config,
             compiler_version_or_requirement,
         )
-        .await
+        .await?;
-        .inspect_err(|err| {
+        let compiler_version =
-            compilation_failure_report_callback(None, None, None, err.to_string())
+            <P::Compiler as SolidityCompiler>::new(compiler_path.clone()).version()?;
-        })?;
-        let compiler_version = <P::Compiler as SolidityCompiler>::new(compiler_path.clone())
-            .version()
-            .await
-            .inspect_err(|err| {
-                compilation_failure_report_callback(
-                    None,
-                    Some(compiler_path.clone()),
-                    None,
-                    err.to_string(),
-                )
-            })?;
 
         let cache_key = CacheKey {
             platform_key: P::config_id().to_string(),
@@ -99,19 +73,13 @@ impl CachedCompiler {
         };
 
         let compilation_callback = || {
-            let compiler_path = compiler_path.clone();
-            let compiler_version = compiler_version.clone();
-            let compilation_success_report_callback = compilation_success_report_callback.clone();
             async move {
                 compile_contracts::<P>(
                     metadata.directory()?,
                     compiler_path,
-                    compiler_version,
                     metadata.files_to_compile()?,
                     mode,
                     deployed_libraries,
-                    compilation_success_report_callback,
-                    compilation_failure_report_callback,
                 )
                 .map(|compilation_result| compilation_result.map(CacheValue::new))
                 .await
@@ -156,19 +124,10 @@ impl CachedCompiler {
                 };
                 let _guard = mutex.lock().await;
 
-                match self.0.get(&cache_key).await {
+                self.0
-                    Some(cache_value) => {
+                    .get_or_insert_with(&cache_key, compilation_callback)
-                        compilation_success_report_callback(
+                    .await
-                            compiler_version.clone(),
+                    .map(|value| value.compiler_output)?
-                            compiler_path,
-                            true,
-                            None,
-                            cache_value.compiler_output.clone(),
-                        );
-                        cache_value.compiler_output
-                    }
-                    None => compilation_callback().await?.compiler_output,
-                }
             }
         };
 
@@ -176,34 +135,19 @@ impl CachedCompiler {
     }
 }
 
-#[allow(clippy::too_many_arguments)]
 async fn compile_contracts<P: Platform>(
     metadata_directory: impl AsRef<Path>,
     compiler_path: impl AsRef<Path>,
-    compiler_version: Version,
     mut files_to_compile: impl Iterator<Item = PathBuf>,
     mode: &Mode,
     deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-    compilation_success_report_callback: impl Fn(
-        Version,
-        PathBuf,
-        bool,
-        Option<CompilerInput>,
-        CompilerOutput,
-    ),
-    compilation_failure_report_callback: impl Fn(
-        Option<Version>,
-        Option<PathBuf>,
-        Option<CompilerInput>,
-        String,
-    ),
 ) -> Result<CompilerOutput> {
     let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
         .with_allowed_extension("sol")
         .with_use_cached_fs(true)
         .collect::<Vec<_>>();
 
-    let compiler = Compiler::<P::Compiler>::new()
+    Compiler::<P::Compiler>::new()
         .with_allow_path(metadata_directory)
         // Handling the modes
         .with_optimization(mode.optimize_setting)
@@ -211,14 +155,6 @@ async fn compile_contracts<P: Platform>(
         // Adding the contract sources to the compiler.
         .try_then(|compiler| {
             files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
-        })
-        .inspect_err(|err| {
-            compilation_failure_report_callback(
-                Some(compiler_version.clone()),
-                Some(compiler_path.as_ref().to_path_buf()),
-                None,
-                err.to_string(),
-            )
         })?
         // Adding the deployed libraries to the compiler.
         .then(|compiler| {
@@ -234,28 +170,9 @@ async fn compile_contracts<P: Platform>(
                 .fold(compiler, |compiler, (ident, address, path)| {
                     compiler.with_library(path, ident.as_str(), *address)
                 })
-        });
+        })
-
+        .try_build(compiler_path)
-    let compiler_input = compiler.input();
-    let compiler_output = compiler
-        .try_build(compiler_path.as_ref())
         .await
-        .inspect_err(|err| {
-            compilation_failure_report_callback(
-                Some(compiler_version.clone()),
-                Some(compiler_path.as_ref().to_path_buf()),
-                Some(compiler_input.clone()),
-                err.to_string(),
-            )
-        })?;
-    compilation_success_report_callback(
-        compiler_version,
-        compiler_path.as_ref().to_path_buf(),
-        false,
-        Some(compiler_input),
-        compiler_output.clone(),
-    );
-    Ok(compiler_output)
 }
 
 struct ArtifactsCache {

crates/core/src/driver/mod.rs

@@ -16,25 +16,26 @@ use alloy::rpc::types::trace::geth::{
 };
 use alloy::{
     primitives::Address,
-    rpc::types::{TransactionRequest, trace::geth::DiffMode},
+    rpc::types::{
+        TransactionRequest,
+        trace::geth::{AccountState, DiffMode},
+    },
 };
 use anyhow::Context;
-use futures::TryStreamExt;
 use indexmap::IndexMap;
 use revive_dt_format::traits::{ResolutionContext, ResolverApi};
-use revive_dt_report::ExecutionSpecificReporter;
 use semver::Version;
 
-use revive_dt_format::case::Case;
+use revive_dt_format::case::{Case, CaseIdx};
 use revive_dt_format::input::{
-    BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method, StepIdx,
+    BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method,
     StorageEmptyAssertion,
 };
 use revive_dt_format::metadata::{ContractIdent, ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Step, metadata::Metadata};
+use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
-use tokio::try_join;
+use tracing::Instrument;
-use tracing::{Instrument, info, info_span, instrument};
 
 use crate::Platform;
 
@@ -52,9 +53,6 @@ pub struct CaseState<T: Platform> {
     /// Stores the version used for the current case.
     compiler_version: Version,
 
-    /// The execution reporter.
-    execution_reporter: ExecutionSpecificReporter,
-
     phantom: PhantomData<T>,
 }
 
@@ -66,14 +64,12 @@ where
         compiler_version: Version,
         compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
         deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
-        execution_reporter: ExecutionSpecificReporter,
     ) -> Self {
         Self {
             compiled_contracts,
             deployed_contracts,
             variables: Default::default(),
             compiler_version,
-            execution_reporter,
             phantom: PhantomData,
         }
     }
@@ -81,38 +77,38 @@ where
     pub async fn handle_step(
         &mut self,
         metadata: &Metadata,
+        case_idx: CaseIdx,
         step: &Step,
         node: &T::Blockchain,
     ) -> anyhow::Result<StepOutput> {
         match step {
             Step::FunctionCall(input) => {
                 let (receipt, geth_trace, diff_mode) =
-                    self.handle_input(metadata, input, node).await?;
+                    self.handle_input(metadata, case_idx, input, node).await?;
                 Ok(StepOutput::FunctionCall(receipt, geth_trace, diff_mode))
             }
             Step::BalanceAssertion(balance_assertion) => {
-                self.handle_balance_assertion(metadata, balance_assertion, node)
+                self.handle_balance_assertion(metadata, case_idx, balance_assertion, node)
                     .await?;
                 Ok(StepOutput::BalanceAssertion)
             }
             Step::StorageEmptyAssertion(storage_empty) => {
-                self.handle_storage_empty(metadata, storage_empty, node)
+                self.handle_storage_empty(metadata, case_idx, storage_empty, node)
                     .await?;
                 Ok(StepOutput::StorageEmptyAssertion)
             }
         }
-        .inspect(|_| info!("Step Succeeded"))
     }
 
-    #[instrument(level = "info", name = "Handling Input", skip_all)]
     pub async fn handle_input(
         &mut self,
         metadata: &Metadata,
+        case_idx: CaseIdx,
         input: &Input,
         node: &T::Blockchain,
     ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
         let deployment_receipts = self
-            .handle_input_contract_deployment(metadata, input, node)
+            .handle_input_contract_deployment(metadata, case_idx, input, node)
             .await?;
         let execution_receipt = self
             .handle_input_execution(input, deployment_receipts, node)
@@ -121,17 +117,16 @@ where
             .handle_input_call_frame_tracing(&execution_receipt, node)
             .await?;
         self.handle_input_variable_assignment(input, &tracing_result)?;
-        let (_, (geth_trace, diff_mode)) = try_join!(
+        self.handle_input_expectations(input, &execution_receipt, node, &tracing_result)
-            self.handle_input_expectations(input, &execution_receipt, node, &tracing_result),
+            .await?;
-            self.handle_input_diff(&execution_receipt, node)
+        self.handle_input_diff(case_idx, execution_receipt, node)
-        )?;
+            .await
-        Ok((execution_receipt, geth_trace, diff_mode))
     }
 
-    #[instrument(level = "info", name = "Handling Balance Assertion", skip_all)]
     pub async fn handle_balance_assertion(
         &mut self,
         metadata: &Metadata,
+        _: CaseIdx,
         balance_assertion: &BalanceAssertion,
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
@@ -142,10 +137,10 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", name = "Handling Storage Assertion", skip_all)]
     pub async fn handle_storage_empty(
         &mut self,
         metadata: &Metadata,
+        _: CaseIdx,
         storage_empty: &StorageEmptyAssertion,
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
@@ -157,10 +152,10 @@ where
     }
 
     /// Handles the contract deployment for a given input performing it if it needs to be performed.
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_contract_deployment(
         &mut self,
         metadata: &Metadata,
+        _: CaseIdx,
         input: &Input,
         node: &T::Blockchain,
     ) -> anyhow::Result<HashMap<ContractInstance, TransactionReceipt>> {
@@ -175,6 +170,11 @@ where
             instances_we_must_deploy.insert(input.instance.clone(), true);
         }
 
+        tracing::debug!(
+            instances_to_deploy = instances_we_must_deploy.len(),
+            "Computed the number of required deployments for input"
+        );
+
         let mut receipts = HashMap::new();
         for (instance, deploy_with_constructor_arguments) in instances_we_must_deploy.into_iter() {
             let calldata = deploy_with_constructor_arguments.then_some(&input.calldata);
@@ -201,7 +201,6 @@ where
     }
 
     /// Handles the execution of the input in terms of the calls that need to be made.
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_execution(
         &mut self,
         input: &Input,
@@ -219,21 +218,33 @@ where
                     .legacy_transaction(node, self.default_resolution_context())
                     .await
                 {
-                    Ok(tx) => tx,
+                    Ok(tx) => {
+                        tracing::debug!("Legacy transaction data: {tx:#?}");
+                        tx
+                    }
                     Err(err) => {
+                        tracing::error!("Failed to construct legacy transaction: {err:?}");
                         return Err(err);
                     }
                 };
 
+                tracing::trace!("Executing transaction for input: {input:?}");
+
                 match node.execute_transaction(tx).await {
                     Ok(receipt) => Ok(receipt),
-                    Err(err) => Err(err),
+                    Err(err) => {
+                        tracing::error!(
+                            "Failed to execute transaction when executing the contract: {}, {:?}",
+                            &*input.instance,
+                            err
+                        );
+                        Err(err)
+                    }
                 }
             }
         }
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_call_frame_tracing(
         &self,
         execution_receipt: &TransactionReceipt,
@@ -248,10 +259,7 @@ where
                 tracer_config: GethDebugTracerConfig(serde_json::json! {{
                     "onlyTopCall": true,
                     "withLog": false,
-                    "withStorage": false,
+                    "withReturnData": false
-                    "withMemory": false,
-                    "withStack": false,
-                    "withReturnData": true
                 }}),
                 ..Default::default()
             },
@@ -264,7 +272,6 @@ where
         })
     }
 
-    #[instrument(level = "info", skip_all)]
     fn handle_input_variable_assignment(
         &mut self,
         input: &Input,
@@ -295,9 +302,8 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_expectations(
-        &self,
+        &mut self,
         input: &Input,
         execution_receipt: &TransactionReceipt,
         resolver: &impl ResolverApi,
@@ -331,25 +337,24 @@ where
             }
         }
 
-        futures::stream::iter(expectations.into_iter().map(Ok))
+        for expectation in expectations.iter() {
-            .try_for_each_concurrent(None, |expectation| async move {
             self.handle_input_expectation_item(
                 execution_receipt,
                 resolver,
                 expectation,
                 tracing_result,
             )
-                .await
+            .await?;
-            })
+        }
-            .await
+
+        Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_expectation_item(
-        &self,
+        &mut self,
         execution_receipt: &TransactionReceipt,
         resolver: &impl ResolverApi,
-        expectation: ExpectedOutput,
+        expectation: &ExpectedOutput,
         tracing_result: &CallFrame,
     ) -> anyhow::Result<()> {
         if let Some(ref version_requirement) = expectation.compiler_version {
@@ -487,12 +492,12 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_diff(
-        &self,
+        &mut self,
-        execution_receipt: &TransactionReceipt,
+        _: CaseIdx,
+        execution_receipt: TransactionReceipt,
         node: &T::Blockchain,
-    ) -> anyhow::Result<(GethTrace, DiffMode)> {
+    ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
             disable_code: None,
@@ -500,14 +505,13 @@ where
         });
 
         let trace = node
-            .trace_transaction(execution_receipt, trace_options)
+            .trace_transaction(&execution_receipt, trace_options)
             .await?;
-        let diff = node.state_diff(execution_receipt).await?;
+        let diff = node.state_diff(&execution_receipt).await?;
 
-        Ok((trace, diff))
+        Ok((execution_receipt, trace, diff))
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_balance_assertion_contract_deployment(
         &mut self,
         metadata: &Metadata,
@@ -533,7 +537,6 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_balance_assertion_execution(
         &mut self,
         BalanceAssertion {
@@ -569,7 +572,6 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_storage_empty_assertion_contract_deployment(
         &mut self,
         metadata: &Metadata,
@@ -595,7 +597,6 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_storage_empty_assertion_execution(
         &mut self,
         StorageEmptyAssertion {
@@ -657,6 +658,7 @@ where
             contract_ident,
         }) = metadata.contract_sources()?.remove(contract_instance)
         else {
+            tracing::error!("Contract source not found for instance");
             anyhow::bail!(
                 "Contract source not found for instance {:?}",
                 contract_instance
@@ -669,6 +671,11 @@ where
             .and_then(|source_file_contracts| source_file_contracts.get(contract_ident.as_ref()))
             .cloned()
         else {
+            tracing::error!(
+                contract_source_path = contract_source_path.display().to_string(),
+                contract_ident = contract_ident.as_ref(),
+                "Failed to find information for contract"
+            );
             anyhow::bail!(
                 "Failed to find information for contract {:?}",
                 contract_instance
@@ -717,6 +724,7 @@ where
         };
 
         let Some(address) = receipt.contract_address else {
+            tracing::error!("Contract deployment transaction didn't return an address");
             anyhow::bail!("Contract deployment didn't return an address");
         };
         tracing::info!(
@@ -724,8 +732,6 @@ where
             instance_address = ?address,
             "Deployed contract"
         );
-        self.execution_reporter
-            .report_contract_deployed_event(contract_instance.clone(), address)?;
 
         self.deployed_contracts.insert(
             contract_instance.clone(),
@@ -745,6 +751,7 @@ where
 pub struct CaseDriver<'a, Leader: Platform, Follower: Platform> {
     metadata: &'a Metadata,
     case: &'a Case,
+    case_idx: CaseIdx,
     leader_node: &'a Leader::Blockchain,
     follower_node: &'a Follower::Blockchain,
     leader_state: CaseState<Leader>,
@@ -760,6 +767,7 @@ where
     pub fn new(
         metadata: &'a Metadata,
         case: &'a Case,
+        case_idx: impl Into<CaseIdx>,
         leader_node: &'a L::Blockchain,
         follower_node: &'a F::Blockchain,
         leader_state: CaseState<L>,
@@ -768,6 +776,7 @@ where
         Self {
             metadata,
             case,
+            case_idx: case_idx.into(),
             leader_node,
             follower_node,
             leader_state,
@@ -775,44 +784,79 @@ where
         }
     }
 
-    #[instrument(level = "info", name = "Executing Case", skip_all)]
+    pub fn trace_diff_mode(label: &str, diff: &DiffMode) {
-    pub async fn execute(&mut self) -> anyhow::Result<usize> {
+        tracing::trace!("{label} - PRE STATE:");
-        let mut steps_executed = 0;
+        for (addr, state) in &diff.pre {
-        for (step_idx, step) in self
+            Self::trace_account_state("  [pre]", addr, state);
-            .case
+        }
-            .steps_iterator()
-            .enumerate()
-            .map(|(idx, v)| (StepIdx::new(idx), v))
-        {
-            let (leader_step_output, follower_step_output) = try_join!(
-                self.leader_state
-                    .handle_step(self.metadata, &step, self.leader_node)
-                    .instrument(info_span!(
-                        "Handling Step",
-                        %step_idx,
-                        target = "Leader",
-                    )),
-                self.follower_state
-                    .handle_step(self.metadata, &step, self.follower_node)
-                    .instrument(info_span!(
-                        "Handling Step",
-                        %step_idx,
-                        target = "Follower",
-                    ))
-            )?;
 
+        tracing::trace!("{label} - POST STATE:");
+        for (addr, state) in &diff.post {
+            Self::trace_account_state("  [post]", addr, state);
+        }
+    }
+
+    fn trace_account_state(prefix: &str, addr: &Address, state: &AccountState) {
+        tracing::trace!("{prefix} 0x{addr:x}");
+
+        if let Some(balance) = &state.balance {
+            tracing::trace!("{prefix}   balance: {balance}");
+        }
+        if let Some(nonce) = &state.nonce {
+            tracing::trace!("{prefix}   nonce: {nonce}");
+        }
+        if let Some(code) = &state.code {
+            tracing::trace!("{prefix}   code: {code}");
+        }
+    }
+
+    pub async fn execute(&mut self) -> anyhow::Result<usize> {
+        if !self
+            .leader_node
+            .matches_target(self.metadata.targets.as_deref())
+            || !self
+                .follower_node
+                .matches_target(self.metadata.targets.as_deref())
+        {
+            tracing::warn!(
+                targets = ?self.metadata.targets,
+                "Either the leader or follower node do not support the targets of the file"
+            );
+            return Ok(0);
+        }
+
+        let mut steps_executed = 0;
+        for (step_idx, step) in self.case.steps_iterator().enumerate() {
+            let tracing_span = tracing::info_span!("Handling input", step_idx);
+
+            let leader_step_output = self
+                .leader_state
+                .handle_step(self.metadata, self.case_idx, &step, self.leader_node)
+                .instrument(tracing_span.clone())
+                .await?;
+            let follower_step_output = self
+                .follower_state
+                .handle_step(self.metadata, self.case_idx, &step, self.follower_node)
+                .instrument(tracing_span)
+                .await?;
             match (leader_step_output, follower_step_output) {
-                (StepOutput::FunctionCall(..), StepOutput::FunctionCall(..)) => {
+                (
-                    // TODO: We need to actually work out how/if we will compare the diff between
+                    StepOutput::FunctionCall(leader_receipt, _, leader_diff),
-                    // the leader and the follower. The diffs are almost guaranteed to be different
+                    StepOutput::FunctionCall(follower_receipt, _, follower_diff),
-                    // from leader and follower and therefore without an actual strategy for this
+                ) => {
-                    // we have something that's guaranteed to fail. Even a simple call to some
+                    if leader_diff == follower_diff {
-                    // contract will produce two non-equal diffs because on the leader the contract
+                        tracing::debug!("State diffs match between leader and follower.");
-                    // has address X and on the follower it has address Y. On the leader contract X
+                    } else {
-                    // contains address A in the state and on the follower it contains address B. So
+                        tracing::debug!("State diffs mismatch between leader and follower.");
-                    // this isn't exactly a straightforward thing to do and I'm not even sure that
+                        Self::trace_diff_mode("Leader", &leader_diff);
-                    // it's possible to do. Once we have an actual strategy for doing the diffs we
+                        Self::trace_diff_mode("Follower", &follower_diff);
-                    // will implement it here. Until then, this remains empty.
+                    }
+
+                    if leader_receipt.logs() != follower_receipt.logs() {
+                        tracing::debug!("Log/event mismatch between leader and follower.");
+                        tracing::trace!("Leader logs: {:?}", leader_receipt.logs());
+                        tracing::trace!("Follower logs: {:?}", follower_receipt.logs());
+                    }
                 }
                 (StepOutput::BalanceAssertion, StepOutput::BalanceAssertion) => {}
                 (StepOutput::StorageEmptyAssertion, StepOutput::StorageEmptyAssertion) => {}

crates/format/Cargo.toml

@@ -17,7 +17,6 @@ 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 }
@@ -26,6 +25,3 @@ serde_json = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true }
-
-[lints]
-workspace = true

crates/format/src/case.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use revive_dt_common::{macros::define_wrapper_type, types::Mode};
+use revive_dt_common::macros::define_wrapper_type;
 
 use crate::{
     input::{Expected, Step},
@@ -60,18 +60,16 @@ impl Case {
                 }
             })
     }
-
-    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, Serialize, Deserialize)]
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    #[serde(transparent)]
+    pub struct CaseIdx(usize);
-    pub struct CaseIdx(usize) impl Display, FromStr;
 );
+
+impl std::fmt::Display for CaseIdx {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}

crates/format/src/corpus.rs

@@ -3,28 +3,26 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use revive_dt_common::iterators::FilesWithExtensionIterator;
+use revive_dt_common::cached_fs::read_dir;
 use serde::{Deserialize, Serialize};
-use tracing::{debug, info};
 
-use crate::metadata::{Metadata, MetadataFile};
+use crate::metadata::MetadataFile;
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq, Hash)]
-#[serde(untagged)]
+pub struct Corpus {
-pub enum Corpus {
+    pub name: String,
-    SinglePath { name: String, path: PathBuf },
+    pub path: PathBuf,
-    MultiplePaths { name: String, paths: Vec<PathBuf> },
 }
 
 impl Corpus {
-    pub fn try_from_path(file_path: impl AsRef<Path>) -> anyhow::Result<Self> {
+    /// Try to read and parse the corpus definition file at given `path`.
-        let mut corpus = File::open(file_path.as_ref())
+    pub fn try_from_path(path: &Path) -> anyhow::Result<Self> {
-            .map_err(anyhow::Error::from)
+        let file = File::open(path)?;
-            .and_then(|file| serde_json::from_reader::<_, Corpus>(file).map_err(Into::into))?;
+        let mut corpus: Corpus = serde_json::from_reader(file)?;
 
-        for path in corpus.paths_iter_mut() {
+        // Ensure that the path mentioned in the corpus is relative to the corpus file.
-            *path = file_path
+        // Canonicalizing also helps make the path in any errors unambiguous.
-                .as_ref()
+        corpus.path = path
             .parent()
             .ok_or_else(|| {
                 anyhow::anyhow!("Corpus path '{}' does not point to a file", path.display())
@@ -36,94 +34,66 @@ impl Corpus {
                     path.display()
                 )
             })?
-                .join(path.as_path())
+            .join(corpus.path);
-        }
 
         Ok(corpus)
     }
 
+    /// Scan the corpus base directory and return all tests found.
     pub fn enumerate_tests(&self) -> Vec<MetadataFile> {
-        let mut tests = self
+        let mut tests = Vec::new();
-            .paths_iter()
+        collect_metadata(&self.path, &mut tests);
-            .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
     }
-
-    pub fn name(&self) -> &str {
-        match self {
-            Corpus::SinglePath { name, .. } | Corpus::MultiplePaths { name, .. } => name.as_str(),
-        }
 }
 
-    pub fn paths_iter(&self) -> impl Iterator<Item = &Path> {
+/// Recursively walks `path` and parses any JSON or Solidity file into a test
-        match self {
+/// definition [Metadata].
-            Corpus::SinglePath { path, .. } => {
+///
-                Box::new(std::iter::once(path.as_path())) as Box<dyn Iterator<Item = _>>
+/// Found tests are inserted into `tests`.
-            }
+///
-            Corpus::MultiplePaths { paths, .. } => {
+/// `path` is expected to be a directory.
-                Box::new(paths.iter().map(|path| path.as_path())) as Box<dyn Iterator<Item = _>>
+pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
+    if path.is_dir() {
+        let dir_entry = match read_dir(path) {
+            Ok(dir_entry) => dir_entry,
+            Err(error) => {
+                tracing::error!("failed to read dir '{}': {error}", path.display());
+                return;
             }
+        };
+
+        for path in dir_entry {
+            let path = match path {
+                Ok(entry) => entry,
+                Err(error) => {
+                    tracing::error!("error reading dir entry: {error}");
+                    continue;
                 }
+            };
+
+            if path.is_dir() {
+                collect_metadata(&path, tests);
+                continue;
             }
 
-    pub fn paths_iter_mut(&mut self) -> impl Iterator<Item = &mut PathBuf> {
+            if path.is_file() {
-        match self {
+                if let Some(metadata) = MetadataFile::try_from_file(&path) {
-            Corpus::SinglePath { path, .. } => {
+                    tests.push(metadata)
-                Box::new(std::iter::once(path)) as Box<dyn Iterator<Item = _>>
-            }
-            Corpus::MultiplePaths { paths, .. } => {
-                Box::new(paths.iter_mut()) as Box<dyn Iterator<Item = _>>
                 }
             }
         }
-
+    } else {
-    pub fn path_count(&self) -> usize {
+        let Some(extension) = path.extension() else {
-        match self {
+            tracing::error!("Failed to get file extension");
-            Corpus::SinglePath { .. } => 1,
+            return;
-            Corpus::MultiplePaths { paths, .. } => paths.len(),
+        };
+        if extension.eq_ignore_ascii_case("sol") || extension.eq_ignore_ascii_case("json") {
+            if let Some(metadata) = MetadataFile::try_from_file(path) {
+                tests.push(metadata)
+            }
+        } else {
+            tracing::error!(?extension, "Unsupported file extension");
         }
     }
 }

crates/format/src/input.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use alloy::{
     eips::BlockNumberOrTag,
+    hex::ToHexExt,
     json_abi::Function,
     network::TransactionBuilder,
     primitives::{Address, Bytes, U256},
@@ -9,12 +10,10 @@ use alloy::{
 };
 use alloy_primitives::{FixedBytes, utils::parse_units};
 use anyhow::Context;
-use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, stream};
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
 
 use revive_dt_common::macros::define_wrapper_type;
-use tracing::{Instrument, info_span, instrument};
 
 use crate::traits::ResolverApi;
 use crate::{metadata::ContractInstance, traits::ResolutionContext};
@@ -34,11 +33,6 @@ pub enum Step {
     StorageEmptyAssertion(Box<StorageEmptyAssertion>),
 }
 
-define_wrapper_type!(
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-    pub struct StepIdx(usize) impl Display;
-);
-
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Input {
     #[serde(default = "Input::default_caller")]
@@ -194,7 +188,7 @@ define_wrapper_type! {
     /// This represents an item in the [`Calldata::Compound`] variant.
     #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
     #[serde(transparent)]
-    pub struct CalldataItem(String) impl Display;
+    pub struct CalldataItem(String);
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
@@ -239,7 +233,7 @@ pub enum Method {
 
 define_wrapper_type!(
     #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub struct EtherValue(U256) impl Display;
+    pub struct EtherValue(U256);
 );
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
@@ -274,9 +268,15 @@ impl Input {
             }
             Method::FunctionName(ref function_name) => {
                 let Some(abi) = context.deployed_contract_abi(&self.instance) else {
+                    tracing::error!(
+                        contract_name = self.instance.as_ref(),
+                        "Attempted to lookup ABI of contract but it wasn't found"
+                    );
                     anyhow::bail!("ABI for instance '{}' not found", self.instance.as_ref());
                 };
 
+                tracing::trace!("ABI found for instance: {}", &self.instance.as_ref());
+
                 // We follow the same logic that's implemented in the matter-labs-tester where they resolve
                 // the function name into a function selector and they assume that he function doesn't have
                 // any existing overloads.
@@ -302,6 +302,13 @@ impl Input {
                         .selector()
                 };
 
+                tracing::trace!("Functions found for instance: {}", self.instance.as_ref());
+
+                tracing::trace!(
+                    "Starting encoding ABI's parameters for instance: {}",
+                    self.instance.as_ref()
+                );
+
                 // Allocating a vector that we will be using for the calldata. The vector size will be:
                 // 4 bytes for the function selector.
                 // function.inputs.len() * 32 bytes for the arguments (each argument is a U256).
@@ -428,18 +435,17 @@ impl Calldata {
                 buffer.extend_from_slice(bytes);
             }
             Calldata::Compound(items) => {
-                let resolved = stream::iter(items.iter().enumerate())
+                for (arg_idx, arg) in items.iter().enumerate() {
-                    .map(|(arg_idx, arg)| async move {
+                    match arg.resolve(resolver, context).await {
-                        arg.resolve(resolver, context)
+                        Ok(resolved) => {
-                            .instrument(info_span!("Resolving argument", %arg, arg_idx))
+                            buffer.extend(resolved.to_be_bytes::<32>());
-                            .map_ok(|value| value.to_be_bytes::<32>())
+                        }
-                            .await
+                        Err(error) => {
-                    })
+                            tracing::error!(?arg, arg_idx, ?error, "Failed to resolve argument");
-                    .buffered(0xFF)
+                            return Err(error);
-                    .try_collect::<Vec<_>>()
+                        }
-                    .await?;
+                    };
-
+                }
-                buffer.extend(resolved.into_iter().flatten());
             }
         };
         Ok(())
@@ -462,12 +468,13 @@ impl Calldata {
         match self {
             Calldata::Single(calldata) => Ok(calldata == other),
             Calldata::Compound(items) => {
-                stream::iter(items.iter().zip(other.chunks(32)))
+                // Chunking the "other" calldata into 32 byte chunks since each
-                    .map(|(this, other)| async move {
+                // one of the items in the compound calldata represents 32 bytes
+                for (this, other) in items.iter().zip(other.chunks(32)) {
                     // The matterlabs format supports wildcards and therefore we
                     // also need to support them.
                     if this.as_ref() == "*" {
-                            return Ok::<_, anyhow::Error>(true);
+                        continue;
                     }
 
                     let other = if other.len() < 32 {
@@ -480,19 +487,17 @@ impl Calldata {
 
                     let this = this.resolve(resolver, context).await?;
                     let other = U256::from_be_slice(&other);
-                        Ok(this == other)
+                    if this != other {
-                    })
+                        return Ok(false);
-                    .buffered(0xFF)
+                    }
-                    .all(|v| async move { v.is_ok_and(|v| v) })
+                }
-                    .map(Ok)
+                Ok(true)
-                    .await
             }
         }
     }
 }
 
 impl CalldataItem {
-    #[instrument(level = "info", skip_all, err)]
     async fn resolve(
         &self,
         resolver: &impl ResolverApi,
@@ -543,7 +548,14 @@ impl CalldataItem {
         match stack.as_slice() {
             // Empty stack means that we got an empty compound calldata which we resolve to zero.
             [] => Ok(U256::ZERO),
-            [CalldataToken::Item(item)] => Ok(*item),
+            [CalldataToken::Item(item)] => {
+                tracing::debug!(
+                    original = self.0,
+                    resolved = item.to_be_bytes::<32>().encode_hex(),
+                    "Resolved a Calldata item"
+                );
+                Ok(*item)
+            }
             _ => Err(anyhow::anyhow!(
                 "Invalid calldata arithmetic operation - Invalid stack"
             )),

crates/format/src/metadata.rs

@@ -15,7 +15,6 @@ use revive_dt_common::{
     cached_fs::read_to_string, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
     types::Mode,
 };
-use tracing::error;
 
 use crate::{case::Case, mode::ParsedMode};
 
@@ -25,26 +24,16 @@ pub const SOLIDITY_CASE_COMMENT_MARKER: &str = "//!";
 
 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct MetadataFile {
-    /// The path of the metadata file. This will either be a JSON or solidity file.
+    pub path: PathBuf,
-    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 relative_path(&self) -> &Path {
+    pub fn try_from_file(path: &Path) -> Option<Self> {
-        if self.corpus_file_path.is_file() {
+        Metadata::try_from_file(path).map(|metadata| Self {
-            &self.corpus_file_path
+            path: path.to_owned(),
-        } else {
+            content: metadata,
-            self.metadata_file_path
+        })
-                .strip_prefix(&self.corpus_file_path)
-                .unwrap()
-        }
     }
 }
 
@@ -156,7 +145,10 @@ impl Metadata {
     pub fn try_from_file(path: &Path) -> Option<Self> {
         assert!(path.is_file(), "not a file: {}", path.display());
 
-        let file_extension = path.extension()?;
+        let Some(file_extension) = path.extension() else {
+            tracing::debug!("skipping corpus file: {}", path.display());
+            return None;
+        };
 
         if file_extension == METADATA_FILE_EXTENSION {
             return Self::try_from_json(path);
@@ -166,12 +158,18 @@ 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(|err| error!(path = %path.display(), %err, "Failed to open file"))
+            .inspect_err(|error| {
+                tracing::error!(
+                    "opening JSON test metadata file '{}' error: {error}",
+                    path.display()
+                );
+            })
             .ok()?;
 
         match serde_json::from_reader::<_, Metadata>(file) {
@@ -179,8 +177,11 @@ impl Metadata {
                 metadata.file_path = Some(path.to_path_buf());
                 Some(metadata)
             }
-            Err(err) => {
+            Err(error) => {
-                error!(path = %path.display(), %err, "Deserialization of metadata failed");
+                tracing::error!(
+                    "parsing JSON test metadata file '{}' error: {error}",
+                    path.display()
+                );
                 None
             }
         }
@@ -188,7 +189,12 @@ impl Metadata {
 
     fn try_from_solidity(path: &Path) -> Option<Self> {
         let spec = read_to_string(path)
-            .inspect_err(|err| error!(path = %path.display(), %err, "Failed to read file content"))
+            .inspect_err(|error| {
+                tracing::error!(
+                    "opening JSON test metadata file '{}' error: {error}",
+                    path.display()
+                );
+            })
             .ok()?
             .lines()
             .filter_map(|line| line.strip_prefix(SOLIDITY_CASE_COMMENT_MARKER))
@@ -216,8 +222,11 @@ impl Metadata {
                 );
                 Some(metadata)
             }
-            Err(err) => {
+            Err(error) => {
-                error!(path = %path.display(), %err, "Failed to deserialize metadata");
+                tracing::error!(
+                    "parsing Solidity test metadata file '{}' error: '{error}' from data: {spec}",
+                    path.display()
+                );
                 None
             }
         }
@@ -257,7 +266,7 @@ define_wrapper_type!(
         Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
     )]
     #[serde(transparent)]
-    pub struct ContractInstance(String) impl Display;
+    pub struct ContractInstance(String);
 );
 
 define_wrapper_type!(
@@ -268,7 +277,7 @@ define_wrapper_type!(
         Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
     )]
     #[serde(transparent)]
-    pub struct ContractIdent(String) impl Display;
+    pub struct ContractIdent(String);
 );
 
 /// Represents an identifier used for contracts.

crates/format/src/mode.rs

@@ -223,7 +223,7 @@ mod tests {
 
         for (actual, expected) in strings {
             let parsed = ParsedMode::from_str(actual)
-                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
+                .expect(format!("Failed to parse mode string '{actual}'").as_str());
             assert_eq!(
                 expected,
                 parsed.to_string(),
@@ -249,7 +249,7 @@ mod tests {
 
         for (actual, expected) in strings {
             let parsed = ParsedMode::from_str(actual)
-                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
+                .expect(format!("Failed to parse mode string '{actual}'").as_str());
             let expected_set: HashSet<_> = expected.into_iter().map(|s| s.to_owned()).collect();
             let actual_set: HashSet<_> = parsed.to_modes().map(|m| m.to_string()).collect();
 

crates/node-interaction/Cargo.toml

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

crates/node/Cargo.toml

@@ -29,6 +29,3 @@ sp-runtime = { workspace = true }
 [dev-dependencies]
 temp-dir = { workspace = true }
 tokio = { workspace = true }
-
-[lints]
-workspace = true

crates/node/src/geth.rs

@@ -33,12 +33,9 @@ use alloy::{
 };
 use anyhow::Context;
 use revive_common::EVMVersion;
-use tracing::{Instrument, instrument};
+use tracing::{Instrument, Level};
 
-use revive_dt_common::{
+use revive_dt_common::{fs::clear_directory, futures::poll};
-    fs::clear_directory,
-    futures::{PollingWaitBehavior, poll},
-};
 use revive_dt_config::Arguments;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::EthereumNode;
@@ -55,7 +52,6 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
-#[allow(clippy::type_complexity)]
 pub struct GethNode {
     connection_string: String,
     base_directory: PathBuf,
@@ -65,9 +61,8 @@ pub struct GethNode {
     id: u32,
     handle: Option<Child>,
     start_timeout: u64,
-    wallet: Arc<EthereumWallet>,
+    wallet: EthereumWallet,
     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
@@ -96,7 +91,7 @@ impl GethNode {
     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))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
@@ -146,7 +141,7 @@ impl GethNode {
     /// Spawn the go-ethereum node child process.
     ///
     /// [Instance::init] must be called prior.
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn spawn_process(&mut self) -> anyhow::Result<&mut Self> {
         // This is the `OpenOptions` that we wish to use for all of the log files that we will be
         // opening in this method. We need to construct it in this way to:
@@ -202,7 +197,7 @@ impl GethNode {
     /// 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))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn wait_ready(&mut self) -> anyhow::Result<&mut Self> {
         let start_time = Instant::now();
 
@@ -236,20 +231,33 @@ impl GethNode {
         }
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
     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))]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
     fn geth_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
     }
 
-    async fn provider(
+    fn provider(
         &self,
-    ) -> anyhow::Result<FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>>
+    ) -> impl Future<
-    {
+        Output = anyhow::Result<
+            FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>,
+        >,
+    > + 'static {
+        let connection_string = self.connection_string();
+        let wallet = self.wallet.clone();
+
+        // Note: We would like all providers to make use of the same nonce manager so that we have
+        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
+        // its implementation and therefore it means that when we clone it then it still references
+        // the same state.
+        let nonce_manager = self.nonce_manager.clone();
+
+        Box::pin(async move {
             ProviderBuilder::new()
                 .disable_recommended_fillers()
                 .filler(FallbackGasFiller::new(
@@ -257,54 +265,46 @@ impl GethNode {
                     1_000_000_000,
                     1_000_000_000,
                 ))
-            .filler(self.chain_id_filler.clone())
+                .filler(ChainIdFiller::default())
-            .filler(NonceFiller::new(self.nonce_manager.clone()))
+                .filler(NonceFiller::new(nonce_manager))
-            .wallet(self.wallet.clone())
+                .wallet(wallet)
-            .connect(&self.connection_string)
+                .connect(&connection_string)
                 .await
                 .map_err(Into::into)
+        })
     }
 }
 
 impl EthereumNode for GethNode {
-    #[instrument(
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
-        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 provider = self.provider().await?;
+        let provider = Arc::new(self.provider().await?);
+        let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();
 
-        let pending_transaction = provider.send_transaction(transaction).await.inspect_err(
+        // The following is a fix for the "transaction indexing is in progress" error that we
-            |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
+        // used to get. You can find more information on this in the following GH issue in geth
-        )?;
-        let transaction_hash = *pending_transaction.tx_hash();
-
-        // The following is a fix for the "transaction indexing is in progress" error that we used
-        // to get. You can find more information on this in the following GH issue in geth
         // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
         // before we can get the receipt of the transaction it needs to have been indexed by the
-        // node's indexer. Just because the transaction has been confirmed it doesn't mean that it
+        // node's indexer. Just because the transaction has been confirmed it doesn't mean that
-        // has been indexed. When we call alloy's `get_receipt` it checks if the transaction was
+        // it has been indexed. When we call alloy's `get_receipt` it checks if the transaction
-        // confirmed. If it has been, then it will call `eth_getTransactionReceipt` method which
+        // was confirmed. If it has been, then it will call `eth_getTransactionReceipt` method
-        // _might_ return the above error if the tx has not yet been indexed yet. So, we need to
+        // which _might_ return the above error if the tx has not yet been indexed yet. So, we
-        // implement a retry mechanism for the receipt to keep retrying to get it until it
+        // need to implement a retry mechanism for the receipt to keep retrying to get it until
-        // eventually works, but we only do that if the error we get back is the "transaction
+        // 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
+        // Getting the transaction indexed and taking a receipt can take a long time especially
-        // a lot of transactions are being submitted to the node. Thus, while initially we only
+        // when a lot of transactions are being submitted to the node. Thus, while initially we
-        // allowed for 60 seconds of waiting with a 1 second delay in polling, we need to allow for
+        // only allowed for 60 seconds of waiting with a 1 second delay in polling, we need to
-        // a larger wait time. Therefore, in here we allow for 5 minutes of waiting with exponential
+        // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
-        // backoff each time we attempt to get the receipt and find that it's not available.
+        // with exponential backoff each time we attempt to get the receipt and find that it's
-        let provider = Arc::new(provider);
+        // not available.
         poll(
             Self::RECEIPT_POLLING_DURATION,
-            PollingWaitBehavior::Constant(Duration::from_millis(200)),
+            Default::default(),
             move || {
                 let provider = provider.clone();
                 async move {
@@ -329,7 +329,7 @@ impl EthereumNode for GethNode {
         .await
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
@@ -338,7 +338,7 @@ impl EthereumNode for GethNode {
         let provider = Arc::new(self.provider().await?);
         poll(
             Self::TRACE_POLLING_DURATION,
-            PollingWaitBehavior::Constant(Duration::from_millis(200)),
+            Default::default(),
             move || {
                 let provider = provider.clone();
                 let trace_options = trace_options.clone();
@@ -362,7 +362,7 @@ impl EthereumNode for GethNode {
         .await
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
@@ -379,7 +379,7 @@ impl EthereumNode for GethNode {
         }
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
         self.provider()
             .await?
@@ -388,7 +388,7 @@ impl EthereumNode for GethNode {
             .map_err(Into::into)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn latest_state_proof(
         &self,
         address: Address,
@@ -404,7 +404,7 @@ impl EthereumNode for GethNode {
 }
 
 impl ResolverApi for GethNode {
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
             .await?
@@ -413,7 +413,7 @@ impl ResolverApi for GethNode {
             .map_err(Into::into)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -423,7 +423,7 @@ impl ResolverApi for GethNode {
             .map(|receipt| receipt.effective_gas_price)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -433,7 +433,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.gas_limit as _)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
             .await?
@@ -443,7 +443,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.beneficiary)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
             .await?
@@ -453,7 +453,7 @@ impl ResolverApi for GethNode {
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
         self.provider()
             .await?
@@ -468,7 +468,7 @@ impl ResolverApi for GethNode {
             })
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
             .await?
@@ -478,7 +478,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.hash)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
             .await?
@@ -488,7 +488,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.timestamp)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
             .await?
@@ -522,26 +522,20 @@ impl Node for GethNode {
             id,
             handle: None,
             start_timeout: config.geth_start_timeout,
-            wallet: Arc::new(wallet),
+            wallet,
-            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),
+            nonce_manager: Default::default(),
         }
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::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()
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn shutdown(&mut self) -> anyhow::Result<()> {
         // Terminate the processes in a graceful manner to allow for the output to be flushed.
         if let Some(mut child) = self.handle.take() {
@@ -563,13 +557,13 @@ impl Node for GethNode {
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
         self.init(genesis)?.spawn_process()?;
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.geth)
             .arg("--version")
@@ -582,7 +576,8 @@ impl Node for GethNode {
         Ok(String::from_utf8_lossy(&output).into())
     }
 
-    fn matches_target(targets: Option<&[String]>) -> bool {
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    fn matches_target(&self, targets: Option<&[String]>) -> bool {
         match targets {
             None => true,
             Some(targets) => targets.iter().any(|str| str.as_str() == "evm"),
@@ -595,7 +590,7 @@ impl Node for GethNode {
 }
 
 impl Drop for GethNode {
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn drop(&mut self) {
         self.shutdown().expect("Failed to shutdown")
     }

crates/node/src/kitchensink.rs

@@ -3,10 +3,7 @@ use std::{
     io::{BufRead, Write},
     path::{Path, PathBuf},
     process::{Child, Command, Stdio},
-    sync::{
+    sync::atomic::{AtomicU32, Ordering},
-        Arc,
-        atomic::{AtomicU32, Ordering},
-    },
     time::Duration,
 };
 
@@ -42,6 +39,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Value as JsonValue, json};
 use sp_core::crypto::Ss58Codec;
 use sp_runtime::AccountId32;
+use tracing::Level;
 
 use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;
@@ -54,17 +52,14 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 pub struct KitchensinkNode {
     id: u32,
     substrate_binary: PathBuf,
-    dev_node_binary: PathBuf,
     eth_proxy_binary: PathBuf,
     rpc_url: String,
+    wallet: EthereumWallet,
     base_directory: PathBuf,
     logs_directory: PathBuf,
     process_substrate: Option<Child>,
     process_proxy: Option<Child>,
-    wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
-    chain_id_filler: ChainIdFiller,
-    use_kitchensink_not_dev_node: bool,
     /// 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
@@ -92,6 +87,7 @@ impl KitchensinkNode {
     const PROXY_STDOUT_LOG_FILE_NAME: &str = "proxy_stdout.log";
     const PROXY_STDERR_LOG_FILE_NAME: &str = "proxy_stderr.log";
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
     fn init(&mut self, genesis: &str) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
@@ -103,21 +99,11 @@ impl KitchensinkNode {
 
         // Note: we do not pipe the logs of this process to a separate file since this is just a
         // once-off export of the default chain spec and not part of the long-running node process.
-        let output = if self.use_kitchensink_not_dev_node {
+        let output = Command::new(&self.substrate_binary)
-            Command::new(&self.substrate_binary)
             .arg("export-chain-spec")
             .arg("--chain")
             .arg("dev")
-                .output()
+            .output()?;
-                .context("Failed to export the chain-spec")?
-        } else {
-            Command::new(&self.dev_node_binary)
-                .arg("build-spec")
-                .arg("--chain")
-                .arg("dev")
-                .output()
-                .context("Failed to export the chain-spec")?
-        };
 
         if !output.status.success() {
             anyhow::bail!(
@@ -174,6 +160,7 @@ impl KitchensinkNode {
         Ok(self)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn spawn_process(&mut self) -> anyhow::Result<()> {
         let substrate_rpc_port = Self::BASE_SUBSTRATE_RPC_PORT + self.id as u16;
         let proxy_rpc_port = Self::BASE_PROXY_RPC_PORT + self.id as u16;
@@ -200,12 +187,7 @@ impl KitchensinkNode {
         let kitchensink_stderr_logs_file = open_options
             .clone()
             .open(self.kitchensink_stderr_log_file_path())?;
-        let node_binary_path = if self.use_kitchensink_not_dev_node {
+        self.process_substrate = Command::new(&self.substrate_binary)
-            self.substrate_binary.as_path()
-        } else {
-            self.dev_node_binary.as_path()
-        };
-        self.process_substrate = Command::new(node_binary_path)
             .arg("--dev")
             .arg("--chain")
             .arg(chainspec_path)
@@ -220,8 +202,6 @@ impl KitchensinkNode {
             .arg("Unsafe")
             .arg("--rpc-cors")
             .arg("all")
-            .arg("--rpc-max-connections")
-            .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::SUBSTRATE_LOG_ENV)
             .stdout(kitchensink_stdout_logs_file.try_clone()?)
             .stderr(kitchensink_stderr_logs_file.try_clone()?)
@@ -234,6 +214,10 @@ impl KitchensinkNode {
             Self::SUBSTRATE_READY_MARKER,
             Duration::from_secs(60),
         ) {
+            tracing::error!(
+                ?error,
+                "Failed to start substrate, shutting down gracefully"
+            );
             self.shutdown()?;
             return Err(error);
         };
@@ -248,8 +232,6 @@ impl KitchensinkNode {
             .arg(proxy_rpc_port.to_string())
             .arg("--node-rpc-url")
             .arg(format!("ws://127.0.0.1:{substrate_rpc_port}"))
-            .arg("--rpc-max-connections")
-            .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::PROXY_LOG_ENV)
             .stdout(eth_proxy_stdout_logs_file.try_clone()?)
             .stderr(eth_proxy_stderr_logs_file.try_clone()?)
@@ -261,6 +243,7 @@ impl KitchensinkNode {
             Self::ETH_PROXY_READY_MARKER,
             Duration::from_secs(60),
         ) {
+            tracing::error!(?error, "Failed to start proxy, shutting down gracefully");
             self.shutdown()?;
             return Err(error);
         };
@@ -275,6 +258,7 @@ impl KitchensinkNode {
         Ok(())
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn extract_balance_from_genesis_file(
         &self,
         genesis: &Genesis,
@@ -323,6 +307,7 @@ impl KitchensinkNode {
         }
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     pub fn eth_rpc_version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.eth_proxy_binary)
             .arg("--version")
@@ -335,33 +320,49 @@ impl KitchensinkNode {
         Ok(String::from_utf8_lossy(&output).trim().to_string())
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn kitchensink_stdout_log_file_path(&self) -> PathBuf {
         self.logs_directory
             .join(Self::KITCHENSINK_STDOUT_LOG_FILE_NAME)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn kitchensink_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory
             .join(Self::KITCHENSINK_STDERR_LOG_FILE_NAME)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn proxy_stdout_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::PROXY_STDOUT_LOG_FILE_NAME)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn proxy_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::PROXY_STDERR_LOG_FILE_NAME)
     }
 
-    async fn provider(
+    fn provider(
         &self,
-    ) -> anyhow::Result<
+    ) -> impl Future<
+        Output = anyhow::Result<
             FillProvider<
                 impl TxFiller<KitchenSinkNetwork>,
                 impl Provider<KitchenSinkNetwork>,
                 KitchenSinkNetwork,
             >,
-    > {
+        >,
+    > + 'static {
+        let connection_string = self.connection_string();
+        let wallet = self.wallet.clone();
+
+        // Note: We would like all providers to make use of the same nonce manager so that we have
+        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
+        // its implementation and therefore it means that when we clone it then it still references
+        // the same state.
+        let nonce_manager = self.nonce_manager.clone();
+
+        Box::pin(async move {
             ProviderBuilder::new()
                 .disable_recommended_fillers()
                 .network::<KitchenSinkNetwork>()
@@ -370,20 +371,23 @@ impl KitchensinkNode {
                     1_000_000_000,
                     1_000_000_000,
                 ))
-            .filler(self.chain_id_filler.clone())
+                .filler(ChainIdFiller::default())
-            .filler(NonceFiller::new(self.nonce_manager.clone()))
+                .filler(NonceFiller::new(nonce_manager))
-            .wallet(self.wallet.clone())
+                .wallet(wallet)
-            .connect(&self.rpc_url)
+                .connect(&connection_string)
                 .await
                 .map_err(Into::into)
+        })
     }
 }
 
 impl EthereumNode for KitchensinkNode {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn execute_transaction(
         &self,
         transaction: alloy::rpc::types::TransactionRequest,
     ) -> anyhow::Result<TransactionReceipt> {
+        tracing::debug!(?transaction, "Submitting transaction");
         let receipt = self
             .provider()
             .await?
@@ -391,9 +395,11 @@ impl EthereumNode for KitchensinkNode {
             .await?
             .get_receipt()
             .await?;
+        tracing::info!(?receipt, "Submitted tx to kitchensink");
         Ok(receipt)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
@@ -407,6 +413,7 @@ impl EthereumNode for KitchensinkNode {
             .await?)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
@@ -423,6 +430,7 @@ impl EthereumNode for KitchensinkNode {
         }
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
         self.provider()
             .await?
@@ -431,6 +439,7 @@ impl EthereumNode for KitchensinkNode {
             .map_err(Into::into)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn latest_state_proof(
         &self,
         address: Address,
@@ -446,6 +455,7 @@ impl EthereumNode for KitchensinkNode {
 }
 
 impl ResolverApi for KitchensinkNode {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
             .await?
@@ -454,6 +464,7 @@ impl ResolverApi for KitchensinkNode {
             .map_err(Into::into)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -463,6 +474,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|receipt| receipt.effective_gas_price)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -472,6 +484,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.gas_limit as _)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
             .await?
@@ -481,6 +494,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.beneficiary)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
             .await?
@@ -490,6 +504,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
         self.provider()
             .await?
@@ -504,6 +519,7 @@ impl ResolverApi for KitchensinkNode {
             })
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
             .await?
@@ -513,6 +529,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.hash)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
             .await?
@@ -522,6 +539,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.timestamp)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
             .await?
@@ -550,31 +568,26 @@ impl Node for KitchensinkNode {
         Self {
             id,
             substrate_binary: config.kitchensink.clone(),
-            dev_node_binary: config.revive_dev_node.clone(),
             eth_proxy_binary: config.eth_proxy.clone(),
             rpc_url: String::new(),
+            wallet,
             base_directory,
             logs_directory,
             process_substrate: None,
             process_proxy: None,
-            wallet: Arc::new(wallet),
-            chain_id_filler: Default::default(),
             nonce_manager: Default::default(),
-            use_kitchensink_not_dev_node: config.use_kitchensink_not_dev_node,
             // We know that we only need to be storing 4 files so we can specify that when creating
             // the vector. It's the stdout and stderr of the substrate-node and the eth-rpc.
             logs_file_to_flush: Vec::with_capacity(4),
         }
     }
 
-    fn id(&self) -> usize {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
-        self.id as _
-    }
-
     fn connection_string(&self) -> String {
         self.rpc_url.clone()
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn shutdown(&mut self) -> anyhow::Result<()> {
         // Terminate the processes in a graceful manner to allow for the output to be flushed.
         if let Some(mut child) = self.process_proxy.take() {
@@ -601,10 +614,12 @@ impl Node for KitchensinkNode {
         Ok(())
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
         self.init(&genesis)?.spawn_process()
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.substrate_binary)
             .arg("--version")
@@ -617,7 +632,8 @@ impl Node for KitchensinkNode {
         Ok(String::from_utf8_lossy(&output).into())
     }
 
-    fn matches_target(targets: Option<&[String]>) -> bool {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    fn matches_target(&self, targets: Option<&[String]>) -> bool {
         match targets {
             None => true,
             Some(targets) => targets.iter().any(|str| str.as_str() == "pvm"),
@@ -630,6 +646,7 @@ impl Node for KitchensinkNode {
 }
 
 impl Drop for KitchensinkNode {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
     fn drop(&mut self) {
         self.shutdown().expect("Failed to shutdown")
     }
@@ -1078,7 +1095,6 @@ mod tests {
         Arguments {
             kitchensink: PathBuf::from("substrate-node"),
             eth_proxy: PathBuf::from("eth-rpc"),
-            use_kitchensink_not_dev_node: true,
             ..Default::default()
         }
     }

crates/node/src/lib.rs

@@ -18,9 +18,6 @@ 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.
@@ -39,7 +36,7 @@ pub trait Node: EthereumNode {
 
     /// 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;
+    fn matches_target(&self, targets: Option<&[String]>) -> bool;
 
     /// Returns the EVM version of the node.
     fn evm_version() -> EVMVersion;

crates/node/src/pool.rs

@@ -9,7 +9,6 @@ use revive_dt_common::cached_fs::read_to_string;
 
 use anyhow::Context;
 use revive_dt_config::Arguments;
-use tracing::info;
 
 use crate::Node;
 
@@ -64,16 +63,7 @@ where
 
 fn spawn_node<T: Node + Send>(args: &Arguments, genesis: String) -> anyhow::Result<T> {
     let mut node = T::new(args);
-    info!(
+    tracing::info!("starting node: {}", node.connection_string());
-        id = node.id(),
-        connection_string = node.connection_string(),
-        "Spawning node"
-    );
     node.spawn(genesis)?;
-    info!(
-        id = node.id(),
-        connection_string = node.connection_string(),
-        "Spawned node"
-    );
     Ok(node)
 }

crates/report/Cargo.toml

@@ -13,16 +13,7 @@ revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
 revive-dt-compiler = { workspace = true }
 
-alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
-paste = { workspace = true }
+tracing = { workspace = true }
-indexmap = { workspace = true, features = ["serde"] }
-semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-serde_with = { workspace = true }
-tokio = { workspace = true }
-tracing = { workspace = true }
-
-[lints]
-workspace = true

crates/report/src/aggregator.rs

@@ -1,550 +0,0 @@
-//! Implementation of the report aggregator task which consumes the events sent by the various
-//! reporters and combines them into a single unified report.
-
-use std::{
-    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
-    fs::OpenOptions,
-    path::PathBuf,
-    time::{SystemTime, UNIX_EPOCH},
-};
-
-use alloy_primitives::Address;
-use anyhow::Result;
-use indexmap::IndexMap;
-use revive_dt_compiler::{CompilerInput, CompilerOutput, Mode};
-use revive_dt_config::{Arguments, TestingPlatform};
-use revive_dt_format::{case::CaseIdx, corpus::Corpus, metadata::ContractInstance};
-use semver::Version;
-use serde::Serialize;
-use serde_with::{DisplayFromStr, serde_as};
-use tokio::sync::{
-    broadcast::{Sender, channel},
-    mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel},
-};
-use tracing::debug;
-
-use crate::*;
-
-pub struct ReportAggregator {
-    /* Internal Report State */
-    report: Report,
-    remaining_cases: HashMap<MetadataFilePath, HashMap<Mode, HashSet<CaseIdx>>>,
-    /* Channels */
-    runner_tx: Option<UnboundedSender<RunnerEvent>>,
-    runner_rx: UnboundedReceiver<RunnerEvent>,
-    listener_tx: Sender<ReporterEvent>,
-}
-
-impl ReportAggregator {
-    pub fn new(config: Arguments) -> Self {
-        let (runner_tx, runner_rx) = unbounded_channel::<RunnerEvent>();
-        let (listener_tx, _) = channel::<ReporterEvent>(1024);
-        Self {
-            report: Report::new(config),
-            remaining_cases: Default::default(),
-            runner_tx: Some(runner_tx),
-            runner_rx,
-            listener_tx,
-        }
-    }
-
-    pub fn into_task(mut self) -> (Reporter, impl Future<Output = Result<()>>) {
-        let reporter = self
-            .runner_tx
-            .take()
-            .map(Into::into)
-            .expect("Can't fail since this can only be called once");
-        (reporter, async move { self.aggregate().await })
-    }
-
-    async fn aggregate(mut self) -> Result<()> {
-        debug!("Starting to aggregate report");
-
-        while let Some(event) = self.runner_rx.recv().await {
-            debug!(?event, "Received Event");
-            match event {
-                RunnerEvent::SubscribeToEvents(event) => {
-                    self.handle_subscribe_to_events_event(*event);
-                }
-                RunnerEvent::CorpusFileDiscovery(event) => {
-                    self.handle_corpus_file_discovered_event(*event)
-                }
-                RunnerEvent::MetadataFileDiscovery(event) => {
-                    self.handle_metadata_file_discovery_event(*event);
-                }
-                RunnerEvent::TestCaseDiscovery(event) => {
-                    self.handle_test_case_discovery(*event);
-                }
-                RunnerEvent::TestSucceeded(event) => {
-                    self.handle_test_succeeded_event(*event);
-                }
-                RunnerEvent::TestFailed(event) => {
-                    self.handle_test_failed_event(*event);
-                }
-                RunnerEvent::TestIgnored(event) => {
-                    self.handle_test_ignored_event(*event);
-                }
-                RunnerEvent::LeaderNodeAssigned(event) => {
-                    self.handle_leader_node_assigned_event(*event);
-                }
-                RunnerEvent::FollowerNodeAssigned(event) => {
-                    self.handle_follower_node_assigned_event(*event);
-                }
-                RunnerEvent::PreLinkContractsCompilationSucceeded(event) => {
-                    self.handle_pre_link_contracts_compilation_succeeded_event(*event)
-                }
-                RunnerEvent::PostLinkContractsCompilationSucceeded(event) => {
-                    self.handle_post_link_contracts_compilation_succeeded_event(*event)
-                }
-                RunnerEvent::PreLinkContractsCompilationFailed(event) => {
-                    self.handle_pre_link_contracts_compilation_failed_event(*event)
-                }
-                RunnerEvent::PostLinkContractsCompilationFailed(event) => {
-                    self.handle_post_link_contracts_compilation_failed_event(*event)
-                }
-                RunnerEvent::LibrariesDeployed(event) => {
-                    self.handle_libraries_deployed_event(*event);
-                }
-                RunnerEvent::ContractDeployed(event) => {
-                    self.handle_contract_deployed_event(*event);
-                }
-            }
-        }
-        debug!("Report aggregation completed");
-
-        let file_name = {
-            let current_timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
-            let mut file_name = current_timestamp.to_string();
-            file_name.push_str(".json");
-            file_name
-        };
-        let file_path = self.report.config.directory().join(file_name);
-        let file = OpenOptions::new()
-            .create(true)
-            .write(true)
-            .truncate(true)
-            .read(false)
-            .open(file_path)?;
-        serde_json::to_writer_pretty(file, &self.report)?;
-
-        Ok(())
-    }
-
-    fn handle_subscribe_to_events_event(&self, event: SubscribeToEventsEvent) {
-        let _ = event.tx.send(self.listener_tx.subscribe());
-    }
-
-    fn handle_corpus_file_discovered_event(&mut self, event: CorpusFileDiscoveryEvent) {
-        self.report.corpora.push(event.corpus);
-    }
-
-    fn handle_metadata_file_discovery_event(&mut self, event: MetadataFileDiscoveryEvent) {
-        self.report.metadata_files.insert(event.path.clone());
-    }
-
-    fn handle_test_case_discovery(&mut self, event: TestCaseDiscoveryEvent) {
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .insert(event.test_specifier.case_idx);
-    }
-
-    fn handle_test_succeeded_event(&mut self, event: TestSucceededEvent) {
-        // Remove this from the set of cases we're tracking since it has completed.
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .remove(&event.test_specifier.case_idx);
-
-        // Add information on the fact that the case was ignored to the report.
-        let test_case_report = self.test_case_report(&event.test_specifier);
-        test_case_report.status = Some(TestCaseStatus::Succeeded {
-            steps_executed: event.steps_executed,
-        });
-        self.handle_post_test_case_status_update(&event.test_specifier);
-    }
-
-    fn handle_test_failed_event(&mut self, event: TestFailedEvent) {
-        // Remove this from the set of cases we're tracking since it has completed.
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .remove(&event.test_specifier.case_idx);
-
-        // Add information on the fact that the case was ignored to the report.
-        let test_case_report = self.test_case_report(&event.test_specifier);
-        test_case_report.status = Some(TestCaseStatus::Failed {
-            reason: event.reason,
-        });
-        self.handle_post_test_case_status_update(&event.test_specifier);
-    }
-
-    fn handle_test_ignored_event(&mut self, event: TestIgnoredEvent) {
-        // Remove this from the set of cases we're tracking since it has completed.
-        self.remaining_cases
-            .entry(event.test_specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(event.test_specifier.solc_mode.clone())
-            .or_default()
-            .remove(&event.test_specifier.case_idx);
-
-        // Add information on the fact that the case was ignored to the report.
-        let test_case_report = self.test_case_report(&event.test_specifier);
-        test_case_report.status = Some(TestCaseStatus::Ignored {
-            reason: event.reason,
-            additional_fields: event.additional_fields,
-        });
-        self.handle_post_test_case_status_update(&event.test_specifier);
-    }
-
-    fn handle_post_test_case_status_update(&mut self, specifier: &TestSpecifier) {
-        let remaining_cases = self
-            .remaining_cases
-            .entry(specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(specifier.solc_mode.clone())
-            .or_default();
-        if !remaining_cases.is_empty() {
-            return;
-        }
-
-        let case_status = self
-            .report
-            .test_case_information
-            .entry(specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(specifier.solc_mode.clone())
-            .or_default()
-            .iter()
-            .map(|(case_idx, case_report)| {
-                (
-                    *case_idx,
-                    case_report.status.clone().expect("Can't be uninitialized"),
-                )
-            })
-            .collect::<BTreeMap<_, _>>();
-        let event = ReporterEvent::MetadataFileSolcModeCombinationExecutionCompleted {
-            metadata_file_path: specifier.metadata_file_path.clone().into(),
-            mode: specifier.solc_mode.clone(),
-            case_status,
-        };
-
-        // According to the documentation on send, the sending fails if there are no more receiver
-        // handles. Therefore, this isn't an error that we want to bubble up or anything. If we fail
-        // to send then we ignore the error.
-        let _ = self.listener_tx.send(event);
-    }
-
-    fn handle_leader_node_assigned_event(&mut self, event: LeaderNodeAssignedEvent) {
-        let execution_information = self.execution_information(&ExecutionSpecifier {
-            test_specifier: event.test_specifier,
-            node_id: event.id,
-            node_designation: NodeDesignation::Leader,
-        });
-        execution_information.node = Some(TestCaseNodeInformation {
-            id: event.id,
-            platform: event.platform,
-            connection_string: event.connection_string,
-        });
-    }
-
-    fn handle_follower_node_assigned_event(&mut self, event: FollowerNodeAssignedEvent) {
-        let execution_information = self.execution_information(&ExecutionSpecifier {
-            test_specifier: event.test_specifier,
-            node_id: event.id,
-            node_designation: NodeDesignation::Follower,
-        });
-        execution_information.node = Some(TestCaseNodeInformation {
-            id: event.id,
-            platform: event.platform,
-            connection_string: event.connection_string,
-        });
-    }
-
-    fn handle_pre_link_contracts_compilation_succeeded_event(
-        &mut self,
-        event: PreLinkContractsCompilationSucceededEvent,
-    ) {
-        let include_input = self.report.config.report_include_compiler_input;
-        let include_output = self.report.config.report_include_compiler_output;
-
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        let compiler_input = if include_input {
-            event.compiler_input
-        } else {
-            None
-        };
-        let compiler_output = if include_output {
-            Some(event.compiler_output)
-        } else {
-            None
-        };
-
-        execution_information.pre_link_compilation_status = Some(CompilationStatus::Success {
-            is_cached: event.is_cached,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input,
-            compiler_output,
-        });
-    }
-
-    fn handle_post_link_contracts_compilation_succeeded_event(
-        &mut self,
-        event: PostLinkContractsCompilationSucceededEvent,
-    ) {
-        let include_input = self.report.config.report_include_compiler_input;
-        let include_output = self.report.config.report_include_compiler_output;
-
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        let compiler_input = if include_input {
-            event.compiler_input
-        } else {
-            None
-        };
-        let compiler_output = if include_output {
-            Some(event.compiler_output)
-        } else {
-            None
-        };
-
-        execution_information.post_link_compilation_status = Some(CompilationStatus::Success {
-            is_cached: event.is_cached,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input,
-            compiler_output,
-        });
-    }
-
-    fn handle_pre_link_contracts_compilation_failed_event(
-        &mut self,
-        event: PreLinkContractsCompilationFailedEvent,
-    ) {
-        let include_input = self.report.config.report_include_compiler_input;
-
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        let compiler_input = if include_input {
-            event.compiler_input
-        } else {
-            None
-        };
-
-        execution_information.pre_link_compilation_status = Some(CompilationStatus::Failure {
-            reason: event.reason,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input,
-        });
-    }
-
-    fn handle_post_link_contracts_compilation_failed_event(
-        &mut self,
-        event: PostLinkContractsCompilationFailedEvent,
-    ) {
-        let include_input = self.report.config.report_include_compiler_input;
-
-        let execution_information = self.execution_information(&event.execution_specifier);
-
-        let compiler_input = if include_input {
-            event.compiler_input
-        } else {
-            None
-        };
-
-        execution_information.post_link_compilation_status = Some(CompilationStatus::Failure {
-            reason: event.reason,
-            compiler_version: event.compiler_version,
-            compiler_path: event.compiler_path,
-            compiler_input,
-        });
-    }
-
-    fn handle_libraries_deployed_event(&mut self, event: LibrariesDeployedEvent) {
-        self.execution_information(&event.execution_specifier)
-            .deployed_libraries = Some(event.libraries);
-    }
-
-    fn handle_contract_deployed_event(&mut self, event: ContractDeployedEvent) {
-        self.execution_information(&event.execution_specifier)
-            .deployed_contracts
-            .get_or_insert_default()
-            .insert(event.contract_instance, event.address);
-    }
-
-    fn test_case_report(&mut self, specifier: &TestSpecifier) -> &mut TestCaseReport {
-        self.report
-            .test_case_information
-            .entry(specifier.metadata_file_path.clone().into())
-            .or_default()
-            .entry(specifier.solc_mode.clone())
-            .or_default()
-            .entry(specifier.case_idx)
-            .or_default()
-    }
-
-    fn execution_information(
-        &mut self,
-        specifier: &ExecutionSpecifier,
-    ) -> &mut ExecutionInformation {
-        let test_case_report = self.test_case_report(&specifier.test_specifier);
-        match specifier.node_designation {
-            NodeDesignation::Leader => test_case_report
-                .leader_execution_information
-                .get_or_insert_default(),
-            NodeDesignation::Follower => test_case_report
-                .follower_execution_information
-                .get_or_insert_default(),
-        }
-    }
-}
-
-#[serde_as]
-#[derive(Clone, Debug, Serialize)]
-pub struct Report {
-    /// The configuration that the tool was started up with.
-    pub config: Arguments,
-    /// The platform of the leader chain.
-    pub leader_platform: TestingPlatform,
-    /// The platform of the follower chain.
-    pub follower_platform: TestingPlatform,
-    /// The list of corpus files that the tool found.
-    pub corpora: Vec<Corpus>,
-    /// The list of metadata files that were found by the tool.
-    pub metadata_files: BTreeSet<MetadataFilePath>,
-    /// Information relating to each test case.
-    #[serde_as(as = "BTreeMap<_, HashMap<DisplayFromStr, BTreeMap<DisplayFromStr, _>>>")]
-    pub test_case_information:
-        BTreeMap<MetadataFilePath, HashMap<Mode, BTreeMap<CaseIdx, TestCaseReport>>>,
-}
-
-impl Report {
-    pub fn new(config: Arguments) -> Self {
-        Self {
-            leader_platform: config.leader,
-            follower_platform: config.follower,
-            config,
-            corpora: Default::default(),
-            metadata_files: Default::default(),
-            test_case_information: Default::default(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Default)]
-pub struct TestCaseReport {
-    /// Information on the status of the test case and whether it succeeded, failed, or was ignored.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub status: Option<TestCaseStatus>,
-    /// Information related to the execution on the leader.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub leader_execution_information: Option<ExecutionInformation>,
-    /// Information related to the execution on the follower.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub follower_execution_information: Option<ExecutionInformation>,
-}
-
-/// Information related to the status of the test. Could be that the test succeeded, failed, or that
-/// it was ignored.
-#[derive(Clone, Debug, Serialize)]
-#[serde(tag = "status")]
-pub enum TestCaseStatus {
-    /// The test case succeeded.
-    Succeeded {
-        /// The number of steps of the case that were executed.
-        steps_executed: usize,
-    },
-    /// The test case failed.
-    Failed {
-        /// The reason for the failure of the test case.
-        reason: String,
-    },
-    /// The test case was ignored. This variant carries information related to why it was ignored.
-    Ignored {
-        /// The reason behind the test case being ignored.
-        reason: String,
-        /// Additional fields that describe more information on why the test case is ignored.
-        #[serde(flatten)]
-        additional_fields: IndexMap<String, serde_json::Value>,
-    },
-}
-
-/// Information related to the leader or follower node that's being used to execute the step.
-#[derive(Clone, Debug, Serialize)]
-pub struct TestCaseNodeInformation {
-    /// The ID of the node that this case is being executed on.
-    pub id: usize,
-    /// The platform of the node.
-    pub platform: TestingPlatform,
-    /// The connection string of the node.
-    pub connection_string: String,
-}
-
-/// Execution information tied to the leader or the follower.
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct ExecutionInformation {
-    /// Information related to the node assigned to this test case.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub node: Option<TestCaseNodeInformation>,
-    /// Information on the pre-link compiled contracts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pre_link_compilation_status: Option<CompilationStatus>,
-    /// Information on the post-link compiled contracts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub post_link_compilation_status: Option<CompilationStatus>,
-    /// Information on the deployed libraries.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub deployed_libraries: Option<BTreeMap<ContractInstance, Address>>,
-    /// Information on the deployed contracts.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub deployed_contracts: Option<BTreeMap<ContractInstance, Address>>,
-}
-
-/// Information related to compilation
-#[derive(Clone, Debug, Serialize)]
-#[serde(tag = "status")]
-pub enum CompilationStatus {
-    /// The compilation was successful.
-    Success {
-        /// A flag with information on whether the compilation artifacts were cached or not.
-        is_cached: bool,
-        /// The version of the compiler used to compile the contracts.
-        compiler_version: Version,
-        /// The path of the compiler used to compile the contracts.
-        compiler_path: PathBuf,
-        /// The input provided to the compiler to compile the contracts. This is only included if
-        /// the appropriate flag is set in the CLI configuration and if the contracts were not
-        /// cached and the compiler was invoked.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_input: Option<CompilerInput>,
-        /// The output of the compiler. This is only included if the appropriate flag is set in the
-        /// CLI configurations.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_output: Option<CompilerOutput>,
-    },
-    /// The compilation failed.
-    Failure {
-        /// The failure reason.
-        reason: String,
-        /// The version of the compiler used to compile the contracts.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_version: Option<Version>,
-        /// The path of the compiler used to compile the contracts.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_path: Option<PathBuf>,
-        /// The input provided to the compiler to compile the contracts. This is only included if
-        /// the appropriate flag is set in the CLI configuration and if the contracts were not
-        /// cached and the compiler was invoked.
-        #[serde(skip_serializing_if = "Option::is_none")]
-        compiler_input: Option<CompilerInput>,
-    },
-}

crates/report/src/analyzer.rs

@@ -0,0 +1,81 @@
+//! The report analyzer enriches the raw report data.
+
+use revive_dt_compiler::CompilerOutput;
+use serde::{Deserialize, Serialize};
+
+use crate::reporter::CompilationTask;
+
+/// Provides insights into how well the compilers perform.
+#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
+pub struct CompilerStatistics {
+    /// The sum of contracts observed.
+    pub n_contracts: usize,
+    /// The mean size of compiled contracts.
+    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 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(CompilerOutput { contracts }) = &compilation_task.json_output else {
+            return;
+        };
+
+        for (_solidity, contracts) in contracts.iter() {
+            for (_name, (bytecode, _)) in contracts.iter() {
+                // 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 = bytecode.len() / 2;
+
+                // TODO: for the time being we set the yul_size to be zero. We need to change this
+                // when we overhaul the reporting.
+
+                self.update_sizes(bytecode_size, 0);
+            }
+        }
+    }
+
+    /// Updates the size statistics cumulatively.
+    fn update_sizes(&mut self, bytecode_size: usize, yul_size: usize) {
+        let n_previous = self.n_contracts;
+        let n_current = self.n_contracts + 1;
+
+        self.n_contracts = n_current;
+
+        self.mean_code_size = (n_previous * self.mean_code_size + bytecode_size) / n_current;
+        self.mean_yul_size = (n_previous * self.mean_yul_size + yul_size) / n_current;
+
+        if self.mean_code_size > 0 {
+            self.yul_to_bytecode_size_ratio =
+                self.mean_yul_size as f32 / self.mean_code_size as f32;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CompilerStatistics;
+
+    #[test]
+    fn compiler_statistics() {
+        let mut received = CompilerStatistics::default();
+        received.update_sizes(0, 0);
+        received.update_sizes(3, 37);
+        received.update_sizes(123, 456);
+
+        let mean_code_size = 41; // rounding error from integer truncation
+        let mean_yul_size = 164;
+        let expected = CompilerStatistics {
+            n_contracts: 3,
+            mean_code_size,
+            mean_yul_size,
+            yul_to_bytecode_size_ratio: mean_yul_size as f32 / mean_code_size as f32,
+        };
+
+        assert_eq!(received, expected);
+    }
+}

crates/report/src/common.rs

@@ -1,43 +0,0 @@
-//! Common types and functions used throughout the crate.
-
-use std::{path::PathBuf, sync::Arc};
-
-use revive_dt_common::define_wrapper_type;
-use revive_dt_compiler::Mode;
-use revive_dt_format::{case::CaseIdx, input::StepIdx};
-use serde::{Deserialize, Serialize};
-
-define_wrapper_type!(
-    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-    #[serde(transparent)]
-    pub struct MetadataFilePath(PathBuf);
-);
-
-/// An absolute specifier for a test.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct TestSpecifier {
-    pub solc_mode: Mode,
-    pub metadata_file_path: PathBuf,
-    pub case_idx: CaseIdx,
-}
-
-/// An absolute path for a test that also includes information about the node that it's assigned to
-/// and whether it's the leader or follower.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct ExecutionSpecifier {
-    pub test_specifier: Arc<TestSpecifier>,
-    pub node_id: usize,
-    pub node_designation: NodeDesignation,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum NodeDesignation {
-    Leader,
-    Follower,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct StepExecutionSpecifier {
-    pub execution_specifier: Arc<ExecutionSpecifier>,
-    pub step_idx: StepIdx,
-}

crates/report/src/lib.rs

@@ -1,11 +1,4 @@
-//! This crate implements the reporting infrastructure for the differential testing tool.
+//! The revive differential tests reporting facility.
 
-mod aggregator;
+pub mod analyzer;
-mod common;
+pub mod reporter;
-mod reporter_event;
-mod runner_event;
-
-pub use aggregator::*;
-pub use common::*;
-pub use reporter_event::*;
-pub use runner_event::*;

crates/report/src/reporter.rs

@@ -0,0 +1,236 @@
+//! The reporter is the central place observing test execution by collecting data.
+//!
+//! The data collected gives useful insights into the outcome of the test run
+//! and helps identifying and reproducing failing cases.
+
+use std::{
+    collections::HashMap,
+    fs::{self, File, create_dir_all},
+    path::PathBuf,
+    sync::{Mutex, OnceLock},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use anyhow::Context;
+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;
+
+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)]
+pub struct Report {
+    /// The configuration used during the test.
+    pub config: Arguments,
+    /// The observed test corpora.
+    pub corpora: Vec<Corpus>,
+    /// The observed test definitions.
+    pub metadata_files: Vec<PathBuf>,
+    /// The observed compilation results.
+    pub compiler_results: HashMap<TestingPlatform, Vec<CompilationResult>>,
+    /// The observed compilation statistics.
+    pub compiler_statistics: HashMap<TestingPlatform, CompilerStatistics>,
+    /// The file name this is serialized to.
+    #[serde(skip)]
+    directory: PathBuf,
+}
+
+/// Contains a compiled contract.
+#[derive(Clone, Debug, Serialize)]
+pub struct CompilationTask {
+    /// The observed compiler input.
+    pub json_input: CompilerInput,
+    /// The observed compiler output.
+    pub json_output: Option<CompilerOutput>,
+    /// The observed compiler mode.
+    pub mode: Mode,
+    /// The observed compiler version.
+    pub compiler_version: String,
+    /// The observed error, if any.
+    pub error: Option<String>,
+}
+
+/// Represents a report about a compilation task.
+#[derive(Clone, Debug, Serialize)]
+pub struct CompilationResult {
+    /// The observed compilation task.
+    pub compilation_task: CompilationTask,
+    /// The linked span.
+    pub span: Span,
+}
+
+/// The [Span] struct indicates the context of what is being reported.
+#[derive(Clone, Copy, Debug, Serialize)]
+pub struct Span {
+    /// The corpus index this belongs to.
+    corpus: usize,
+    /// The metadata file this belongs to.
+    metadata_file: usize,
+    /// The index of the case definition this belongs to.
+    case: usize,
+    /// The index of the case input this belongs to.
+    input: usize,
+}
+
+impl Report {
+    /// The file name where this report will be written to.
+    pub const FILE_NAME: &str = "report.json";
+
+    /// The [Span] is expected to initialize the reporter by providing the config.
+    const INITIALIZED_VIA_SPAN: &str = "requires a Span which initializes the reporter";
+
+    /// Create a new [Report].
+    fn new(config: Arguments) -> anyhow::Result<Self> {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_millis();
+
+        let directory = config.directory().join("report").join(format!("{now}"));
+        if !directory.exists() {
+            create_dir_all(&directory)?;
+        }
+
+        Ok(Self {
+            config,
+            directory,
+            ..Default::default()
+        })
+    }
+
+    /// Add a compilation task to the report.
+    pub fn compilation(span: Span, platform: TestingPlatform, compilation_task: CompilationTask) {
+        let mut report = REPORTER
+            .get()
+            .expect(Report::INITIALIZED_VIA_SPAN)
+            .lock()
+            .unwrap();
+
+        report
+            .compiler_statistics
+            .entry(platform)
+            .or_default()
+            .sample(&compilation_task);
+
+        report
+            .compiler_results
+            .entry(platform)
+            .or_default()
+            .push(CompilationResult {
+                compilation_task,
+                span,
+            });
+    }
+
+    /// Write the report to disk.
+    pub fn save() -> anyhow::Result<()> {
+        let Some(reporter) = REPORTER.get() else {
+            return Ok(());
+        };
+        let report = reporter.lock().unwrap();
+
+        if let Err(error) = report.write_to_file() {
+            anyhow::bail!("can not write report: {error}");
+        }
+
+        if report.config.extract_problems {
+            if let Err(error) = report.save_compiler_problems() {
+                anyhow::bail!("can not write compiler problems: {error}");
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Write compiler problems to disk for later debugging.
+    pub fn save_compiler_problems(&self) -> anyhow::Result<()> {
+        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() {
+                    continue;
+                }
+
+                let path = &self.metadata_files[result.span.metadata_file]
+                    .parent()
+                    .unwrap()
+                    .join(format!("{platform}_errors"));
+                if !path.exists() {
+                    create_dir_all(path)?;
+                }
+
+                if let Some(error) = result.compilation_task.error.as_ref() {
+                    fs::write(path.join("compiler_error.txt"), error)?;
+                }
+
+                if let Some(errors) = result.compilation_task.json_output.as_ref() {
+                    let file = File::create(path.join("compiler_output.txt"))?;
+                    serde_json::to_writer_pretty(file, &errors)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write_to_file(&self) -> anyhow::Result<()> {
+        let path = self.directory.join(Self::FILE_NAME);
+
+        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(())
+    }
+}
+
+impl Span {
+    /// Create a new [Span] with case and input index at 0.
+    ///
+    /// Initializes the reporting facility on the first call.
+    pub fn new(corpus: Corpus, config: Arguments) -> anyhow::Result<Self> {
+        let report = Mutex::new(Report::new(config)?);
+        let mut reporter = REPORTER.get_or_init(|| report).lock().unwrap();
+        reporter.corpora.push(corpus);
+
+        Ok(Self {
+            corpus: reporter.corpora.len() - 1,
+            metadata_file: 0,
+            case: 0,
+            input: 0,
+        })
+    }
+
+    /// Advance to the next metadata file: Resets the case input index to 0.
+    pub fn next_metadata(&mut self, metadata_file: PathBuf) {
+        let mut reporter = REPORTER
+            .get()
+            .expect(Report::INITIALIZED_VIA_SPAN)
+            .lock()
+            .unwrap();
+
+        reporter.metadata_files.push(metadata_file);
+
+        self.metadata_file = reporter.metadata_files.len() - 1;
+        self.case = 0;
+        self.input = 0;
+    }
+
+    /// Advance to the next case: Increas the case index by one and resets the input index to 0.
+    pub fn next_case(&mut self) {
+        self.case += 1;
+        self.input = 0;
+    }
+
+    /// Advance to the next input.
+    pub fn next_input(&mut self) {
+        self.input += 1;
+    }
+}

crates/report/src/reporter_event.rs

@@ -1,22 +0,0 @@
-//! A reporter event sent by the report aggregator to the various listeners.
-
-use std::collections::BTreeMap;
-
-use revive_dt_compiler::Mode;
-use revive_dt_format::case::CaseIdx;
-
-use crate::{MetadataFilePath, TestCaseStatus};
-
-#[derive(Clone, Debug)]
-pub enum ReporterEvent {
-    /// An event sent by the reporter once an entire metadata file and solc mode combination has
-    /// finished execution.
-    MetadataFileSolcModeCombinationExecutionCompleted {
-        /// The path of the metadata file.
-        metadata_file_path: MetadataFilePath,
-        /// The Solc mode that this metadata file was executed in.
-        mode: Mode,
-        /// The status of each one of the cases.
-        case_status: BTreeMap<CaseIdx, TestCaseStatus>,
-    },
-}

crates/report/src/runner_event.rs

@@ -1,640 +0,0 @@
-//! The types associated with the events sent by the runner to the reporter.
-#![allow(dead_code)]
-
-use std::{collections::BTreeMap, path::PathBuf, sync::Arc};
-
-use alloy_primitives::Address;
-use indexmap::IndexMap;
-use revive_dt_compiler::{CompilerInput, CompilerOutput};
-use revive_dt_config::TestingPlatform;
-use revive_dt_format::metadata::Metadata;
-use revive_dt_format::{corpus::Corpus, metadata::ContractInstance};
-use semver::Version;
-use tokio::sync::{broadcast, oneshot};
-
-use crate::{ExecutionSpecifier, ReporterEvent, TestSpecifier, common::MetadataFilePath};
-
-macro_rules! __report_gen_emit_test_specific {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )*
-        ;
-        $( $aname:ident : $aty:ty, )*
-    ) => {
-        paste::paste! {
-            pub fn [< report_ $variant_ident:snake _event >](
-                &self
-                $(, $bname: impl Into<$bty> )*
-                $(, $aname: impl Into<$aty> )*
-            ) -> anyhow::Result<()> {
-                self.report([< $variant_ident Event >] {
-                    $skip_field: self.test_specifier.clone()
-                    $(, $bname: $bname.into() )*
-                    $(, $aname: $aname.into() )*
-                })
-            }
-        }
-    };
-}
-
-macro_rules! __report_gen_emit_test_specific_by_parse {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )* ; $( $aname:ident : $aty:ty, )*
-    ) => {
-        __report_gen_emit_test_specific!(
-            $ident, $variant_ident, $skip_field;
-            $( $bname : $bty, )* ; $( $aname : $aty, )*
-        );
-    };
-}
-
-macro_rules! __report_gen_scan_before {
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        test_specifier : $skip_ty:ty,
-        $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_emit_test_specific_by_parse!(
-            $ident, $variant_ident, test_specifier;
-            $( $before : $bty, )* ; $( $after : $aty, )*
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        $name:ident : $ty:ty, $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_scan_before!(
-            $ident, $variant_ident;
-            $( $before : $bty, )* $name : $ty,
-            ;
-            $( $after : $aty, )*
-            ;
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        ;
-    ) => {};
-}
-
-macro_rules! __report_gen_for_variant {
-    (
-        $ident:ident,
-        $variant_ident:ident;
-    ) => {};
-    (
-        $ident:ident,
-        $variant_ident:ident;
-        $( $field_ident:ident : $field_ty:ty ),+ $(,)?
-    ) => {
-        __report_gen_scan_before!(
-            $ident, $variant_ident;
-            ;
-            $( $field_ident : $field_ty, )*
-            ;
-        );
-    };
-}
-
-macro_rules! __report_gen_emit_execution_specific {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )*
-        ;
-        $( $aname:ident : $aty:ty, )*
-    ) => {
-        paste::paste! {
-            pub fn [< report_ $variant_ident:snake _event >](
-                &self
-                $(, $bname: impl Into<$bty> )*
-                $(, $aname: impl Into<$aty> )*
-            ) -> anyhow::Result<()> {
-                self.report([< $variant_ident Event >] {
-                    $skip_field: self.execution_specifier.clone()
-                    $(, $bname: $bname.into() )*
-                    $(, $aname: $aname.into() )*
-                })
-            }
-        }
-    };
-}
-
-macro_rules! __report_gen_emit_execution_specific_by_parse {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )* ; $( $aname:ident : $aty:ty, )*
-    ) => {
-        __report_gen_emit_execution_specific!(
-            $ident, $variant_ident, $skip_field;
-            $( $bname : $bty, )* ; $( $aname : $aty, )*
-        );
-    };
-}
-
-macro_rules! __report_gen_scan_before_exec {
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        execution_specifier : $skip_ty:ty,
-        $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_emit_execution_specific_by_parse!(
-            $ident, $variant_ident, execution_specifier;
-            $( $before : $bty, )* ; $( $after : $aty, )*
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        $name:ident : $ty:ty, $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_scan_before_exec!(
-            $ident, $variant_ident;
-            $( $before : $bty, )* $name : $ty,
-            ;
-            $( $after : $aty, )*
-            ;
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        ;
-    ) => {};
-}
-
-macro_rules! __report_gen_for_variant_exec {
-    (
-        $ident:ident,
-        $variant_ident:ident;
-    ) => {};
-    (
-        $ident:ident,
-        $variant_ident:ident;
-        $( $field_ident:ident : $field_ty:ty ),+ $(,)?
-    ) => {
-        __report_gen_scan_before_exec!(
-            $ident, $variant_ident;
-            ;
-            $( $field_ident : $field_ty, )*
-            ;
-        );
-    };
-}
-
-macro_rules! __report_gen_emit_step_execution_specific {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )*
-        ;
-        $( $aname:ident : $aty:ty, )*
-    ) => {
-        paste::paste! {
-            pub fn [< report_ $variant_ident:snake _event >](
-                &self
-                $(, $bname: impl Into<$bty> )*
-                $(, $aname: impl Into<$aty> )*
-            ) -> anyhow::Result<()> {
-                self.report([< $variant_ident Event >] {
-                    $skip_field: self.step_specifier.clone()
-                    $(, $bname: $bname.into() )*
-                    $(, $aname: $aname.into() )*
-                })
-            }
-        }
-    };
-}
-
-macro_rules! __report_gen_emit_step_execution_specific_by_parse {
-    (
-        $ident:ident,
-        $variant_ident:ident,
-        $skip_field:ident;
-        $( $bname:ident : $bty:ty, )* ; $( $aname:ident : $aty:ty, )*
-    ) => {
-        __report_gen_emit_step_execution_specific!(
-            $ident, $variant_ident, $skip_field;
-            $( $bname : $bty, )* ; $( $aname : $aty, )*
-        );
-    };
-}
-
-macro_rules! __report_gen_scan_before_step {
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        step_specifier : $skip_ty:ty,
-        $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_emit_step_execution_specific_by_parse!(
-            $ident, $variant_ident, step_specifier;
-            $( $before : $bty, )* ; $( $after : $aty, )*
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        $name:ident : $ty:ty, $( $after:ident : $aty:ty, )*
-        ;
-    ) => {
-        __report_gen_scan_before_step!(
-            $ident, $variant_ident;
-            $( $before : $bty, )* $name : $ty,
-            ;
-            $( $after : $aty, )*
-            ;
-        );
-    };
-    (
-        $ident:ident, $variant_ident:ident;
-        $( $before:ident : $bty:ty, )*
-        ;
-        ;
-    ) => {};
-}
-
-macro_rules! __report_gen_for_variant_step {
-    (
-        $ident:ident,
-        $variant_ident:ident;
-    ) => {};
-    (
-        $ident:ident,
-        $variant_ident:ident;
-        $( $field_ident:ident : $field_ty:ty ),+ $(,)?
-    ) => {
-        __report_gen_scan_before_step!(
-            $ident, $variant_ident;
-            ;
-            $( $field_ident : $field_ty, )*
-            ;
-        );
-    };
-}
-
-/// Defines the runner-event which is sent from the test runners to the report aggregator.
-///
-/// This macro defines a number of things related to the reporting infrastructure and the interface
-/// used. First of all, it defines the enum of all of the possible events that the runners can send
-/// to the aggregator. For each one of the variants it defines a separate struct for it to allow the
-/// variant field in the enum to be put in a [`Box`].
-///
-/// In addition to the above, it defines [`From`] implementations for the various event types for
-/// the [`RunnerEvent`] enum essentially allowing for events such as [`CorpusFileDiscoveryEvent`] to
-/// be converted into a [`RunnerEvent`].
-///
-/// In addition to the above, it also defines the [`RunnerEventReporter`] which is a wrapper around
-/// an [`UnboundedSender`] allowing for events to be sent to the report aggregator.
-///
-/// With the above description, we can see that this macro defines almost all of the interface of
-/// the reporting infrastructure, from the enum itself, to its associated types, and also to the
-/// reporter that's used to report events to the aggregator.
-///
-/// [`UnboundedSender`]: tokio::sync::mpsc::UnboundedSender
-macro_rules! define_event {
-    (
-        $(#[$enum_meta: meta])*
-        $vis: vis enum $ident: ident {
-            $(
-                $(#[$variant_meta: meta])*
-                $variant_ident: ident {
-                    $(
-                        $(#[$field_meta: meta])*
-                        $field_ident: ident: $field_ty: ty
-                    ),* $(,)?
-                }
-            ),* $(,)?
-        }
-    ) => {
-        paste::paste! {
-            $(#[$enum_meta])*
-            #[derive(Debug)]
-            $vis enum $ident {
-                $(
-                    $(#[$variant_meta])*
-                    $variant_ident(Box<[<$variant_ident Event>]>)
-                ),*
-            }
-
-            $(
-                #[derive(Debug)]
-                $(#[$variant_meta])*
-                $vis struct [<$variant_ident Event>] {
-                    $(
-                        $(#[$field_meta])*
-                        $vis $field_ident: $field_ty
-                    ),*
-                }
-            )*
-
-            $(
-                impl From<[<$variant_ident Event>]> for $ident {
-                    fn from(value: [<$variant_ident Event>]) -> Self {
-                        Self::$variant_ident(Box::new(value))
-                    }
-                }
-            )*
-
-            /// Provides a way to report events to the aggregator.
-            ///
-            /// Under the hood, this is a wrapper around an [`UnboundedSender`] which abstracts away
-            /// the fact that channels are used and that implements high-level methods for reporting
-            /// various events to the aggregator.
-            #[derive(Clone, Debug)]
-            pub struct [< $ident Reporter >]($vis tokio::sync::mpsc::UnboundedSender<$ident>);
-
-            impl From<tokio::sync::mpsc::UnboundedSender<$ident>> for [< $ident Reporter >] {
-                fn from(value: tokio::sync::mpsc::UnboundedSender<$ident>) -> Self {
-                    Self(value)
-                }
-            }
-
-            impl [< $ident Reporter >] {
-                pub fn test_specific_reporter(
-                    &self,
-                    test_specifier: impl Into<std::sync::Arc<crate::common::TestSpecifier>>
-                ) -> [< $ident TestSpecificReporter >] {
-                    [< $ident TestSpecificReporter >] {
-                        reporter: self.clone(),
-                        test_specifier: test_specifier.into(),
-                    }
-                }
-
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.0.send(event.into()).map_err(Into::into)
-                }
-
-                $(
-                    pub fn [< report_ $variant_ident:snake _event >](&self, $($field_ident: impl Into<$field_ty>),*) -> anyhow::Result<()> {
-                        self.report([< $variant_ident Event >] {
-                            $($field_ident: $field_ident.into()),*
-                        })
-                    }
-                )*
-            }
-
-            /// A reporter that's tied to a specific test case.
-            #[derive(Clone, Debug)]
-            pub struct [< $ident TestSpecificReporter >] {
-                $vis reporter: [< $ident Reporter >],
-                $vis test_specifier: std::sync::Arc<crate::common::TestSpecifier>,
-            }
-
-            impl [< $ident TestSpecificReporter >] {
-                pub fn execution_specific_reporter(
-                    &self,
-                    node_id: impl Into<usize>,
-                    node_designation: impl Into<$crate::common::NodeDesignation>
-                ) -> [< $ident ExecutionSpecificReporter >] {
-                    [< $ident ExecutionSpecificReporter >] {
-                        reporter: self.reporter.clone(),
-                        execution_specifier: Arc::new($crate::common::ExecutionSpecifier {
-                            test_specifier: self.test_specifier.clone(),
-                            node_id: node_id.into(),
-                            node_designation: node_designation.into(),
-                        })
-                    }
-                }
-
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.reporter.report(event)
-                }
-
-                $(
-                    __report_gen_for_variant! { $ident, $variant_ident; $( $field_ident : $field_ty ),* }
-                )*
-            }
-
-            /// A reporter that's tied to a specific execution of the test case such as execution on
-            /// a specific node like the leader or follower.
-            #[derive(Clone, Debug)]
-            pub struct [< $ident ExecutionSpecificReporter >] {
-                $vis reporter: [< $ident Reporter >],
-                $vis execution_specifier: std::sync::Arc<$crate::common::ExecutionSpecifier>,
-            }
-
-            impl [< $ident ExecutionSpecificReporter >] {
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.reporter.report(event)
-                }
-
-                $(
-                    __report_gen_for_variant_exec! { $ident, $variant_ident; $( $field_ident : $field_ty ),* }
-                )*
-            }
-
-            /// A reporter that's tied to a specific step execution
-            #[derive(Clone, Debug)]
-            pub struct [< $ident StepExecutionSpecificReporter >] {
-                $vis reporter: [< $ident Reporter >],
-                $vis step_specifier: std::sync::Arc<$crate::common::StepExecutionSpecifier>,
-            }
-
-            impl [< $ident StepExecutionSpecificReporter >] {
-                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
-                    self.reporter.report(event)
-                }
-
-                $(
-                    __report_gen_for_variant_step! { $ident, $variant_ident; $( $field_ident : $field_ty ),* }
-                )*
-            }
-        }
-    };
-}
-
-define_event! {
-    /// An event type that's sent by the test runners/drivers to the report aggregator.
-    pub(crate) enum RunnerEvent {
-        /// An event emitted by the reporter when it wishes to listen to events emitted by the
-        /// aggregator.
-        SubscribeToEvents {
-            /// The channel that the aggregator is to send the receive side of the channel on.
-            tx: oneshot::Sender<broadcast::Receiver<ReporterEvent>>
-        },
-        /// An event emitted by runners when they've discovered a corpus file.
-        CorpusFileDiscovery {
-            /// The contents of the corpus file.
-            corpus: Corpus
-        },
-        /// An event emitted by runners when they've discovered a metadata file.
-        MetadataFileDiscovery {
-            /// The path of the metadata file discovered.
-            path: MetadataFilePath,
-            /// The content of the metadata file.
-            metadata: Metadata
-        },
-        /// An event emitted by the runners when they discover a test case.
-        TestCaseDiscovery {
-            /// A specifier for the test that was discovered.
-            test_specifier: Arc<TestSpecifier>,
-        },
-        /// An event emitted by the runners when a test case is ignored.
-        TestIgnored {
-            /// A specifier for the test that's been ignored.
-            test_specifier: Arc<TestSpecifier>,
-            /// A reason for the test to be ignored.
-            reason: String,
-            /// Additional fields that describe more information on why the test was ignored.
-            additional_fields: IndexMap<String, serde_json::Value>
-        },
-        /// An event emitted by the runners when a test case has succeeded.
-        TestSucceeded {
-            /// A specifier for the test that succeeded.
-            test_specifier: Arc<TestSpecifier>,
-            /// The number of steps of the case that were executed by the driver.
-            steps_executed: usize,
-        },
-        /// An event emitted by the runners when a test case has failed.
-        TestFailed {
-            /// A specifier for the test that succeeded.
-            test_specifier: Arc<TestSpecifier>,
-            /// A reason for the failure of the test.
-            reason: String,
-        },
-        /// An event emitted when the test case is assigned a leader node.
-        LeaderNodeAssigned {
-            /// A specifier for the test that the assignment is for.
-            test_specifier: Arc<TestSpecifier>,
-            /// The ID of the node that this case is being executed on.
-            id: usize,
-            /// The platform of the node.
-            platform: TestingPlatform,
-            /// The connection string of the node.
-            connection_string: String,
-        },
-        /// An event emitted when the test case is assigned a follower node.
-        FollowerNodeAssigned {
-            /// A specifier for the test that the assignment is for.
-            test_specifier: Arc<TestSpecifier>,
-            /// The ID of the node that this case is being executed on.
-            id: usize,
-            /// The platform of the node.
-            platform: TestingPlatform,
-            /// The connection string of the node.
-            connection_string: String,
-        },
-        /// An event emitted by the runners when the compilation of the contracts has succeeded
-        /// on the pre-link contracts.
-        PreLinkContractsCompilationSucceeded {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Version,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: PathBuf,
-            /// A flag of whether the contract bytecode and ABI were cached or if they were compiled
-            /// anew.
-            is_cached: bool,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The output of the compiler.
-            compiler_output: CompilerOutput
-        },
-        /// An event emitted by the runners when the compilation of the contracts has succeeded
-        /// on the post-link contracts.
-        PostLinkContractsCompilationSucceeded {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Version,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: PathBuf,
-            /// A flag of whether the contract bytecode and ABI were cached or if they were compiled
-            /// anew.
-            is_cached: bool,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The output of the compiler.
-            compiler_output: CompilerOutput
-        },
-        /// An event emitted by the runners when the compilation of the pre-link contract has
-        /// failed.
-        PreLinkContractsCompilationFailed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Option<Version>,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: Option<PathBuf>,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The failure reason.
-            reason: String,
-        },
-        /// An event emitted by the runners when the compilation of the post-link contract has
-        /// failed.
-        PostLinkContractsCompilationFailed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The version of the compiler used to compile the contracts.
-            compiler_version: Option<Version>,
-            /// The path of the compiler used to compile the contracts.
-            compiler_path: Option<PathBuf>,
-            /// The input provided to the compiler - this is optional and not provided if the
-            /// contracts were obtained from the cache.
-            compiler_input: Option<CompilerInput>,
-            /// The failure reason.
-            reason: String,
-        },
-        /// An event emitted by the runners when a library has been deployed.
-        LibrariesDeployed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The addresses of the libraries that were deployed.
-            libraries: BTreeMap<ContractInstance, Address>
-        },
-        /// An event emitted by the runners when they've deployed a new contract.
-        ContractDeployed {
-            /// A specifier for the execution that's taking place.
-            execution_specifier: Arc<ExecutionSpecifier>,
-            /// The instance name of the contract.
-            contract_instance: ContractInstance,
-            /// The address of the contract.
-            address: Address
-        },
-    }
-}
-
-/// An extension to the [`Reporter`] implemented by the macro.
-impl RunnerEventReporter {
-    pub async fn subscribe(&self) -> anyhow::Result<broadcast::Receiver<ReporterEvent>> {
-        let (tx, rx) = oneshot::channel::<broadcast::Receiver<ReporterEvent>>();
-        self.report_subscribe_to_events_event(tx)?;
-        rx.await.map_err(Into::into)
-    }
-}
-
-pub type Reporter = RunnerEventReporter;
-pub type TestSpecificReporter = RunnerEventTestSpecificReporter;
-pub type ExecutionSpecificReporter = RunnerEventExecutionSpecificReporter;

crates/solc-binaries/Cargo.toml

@@ -19,6 +19,3 @@ reqwest = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 sha2 = { workspace = true }
-
-[lints]
-workspace = true

crates/solc-binaries/src/cache.rs

@@ -39,7 +39,10 @@ pub(crate) async fn get_or_download(
 }
 
 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(());
     };
 

crates/solc-binaries/src/download.rs

@@ -107,6 +107,7 @@ impl SolcDownloader {
     /// Errors out if the download fails or the digest of the downloaded file
     /// mismatches the expected digest from the release [List].
     pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
+        tracing::info!("downloading solc: {self:?}");
         let builds = List::download(self.list).await?.builds;
         let build = builds
             .iter()