Cache the chainspec

* Update the commit hash of the tests

* Update the number of cached blocks in revive-dev-node

.github/workflows/test.yml

@@ -18,153 +18,95 @@ env:
   POLKADOT_VERSION: polkadot-stable2506-2
 
 jobs:
-  fmt:
+  machete:
-    runs-on: ubuntu-latest
+    name: Check for Unneeded Dependencies
+    runs-on: ubuntu-24.04
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     steps:
-      - name: Checkout repo
+      - name: Checkout This Repository
-        uses: actions/checkout@v4
-
-      - name: Setup Rust toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
-
-      - name: Install nightly toolchain
-        run: rustup toolchain install nightly
-
-      - name: Install rustfmt for nightly
-        run: rustup component add --toolchain nightly rustfmt
-
-      - name: Cargo fmt
-        run: cargo +nightly fmt --all -- --check
-
-  cache-polkadot:
-    name: Build and cache Polkadot binaries on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    needs: [fmt]
-    strategy:
-      matrix:
-        os: [ubuntu-24.04, macos-14]
-
-    steps:
-      - name: Checkout repo and submodules
         uses: actions/checkout@v4
         with:
           submodules: recursive
-
+      - name: Run Sccache
-      - name: Install dependencies (Linux)
+        uses: mozilla-actions/sccache-action@v0.0.9
-        if: matrix.os == 'ubuntu-24.04'
+      - name: Install the Rust Toolchain
-        run: |
+        uses: actions-rust-lang/setup-rust-toolchain@v1
-          sudo apt-get update
+      - name: Install the Cargo Make Binary
-          sudo apt-get install -y protobuf-compiler clang libclang-dev
+        uses: davidB/rust-cargo-make@v1
-          rustup target add wasm32-unknown-unknown
+      - name: Run Cargo Machete
-          rustup component add rust-src
+        run: cargo make machete
-
+  check-fmt:
-      - name: Install dependencies (macOS)
+    name: Check Formatting
-        if: matrix.os == 'macos-14'
+    runs-on: ubuntu-24.04
-        run: |
+    env:
-          brew install protobuf
+      SCCACHE_GHA_ENABLED: "true"
-          rustup target add wasm32-unknown-unknown
+      RUSTC_WRAPPER: "sccache"
-          rustup component add rust-src
+    steps:
-
+      - name: Checkout This Repository
-      - name: Cache binaries
+        uses: actions/checkout@v4
-        id: cache
-        uses: actions/cache@v3
         with:
-          path: |
+          submodules: recursive
-            ~/.cargo/bin/substrate-node
+      - name: Run Sccache
-            ~/.cargo/bin/eth-rpc
+        uses: mozilla-actions/sccache-action@v0.0.9
-          key: polkadot-binaries-${{ matrix.os }}-${{ hashFiles('polkadot-sdk/.git') }}
+      - name: Install the Rust Toolchain
-
+        uses: actions-rust-lang/setup-rust-toolchain@v1
-      - name: Build substrate-node
+      - name: Install the Cargo Make Binary
-        if: steps.cache.outputs.cache-hit != 'true'
+        uses: davidB/rust-cargo-make@v1
-        run: |
+      - name: Run Cargo Formatter
-          cd polkadot-sdk
+        run: cargo make fmt-check
-          cargo install --locked --force --profile=production --path substrate/bin/node/cli --bin substrate-node --features cli
+  check-clippy:
-
+    name: Check Clippy Lints
-      - name: Build eth-rpc
+    runs-on: ubuntu-24.04
-        if: steps.cache.outputs.cache-hit != 'true'
+    env:
-        run: |
+      SCCACHE_GHA_ENABLED: "true"
-          cd polkadot-sdk
+      RUSTC_WRAPPER: "sccache"
-          cargo install --path substrate/frame/revive/rpc --bin eth-rpc
+    steps:
-      
+      - name: Checkout This Repository
-      - name: Cache downloaded Polkadot binaries
+        uses: actions/checkout@v4
-        id: cache-polkadot
-        uses: actions/cache@v3
         with:
-          path: |
+          submodules: recursive
-            ~/polkadot-cache/polkadot
+      - name: Run Sccache
-            ~/polkadot-cache/polkadot-execute-worker
+        uses: mozilla-actions/sccache-action@v0.0.9
-            ~/polkadot-cache/polkadot-prepare-worker
+      - name: Install the Rust Toolchain
-            ~/polkadot-cache/polkadot-parachain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
-          key: polkadot-downloaded-${{ matrix.os }}-${{ env.POLKADOT_VERSION }}
+      - name: Install the Cargo Make Binary
-
+        uses: davidB/rust-cargo-make@v1
-      - name: Download Polkadot binaries on macOS
+      - name: Run Cargo Clippy
-        if: matrix.os == 'macos-14' && steps.cache-polkadot.outputs.cache-hit != 'true'
+        run: cargo make clippy
-        run: |
+  test:
-          mkdir -p ~/polkadot-cache
+    name: Unit Tests
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-aarch64-apple-darwin -o ~/polkadot-cache/polkadot
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-execute-worker-aarch64-apple-darwin -o ~/polkadot-cache/polkadot-execute-worker
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-prepare-worker-aarch64-apple-darwin -o ~/polkadot-cache/polkadot-prepare-worker
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-parachain-aarch64-apple-darwin -o ~/polkadot-cache/polkadot-parachain
-          chmod +x ~/polkadot-cache/*
-
-      - name: Download Polkadot binaries on Ubuntu
-        if: matrix.os == 'ubuntu-24.04' && steps.cache-polkadot.outputs.cache-hit != 'true'
-        run: |
-          mkdir -p ~/polkadot-cache
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot -o ~/polkadot-cache/polkadot
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-execute-worker -o ~/polkadot-cache/polkadot-execute-worker
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-prepare-worker -o ~/polkadot-cache/polkadot-prepare-worker
-          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-parachain -o ~/polkadot-cache/polkadot-parachain
-          chmod +x ~/polkadot-cache/*
-
-  ci:
-    name: CI on ${{ matrix.os }}
-    needs: cache-polkadot
     runs-on: ${{ matrix.os }}
+    needs: cache-polkadot
     strategy:
       matrix:
         os: [ubuntu-24.04, macos-14]
-
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
+      POLKADOT_SDK_COMMIT_HASH: "30cda2aad8612a10ff729d494acd9d5353294d63"
     steps:
-      - name: Checkout repo
+      - name: Checkout This Repository
         uses: actions/checkout@v4
-
-      - name: Restore binaries from cache
-        uses: actions/cache@v3
         with:
-          path: |
+          submodules: recursive
-            ~/.cargo/bin/substrate-node
+      - name: Run Sccache
-            ~/.cargo/bin/eth-rpc
+        uses: mozilla-actions/sccache-action@v0.0.9
-          key: polkadot-binaries-${{ matrix.os }}-${{ hashFiles('polkadot-sdk/.git') }}
+      - name: Install the Rust Toolchain
-
-      - name: Restore downloaded Polkadot binaries from cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/polkadot-cache/polkadot
-            ~/polkadot-cache/polkadot-execute-worker
-            ~/polkadot-cache/polkadot-prepare-worker
-            ~/polkadot-cache/polkadot-parachain
-          key: polkadot-downloaded-${{ matrix.os }}-${{ env.POLKADOT_VERSION }}
-
-      - name: Install Polkadot binaries
-        run: |
-          sudo cp ~/polkadot-cache/polkadot /usr/local/bin/
-          sudo cp ~/polkadot-cache/polkadot-execute-worker /usr/local/bin/
-          sudo cp ~/polkadot-cache/polkadot-prepare-worker /usr/local/bin/
-          sudo cp ~/polkadot-cache/polkadot-parachain /usr/local/bin/
-          sudo chmod +x /usr/local/bin/polkadot*
-
-      - name: Setup Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          rustflags: ""
+          target: "wasm32-unknown-unknown"
-
+          components: "rust-src,rust-std"
-      - name: Add wasm32 target and formatting
+      - name: Install the Cargo Make Binary
-        run: |
+        uses: davidB/rust-cargo-make@v1
-          rustup target add wasm32-unknown-unknown
+      - name: Caching Step
-          rustup component add rust-src rustfmt clippy
+        uses: actions/cache@v4
-
+        with:
+          path: |
+            ~/.cargo/bin/eth-rpc
+            ~/.cargo/bin/revive-dev-node
+          key: polkadot-binaries-${{ env.POLKADOT_SDK_COMMIT_HASH }}-${{ matrix.os }}
       - name: Install Geth on Ubuntu
         if: matrix.os == 'ubuntu-24.04'
         run: |
@@ -197,7 +139,6 @@ jobs:
           curl -sL https://github.com/paritytech/revive/releases/download/v0.3.0/resolc-x86_64-unknown-linux-musl -o resolc
           chmod +x resolc
           sudo mv resolc /usr/local/bin
-
       - name: Install Geth on macOS
         if: matrix.os == 'macos-14'
         run: |
@@ -209,64 +150,79 @@ jobs:
           curl -sL https://github.com/paritytech/revive/releases/download/v0.3.0/resolc-universal-apple-darwin -o resolc
           chmod +x resolc
           sudo mv resolc /usr/local/bin
-
       - name: Install Kurtosis on macOS
         if: matrix.os == 'macos-14'
         run: brew install kurtosis-tech/tap/kurtosis-cli
-
       - name: Install Kurtosis on Ubuntu
         if: matrix.os == 'ubuntu-24.04'
         run: |
           echo "deb [trusted=yes] https://apt.fury.io/kurtosis-tech/ /" | sudo tee /etc/apt/sources.list.d/kurtosis.list
           sudo apt update
           sudo apt install kurtosis-cli
+      - name: Run Tests
+        run: cargo make test
+  cache-polkadot:
+    name: Build and Cache Polkadot Binaries on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, macos-14]
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
+      RUSTFLAGS: "-Awarnings"
+      POLKADOT_SDK_COMMIT_HASH: "30cda2aad8612a10ff729d494acd9d5353294d63"
+    steps:
+      - name: Caching Step
+        id: cache-step
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/eth-rpc
+            ~/.cargo/bin/revive-dev-node
+          key: polkadot-binaries-${{ env.POLKADOT_SDK_COMMIT_HASH }}-${{ matrix.os }}
+      - name: Checkout the Polkadot SDK Repository
+        uses: actions/checkout@v4
+        if: steps.cache-step.outputs.cache-hit != 'true'
+        with:
+          repository: paritytech/polkadot-sdk
+          ref: ${{ env.POLKADOT_SDK_COMMIT_HASH }}
+          submodules: recursive
+      - name: Run Sccache
+        uses: mozilla-actions/sccache-action@v0.0.9
+        if: steps.cache-step.outputs.cache-hit != 'true'
+      - name: Install the Rust Toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        if: steps.cache-step.outputs.cache-hit != 'true'
+        with:
+          target: "wasm32-unknown-unknown"
+          components: "rust-src"
+          toolchain: "1.90.0"
 
-      - name: Machete
+      - name: Install dependencies (Linux)
-        uses: bnjbvr/cargo-machete@v0.7.1
+        if: matrix.os == 'ubuntu-24.04' && steps.cache-step.outputs.cache-hit != 'true'
-
-      - name: Format
-        run: make format
-
-      - name: Clippy
-        run: make clippy
-
-      - name: Check substrate-node version
-        run: substrate-node --version
-
-      - name: Check eth-rpc version
-        run: eth-rpc --version
-
-      - name: Check resolc version
-        run: resolc --version
-
-      - name: Check polkadot version
-        run: polkadot --version
-      
-      - name: Check polkadot-parachain version
-        run: polkadot-parachain --version
-
-      - name: Check polkadot-execute-worker version
-        run: polkadot-execute-worker --version
-      
-      - name: Check polkadot-prepare-worker version
-        run: polkadot-prepare-worker --version
-
-      - name: Test Formatting
-        run: make format
-
-      - name: Test Clippy
-        run: make clippy
-
-      - name: Test Machete
-        run: make machete
-
-      - name: Unit Tests
-        if: matrix.os == 'ubuntu-24.04'
-        run: cargo test --workspace -- --nocapture
-
-      # We can't install docker in the MacOS image used in CI and therefore we need to skip the
-      # Kurtosis and lighthouse related tests when running the CI on MacOS.
-      - name: Unit Tests
-        if: matrix.os == 'macos-14'
         run: |
-          cargo test --workspace -- --nocapture --skip lighthouse_geth::tests::
+          sudo apt-get update
+          sudo apt-get install -y protobuf-compiler clang libclang-dev
+      - name: Install dependencies (macOS)
+        if: matrix.os == 'macos-14' && steps.cache-step.outputs.cache-hit != 'true'
+        run: |
+          brew install protobuf llvm
+          LLVM_PREFIX="$(brew --prefix llvm)"
+          echo "LDFLAGS=-L${LLVM_PREFIX}/lib" >> "$GITHUB_ENV"
+          echo "CPPFLAGS=-I${LLVM_PREFIX}/include" >> "$GITHUB_ENV"
+          echo "CMAKE_PREFIX_PATH=${LLVM_PREFIX}" >> "$GITHUB_ENV"
+          echo "LIBCLANG_PATH=${LLVM_PREFIX}/lib" >> "$GITHUB_ENV"
+          echo "DYLD_FALLBACK_LIBRARY_PATH=${LLVM_PREFIX}/lib" >> "$GITHUB_ENV"
+          echo "${LLVM_PREFIX}/bin" >> "$GITHUB_PATH"
+      - name: Build Polkadot Dependencies
+        if: steps.cache-step.outputs.cache-hit != 'true'
+        run: |
+          cargo build \
+            --locked \
+            --profile production \
+            --package revive-dev-node \
+            --package pallet-revive-eth-rpc;
+          mv ./target/production/revive-dev-node ~/.cargo/bin
+          mv ./target/production/eth-rpc ~/.cargo/bin
+          chmod +x ~/.cargo/bin/*

.gitignore

@@ -3,13 +3,15 @@
 .DS_Store
 node_modules
 /*.json
+*.sh
 
 # 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
-resolc-compiler-tests
 workdir
 
 !/schema.json
+!/dev-genesis.json
+!/scripts/*

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "polkadot-sdk"]
+[submodule "resolc-compiler-tests"]
-	path = polkadot-sdk
+	path = resolc-compiler-tests
-	url = https://github.com/paritytech/polkadot-sdk.git
+	url = https://github.com/paritytech/resolc-compiler-tests

Cargo.lock

@@ -782,6 +782,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "anstream"
 version = "0.6.18"
@@ -1911,6 +1920,7 @@ dependencies = [
  "anstyle",
  "clap_lex",
  "strsim",
+ "terminal_size",
 ]
 
 [[package]]
@@ -2328,7 +2338,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d162beedaa69905488a8da94f5ac3edb4dd4788b732fadb7bd120b2625c1976"
 dependencies = [
  "data-encoding",
- "syn 1.0.109",
+ "syn 2.0.101",
 ]
 
 [[package]]
@@ -2927,6 +2937,22 @@ dependencies = [
  "sp-crypto-hashing",
 ]
 
+[[package]]
+name = "frame-decode"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c470df86cf28818dd3cd2fc4667b80dbefe2236c722c3dc1d09e7c6c82d6dfcd"
+dependencies = [
+ "frame-metadata",
+ "parity-scale-codec",
+ "scale-decode",
+ "scale-encode",
+ "scale-info",
+ "scale-type-resolver",
+ "sp-crypto-hashing",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "frame-metadata"
 version = "23.0.0"
@@ -4526,27 +4552,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "ml-test-runner"
-version = "0.1.0"
-dependencies = [
- "alloy",
- "anyhow",
- "clap",
- "revive-dt-common",
- "revive-dt-compiler",
- "revive-dt-config",
- "revive-dt-core",
- "revive-dt-format",
- "revive-dt-node",
- "revive-dt-node-interaction",
- "revive-dt-report",
- "temp-dir",
- "tokio",
- "tracing",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "moka"
 version = "0.12.10"
@@ -5585,6 +5590,7 @@ dependencies = [
  "clap",
  "moka",
  "once_cell",
+ "regex",
  "schemars 1.0.4",
  "semver 1.0.26",
  "serde",
@@ -5623,6 +5629,7 @@ dependencies = [
  "semver 1.0.26",
  "serde",
  "serde_json",
+ "serde_with",
  "strum",
  "temp-dir",
 ]
@@ -5632,6 +5639,7 @@ name = "revive-dt-core"
 version = "0.1.0"
 dependencies = [
  "alloy",
+ "ansi_term",
  "anyhow",
  "bson",
  "cacache",
@@ -5649,6 +5657,7 @@ dependencies = [
  "semver 1.0.26",
  "serde",
  "serde_json",
+ "subxt 0.44.0",
  "tokio",
  "tracing",
  "tracing-appender",
@@ -5662,7 +5671,7 @@ dependencies = [
  "alloy",
  "anyhow",
  "futures",
- "regex",
+ "itertools 0.14.0",
  "revive-common",
  "revive-dt-common",
  "schemars 1.0.4",
@@ -5685,12 +5694,14 @@ dependencies = [
  "revive-dt-config",
  "revive-dt-format",
  "revive-dt-node-interaction",
+ "revive-dt-report",
  "serde",
  "serde_json",
  "serde_with",
  "serde_yaml_ng",
  "sp-core",
  "sp-runtime",
+ "subxt 0.44.0",
  "temp-dir",
  "tokio",
  "tower 0.5.2",
@@ -5707,6 +5718,7 @@ dependencies = [
  "futures",
  "revive-common",
  "revive-dt-format",
+ "revive-dt-report",
 ]
 
 [[package]]
@@ -5716,6 +5728,7 @@ dependencies = [
  "alloy",
  "anyhow",
  "indexmap 2.10.0",
+ "itertools 0.14.0",
  "paste",
  "revive-dt-common",
  "revive-dt-compiler",
@@ -5963,7 +5976,7 @@ dependencies = [
  "security-framework 3.3.0",
  "security-framework-sys",
  "webpki-root-certs 0.26.11",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -7360,11 +7373,48 @@ dependencies = [
  "serde",
  "serde_json",
  "sp-crypto-hashing",
- "subxt-core",
+ "subxt-core 0.43.0",
- "subxt-lightclient",
+ "subxt-lightclient 0.43.0",
- "subxt-macro",
+ "subxt-macro 0.43.0",
- "subxt-metadata",
+ "subxt-metadata 0.43.0",
- "subxt-rpcs",
+ "subxt-rpcs 0.43.0",
+ "thiserror 2.0.12",
+ "tokio",
+ "tokio-util",
+ "tracing",
+ "url",
+ "wasm-bindgen-futures",
+ "web-time",
+]
+
+[[package]]
+name = "subxt"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddbf938ac1d86a361a84709a71cdbae5d87f370770b563651d1ec052eed9d0b4"
+dependencies = [
+ "async-trait",
+ "derive-where",
+ "either",
+ "frame-metadata",
+ "futures",
+ "hex",
+ "jsonrpsee",
+ "parity-scale-codec",
+ "primitive-types 0.13.1",
+ "scale-bits",
+ "scale-decode",
+ "scale-encode",
+ "scale-info",
+ "scale-value",
+ "serde",
+ "serde_json",
+ "sp-crypto-hashing",
+ "subxt-core 0.44.0",
+ "subxt-lightclient 0.44.0",
+ "subxt-macro 0.44.0",
+ "subxt-metadata 0.44.0",
+ "subxt-rpcs 0.44.0",
  "thiserror 2.0.12",
  "tokio",
  "tokio-util",
@@ -7386,7 +7436,24 @@ dependencies = [
  "quote",
  "scale-info",
  "scale-typegen",
- "subxt-metadata",
+ "subxt-metadata 0.43.0",
+ "syn 2.0.101",
+ "thiserror 2.0.12",
+]
+
+[[package]]
+name = "subxt-codegen"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c250ad8cd102d40ae47977b03295a2ff791375f30ddc7474d399fb56efb793b"
+dependencies = [
+ "heck",
+ "parity-scale-codec",
+ "proc-macro2",
+ "quote",
+ "scale-info",
+ "scale-typegen",
+ "subxt-metadata 0.44.0",
  "syn 2.0.101",
  "thiserror 2.0.12",
 ]
@@ -7400,7 +7467,7 @@ dependencies = [
  "base58",
  "blake2",
  "derive-where",
- "frame-decode",
+ "frame-decode 0.8.3",
  "frame-metadata",
  "hashbrown 0.14.5",
  "hex",
@@ -7416,7 +7483,37 @@ dependencies = [
  "serde",
  "serde_json",
  "sp-crypto-hashing",
- "subxt-metadata",
+ "subxt-metadata 0.43.0",
+ "thiserror 2.0.12",
+ "tracing",
+]
+
+[[package]]
+name = "subxt-core"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5705c5b420294524e41349bf23c6b11aa474ce731de7317f4153390e1927f702"
+dependencies = [
+ "base58",
+ "blake2",
+ "derive-where",
+ "frame-decode 0.9.0",
+ "frame-metadata",
+ "hashbrown 0.14.5",
+ "hex",
+ "impl-serde",
+ "keccak-hash",
+ "parity-scale-codec",
+ "primitive-types 0.13.1",
+ "scale-bits",
+ "scale-decode",
+ "scale-encode",
+ "scale-info",
+ "scale-value",
+ "serde",
+ "serde_json",
+ "sp-crypto-hashing",
+ "subxt-metadata 0.44.0",
  "thiserror 2.0.12",
  "tracing",
 ]
@@ -7438,6 +7535,23 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "subxt-lightclient"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64e02732a6c9ae46bc282c1a741b3d3e494021b3e87e7e92cfb3620116d92911"
+dependencies = [
+ "futures",
+ "futures-util",
+ "serde",
+ "serde_json",
+ "smoldot-light",
+ "thiserror 2.0.12",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+]
+
 [[package]]
 name = "subxt-macro"
 version = "0.43.0"
@@ -7449,9 +7563,26 @@ dependencies = [
  "proc-macro-error2",
  "quote",
  "scale-typegen",
- "subxt-codegen",
+ "subxt-codegen 0.43.0",
- "subxt-metadata",
+ "subxt-metadata 0.43.0",
- "subxt-utils-fetchmetadata",
+ "subxt-utils-fetchmetadata 0.43.0",
+ "syn 2.0.101",
+]
+
+[[package]]
+name = "subxt-macro"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501bf358698f5ab02a6199a1fcd3f1b482e2f5b6eb5d185411e6a74a175ec8e8"
+dependencies = [
+ "darling 0.20.11",
+ "parity-scale-codec",
+ "proc-macro-error2",
+ "quote",
+ "scale-typegen",
+ "subxt-codegen 0.44.0",
+ "subxt-metadata 0.44.0",
+ "subxt-utils-fetchmetadata 0.44.0",
  "syn 2.0.101",
 ]
 
@@ -7461,7 +7592,22 @@ version = "0.43.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2c134068711c0c46906abc0e6e4911204420331530738e18ca903a5469364d9f"
 dependencies = [
- "frame-decode",
+ "frame-decode 0.8.3",
+ "frame-metadata",
+ "hashbrown 0.14.5",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-crypto-hashing",
+ "thiserror 2.0.12",
+]
+
+[[package]]
+name = "subxt-metadata"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01fb7c0bfafad78dda7084c6a2444444744af3bbf7b2502399198b9b4c20eddf"
+dependencies = [
+ "frame-decode 0.9.0",
  "frame-metadata",
  "hashbrown 0.14.5",
  "parity-scale-codec",
@@ -7486,8 +7632,32 @@ dependencies = [
  "primitive-types 0.13.1",
  "serde",
  "serde_json",
- "subxt-core",
+ "subxt-core 0.43.0",
- "subxt-lightclient",
+ "subxt-lightclient 0.43.0",
+ "thiserror 2.0.12",
+ "tokio-util",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "subxt-rpcs"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab68a9c20ecedb0cb7d62d64f884e6add91bb70485783bf40aa8eac5c389c6e0"
+dependencies = [
+ "derive-where",
+ "frame-metadata",
+ "futures",
+ "hex",
+ "impl-serde",
+ "jsonrpsee",
+ "parity-scale-codec",
+ "primitive-types 0.13.1",
+ "serde",
+ "serde_json",
+ "subxt-core 0.44.0",
+ "subxt-lightclient 0.44.0",
  "thiserror 2.0.12",
  "tokio-util",
  "tracing",
@@ -7517,7 +7687,7 @@ dependencies = [
  "serde_json",
  "sha2 0.10.9",
  "sp-crypto-hashing",
- "subxt-core",
+ "subxt-core 0.43.0",
  "thiserror 2.0.12",
  "zeroize",
 ]
@@ -7533,6 +7703,17 @@ dependencies = [
  "thiserror 2.0.12",
 ]
 
+[[package]]
+name = "subxt-utils-fetchmetadata"
+version = "0.44.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e450f6812a653c5a3e63a079aa3b60a3f4c362722753c3222286eaa1800f9002"
+dependencies = [
+ "hex",
+ "parity-scale-codec",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -7659,6 +7840,16 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "terminal_size"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45c6481c4829e4cc63825e62c49186a34538b7b2750b73b266581ffb612fb5ed"
+dependencies = [
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -9326,7 +9517,7 @@ dependencies = [
  "serde_json",
  "sha2 0.10.9",
  "sp-core",
- "subxt",
+ "subxt 0.43.0",
  "subxt-signer",
  "thiserror 1.0.69",
  "tokio",
@@ -9386,7 +9577,7 @@ dependencies = [
  "async-trait",
  "futures",
  "lazy_static",
- "subxt",
+ "subxt 0.43.0",
  "subxt-signer",
  "tokio",
  "zombienet-configuration",

Cargo.toml

@@ -22,10 +22,11 @@ revive-dt-node-pool = { version = "0.1.0", path = "crates/node-pool" }
 revive-dt-report = { version = "0.1.0", path = "crates/report" }
 revive-dt-solc-binaries = { version = "0.1.0", path = "crates/solc-binaries" }
 
+ansi_term = "0.12.1"
 anyhow = "1.0"
 bson = { version = "2.15.0" }
 cacache = { version = "13.1.0" }
-clap = { version = "4", features = ["derive"] }
+clap = { version = "4", features = ["derive", "wrap_help"] }
 dashmap = { version = "6.1.0" }
 foundry-compilers-artifacts = { version = "0.18.0" }
 futures = { version = "0.3.31" }
@@ -49,6 +50,7 @@ sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"
 sp-runtime = "41.1.0"
 strum = { version = "0.27.2", features = ["derive"] }
+subxt = { version = "0.44.0" }
 temp-dir = { version = "0.1.16" }
 tempfile = "3.3"
 thiserror = "2"
@@ -67,13 +69,14 @@ tracing-subscriber = { version = "0.3.19", default-features = false, features =
     "env-filter",
 ] }
 indexmap = { version = "2.10.0", default-features = false }
+itertools = { version = "0.14.0" }
 
 # revive compiler
 revive-solc-json-interface = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
 revive-common = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
 revive-differential = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
 
-zombienet-sdk = { git = "https://github.com/paritytech/zombienet-sdk.git", rev ="891f6554354ce466abd496366dbf8b4f82141241" }
+zombienet-sdk = { git = "https://github.com/paritytech/zombienet-sdk.git", rev = "891f6554354ce466abd496366dbf8b4f82141241" }
 
 [workspace.dependencies.alloy]
 version = "1.0.37"

Makefile

@@ -1,15 +0,0 @@
-.PHONY: format clippy test machete
-
-format:
-	cargo fmt --all -- --check
-
-clippy:
-	cargo clippy --all-features --workspace -- --deny warnings
-
-machete:
-	cargo install cargo-machete
-	cargo machete crates
-
-test: format clippy machete
-	cargo test --workspace -- --nocapture
-

Makefile.toml

@@ -0,0 +1,21 @@
+[config]
+default_to_workspace = false
+
+[tasks.machete]
+command = "cargo"
+args = ["machete", "crates"]
+install_crate = "cargo-machete"
+
+[tasks.fmt-check]
+command = "cargo"
+args = ["fmt", "--all", "--", "--check"]
+install_crate = "rustfmt"
+
+[tasks.clippy]
+command = "cargo"
+args = ["clippy", "--all-features", "--workspace", "--", "--deny", "warnings"]
+install_crate = "clippy"
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--workspace", "--", "--nocapture"]

README.md

@@ -9,7 +9,7 @@
 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:
 
 - Geth (EVM reference implementation)
-- Revive Kitchensink (Substrate-based PolkaVM + `eth-rpc` proxy)
+- Revive Dev Node (Substrate-based PolkaVM + `eth-rpc` proxy)
 
 Use it to:
 
@@ -39,9 +39,9 @@ This repository contains none of the tests and only contains the testing framewo
 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.
+- Geth - When doing differential testing against the PVM we submit transactions to a Geth node and to Revive Dev Node to compare them.
-- Kitchensink - When doing differential testing against the PVM we submit transactions to a Geth node and to Kitchensink to compare them.
+- Revive Dev Node - When doing differential testing against the PVM we submit transactions to a Geth node and to Revive Dev Node to compare them.
-- ETH-RPC - All communication with Kitchensink is done through the ETH RPC.
+- ETH-RPC - All communication with Revive Dev Node 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.
 - Kurtosis - The Kurtosis CLI tool is required for the production Ethereum mainnet-like node configuration with Geth as the execution layer and lighthouse as the consensus layer. Kurtosis also requires docker to be installed since it runs everything inside of docker containers.
@@ -52,192 +52,69 @@ All of the above need to be installed and available in the path in order for the
 
 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 -- execute-tests --help
-Error: Executes tests in the MatterLabs format differentially on multiple targets concurrently
-
-Usage: retester execute-tests [OPTIONS]
-
-Options:
-  -w, --working-directory <WORKING_DIRECTORY>
-          The working directory that the program will use for all of the temporary artifacts needed at runtime.
-
-          If not specified, then a temporary directory will be created and used by the program for all temporary artifacts.
-
-          [default: ]
-
-  -p, --platform <PLATFORMS>
-          The set of platforms that the differential tests should run on
-
-          [default: geth-evm-solc,revive-dev-node-polkavm-resolc]
-
-          Possible values:
-          - geth-evm-solc:                  The Go-ethereum reference full node EVM implementation with the solc compiler
-          - kitchensink-polkavm-resolc:     The kitchensink node with the PolkaVM backend with the resolc compiler
-          - kitchensink-revm-solc:          The kitchensink node with the REVM backend with the solc compiler
-          - revive-dev-node-polkavm-resolc: The revive dev node with the PolkaVM backend with the resolc compiler
-          - revive-dev-node-revm-solc:      The revive dev node with the REVM backend with the solc compiler
-
-  -c, --corpus <CORPUS>
-          A list of test corpus JSON files to be tested
-
-  -h, --help
-          Print help (see a summary with '-h')
-
-Solc Configuration:
-      --solc.version <VERSION>
-          Specifies the default version of the Solc compiler that should be used if there is no override specified by one of the test cases
-
-          [default: 0.8.29]
-
-Resolc Configuration:
-      --resolc.path <resolc.path>
-          Specifies the path of the resolc compiler to be used by the tool.
-
-          If this is not specified, then the tool assumes that it should use the resolc binary that's provided in the user's $PATH.
-
-          [default: resolc]
-
-Geth Configuration:
-      --geth.path <geth.path>
-          Specifies the path of the geth node to be used by the tool.
-
-          If this is not specified, then the tool assumes that it should use the geth binary that's provided in the user's $PATH.
-
-          [default: geth]
-
-      --geth.start-timeout-ms <geth.start-timeout-ms>
-          The amount of time to wait upon startup before considering that the node timed out
-
-          [default: 5000]
-
-Kitchensink Configuration:
-      --kitchensink.path <kitchensink.path>
-          Specifies the path of the kitchensink node to be used by the tool.
-
-          If this is not specified, then the tool assumes that it should use the kitchensink binary that's provided in the user's $PATH.
-
-          [default: substrate-node]
-
-      --kitchensink.start-timeout-ms <kitchensink.start-timeout-ms>
-          The amount of time to wait upon startup before considering that the node timed out
-
-          [default: 5000]
-
-      --kitchensink.dont-use-dev-node
-          This configures the tool to use Kitchensink instead of using the revive-dev-node
-
-Revive Dev Node Configuration:
-      --revive-dev-node.path <revive-dev-node.path>
-          Specifies the path of the revive dev node to be used by the tool.
-
-          If this is not specified, then the tool assumes that it should use the revive dev node binary that's provided in the user's $PATH.
-
-          [default: revive-dev-node]
-
-      --revive-dev-node.start-timeout-ms <revive-dev-node.start-timeout-ms>
-          The amount of time to wait upon startup before considering that the node timed out
-
-          [default: 5000]
-
-Eth RPC Configuration:
-      --eth-rpc.path <eth-rpc.path>
-          Specifies the path of the ETH RPC to be used by the tool.
-
-          If this is not specified, then the tool assumes that it should use the ETH RPC binary that's provided in the user's $PATH.
-
-          [default: eth-rpc]
-
-      --eth-rpc.start-timeout-ms <eth-rpc.start-timeout-ms>
-          The amount of time to wait upon startup before considering that the node timed out
-
-          [default: 5000]
-
-Genesis Configuration:
-      --genesis.path <genesis.path>
-          Specifies the path of the genesis file to use for the nodes that are started.
-
-          This is expected to be the path of a JSON geth genesis file.
-
-Wallet Configuration:
-      --wallet.default-private-key <DEFAULT_KEY>
-          The private key of the default signer
-
-          [default: 0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d]
-
-      --wallet.additional-keys <ADDITIONAL_KEYS>
-          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]
-
-Concurrency Configuration:
-      --concurrency.number-of-nodes <NUMBER_OF_NODES>
-          Determines the amount of nodes that will be spawned for each chain
-
-          [default: 5]
-
-      --concurrency.number-of-threads <NUMBER_OF_THREADS>
-          Determines the amount of tokio worker threads that will will be used
-
-          [default: 16]
-
-      --concurrency.number-of-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.
-
-      --concurrency.ignore-concurrency-limit
-          Determines if the concurrency limit should be ignored or not
-
-Compilation Configuration:
-      --compilation.invalidate-cache
-          Controls if the compilation cache should be invalidated or not
-
-Report Configuration:
-      --report.include-compiler-input
-          Controls if the compiler input is included in the final report
-
-      --report.include-compiler-output
-          Controls if the compiler output is included in the final report
-```
-
-To run tests with this tool you need a corpus JSON file that defines the tests included in the corpus. The simplest corpus file looks like the following:
-
-```json
-{
-  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
-  "path": "resolc-compiler-tests/fixtures/solidity"
-}
-```
-
 > [!NOTE]  
 > Note that the tests can be found in the [`resolc-compiler-tests`](https://github.com/paritytech/resolc-compiler-tests) repository.
 
-The above corpus file instructs the tool to look for all of the test cases contained within all of the metadata files of the specified directory.
-
 The simplest command to run this tool is the following:
 
 ```bash
-RUST_LOG="info" cargo run --release -- execute-tests \
+RUST_LOG="info" cargo run --release -- test \
+    --test ./resolc-compiler-tests/fixtures/solidity \
     --platform geth-evm-solc \
-    --corpus corp.json \
     --working-directory workdir \
-    --concurrency.number-of-nodes 5 \
-    --concurrency.ignore-concurrency-limit \
     > 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.
+The above command will run the tool executing every one of the tests discovered in the path provided to the tool. 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:
+<details>
+<summary>User Managed Nodes</summary>
 
-```json
+This section describes how the user can make use of nodes that they manage rather than allowing the tool to spawn and manage the nodes on the user's behalf.
-{
+
-  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
+> ⚠️ This is an advanced feature of the tool and could lead test successes or failures to not be reproducible. Please use this feature with caution and only if you understand the implications of running your own node instead of having the framework manage your nodes. ⚠️
-  "paths": [
+
-    "path/to/a/single/metadata/file/I/want/to/run.json",
+If you're an advanced user and you'd like to manage your own nodes instead of having the tool initialize, spawn, and manage them, then you can choose to run your own nodes and then provide them to the tool to make use of just like the following:
-    "path/to/a/directory/to/find/all/metadata/files/within"
+
-  ]
+```bash
-}
+#!/usr/bin/env bash
+set -euo pipefail
+
+PLATFORM="revive-dev-node-revm-solc"
+
+retester export-genesis "$PLATFORM" > chainspec.json
+
+# Start revive-dev-node in a detached tmux session
+tmux new-session -d -s revive-dev-node \
+  'RUST_LOG="error,evm=debug,sc_rpc_server=info,runtime::revive=debug" revive-dev-node \
+    --dev \
+    --chain chainspec.json \
+    --force-authoring \
+    --rpc-methods Unsafe \
+    --rpc-cors all \
+    --rpc-max-connections 4294967295 \
+    --pool-limit 4294967295 \
+    --pool-kbytes 4294967295'
+sleep 5
+
+# Start eth-rpc in a detached tmux session
+tmux new-session -d -s eth-rpc \
+  'RUST_LOG="info,eth-rpc=debug" eth-rpc \
+    --dev \
+    --node-rpc-url ws://127.0.0.1:9944 \
+    --rpc-max-connections 4294967295'
+sleep 5
+
+# Run the tests (logs to files as before)
+RUST_LOG="info" retester test \
+  --platform "$PLATFORM" \
+  --corpus ./revive-differential-tests/fixtures/solidity \
+  --working-directory ./workdir \
+  --concurrency.number-of-nodes 1 \
+  --concurrency.number-of-concurrent-tasks 5 \
+  --revive-dev-node.existing-rpc-url "http://localhost:8545" \
+  > logs.log
 ```
+
+</details>

crates/common/Cargo.toml

@@ -14,6 +14,7 @@ anyhow = { workspace = true }
 clap = { workspace = true }
 moka = { workspace = true, features = ["sync"] }
 once_cell = { workspace = true }
+regex = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 schemars = { workspace = true }

crates/common/src/cached_fs/mod.rs

@@ -1,11 +1,9 @@
 //! This module implements a cached file system allowing for results to be stored in-memory rather
 //! rather being queried from the file system again.
 
-use std::{
+use std::fs;
-    fs,
+use std::io::{Error, Result};
-    io::{Error, Result},
+use std::path::{Path, PathBuf};
-    path::{Path, PathBuf},
-};
 
 use moka::sync::Cache;
 use once_cell::sync::Lazy;

crates/common/src/futures/poll.rs

@@ -1,4 +1,5 @@
-use std::{ops::ControlFlow, time::Duration};
+use std::ops::ControlFlow;
+use std::time::Duration;
 
 use anyhow::{Context as _, Result, anyhow};
 

crates/common/src/macros/define_wrapper_type.rs

@@ -135,6 +135,6 @@ macro_rules! define_wrapper_type {
     };
 }
 
-/// Technically not needed but this allows for the macro to be found in the `macros` module of
+/// Technically not needed but this allows for the macro to be found in the `macros` module of the
-/// the crate in addition to being found in the root of the crate.
+/// crate in addition to being found in the root of the crate.
 pub use {define_wrapper_type, impl_for_wrapper};

crates/common/src/types/identifiers.rs

@@ -31,10 +31,6 @@ pub enum PlatformIdentifier {
     GethEvmSolc,
     /// The Lighthouse Go-ethereum reference full node EVM implementation with the solc compiler.
     LighthouseGethEvmSolc,
-    /// The kitchensink node with the PolkaVM backend with the resolc compiler.
-    KitchensinkPolkavmResolc,
-    /// The kitchensink node with the REVM backend with the solc compiler.
-    KitchensinkRevmSolc,
     /// The revive dev node with the PolkaVM backend with the resolc compiler.
     ReviveDevNodePolkavmResolc,
     /// The revive dev node with the REVM backend with the solc compiler.
@@ -95,8 +91,6 @@ pub enum NodeIdentifier {
     Geth,
     /// The go-ethereum node implementation.
     LighthouseGeth,
-    /// The Kitchensink node implementation.
-    Kitchensink,
     /// The revive dev node implementation.
     ReviveDevNode,
     /// A zombienet spawned nodes

crates/common/src/types/mod.rs

@@ -1,11 +1,13 @@
 mod identifiers;
 mod mode;
+mod parsed_test_specifier;
 mod private_key_allocator;
 mod round_robin_pool;
 mod version_or_requirement;
 
 pub use identifiers::*;
 pub use mode::*;
+pub use parsed_test_specifier::*;
 pub use private_key_allocator::*;
 pub use round_robin_pool::*;
 pub use version_or_requirement::*;

crates/common/src/types/mode.rs

@@ -1,7 +1,14 @@
+use crate::iterators::EitherIter;
 use crate::types::VersionOrRequirement;
+use anyhow::{Context as _, bail};
+use regex::Regex;
+use schemars::JsonSchema;
 use semver::Version;
 use serde::{Deserialize, Serialize};
-use std::{fmt::Display, str::FromStr, sync::LazyLock};
+use std::collections::HashSet;
+use std::fmt::Display;
+use std::str::FromStr;
+use std::sync::LazyLock;
 
 /// This represents a mode that a given test should be run with, if possible.
 ///
@@ -31,6 +38,19 @@ impl Display for Mode {
     }
 }
 
+impl FromStr for Mode {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parsed_mode = ParsedMode::from_str(s)?;
+        let mut iter = parsed_mode.to_modes();
+        let (Some(mode), None) = (iter.next(), iter.next()) else {
+            bail!("Failed to parse the mode")
+        };
+        Ok(mode)
+    }
+}
+
 impl Mode {
     /// Return all of the available mode combinations.
     pub fn all() -> impl Iterator<Item = &'static Mode> {
@@ -169,3 +189,250 @@ impl ModeOptimizerSetting {
         !matches!(self, ModeOptimizerSetting::M0)
     }
 }
+
+/// This represents a mode that has been parsed from test metadata.
+///
+/// Mode strings can take the following form (in pseudo-regex):
+///
+/// ```text
+/// [YEILV][+-]? (M[0123sz])? <semver>?
+/// ```
+///
+/// We can parse valid mode strings into [`ParsedMode`] using [`ParsedMode::from_str`].
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, JsonSchema)]
+#[serde(try_from = "String", into = "String")]
+pub struct ParsedMode {
+    pub pipeline: Option<ModePipeline>,
+    pub optimize_flag: Option<bool>,
+    pub optimize_setting: Option<ModeOptimizerSetting>,
+    pub version: Option<semver::VersionReq>,
+}
+
+impl FromStr for ParsedMode {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        static REGEX: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"(?x)
+                ^
+                (?:(?P<pipeline>[YEILV])(?P<optimize_flag>[+-])?)? # Pipeline to use eg Y, E+, E-
+                \s*
+                (?P<optimize_setting>M[a-zA-Z0-9])?                # Optimize setting eg M0, Ms, Mz
+                \s*
+                (?P<version>[>=<^]*\d+(?:\.\d+)*)?                  # Optional semver version eg >=0.8.0, 0.7, <0.8
+                $
+            ").unwrap()
+        });
+
+        let Some(caps) = REGEX.captures(s) else {
+            anyhow::bail!("Cannot parse mode '{s}' from string");
+        };
+
+        let pipeline = match caps.name("pipeline") {
+            Some(m) => Some(
+                ModePipeline::from_str(m.as_str())
+                    .context("Failed to parse mode pipeline from string")?,
+            ),
+            None => None,
+        };
+
+        let optimize_flag = caps.name("optimize_flag").map(|m| m.as_str() == "+");
+
+        let optimize_setting = match caps.name("optimize_setting") {
+            Some(m) => Some(
+                ModeOptimizerSetting::from_str(m.as_str())
+                    .context("Failed to parse optimizer setting from string")?,
+            ),
+            None => None,
+        };
+
+        let version = match caps.name("version") {
+            Some(m) => Some(
+                semver::VersionReq::parse(m.as_str())
+                    .map_err(|e| {
+                        anyhow::anyhow!(
+                            "Cannot parse the version requirement '{}': {e}",
+                            m.as_str()
+                        )
+                    })
+                    .context("Failed to parse semver requirement from mode string")?,
+            ),
+            None => None,
+        };
+
+        Ok(ParsedMode {
+            pipeline,
+            optimize_flag,
+            optimize_setting,
+            version,
+        })
+    }
+}
+
+impl Display for ParsedMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut has_written = false;
+
+        if let Some(pipeline) = self.pipeline {
+            pipeline.fmt(f)?;
+            if let Some(optimize_flag) = self.optimize_flag {
+                f.write_str(if optimize_flag { "+" } else { "-" })?;
+            }
+            has_written = true;
+        }
+
+        if let Some(optimize_setting) = self.optimize_setting {
+            if has_written {
+                f.write_str(" ")?;
+            }
+            optimize_setting.fmt(f)?;
+            has_written = true;
+        }
+
+        if let Some(version) = &self.version {
+            if has_written {
+                f.write_str(" ")?;
+            }
+            version.fmt(f)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl From<ParsedMode> for String {
+    fn from(parsed_mode: ParsedMode) -> Self {
+        parsed_mode.to_string()
+    }
+}
+
+impl TryFrom<String> for ParsedMode {
+    type Error = anyhow::Error;
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        ParsedMode::from_str(&value)
+    }
+}
+
+impl ParsedMode {
+    /// This takes a [`ParsedMode`] and expands it into a list of [`Mode`]s that we should try.
+    pub fn to_modes(&self) -> impl Iterator<Item = Mode> {
+        let pipeline_iter = self.pipeline.as_ref().map_or_else(
+            || EitherIter::A(ModePipeline::test_cases()),
+            |p| EitherIter::B(std::iter::once(*p)),
+        );
+
+        let optimize_flag_setting = self.optimize_flag.map(|flag| {
+            if flag {
+                ModeOptimizerSetting::M3
+            } else {
+                ModeOptimizerSetting::M0
+            }
+        });
+
+        let optimize_flag_iter = match optimize_flag_setting {
+            Some(setting) => EitherIter::A(std::iter::once(setting)),
+            None => EitherIter::B(ModeOptimizerSetting::test_cases()),
+        };
+
+        let optimize_settings_iter = self.optimize_setting.as_ref().map_or_else(
+            || EitherIter::A(optimize_flag_iter),
+            |s| EitherIter::B(std::iter::once(*s)),
+        );
+
+        pipeline_iter.flat_map(move |pipeline| {
+            optimize_settings_iter
+                .clone()
+                .map(move |optimize_setting| Mode {
+                    pipeline,
+                    optimize_setting,
+                    version: self.version.clone(),
+                })
+        })
+    }
+
+    /// Return a set of [`Mode`]s that correspond to the given [`ParsedMode`]s.
+    /// This avoids any duplicate entries.
+    pub fn many_to_modes<'a>(
+        parsed: impl Iterator<Item = &'a ParsedMode>,
+    ) -> impl Iterator<Item = Mode> {
+        let modes: HashSet<_> = parsed.flat_map(|p| p.to_modes()).collect();
+        modes.into_iter()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parsed_mode_from_str() {
+        let strings = vec![
+            ("Mz", "Mz"),
+            ("Y", "Y"),
+            ("Y+", "Y+"),
+            ("Y-", "Y-"),
+            ("E", "E"),
+            ("E+", "E+"),
+            ("E-", "E-"),
+            ("Y M0", "Y M0"),
+            ("Y M1", "Y M1"),
+            ("Y M2", "Y M2"),
+            ("Y M3", "Y M3"),
+            ("Y Ms", "Y Ms"),
+            ("Y Mz", "Y Mz"),
+            ("E M0", "E M0"),
+            ("E M1", "E M1"),
+            ("E M2", "E M2"),
+            ("E M3", "E M3"),
+            ("E Ms", "E Ms"),
+            ("E Mz", "E Mz"),
+            // When stringifying semver again, 0.8.0 becomes ^0.8.0 (same meaning)
+            ("Y 0.8.0", "Y ^0.8.0"),
+            ("E+ 0.8.0", "E+ ^0.8.0"),
+            ("Y M3 >=0.8.0", "Y M3 >=0.8.0"),
+            ("E Mz <0.7.0", "E Mz <0.7.0"),
+            // We can parse +- _and_ M1/M2 but the latter takes priority.
+            ("Y+ M1 0.8.0", "Y+ M1 ^0.8.0"),
+            ("E- M2 0.7.0", "E- M2 ^0.7.0"),
+            // We don't see this in the wild but it is parsed.
+            ("<=0.8", "<=0.8"),
+        ];
+
+        for (actual, expected) in strings {
+            let parsed = ParsedMode::from_str(actual)
+                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
+            assert_eq!(
+                expected,
+                parsed.to_string(),
+                "Mode string '{actual}' did not parse to '{expected}': got '{parsed}'"
+            );
+        }
+    }
+
+    #[test]
+    fn test_parsed_mode_to_test_modes() {
+        let strings = vec![
+            ("Mz", vec!["Y Mz", "E Mz"]),
+            ("Y", vec!["Y M0", "Y M3"]),
+            ("E", vec!["E M0", "E M3"]),
+            ("Y+", vec!["Y M3"]),
+            ("Y-", vec!["Y M0"]),
+            ("Y <=0.8", vec!["Y M0 <=0.8", "Y M3 <=0.8"]),
+            (
+                "<=0.8",
+                vec!["Y M0 <=0.8", "Y M3 <=0.8", "E M0 <=0.8", "E M3 <=0.8"],
+            ),
+        ];
+
+        for (actual, expected) in strings {
+            let parsed = ParsedMode::from_str(actual)
+                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
+            let expected_set: HashSet<_> = expected.into_iter().map(|s| s.to_owned()).collect();
+            let actual_set: HashSet<_> = parsed.to_modes().map(|m| m.to_string()).collect();
+
+            assert_eq!(
+                expected_set, actual_set,
+                "Mode string '{actual}' did not expand to '{expected_set:?}': got '{actual_set:?}'"
+            );
+        }
+    }
+}

crates/common/src/types/parsed_test_specifier.rs

@@ -0,0 +1,133 @@
+use std::{fmt::Display, path::PathBuf, str::FromStr};
+
+use anyhow::{Context as _, bail};
+
+use crate::types::Mode;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum ParsedTestSpecifier {
+    /// All of the test cases in the file should be ran across all of the specified modes
+    FileOrDirectory {
+        /// The path of the metadata file containing the test cases.
+        metadata_or_directory_file_path: PathBuf,
+    },
+    /// Only a specific case within the metadata file should be ran across all of the modes in the
+    /// file.
+    Case {
+        /// The path of the metadata file containing the test cases.
+        metadata_file_path: PathBuf,
+
+        /// The index of the specific case to run.
+        case_idx: usize,
+    },
+    /// A specific case and a specific mode should be ran. This is the most specific out of all of
+    /// the specifier types.
+    CaseWithMode {
+        /// The path of the metadata file containing the test cases.
+        metadata_file_path: PathBuf,
+
+        /// The index of the specific case to run.
+        case_idx: usize,
+
+        /// The parsed mode that the test should be run in.
+        mode: Mode,
+    },
+}
+
+impl Display for ParsedTestSpecifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParsedTestSpecifier::FileOrDirectory {
+                metadata_or_directory_file_path,
+            } => {
+                write!(f, "{}", metadata_or_directory_file_path.display())
+            }
+            ParsedTestSpecifier::Case {
+                metadata_file_path,
+                case_idx,
+            } => {
+                write!(f, "{}::{}", metadata_file_path.display(), case_idx)
+            }
+            ParsedTestSpecifier::CaseWithMode {
+                metadata_file_path,
+                case_idx,
+                mode,
+            } => {
+                write!(
+                    f,
+                    "{}::{}::{}",
+                    metadata_file_path.display(),
+                    case_idx,
+                    mode
+                )
+            }
+        }
+    }
+}
+
+impl FromStr for ParsedTestSpecifier {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut split_iter = s.split("::");
+
+        let Some(path_string) = split_iter.next() else {
+            bail!("Could not find the path in the test specifier")
+        };
+        let path = PathBuf::from(path_string)
+            .canonicalize()
+            .context("Failed to canonicalize the path of the test")?;
+
+        let Some(case_idx_string) = split_iter.next() else {
+            return Ok(Self::FileOrDirectory {
+                metadata_or_directory_file_path: path,
+            });
+        };
+        let case_idx = usize::from_str(case_idx_string)
+            .context("Failed to parse the case idx of the test specifier from string")?;
+
+        // At this point the provided path must be a file.
+        if !path.is_file() {
+            bail!(
+                "Test specifier with a path and case idx must point to a file and not a directory"
+            )
+        }
+
+        let Some(mode_string) = split_iter.next() else {
+            return Ok(Self::Case {
+                metadata_file_path: path,
+                case_idx,
+            });
+        };
+        let mode = Mode::from_str(mode_string)
+            .context("Failed to parse the mode string in the parsed test specifier")?;
+
+        Ok(Self::CaseWithMode {
+            metadata_file_path: path,
+            case_idx,
+            mode,
+        })
+    }
+}
+
+impl From<ParsedTestSpecifier> for String {
+    fn from(value: ParsedTestSpecifier) -> Self {
+        value.to_string()
+    }
+}
+
+impl TryFrom<String> for ParsedTestSpecifier {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        value.parse()
+    }
+}
+
+impl TryFrom<&str> for ParsedTestSpecifier {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        value.parse()
+    }
+}

crates/common/src/types/private_key_allocator.rs

@@ -1,4 +1,5 @@
-use alloy::{primitives::U256, signers::local::PrivateKeySigner};
+use alloy::primitives::U256;
+use alloy::signers::local::PrivateKeySigner;
 use anyhow::{Context, Result, bail};
 
 /// This is a sequential private key allocator. When instantiated, it allocated private keys in

crates/compiler/src/lib.rs

@@ -10,7 +10,8 @@ use std::{
     pin::Pin,
 };
 
-use alloy::{json_abi::JsonAbi, primitives::Address};
+use alloy::json_abi::JsonAbi;
+use alloy::primitives::Address;
 use anyhow::{Context as _, Result};
 use semver::Version;
 use serde::{Deserialize, Serialize};

crates/compiler/src/revive_resolc.rs

@@ -253,8 +253,7 @@ impl SolidityCompiler for Resolc {
                         .evm
                         .and_then(|evm| evm.bytecode.clone())
                         .context("Unexpected - Contract compiled with resolc has no bytecode")?;
-                    let abi =
+                    let abi = {
-                        {
                         let metadata = contract_information
                             .metadata
                             .as_ref()
@@ -278,8 +277,10 @@ impl SolidityCompiler for Resolc {
                                 anyhow::bail!("Unsupported type of metadata {metadata:?}")
                             }
                         };
-                            let solc_metadata =
+                        let solc_metadata = serde_json::from_str::<serde_json::Value>(
-							serde_json::from_str::<serde_json::Value>(solc_metadata_str).context(
+                            solc_metadata_str,
+                        )
+                        .context(
                             "Failed to deserialize the solc_metadata as a serde_json generic value",
                         )?;
                         let output_value = solc_metadata

crates/compiler/src/solc.rs

@@ -21,7 +21,8 @@ use foundry_compilers_artifacts::{
     output_selection::{
         BytecodeOutputSelection, ContractOutputSelection, EvmOutputSelection, OutputSelection,
     },
-    solc::{CompilerOutput as SolcOutput, *},
+    solc::CompilerOutput as SolcOutput,
+    solc::*,
 };
 use semver::Version;
 use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
@@ -283,9 +284,8 @@ impl SolidityCompiler for Solc {
         _optimize_setting: ModeOptimizerSetting,
         pipeline: ModePipeline,
     ) -> bool {
-        // solc 0.8.13 and above supports --via-ir, and less than that does not. Thus, we support
+        // solc 0.8.13 and above supports --via-ir, and less than that does not. Thus, we support mode E
-        // mode E (ie no Yul IR) in either case, but only support Y (via Yul IR) if the compiler
+        // (ie no Yul IR) in either case, but only support Y (via Yul IR) if the compiler is new enough.
-        // is new enough.
         pipeline == ModePipeline::ViaEVMAssembly
             || (pipeline == ModePipeline::ViaYulIR && self.compiler_supports_yul())
     }

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

@@ -7,7 +7,10 @@ pragma solidity >=0.6.9;
 import "./callable.sol";
 
 contract Main {
-    function main(uint[1] calldata p1, Callable callable) public returns(uint) {
+    function main(
+        uint[1] calldata p1,
+        Callable callable
+    ) public pure returns (uint) {
         return callable.f(p1);
     }
 }

crates/config/Cargo.toml

@@ -18,6 +18,7 @@ semver = { workspace = true }
 temp-dir = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+serde_with = { workspace = true }
 strum = { workspace = true }
 
 [lints]

crates/config/src/lib.rs

@@ -12,20 +12,20 @@ use std::{
 
 use alloy::{
     genesis::Genesis,
-    hex::ToHexExt,
     network::EthereumWallet,
-    primitives::{FixedBytes, U256},
+    primitives::{B256, FixedBytes, U256},
     signers::local::PrivateKeySigner,
 };
+use anyhow::Context as _;
 use clap::{Parser, ValueEnum, ValueHint};
-use revive_dt_common::types::PlatformIdentifier;
+use revive_dt_common::types::{ParsedTestSpecifier, PlatformIdentifier};
 use semver::Version;
-use serde::{Serialize, Serializer};
+use serde::{Deserialize, Serialize, Serializer};
 use strum::{AsRefStr, Display, EnumString, IntoStaticStr};
 use temp_dir::TempDir;
 
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
-#[command(name = "retester")]
+#[command(name = "retester", term_width = 100)]
 pub enum Context {
     /// Executes tests in the MatterLabs format differentially on multiple targets concurrently.
     Test(Box<TestExecutionContext>),
@@ -35,6 +35,9 @@ pub enum Context {
 
     /// Exports the JSON schema of the MatterLabs test format used by the tool.
     ExportJsonSchema,
+
+    /// Exports the genesis file of the desired platform.
+    ExportGenesis(Box<ExportGenesisContext>),
 }
 
 impl Context {
@@ -45,6 +48,15 @@ impl Context {
     pub fn report_configuration(&self) -> &ReportConfiguration {
         self.as_ref()
     }
+
+    pub fn update_for_profile(&mut self) {
+        match self {
+            Context::Test(ctx) => ctx.update_for_profile(),
+            Context::Benchmark(ctx) => ctx.update_for_profile(),
+            Context::ExportJsonSchema => {}
+            Context::ExportGenesis(..) => {}
+        }
+    }
 }
 
 impl AsRef<WorkingDirectoryConfiguration> for Context {
@@ -52,7 +64,7 @@ impl AsRef<WorkingDirectoryConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
@@ -62,7 +74,7 @@ impl AsRef<CorpusConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
@@ -72,7 +84,7 @@ impl AsRef<SolcConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
@@ -82,7 +94,7 @@ impl AsRef<ResolcConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
@@ -92,6 +104,7 @@ impl AsRef<GethConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
+            Self::ExportGenesis(context) => context.as_ref().as_ref(),
             Self::ExportJsonSchema => unreachable!(),
         }
     }
@@ -102,6 +115,7 @@ impl AsRef<KurtosisConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
+            Self::ExportGenesis(context) => context.as_ref().as_ref(),
             Self::ExportJsonSchema => unreachable!(),
         }
     }
@@ -112,16 +126,7 @@ impl AsRef<PolkadotParachainConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportGenesis(context) => context.as_ref().as_ref(),
-        }
-    }
-}
-
-impl AsRef<KitchensinkConfiguration> for Context {
-    fn as_ref(&self) -> &KitchensinkConfiguration {
-        match self {
-            Self::Test(context) => context.as_ref().as_ref(),
-            Self::Benchmark(context) => context.as_ref().as_ref(),
             Self::ExportJsonSchema => unreachable!(),
         }
     }
@@ -132,6 +137,7 @@ impl AsRef<ReviveDevNodeConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
+            Self::ExportGenesis(context) => context.as_ref().as_ref(),
             Self::ExportJsonSchema => unreachable!(),
         }
     }
@@ -142,7 +148,7 @@ impl AsRef<EthRpcConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
@@ -151,7 +157,7 @@ impl AsRef<GenesisConfiguration> for Context {
     fn as_ref(&self) -> &GenesisConfiguration {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
-            Self::Benchmark(..) => {
+            Self::Benchmark(..) | Self::ExportGenesis(..) => {
                 static GENESIS: LazyLock<GenesisConfiguration> = LazyLock::new(Default::default);
                 &GENESIS
             }
@@ -165,6 +171,7 @@ impl AsRef<WalletConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
+            Self::ExportGenesis(context) => context.as_ref().as_ref(),
             Self::ExportJsonSchema => unreachable!(),
         }
     }
@@ -175,7 +182,7 @@ impl AsRef<ConcurrencyConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
@@ -185,7 +192,7 @@ impl AsRef<CompilationConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
@@ -195,25 +202,27 @@ impl AsRef<ReportConfiguration> for Context {
         match self {
             Self::Test(context) => context.as_ref().as_ref(),
             Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
         }
     }
 }
 
-#[derive(Clone, Debug, Parser, Serialize)]
+impl AsRef<IgnoreSuccessConfiguration> for Context {
+    fn as_ref(&self) -> &IgnoreSuccessConfiguration {
+        match self {
+            Self::Test(context) => context.as_ref().as_ref(),
+            Self::Benchmark(..) => unreachable!(),
+            Self::ExportJsonSchema | Self::ExportGenesis(..) => unreachable!(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct TestExecutionContext {
-    /// The working directory that the program will use for all of the temporary artifacts needed
+    /// The commandline profile to use. Different profiles change the defaults of the various cli
-    /// at runtime.
+    /// arguments.
-    ///
+    #[arg(long = "profile", default_value_t = Profile::Default)]
-    /// If not specified, then a temporary directory will be created and used by the program for
+    pub profile: Profile,
-    /// all temporary artifacts.
-    #[clap(
-        short,
-        long,
-        default_value = "",
-        value_hint = ValueHint::DirPath,
-    )]
-    pub working_directory: WorkingDirectoryConfiguration,
 
     /// The set of platforms that the differential tests should run on.
     #[arg(
@@ -223,6 +232,23 @@ pub struct TestExecutionContext {
     )]
     pub platforms: Vec<PlatformIdentifier>,
 
+    /// The output format to use for the tool's output.
+    #[arg(short, long, default_value_t = OutputFormat::CargoTestLike)]
+    pub output_format: OutputFormat,
+
+    /// The working directory that the program will use for all of the temporary artifacts needed at
+    /// runtime.
+    ///
+    /// If not specified, then a temporary directory will be created and used by the program for all
+    /// temporary artifacts.
+    #[clap(
+        short,
+        long,
+        default_value = "",
+        value_hint = ValueHint::DirPath,
+    )]
+    pub working_directory: WorkingDirectoryConfiguration,
+
     /// Configuration parameters for the corpus files to use.
     #[clap(flatten, next_help_heading = "Corpus Configuration")]
     pub corpus_configuration: CorpusConfiguration,
@@ -247,10 +273,6 @@ pub struct TestExecutionContext {
     #[clap(flatten, next_help_heading = "Lighthouse Configuration")]
     pub lighthouse_configuration: KurtosisConfiguration,
 
-    /// Configuration parameters for the Kitchensink.
-    #[clap(flatten, next_help_heading = "Kitchensink Configuration")]
-    pub kitchensink_configuration: KitchensinkConfiguration,
-
     /// Configuration parameters for the Revive Dev Node.
     #[clap(flatten, next_help_heading = "Revive Dev Node Configuration")]
     pub revive_dev_node_configuration: ReviveDevNodeConfiguration,
@@ -278,15 +300,60 @@ pub struct TestExecutionContext {
     /// Configuration parameters for the report.
     #[clap(flatten, next_help_heading = "Report Configuration")]
     pub report_configuration: ReportConfiguration,
+
+    /// Configuration parameters for ignoring certain test cases based on the report
+    #[clap(flatten, next_help_heading = "Ignore Success Configuration")]
+    pub ignore_success_configuration: IgnoreSuccessConfiguration,
 }
 
-#[derive(Clone, Debug, Parser, Serialize)]
+impl TestExecutionContext {
+    pub fn update_for_profile(&mut self) {
+        match self.profile {
+            Profile::Default => {}
+            Profile::Debug => {
+                let default_concurrency_config =
+                    ConcurrencyConfiguration::parse_from(["concurrency-configuration"]);
+                let working_directory_config = WorkingDirectoryConfiguration::default();
+
+                if self.concurrency_configuration.number_of_nodes
+                    == default_concurrency_config.number_of_nodes
+                {
+                    self.concurrency_configuration.number_of_nodes = 1;
+                }
+                if self.concurrency_configuration.number_of_threads
+                    == default_concurrency_config.number_of_threads
+                {
+                    self.concurrency_configuration.number_of_threads = 5;
+                }
+                if self.concurrency_configuration.number_concurrent_tasks
+                    == default_concurrency_config.number_concurrent_tasks
+                {
+                    self.concurrency_configuration.number_concurrent_tasks = 1;
+                }
+
+                if working_directory_config == self.working_directory {
+                    let home_directory =
+                        PathBuf::from(std::env::var("HOME").expect("Home dir not found"));
+                    let working_directory = home_directory.join(".retester-workdir");
+                    self.working_directory = WorkingDirectoryConfiguration::Path(working_directory)
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct BenchmarkingContext {
-    /// The working directory that the program will use for all of the temporary artifacts needed
+    /// The commandline profile to use. Different profiles change the defaults of the various cli
-    /// at runtime.
+    /// arguments.
+    #[arg(long = "profile", default_value_t = Profile::Default)]
+    pub profile: Profile,
+
+    /// The working directory that the program will use for all of the temporary artifacts needed at
+    /// runtime.
     ///
-    /// If not specified, then a temporary directory will be created and used by the program for
+    /// If not specified, then a temporary directory will be created and used by the program for all
-    /// all temporary artifacts.
+    /// temporary artifacts.
     #[clap(
         short,
         long,
@@ -328,10 +395,6 @@ pub struct BenchmarkingContext {
     #[clap(flatten, next_help_heading = "Lighthouse Configuration")]
     pub lighthouse_configuration: KurtosisConfiguration,
 
-    /// Configuration parameters for the Kitchensink.
-    #[clap(flatten, next_help_heading = "Kitchensink Configuration")]
-    pub kitchensink_configuration: KitchensinkConfiguration,
-
     /// Configuration parameters for the Polkadot Parachain.
     #[clap(flatten, next_help_heading = "Polkadot Parachain Configuration")]
     pub polkadot_parachain_configuration: PolkadotParachainConfiguration,
@@ -361,9 +424,71 @@ pub struct BenchmarkingContext {
     pub report_configuration: ReportConfiguration,
 }
 
+impl BenchmarkingContext {
+    pub fn update_for_profile(&mut self) {
+        match self.profile {
+            Profile::Default => {}
+            Profile::Debug => {
+                let default_concurrency_config =
+                    ConcurrencyConfiguration::parse_from(["concurrency-configuration"]);
+                let working_directory_config = WorkingDirectoryConfiguration::default();
+
+                if self.concurrency_configuration.number_of_nodes
+                    == default_concurrency_config.number_of_nodes
+                {
+                    self.concurrency_configuration.number_of_nodes = 1;
+                }
+                if self.concurrency_configuration.number_of_threads
+                    == default_concurrency_config.number_of_threads
+                {
+                    self.concurrency_configuration.number_of_threads = 5;
+                }
+                if self.concurrency_configuration.number_concurrent_tasks
+                    == default_concurrency_config.number_concurrent_tasks
+                {
+                    self.concurrency_configuration.number_concurrent_tasks = 1;
+                }
+
+                if working_directory_config == self.working_directory {
+                    let home_directory =
+                        PathBuf::from(std::env::var("HOME").expect("Home dir not found"));
+                    let working_directory = home_directory.join(".retester-workdir");
+                    self.working_directory = WorkingDirectoryConfiguration::Path(working_directory)
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
+pub struct ExportGenesisContext {
+    /// The platform of choice to export the genesis for.
+    pub platform: PlatformIdentifier,
+
+    /// Configuration parameters for the geth node.
+    #[clap(flatten, next_help_heading = "Geth Configuration")]
+    pub geth_configuration: GethConfiguration,
+
+    /// Configuration parameters for the lighthouse node.
+    #[clap(flatten, next_help_heading = "Lighthouse Configuration")]
+    pub lighthouse_configuration: KurtosisConfiguration,
+
+    /// Configuration parameters for the Polkadot Parachain.
+    #[clap(flatten, next_help_heading = "Polkadot Parachain Configuration")]
+    pub polkadot_parachain_configuration: PolkadotParachainConfiguration,
+
+    /// Configuration parameters for the Revive Dev Node.
+    #[clap(flatten, next_help_heading = "Revive Dev Node Configuration")]
+    pub revive_dev_node_configuration: ReviveDevNodeConfiguration,
+
+    /// Configuration parameters for the wallet.
+    #[clap(flatten, next_help_heading = "Wallet Configuration")]
+    pub wallet_configuration: WalletConfiguration,
+}
+
 impl Default for TestExecutionContext {
     fn default() -> Self {
-        Self::parse_from(["execution-context"])
+        Self::parse_from(["execution-context", "--test", "."])
     }
 }
 
@@ -409,12 +534,6 @@ impl AsRef<KurtosisConfiguration> for TestExecutionContext {
     }
 }
 
-impl AsRef<KitchensinkConfiguration> for TestExecutionContext {
-    fn as_ref(&self) -> &KitchensinkConfiguration {
-        &self.kitchensink_configuration
-    }
-}
-
 impl AsRef<ReviveDevNodeConfiguration> for TestExecutionContext {
     fn as_ref(&self) -> &ReviveDevNodeConfiguration {
         &self.revive_dev_node_configuration
@@ -457,9 +576,15 @@ impl AsRef<ReportConfiguration> for TestExecutionContext {
     }
 }
 
+impl AsRef<IgnoreSuccessConfiguration> for TestExecutionContext {
+    fn as_ref(&self) -> &IgnoreSuccessConfiguration {
+        &self.ignore_success_configuration
+    }
+}
+
 impl Default for BenchmarkingContext {
     fn default() -> Self {
-        Self::parse_from(["execution-context"])
+        Self::parse_from(["benchmarking-context", "--test", "."])
     }
 }
 
@@ -505,12 +630,6 @@ impl AsRef<PolkadotParachainConfiguration> for BenchmarkingContext {
     }
 }
 
-impl AsRef<KitchensinkConfiguration> for BenchmarkingContext {
-    fn as_ref(&self) -> &KitchensinkConfiguration {
-        &self.kitchensink_configuration
-    }
-}
-
 impl AsRef<ReviveDevNodeConfiguration> for BenchmarkingContext {
     fn as_ref(&self) -> &ReviveDevNodeConfiguration {
         &self.revive_dev_node_configuration
@@ -547,16 +666,65 @@ impl AsRef<ReportConfiguration> for BenchmarkingContext {
     }
 }
 
+impl Default for ExportGenesisContext {
+    fn default() -> Self {
+        Self::parse_from(["export-genesis-context"])
+    }
+}
+
+impl AsRef<GethConfiguration> for ExportGenesisContext {
+    fn as_ref(&self) -> &GethConfiguration {
+        &self.geth_configuration
+    }
+}
+
+impl AsRef<KurtosisConfiguration> for ExportGenesisContext {
+    fn as_ref(&self) -> &KurtosisConfiguration {
+        &self.lighthouse_configuration
+    }
+}
+
+impl AsRef<PolkadotParachainConfiguration> for ExportGenesisContext {
+    fn as_ref(&self) -> &PolkadotParachainConfiguration {
+        &self.polkadot_parachain_configuration
+    }
+}
+
+impl AsRef<ReviveDevNodeConfiguration> for ExportGenesisContext {
+    fn as_ref(&self) -> &ReviveDevNodeConfiguration {
+        &self.revive_dev_node_configuration
+    }
+}
+
+impl AsRef<WalletConfiguration> for ExportGenesisContext {
+    fn as_ref(&self) -> &WalletConfiguration {
+        &self.wallet_configuration
+    }
+}
+
 /// A set of configuration parameters for the corpus files to use for the execution.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[serde_with::serde_as]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct CorpusConfiguration {
-    /// A list of test corpus JSON files to be tested.
+    /// A list of test specifiers for the tests that the tool should run.
-    #[arg(short = 'c', long = "corpus")]
+    ///
-    pub paths: Vec<PathBuf>,
+    /// Test specifiers follow the following format:
+    ///
+    /// - `{directory_path|metadata_file_path}`: A path to a metadata file where all of the cases
+    ///   live and should be run. Alternatively, it points to a directory instructing the framework
+    ///   to discover of the metadata files that live there an execute them.
+    /// - `{metadata_file_path}::{case_idx}`: The path to a metadata file and then a case idx
+    ///   separated by two colons. This specifies that only this specific test case within the
+    ///   metadata file should be executed.
+    /// - `{metadata_file_path}::{case_idx}::{mode}`: This is very similar to the above specifier
+    ///   with the exception that in this case the mode is specified and will be used in the test.
+    #[serde_as(as = "Vec<serde_with::DisplayFromStr>")]
+    #[arg(short = 't', long = "test", required = true)]
+    pub test_specifiers: Vec<ParsedTestSpecifier>,
 }
 
 /// A set of configuration parameters for Solc.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct SolcConfiguration {
     /// Specifies the default version of the Solc compiler that should be used if there is no
     /// override specified by one of the test cases.
@@ -565,7 +733,7 @@ pub struct SolcConfiguration {
 }
 
 /// A set of configuration parameters for Resolc.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct ResolcConfiguration {
     /// Specifies the path of the resolc compiler to be used by the tool.
     ///
@@ -576,12 +744,12 @@ pub struct ResolcConfiguration {
 }
 
 /// A set of configuration parameters for Polkadot Parachain.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct PolkadotParachainConfiguration {
     /// Specifies the path of the polkadot-parachain node to be used by the tool.
     ///
-    /// If this is not specified, then the tool assumes that it should use the polkadot-parachain
+    /// If this is not specified, then the tool assumes that it should use the polkadot-parachain binary
-    /// binary that's provided in the user's $PATH.
+    /// that's provided in the user's $PATH.
     #[clap(
         id = "polkadot-parachain.path",
         long = "polkadot-parachain.path",
@@ -600,7 +768,7 @@ pub struct PolkadotParachainConfiguration {
 }
 
 /// A set of configuration parameters for Geth.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct GethConfiguration {
     /// Specifies the path of the geth node to be used by the tool.
     ///
@@ -620,12 +788,12 @@ pub struct GethConfiguration {
 }
 
 /// A set of configuration parameters for kurtosis.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct KurtosisConfiguration {
     /// Specifies the path of the kurtosis node to be used by the tool.
     ///
-    /// If this is not specified, then the tool assumes that it should use the kurtosis binary
+    /// If this is not specified, then the tool assumes that it should use the kurtosis binary that's
-    /// that's provided in the user's $PATH.
+    /// provided in the user's $PATH.
     #[clap(
         id = "kurtosis.path",
         long = "kurtosis.path",
@@ -634,37 +802,13 @@ pub struct KurtosisConfiguration {
     pub path: PathBuf,
 }
 
-/// A set of configuration parameters for Kitchensink.
-#[derive(Clone, Debug, Parser, Serialize)]
-pub struct KitchensinkConfiguration {
-    /// Specifies the path of the kitchensink node to be used by the tool.
-    ///
-    /// If this is not specified, then the tool assumes that it should use the kitchensink binary
-    /// that's provided in the user's $PATH.
-    #[clap(
-        id = "kitchensink.path",
-        long = "kitchensink.path",
-        default_value = "substrate-node"
-    )]
-    pub path: PathBuf,
-
-    /// The amount of time to wait upon startup before considering that the node timed out.
-    #[clap(
-        id = "kitchensink.start-timeout-ms",
-        long = "kitchensink.start-timeout-ms",
-        default_value = "30000",
-        value_parser = parse_duration
-    )]
-    pub start_timeout_ms: Duration,
-}
-
 /// A set of configuration parameters for the revive dev node.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct ReviveDevNodeConfiguration {
     /// Specifies the path of the revive dev node to be used by the tool.
     ///
-    /// If this is not specified, then the tool assumes that it should use the revive dev node
+    /// If this is not specified, then the tool assumes that it should use the revive dev node binary
-    /// binary that's provided in the user's $PATH.
+    /// that's provided in the user's $PATH.
     #[clap(
         id = "revive-dev-node.path",
         long = "revive-dev-node.path",
@@ -680,10 +824,36 @@ pub struct ReviveDevNodeConfiguration {
         value_parser = parse_duration
     )]
     pub start_timeout_ms: Duration,
+
+    /// The consensus to use for the spawned revive-dev-node.
+    #[clap(
+        id = "revive-dev-node.consensus",
+        long = "revive-dev-node.consensus",
+        default_value = "instant-seal"
+    )]
+    pub consensus: String,
+
+    /// Specifies the connection string of an existing node that's not managed by the framework.
+    ///
+    /// If this argument is specified then the framework will not spawn certain nodes itself but
+    /// rather it will opt to using the existing node's through their provided connection strings.
+    ///
+    /// This means that if `ConcurrencyConfiguration.number_of_nodes` is 10 and we only specify the
+    /// connection strings of 2 nodes here, then nodes 0 and 1 will use the provided connection
+    /// strings and nodes 2 through 10 (exclusive) will all be spawned and managed by the framework.
+    ///
+    /// Thus, if you want all of the transactions and tests to happen against the node that you
+    /// spawned and manage then you need to specify a `ConcurrencyConfiguration.number_of_nodes` of
+    /// 1.
+    #[clap(
+        id = "revive-dev-node.existing-rpc-url",
+        long = "revive-dev-node.existing-rpc-url"
+    )]
+    pub existing_rpc_url: Vec<String>,
 }
 
 /// A set of configuration parameters for the ETH RPC.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct EthRpcConfiguration {
     /// Specifies the path of the ETH RPC to be used by the tool.
     ///
@@ -703,7 +873,7 @@ pub struct EthRpcConfiguration {
 }
 
 /// A set of configuration parameters for the genesis.
-#[derive(Clone, Debug, Default, Parser, Serialize)]
+#[derive(Clone, Debug, Default, Parser, Serialize, Deserialize)]
 pub struct GenesisConfiguration {
     /// Specifies the path of the genesis file to use for the nodes that are started.
     ///
@@ -741,15 +911,14 @@ impl GenesisConfiguration {
 }
 
 /// A set of configuration parameters for the wallet.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct WalletConfiguration {
     /// The private key of the default signer.
     #[clap(
         long = "wallet.default-private-key",
         default_value = "0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d"
     )]
-    #[serde(serialize_with = "serialize_private_key")]
+    default_key: B256,
-    default_key: PrivateKeySigner,
 
     /// 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
@@ -767,7 +936,8 @@ impl WalletConfiguration {
     pub fn wallet(&self) -> Arc<EthereumWallet> {
         self.wallet
             .get_or_init(|| {
-                let mut wallet = EthereumWallet::new(self.default_key.clone());
+                let mut wallet =
+                    EthereumWallet::new(PrivateKeySigner::from_bytes(&self.default_key).unwrap());
                 for signer in (1..=self.additional_keys)
                     .map(|id| U256::from(id))
                     .map(|id| id.to_be_bytes::<32>())
@@ -785,15 +955,8 @@ impl WalletConfiguration {
     }
 }
 
-fn serialize_private_key<S>(value: &PrivateKeySigner, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    value.to_bytes().encode_hex().serialize(serializer)
-}
-
 /// A set of configuration for concurrency.
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct ConcurrencyConfiguration {
     /// Determines the amount of nodes that will be spawned for each chain.
     #[clap(long = "concurrency.number-of-nodes", default_value_t = 5)]
@@ -803,42 +966,38 @@ pub struct ConcurrencyConfiguration {
     #[arg(
         long = "concurrency.number-of-threads",
         default_value_t = std::thread::available_parallelism()
-            .map(|n| n.get())
+            .map(|n| n.get() * 4 / 6)
             .unwrap_or(1)
     )]
     pub number_of_threads: usize,
 
-    /// Determines the amount of concurrent tasks that will be spawned to run tests.
+    /// Determines the amount of concurrent tasks that will be spawned to run tests. This means that
+    /// at any given time there is `concurrency.number-of-concurrent-tasks` tests concurrently
+    /// executing.
     ///
-    /// Defaults to 10 x the number of nodes.
+    /// Note that a task limit of `0` means no limit on the number of concurrent tasks.
-    #[arg(long = "concurrency.number-of-concurrent-tasks")]
+    #[arg(long = "concurrency.number-of-concurrent-tasks", default_value_t = 500)]
-    number_concurrent_tasks: Option<usize>,
+    number_concurrent_tasks: usize,
-
-    /// Determines if the concurrency limit should be ignored or not.
-    #[arg(long = "concurrency.ignore-concurrency-limit")]
-    ignore_concurrency_limit: bool,
 }
 
 impl ConcurrencyConfiguration {
     pub fn concurrency_limit(&self) -> Option<usize> {
-        match self.ignore_concurrency_limit {
+        if self.number_concurrent_tasks == 0 {
-            true => None,
+            None
-            false => Some(
+        } else {
-                self.number_concurrent_tasks
+            Some(self.number_concurrent_tasks)
-                    .unwrap_or(20 * self.number_of_nodes),
-            ),
         }
     }
 }
 
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct CompilationConfiguration {
     /// Controls if the compilation cache should be invalidated or not.
     #[arg(long = "compilation.invalidate-cache")]
     pub invalidate_compilation_cache: bool,
 }
 
-#[derive(Clone, Debug, Parser, Serialize)]
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct ReportConfiguration {
     /// Controls if the compiler input is included in the final report.
     #[clap(long = "report.include-compiler-input")]
@@ -849,8 +1008,15 @@ pub struct ReportConfiguration {
     pub include_compiler_output: bool,
 }
 
+#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
+pub struct IgnoreSuccessConfiguration {
+    /// The path of the report generated by the tool to use to ignore the cases that succeeded.
+    #[clap(long = "ignore-success.report-path")]
+    pub path: Option<PathBuf>,
+}
+
 /// Represents the working directory that the program uses.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum WorkingDirectoryConfiguration {
     /// A temporary directory is used as the working directory. This will be removed when dropped.
     TemporaryDirectory(Arc<TempDir>),
@@ -858,6 +1024,24 @@ pub enum WorkingDirectoryConfiguration {
     Path(PathBuf),
 }
 
+impl Serialize for WorkingDirectoryConfiguration {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_path().serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for WorkingDirectoryConfiguration {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'a>,
+    {
+        PathBuf::deserialize(deserializer).map(Self::Path)
+    }
+}
+
 impl WorkingDirectoryConfiguration {
     pub fn as_path(&self) -> &Path {
         self.as_ref()
@@ -896,7 +1080,10 @@ impl FromStr for WorkingDirectoryConfiguration {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "" => Ok(Default::default()),
-            _ => Ok(Self::Path(PathBuf::from(s))),
+            _ => PathBuf::from(s)
+                .canonicalize()
+                .context("Failed to canonicalize the working directory path")
+                .map(Self::Path),
         }
     }
 }
@@ -907,24 +1094,13 @@ impl Display for WorkingDirectoryConfiguration {
     }
 }
 
-impl Serialize for WorkingDirectoryConfiguration {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.as_path().serialize(serializer)
-    }
-}
-
 fn parse_duration(s: &str) -> anyhow::Result<Duration> {
     u64::from_str(s)
         .map(Duration::from_millis)
         .map_err(Into::into)
 }
 
-/// The Solidity compatible node implementation.
+/// The output format to use for the test execution output.
-///
-/// This describes the solutions to be tested against on a high level.
 #[derive(
     Clone,
     Copy,
@@ -935,6 +1111,7 @@ fn parse_duration(s: &str) -> anyhow::Result<Duration> {
     Ord,
     Hash,
     Serialize,
+    Deserialize,
     ValueEnum,
     EnumString,
     Display,
@@ -942,11 +1119,46 @@ fn parse_duration(s: &str) -> anyhow::Result<Duration> {
     IntoStaticStr,
 )]
 #[strum(serialize_all = "kebab-case")]
-pub enum TestingPlatform {
+pub enum OutputFormat {
-    /// The go-ethereum reference full node EVM implementation.
+    /// The legacy format that was used in the past for the output.
-    Geth,
+    Legacy,
-    /// The kitchensink runtime provides the PolkaVM (PVM) based node implementation.
+
-    Kitchensink,
+    /// An output format that looks heavily resembles the output from `cargo test`.
-    /// A polkadot/Substrate based network
+    CargoTestLike,
-    Zombienet,
+}
+
+/// Command line profiles used to override the default values provided for the commands.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    Serialize,
+    Deserialize,
+    ValueEnum,
+    EnumString,
+    Display,
+    AsRefStr,
+    IntoStaticStr,
+)]
+#[strum(serialize_all = "kebab-case")]
+pub enum Profile {
+    /// The default profile used by the framework. This profile is optimized to make the test
+    /// and workload execution happen as fast as possible.
+    #[default]
+    Default,
+
+    /// A debug profile optimized for use cases when certain tests are being debugged. This profile
+    /// sets up the framework with the following:
+    ///
+    /// * `concurrency.number-of-nodes` set to 1 node.
+    /// * `concurrency.number-of-concurrent-tasks` set to 1 such that tests execute sequentially.
+    /// * `concurrency.number-of-threads` set to 5.
+    /// * `working-directory` set to ~/.retester-workdir
+    Debug,
 }

crates/core/Cargo.toml

@@ -21,6 +21,7 @@ revive-dt-node = { workspace = true }
 revive-dt-node-interaction = { workspace = true }
 revive-dt-report = { workspace = true }
 
+ansi_term = { workspace = true }
 alloy = { workspace = true }
 anyhow = { workspace = true }
 bson = { workspace = true }
@@ -36,6 +37,7 @@ schemars = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+subxt = { workspace = true }
 
 [lints]
 workspace = true

crates/core/src/differential_benchmarks/driver.rs

@@ -22,6 +22,7 @@ use alloy::{
     },
 };
 use anyhow::{Context as _, Result, bail};
+use futures::TryFutureExt;
 use indexmap::IndexMap;
 use revive_dt_common::{
     futures::{PollingWaitBehavior, poll},
@@ -30,12 +31,12 @@ use revive_dt_common::{
 use revive_dt_format::{
     metadata::{ContractInstance, ContractPathAndIdent},
     steps::{
-        AllocateAccountStep, BalanceAssertionStep, Calldata, EtherValue, FunctionCallStep, Method,
+        AllocateAccountStep, Calldata, EtherValue, FunctionCallStep, Method, RepeatStep, Step,
-        RepeatStep, Step, StepAddress, StepIdx, StepPath, StorageEmptyAssertionStep,
+        StepIdx, StepPath,
     },
     traits::{ResolutionContext, ResolverApi},
 };
-use tokio::sync::{Mutex, mpsc::UnboundedSender};
+use tokio::sync::{Mutex, OnceCell, mpsc::UnboundedSender};
 use tracing::{Instrument, Span, debug, error, field::display, info, info_span, instrument};
 
 use crate::{
@@ -59,8 +60,8 @@ pub struct Driver<'a, I> {
     /// The definition of the test that the driver is instructed to execute.
     test_definition: &'a TestDefinition<'a>,
 
-    /// The private key allocator used by this driver and other drivers when account allocations
+    /// The private key allocator used by this driver and other drivers when account allocations are
-    /// are needed.
+    /// needed.
     private_key_allocator: Arc<Mutex<PrivateKeyAllocator>>,
 
     /// The execution state associated with the platform.
@@ -123,27 +124,17 @@ where
                 &self.platform_information.reporter,
             )
             .await
-            .inspect_err(|err| {
+            .inspect_err(|err| error!(?err, "Pre-linking compilation failed"))
-                error!(
-                    ?err,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
-                    "Pre-linking compilation failed"
-                )
-            })
             .context("Failed to produce the pre-linking compiled contracts")?;
 
+        let deployer_address = self.test_definition.case.deployer_address();
+
         let mut deployed_libraries = None::<HashMap<_, _>>;
         let mut contract_sources = self
             .test_definition
             .metadata
             .contract_sources()
-            .inspect_err(|err| {
+            .inspect_err(|err| error!(?err, "Failed to retrieve contract sources from metadata"))
-                error!(
-                    ?err,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
-                    "Failed to retrieve contract sources from metadata"
-                )
-            })
             .context("Failed to get the contract instances from the metadata file")?;
         for library_instance in self
             .test_definition
@@ -170,41 +161,23 @@ where
 
             let code = alloy::hex::decode(code)?;
 
-            // Getting the deployer address from the cases themselves. This is to ensure
-            // that we're doing the deployments from different accounts and therefore we're
-            // not slowed down by the nonce.
-            let deployer_address = self
-                .test_definition
-                .case
-                .steps
-                .iter()
-                .filter_map(|step| match step {
-                    Step::FunctionCall(input) => input.caller.as_address().copied(),
-                    Step::BalanceAssertion(..) => None,
-                    Step::StorageEmptyAssertion(..) => None,
-                    Step::Repeat(..) => None,
-                    Step::AllocateAccount(..) => None,
-                })
-                .next()
-                .unwrap_or(FunctionCallStep::default_caller_address());
             let tx = TransactionBuilder::<Ethereum>::with_deploy_code(
                 TransactionRequest::default().from(deployer_address),
                 code,
             );
-            let receipt = self.execute_transaction(tx).await.inspect_err(|err| {
+            let receipt = self
+                .execute_transaction(tx, None)
+                .and_then(|(_, receipt_fut)| receipt_fut)
+                .await
+                .inspect_err(|err| {
                     error!(
                         ?err,
                         %library_instance,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
                         "Failed to deploy the library"
                     )
                 })?;
 
-            debug!(
+            debug!(?library_instance, "Deployed library");
-                ?library_instance,
-                platform_identifier = %self.platform_information.platform.platform_identifier(),
-                "Deployed library"
-            );
 
             let library_address = receipt
                 .contract_address
@@ -227,15 +200,25 @@ where
                 &self.platform_information.reporter,
             )
             .await
-            .inspect_err(|err| {
+            .inspect_err(|err| error!(?err, "Post-linking compilation failed"))
-                error!(
-                    ?err,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
-                    "Post-linking compilation failed"
-                )
-            })
             .context("Failed to compile the post-link contracts")?;
 
+        for (contract_path, contract_name_to_info_mapping) in compiler_output.contracts.iter() {
+            for (contract_name, (contract_bytecode, _)) in contract_name_to_info_mapping.iter() {
+                let contract_bytecode = hex::decode(contract_bytecode)
+                    .expect("Impossible for us to get an undecodable bytecode after linking");
+
+                self.platform_information
+                    .reporter
+                    .report_contract_information_event(
+                        contract_path.to_path_buf(),
+                        contract_name.clone(),
+                        contract_bytecode.len(),
+                    )
+                    .expect("Should not fail");
+            }
+        }
+
         self.execution_state = ExecutionState::new(
             compiler_output.contracts,
             deployed_libraries.unwrap_or_default(),
@@ -269,7 +252,6 @@ where
         skip_all,
         fields(
             driver_id = self.driver_id,
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %step_path,
         ),
         err(Debug),
@@ -298,22 +280,18 @@ where
     #[instrument(level = "info", skip_all, fields(driver_id = self.driver_id))]
     pub async fn execute_function_call(
         &mut self,
-        _: &StepPath,
+        step_path: &StepPath,
         step: &FunctionCallStep,
     ) -> Result<usize> {
         let deployment_receipts = self
-            .handle_function_call_contract_deployment(step)
+            .handle_function_call_contract_deployment(step_path, step)
             .await
             .context("Failed to deploy contracts for the function call step")?;
-        let execution_receipt = self
+        let transaction_hash = self
-            .handle_function_call_execution(step, deployment_receipts)
+            .handle_function_call_execution(step_path, step, deployment_receipts)
             .await
             .context("Failed to handle the function call execution")?;
-        let tracing_result = self
+        self.handle_function_call_variable_assignment(step, transaction_hash)
-            .handle_function_call_call_frame_tracing(execution_receipt.transaction_hash)
-            .await
-            .context("Failed to handle the function call call frame tracing")?;
-        self.handle_function_call_variable_assignment(step, &tracing_result)
             .await
             .context("Failed to handle function call variable assignment")?;
         Ok(1)
@@ -321,6 +299,7 @@ where
 
     async fn handle_function_call_contract_deployment(
         &mut self,
+        step_path: &StepPath,
         step: &FunctionCallStep,
     ) -> Result<HashMap<ContractInstance, TransactionReceipt>> {
         let mut instances_we_must_deploy = IndexMap::<ContractInstance, bool>::new();
@@ -352,7 +331,13 @@ where
                     .await?
             };
             if let (_, _, Some(receipt)) = self
-                .get_or_deploy_contract_instance(&instance, caller, calldata, value)
+                .get_or_deploy_contract_instance(
+                    &instance,
+                    caller,
+                    calldata,
+                    value,
+                    Some(step_path),
+                )
                 .await
                 .context("Failed to get or deploy contract instance during input execution")?
             {
@@ -365,20 +350,22 @@ where
 
     async fn handle_function_call_execution(
         &mut self,
+        step_path: &StepPath,
         step: &FunctionCallStep,
         mut deployment_receipts: HashMap<ContractInstance, TransactionReceipt>,
-    ) -> Result<TransactionReceipt> {
+    ) -> Result<TxHash> {
         match step.method {
             // This step was already executed when `handle_step` was called. We just need to
             // lookup the transaction receipt in this case and continue on.
             Method::Deployer => deployment_receipts
                 .remove(&step.instance)
-                .context("Failed to find deployment receipt for constructor call"),
+                .context("Failed to find deployment receipt for constructor call")
+                .map(|receipt| receipt.transaction_hash),
             Method::Fallback | Method::FunctionName(_) => {
                 let tx = step
                     .as_transaction(self.resolver.as_ref(), self.default_resolution_context())
                     .await?;
-                self.execute_transaction(tx).await
+                Ok(self.execute_transaction(tx, Some(step_path)).await?.0)
             }
         }
     }
@@ -417,15 +404,19 @@ where
     async fn handle_function_call_variable_assignment(
         &mut self,
         step: &FunctionCallStep,
-        tracing_result: &CallFrame,
+        tx_hash: TxHash,
     ) -> Result<()> {
         let Some(ref assignments) = step.variable_assignments else {
             return Ok(());
         };
 
         // Handling the return data variable assignments.
+        let callframe = OnceCell::new();
         for (variable_name, output_word) in assignments.return_data.iter().zip(
-            tracing_result
+            callframe
+                .get_or_try_init(|| self.handle_function_call_call_frame_tracing(tx_hash))
+                .await
+                .context("Failed to get the callframe trace for transaction")?
                 .output
                 .as_ref()
                 .unwrap_or_default()
@@ -446,26 +437,6 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all, fields(driver_id = self.driver_id))]
-    pub async fn execute_balance_assertion(
-        &mut self,
-        _: &StepPath,
-        _: &BalanceAssertionStep,
-    ) -> anyhow::Result<usize> {
-        // Kept empty intentionally for the benchmark driver.
-        Ok(1)
-    }
-
-    #[instrument(level = "info", skip_all, fields(driver_id = self.driver_id), err(Debug))]
-    async fn execute_storage_empty_assertion_step(
-        &mut self,
-        _: &StepPath,
-        _: &StorageEmptyAssertionStep,
-    ) -> Result<usize> {
-        // Kept empty intentionally for the benchmark driver.
-        Ok(1)
-    }
-
     #[instrument(level = "info", skip_all, fields(driver_id = self.driver_id), err(Debug))]
     async fn execute_repeat_step(
         &mut self,
@@ -547,7 +518,6 @@ where
         skip_all,
         fields(
             driver_id = self.driver_id,
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %contract_instance,
             %deployer
         ),
@@ -559,6 +529,7 @@ where
         deployer: Address,
         calldata: Option<&Calldata>,
         value: Option<EtherValue>,
+        step_path: Option<&StepPath>,
     ) -> Result<(Address, JsonAbi, Option<TransactionReceipt>)> {
         if let Some((_, address, abi)) = self
             .execution_state
@@ -574,7 +545,7 @@ where
         } else {
             info!("Contract instance requires deployment.");
             let (address, abi, receipt) = self
-                .deploy_contract(contract_instance, deployer, calldata, value)
+                .deploy_contract(contract_instance, deployer, calldata, value, step_path)
                 .await
                 .context("Failed to deploy contract")?;
             info!(
@@ -590,7 +561,6 @@ where
     skip_all,
         fields(
             driver_id = self.driver_id,
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %contract_instance,
             %deployer
         ),
@@ -602,6 +572,7 @@ where
         deployer: Address,
         calldata: Option<&Calldata>,
         value: Option<EtherValue>,
+        step_path: Option<&StepPath>,
     ) -> Result<(Address, JsonAbi, TransactionReceipt)> {
         let Some(ContractPathAndIdent {
             contract_source_path,
@@ -660,7 +631,11 @@ where
             TransactionBuilder::<Ethereum>::with_deploy_code(tx, code)
         };
 
-        let receipt = match self.execute_transaction(tx).await {
+        let receipt = match self
+            .execute_transaction(tx, step_path)
+            .and_then(|(_, receipt_fut)| receipt_fut)
+            .await
+        {
             Ok(receipt) => receipt,
             Err(error) => {
                 tracing::error!(?error, "Contract deployment transaction failed.");
@@ -687,33 +662,6 @@ where
 
         Ok((address, abi, receipt))
     }
-
-    #[instrument(level = "info", fields(driver_id = self.driver_id), skip_all)]
-    async fn step_address_auto_deployment(
-        &mut self,
-        step_address: &StepAddress,
-    ) -> Result<Address> {
-        match step_address {
-            StepAddress::Address(address) => Ok(*address),
-            StepAddress::ResolvableAddress(resolvable) => {
-                let Some(instance) = resolvable
-                    .strip_suffix(".address")
-                    .map(ContractInstance::new)
-                else {
-                    bail!("Not an address variable");
-                };
-
-                self.get_or_deploy_contract_instance(
-                    &instance,
-                    FunctionCallStep::default_caller_address(),
-                    None,
-                    None,
-                )
-                .await
-                .map(|v| v.0)
-            }
-        }
-    }
     // endregion:Contract Deployment
 
     // region:Resolution & Resolver
@@ -734,7 +682,8 @@ where
     async fn execute_transaction(
         &self,
         transaction: TransactionRequest,
-    ) -> anyhow::Result<TransactionReceipt> {
+        step_path: Option<&StepPath>,
+    ) -> anyhow::Result<(TxHash, impl Future<Output = Result<TransactionReceipt>>)> {
         let node = self.platform_information.node;
         let transaction_hash = node
             .submit_transaction(transaction)
@@ -743,10 +692,16 @@ where
         Span::current().record("transaction_hash", display(transaction_hash));
 
         info!("Submitted transaction");
+        if let Some(step_path) = step_path {
             self.watcher_tx
-            .send(WatcherEvent::SubmittedTransaction { transaction_hash })
+                .send(WatcherEvent::SubmittedTransaction {
+                    transaction_hash,
+                    step_path: step_path.clone(),
+                })
                 .context("Failed to send the transaction hash to the watcher")?;
+        };
 
+        Ok((transaction_hash, async move {
             info!("Starting to poll for transaction receipt");
             poll(
                 Duration::from_secs(30 * 60),
@@ -764,7 +719,10 @@ where
                     .instrument(info_span!("Polling for receipt"))
                 },
             )
+            .instrument(info_span!("Polling for receipt", %transaction_hash))
             .await
+            .inspect(|_| info!("Found the transaction receipt"))
+        }))
     }
     // endregion:Transaction Execution
 }

crates/core/src/differential_benchmarks/entry_point.rs

@@ -6,16 +6,19 @@ use anyhow::Context as _;
 use futures::{FutureExt, StreamExt};
 use revive_dt_common::types::PrivateKeyAllocator;
 use revive_dt_core::Platform;
-use revive_dt_format::steps::{Step, StepIdx, StepPath};
+use revive_dt_format::{
+    corpus::Corpus,
+    steps::{Step, StepIdx, StepPath},
+};
 use tokio::sync::Mutex;
-use tracing::{error, info, info_span, instrument, warn};
+use tracing::{Instrument, error, info, info_span, instrument, warn};
 
 use revive_dt_config::{BenchmarkingContext, Context};
 use revive_dt_report::Reporter;
 
 use crate::{
     differential_benchmarks::{Driver, Watcher, WatcherEvent},
-    helpers::{CachedCompiler, NodePool, collect_metadata_files, create_test_definitions_stream},
+    helpers::{CachedCompiler, NodePool, create_test_definitions_stream},
 };
 
 /// Handles the differential testing executing it according to the information defined in the
@@ -39,9 +42,17 @@ pub async fn handle_differential_benchmarks(
     let full_context = Context::Benchmark(Box::new(context.clone()));
 
     // Discover all of the metadata files that are defined in the context.
-    let metadata_files = collect_metadata_files(&context)
+    let corpus = context
-        .context("Failed to collect metadata files for differential testing")?;
+        .corpus_configuration
-    info!(len = metadata_files.len(), "Discovered metadata files");
+        .test_specifiers
+        .clone()
+        .into_iter()
+        .try_fold(Corpus::default(), Corpus::with_test_specifier)
+        .context("Failed to parse the test corpus")?;
+    info!(
+        len = corpus.metadata_file_count(),
+        "Discovered metadata files"
+    );
 
     // Discover the list of platforms that the tests should run on based on the context.
     let platforms = context
@@ -84,8 +95,9 @@ pub async fn handle_differential_benchmarks(
     // Preparing test definitions for the execution.
     let test_definitions = create_test_definitions_stream(
         &full_context,
-        metadata_files.iter(),
+        &corpus,
         &platforms_and_nodes,
+        None,
         reporter.clone(),
     )
     .await
@@ -133,12 +145,14 @@ pub async fn handle_differential_benchmarks(
                 context.wallet_configuration.highest_private_key_exclusive(),
             )));
             let (watcher, watcher_tx) = Watcher::new(
-                platform_identifier,
                 platform_information
                     .node
                     .subscribe_to_full_blocks_information()
                     .await
                     .context("Failed to subscribe to full blocks information from the node")?,
+                test_definition
+                    .reporter
+                    .execution_specific_reporter(0usize, platform_identifier),
             );
             let driver = Driver::new(
                 platform_information,
@@ -159,7 +173,10 @@ pub async fn handle_differential_benchmarks(
 
             futures::future::try_join(
                 watcher.run(),
-                driver.execute_all().inspect(|_| {
+                driver
+                    .execute_all()
+                    .instrument(info_span!("Executing Benchmarks", %platform_identifier))
+                    .inspect(|_| {
                         info!("All transactions submitted - driver completed execution");
                         watcher_tx
                             .send(WatcherEvent::AllTransactionsSubmitted)

crates/core/src/differential_benchmarks/execution_state.rs

@@ -10,15 +10,14 @@ use revive_dt_format::metadata::{ContractIdent, ContractInstance};
 #[derive(Clone)]
 /// The state associated with the test execution of one of the workloads.
 pub struct ExecutionState {
-    /// The compiled contracts, these contracts have been compiled and have had the libraries
+    /// The compiled contracts, these contracts have been compiled and have had the libraries linked
-    /// linked against them and therefore they're ready to be deployed on-demand.
+    /// against them and therefore they're ready to be deployed on-demand.
     pub compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
 
     /// A map of all of the deployed contracts and information about them.
     pub deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
 
-    /// This map stores the variables used for each one of the cases contained in the metadata
+    /// This map stores the variables used for each one of the cases contained in the metadata file.
-    /// file.
     pub variables: HashMap<String, U256>,
 }
 

crates/core/src/differential_benchmarks/watcher.rs

@@ -1,10 +1,15 @@
-use std::{collections::HashSet, pin::Pin, sync::Arc};
+use std::{
+    collections::HashMap,
+    pin::Pin,
+    sync::Arc,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
 use alloy::primitives::{BlockNumber, TxHash};
 use anyhow::Result;
 use futures::{Stream, StreamExt};
-use revive_dt_common::types::PlatformIdentifier;
+use revive_dt_format::steps::StepPath;
-use revive_dt_node_interaction::MinedBlockInformation;
+use revive_dt_report::{ExecutionSpecificReporter, MinedBlockInformation, TransactionInformation};
 use tokio::sync::{
     RwLock,
     mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel},
@@ -15,9 +20,6 @@ use tracing::{info, instrument};
 /// and MUST NOT be re-used between workloads since it holds important internal state for a given
 /// workload and is not designed for reuse.
 pub struct Watcher {
-    /// The identifier of the platform that this watcher is for.
-    platform_identifier: PlatformIdentifier,
-
     /// The receive side of the channel that all of the drivers and various other parts of the code
     /// send events to the watcher on.
     rx: UnboundedReceiver<WatcherEvent>,
@@ -25,19 +27,22 @@ pub struct Watcher {
     /// This is a stream of the blocks that were mined by the node. This is for a single platform
     /// and a single node from that platform.
     blocks_stream: Pin<Box<dyn Stream<Item = MinedBlockInformation>>>,
+
+    /// The reporter used to send events to the report aggregator.
+    reporter: ExecutionSpecificReporter,
 }
 
 impl Watcher {
     pub fn new(
-        platform_identifier: PlatformIdentifier,
         blocks_stream: Pin<Box<dyn Stream<Item = MinedBlockInformation>>>,
+        reporter: ExecutionSpecificReporter,
     ) -> (Self, UnboundedSender<WatcherEvent>) {
         let (tx, rx) = unbounded_channel::<WatcherEvent>();
         (
             Self {
-                platform_identifier,
                 rx,
                 blocks_stream,
+                reporter,
             },
             tx,
         )
@@ -61,7 +66,8 @@ impl Watcher {
         // This is the set of the transaction hashes that the watcher should be looking for and
         // watch for them in the blocks. The watcher will keep watching for blocks until it sees
         // that all of the transactions that it was watching for has been seen in the mined blocks.
-        let watch_for_transaction_hashes = Arc::new(RwLock::new(HashSet::<TxHash>::new()));
+        let watch_for_transaction_hashes =
+            Arc::new(RwLock::new(HashMap::<TxHash, (StepPath, SystemTime)>::new()));
 
         // A boolean that keeps track of whether all of the transactions were submitted or if more
         // txs are expected to come through the receive side of the channel. We do not want to rely
@@ -81,11 +87,14 @@ impl Watcher {
                         // contain nested repetitions and therefore there's no use in doing any
                         // action if the repetitions are nested.
                         WatcherEvent::RepetitionStartEvent { .. } => {}
-                        WatcherEvent::SubmittedTransaction { transaction_hash } => {
+                        WatcherEvent::SubmittedTransaction {
+                            transaction_hash,
+                            step_path,
+                        } => {
                             watch_for_transaction_hashes
                                 .write()
                                 .await
-                                .insert(transaction_hash);
+                                .insert(transaction_hash, (step_path, SystemTime::now()));
                         }
                         WatcherEvent::AllTransactionsSubmitted => {
                             *all_transactions_submitted.write().await = true;
@@ -97,19 +106,32 @@ impl Watcher {
                 }
             }
         };
+        let reporter = self.reporter.clone();
         let block_information_watching_task = {
             let watch_for_transaction_hashes = watch_for_transaction_hashes.clone();
             let all_transactions_submitted = all_transactions_submitted.clone();
             let mut blocks_information_stream = self.blocks_stream;
             async move {
-                let mut mined_blocks_information = Vec::new();
+                while let Some(mut block) = blocks_information_stream.next().await {
-
-                while let Some(block) = blocks_information_stream.next().await {
                     // If the block number is equal to or less than the last block before the
                     // repetition then we ignore it and continue on to the next block.
-                    if block.block_number <= ignore_block_before {
+                    if block.ethereum_block_information.block_number <= ignore_block_before {
                         continue;
                     }
+                    {
+                        let watch_for_transaction_hashes =
+                            watch_for_transaction_hashes.read().await;
+                        for tx_hash in block.ethereum_block_information.transaction_hashes.iter() {
+                            let Some((step_path, _)) = watch_for_transaction_hashes.get(tx_hash)
+                            else {
+                                continue;
+                            };
+                            *block.tx_counts.entry(step_path.clone()).or_default() += 1
+                        }
+                    }
+                    reporter
+                        .report_block_mined_event(block.clone())
+                        .expect("Can't fail");
 
                     if *all_transactions_submitted.read().await
                         && watch_for_transaction_hashes.read().await.is_empty()
@@ -118,8 +140,9 @@ impl Watcher {
                     }
 
                     info!(
+                        block_number = block.ethereum_block_information.block_number,
+                        block_tx_count = block.ethereum_block_information.transaction_hashes.len(),
                         remaining_transactions = watch_for_transaction_hashes.read().await.len(),
-                        block_tx_count = block.transaction_hashes.len(),
                         "Observed a block"
                     );
 
@@ -127,58 +150,43 @@ impl Watcher {
                     // are currently watching for.
                     let mut watch_for_transaction_hashes =
                         watch_for_transaction_hashes.write().await;
-                    for tx_hash in block.transaction_hashes.iter() {
+                    for tx_hash in block.ethereum_block_information.transaction_hashes.iter() {
-                        watch_for_transaction_hashes.remove(tx_hash);
+                        let Some((step_path, submission_time)) =
+                            watch_for_transaction_hashes.remove(tx_hash)
+                        else {
+                            continue;
+                        };
+                        let transaction_information = TransactionInformation {
+                            transaction_hash: *tx_hash,
+                            submission_timestamp: submission_time
+                                .duration_since(UNIX_EPOCH)
+                                .expect("Can't fail")
+                                .as_secs() as _,
+                            block_timestamp: block.ethereum_block_information.block_timestamp,
+                            block_number: block.ethereum_block_information.block_number,
+                        };
+                        reporter
+                            .report_step_transaction_information_event(
+                                step_path,
+                                transaction_information,
+                            )
+                            .expect("Can't fail")
                     }
-
-                    mined_blocks_information.push(block);
                 }
 
                 info!("Watcher's Block Watching Task Finished");
-                mined_blocks_information
             }
         };
 
-        let (_, mined_blocks_information) =
+        let (_, _) =
             futures::future::join(watcher_event_watching_task, block_information_watching_task)
                 .await;
 
-        // region:TEMPORARY
-        {
-            // TODO: The following core is TEMPORARY and will be removed once we have proper
-            // reporting in place and then it can be removed. This serves as as way of doing some
-            // very simple reporting for the time being.
-            use std::io::Write;
-
-            let mut stderr = std::io::stderr().lock();
-            writeln!(
-                stderr,
-                "Watcher information for {}",
-                self.platform_identifier
-            )?;
-            writeln!(
-                stderr,
-                "block_number,block_timestamp,mined_gas,block_gas_limit,tx_count"
-            )?;
-            for block in mined_blocks_information {
-                writeln!(
-                    stderr,
-                    "{},{},{},{},{}",
-                    block.block_number,
-                    block.block_timestamp,
-                    block.mined_gas,
-                    block.block_gas_limit,
-                    block.transaction_hashes.len()
-                )?
-            }
-        }
-        // endregion:TEMPORARY
-
         Ok(())
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum WatcherEvent {
     /// Informs the watcher that it should begin watching for the blocks mined by the platforms.
     /// Before the watcher receives this event it will not be watching for the mined blocks. The
@@ -192,14 +200,14 @@ pub enum WatcherEvent {
         /// streaming the blocks.
         ignore_block_before: BlockNumber,
     },
-
     /// Informs the watcher that a transaction was submitted and that the watcher should watch for a
     /// transaction with this hash in the blocks that it watches.
     SubmittedTransaction {
         /// The hash of the submitted transaction.
         transaction_hash: TxHash,
+        /// The step path of the step that the transaction belongs to.
+        step_path: StepPath,
     },
-
     /// Informs the watcher that all of the transactions of this benchmark have been submitted and
     /// that it can expect to receive no further transaction hashes and not even watch the channel
     /// any longer.

crates/core/src/differential_tests/driver.rs

@@ -8,7 +8,7 @@ use alloy::{
     hex,
     json_abi::JsonAbi,
     network::{Ethereum, TransactionBuilder},
-    primitives::{Address, TxHash, U256},
+    primitives::{Address, TxHash, U256, address},
     rpc::types::{
         TransactionReceipt, TransactionRequest,
         trace::geth::{
@@ -18,9 +18,9 @@ use alloy::{
     },
 };
 use anyhow::{Context as _, Result, bail};
-use futures::TryStreamExt;
+use futures::{TryStreamExt, future::try_join_all};
 use indexmap::IndexMap;
-use revive_dt_common::types::{PlatformIdentifier, PrivateKeyAllocator};
+use revive_dt_common::types::{PlatformIdentifier, PrivateKeyAllocator, VmIdentifier};
 use revive_dt_format::{
     metadata::{ContractInstance, ContractPathAndIdent},
     steps::{
@@ -30,6 +30,7 @@ use revive_dt_format::{
     },
     traits::ResolutionContext,
 };
+use subxt::{ext::codec::Decode, metadata::Metadata, tx::Payload};
 use tokio::sync::Mutex;
 use tracing::{error, info, instrument};
 
@@ -131,8 +132,8 @@ pub struct PlatformDriver<'a, I> {
     /// The definition of the test that the driver is instructed to execute.
     test_definition: &'a TestDefinition<'a>,
 
-    /// The private key allocator used by this driver and other drivers when account allocations
+    /// The private key allocator used by this driver and other drivers when account allocations are
-    /// are needed.
+    /// needed.
     private_key_allocator: Arc<Mutex<PrivateKeyAllocator>>,
 
     /// The execution state associated with the platform.
@@ -198,6 +199,8 @@ where
             })
             .context("Failed to produce the pre-linking compiled contracts")?;
 
+        let deployer_address = test_definition.case.deployer_address();
+
         let mut deployed_libraries = None::<HashMap<_, _>>;
         let mut contract_sources = test_definition
             .metadata
@@ -232,22 +235,6 @@ where
 
             let code = alloy::hex::decode(code)?;
 
-            // Getting the deployer address from the cases themselves. This is to ensure
-            // that we're doing the deployments from different accounts and therefore we're
-            // not slowed down by the nonce.
-            let deployer_address = test_definition
-                .case
-                .steps
-                .iter()
-                .filter_map(|step| match step {
-                    Step::FunctionCall(input) => input.caller.as_address().copied(),
-                    Step::BalanceAssertion(..) => None,
-                    Step::StorageEmptyAssertion(..) => None,
-                    Step::Repeat(..) => None,
-                    Step::AllocateAccount(..) => None,
-                })
-                .next()
-                .unwrap_or(FunctionCallStep::default_caller_address());
             let tx = TransactionBuilder::<Ethereum>::with_deploy_code(
                 TransactionRequest::default().from(deployer_address),
                 code,
@@ -295,6 +282,51 @@ where
             })
             .context("Failed to compile the post-link contracts")?;
 
+        // Factory contracts on the PVM refer to the code that they're instantiating by hash rather
+        // than including the actual bytecode. This creates a problem where a factory contract could
+        // be deployed but the code it's supposed to create is not on chain. Therefore, we upload
+        // all the code to the chain prior to running any transactions on the driver.
+        if platform_information.platform.vm_identifier() == VmIdentifier::PolkaVM {
+            #[subxt::subxt(runtime_metadata_path = "../../assets/revive_metadata.scale")]
+            pub mod revive {}
+
+            let metadata_bytes = include_bytes!("../../../../assets/revive_metadata.scale");
+            let metadata = Metadata::decode(&mut &metadata_bytes[..])
+                .context("Failed to decode the revive metadata")?;
+
+            const RUNTIME_PALLET_ADDRESS: Address =
+                address!("0x6d6f646c70792f70616464720000000000000000");
+
+            let code_upload_tasks = compiler_output
+                .contracts
+                .values()
+                .flat_map(|item| item.values())
+                .map(|(code_string, _)| {
+                    let metadata = metadata.clone();
+                    async move {
+                        let code = alloy::hex::decode(code_string)
+                            .context("Failed to hex-decode the post-link code. This is a bug")?;
+                        let payload = revive::tx().revive().upload_code(code, u128::MAX);
+                        let encoded_payload = payload
+                            .encode_call_data(&metadata)
+                            .context("Failed to encode the upload code payload")?;
+
+                        let tx_request = TransactionRequest::default()
+                            .from(deployer_address)
+                            .to(RUNTIME_PALLET_ADDRESS)
+                            .input(encoded_payload.into());
+                        platform_information
+                            .node
+                            .execute_transaction(tx_request)
+                            .await
+                            .context("Failed to execute transaction")
+                    }
+                });
+            try_join_all(code_upload_tasks)
+                .await
+                .context("Code upload failed")?;
+        }
+
         Ok(ExecutionState::new(
             compiler_output.contracts,
             deployed_libraries.unwrap_or_default(),
@@ -353,12 +385,17 @@ where
                 .execute_account_allocation(step_path, step.as_ref())
                 .await
                 .context("Account Allocation Step Failed"),
-        }?;
+        }
+        .context(format!("Failure on step {step_path}"))?;
         self.steps_executed += steps_executed;
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
+    #[instrument(
+        level = "info",
+        skip_all,
+        fields(block_number = tracing::field::Empty)
+    )]
     pub async fn execute_function_call(
         &mut self,
         _: &StepPath,
@@ -372,6 +409,7 @@ where
             .handle_function_call_execution(step, deployment_receipts)
             .await
             .context("Failed to handle the function call execution")?;
+        tracing::Span::current().record("block_number", execution_receipt.block_number);
         let tracing_result = self
             .handle_function_call_call_frame_tracing(execution_receipt.transaction_hash)
             .await
@@ -415,13 +453,9 @@ where
             let caller = {
                 let context = self.default_resolution_context();
                 let resolver = self.platform_information.node.resolver().await?;
-                let resolved = step
+                step.caller
-                    .caller
                     .resolve_address(resolver.as_ref(), context)
-                    .await?;
+                    .await?
-                self.platform_information
-                    .node
-                    .resolve_signer_or_default(resolved)
             };
             if let (_, _, Some(receipt)) = self
                 .get_or_deploy_contract_instance(&instance, caller, calldata, value)
@@ -449,7 +483,7 @@ where
                 .context("Failed to find deployment receipt for constructor call"),
             Method::Fallback | Method::FunctionName(_) => {
                 let resolver = self.platform_information.node.resolver().await?;
-                let mut tx = match step
+                let tx = match step
                     .as_transaction(resolver.as_ref(), self.default_resolution_context())
                     .await
                 {
@@ -459,15 +493,6 @@ where
                     }
                 };
 
-                // Resolve the signer to ensure we use an address that has keys
-                if let Some(from) = tx.from {
-                    tx.from = Some(
-                        self.platform_information
-                            .node
-                            .resolve_signer_or_default(from),
-                    );
-                }
-
                 self.platform_information.node.execute_transaction(tx).await
             }
         }
@@ -610,21 +635,26 @@ where
         let expected = !assertion.exception;
         let actual = receipt.status();
         if actual != expected {
+            let revert_reason = tracing_result
+                .revert_reason
+                .as_ref()
+                .or(tracing_result.error.as_ref());
             tracing::error!(
                 expected,
                 actual,
                 ?receipt,
                 ?tracing_result,
+                ?revert_reason,
                 "Transaction status assertion failed"
             );
             anyhow::bail!(
-                "Transaction status assertion failed - Expected {expected} but got {actual}",
+                "Transaction status assertion failed - Expected {expected} but got {actual}. Revert reason: {revert_reason:?}",
             );
         }
 
         // Handling the calldata assertion
-        if let Some(ref expected_calldata) = assertion.return_data {
+        if let Some(ref expected_output) = assertion.return_data {
-            let expected = expected_calldata;
+            let expected = expected_output;
             let actual = &tracing_result.output.as_ref().unwrap_or_default();
             if !expected
                 .is_equivalent(actual, resolver.as_ref(), resolution_context)
@@ -635,9 +665,9 @@ where
                     ?receipt,
                     ?expected,
                     %actual,
-                    "Calldata assertion failed"
+                    "Output assertion failed"
                 );
-                anyhow::bail!("Calldata assertion failed - Expected {expected:?} but got {actual}",);
+                anyhow::bail!("Output assertion failed - Expected {expected:?} but got {actual}",);
             }
         }
 
@@ -967,10 +997,6 @@ where
         }
 
         let tx = {
-            let deployer = self
-                .platform_information
-                .node
-                .resolve_signer_or_default(deployer);
             let tx = TransactionRequest::default().from(deployer);
             let tx = match value {
                 Some(ref value) => tx.value(value.into_inner()),

crates/core/src/differential_tests/entry_point.rs

@@ -7,19 +7,21 @@ use std::{
     time::{Duration, Instant},
 };
 
-use crate::Platform;
+use ansi_term::{ANSIStrings, Color};
 use anyhow::Context as _;
 use futures::{FutureExt, StreamExt};
-use revive_dt_common::types::PrivateKeyAllocator;
+use revive_dt_common::{cached_fs::read_to_string, types::PrivateKeyAllocator};
+use revive_dt_core::Platform;
+use revive_dt_format::corpus::Corpus;
 use tokio::sync::{Mutex, RwLock, Semaphore};
 use tracing::{Instrument, error, info, info_span, instrument};
 
-use revive_dt_config::{Context, TestExecutionContext};
+use revive_dt_config::{Context, OutputFormat, TestExecutionContext};
 use revive_dt_report::{Reporter, ReporterEvent, TestCaseStatus};
 
 use crate::{
     differential_tests::Driver,
-    helpers::{CachedCompiler, NodePool, collect_metadata_files, create_test_definitions_stream},
+    helpers::{CachedCompiler, NodePool, create_test_definitions_stream},
 };
 
 /// Handles the differential testing executing it according to the information defined in the
@@ -32,9 +34,17 @@ pub async fn handle_differential_tests(
     let reporter_clone = reporter.clone();
 
     // Discover all of the metadata files that are defined in the context.
-    let metadata_files = collect_metadata_files(&context)
+    let corpus = context
-        .context("Failed to collect metadata files for differential testing")?;
+        .corpus_configuration
-    info!(len = metadata_files.len(), "Discovered metadata files");
+        .test_specifiers
+        .clone()
+        .into_iter()
+        .try_fold(Corpus::default(), Corpus::with_test_specifier)
+        .context("Failed to parse the test corpus")?;
+    info!(
+        len = corpus.metadata_file_count(),
+        "Discovered metadata files"
+    );
 
     // Discover the list of platforms that the tests should run on based on the context.
     let platforms = context
@@ -71,11 +81,20 @@ pub async fn handle_differential_tests(
     info!("Spawned the platform nodes");
 
     // Preparing test definitions.
+    let only_execute_failed_tests = match context.ignore_success_configuration.path.as_ref() {
+        Some(path) => {
+            let report = read_to_string(path)
+                .context("Failed to read the report file to ignore the succeeding test cases")?;
+            Some(serde_json::from_str(&report).context("Failed to deserialize report")?)
+        }
+        None => None,
+    };
     let full_context = Context::Test(Box::new(context.clone()));
     let test_definitions = create_test_definitions_stream(
         &full_context,
-        metadata_files.iter(),
+        &corpus,
         &platforms_and_nodes,
+        only_execute_failed_tests.as_ref(),
         reporter.clone(),
     )
     .await
@@ -176,7 +195,7 @@ pub async fn handle_differential_tests(
             .report_completion_event()
             .expect("Can't fail")
     });
-    let cli_reporting_task = start_cli_reporting_task(reporter);
+    let cli_reporting_task = start_cli_reporting_task(context.output_format, reporter);
 
     tokio::task::spawn(async move {
         loop {
@@ -186,6 +205,7 @@ pub async fn handle_differential_tests(
                 ?remaining_tasks,
                 "Remaining Tests"
             );
+            drop(remaining_tasks);
             tokio::time::sleep(Duration::from_secs(10)).await
         }
     });
@@ -196,21 +216,15 @@ pub async fn handle_differential_tests(
 }
 
 #[allow(irrefutable_let_patterns, clippy::uninlined_format_args)]
-async fn start_cli_reporting_task(reporter: Reporter) {
+async fn start_cli_reporting_task(output_format: OutputFormat, reporter: Reporter) {
     let mut aggregator_events_rx = reporter.subscribe().await.expect("Can't fail");
     drop(reporter);
 
     let start = Instant::now();
 
-    const GREEN: &str = "\x1B[32m";
+    let mut global_success_count = 0;
-    const RED: &str = "\x1B[31m";
+    let mut global_failure_count = 0;
-    const GREY: &str = "\x1B[90m";
+    let mut global_ignore_count = 0;
-    const COLOR_RESET: &str = "\x1B[0m";
-    const BOLD: &str = "\x1B[1m";
-    const BOLD_RESET: &str = "\x1B[22m";
-
-    let mut number_of_successes = 0;
-    let mut number_of_failures = 0;
 
     let mut buf = BufWriter::new(stderr());
     while let Ok(event) = aggregator_events_rx.recv().await {
@@ -223,55 +237,135 @@ async fn start_cli_reporting_task(reporter: Reporter) {
             continue;
         };
 
+        match output_format {
+            OutputFormat::Legacy => {
                 let _ = writeln!(buf, "{} - {}", mode, metadata_file_path.display());
                 for (case_idx, case_status) in case_status.into_iter() {
                     let _ = write!(buf, "\tCase Index {case_idx:>3}: ");
                     let _ = match case_status {
                         TestCaseStatus::Succeeded { steps_executed } => {
-                    number_of_successes += 1;
+                            global_success_count += 1;
                             writeln!(
                                 buf,
-                        "{}{}Case Succeeded{} - Steps Executed: {}{}",
+                                "{}",
-                        GREEN, BOLD, BOLD_RESET, steps_executed, COLOR_RESET
+                                ANSIStrings(&[
+                                    Color::Green.bold().paint("Case Succeeded"),
+                                    Color::Green
+                                        .paint(format!(" - Steps Executed: {steps_executed}")),
+                                ])
                             )
                         }
                         TestCaseStatus::Failed { reason } => {
-                    number_of_failures += 1;
+                            global_failure_count += 1;
                             writeln!(
                                 buf,
-                        "{}{}Case Failed{} - Reason: {}{}",
+                                "{}",
-                        RED,
+                                ANSIStrings(&[
-                        BOLD,
+                                    Color::Red.bold().paint("Case Failed"),
-                        BOLD_RESET,
+                                    Color::Red.paint(format!(" - Reason: {}", reason.trim())),
-                        reason.trim(),
+                                ])
-                        COLOR_RESET,
                             )
                         }
-                TestCaseStatus::Ignored { reason, .. } => writeln!(
+                        TestCaseStatus::Ignored { reason, .. } => {
+                            global_ignore_count += 1;
+                            writeln!(
                                 buf,
-                    "{}{}Case Ignored{} - Reason: {}{}",
+                                "{}",
-                    GREY,
+                                ANSIStrings(&[
-                    BOLD,
+                                    Color::Yellow.bold().paint("Case Ignored"),
-                    BOLD_RESET,
+                                    Color::Yellow.paint(format!(" - Reason: {}", reason.trim())),
-                    reason.trim(),
+                                ])
-                    COLOR_RESET,
+                            )
-                ),
+                        }
                     };
                 }
                 let _ = writeln!(buf);
             }
+            OutputFormat::CargoTestLike => {
+                writeln!(
+                    buf,
+                    "\t{} {} - {}\n",
+                    Color::Green.paint("Running"),
+                    metadata_file_path.display(),
+                    mode
+                )
+                .unwrap();
+
+                let mut success_count = 0;
+                let mut failure_count = 0;
+                let mut ignored_count = 0;
+                writeln!(buf, "running {} tests", case_status.len()).unwrap();
+                for (case_idx, case_result) in case_status.iter() {
+                    let status = match case_result {
+                        TestCaseStatus::Succeeded { .. } => {
+                            success_count += 1;
+                            global_success_count += 1;
+                            Color::Green.paint("ok")
+                        }
+                        TestCaseStatus::Failed { reason } => {
+                            failure_count += 1;
+                            global_failure_count += 1;
+                            Color::Red.paint(format!("FAILED, {reason}"))
+                        }
+                        TestCaseStatus::Ignored { reason, .. } => {
+                            ignored_count += 1;
+                            global_ignore_count += 1;
+                            Color::Yellow.paint(format!("ignored, {reason:?}"))
+                        }
+                    };
+                    writeln!(buf, "test case_idx_{} ... {}", case_idx, status).unwrap();
+                }
+                writeln!(buf).unwrap();
+
+                let status = if failure_count > 0 {
+                    Color::Red.paint("FAILED")
+                } else {
+                    Color::Green.paint("ok")
+                };
+                writeln!(
+                    buf,
+                    "test result: {}. {} passed; {} failed; {} ignored",
+                    status, success_count, failure_count, ignored_count,
+                )
+                .unwrap();
+                writeln!(buf).unwrap();
+
+                if aggregator_events_rx.is_empty() {
+                    buf = tokio::task::spawn_blocking(move || {
+                        buf.flush().unwrap();
+                        buf
+                    })
+                    .await
+                    .unwrap();
+                }
+            }
+        }
+    }
+    info!("Aggregator Broadcast Channel Closed");
 
     // Summary at the end.
-    let _ = writeln!(
+    match output_format {
+        OutputFormat::Legacy => {
+            writeln!(
                 buf,
-        "{} cases: {}{}{} cases succeeded, {}{}{} cases failed in {} seconds",
+                "{} cases: {} cases succeeded, {} cases failed in {} seconds",
-        number_of_successes + number_of_failures,
+                global_success_count + global_failure_count + global_ignore_count,
-        GREEN,
+                Color::Green.paint(global_success_count.to_string()),
-        number_of_successes,
+                Color::Red.paint(global_failure_count.to_string()),
-        COLOR_RESET,
-        RED,
-        number_of_failures,
-        COLOR_RESET,
                 start.elapsed().as_secs()
-    );
+            )
+            .unwrap();
+        }
+        OutputFormat::CargoTestLike => {
+            writeln!(
+                buf,
+                "run finished. {} passed; {} failed; {} ignored; finished in {}s",
+                global_success_count,
+                global_failure_count,
+                global_ignore_count,
+                start.elapsed().as_secs()
+            )
+            .unwrap();
+        }
+    }
 }

crates/core/src/differential_tests/execution_state.rs

@@ -10,15 +10,14 @@ use revive_dt_format::metadata::{ContractIdent, ContractInstance};
 #[derive(Clone)]
 /// The state associated with the test execution of one of the tests.
 pub struct ExecutionState {
-    /// The compiled contracts, these contracts have been compiled and have had the libraries
+    /// The compiled contracts, these contracts have been compiled and have had the libraries linked
-    /// linked against them and therefore they're ready to be deployed on-demand.
+    /// against them and therefore they're ready to be deployed on-demand.
     pub compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
 
     /// A map of all of the deployed contracts and information about them.
     pub deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
 
-    /// This map stores the variables used for each one of the cases contained in the metadata
+    /// This map stores the variables used for each one of the cases contained in the metadata file.
-    /// file.
     pub variables: HashMap<String, U256>,
 }
 

crates/core/src/helpers/cached_compiler.rs

@@ -8,10 +8,10 @@ use std::{
     sync::{Arc, LazyLock},
 };
 
-use crate::Platform;
 use futures::FutureExt;
 use revive_dt_common::{iterators::FilesWithExtensionIterator, types::CompilerIdentifier};
 use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
+use revive_dt_core::Platform;
 use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
 
 use alloy::{hex::ToHexExt, json_abi::JsonAbi, primitives::Address};
@@ -325,26 +325,6 @@ impl ArtifactsCache {
         let value = bson::from_slice::<CacheValue>(&value).ok()?;
         Some(value)
     }
-
-    #[instrument(level = "debug", skip_all, err)]
-    pub async fn get_or_insert_with(
-        &self,
-        key: &CacheKey<'_>,
-        callback: impl AsyncFnOnce() -> Result<CacheValue>,
-    ) -> Result<CacheValue> {
-        match self.get(key).await {
-            Some(value) => {
-                debug!("Cache hit");
-                Ok(value)
-            }
-            None => {
-                debug!("Cache miss");
-                let value = callback().await?;
-                self.insert(key, &value).await?;
-                Ok(value)
-            }
-        }
-    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]

crates/core/src/helpers/metadata.rs

@@ -1,33 +0,0 @@
-use revive_dt_config::CorpusConfiguration;
-use revive_dt_format::{corpus::Corpus, metadata::MetadataFile};
-use tracing::{info, info_span, instrument};
-
-/// Given an object that implements [`AsRef<CorpusConfiguration>`], this function finds all of the
-/// corpus files and produces a map containing all of the [`MetadataFile`]s discovered.
-#[instrument(level = "debug", name = "Collecting Corpora", skip_all)]
-pub fn collect_metadata_files(
-    context: impl AsRef<CorpusConfiguration>,
-) -> anyhow::Result<Vec<MetadataFile>> {
-    let mut metadata_files = Vec::new();
-
-    let corpus_configuration = AsRef::<CorpusConfiguration>::as_ref(&context);
-    for path in &corpus_configuration.paths {
-        let span = info_span!("Processing corpus file", path = %path.display());
-        let _guard = span.enter();
-
-        let corpus = Corpus::try_from_path(path)?;
-        info!(
-            name = corpus.name(),
-            number_of_contained_paths = corpus.path_count(),
-            "Deserialized corpus file"
-        );
-        metadata_files.extend(corpus.enumerate_tests());
-    }
-
-    // There's a possibility that there are certain paths that all lead to the same metadata files
-    // and therefore it's important that we sort them and then deduplicate them.
-    metadata_files.sort_by(|a, b| a.metadata_file_path.cmp(&b.metadata_file_path));
-    metadata_files.dedup_by(|a, b| a.metadata_file_path == b.metadata_file_path);
-
-    Ok(metadata_files)
-}

crates/core/src/helpers/mod.rs

@@ -1,9 +1,7 @@
 mod cached_compiler;
-mod metadata;
 mod pool;
 mod test;
 
 pub use cached_compiler::*;
-pub use metadata::*;
 pub use pool::*;
 pub use test::*;

crates/core/src/helpers/pool.rs

@@ -2,9 +2,9 @@
 
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use crate::Platform;
 use anyhow::Context as _;
 use revive_dt_config::*;
+use revive_dt_core::Platform;
 use revive_dt_node_interaction::EthereumNode;
 
 /// The node pool starts one or more [Node] which then can be accessed

crates/core/src/helpers/test.rs

@@ -1,55 +1,52 @@
-use std::{borrow::Cow, collections::BTreeMap, path::Path, sync::Arc};
+use std::collections::BTreeMap;
+use std::sync::Arc;
+use std::{borrow::Cow, path::Path};
 
 use futures::{Stream, StreamExt, stream};
 use indexmap::{IndexMap, indexmap};
-use revive_dt_common::{iterators::EitherIter, types::PlatformIdentifier};
+use revive_dt_common::types::PlatformIdentifier;
 use revive_dt_config::Context;
-use revive_dt_format::mode::ParsedMode;
+use revive_dt_format::corpus::Corpus;
 use serde_json::{Value, json};
 
-use revive_dt_compiler::{Mode, SolidityCompiler};
+use revive_dt_compiler::Mode;
+use revive_dt_compiler::SolidityCompiler;
 use revive_dt_format::{
     case::{Case, CaseIdx},
     metadata::MetadataFile,
 };
 use revive_dt_node_interaction::EthereumNode;
-use revive_dt_report::{ExecutionSpecificReporter, Reporter, TestSpecificReporter, TestSpecifier};
+use revive_dt_report::{ExecutionSpecificReporter, Report, Reporter, TestCaseStatus};
+use revive_dt_report::{TestSpecificReporter, TestSpecifier};
 use tracing::{debug, error, info};
 
-use crate::{Platform, helpers::NodePool};
+use crate::Platform;
+use crate::helpers::NodePool;
 
 pub async fn create_test_definitions_stream<'a>(
     // This is only required for creating the compiler objects and is not used anywhere else in the
     // function.
     context: &Context,
-    metadata_files: impl IntoIterator<Item = &'a MetadataFile>,
+    corpus: &'a Corpus,
     platforms_and_nodes: &'a BTreeMap<PlatformIdentifier, (&dyn Platform, NodePool)>,
+    only_execute_failed_tests: Option<&Report>,
     reporter: Reporter,
 ) -> impl Stream<Item = TestDefinition<'a>> {
+    let cloned_reporter = reporter.clone();
     stream::iter(
-        metadata_files
+        corpus
-            .into_iter()
+            .cases_iterator()
-            // Flatten over the cases.
+            .inspect(move |(metadata_file, ..)| {
-            .flat_map(|metadata_file| {
+                cloned_reporter
-                metadata_file
+                    .report_metadata_file_discovery_event(
-                    .cases
+                        metadata_file.metadata_file_path.clone(),
-                    .iter()
+                        metadata_file.content.clone(),
-                    .enumerate()
+                    )
-                    .map(move |(case_idx, case)| (metadata_file, case_idx, case))
+                    .unwrap();
             })
-            // Flatten over the modes, prefer the case modes over the metadata file modes.
+            .map(move |(metadata_file, case_idx, case, mode)| {
-            .flat_map(move |(metadata_file, case_idx, case)| {
                 let reporter = reporter.clone();
 
-                let modes = case.modes.as_ref().or(metadata_file.modes.as_ref());
-                let modes = match modes {
-                    Some(modes) => EitherIter::A(
-                        ParsedMode::many_to_modes(modes.iter()).map(Cow::<'static, _>::Owned),
-                    ),
-                    None => EitherIter::B(Mode::all().map(Cow::<'static, _>::Borrowed)),
-                };
-
-                modes.into_iter().map(move |mode| {
                 (
                     metadata_file,
                     case_idx,
@@ -62,9 +59,8 @@ pub async fn create_test_definitions_stream<'a>(
                     })),
                 )
             })
-            })
+            // Inform the reporter of each one of the test cases that were discovered which we expect to
-            // Inform the reporter of each one of the test cases that were discovered which we
+            // run.
-            // expect to run.
             .inspect(|(_, _, _, _, reporter)| {
                 reporter
                     .report_test_case_discovery_event()
@@ -134,7 +130,7 @@ pub async fn create_test_definitions_stream<'a>(
     )
     // Filter out the test cases which are incompatible or that can't run in the current setup.
     .filter_map(move |test| async move {
-        match test.check_compatibility() {
+        match test.check_compatibility(only_execute_failed_tests) {
             Ok(()) => Some(test),
             Err((reason, additional_information)) => {
                 debug!(
@@ -194,12 +190,16 @@ pub struct TestDefinition<'a> {
 
 impl<'a> TestDefinition<'a> {
     /// Checks if this test can be ran with the current configuration.
-    pub fn check_compatibility(&self) -> TestCheckFunctionResult {
+    pub fn check_compatibility(
+        &self,
+        only_execute_failed_tests: Option<&Report>,
+    ) -> TestCheckFunctionResult {
         self.check_metadata_file_ignored()?;
         self.check_case_file_ignored()?;
         self.check_target_compatibility()?;
         self.check_evm_version_compatibility()?;
         self.check_compiler_compatibility()?;
+        self.check_ignore_succeeded(only_execute_failed_tests)?;
         Ok(())
     }
 
@@ -307,6 +307,36 @@ impl<'a> TestDefinition<'a> {
             ))
         }
     }
+
+    /// Checks if the test case should be executed or not based on the passed report and whether the
+    /// user has instructed the tool to ignore the already succeeding test cases.
+    fn check_ignore_succeeded(
+        &self,
+        only_execute_failed_tests: Option<&Report>,
+    ) -> TestCheckFunctionResult {
+        let Some(report) = only_execute_failed_tests else {
+            return Ok(());
+        };
+
+        let test_case_status = report
+            .execution_information
+            .get(&(self.metadata_file_path.to_path_buf().into()))
+            .and_then(|obj| obj.case_reports.get(&self.case_idx))
+            .and_then(|obj| obj.mode_execution_reports.get(&self.mode))
+            .and_then(|obj| obj.status.as_ref());
+
+        match test_case_status {
+            Some(TestCaseStatus::Failed { .. }) => Ok(()),
+            Some(TestCaseStatus::Ignored { .. }) => Err((
+                "Ignored since it was ignored in a previous run",
+                indexmap! {},
+            )),
+            Some(TestCaseStatus::Succeeded { .. }) => {
+                Err(("Ignored since it succeeded in a prior run", indexmap! {}))
+            }
+            None => Ok(()),
+        }
+    }
 }
 
 pub struct TestPlatformInformation<'a> {

crates/core/src/lib.rs

@@ -3,9 +3,6 @@
 //! This crate defines the testing configuration and
 //! provides a helper utility to execute tests.
 
-pub mod differential_tests;
-pub mod helpers;
-
 use std::{
     pin::Pin,
     thread::{self, JoinHandle},
@@ -17,17 +14,13 @@ use revive_dt_common::types::*;
 use revive_dt_compiler::{SolidityCompiler, revive_resolc::Resolc, solc::Solc};
 use revive_dt_config::*;
 use revive_dt_node::{
-    Node,
+    Node, node_implementations::geth::GethNode,
-    node_implementations::{
+    node_implementations::lighthouse_geth::LighthouseGethNode,
-        geth::GethNode, lighthouse_geth::LighthouseGethNode, substrate::SubstrateNode,
+    node_implementations::substrate::SubstrateNode, node_implementations::zombienet::ZombienetNode,
-        zombienet::ZombieNode,
-    },
 };
 use revive_dt_node_interaction::EthereumNode;
 use tracing::info;
 
-pub use helpers::CachedCompiler;
-
 /// A trait that describes the interface for the platforms that are supported by the tool.
 #[allow(clippy::type_complexity)]
 pub trait Platform {
@@ -66,6 +59,9 @@ pub trait Platform {
         context: Context,
         version: Option<VersionOrRequirement>,
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<Box<dyn SolidityCompiler>>>>>;
+
+    /// Exports the genesis/chainspec for the node.
+    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value>;
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
@@ -111,6 +107,15 @@ impl Platform for GethEvmSolcPlatform {
             compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
         })
     }
+
+    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
+        let genesis = AsRef::<GenesisConfiguration>::as_ref(&context).genesis()?;
+        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
+
+        let node_genesis = GethNode::node_genesis(genesis.clone(), &wallet);
+        serde_json::to_value(node_genesis)
+            .context("Failed to convert node genesis to a serde_value")
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
@@ -156,109 +161,14 @@ impl Platform for LighthouseGethEvmSolcPlatform {
             compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
         })
     }
-}
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
+    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
-pub struct KitchensinkPolkavmResolcPlatform;
+        let genesis = AsRef::<GenesisConfiguration>::as_ref(&context).genesis()?;
+        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
 
-impl Platform for KitchensinkPolkavmResolcPlatform {
+        let node_genesis = LighthouseGethNode::node_genesis(genesis.clone(), &wallet);
-    fn platform_identifier(&self) -> PlatformIdentifier {
+        serde_json::to_value(node_genesis)
-        PlatformIdentifier::KitchensinkPolkavmResolc
+            .context("Failed to convert node genesis to a serde_value")
-    }
-
-    fn node_identifier(&self) -> NodeIdentifier {
-        NodeIdentifier::Kitchensink
-    }
-
-    fn vm_identifier(&self) -> VmIdentifier {
-        VmIdentifier::PolkaVM
-    }
-
-    fn compiler_identifier(&self) -> CompilerIdentifier {
-        CompilerIdentifier::Resolc
-    }
-
-    fn new_node(
-        &self,
-        context: Context,
-    ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
-        let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-        let kitchensink_path = AsRef::<KitchensinkConfiguration>::as_ref(&context)
-            .path
-            .clone();
-        let genesis = genesis_configuration.genesis()?.clone();
-        Ok(thread::spawn(move || {
-            let node = SubstrateNode::new(
-                kitchensink_path,
-                SubstrateNode::KITCHENSINK_EXPORT_CHAINSPEC_COMMAND,
-                context,
-            );
-            let node = spawn_node(node, genesis)?;
-            Ok(Box::new(node) as Box<_>)
-        }))
-    }
-
-    fn new_compiler(
-        &self,
-        context: Context,
-        version: Option<VersionOrRequirement>,
-    ) -> Pin<Box<dyn Future<Output = anyhow::Result<Box<dyn SolidityCompiler>>>>> {
-        Box::pin(async move {
-            let compiler = Resolc::new(context, version).await;
-            compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
-        })
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
-pub struct KitchensinkRevmSolcPlatform;
-
-impl Platform for KitchensinkRevmSolcPlatform {
-    fn platform_identifier(&self) -> PlatformIdentifier {
-        PlatformIdentifier::KitchensinkRevmSolc
-    }
-
-    fn node_identifier(&self) -> NodeIdentifier {
-        NodeIdentifier::Kitchensink
-    }
-
-    fn vm_identifier(&self) -> VmIdentifier {
-        VmIdentifier::Evm
-    }
-
-    fn compiler_identifier(&self) -> CompilerIdentifier {
-        CompilerIdentifier::Solc
-    }
-
-    fn new_node(
-        &self,
-        context: Context,
-    ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
-        let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-        let kitchensink_path = AsRef::<KitchensinkConfiguration>::as_ref(&context)
-            .path
-            .clone();
-        let genesis = genesis_configuration.genesis()?.clone();
-        Ok(thread::spawn(move || {
-            let node = SubstrateNode::new(
-                kitchensink_path,
-                SubstrateNode::KITCHENSINK_EXPORT_CHAINSPEC_COMMAND,
-                context,
-            );
-            let node = spawn_node(node, genesis)?;
-            Ok(Box::new(node) as Box<_>)
-        }))
-    }
-
-    fn new_compiler(
-        &self,
-        context: Context,
-        version: Option<VersionOrRequirement>,
-    ) -> Pin<Box<dyn Future<Output = anyhow::Result<Box<dyn SolidityCompiler>>>>> {
-        Box::pin(async move {
-            let compiler = Solc::new(context, version).await;
-            compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
-        })
     }
 }
 
@@ -287,15 +197,21 @@ impl Platform for ReviveDevNodePolkavmResolcPlatform {
         context: Context,
     ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
         let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-        let revive_dev_node_path = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context)
+        let revive_dev_node_configuration = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context);
-            .path
+
-            .clone();
+        let revive_dev_node_path = revive_dev_node_configuration.path.clone();
+        let revive_dev_node_consensus = revive_dev_node_configuration.consensus.clone();
+
+        let eth_rpc_connection_strings = revive_dev_node_configuration.existing_rpc_url.clone();
+
         let genesis = genesis_configuration.genesis()?.clone();
         Ok(thread::spawn(move || {
             let node = SubstrateNode::new(
                 revive_dev_node_path,
                 SubstrateNode::REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND,
+                Some(revive_dev_node_consensus),
                 context,
+                &eth_rpc_connection_strings,
             );
             let node = spawn_node(node, genesis)?;
             Ok(Box::new(node) as Box<_>)
@@ -312,6 +228,16 @@ impl Platform for ReviveDevNodePolkavmResolcPlatform {
             compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
         })
     }
+
+    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
+        let revive_dev_node_path = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context)
+            .path
+            .as_path();
+        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
+        let export_chainspec_command = SubstrateNode::REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND;
+
+        SubstrateNode::node_genesis(revive_dev_node_path, export_chainspec_command, &wallet)
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
@@ -339,15 +265,21 @@ impl Platform for ReviveDevNodeRevmSolcPlatform {
         context: Context,
     ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
         let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-        let revive_dev_node_path = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context)
+        let revive_dev_node_configuration = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context);
-            .path
+
-            .clone();
+        let revive_dev_node_path = revive_dev_node_configuration.path.clone();
+        let revive_dev_node_consensus = revive_dev_node_configuration.consensus.clone();
+
+        let eth_rpc_connection_strings = revive_dev_node_configuration.existing_rpc_url.clone();
+
         let genesis = genesis_configuration.genesis()?.clone();
         Ok(thread::spawn(move || {
             let node = SubstrateNode::new(
                 revive_dev_node_path,
                 SubstrateNode::REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND,
+                Some(revive_dev_node_consensus),
                 context,
+                &eth_rpc_connection_strings,
             );
             let node = spawn_node(node, genesis)?;
             Ok(Box::new(node) as Box<_>)
@@ -364,6 +296,16 @@ impl Platform for ReviveDevNodeRevmSolcPlatform {
             compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
         })
     }
+
+    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
+        let revive_dev_node_path = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context)
+            .path
+            .as_path();
+        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
+        let export_chainspec_command = SubstrateNode::REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND;
+
+        SubstrateNode::node_genesis(revive_dev_node_path, export_chainspec_command, &wallet)
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
@@ -396,7 +338,7 @@ impl Platform for ZombienetPolkavmResolcPlatform {
             .clone();
         let genesis = genesis_configuration.genesis()?.clone();
         Ok(thread::spawn(move || {
-            let node = ZombieNode::new(polkadot_parachain_path, context);
+            let node = ZombienetNode::new(polkadot_parachain_path, context);
             let node = spawn_node(node, genesis)?;
             Ok(Box::new(node) as Box<_>)
         }))
@@ -408,10 +350,19 @@ impl Platform for ZombienetPolkavmResolcPlatform {
         version: Option<VersionOrRequirement>,
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<Box<dyn SolidityCompiler>>>>> {
         Box::pin(async move {
-            let compiler = Solc::new(context, version).await;
+            let compiler = Resolc::new(context, version).await;
             compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
         })
     }
+
+    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
+        let polkadot_parachain_path = AsRef::<PolkadotParachainConfiguration>::as_ref(&context)
+            .path
+            .as_path();
+        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
+
+        ZombienetNode::node_genesis(polkadot_parachain_path, &wallet)
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
@@ -444,7 +395,7 @@ impl Platform for ZombienetRevmSolcPlatform {
             .clone();
         let genesis = genesis_configuration.genesis()?.clone();
         Ok(thread::spawn(move || {
-            let node = ZombieNode::new(polkadot_parachain_path, context);
+            let node = ZombienetNode::new(polkadot_parachain_path, context);
             let node = spawn_node(node, genesis)?;
             Ok(Box::new(node) as Box<_>)
         }))
@@ -460,6 +411,15 @@ impl Platform for ZombienetRevmSolcPlatform {
             compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
         })
     }
+
+    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
+        let polkadot_parachain_path = AsRef::<PolkadotParachainConfiguration>::as_ref(&context)
+            .path
+            .as_path();
+        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
+
+        ZombienetNode::node_genesis(polkadot_parachain_path, &wallet)
+    }
 }
 
 impl From<PlatformIdentifier> for Box<dyn Platform> {
@@ -469,12 +429,6 @@ impl From<PlatformIdentifier> for Box<dyn Platform> {
             PlatformIdentifier::LighthouseGethEvmSolc => {
                 Box::new(LighthouseGethEvmSolcPlatform) as Box<_>
             }
-            PlatformIdentifier::KitchensinkPolkavmResolc => {
-                Box::new(KitchensinkPolkavmResolcPlatform) as Box<_>
-            }
-            PlatformIdentifier::KitchensinkRevmSolc => {
-                Box::new(KitchensinkRevmSolcPlatform) as Box<_>
-            }
             PlatformIdentifier::ReviveDevNodePolkavmResolc => {
                 Box::new(ReviveDevNodePolkavmResolcPlatform) as Box<_>
             }
@@ -496,12 +450,6 @@ impl From<PlatformIdentifier> for &dyn Platform {
             PlatformIdentifier::LighthouseGethEvmSolc => {
                 &LighthouseGethEvmSolcPlatform as &dyn Platform
             }
-            PlatformIdentifier::KitchensinkPolkavmResolc => {
-                &KitchensinkPolkavmResolcPlatform as &dyn Platform
-            }
-            PlatformIdentifier::KitchensinkRevmSolc => {
-                &KitchensinkRevmSolcPlatform as &dyn Platform
-            }
             PlatformIdentifier::ReviveDevNodePolkavmResolc => {
                 &ReviveDevNodePolkavmResolcPlatform as &dyn Platform
             }

crates/core/src/main.rs

@@ -2,10 +2,11 @@ mod differential_benchmarks;
 mod differential_tests;
 mod helpers;
 
+use anyhow::Context as _;
 use clap::Parser;
 use revive_dt_report::ReportAggregator;
 use schemars::schema_for;
-use tracing::info;
+use tracing::{info, level_filters::LevelFilter};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
 use revive_dt_config::Context;
@@ -30,14 +31,20 @@ fn main() -> anyhow::Result<()> {
         .with_writer(writer)
         .with_thread_ids(false)
         .with_thread_names(false)
-        .with_env_filter(EnvFilter::from_default_env())
+        .with_env_filter(
+            EnvFilter::builder()
+                .with_default_directive(LevelFilter::OFF.into())
+                .from_env_lossy(),
+        )
         .with_ansi(false)
         .pretty()
         .finish();
     tracing::subscriber::set_global_default(subscriber)?;
     info!("Differential testing tool is starting");
 
-    let context = Context::try_parse()?;
+    let mut context = Context::try_parse()?;
+    context.update_for_profile();
+
     let (reporter, report_aggregator_task) = ReportAggregator::new(context.clone()).into_task();
 
     match context {
@@ -72,6 +79,14 @@ fn main() -> anyhow::Result<()> {
 
                 Ok(())
             }),
+        Context::ExportGenesis(ref export_genesis_context) => {
+            let platform = Into::<&dyn Platform>::into(export_genesis_context.platform);
+            let genesis = platform.export_genesis(context)?;
+            let genesis_json = serde_json::to_string_pretty(&genesis)
+                .context("Failed to serialize the genesis to JSON")?;
+            println!("{genesis_json}");
+            Ok(())
+        }
         Context::ExportJsonSchema => {
             let schema = schema_for!(Metadata);
             println!("{}", serde_json::to_string_pretty(&schema).unwrap());

crates/format/Cargo.toml

@@ -16,12 +16,12 @@ revive-common = { workspace = true }
 alloy = { workspace = true }
 anyhow = { workspace = true }
 futures = { workspace = true }
-regex = { workspace = true }
 tracing = { workspace = true }
 schemars = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+itertools = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true }

crates/format/src/case.rs

@@ -1,9 +1,13 @@
+use alloy::primitives::Address;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use revive_dt_common::{macros::define_wrapper_type, types::Mode};
+use revive_dt_common::{
+    macros::define_wrapper_type,
+    types::{Mode, ParsedMode},
+};
 
-use crate::{mode::ParsedMode, steps::*};
+use crate::steps::*;
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq, JsonSchema)]
 pub struct Case {
@@ -45,8 +49,8 @@ pub struct Case {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub expected: Option<Expected>,
 
-    /// An optional boolean which defines if the case as a whole should be ignored. If null then
+    /// An optional boolean which defines if the case as a whole should be ignored. If null then the
-    /// the case will not be ignored.
+    /// case will not be ignored.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ignore: Option<bool>,
 }
@@ -104,6 +108,20 @@ impl Case {
             None => Mode::all().cloned().collect(),
         }
     }
+
+    pub fn deployer_address(&self) -> Address {
+        self.steps
+            .iter()
+            .filter_map(|step| match step {
+                Step::FunctionCall(input) => input.caller.as_address().copied(),
+                Step::BalanceAssertion(..) => None,
+                Step::StorageEmptyAssertion(..) => None,
+                Step::Repeat(..) => None,
+                Step::AllocateAccount(..) => None,
+            })
+            .next()
+            .unwrap_or(FunctionCallStep::default_caller_address())
+    }
 }
 
 define_wrapper_type!(

crates/format/src/corpus.rs

@@ -1,56 +1,167 @@
 use std::{
-    fs::File,
+    borrow::Cow,
+    collections::HashMap,
     path::{Path, PathBuf},
 };
 
-use revive_dt_common::iterators::FilesWithExtensionIterator;
+use itertools::Itertools;
-use serde::{Deserialize, Serialize};
+use revive_dt_common::{
-use tracing::{debug, info};
+    iterators::{EitherIter, FilesWithExtensionIterator},
+    types::{Mode, ParsedMode, ParsedTestSpecifier},
+};
+use tracing::{debug, warn};
 
-use crate::metadata::{Metadata, MetadataFile};
+use crate::{
-use anyhow::Context as _;
+    case::{Case, CaseIdx},
+    metadata::{Metadata, MetadataFile},
+};
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[derive(Default)]
-#[serde(untagged)]
+pub struct Corpus {
-pub enum Corpus {
+    test_specifiers: HashMap<ParsedTestSpecifier, Vec<PathBuf>>,
-    SinglePath { name: String, path: PathBuf },
+    metadata_files: HashMap<PathBuf, MetadataFile>,
-    MultiplePaths { name: String, paths: Vec<PathBuf> },
 }
 
 impl Corpus {
-    pub fn try_from_path(file_path: impl AsRef<Path>) -> anyhow::Result<Self> {
+    pub fn new() -> Self {
-        let mut corpus = File::open(file_path.as_ref())
+        Default::default()
-            .map_err(anyhow::Error::from)
+    }
-            .and_then(|file| serde_json::from_reader::<_, Corpus>(file).map_err(Into::into))
+
-            .with_context(|| {
+    pub fn with_test_specifier(
-                format!(
+        mut self,
-                    "Failed to open and deserialize corpus file at {}",
+        test_specifier: ParsedTestSpecifier,
-                    file_path.as_ref().display()
+    ) -> anyhow::Result<Self> {
+        match &test_specifier {
+            ParsedTestSpecifier::FileOrDirectory {
+                metadata_or_directory_file_path: metadata_file_path,
+            }
+            | ParsedTestSpecifier::Case {
+                metadata_file_path, ..
+            }
+            | ParsedTestSpecifier::CaseWithMode {
+                metadata_file_path, ..
+            } => {
+                let metadata_files = enumerate_metadata_files(metadata_file_path);
+                self.test_specifiers.insert(
+                    test_specifier,
+                    metadata_files
+                        .iter()
+                        .map(|metadata_file| metadata_file.metadata_file_path.clone())
+                        .collect(),
+                );
+                for metadata_file in metadata_files.into_iter() {
+                    self.metadata_files
+                        .insert(metadata_file.metadata_file_path.clone(), metadata_file);
+                }
+            }
+        };
+
+        Ok(self)
+    }
+
+    pub fn cases_iterator(
+        &self,
+    ) -> impl Iterator<Item = (&'_ MetadataFile, CaseIdx, &'_ Case, Cow<'_, Mode>)> + '_ {
+        let mut iterator = Box::new(std::iter::empty())
+            as Box<dyn Iterator<Item = (&'_ MetadataFile, CaseIdx, &'_ Case, Cow<'_, Mode>)> + '_>;
+
+        for (test_specifier, metadata_file_paths) in self.test_specifiers.iter() {
+            for metadata_file_path in metadata_file_paths {
+                let metadata_file = self
+                    .metadata_files
+                    .get(metadata_file_path)
+                    .expect("Must succeed");
+
+                match test_specifier {
+                    ParsedTestSpecifier::FileOrDirectory { .. } => {
+                        for (case_idx, case) in metadata_file.cases.iter().enumerate() {
+                            let case_idx = CaseIdx::new(case_idx);
+
+                            let modes = case.modes.as_ref().or(metadata_file.modes.as_ref());
+                            let modes = match modes {
+                                Some(modes) => EitherIter::A(
+                                    ParsedMode::many_to_modes(modes.iter())
+                                        .map(Cow::<'static, _>::Owned),
+                                ),
+                                None => EitherIter::B(Mode::all().map(Cow::<'static, _>::Borrowed)),
+                            };
+
+                            iterator = Box::new(
+                                iterator.chain(
+                                    modes
+                                        .into_iter()
+                                        .map(move |mode| (metadata_file, case_idx, case, mode)),
+                                ),
                             )
-            })?;
+                        }
+                    }
+                    ParsedTestSpecifier::Case { case_idx, .. } => {
+                        let Some(case) = metadata_file.cases.get(*case_idx) else {
+                            warn!(
+                                test_specifier = %test_specifier,
+                                metadata_file_path = %metadata_file_path.display(),
+                                case_idx = case_idx,
+                                case_count = metadata_file.cases.len(),
+                                "Specified case not found in metadata file"
+                            );
+                            continue;
+                        };
+                        let case_idx = CaseIdx::new(*case_idx);
 
-        let corpus_directory = file_path
+                        let modes = case.modes.as_ref().or(metadata_file.modes.as_ref());
-            .as_ref()
+                        let modes = match modes {
-            .canonicalize()
+                            Some(modes) => EitherIter::A(
-            .context("Failed to canonicalize the path to the corpus file")?
+                                ParsedMode::many_to_modes(modes.iter())
-            .parent()
+                                    .map(Cow::<'static, Mode>::Owned),
-            .context("Corpus file has no parent")?
+                            ),
-            .to_path_buf();
+                            None => EitherIter::B(Mode::all().map(Cow::<'static, _>::Borrowed)),
+                        };
 
-        for path in corpus.paths_iter_mut() {
+                        iterator = Box::new(
-            *path = corpus_directory.join(path.as_path())
+                            iterator.chain(
+                                modes
+                                    .into_iter()
+                                    .map(move |mode| (metadata_file, case_idx, case, mode)),
+                            ),
+                        )
+                    }
+                    ParsedTestSpecifier::CaseWithMode { case_idx, mode, .. } => {
+                        let Some(case) = metadata_file.cases.get(*case_idx) else {
+                            warn!(
+                                test_specifier = %test_specifier,
+                                metadata_file_path = %metadata_file_path.display(),
+                                case_idx = case_idx,
+                                case_count = metadata_file.cases.len(),
+                                "Specified case not found in metadata file"
+                            );
+                            continue;
+                        };
+                        let case_idx = CaseIdx::new(*case_idx);
+
+                        let mode = Cow::Borrowed(mode);
+                        iterator = Box::new(iterator.chain(std::iter::once((
+                            metadata_file,
+                            case_idx,
+                            case,
+                            mode,
+                        ))))
+                    }
+                }
+            }
         }
 
-        Ok(corpus)
+        iterator.unique_by(|item| (&item.0.metadata_file_path, item.1, item.3.clone()))
     }
 
-    pub fn enumerate_tests(&self) -> Vec<MetadataFile> {
+    pub fn metadata_file_count(&self) -> usize {
-        let mut tests = self
+        self.metadata_files.len()
-            .paths_iter()
+    }
-            .flat_map(|root_path| {
+}
-                if !root_path.is_dir() {
+
-                    Box::new(std::iter::once(root_path.to_path_buf()))
+fn enumerate_metadata_files(path: impl AsRef<Path>) -> Vec<MetadataFile> {
-                        as Box<dyn Iterator<Item = _>>
+    let root_path = path.as_ref();
+    let mut tests = 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)
@@ -60,7 +171,6 @@ impl Corpus {
         )
     }
     .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(|| {
@@ -86,46 +196,5 @@ impl Corpus {
     .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> {
-        match self {
-            Corpus::SinglePath { path, .. } => {
-                Box::new(std::iter::once(path.as_path())) as Box<dyn Iterator<Item = _>>
-            }
-            Corpus::MultiplePaths { paths, .. } => {
-                Box::new(paths.iter().map(|path| path.as_path())) as Box<dyn Iterator<Item = _>>
-            }
-        }
-    }
-
-    pub fn paths_iter_mut(&mut self) -> impl Iterator<Item = &mut PathBuf> {
-        match self {
-            Corpus::SinglePath { path, .. } => {
-                Box::new(std::iter::once(path)) as Box<dyn Iterator<Item = _>>
-            }
-            Corpus::MultiplePaths { paths, .. } => {
-                Box::new(paths.iter_mut()) as Box<dyn Iterator<Item = _>>
-            }
-        }
-    }
-
-    pub fn path_count(&self) -> usize {
-        match self {
-            Corpus::SinglePath { .. } => 1,
-            Corpus::MultiplePaths { paths, .. } => paths.len(),
-        }
-    }
 }

crates/format/src/lib.rs

@@ -3,6 +3,5 @@
 pub mod case;
 pub mod corpus;
 pub mod metadata;
-pub mod mode;
 pub mod steps;
 pub mod traits;

crates/format/src/metadata.rs

@@ -16,11 +16,11 @@ use revive_dt_common::{
     cached_fs::read_to_string,
     iterators::FilesWithExtensionIterator,
     macros::define_wrapper_type,
-    types::{Mode, VmIdentifier},
+    types::{Mode, ParsedMode, VmIdentifier},
 };
 use tracing::error;
 
-use crate::{case::Case, mode::ParsedMode};
+use crate::case::Case;
 
 pub const METADATA_FILE_EXTENSION: &str = "json";
 pub const SOLIDITY_CASE_FILE_EXTENSION: &str = "sol";
@@ -31,8 +31,8 @@ pub struct MetadataFile {
     /// The path of the metadata file. This will either be a JSON or solidity file.
     pub metadata_file_path: PathBuf,
 
-    /// This is the path contained within the corpus file. This could either be the path of some
+    /// This is the path contained within the corpus file. This could either be the path of some dir
-    /// dir or could be the actual metadata file path.
+    /// or could be the actual metadata file path.
     pub corpus_file_path: PathBuf,
 
     /// The metadata contained within the file.
@@ -69,13 +69,13 @@ impl Deref for MetadataFile {
 /// of steps and assertions that should be performed as part of the test case.
 #[derive(Debug, Default, Serialize, Deserialize, JsonSchema, Clone, Eq, PartialEq)]
 pub struct Metadata {
-    /// This is an optional comment on the metadata file which has no impact on the execution in
+    /// This is an optional comment on the metadata file which has no impact on the execution in any
-    /// any way.
+    /// way.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
 
-    /// An optional boolean which defines if the metadata file as a whole should be ignored. If
+    /// An optional boolean which defines if the metadata file as a whole should be ignored. If null
-    /// null then the metadata file will not be ignored.
+    /// then the metadata file will not be ignored.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ignore: Option<bool>,
 
@@ -94,8 +94,8 @@ pub struct Metadata {
     /// This is a map where the key is the name of the contract instance and the value is the
     /// contract's path and ident in the file.
     ///
-    /// If any contract is to be used by the test then it must be included in here first so that
+    /// If any contract is to be used by the test then it must be included in here first so that the
-    /// the framework is aware of its path, compiles it, and prepares it.
+    /// framework is aware of its path, compiles it, and prepares it.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdent>>,
 
@@ -123,9 +123,8 @@ pub struct Metadata {
     pub required_evm_version: Option<EvmVersionRequirement>,
 
     /// A set of compilation directives that will be passed to the compiler whenever the contracts
-    /// for the test are being compiled. Note that this differs from the [`Mode`]s in that a
+    /// for the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`]
-    /// [`Mode`] is just a filter for when a test can run whereas this is an instruction to the
+    /// is just a filter for when a test can run whereas this is an instruction to the compiler.
-    /// compiler.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub compiler_directives: Option<CompilationDirectives>,
 }
@@ -327,8 +326,7 @@ define_wrapper_type!(
 )]
 #[serde(try_from = "String", into = "String")]
 pub struct ContractPathAndIdent {
-    /// The path of the contract source code relative to the directory containing the metadata
+    /// The path of the contract source code relative to the directory containing the metadata file.
-    /// file.
     pub contract_source_path: PathBuf,
 
     /// The identifier of the contract.

crates/format/src/mode.rs

@@ -1,256 +0,0 @@
-use anyhow::Context as _;
-use regex::Regex;
-use revive_dt_common::{
-    iterators::EitherIter,
-    types::{Mode, ModeOptimizerSetting, ModePipeline},
-};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::{collections::HashSet, fmt::Display, str::FromStr, sync::LazyLock};
-
-/// This represents a mode that has been parsed from test metadata.
-///
-/// Mode strings can take the following form (in pseudo-regex):
-///
-/// ```text
-/// [YEILV][+-]? (M[0123sz])? <semver>?
-/// ```
-///
-/// We can parse valid mode strings into [`ParsedMode`] using [`ParsedMode::from_str`].
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, JsonSchema)]
-#[serde(try_from = "String", into = "String")]
-pub struct ParsedMode {
-    pub pipeline: Option<ModePipeline>,
-    pub optimize_flag: Option<bool>,
-    pub optimize_setting: Option<ModeOptimizerSetting>,
-    pub version: Option<semver::VersionReq>,
-}
-
-impl FromStr for ParsedMode {
-    type Err = anyhow::Error;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        static REGEX: LazyLock<Regex> = LazyLock::new(|| {
-            Regex::new(r"(?x)
-                ^
-                (?:(?P<pipeline>[YEILV])(?P<optimize_flag>[+-])?)? # Pipeline to use eg Y, E+, E-
-                \s*
-                (?P<optimize_setting>M[a-zA-Z0-9])?                # Optimize setting eg M0, Ms, Mz
-                \s*
-                (?P<version>[>=<]*\d+(?:\.\d+)*)?                  # Optional semver version eg >=0.8.0, 0.7, <0.8
-                $
-            ").unwrap()
-        });
-
-        let Some(caps) = REGEX.captures(s) else {
-            anyhow::bail!("Cannot parse mode '{s}' from string");
-        };
-
-        let pipeline = match caps.name("pipeline") {
-            Some(m) => Some(
-                ModePipeline::from_str(m.as_str())
-                    .context("Failed to parse mode pipeline from string")?,
-            ),
-            None => None,
-        };
-
-        let optimize_flag = caps.name("optimize_flag").map(|m| m.as_str() == "+");
-
-        let optimize_setting = match caps.name("optimize_setting") {
-            Some(m) => Some(
-                ModeOptimizerSetting::from_str(m.as_str())
-                    .context("Failed to parse optimizer setting from string")?,
-            ),
-            None => None,
-        };
-
-        let version = match caps.name("version") {
-            Some(m) => Some(
-                semver::VersionReq::parse(m.as_str())
-                    .map_err(|e| {
-                        anyhow::anyhow!(
-                            "Cannot parse the version requirement '{}': {e}",
-                            m.as_str()
-                        )
-                    })
-                    .context("Failed to parse semver requirement from mode string")?,
-            ),
-            None => None,
-        };
-
-        Ok(ParsedMode {
-            pipeline,
-            optimize_flag,
-            optimize_setting,
-            version,
-        })
-    }
-}
-
-impl Display for ParsedMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut has_written = false;
-
-        if let Some(pipeline) = self.pipeline {
-            pipeline.fmt(f)?;
-            if let Some(optimize_flag) = self.optimize_flag {
-                f.write_str(if optimize_flag { "+" } else { "-" })?;
-            }
-            has_written = true;
-        }
-
-        if let Some(optimize_setting) = self.optimize_setting {
-            if has_written {
-                f.write_str(" ")?;
-            }
-            optimize_setting.fmt(f)?;
-            has_written = true;
-        }
-
-        if let Some(version) = &self.version {
-            if has_written {
-                f.write_str(" ")?;
-            }
-            version.fmt(f)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl From<ParsedMode> for String {
-    fn from(parsed_mode: ParsedMode) -> Self {
-        parsed_mode.to_string()
-    }
-}
-
-impl TryFrom<String> for ParsedMode {
-    type Error = anyhow::Error;
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        ParsedMode::from_str(&value)
-    }
-}
-
-impl ParsedMode {
-    /// This takes a [`ParsedMode`] and expands it into a list of [`Mode`]s that we should try.
-    pub fn to_modes(&self) -> impl Iterator<Item = Mode> {
-        let pipeline_iter = self.pipeline.as_ref().map_or_else(
-            || EitherIter::A(ModePipeline::test_cases()),
-            |p| EitherIter::B(std::iter::once(*p)),
-        );
-
-        let optimize_flag_setting = self.optimize_flag.map(|flag| {
-            if flag {
-                ModeOptimizerSetting::M3
-            } else {
-                ModeOptimizerSetting::M0
-            }
-        });
-
-        let optimize_flag_iter = match optimize_flag_setting {
-            Some(setting) => EitherIter::A(std::iter::once(setting)),
-            None => EitherIter::B(ModeOptimizerSetting::test_cases()),
-        };
-
-        let optimize_settings_iter = self.optimize_setting.as_ref().map_or_else(
-            || EitherIter::A(optimize_flag_iter),
-            |s| EitherIter::B(std::iter::once(*s)),
-        );
-
-        pipeline_iter.flat_map(move |pipeline| {
-            optimize_settings_iter
-                .clone()
-                .map(move |optimize_setting| Mode {
-                    pipeline,
-                    optimize_setting,
-                    version: self.version.clone(),
-                })
-        })
-    }
-
-    /// Return a set of [`Mode`]s that correspond to the given [`ParsedMode`]s.
-    /// This avoids any duplicate entries.
-    pub fn many_to_modes<'a>(
-        parsed: impl Iterator<Item = &'a ParsedMode>,
-    ) -> impl Iterator<Item = Mode> {
-        let modes: HashSet<_> = parsed.flat_map(|p| p.to_modes()).collect();
-        modes.into_iter()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parsed_mode_from_str() {
-        let strings = vec![
-            ("Mz", "Mz"),
-            ("Y", "Y"),
-            ("Y+", "Y+"),
-            ("Y-", "Y-"),
-            ("E", "E"),
-            ("E+", "E+"),
-            ("E-", "E-"),
-            ("Y M0", "Y M0"),
-            ("Y M1", "Y M1"),
-            ("Y M2", "Y M2"),
-            ("Y M3", "Y M3"),
-            ("Y Ms", "Y Ms"),
-            ("Y Mz", "Y Mz"),
-            ("E M0", "E M0"),
-            ("E M1", "E M1"),
-            ("E M2", "E M2"),
-            ("E M3", "E M3"),
-            ("E Ms", "E Ms"),
-            ("E Mz", "E Mz"),
-            // When stringifying semver again, 0.8.0 becomes ^0.8.0 (same meaning)
-            ("Y 0.8.0", "Y ^0.8.0"),
-            ("E+ 0.8.0", "E+ ^0.8.0"),
-            ("Y M3 >=0.8.0", "Y M3 >=0.8.0"),
-            ("E Mz <0.7.0", "E Mz <0.7.0"),
-            // We can parse +- _and_ M1/M2 but the latter takes priority.
-            ("Y+ M1 0.8.0", "Y+ M1 ^0.8.0"),
-            ("E- M2 0.7.0", "E- M2 ^0.7.0"),
-            // We don't see this in the wild but it is parsed.
-            ("<=0.8", "<=0.8"),
-        ];
-
-        for (actual, expected) in strings {
-            let parsed = ParsedMode::from_str(actual)
-                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
-            assert_eq!(
-                expected,
-                parsed.to_string(),
-                "Mode string '{actual}' did not parse to '{expected}': got '{parsed}'"
-            );
-        }
-    }
-
-    #[test]
-    fn test_parsed_mode_to_test_modes() {
-        let strings = vec![
-            ("Mz", vec!["Y Mz", "E Mz"]),
-            ("Y", vec!["Y M0", "Y M3"]),
-            ("E", vec!["E M0", "E M3"]),
-            ("Y+", vec!["Y M3"]),
-            ("Y-", vec!["Y M0"]),
-            ("Y <=0.8", vec!["Y M0 <=0.8", "Y M3 <=0.8"]),
-            (
-                "<=0.8",
-                vec!["Y M0 <=0.8", "Y M3 <=0.8", "E M0 <=0.8", "E M3 <=0.8"],
-            ),
-        ];
-
-        for (actual, expected) in strings {
-            let parsed = ParsedMode::from_str(actual)
-                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
-            let expected_set: HashSet<_> = expected.into_iter().map(|s| s.to_owned()).collect();
-            let actual_set: HashSet<_> = parsed.to_modes().map(|m| m.to_string()).collect();
-
-            assert_eq!(
-                expected_set, actual_set,
-                "Mode string '{actual}' did not expand to '{expected_set:?}': got '{actual_set:?}'"
-            );
-        }
-    }
-}

crates/format/src/steps.rs

@@ -1,10 +1,12 @@
 use std::{collections::HashMap, fmt::Display, str::FromStr};
 
+use alloy::hex::ToHexExt;
+use alloy::primitives::{FixedBytes, utils::parse_units};
 use alloy::{
     eips::BlockNumberOrTag,
     json_abi::Function,
     network::TransactionBuilder,
-    primitives::{Address, Bytes, FixedBytes, U256, utils::parse_units},
+    primitives::{Address, Bytes, U256},
     rpc::types::TransactionRequest,
 };
 use anyhow::Context as _;
@@ -16,10 +18,8 @@ use serde::{Deserialize, Serialize};
 use revive_dt_common::macros::define_wrapper_type;
 use tracing::{Instrument, info_span, instrument};
 
-use crate::{
+use crate::traits::ResolverApi;
-    metadata::ContractInstance,
+use crate::{metadata::ContractInstance, traits::ResolutionContext};
-    traits::{ResolutionContext, ResolverApi},
-};
 
 /// A test step.
 ///
@@ -46,12 +46,12 @@ pub enum Step {
 }
 
 define_wrapper_type!(
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
     pub struct StepIdx(usize) impl Display, FromStr;
 );
 
 define_wrapper_type!(
-    #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
     #[serde(try_from = "String", into = "String")]
     pub struct StepPath(Vec<StepIdx>);
 );
@@ -148,8 +148,8 @@ pub struct FunctionCallStep {
     #[schemars(skip)]
     pub storage: Option<HashMap<String, Calldata>>,
 
-    /// Variable assignment to perform in the framework allowing us to reference them again later
+    /// Variable assignment to perform in the framework allowing us to reference them again later on
-    /// on during the execution.
+    /// during the execution.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub variable_assignments: Option<VariableAssignments>,
 }
@@ -489,13 +489,14 @@ impl FunctionCallStep {
                     anyhow::bail!("ABI for instance '{}' not found", self.instance.as_ref());
                 };
 
-                // We follow the same logic that's implemented in the matter-labs-tester where they
+                // We follow the same logic that's implemented in the matter-labs-tester where they resolve
-                // resolve the function name into a function selector and they assume that he
+                // the function name into a function selector and they assume that he function doesn't have
-                // function doesn't have any existing overloads.
+                // any existing overloads.
                 // Overloads are handled by providing the full function signature in the "function
                 // name".
                 // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
-                let selector = if function_name.contains('(') && function_name.contains(')') {
+                let selector =
+                    if function_name.contains('(') && function_name.contains(')') {
                         Function::parse(function_name)
                         .context(
                             "Failed to parse the provided function name into a function signature",
@@ -511,21 +512,19 @@ impl FunctionCallStep {
                                 &self.instance
                             )
                         })
-                        .with_context(|| {
+                        .with_context(|| format!(
-                            format!(
                             "Failed to resolve function selector for {:?} on instance {:?}",
                             function_name, &self.instance
-                            )
+                        ))?
-                        })?
                         .selector()
                     };
 
-                // Allocating a vector that we will be using for the calldata. The vector size will
+                // Allocating a vector that we will be using for the calldata. The vector size will be:
-                // be: 4 bytes for the function selector.
+                // 4 bytes for the function selector.
                 // function.inputs.len() * 32 bytes for the arguments (each argument is a U256).
                 //
-                // We're using indices in the following code in order to avoid the need for us to
+                // We're using indices in the following code in order to avoid the need for us to allocate
-                // allocate a new buffer for each one of the resolved arguments.
+                // a new buffer for each one of the resolved arguments.
                 let mut calldata = Vec::<u8>::with_capacity(4 + self.calldata.size_requirement());
                 calldata.extend(selector.0);
                 self.calldata
@@ -688,8 +687,8 @@ impl Calldata {
             Calldata::Compound(items) => {
                 stream::iter(items.iter().zip(other.chunks(32)))
                     .map(|(this, other)| async move {
-                        // The matterlabs format supports wildcards and therefore we
+                        // The MatterLabs format supports wildcards and therefore we also need to
-                        // also need to support them.
+                        // support them.
                         if this.as_ref() == "*" {
                             return Ok::<_, anyhow::Error>(true);
                         }
@@ -707,6 +706,7 @@ impl Calldata {
                             .await
                             .context("Failed to resolve calldata item during equivalence check")?;
                         let other = U256::from_be_slice(&other);
+
                         Ok(this == other)
                     })
                     .buffered(0xFF)
@@ -719,7 +719,7 @@ impl Calldata {
 }
 
 impl CalldataItem {
-    #[instrument(level = "info", skip_all, err)]
+    #[instrument(level = "info", skip_all, err(Debug))]
     async fn resolve(
         &self,
         resolver: &(impl ResolverApi + ?Sized),
@@ -770,7 +770,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_item = ?self,
+                    resolved_item = item.to_be_bytes::<32>().encode_hex(),
+                    "Resolution Done"
+                );
+                Ok(*item)
+            }
             _ => Err(anyhow::anyhow!(
                 "Invalid calldata arithmetic operation - Invalid stack"
             )),
@@ -900,7 +907,7 @@ impl<T: AsRef<str>> CalldataToken<T> {
                     let block_hash = resolver
                         .block_hash(desired_block_number.into())
                         .await
-                        .context("Failed to resolve block hash for desired block number")?;
+                        .context(format!("Failed to resolve the block hash of block number {desired_block_number}"))?;
 
                     Ok(U256::from_be_bytes(block_hash.0))
                 } else if item == Self::BLOCK_NUMBER_VARIABLE {
@@ -961,12 +968,9 @@ impl<'de> Deserialize<'de> for EtherValue {
 #[cfg(test)]
 mod tests {
 
-    use alloy::{
+    use alloy::primitives::{BlockHash, BlockNumber, BlockTimestamp, ChainId, TxHash, address};
-        eips::BlockNumberOrTag,
+    use alloy::sol_types::SolValue;
-        json_abi::JsonAbi,
+    use alloy::{eips::BlockNumberOrTag, json_abi::JsonAbi};
-        primitives::{BlockHash, BlockNumber, BlockTimestamp, ChainId, TxHash, address},
-        sol_types::SolValue,
-    };
     use std::{collections::HashMap, pin::Pin};
 
     use super::*;

crates/format/src/traits.rs

@@ -1,10 +1,10 @@
-use std::{collections::HashMap, pin::Pin};
+use std::collections::HashMap;
+use std::pin::Pin;
 
-use alloy::{
+use alloy::eips::BlockNumberOrTag;
-    eips::BlockNumberOrTag,
+use alloy::json_abi::JsonAbi;
-    json_abi::JsonAbi,
+use alloy::primitives::TxHash;
-    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, TxHash, U256},
+use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
-};
 use anyhow::Result;
 
 use crate::metadata::{ContractIdent, ContractInstance};

crates/ml-test-runner/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "ml-test-runner"
-description = "ML-based test runner for executing differential tests file by file"
-version.workspace = true
-authors.workspace = true
-license.workspace = true
-edition.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-
-[[bin]]
-name = "ml-test-runner"
-path = "src/main.rs"
-
-[dependencies]
-revive-dt-common = { workspace = true }
-revive-dt-compiler = { workspace = true }
-revive-dt-config = { workspace = true }
-revive-dt-core = { workspace = true }
-revive-dt-format = { workspace = true }
-revive-dt-node = { workspace = true }
-revive-dt-node-interaction = { workspace = true }
-revive-dt-report = { workspace = true }
-
-alloy = { workspace = true }
-anyhow = { workspace = true }
-clap = { workspace = true }
-tokio = { workspace = true }
-temp-dir = { workspace = true }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
-
-[lints]
-workspace = true

crates/ml-test-runner/README.md

@@ -1,74 +0,0 @@
-# ML Test Runner
-
-A test runner for executing Revive differential tests file-by-file with cargo-test-style output.
-
-This is similar to the `retester` binary but designed for ML-based test execution with a focus on:
-- Running tests file-by-file (rather than in bulk)
-- Caching passed tests to skip them in future runs
-- Providing cargo-test-style output for easy integration with ML pipelines
-- Single platform testing (rather than differential testing)
-
-## Features
-
-- **File-by-file execution**: Run tests on individual `.sol` files, corpus files (`.json`), or recursively walk directories
-- **Cached results**: Skip tests that have already passed using `--cached-passed`
-- **Fail fast**: Stop on first failure with `--bail`
-- **Cargo-like output**: Familiar test output format with colored pass/fail indicators
-- **Platform support**: Test against `geth` or `kitchensink` platforms
-
-## Usage
-
-```bash
-# Run a single .sol file (compile-only mode, default)
-./ml-test-runner path/to/test.sol --platform geth
-
-# Run all tests in a corpus file
-./ml-test-runner path/to/corpus.json --platform kitchensink
-
-# Walk a directory recursively for .sol files
-./ml-test-runner path/to/tests/ --platform geth
-
-# Use cached results and bail on first failure
-./ml-test-runner path/to/tests/ --cached-passed ./cache.txt --bail
-
-# Start the platform and execute tests (full mode)
-./ml-test-runner path/to/tests/ --platform geth --start-platform
-
-# Enable verbose logging (info, debug, or trace level)
-RUST_LOG=info ./ml-test-runner path/to/tests/
-RUST_LOG=debug ./ml-test-runner path/to/tests/ --start-platform
-RUST_LOG=trace ./ml-test-runner path/to/tests/ --start-platform
-```
-
-## Arguments
-
-- `<PATH>` - Path to test file (`.sol`), corpus file (`.json`), or folder of `.sol` files
-- `--cached-passed <FILE>` - File to track tests that have already passed
-- `--bail` - Stop after the first file failure
-- `--platform <PLATFORM>` - Platform to test against (`geth`, `kitchensink`, or `zombienet`, default: `geth`)
-- `--start-platform` - Start the platform and execute tests (default: `false`, compile-only mode)
-
-## Output Format
-
-The runner produces cargo-test-style output:
-
-```
-test path/to/test1.sol ... ok
-test path/to/test2.sol ... FAILED
-test path/to/test3.sol ... cached
-
-failures:
-
----- path/to/test2.sol ----
-Error: ...
-
-test result: FAILED. 1 passed; 1 failed; 1 cached; finished in 2.34s
-```
-
-## Building
-
-```bash
-cargo build --release -p ml-test-runner
-```
-
-The binary will be available at `target/release/ml-test-runner`.

crates/ml-test-runner/src/main.rs

@@ -1,541 +0,0 @@
-use anyhow::Context;
-use clap::Parser;
-use revive_dt_common::{
-    iterators::FilesWithExtensionIterator,
-    types::{PlatformIdentifier, PrivateKeyAllocator},
-};
-use revive_dt_config::TestExecutionContext;
-use revive_dt_core::{
-    CachedCompiler, Platform,
-    helpers::{TestDefinition, TestPlatformInformation},
-};
-use revive_dt_format::{
-    case::CaseIdx,
-    corpus::Corpus,
-    metadata::{Metadata, MetadataFile},
-};
-use std::{
-    borrow::Cow,
-    collections::{BTreeMap, HashSet},
-    fs::File,
-    io::{BufRead, BufReader, BufWriter, Write},
-    path::{Path, PathBuf},
-    sync::Arc,
-    time::Instant,
-};
-use temp_dir::TempDir;
-use tokio::sync::Mutex;
-use tracing::info;
-use tracing_subscriber::{EnvFilter, FmtSubscriber};
-
-/// ML-based test runner for executing differential tests file by file
-#[derive(Debug, Parser)]
-#[command(name = "ml-test-runner")]
-struct MlTestRunnerArgs {
-    /// Path to test file (.sol), corpus file (.json), or folder containing .sol files
-    #[arg(value_name = "PATH")]
-    path: PathBuf,
-
-    /// File to cache tests that have already passed
-    #[arg(long = "cached-passed")]
-    cached_passed: Option<PathBuf>,
-
-    /// Stop after the first file failure
-    #[arg(long = "bail")]
-    bail: bool,
-
-    /// Platform to test against (e.g., geth-evm-solc, kitchensink-polkavm-resolc)
-    #[arg(long = "platform", default_value = "geth-evm-solc")]
-    platform: PlatformIdentifier,
-
-    /// Start the platform and wait for RPC readiness
-    #[arg(long = "start-platform", default_value = "false")]
-    start_platform: bool,
-
-    /// Private key to use for wallet initialization (hex string with or without 0x prefix)
-    #[arg(
-        long = "private-key",
-        default_value = "0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133"
-    )]
-    private_key: String,
-
-    /// RPC port to connect to when using existing node
-    #[arg(long = "rpc-port", default_value = "8545")]
-    rpc_port: u16,
-}
-
-fn main() -> anyhow::Result<()> {
-    let subscriber = FmtSubscriber::builder()
-        .with_env_filter(EnvFilter::from_default_env())
-        .with_writer(std::io::stderr)
-        .finish();
-    tracing::subscriber::set_global_default(subscriber).expect("Failed to set tracing subscriber");
-
-    let args = MlTestRunnerArgs::parse();
-
-    info!("ML test runner starting");
-    info!("Platform: {:?}", args.platform);
-    info!("Start platform: {}", args.start_platform);
-
-    tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()
-        .expect("Failed building the Runtime")
-        .block_on(run(args))
-}
-
-async fn run(args: MlTestRunnerArgs) -> anyhow::Result<()> {
-    let start_time = Instant::now();
-
-    info!("Discovering test files from: {}", args.path.display());
-    let test_files = discover_test_files(&args.path)?;
-    info!("Found {} test file(s)", test_files.len());
-
-    let cached_passed = if let Some(cache_file) = &args.cached_passed {
-        let cached = load_cached_passed(cache_file)?;
-        info!("Loaded {} cached passed test(s)", cached.len());
-        cached
-    } else {
-        HashSet::new()
-    };
-
-    let cached_passed = Arc::new(Mutex::new(cached_passed));
-
-    let mut passed_files = 0;
-    let mut failed_files = 0;
-    let mut skipped_files = 0;
-    let mut failures = Vec::new();
-
-    const GREEN: &str = "\x1B[32m";
-    const RED: &str = "\x1B[31m";
-    const YELLOW: &str = "\x1B[33m";
-    const COLOUR_RESET: &str = "\x1B[0m";
-    const BOLD: &str = "\x1B[1m";
-    const BOLD_RESET: &str = "\x1B[22m";
-
-    for test_file in test_files {
-        let file_display = test_file.display().to_string();
-
-        // Check if already passed
-        {
-            let cache = cached_passed.lock().await;
-            if cache.contains(&file_display) {
-                println!("test {} ... {YELLOW}cached{COLOUR_RESET}", file_display);
-                skipped_files += 1;
-                continue;
-            }
-        }
-
-        info!("Loading metadata from: {}", test_file.display());
-        let metadata_file = match load_metadata_file(&test_file) {
-            Ok(mf) => {
-                info!("Loaded metadata with {} case(s)", mf.cases.len());
-                mf
-            }
-            Err(e) => {
-                println!("test {} ... {RED}FAILED{COLOUR_RESET}", file_display);
-                println!("    Error loading metadata: {}", e);
-                failed_files += 1;
-                failures.push((
-                    file_display.clone(),
-                    format!("Error loading metadata: {}", e),
-                ));
-                if args.bail {
-                    break;
-                }
-                continue;
-            }
-        };
-
-        info!("Executing test file: {}", file_display);
-        match execute_test_file(&args, &metadata_file).await {
-            Ok(_) => {
-                println!("test {} ... {GREEN}ok{COLOUR_RESET}", file_display);
-                info!("Test file passed: {}", file_display);
-                passed_files += 1;
-
-                {
-                    let mut cache = cached_passed.lock().await;
-                    cache.insert(file_display);
-                }
-            }
-            Err(e) => {
-                println!("test {} ... {RED}FAILED{COLOUR_RESET}", file_display);
-                failed_files += 1;
-                failures.push((file_display, format!("{:?}", e)));
-
-                if args.bail {
-                    info!("Bailing after first failure");
-                    break;
-                }
-            }
-        }
-    }
-
-    if let Some(cache_file) = &args.cached_passed {
-        let cache = cached_passed.lock().await;
-        info!("Saving {} cached passed test(s)", cache.len());
-        save_cached_passed(cache_file, &cache)?;
-    }
-
-    // Print summary
-    println!();
-    if !failures.is_empty() {
-        println!("{BOLD}failures:{BOLD_RESET}");
-        println!();
-        for (file, error) in &failures {
-            println!("---- {} ----", file);
-            println!("{}", error);
-            println!();
-        }
-    }
-
-    let elapsed = start_time.elapsed();
-    println!(
-        "test result: {}. {} passed; {} failed; {} cached; finished in {:.2}s",
-        if failed_files == 0 {
-            format!("{GREEN}ok{COLOUR_RESET}")
-        } else {
-            format!("{RED}FAILED{COLOUR_RESET}")
-        },
-        passed_files,
-        failed_files,
-        skipped_files,
-        elapsed.as_secs_f64()
-    );
-
-    if failed_files > 0 {
-        std::process::exit(1);
-    }
-
-    Ok(())
-}
-
-/// Discover test files from the given path
-fn discover_test_files(path: &Path) -> anyhow::Result<Vec<PathBuf>> {
-    if !path.exists() {
-        anyhow::bail!("Path does not exist: {}", path.display());
-    }
-
-    let mut files = Vec::new();
-
-    if path.is_file() {
-        let extension = path.extension().and_then(|s| s.to_str()).unwrap_or("");
-
-        match extension {
-            "sol" => {
-                // Single .sol file
-                files.push(path.to_path_buf());
-            }
-            "json" => {
-                // Corpus file - enumerate its tests
-                let corpus = Corpus::try_from_path(path)?;
-                let metadata_files = corpus.enumerate_tests();
-                for metadata in metadata_files {
-                    files.push(metadata.metadata_file_path);
-                }
-            }
-            _ => anyhow::bail!(
-                "Unsupported file extension: {}. Expected .sol or .json",
-                extension
-            ),
-        }
-    } else if path.is_dir() {
-        // Walk directory recursively for .sol files
-        for entry in FilesWithExtensionIterator::new(path)
-            .with_allowed_extension("sol")
-            .with_use_cached_fs(true)
-        {
-            files.push(entry);
-        }
-    } else {
-        anyhow::bail!("Path is neither a file nor a directory: {}", path.display());
-    }
-
-    Ok(files)
-}
-
-/// Load metadata from a test file
-fn load_metadata_file(path: &Path) -> anyhow::Result<MetadataFile> {
-    let metadata = Metadata::try_from_file(path)
-        .ok_or_else(|| anyhow::anyhow!("Failed to load metadata from {}", path.display()))?;
-
-    Ok(MetadataFile {
-        metadata_file_path: path.to_path_buf(),
-        corpus_file_path: path.to_path_buf(),
-        content: metadata,
-    })
-}
-
-/// Execute all test cases in a metadata file
-async fn execute_test_file(
-    args: &MlTestRunnerArgs,
-    metadata_file: &MetadataFile,
-) -> anyhow::Result<()> {
-    if metadata_file.cases.is_empty() {
-        anyhow::bail!("No test cases found in file");
-    }
-
-    info!("Processing {} test case(s)", metadata_file.cases.len());
-
-    // Get the platform based on CLI args
-    let platform: &dyn Platform = match args.platform {
-        PlatformIdentifier::GethEvmSolc => &revive_dt_core::GethEvmSolcPlatform,
-        PlatformIdentifier::LighthouseGethEvmSolc => &revive_dt_core::LighthouseGethEvmSolcPlatform,
-        PlatformIdentifier::KitchensinkPolkavmResolc => {
-            &revive_dt_core::KitchensinkPolkavmResolcPlatform
-        }
-        PlatformIdentifier::KitchensinkRevmSolc => &revive_dt_core::KitchensinkRevmSolcPlatform,
-        PlatformIdentifier::ReviveDevNodePolkavmResolc => {
-            &revive_dt_core::ReviveDevNodePolkavmResolcPlatform
-        }
-        PlatformIdentifier::ReviveDevNodeRevmSolc => &revive_dt_core::ReviveDevNodeRevmSolcPlatform,
-        PlatformIdentifier::ZombienetPolkavmResolc => {
-            &revive_dt_core::ZombienetPolkavmResolcPlatform
-        }
-        PlatformIdentifier::ZombienetRevmSolc => &revive_dt_core::ZombienetRevmSolcPlatform,
-    };
-
-    let temp_dir = TempDir::new()?;
-    info!("Created temporary directory: {}", temp_dir.path().display());
-
-    let test_context = TestExecutionContext::default();
-    let context = revive_dt_config::Context::Test(Box::new(test_context));
-
-    let node: &'static dyn revive_dt_node_interaction::EthereumNode = if args.start_platform {
-        info!("Starting blockchain node...");
-        let node_handle = platform
-            .new_node(context.clone())
-            .context("Failed to spawn node thread")?;
-
-        info!("Waiting for node to start...");
-        let node = node_handle
-            .join()
-            .map_err(|e| anyhow::anyhow!("Node thread panicked: {:?}", e))?
-            .context("Failed to start node")?;
-
-        info!(
-            "Node started with ID: {}, connection: {}",
-            node.id(),
-            node.connection_string()
-        );
-        let node = Box::leak(node);
-
-        info!("Running pre-transactions...");
-        node.pre_transactions()
-            .await
-            .context("Failed to run pre-transactions")?;
-        info!("Pre-transactions completed");
-
-        node
-    } else {
-        info!("Using existing node");
-        let existing_node: Box<dyn revive_dt_node_interaction::EthereumNode> = match args.platform {
-            PlatformIdentifier::GethEvmSolc | PlatformIdentifier::LighthouseGethEvmSolc => {
-                Box::new(
-                    revive_dt_node::node_implementations::geth::GethNode::new_existing(
-                        &args.private_key,
-                        args.rpc_port,
-                    )
-                    .await?,
-                )
-            }
-            PlatformIdentifier::KitchensinkPolkavmResolc
-            | PlatformIdentifier::KitchensinkRevmSolc
-            | PlatformIdentifier::ReviveDevNodePolkavmResolc
-            | PlatformIdentifier::ReviveDevNodeRevmSolc
-            | PlatformIdentifier::ZombienetPolkavmResolc
-            | PlatformIdentifier::ZombienetRevmSolc => Box::new(
-                revive_dt_node::node_implementations::substrate::SubstrateNode::new_existing(
-                    &args.private_key,
-                    args.rpc_port,
-                )
-                .await?,
-            ),
-        };
-        Box::leak(existing_node)
-    };
-
-    info!("Initializing cached compiler");
-    let cached_compiler = CachedCompiler::new(temp_dir.path().join("compilation_cache"), false)
-        .await
-        .map(Arc::new)
-        .context("Failed to create cached compiler")?;
-
-    let private_key_allocator = Arc::new(Mutex::new(PrivateKeyAllocator::new(
-        alloy::primitives::U256::from(100),
-    )));
-
-    let (reporter, report_task) =
-        revive_dt_report::ReportAggregator::new(context.clone()).into_task();
-
-    tokio::spawn(report_task);
-
-    info!(
-        "Building test definitions for {} case(s)",
-        metadata_file.cases.len()
-    );
-    let mut test_definitions = Vec::new();
-    for (case_idx, case) in metadata_file.cases.iter().enumerate() {
-        info!("Building test definition for case {}", case_idx);
-        let test_def = build_test_definition(
-            metadata_file,
-            case,
-            case_idx,
-            platform,
-            node,
-            &context,
-            &reporter,
-        )
-        .await?;
-
-        if let Some(test_def) = test_def {
-            info!("Test definition for case {} created successfully", case_idx);
-            test_definitions.push(test_def);
-        }
-    }
-
-    info!("Executing {} test definition(s)", test_definitions.len());
-    for (idx, test_definition) in test_definitions.iter().enumerate() {
-        info!("─────────────────────────────────────────────────────────────────");
-        info!(
-            "Executing case {}/{}: case_idx={}, mode={}, steps={}",
-            idx + 1,
-            test_definitions.len(),
-            test_definition.case_idx,
-            test_definition.mode,
-            test_definition.case.steps.len()
-        );
-
-        info!("Creating driver for case {}", test_definition.case_idx);
-        let driver = revive_dt_core::differential_tests::Driver::new_root(
-            test_definition,
-            private_key_allocator.clone(),
-            &cached_compiler,
-        )
-        .await
-        .context("Failed to create driver")?;
-
-        info!(
-            "Running {} step(s) for case {}",
-            test_definition.case.steps.len(),
-            test_definition.case_idx
-        );
-        let steps_executed = driver.execute_all().await.context(format!(
-            "Failed to execute case {}",
-            test_definition.case_idx
-        ))?;
-        info!(
-            "✓ Case {} completed successfully, executed {} step(s)",
-            test_definition.case_idx, steps_executed
-        );
-    }
-    info!("─────────────────────────────────────────────────────────────────");
-    info!(
-        "All {} test case(s) executed successfully",
-        test_definitions.len()
-    );
-
-    Ok(())
-}
-
-/// Build a test definition for a single test case
-async fn build_test_definition<'a>(
-    metadata_file: &'a MetadataFile,
-    case: &'a revive_dt_format::case::Case,
-    case_idx: usize,
-    platform: &'a dyn Platform,
-    node: &'a dyn revive_dt_node_interaction::EthereumNode,
-    context: &revive_dt_config::Context,
-    reporter: &revive_dt_report::Reporter,
-) -> anyhow::Result<Option<TestDefinition<'a>>> {
-    let mode = case
-        .modes
-        .as_ref()
-        .or(metadata_file.modes.as_ref())
-        .and_then(|modes| modes.first())
-        .and_then(|parsed_mode| parsed_mode.to_modes().next())
-        .map(Cow::Owned)
-        .or_else(|| revive_dt_compiler::Mode::all().next().map(Cow::Borrowed))
-        .unwrap();
-
-    let compiler = platform
-        .new_compiler(context.clone(), mode.version.clone().map(Into::into))
-        .await
-        .context("Failed to create compiler")?;
-
-    let test_reporter =
-        reporter.test_specific_reporter(Arc::new(revive_dt_report::TestSpecifier {
-            solc_mode: mode.as_ref().clone(),
-            metadata_file_path: metadata_file.metadata_file_path.clone(),
-            case_idx: CaseIdx::new(case_idx),
-        }));
-
-    let execution_reporter =
-        test_reporter.execution_specific_reporter(node.id(), platform.platform_identifier());
-
-    let mut platforms = BTreeMap::new();
-    platforms.insert(
-        platform.platform_identifier(),
-        TestPlatformInformation {
-            platform,
-            node,
-            compiler,
-            reporter: execution_reporter,
-        },
-    );
-
-    let test_definition = TestDefinition {
-        metadata: metadata_file,
-        metadata_file_path: &metadata_file.metadata_file_path,
-        mode,
-        case_idx: CaseIdx::new(case_idx),
-        case,
-        platforms,
-        reporter: test_reporter,
-    };
-
-    if let Err((reason, _)) = test_definition.check_compatibility() {
-        println!("    Skipping case {}: {}", case_idx, reason);
-        return Ok(None);
-    }
-
-    Ok(Some(test_definition))
-}
-
-/// Load cached passed tests from file
-fn load_cached_passed(path: &Path) -> anyhow::Result<HashSet<String>> {
-    if !path.exists() {
-        return Ok(HashSet::new());
-    }
-
-    let file = File::open(path).context("Failed to open cached-passed file")?;
-    let reader = BufReader::new(file);
-
-    let mut cache = HashSet::new();
-    for line in reader.lines() {
-        let line = line?;
-        let trimmed = line.trim();
-        if !trimmed.is_empty() {
-            cache.insert(trimmed.to_string());
-        }
-    }
-
-    Ok(cache)
-}
-
-/// Save cached passed tests to file
-fn save_cached_passed(path: &Path, cache: &HashSet<String>) -> anyhow::Result<()> {
-    let file = File::create(path).context("Failed to create cached-passed file")?;
-    let mut writer = BufWriter::new(file);
-
-    let mut entries: Vec<_> = cache.iter().collect();
-    entries.sort();
-
-    for entry in entries {
-        writeln!(writer, "{}", entry)?;
-    }
-
-    writer.flush()?;
-    Ok(())
-}

crates/node-interaction/Cargo.toml

@@ -12,6 +12,7 @@ rust-version.workspace = true
 revive-common = { workspace = true }
 
 revive-dt-format = { workspace = true }
+revive-dt-report = { workspace = true }
 
 alloy = { workspace = true }
 anyhow = { workspace = true }

crates/node-interaction/src/lib.rs

@@ -1,19 +1,19 @@
 //! This crate implements all node interactions.
 
-use std::{pin::Pin, sync::Arc};
+use std::pin::Pin;
+use std::sync::Arc;
 
-use alloy::{
+use alloy::network::Ethereum;
-    primitives::{Address, BlockNumber, BlockTimestamp, StorageKey, TxHash, U256},
+use alloy::primitives::{Address, StorageKey, TxHash, U256};
-    rpc::types::{
+use alloy::providers::DynProvider;
-        EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
+use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
-        trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace},
+use alloy::rpc::types::{EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest};
-    },
-};
 use anyhow::Result;
 
 use futures::Stream;
 use revive_common::EVMVersion;
 use revive_dt_format::traits::ResolverApi;
+use revive_dt_report::MinedBlockInformation;
 
 /// An interface for all interactions with Ethereum compatible nodes.
 #[allow(clippy::type_complexity)]
@@ -78,25 +78,6 @@ pub trait EthereumNode {
         >,
     >;
 
-    /// Checks if the provided address is in the wallet. If it is, returns the address.
+    fn provider(&self)
-    /// Otherwise, returns the default signer's address.
+    -> Pin<Box<dyn Future<Output = anyhow::Result<DynProvider<Ethereum>>> + '_>>;
-    fn resolve_signer_or_default(&self, address: Address) -> Address;
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct MinedBlockInformation {
-    /// The block number.
-    pub block_number: BlockNumber,
-
-    /// The block timestamp.
-    pub block_timestamp: BlockTimestamp,
-
-    /// The amount of gas mined in the block.
-    pub mined_gas: u128,
-
-    /// The gas limit of the block.
-    pub block_gas_limit: u128,
-
-    /// The hashes of the transactions that were mined as part of the block.
-    pub transaction_hashes: Vec<TxHash>,
 }

crates/node/Cargo.toml

@@ -21,6 +21,7 @@ revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
 revive-dt-node-interaction = { workspace = true }
+revive-dt-report = { workspace = true }
 
 serde = { workspace = true }
 serde_json = { workspace = true }
@@ -29,6 +30,7 @@ serde_yaml_ng = { workspace = true }
 
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }
+subxt = { workspace = true }
 zombienet-sdk = { workspace = true }
 
 [dev-dependencies]

crates/node/src/node_implementations/geth.rs

@@ -18,9 +18,7 @@ use alloy::{
     eips::BlockNumberOrTag,
     genesis::{Genesis, GenesisAccount},
     network::{Ethereum, EthereumWallet, NetworkWallet},
-    primitives::{
+    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, StorageKey, TxHash, U256},
-        Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, StorageKey, TxHash, U256,
-    },
     providers::{
         Provider,
         ext::DebugApi,
@@ -34,7 +32,7 @@ use alloy::{
     },
 };
 use anyhow::Context as _;
-use futures::{Stream, StreamExt};
+use futures::{FutureExt, Stream, StreamExt};
 use revive_common::EVMVersion;
 use tokio::sync::OnceCell;
 use tracing::{Instrument, error, instrument};
@@ -45,7 +43,8 @@ use revive_dt_common::{
 };
 use revive_dt_config::*;
 use revive_dt_format::traits::ResolverApi;
-use revive_dt_node_interaction::{EthereumNode, MinedBlockInformation};
+use revive_dt_node_interaction::EthereumNode;
+use revive_dt_report::{EthereumMinedBlockInformation, MinedBlockInformation};
 
 use crate::{
     Node,
@@ -77,7 +76,6 @@ pub struct GethNode {
     wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
     provider: OnceCell<ConcreteProvider<Ethereum, Arc<EthereumWallet>>>,
-    chain_id: ChainId,
 }
 
 impl GethNode {
@@ -128,123 +126,12 @@ impl GethNode {
             wallet: wallet.clone(),
             nonce_manager: Default::default(),
             provider: Default::default(),
-            chain_id: CHAIN_ID,
         }
     }
 
-    pub async fn new_existing(private_key: &str, rpc_port: u16) -> anyhow::Result<Self> {
-        use alloy::{
-            primitives::FixedBytes,
-            providers::{Provider, ProviderBuilder},
-            signers::local::PrivateKeySigner,
-        };
-
-        let key_str = private_key
-            .trim()
-            .strip_prefix("0x")
-            .unwrap_or(private_key.trim());
-        let key_bytes = alloy::hex::decode(key_str)
-            .map_err(|e| anyhow::anyhow!("Failed to decode private key hex: {}", e))?;
-
-        if key_bytes.len() != 32 {
-            anyhow::bail!(
-                "Private key must be 32 bytes (64 hex characters), got {}",
-                key_bytes.len()
-            );
-        }
-
-        let mut bytes = [0u8; 32];
-        bytes.copy_from_slice(&key_bytes);
-
-        let signer = PrivateKeySigner::from_bytes(&FixedBytes(bytes))
-            .map_err(|e| anyhow::anyhow!("Failed to create signer from private key: {}", e))?;
-
-        let address = signer.address();
-        let wallet = Arc::new(EthereumWallet::new(signer));
-        let connection_string = format!("http://localhost:{}", rpc_port);
-
-        let chain_id = ProviderBuilder::new()
-            .connect_http(connection_string.parse()?)
-            .get_chain_id()
-            .await
-            .context("Failed to query chain ID from RPC")?;
-
-        let node = Self {
-            connection_string: format!("http://localhost:{}", rpc_port),
-            base_directory: PathBuf::new(),
-            data_directory: PathBuf::new(),
-            logs_directory: PathBuf::new(),
-            geth: PathBuf::new(),
-            id: 0,
-            chain_id,
-            handle: None,
-            start_timeout: Duration::from_secs(0),
-            wallet,
-            nonce_manager: Default::default(),
-            provider: Default::default(),
-        };
-
-        // Check balance and fund if needed
-        node.ensure_funded(address).await?;
-
-        Ok(node)
-    }
-
-    /// Ensure that the given address has at least 1000 ETH, funding it from the node's managed
-    /// account if necessary.
-    async fn ensure_funded(&self, address: Address) -> anyhow::Result<()> {
-        use alloy::{
-            primitives::utils::{format_ether, parse_ether},
-            providers::{Provider, ProviderBuilder},
-        };
-
-        let provider = ProviderBuilder::new().connect_http(self.connection_string.parse()?);
-        let balance = provider.get_balance(address).await?;
-        let min_balance = parse_ether("1000")?;
-
-        if balance >= min_balance {
-            tracing::info!(
-                "Wallet {} already has sufficient balance: {} ETH",
-                address,
-                format_ether(balance)
-            );
-            return Ok(());
-        }
-
-        tracing::info!(
-            "Funding wallet {} (current: {} ETH, target: 1000 ETH)",
-            address,
-            format_ether(balance)
-        );
-
-        // Get the node's managed account
-        let accounts = provider.get_accounts().await?;
-        if accounts.is_empty() {
-            anyhow::bail!("No managed accounts available on the node to fund wallet");
-        }
-
-        let from_account = accounts[0];
-
-        let funding_amount = min_balance - balance;
-        let tx = TransactionRequest::default()
-            .from(from_account)
-            .to(address)
-            .value(funding_amount);
-
-        provider
-            .send_transaction(tx)
-            .await?
-            .get_receipt()
-            .await
-            .context("Failed to get receipt for funding transaction")?;
-
-        tracing::info!("Successfully funded wallet {}", address);
-        Ok(())
-    }
-
     /// Create the node directory and call `geth init` to configure the genesis.
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-    fn init(&mut self, mut genesis: Genesis) -> anyhow::Result<&mut Self> {
+    fn init(&mut self, genesis: Genesis) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
@@ -253,16 +140,7 @@ impl GethNode {
         create_dir_all(&self.logs_directory)
             .context("Failed to create logs directory for geth node")?;
 
-        for signer_address in
+        let genesis = Self::node_genesis(genesis, self.wallet.as_ref());
-            <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
-        {
-            // Note, the use of the entry API here means that we only modify the entries for any
-            // account that is not in the `alloc` field of the genesis state.
-            genesis
-                .alloc
-                .entry(signer_address)
-                .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
-        }
         let genesis_path = self.base_directory.join(Self::GENESIS_JSON_FILE);
         serde_json::to_writer(
             File::create(&genesis_path).context("Failed to create geth genesis file")?,
@@ -369,7 +247,7 @@ impl GethNode {
                 construct_concurrency_limited_provider::<Ethereum, _>(
                     self.connection_string.as_str(),
                     FallbackGasFiller::default(),
-                    ChainIdFiller::new(Some(self.chain_id)),
+                    ChainIdFiller::new(Some(CHAIN_ID)),
                     NonceFiller::new(self.nonce_manager.clone()),
                     self.wallet.clone(),
                 )
@@ -379,6 +257,16 @@ impl GethNode {
             .await
             .cloned()
     }
+
+    pub fn node_genesis(mut genesis: Genesis, wallet: &EthereumWallet) -> Genesis {
+        for signer_address in NetworkWallet::<Ethereum>::signer_addresses(&wallet) {
+            genesis
+                .alloc
+                .entry(signer_address)
+                .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
+        }
+        genesis
+    }
 }
 
 impl EthereumNode for GethNode {
@@ -463,25 +351,23 @@ impl EthereumNode for GethNode {
                 .context("Failed to submit transaction to geth node")?;
             let transaction_hash = *pending_transaction.tx_hash();
 
-            // The following is a fix for the "transaction indexing is in progress" error that we
+            // The following is a fix for the "transaction indexing is in progress" error that we used
-            // used to get. You can find more information on this in the following GH issue in
+            // to get. You can find more information on this in the following GH issue in geth
-            // geth https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
+            // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
             // before we can get the receipt of the transaction it needs to have been indexed by the
-            // node's indexer. Just because the transaction has been confirmed it doesn't mean that
+            // node's indexer. Just because the transaction has been confirmed it doesn't mean that it
-            // it has been indexed. When we call alloy's `get_receipt` it checks if the
+            // has been indexed. When we call alloy's `get_receipt` it checks if the transaction was
-            // transaction was confirmed. If it has been, then it will call
+            // confirmed. If it has been, then it will call `eth_getTransactionReceipt` method which
-            // `eth_getTransactionReceipt` method which _might_ return the above error if the tx
+            // _might_ return the above error if the tx has not yet been indexed yet. So, we need to
-            // has not yet been indexed yet. So, we need to implement a retry mechanism for the
+            // implement a retry mechanism for the receipt to keep retrying to get it until it
-            // receipt to keep retrying to get it until it eventually works, but we only do that
+            // eventually works, but we only do that if the error we get back is the "transaction
-            // if the error we get back is the "transaction indexing is in progress" error or if
+            // indexing is in progress" error or if the receipt is None.
-            // the receipt is None.
             //
-            // Getting the transaction indexed and taking a receipt can take a long time especially
+            // Getting the transaction indexed and taking a receipt can take a long time especially when
-            // when a lot of transactions are being submitted to the node. Thus, while initially
+            // a lot of transactions are being submitted to the node. Thus, while initially we only
-            // we only allowed for 60 seconds of waiting with a 1 second delay in polling, we
+            // allowed for 60 seconds of waiting with a 1 second delay in polling, we need to allow for
-            // need to allow for a larger wait time. Therefore, in here we allow for 5 minutes of
+            // a larger wait time. Therefore, in here we allow for 5 minutes of waiting with exponential
-            // waiting with exponential backoff each time we attempt to get the receipt and find
+            // backoff each time we attempt to get the receipt and find that it's not available.
-            // that it's not available.
             poll(
                 Self::RECEIPT_POLLING_DURATION,
                 PollingWaitBehavior::Constant(Duration::from_millis(200)),
@@ -641,6 +527,7 @@ impl EthereumNode for GethNode {
             let mined_block_information_stream = block_stream.filter_map(|block| async {
                 let block = block.ok()?;
                 Some(MinedBlockInformation {
+                    ethereum_block_information: EthereumMinedBlockInformation {
                         block_number: block.number(),
                         block_timestamp: block.header.timestamp,
                         mined_gas: block.header.gas_used as _,
@@ -651,6 +538,9 @@ impl EthereumNode for GethNode {
                             .as_hashes()
                             .expect("Must be hashes")
                             .to_vec(),
+                    },
+                    substrate_block_information: None,
+                    tx_counts: Default::default(),
                 })
             });
 
@@ -659,14 +549,14 @@ impl EthereumNode for GethNode {
         })
     }
 
-    fn resolve_signer_or_default(&self, address: Address) -> Address {
+    fn provider(
-        let signer_addresses: Vec<_> =
+        &self,
-            <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet).collect();
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<alloy::providers::DynProvider<Ethereum>>> + '_>>
-        if signer_addresses.contains(&address) {
+    {
-            address
+        Box::pin(
-        } else {
+            self.provider()
-            self.wallet.default_signer().address()
+                .map(|provider| provider.map(|provider| provider.erased())),
-        }
+        )
     }
 }
 

crates/node/src/node_implementations/lighthouse_geth.rs

@@ -43,7 +43,7 @@ use alloy::{
     },
 };
 use anyhow::Context as _;
-use futures::{Stream, StreamExt};
+use futures::{FutureExt, Stream, StreamExt};
 use revive_common::EVMVersion;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_with::serde_as;
@@ -56,7 +56,8 @@ use revive_dt_common::{
 };
 use revive_dt_config::*;
 use revive_dt_format::traits::ResolverApi;
-use revive_dt_node_interaction::{EthereumNode, MinedBlockInformation};
+use revive_dt_node_interaction::EthereumNode;
+use revive_dt_report::{EthereumMinedBlockInformation, MinedBlockInformation};
 
 use crate::{
     Node,
@@ -222,6 +223,7 @@ impl LighthouseGethNode {
                     "--ws.port=8546".to_string(),
                     "--ws.api=eth,net,web3,txpool,engine".to_string(),
                     "--ws.origins=*".to_string(),
+                    "--miner.gaslimit=30000000".to_string(),
                 ],
                 consensus_layer_extra_parameters: vec![
                     "--disable-quic".to_string(),
@@ -247,6 +249,8 @@ impl LighthouseGethNode {
                         .collect::<BTreeMap<_, _>>();
                     serde_json::to_string(&map).unwrap()
                 },
+                gas_limit: 30_000_000,
+                genesis_gaslimit: 30_000_000,
             },
             wait_for_finalization: false,
             port_publisher: Some(PortPublisherParameters {
@@ -538,6 +542,16 @@ impl LighthouseGethNode {
             .await
         })
     }
+
+    pub fn node_genesis(mut genesis: Genesis, wallet: &EthereumWallet) -> Genesis {
+        for signer_address in NetworkWallet::<Ethereum>::signer_addresses(&wallet) {
+            genesis
+                .alloc
+                .entry(signer_address)
+                .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
+        }
+        genesis
+    }
 }
 
 impl EthereumNode for LighthouseGethNode {
@@ -744,6 +758,7 @@ impl EthereumNode for LighthouseGethNode {
             let mined_block_information_stream = block_stream.filter_map(|block| async {
                 let block = block.ok()?;
                 Some(MinedBlockInformation {
+                    ethereum_block_information: EthereumMinedBlockInformation {
                         block_number: block.number(),
                         block_timestamp: block.header.timestamp,
                         mined_gas: block.header.gas_used as _,
@@ -754,6 +769,9 @@ impl EthereumNode for LighthouseGethNode {
                             .as_hashes()
                             .expect("Must be hashes")
                             .to_vec(),
+                    },
+                    substrate_block_information: None,
+                    tx_counts: Default::default(),
                 })
             });
 
@@ -762,14 +780,14 @@ impl EthereumNode for LighthouseGethNode {
         })
     }
 
-    fn resolve_signer_or_default(&self, address: Address) -> Address {
+    fn provider(
-        let signer_addresses: Vec<_> =
+        &self,
-            <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet).collect();
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<alloy::providers::DynProvider<Ethereum>>> + '_>>
-        if signer_addresses.contains(&address) {
+    {
-            address
+        Box::pin(
-        } else {
+            self.http_provider()
-            self.wallet.default_signer().address()
+                .map(|provider| provider.map(|provider| provider.erased())),
-        }
+        )
     }
 }
 
@@ -1045,6 +1063,8 @@ struct NetworkParameters {
     pub num_validator_keys_per_node: u64,
 
     pub genesis_delay: u64,
+    pub genesis_gaslimit: u64,
+    pub gas_limit: u64,
 
     pub prefunded_accounts: String,
 }
@@ -1141,6 +1161,7 @@ mod tests {
     }
 
     #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
     async fn node_mines_simple_transfer_transaction_and_returns_receipt() {
         // Arrange
         let (context, node) = new_node();

crates/node/src/node_implementations/zombienet.rs

@@ -3,24 +3,32 @@
 //! ## Required Binaries
 //! This module requires the following binaries to be compiled and available in your PATH:
 //!
-//! 1. **polkadot-parachain**: ```bash git clone https://github.com/paritytech/polkadot-sdk.git cd
+//! 1. **polkadot-parachain**:
-//!    polkadot-sdk cargo build --release --locked -p polkadot-parachain-bin --bin
+//!    ```bash
-//!    polkadot-parachain ```
+//!    git clone https://github.com/paritytech/polkadot-sdk.git
+//!    cd polkadot-sdk
+//!    cargo build --release --locked -p polkadot-parachain-bin --bin polkadot-parachain
+//!    ```
 //!
-//! 2. **eth-rpc** (Revive EVM RPC server): ```bash git clone https://github.com/paritytech/polkadot-sdk.git
+//! 2. **eth-rpc** (Revive EVM RPC server):
-//!    cd polkadot-sdk cargo build --locked --profile production -p pallet-revive-eth-rpc --bin
+//!    ```bash
-//!    eth-rpc ```
+//!    git clone https://github.com/paritytech/polkadot-sdk.git
+//!    cd polkadot-sdk
+//!    cargo build --locked --profile production -p pallet-revive-eth-rpc --bin eth-rpc
+//!    ```
 //!
-//! 3. **polkadot** (for the relay chain): ```bash # In polkadot-sdk directory cargo build --locked
+//! 3. **polkadot** (for the relay chain):
-//!    --profile testnet --features fast-runtime --bin polkadot --bin polkadot-prepare-worker --bin
+//!    ```bash
-//!    polkadot-execute-worker ```
+//!    # In polkadot-sdk directory
+//!    cargo build --locked --profile testnet --features fast-runtime --bin polkadot --bin polkadot-prepare-worker --bin polkadot-execute-worker
+//!    ```
 //!
 //! Make sure to add the build output directories to your PATH or provide
 //! the full paths in your configuration.
 
 use std::{
     fs::{create_dir_all, remove_dir_all},
-    path::PathBuf,
+    path::{Path, PathBuf},
     pin::Pin,
     process::{Command, Stdio},
     sync::{
@@ -32,7 +40,7 @@ use std::{
 
 use alloy::{
     eips::BlockNumberOrTag,
-    genesis::{Genesis, GenesisAccount},
+    genesis::Genesis,
     network::{Ethereum, EthereumWallet, NetworkWallet},
     primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, StorageKey, TxHash, U256},
     providers::{
@@ -47,15 +55,19 @@ use alloy::{
 };
 
 use anyhow::Context as _;
-use futures::{Stream, StreamExt};
+use futures::{FutureExt, Stream, StreamExt};
 use revive_common::EVMVersion;
 use revive_dt_common::fs::clear_directory;
 use revive_dt_config::*;
 use revive_dt_format::traits::ResolverApi;
-use revive_dt_node_interaction::{EthereumNode, MinedBlockInformation};
+use revive_dt_node_interaction::*;
-use serde_json::{Value as JsonValue, json};
+use revive_dt_report::{
+    EthereumMinedBlockInformation, MinedBlockInformation, SubstrateMinedBlockInformation,
+};
+use serde_json::json;
 use sp_core::crypto::Ss58Codec;
 use sp_runtime::AccountId32;
+use subxt::{OnlineClient, SubstrateConfig};
 use tokio::sync::OnceCell;
 use tracing::instrument;
 use zombienet_sdk::{LocalFileSystem, NetworkConfigBuilder, NetworkConfigExt};
@@ -64,17 +76,19 @@ use crate::{
     Node,
     constants::INITIAL_BALANCE,
     helpers::{Process, ProcessReadinessWaitBehavior},
-    node_implementations::substrate::ReviveNetwork,
+    provider_utils::{
-    provider_utils::{ConcreteProvider, FallbackGasFiller, construct_concurrency_limited_provider},
+        ConcreteProvider, FallbackGasFiller, construct_concurrency_limited_provider,
+        execute_transaction,
+    },
 };
 
 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 
-/// A Zombienet network where collator is `polkadot-parachain` node with `eth-rpc`
+/// A Zombienet network where collator is `polkadot-parachain` node with `eth-rpc` [`ZombieNode`]
-/// [`ZombieNode`] abstracts away the details of managing the zombienet network and provides
+/// abstracts away the details of managing the zombienet network and provides an interface to
-/// an interface to interact with the parachain's Ethereum RPC.
+/// interact with the parachain's Ethereum RPC.
 #[derive(Debug, Default)]
-pub struct ZombieNode {
+pub struct ZombienetNode {
     /* Node Identifier */
     id: u32,
     connection_string: String,
@@ -99,10 +113,10 @@ pub struct ZombieNode {
     wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
 
-    provider: OnceCell<ConcreteProvider<ReviveNetwork, Arc<EthereumWallet>>>,
+    provider: OnceCell<ConcreteProvider<Ethereum, Arc<EthereumWallet>>>,
 }
 
-impl ZombieNode {
+impl ZombienetNode {
     const BASE_DIRECTORY: &str = "zombienet";
     const DATA_DIRECTORY: &str = "data";
     const LOGS_DIRECTORY: &str = "logs";
@@ -111,6 +125,8 @@ impl ZombieNode {
     const PARACHAIN_ID: u32 = 100;
     const ETH_RPC_BASE_PORT: u16 = 8545;
 
+    const PROXY_LOG_ENV: &str = "info,eth-rpc=debug";
+
     const ETH_RPC_READY_MARKER: &str = "Running JSON-RPC server";
 
     const EXPORT_CHAINSPEC_COMMAND: &str = "build-spec";
@@ -151,7 +167,7 @@ impl ZombieNode {
         }
     }
 
-    fn init(&mut self, genesis: Genesis) -> anyhow::Result<&mut Self> {
+    fn init(&mut self, _: Genesis) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
@@ -161,7 +177,7 @@ impl ZombieNode {
             .context("Failed to create logs directory for zombie node")?;
 
         let template_chainspec_path = self.base_directory.join(Self::CHAIN_SPEC_JSON_FILE);
-        self.prepare_chainspec(template_chainspec_path.clone(), genesis)?;
+        self.prepare_chainspec(template_chainspec_path.clone())?;
         let polkadot_parachain_path = self
             .polkadot_parachain_path
             .to_str()
@@ -170,25 +186,36 @@ impl ZombieNode {
         let node_rpc_port = Self::NODE_BASE_RPC_PORT + self.id as u16;
 
         let network_config = NetworkConfigBuilder::new()
-            .with_relaychain(|r| {
+            .with_relaychain(|relay_chain| {
-                r.with_chain("westend-local")
+                relay_chain
+                    .with_chain("westend-local")
                     .with_default_command("polkadot")
                     .with_node(|node| node.with_name("alice"))
                     .with_node(|node| node.with_name("bob"))
             })
-            .with_global_settings(|g| g.with_base_dir(&self.base_directory))
+            .with_global_settings(|global_settings| {
-            .with_parachain(|p| {
+                // global_settings.with_base_dir(&self.base_directory)
-                p.with_id(Self::PARACHAIN_ID)
+                global_settings
-                    .with_chain_spec_path(template_chainspec_path.to_str().unwrap())
+            })
+            .with_parachain(|parachain| {
+                parachain
+                    .with_id(Self::PARACHAIN_ID)
+                    .with_chain_spec_path(template_chainspec_path.to_path_buf())
                     .with_chain("asset-hub-westend-local")
-                    .with_collator(|n| {
+                    .with_collator(|node_config| {
-                        n.with_name("Collator")
+                        node_config
+                            .with_name("Collator")
                             .with_command(polkadot_parachain_path)
                             .with_rpc_port(node_rpc_port)
+                            .with_args(vec![
+                                ("--pool-limit", u32::MAX.to_string().as_str()).into(),
+                                ("--pool-kbytes", u32::MAX.to_string().as_str()).into(),
+                                ("--dev-block-time", 12000u16.to_string().as_str()).into(),
+                            ])
                     })
             })
             .build()
-            .map_err(|e| anyhow::anyhow!("Failed to build zombienet network config: {e:?}"))?;
+            .map_err(|err| anyhow::anyhow!("Failed to build zombienet network config: {err:?}"))?;
 
         self.node_rpc_port = Some(node_rpc_port);
         self.network_config = Some(network_config);
@@ -202,6 +229,9 @@ impl ZombieNode {
             .clone()
             .context("Node not initialized, call init() first")?;
 
+        // TODO: Look into the possibility of removing this in the future, perhaps by reintroducing
+        // the blocking runtime abstraction and making it available to the entire program so that we
+        // don't need to be spawning multiple different runtimes.
         let rt = tokio::runtime::Runtime::new().unwrap();
         let network = rt.block_on(async {
             network_config
@@ -229,6 +259,7 @@ impl ZombieNode {
                     .arg(u32::MAX.to_string())
                     .arg("--rpc-port")
                     .arg(eth_rpc_port.to_string())
+                    .env("RUST_LOG", Self::PROXY_LOG_ENV)
                     .stdout(stdout_file)
                     .stderr(stderr_file);
             },
@@ -259,70 +290,9 @@ impl ZombieNode {
         Ok(())
     }
 
-    fn prepare_chainspec(
+    fn prepare_chainspec(&mut self, template_chainspec_path: PathBuf) -> anyhow::Result<()> {
-        &mut self,
+        let chainspec_json = Self::node_genesis(&self.polkadot_parachain_path, &self.wallet)
-        template_chainspec_path: PathBuf,
+            .context("Failed to prepare the zombienet chainspec file")?;
-        mut genesis: Genesis,
-    ) -> anyhow::Result<()> {
-        let mut cmd: Command = std::process::Command::new(&self.polkadot_parachain_path);
-        cmd.arg(Self::EXPORT_CHAINSPEC_COMMAND)
-            .arg("--chain")
-            .arg("asset-hub-westend-local");
-
-        let output = cmd.output().context("Failed to export the chain-spec")?;
-
-        if !output.status.success() {
-            anyhow::bail!(
-                "Build chain-spec failed: {}",
-                String::from_utf8_lossy(&output.stderr)
-            );
-        }
-
-        let content = String::from_utf8(output.stdout)
-            .context("Failed to decode collators chain-spec output as UTF-8")?;
-        let mut chainspec_json: JsonValue =
-            serde_json::from_str(&content).context("Failed to parse collators chain spec JSON")?;
-
-        let existing_chainspec_balances =
-            chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
-                .as_array()
-                .cloned()
-                .unwrap_or_default();
-
-        let mut merged_balances: Vec<(String, u128)> = existing_chainspec_balances
-            .into_iter()
-            .filter_map(|val| {
-                if let Some(arr) = val.as_array() {
-                    if arr.len() == 2 {
-                        let account = arr[0].as_str()?.to_string();
-                        let balance = arr[1].as_f64()? as u128;
-                        return Some((account, balance));
-                    }
-                }
-                None
-            })
-            .collect();
-
-        let mut eth_balances = {
-            for signer_address in
-                <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
-            {
-                // Note, the use of the entry API here means that we only modify the entries for any
-                // account that is not in the `alloc` field of the genesis state.
-                genesis
-                    .alloc
-                    .entry(signer_address)
-                    .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
-            }
-            self.extract_balance_from_genesis_file(&genesis)
-                .context("Failed to extract balances from EVM genesis JSON")?
-        };
-
-        merged_balances.append(&mut eth_balances);
-
-        chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"] =
-            json!(merged_balances);
-
         let writer = std::fs::File::create(&template_chainspec_path)
             .context("Failed to create template chainspec file")?;
 
@@ -332,21 +302,6 @@ impl ZombieNode {
         Ok(())
     }
 
-    fn extract_balance_from_genesis_file(
-        &self,
-        genesis: &Genesis,
-    ) -> anyhow::Result<Vec<(String, u128)>> {
-        genesis
-            .alloc
-            .iter()
-            .try_fold(Vec::new(), |mut vec, (address, acc)| {
-                let polkadot_address = Self::eth_to_polkadot_address(address);
-                let balance = acc.balance.try_into()?;
-                vec.push((polkadot_address, balance));
-                Ok(vec)
-            })
-    }
-
     fn eth_to_polkadot_address(address: &Address) -> String {
         let eth_bytes = address.0.0;
 
@@ -370,14 +325,12 @@ impl ZombieNode {
         Ok(String::from_utf8_lossy(&output).trim().to_string())
     }
 
-    async fn provider(
+    async fn provider(&self) -> anyhow::Result<ConcreteProvider<Ethereum, Arc<EthereumWallet>>> {
-        &self,
-    ) -> anyhow::Result<ConcreteProvider<ReviveNetwork, Arc<EthereumWallet>>> {
         self.provider
             .get_or_try_init(|| async move {
-                construct_concurrency_limited_provider::<ReviveNetwork, _>(
+                construct_concurrency_limited_provider::<Ethereum, _>(
                     self.connection_string.as_str(),
-                    FallbackGasFiller::new(250_000_000, 5_000_000_000, 1_000_000_000),
+                    FallbackGasFiller::new(u64::MAX, 5_000_000_000, 1_000_000_000),
                     ChainIdFiller::default(), // TODO: use CHAIN_ID constant
                     NonceFiller::new(self.nonce_manager.clone()),
                     self.wallet.clone(),
@@ -388,9 +341,47 @@ impl ZombieNode {
             .await
             .cloned()
     }
+
+    pub fn node_genesis(
+        node_path: &Path,
+        wallet: &EthereumWallet,
+    ) -> anyhow::Result<serde_json::Value> {
+        let output = Command::new(node_path)
+            .arg(Self::EXPORT_CHAINSPEC_COMMAND)
+            .arg("--chain")
+            .arg("asset-hub-westend-local")
+            .env_remove("RUST_LOG")
+            .output()
+            .context("Failed to export the chainspec of the chain")?;
+
+        if !output.status.success() {
+            anyhow::bail!(
+                "substrate-node export-chain-spec failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+        }
+
+        let content = String::from_utf8(output.stdout)
+            .context("Failed to decode Substrate export-chain-spec output as UTF-8")?;
+        let mut chainspec_json = serde_json::from_str::<serde_json::Value>(&content)
+            .context("Failed to parse Substrate chain spec JSON")?;
+
+        let existing_chainspec_balances =
+            chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
+                .as_array_mut()
+                .expect("Can't fail");
+
+        for address in NetworkWallet::<Ethereum>::signer_addresses(wallet) {
+            let substrate_address = Self::eth_to_polkadot_address(&address);
+            let balance = INITIAL_BALANCE;
+            existing_chainspec_balances.push(json!((substrate_address, balance)));
+        }
+
+        Ok(chainspec_json)
+    }
 }
 
-impl EthereumNode for ZombieNode {
+impl EthereumNode for ZombienetNode {
     fn pre_transactions(&mut self) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + '_>> {
         Box::pin(async move { Ok(()) })
     }
@@ -440,17 +431,11 @@ impl EthereumNode for ZombieNode {
         transaction: alloy::rpc::types::TransactionRequest,
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<TransactionReceipt>> + '_>> {
         Box::pin(async move {
-            let receipt = self
+            let provider = self
                 .provider()
                 .await
-                .context("Failed to create provider for transaction submission")?
+                .context("Failed to create the provider")?;
-                .send_transaction(transaction)
+            execute_transaction(provider, transaction).await
-                .await
-                .context("Failed to submit transaction to proxy")?
-                .get_receipt()
-                .await
-                .context("Failed to fetch transaction receipt from proxy")?;
-            Ok(receipt)
         })
     }
 
@@ -544,33 +529,80 @@ impl EthereumNode for ZombieNode {
                 + '_,
         >,
     > {
-        Box::pin(async move {
+        #[subxt::subxt(runtime_metadata_path = "../../assets/revive_metadata.scale")]
-            let provider = self
+        pub mod revive {}
-                .provider()
+
-                .await
+        Box::pin(async move {
-                .context("Failed to create the provider for block subscription")?;
+            let substrate_rpc_url = format!("ws://127.0.0.1:{}", self.node_rpc_port.unwrap());
-            let mut block_subscription = provider
+            let api = OnlineClient::<SubstrateConfig>::from_url(substrate_rpc_url)
-                .watch_full_blocks()
+                .await
-                .await
+                .context("Failed to create subxt rpc client")?;
-                .context("Failed to create the blocks stream")?;
+            let provider = self.provider().await.context("Failed to create provider")?;
-            block_subscription.set_channel_size(0xFFFF);
+
-            block_subscription.set_poll_interval(Duration::from_secs(1));
+            let block_stream = api
-            let block_stream = block_subscription.into_stream();
+                .blocks()
+                .subscribe_all()
+                .await
+                .context("Failed to subscribe to blocks")?;
+
+            let mined_block_information_stream = block_stream.filter_map(move |block| {
+                let api = api.clone();
+                let provider = provider.clone();
+
+                async move {
+                    let substrate_block = block.ok()?;
+                    let revive_block = provider
+                        .get_block_by_number(
+                            BlockNumberOrTag::Number(substrate_block.number() as _),
+                        )
+                        .await
+                        .expect("TODO: Remove")
+                        .expect("TODO: Remove");
+
+                    let used = api
+                        .storage()
+                        .at(substrate_block.reference())
+                        .fetch_or_default(&revive::storage().system().block_weight())
+                        .await
+                        .expect("TODO: Remove");
+
+                    let block_ref_time = (used.normal.ref_time as u128)
+                        + (used.operational.ref_time as u128)
+                        + (used.mandatory.ref_time as u128);
+                    let block_proof_size = (used.normal.proof_size as u128)
+                        + (used.operational.proof_size as u128)
+                        + (used.mandatory.proof_size as u128);
+
+                    let limits = api
+                        .constants()
+                        .at(&revive::constants().system().block_weights())
+                        .expect("TODO: Remove");
+
+                    let max_ref_time = limits.max_block.ref_time;
+                    let max_proof_size = limits.max_block.proof_size;
 
-            let mined_block_information_stream = block_stream.filter_map(|block| async {
-                let block = block.ok()?;
                     Some(MinedBlockInformation {
-                    block_number: block.number(),
+                        ethereum_block_information: EthereumMinedBlockInformation {
-                    block_timestamp: block.header.timestamp,
+                            block_number: revive_block.number(),
-                    mined_gas: block.header.gas_used as _,
+                            block_timestamp: revive_block.header.timestamp,
-                    block_gas_limit: block.header.gas_limit,
+                            mined_gas: revive_block.header.gas_used as _,
-                    transaction_hashes: block
+                            block_gas_limit: revive_block.header.gas_limit as _,
+                            transaction_hashes: revive_block
                                 .transactions
                                 .into_hashes()
                                 .as_hashes()
                                 .expect("Must be hashes")
                                 .to_vec(),
+                        },
+                        substrate_block_information: Some(SubstrateMinedBlockInformation {
+                            ref_time: block_ref_time,
+                            max_ref_time,
+                            proof_size: block_proof_size,
+                            max_proof_size,
+                        }),
+                        tx_counts: Default::default(),
                     })
+                }
             });
 
             Ok(Box::pin(mined_block_information_stream)
@@ -578,25 +610,23 @@ impl EthereumNode for ZombieNode {
         })
     }
 
-    fn resolve_signer_or_default(&self, address: Address) -> Address {
+    fn provider(
-        let signer_addresses: Vec<_> =
+        &self,
-            <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet).collect();
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<alloy::providers::DynProvider<Ethereum>>> + '_>>
-        if signer_addresses.contains(&address) {
+    {
-            address
+        Box::pin(
-        } else {
+            self.provider()
-            self.wallet.default_signer().address()
+                .map(|provider| provider.map(|provider| provider.erased())),
-        }
+        )
     }
 }
 
-pub struct ZombieNodeResolver<F: TxFiller<ReviveNetwork>, P: Provider<ReviveNetwork>> {
+pub struct ZombieNodeResolver<F: TxFiller<Ethereum>, P: Provider<Ethereum>> {
     id: u32,
-    provider: FillProvider<F, P, ReviveNetwork>,
+    provider: FillProvider<F, P, Ethereum>,
 }
 
-impl<F: TxFiller<ReviveNetwork>, P: Provider<ReviveNetwork>> ResolverApi
+impl<F: TxFiller<Ethereum>, P: Provider<Ethereum>> ResolverApi for ZombieNodeResolver<F, P> {
-    for ZombieNodeResolver<F, P>
-{
     #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
     fn chain_id(
         &self,
@@ -719,7 +749,7 @@ impl<F: TxFiller<ReviveNetwork>, P: Provider<ReviveNetwork>> ResolverApi
     }
 }
 
-impl Node for ZombieNode {
+impl Node for ZombienetNode {
     fn shutdown(&mut self) -> anyhow::Result<()> {
         // Kill the eth_rpc process
         drop(self.eth_rpc_process.take());
@@ -764,7 +794,7 @@ impl Node for ZombieNode {
     }
 }
 
-impl Drop for ZombieNode {
+impl Drop for ZombienetNode {
     fn drop(&mut self) {
         let _ = self.shutdown();
     }
@@ -788,9 +818,9 @@ mod tests {
             TestExecutionContext::default()
         }
 
-        pub async fn new_node() -> (TestExecutionContext, ZombieNode) {
+        pub async fn new_node() -> (TestExecutionContext, ZombienetNode) {
             let context = test_config();
-            let mut node = ZombieNode::new(
+            let mut node = ZombienetNode::new(
                 context.polkadot_parachain_configuration.path.clone(),
                 &context,
             );
@@ -808,8 +838,9 @@ mod tests {
             (context, node)
         }
 
-        pub async fn shared_state() -> &'static (TestExecutionContext, Arc<ZombieNode>) {
+        pub async fn shared_state() -> &'static (TestExecutionContext, Arc<ZombienetNode>) {
-            static NODE: OnceCell<(TestExecutionContext, Arc<ZombieNode>)> = OnceCell::const_new();
+            static NODE: OnceCell<(TestExecutionContext, Arc<ZombienetNode>)> =
+                OnceCell::const_new();
 
             NODE.get_or_init(|| async {
                 let (context, node) = new_node().await;
@@ -818,14 +849,16 @@ mod tests {
             .await
         }
 
-        pub async fn shared_node() -> &'static Arc<ZombieNode> {
+        pub async fn shared_node() -> &'static Arc<ZombienetNode> {
             &shared_state().await.1
         }
     }
     use utils::{new_node, test_config};
 
     #[tokio::test]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn test_transfer_transaction_should_return_receipt() {
+        // Arrange
         let (ctx, node) = new_node().await;
 
         let provider = node.provider().await.expect("Failed to create provider");
@@ -834,106 +867,22 @@ mod tests {
             .to(account_address)
             .value(U256::from(100_000_000_000_000u128));
 
-        let receipt = provider.send_transaction(transaction).await;
+        // Act
-        let _ = receipt
+        let mut pending_transaction = provider
-            .expect("Failed to send the transfer transaction")
+            .send_transaction(transaction)
+            .await
+            .expect("Submission failed");
+        pending_transaction.set_timeout(Some(Duration::from_secs(60)));
+
+        // Assert
+        let _ = pending_transaction
             .get_receipt()
             .await
             .expect("Failed to get the receipt for the transfer");
     }
 
-    #[tokio::test]
-    async fn test_init_generates_chainspec_with_balances() {
-        let genesis_content = r#"
-        {
-            "alloc": {
-                "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
-                    "balance": "1000000000000000000"
-                },
-                "Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2": {
-                    "balance": "2000000000000000000"
-                }
-            }
-        }
-        "#;
-
-        let context = test_config();
-        let mut node = ZombieNode::new(
-            context.polkadot_parachain_configuration.path.clone(),
-            &context,
-        );
-
-        // Call `init()`
-        node.init(serde_json::from_str(genesis_content).unwrap())
-            .expect("init failed");
-
-        // Check that the patched chainspec file was generated
-        let final_chainspec_path = node.base_directory.join(ZombieNode::CHAIN_SPEC_JSON_FILE);
-        assert!(final_chainspec_path.exists(), "Chainspec file should exist");
-
-        let contents =
-            std::fs::read_to_string(&final_chainspec_path).expect("Failed to read chainspec");
-
-        // Validate that the Polkadot addresses derived from the Ethereum addresses are in the file
-        let first_eth_addr = ZombieNode::eth_to_polkadot_address(
-            &"90F8bf6A479f320ead074411a4B0e7944Ea8c9C1".parse().unwrap(),
-        );
-        let second_eth_addr = ZombieNode::eth_to_polkadot_address(
-            &"Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2".parse().unwrap(),
-        );
-
-        assert!(
-            contents.contains(&first_eth_addr),
-            "Chainspec should contain Polkadot address for first Ethereum account"
-        );
-        assert!(
-            contents.contains(&second_eth_addr),
-            "Chainspec should contain Polkadot address for second Ethereum account"
-        );
-    }
-
-    #[tokio::test]
-    async fn test_parse_genesis_alloc() {
-        // Create test genesis file
-        let genesis_json = r#"
-        {
-          "alloc": {
-            "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": { "balance": "1000000000000000000" },
-            "0x0000000000000000000000000000000000000000": { "balance": "0xDE0B6B3A7640000" },
-            "0xffffffffffffffffffffffffffffffffffffffff": { "balance": "123456789" }
-          }
-        }
-        "#;
-
-        let context = test_config();
-        let node = ZombieNode::new(
-            context.polkadot_parachain_configuration.path.clone(),
-            &context,
-        );
-
-        let result = node
-            .extract_balance_from_genesis_file(&serde_json::from_str(genesis_json).unwrap())
-            .unwrap();
-
-        let result_map: std::collections::HashMap<_, _> = result.into_iter().collect();
-
-        assert_eq!(
-            result_map.get("5FLneRcWAfk3X3tg6PuGyLNGAquPAZez5gpqvyuf3yUK8VaV"),
-            Some(&1_000_000_000_000_000_000u128)
-        );
-
-        assert_eq!(
-            result_map.get("5C4hrfjw9DjXZTzV3MwzrrAr9P1MLDHajjSidz9bR544LEq1"),
-            Some(&1_000_000_000_000_000_000u128)
-        );
-
-        assert_eq!(
-            result_map.get("5HrN7fHLXWcFiXPwwtq2EkSGns9eMmoUQnbVKweNz3VVr6N4"),
-            Some(&123_456_789u128)
-        );
-    }
-
     #[test]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     fn print_eth_to_polkadot_mappings() {
         let eth_addresses = vec![
             "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
@@ -942,13 +891,14 @@ mod tests {
         ];
 
         for eth_addr in eth_addresses {
-            let ss58 = ZombieNode::eth_to_polkadot_address(&eth_addr.parse().unwrap());
+            let ss58 = ZombienetNode::eth_to_polkadot_address(&eth_addr.parse().unwrap());
 
             println!("Ethereum: {eth_addr} -> Polkadot SS58: {ss58}");
         }
     }
 
     #[test]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     fn test_eth_to_polkadot_address() {
         let cases = vec![
             (
@@ -970,7 +920,7 @@ mod tests {
         ];
 
         for (eth_addr, expected_ss58) in cases {
-            let result = ZombieNode::eth_to_polkadot_address(&eth_addr.parse().unwrap());
+            let result = ZombienetNode::eth_to_polkadot_address(&eth_addr.parse().unwrap());
             assert_eq!(
                 result, expected_ss58,
                 "Mismatch for Ethereum address {eth_addr}"
@@ -979,10 +929,11 @@ mod tests {
     }
 
     #[test]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     fn eth_rpc_version_works() {
         // Arrange
         let context = test_config();
-        let node = ZombieNode::new(
+        let node = ZombienetNode::new(
             context.polkadot_parachain_configuration.path.clone(),
             &context,
         );
@@ -998,10 +949,11 @@ mod tests {
     }
 
     #[test]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     fn version_works() {
         // Arrange
         let context = test_config();
-        let node = ZombieNode::new(
+        let node = ZombienetNode::new(
             context.polkadot_parachain_configuration.path.clone(),
             &context,
         );
@@ -1017,7 +969,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[ignore = "Ignored since they take a long time to run"]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn get_chain_id_from_node_should_succeed() {
         // Arrange
         let node = shared_node().await;
@@ -1036,7 +988,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[ignore = "Ignored since they take a long time to run"]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn can_get_gas_limit_from_node() {
         // Arrange
         let node = shared_node().await;
@@ -1054,7 +1006,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[ignore = "Ignored since they take a long time to run"]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn can_get_coinbase_from_node() {
         // Arrange
         let node = shared_node().await;
@@ -1072,7 +1024,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[ignore = "Ignored since they take a long time to run"]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn can_get_block_difficulty_from_node() {
         // Arrange
         let node = shared_node().await;
@@ -1090,7 +1042,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[ignore = "Ignored since they take a long time to run"]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn can_get_block_hash_from_node() {
         // Arrange
         let node = shared_node().await;
@@ -1108,7 +1060,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[ignore = "Ignored since they take a long time to run"]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn can_get_block_timestamp_from_node() {
         // Arrange
         let node = shared_node().await;
@@ -1126,7 +1078,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[ignore = "Ignored since they take a long time to run"]
+    #[ignore = "Ignored since CI doesn't have zombienet installed"]
     async fn can_get_block_number_from_node() {
         // Arrange
         let node = shared_node().await;

crates/node/src/provider_utils/fallback_gas_filler.rs

@@ -7,6 +7,10 @@ use alloy::{
     transports::TransportResult,
 };
 
+// Percentage padding applied to estimated gas (e.g. 120 = 20% padding)
+const GAS_ESTIMATE_PADDING_NUMERATOR: u64 = 120;
+const GAS_ESTIMATE_PADDING_DENOMINATOR: u64 = 100;
+
 #[derive(Clone, Debug)]
 pub struct FallbackGasFiller {
     inner: GasFiller,
@@ -56,11 +60,12 @@ where
         provider: &P,
         tx: &<N as Network>::TransactionRequest,
     ) -> TransportResult<Self::Fillable> {
-        // Try to fetch GasFiller’s “fillable” (gas_price, base_fee, estimate_gas, …)
-        // If it errors (i.e. tx would revert under eth_estimateGas), swallow it.
         match self.inner.prepare(provider, tx).await {
             Ok(fill) => Ok(Some(fill)),
-            Err(_) => Ok(None),
+            Err(err) => {
+                tracing::debug!(error = ?err, "Gas Provider Estimation Failed, using fallback");
+                Ok(None)
+            }
         }
     }
 
@@ -70,8 +75,17 @@ where
         mut tx: alloy::providers::SendableTx<N>,
     ) -> TransportResult<SendableTx<N>> {
         if let Some(fill) = fillable {
-            // our inner GasFiller succeeded — use it
+            let mut tx = self.inner.fill(fill, tx).await?;
-            self.inner.fill(fill, tx).await
+            if let Some(builder) = tx.as_mut_builder() {
+                if let Some(estimated) = builder.gas_limit() {
+                    let padded = estimated
+                        .checked_mul(GAS_ESTIMATE_PADDING_NUMERATOR)
+                        .and_then(|v| v.checked_div(GAS_ESTIMATE_PADDING_DENOMINATOR))
+                        .unwrap_or(u64::MAX);
+                    builder.set_gas_limit(padded);
+                }
+            }
+            Ok(tx)
         } else {
             if let Some(builder) = tx.as_mut_builder() {
                 builder.set_gas_limit(self.default_gas_limit);

crates/node/src/provider_utils/mod.rs

@@ -1,7 +1,7 @@
 mod concurrency_limiter;
-mod fallback_gas_provider;
+mod fallback_gas_filler;
 mod provider;
 
 pub use concurrency_limiter::*;
-pub use fallback_gas_provider::*;
+pub use fallback_gas_filler::*;
 pub use provider::*;

crates/node/src/provider_utils/provider.rs

@@ -10,7 +10,7 @@ use alloy::{
 };
 use anyhow::{Context, Result};
 use revive_dt_common::futures::{PollingWaitBehavior, poll};
-use tracing::debug;
+use tracing::{Instrument, debug, info, info_span};
 
 use crate::provider_utils::{ConcurrencyLimiterLayer, FallbackGasFiller};
 
@@ -44,7 +44,7 @@ where
     // requests at any point of time and no more than that. This is done in an effort to stabilize
     // the framework from some of the interment issues that we've been seeing related to RPC calls.
     static GLOBAL_CONCURRENCY_LIMITER_LAYER: LazyLock<ConcurrencyLimiterLayer> =
-        LazyLock::new(|| ConcurrencyLimiterLayer::new(10));
+        LazyLock::new(|| ConcurrencyLimiterLayer::new(500));
 
     let client = ClientBuilder::default()
         .layer(GLOBAL_CONCURRENCY_LIMITER_LAYER.clone())
@@ -117,12 +117,16 @@ where
 
             async move {
                 match provider.get_transaction_receipt(tx_hash).await {
-                    Ok(Some(receipt)) => Ok(ControlFlow::Break(receipt)),
+                    Ok(Some(receipt)) => {
+                        info!("Found the transaction receipt");
+                        Ok(ControlFlow::Break(receipt))
+                    }
                     _ => Ok(ControlFlow::Continue(())),
                 }
             }
         },
     )
+    .instrument(info_span!("Polling for receipt", %tx_hash))
     .await
     .context(format!("Polling for receipt failed for {tx_hash}"))
 }

crates/report/Cargo.toml

@@ -17,6 +17,7 @@ alloy = { workspace = true }
 anyhow = { workspace = true }
 paste = { workspace = true }
 indexmap = { workspace = true, features = ["serde"] }
+itertools = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/report/src/aggregator.rs

@@ -4,19 +4,21 @@
 use std::{
     collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     fs::OpenOptions,
+    ops::{Add, Div},
     path::PathBuf,
     time::{SystemTime, UNIX_EPOCH},
 };
 
-use alloy::primitives::Address;
+use alloy::primitives::{Address, BlockNumber, BlockTimestamp, TxHash};
 use anyhow::{Context as _, Result};
 use indexmap::IndexMap;
+use itertools::Itertools;
 use revive_dt_common::types::PlatformIdentifier;
 use revive_dt_compiler::{CompilerInput, CompilerOutput, Mode};
 use revive_dt_config::Context;
-use revive_dt_format::{case::CaseIdx, corpus::Corpus, metadata::ContractInstance};
+use revive_dt_format::{case::CaseIdx, metadata::ContractInstance, steps::StepPath};
 use semver::Version;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use serde_with::{DisplayFromStr, serde_as};
 use tokio::sync::{
     broadcast::{Sender, channel},
@@ -39,7 +41,7 @@ pub struct ReportAggregator {
 impl ReportAggregator {
     pub fn new(context: Context) -> Self {
         let (runner_tx, runner_rx) = unbounded_channel::<RunnerEvent>();
-        let (listener_tx, _) = channel::<ReporterEvent>(1024);
+        let (listener_tx, _) = channel::<ReporterEvent>(0xFFFF);
         Self {
             report: Report::new(context),
             remaining_cases: Default::default(),
@@ -62,14 +64,11 @@ impl ReportAggregator {
         debug!("Starting to aggregate report");
 
         while let Some(event) = self.runner_rx.recv().await {
-            debug!(?event, "Received Event");
+            debug!(event = event.variant_name(), "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);
                 }
@@ -106,12 +105,20 @@ impl ReportAggregator {
                 RunnerEvent::ContractDeployed(event) => {
                     self.handle_contract_deployed_event(*event);
                 }
-                RunnerEvent::Completion(event) => {
+                RunnerEvent::Completion(_) => {
-                    self.handle_completion(*event);
                     break;
                 }
+                /* Benchmarks Events */
+                RunnerEvent::StepTransactionInformation(event) => {
+                    self.handle_step_transaction_information(*event)
+                }
+                RunnerEvent::ContractInformation(event) => {
+                    self.handle_contract_information(*event);
+                }
+                RunnerEvent::BlockMined(event) => self.handle_block_mined(*event),
             }
         }
+        self.handle_completion(CompletionEvent {});
         debug!("Report aggregation completed");
 
         let file_name = {
@@ -152,10 +159,6 @@ impl ReportAggregator {
         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());
     }
@@ -234,17 +237,19 @@ impl ReportAggregator {
 
         let case_status = self
             .report
-            .test_case_information
+            .execution_information
             .entry(specifier.metadata_file_path.clone().into())
             .or_default()
-            .entry(specifier.solc_mode.clone())
+            .case_reports
-            .or_default()
             .iter()
-            .map(|(case_idx, case_report)| {
+            .flat_map(|(case_idx, mode_to_execution_map)| {
-                (
+                let case_status = mode_to_execution_map
-                    *case_idx,
+                    .mode_execution_reports
-                    case_report.status.clone().expect("Can't be uninitialized"),
+                    .get(&specifier.solc_mode)?
-                )
+                    .status
+                    .clone()
+                    .expect("Can't be uninitialized");
+                Some((*case_idx, case_status))
             })
             .collect::<BTreeMap<_, _>>();
         let event = ReporterEvent::MetadataFileSolcModeCombinationExecutionCompleted {
@@ -383,22 +388,157 @@ impl ReportAggregator {
         self.execution_information(&event.execution_specifier)
             .deployed_contracts
             .get_or_insert_default()
-            .insert(event.contract_instance, event.address);
+            .insert(event.contract_instance.clone(), event.address);
+        self.test_case_report(&event.execution_specifier.test_specifier)
+            .contract_addresses
+            .entry(event.contract_instance)
+            .or_default()
+            .entry(event.execution_specifier.platform_identifier)
+            .or_default()
+            .push(event.address);
     }
 
     fn handle_completion(&mut self, _: CompletionEvent) {
         self.runner_rx.close();
+        self.handle_metrics_computation();
     }
 
-    fn test_case_report(&mut self, specifier: &TestSpecifier) -> &mut TestCaseReport {
+    fn handle_metrics_computation(&mut self) {
+        for report in self.report.execution_information.values_mut() {
+            for report in report.case_reports.values_mut() {
+                for report in report.mode_execution_reports.values_mut() {
+                    for (platform_identifier, block_information) in
+                        report.mined_block_information.iter_mut()
+                    {
+                        block_information.sort_by(|a, b| {
+                            a.ethereum_block_information
+                                .block_number
+                                .cmp(&b.ethereum_block_information.block_number)
+                        });
+
+                        // Computing the TPS.
+                        let tps = block_information
+                            .iter()
+                            .tuple_windows::<(_, _)>()
+                            .map(|(block1, block2)| {
+                                block2.ethereum_block_information.transaction_hashes.len() as u64
+                                    / (block2.ethereum_block_information.block_timestamp
+                                        - block1.ethereum_block_information.block_timestamp)
+                            })
+                            .collect::<Vec<_>>();
+                        report
+                            .metrics
+                            .get_or_insert_default()
+                            .transaction_per_second
+                            .with_list(*platform_identifier, tps);
+
+                        // Computing the GPS.
+                        let gps = block_information
+                            .iter()
+                            .tuple_windows::<(_, _)>()
+                            .map(|(block1, block2)| {
+                                block2.ethereum_block_information.mined_gas as u64
+                                    / (block2.ethereum_block_information.block_timestamp
+                                        - block1.ethereum_block_information.block_timestamp)
+                            })
+                            .collect::<Vec<_>>();
+                        report
+                            .metrics
+                            .get_or_insert_default()
+                            .gas_per_second
+                            .with_list(*platform_identifier, gps);
+
+                        // Computing the gas block fullness
+                        let gas_block_fullness = block_information
+                            .iter()
+                            .map(|block| block.gas_block_fullness_percentage())
+                            .map(|v| v as u64)
+                            .collect::<Vec<_>>();
+                        report
+                            .metrics
+                            .get_or_insert_default()
+                            .gas_block_fullness
+                            .with_list(*platform_identifier, gas_block_fullness);
+
+                        // Computing the ref-time block fullness
+                        let reftime_block_fullness = block_information
+                            .iter()
+                            .filter_map(|block| block.ref_time_block_fullness_percentage())
+                            .map(|v| v as u64)
+                            .collect::<Vec<_>>();
+                        if !reftime_block_fullness.is_empty() {
+                            report
+                                .metrics
+                                .get_or_insert_default()
+                                .ref_time_block_fullness
+                                .get_or_insert_default()
+                                .with_list(*platform_identifier, reftime_block_fullness);
+                        }
+
+                        // Computing the proof size block fullness
+                        let proof_size_block_fullness = block_information
+                            .iter()
+                            .filter_map(|block| block.proof_size_block_fullness_percentage())
+                            .map(|v| v as u64)
+                            .collect::<Vec<_>>();
+                        if !proof_size_block_fullness.is_empty() {
+                            report
+                                .metrics
+                                .get_or_insert_default()
+                                .proof_size_block_fullness
+                                .get_or_insert_default()
+                                .with_list(*platform_identifier, proof_size_block_fullness);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn handle_step_transaction_information(&mut self, event: StepTransactionInformationEvent) {
+        self.test_case_report(&event.execution_specifier.test_specifier)
+            .steps
+            .entry(event.step_path)
+            .or_default()
+            .transactions
+            .entry(event.execution_specifier.platform_identifier)
+            .or_default()
+            .push(event.transaction_information);
+    }
+
+    fn handle_contract_information(&mut self, event: ContractInformationEvent) {
+        self.test_case_report(&event.execution_specifier.test_specifier)
+            .compiled_contracts
+            .entry(event.source_code_path)
+            .or_default()
+            .entry(event.contract_name)
+            .or_default()
+            .contract_size
+            .insert(
+                event.execution_specifier.platform_identifier,
+                event.contract_size,
+            );
+    }
+
+    fn handle_block_mined(&mut self, event: BlockMinedEvent) {
+        self.test_case_report(&event.execution_specifier.test_specifier)
+            .mined_block_information
+            .entry(event.execution_specifier.platform_identifier)
+            .or_default()
+            .push(event.mined_block_information);
+    }
+
+    fn test_case_report(&mut self, specifier: &TestSpecifier) -> &mut ExecutionReport {
         self.report
-            .test_case_information
+            .execution_information
             .entry(specifier.metadata_file_path.clone().into())
             .or_default()
-            .entry(specifier.solc_mode.clone())
+            .case_reports
-            .or_default()
             .entry(specifier.case_idx)
             .or_default()
+            .mode_execution_reports
+            .entry(specifier.solc_mode.clone())
+            .or_default()
     }
 
     fn execution_information(
@@ -415,44 +555,78 @@ impl ReportAggregator {
 }
 
 #[serde_as]
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Report {
     /// The context that the tool was started up with.
     pub context: Context,
-    /// 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>,
+    /// Metrics from the execution.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metrics: Option<Metrics>,
     /// Information relating to each test case.
-    #[serde_as(as = "BTreeMap<_, HashMap<DisplayFromStr, BTreeMap<DisplayFromStr, _>>>")]
+    pub execution_information: BTreeMap<MetadataFilePath, MetadataFileReport>,
-    pub test_case_information:
-        BTreeMap<MetadataFilePath, HashMap<Mode, BTreeMap<CaseIdx, TestCaseReport>>>,
 }
 
 impl Report {
     pub fn new(context: Context) -> Self {
         Self {
             context,
-            corpora: Default::default(),
+            metrics: Default::default(),
             metadata_files: Default::default(),
-            test_case_information: Default::default(),
+            execution_information: Default::default(),
         }
     }
 }
 
-#[derive(Clone, Debug, Serialize, Default)]
+#[derive(Clone, Debug, Serialize, Deserialize, Default)]
-pub struct TestCaseReport {
+pub struct MetadataFileReport {
-    /// Information on the status of the test case and whether it succeeded, failed, or was
+    /// Metrics from the execution.
-    /// ignored.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metrics: Option<Metrics>,
+    /// The report of each case keyed by the case idx.
+    pub case_reports: BTreeMap<CaseIdx, CaseReport>,
+}
+
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize, Default)]
+pub struct CaseReport {
+    /// Metrics from the execution.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metrics: Option<Metrics>,
+    /// The [`ExecutionReport`] for each one of the [`Mode`]s.
+    #[serde_as(as = "HashMap<DisplayFromStr, _>")]
+    pub mode_execution_reports: HashMap<Mode, ExecutionReport>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Default)]
+pub struct ExecutionReport {
+    /// 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>,
+    /// Metrics from the execution.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metrics: Option<Metrics>,
     /// Information related to the execution on one of the platforms.
-    pub platform_execution: BTreeMap<PlatformIdentifier, Option<ExecutionInformation>>,
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub platform_execution: PlatformKeyedInformation<Option<ExecutionInformation>>,
+    /// Information on the compiled contracts.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub compiled_contracts: BTreeMap<PathBuf, BTreeMap<String, ContractInformation>>,
+    /// The addresses of the deployed contracts
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub contract_addresses: BTreeMap<ContractInstance, PlatformKeyedInformation<Vec<Address>>>,
+    /// Information on the mined blocks as part of this execution.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub mined_block_information: PlatformKeyedInformation<Vec<MinedBlockInformation>>,
+    /// Information tracked for each step that was executed.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub steps: BTreeMap<StepPath, StepReport>,
 }
 
 /// Information related to the status of the test. Could be that the test succeeded, failed, or that
 /// it was ignored.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "status")]
 pub enum TestCaseStatus {
     /// The test case succeeded.
@@ -476,7 +650,7 @@ pub enum TestCaseStatus {
 }
 
 /// Information related to the platform node that's being used to execute the step.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct TestCaseNodeInformation {
     /// The ID of the node that this case is being executed on.
     pub id: usize,
@@ -487,7 +661,7 @@ pub struct TestCaseNodeInformation {
 }
 
 /// Execution information tied to the platform.
-#[derive(Clone, Debug, Default, Serialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct ExecutionInformation {
     /// Information related to the node assigned to this test case.
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -507,7 +681,7 @@ pub struct ExecutionInformation {
 }
 
 /// Information related to compilation
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "status")]
 pub enum CompilationStatus {
     /// The compilation was successful.
@@ -545,3 +719,239 @@ pub enum CompilationStatus {
         compiler_input: Option<CompilerInput>,
     },
 }
+
+/// Information on each step in the execution.
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct StepReport {
+    /// Information on the transactions submitted as part of this step.
+    transactions: PlatformKeyedInformation<Vec<TransactionInformation>>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct TransactionInformation {
+    /// The hash of the transaction
+    pub transaction_hash: TxHash,
+    pub submission_timestamp: u64,
+    pub block_timestamp: u64,
+    pub block_number: BlockNumber,
+}
+
+/// The metrics we collect for our benchmarks.
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct Metrics {
+    pub transaction_per_second: Metric<u64>,
+    pub gas_per_second: Metric<u64>,
+    /* Block Fullness */
+    pub gas_block_fullness: Metric<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ref_time_block_fullness: Option<Metric<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub proof_size_block_fullness: Option<Metric<u64>>,
+}
+
+/// The data that we store for a given metric (e.g., TPS).
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct Metric<T> {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minimum: Option<PlatformKeyedInformation<T>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maximum: Option<PlatformKeyedInformation<T>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mean: Option<PlatformKeyedInformation<T>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub median: Option<PlatformKeyedInformation<T>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raw: Option<PlatformKeyedInformation<Vec<T>>>,
+}
+
+impl<T> Metric<T>
+where
+    T: Default
+        + Copy
+        + Ord
+        + PartialOrd
+        + Add<Output = T>
+        + Div<Output = T>
+        + TryFrom<usize, Error: std::fmt::Debug>,
+{
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn platform_identifiers(&self) -> BTreeSet<PlatformIdentifier> {
+        self.minimum
+            .as_ref()
+            .map(|m| m.keys())
+            .into_iter()
+            .flatten()
+            .chain(
+                self.maximum
+                    .as_ref()
+                    .map(|m| m.keys())
+                    .into_iter()
+                    .flatten(),
+            )
+            .chain(self.mean.as_ref().map(|m| m.keys()).into_iter().flatten())
+            .chain(self.median.as_ref().map(|m| m.keys()).into_iter().flatten())
+            .chain(self.raw.as_ref().map(|m| m.keys()).into_iter().flatten())
+            .copied()
+            .collect()
+    }
+
+    pub fn with_list(
+        &mut self,
+        platform_identifier: PlatformIdentifier,
+        original_list: Vec<T>,
+    ) -> &mut Self {
+        let mut list = original_list.clone();
+        list.sort();
+        let Some(min) = list.first().copied() else {
+            return self;
+        };
+        let Some(max) = list.last().copied() else {
+            return self;
+        };
+        let sum = list.iter().fold(T::default(), |acc, num| acc + *num);
+        let mean = sum / TryInto::<T>::try_into(list.len()).unwrap();
+
+        let median = match list.len().is_multiple_of(2) {
+            true => {
+                let idx = list.len() / 2;
+                let val1 = *list.get(idx - 1).unwrap();
+                let val2 = *list.get(idx).unwrap();
+                (val1 + val2) / TryInto::<T>::try_into(2usize).unwrap()
+            }
+            false => {
+                let idx = list.len() / 2;
+                *list.get(idx).unwrap()
+            }
+        };
+
+        self.minimum
+            .get_or_insert_default()
+            .insert(platform_identifier, min);
+        self.maximum
+            .get_or_insert_default()
+            .insert(platform_identifier, max);
+        self.mean
+            .get_or_insert_default()
+            .insert(platform_identifier, mean);
+        self.median
+            .get_or_insert_default()
+            .insert(platform_identifier, median);
+        self.raw
+            .get_or_insert_default()
+            .insert(platform_identifier, original_list);
+
+        self
+    }
+
+    pub fn combine(&self, other: &Self) -> Self {
+        let mut platform_identifiers = self.platform_identifiers();
+        platform_identifiers.extend(other.platform_identifiers());
+
+        let mut this = Self::new();
+        for platform_identifier in platform_identifiers {
+            let mut l1 = self
+                .raw
+                .as_ref()
+                .and_then(|m| m.get(&platform_identifier))
+                .cloned()
+                .unwrap_or_default();
+            let l2 = other
+                .raw
+                .as_ref()
+                .and_then(|m| m.get(&platform_identifier))
+                .cloned()
+                .unwrap_or_default();
+            l1.extend(l2);
+            this.with_list(platform_identifier, l1);
+        }
+
+        this
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Default)]
+pub struct ContractInformation {
+    /// The size of the contract on the various platforms.
+    pub contract_size: PlatformKeyedInformation<usize>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct MinedBlockInformation {
+    pub ethereum_block_information: EthereumMinedBlockInformation,
+    pub substrate_block_information: Option<SubstrateMinedBlockInformation>,
+    pub tx_counts: BTreeMap<StepPath, usize>,
+}
+
+impl MinedBlockInformation {
+    pub fn gas_block_fullness_percentage(&self) -> u8 {
+        self.ethereum_block_information
+            .gas_block_fullness_percentage()
+    }
+
+    pub fn ref_time_block_fullness_percentage(&self) -> Option<u8> {
+        self.substrate_block_information
+            .as_ref()
+            .map(|block| block.ref_time_block_fullness_percentage())
+    }
+
+    pub fn proof_size_block_fullness_percentage(&self) -> Option<u8> {
+        self.substrate_block_information
+            .as_ref()
+            .map(|block| block.proof_size_block_fullness_percentage())
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct EthereumMinedBlockInformation {
+    /// The block number.
+    pub block_number: BlockNumber,
+
+    /// The block timestamp.
+    pub block_timestamp: BlockTimestamp,
+
+    /// The amount of gas mined in the block.
+    pub mined_gas: u128,
+
+    /// The gas limit of the block.
+    pub block_gas_limit: u128,
+
+    /// The hashes of the transactions that were mined as part of the block.
+    pub transaction_hashes: Vec<TxHash>,
+}
+
+impl EthereumMinedBlockInformation {
+    pub fn gas_block_fullness_percentage(&self) -> u8 {
+        (self.mined_gas * 100 / self.block_gas_limit) as u8
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct SubstrateMinedBlockInformation {
+    /// The ref time for substrate based chains.
+    pub ref_time: u128,
+
+    /// The max ref time for substrate based chains.
+    pub max_ref_time: u64,
+
+    /// The proof size for substrate based chains.
+    pub proof_size: u128,
+
+    /// The max proof size for substrate based chains.
+    pub max_proof_size: u64,
+}
+
+impl SubstrateMinedBlockInformation {
+    pub fn ref_time_block_fullness_percentage(&self) -> u8 {
+        (self.ref_time * 100 / self.max_ref_time as u128) as u8
+    }
+
+    pub fn proof_size_block_fullness_percentage(&self) -> u8 {
+        (self.proof_size * 100 / self.max_proof_size as u128) as u8
+    }
+}
+
+/// Information keyed by the platform identifier.
+pub type PlatformKeyedInformation<T> = BTreeMap<PlatformIdentifier, T>;

crates/report/src/runner_event.rs

@@ -8,13 +8,14 @@ use anyhow::Context as _;
 use indexmap::IndexMap;
 use revive_dt_common::types::PlatformIdentifier;
 use revive_dt_compiler::{CompilerInput, CompilerOutput};
-use revive_dt_format::{
+use revive_dt_format::metadata::ContractInstance;
-    corpus::Corpus,
+use revive_dt_format::metadata::Metadata;
-    metadata::{ContractInstance, Metadata},
+use revive_dt_format::steps::StepPath;
-};
 use semver::Version;
 use tokio::sync::{broadcast, oneshot};
 
+use crate::MinedBlockInformation;
+use crate::TransactionInformation;
 use crate::{ExecutionSpecifier, ReporterEvent, TestSpecifier, common::MetadataFilePath};
 
 macro_rules! __report_gen_emit_test_specific {
@@ -346,6 +347,16 @@ macro_rules! define_event {
                 ),*
             }
 
+            impl $ident {
+                pub fn variant_name(&self) -> &'static str {
+                    match self {
+                        $(
+                            Self::$variant_ident { .. } => stringify!($variant_ident)
+                        ),*
+                    }
+                }
+            }
+
             $(
                 #[derive(Debug)]
                 $(#[$variant_meta])*
@@ -482,11 +493,6 @@ define_event! {
             /// 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.
@@ -616,7 +622,35 @@ define_event! {
             address: Address
         },
         /// Reports the completion of the run.
-        Completion {}
+        Completion {},
+
+        /* Benchmarks Events */
+        /// An event emitted with information on a transaction that was submitted for a certain step
+        /// of the execution.
+        StepTransactionInformation {
+            /// A specifier for the execution that's taking place.
+            execution_specifier: Arc<ExecutionSpecifier>,
+            /// The path of the step that this transaction belongs to.
+            step_path: StepPath,
+            /// Information about the transaction
+            transaction_information: TransactionInformation
+        },
+        ContractInformation {
+            /// A specifier for the execution that's taking place.
+            execution_specifier: Arc<ExecutionSpecifier>,
+            /// The path of the solidity source code that contains the contract.
+            source_code_path: PathBuf,
+            /// The name of the contract
+            contract_name: String,
+            /// The size of the contract
+            contract_size: usize
+        },
+        BlockMined {
+            /// A specifier for the execution that's taking place.
+            execution_specifier: Arc<ExecutionSpecifier>,
+            /// Information on the mined block,
+            mined_block_information: MinedBlockInformation
+        }
     }
 }
 

crates/solc-binaries/src/download.rs

@@ -2,12 +2,13 @@
 
 use std::{
     collections::HashMap,
+    str::FromStr,
     sync::{LazyLock, Mutex},
 };
 
 use revive_dt_common::types::VersionOrRequirement;
 
-use semver::Version;
+use semver::{Version, VersionReq};
 use sha2::{Digest, Sha256};
 
 use crate::list::List;
@@ -65,6 +66,9 @@ impl SolcDownloader {
         target: &'static str,
         list: &'static str,
     ) -> anyhow::Result<Self> {
+        static MAXIMUM_COMPILER_VERSION_REQUIREMENT: LazyLock<VersionReq> =
+            LazyLock::new(|| VersionReq::from_str("<=0.8.30").unwrap());
+
         let version_or_requirement = version.into();
         match version_or_requirement {
             VersionOrRequirement::Version(version) => Ok(Self {
@@ -79,7 +83,10 @@ impl SolcDownloader {
                     .builds
                     .into_iter()
                     .map(|build| build.version)
-                    .filter(|version| requirement.matches(version))
+                    .filter(|version| {
+                        MAXIMUM_COMPILER_VERSION_REQUIREMENT.matches(version)
+                            && requirement.matches(version)
+                    })
                     .max()
                 else {
                     anyhow::bail!("Failed to find a version that satisfies {requirement:?}");

scripts/print_benchmark_metrics_csv.py

@@ -0,0 +1,246 @@
+"""
+Utilities to print benchmark metrics from a report JSON into CSV.
+
+Usage:
+  python scripts/print_benchmark_metrics_csv.py /absolute/path/to/report.json
+
+The script prints, for each metadata path, case index, and mode combination,
+CSV rows aligned to mined blocks with the following columns:
+  - block_number
+  - number_of_txs
+  - tps (transaction_per_second)
+  - gps (gas_per_second)
+  - gas_block_fullness
+  - ref_time (if available)
+  - max_ref_time (if available)
+  - proof_size (if available)
+  - max_proof_size (if available)
+  - ref_time_block_fullness (if available)
+  - proof_size_block_fullness (if available)
+
+Important nuance: TPS and GPS arrays have (number_of_blocks - 1) items. The
+first block row has no TPS/GPS; the CSV leaves those cells empty for the first
+row and aligns subsequent values to their corresponding next block.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import csv
+from typing import List, Mapping, TypedDict
+
+
+class EthereumMinedBlockInformation(TypedDict):
+    """EVM block information extracted from the report.
+
+    Attributes:
+        block_number: The block height.
+        block_timestamp: The UNIX timestamp of the block.
+        mined_gas: Total gas used (mined) in the block.
+        block_gas_limit: The gas limit of the block.
+        transaction_hashes: List of transaction hashes included in the block.
+    """
+
+    block_number: int
+    block_timestamp: int
+    mined_gas: int
+    block_gas_limit: int
+    transaction_hashes: List[str]
+
+
+class SubstrateMinedBlockInformation(TypedDict):
+    """Substrate-specific block resource usage fields.
+
+    Attributes:
+        ref_time: The consumed ref time in the block.
+        max_ref_time: The maximum ref time allowed for the block.
+        proof_size: The consumed proof size in the block.
+        max_proof_size: The maximum proof size allowed for the block.
+    """
+
+    ref_time: int
+    max_ref_time: int
+    proof_size: int
+    max_proof_size: int
+
+
+class MinedBlockInformation(TypedDict):
+    """Block-level information for a mined block with both EVM and optional Substrate fields."""
+
+    ethereum_block_information: EthereumMinedBlockInformation
+    substrate_block_information: SubstrateMinedBlockInformation
+
+
+class Metric(TypedDict):
+    """Metric data of integer values keyed by platform identifier.
+
+    Attributes:
+        minimum: Single scalar minimum per platform.
+        maximum: Single scalar maximum per platform.
+        mean: Single scalar mean per platform.
+        median: Single scalar median per platform.
+        raw: Time-series (or list) of values per platform.
+    """
+
+    minimum: Mapping[str, int]
+    maximum: Mapping[str, int]
+    mean: Mapping[str, int]
+    median: Mapping[str, int]
+    raw: Mapping[str, List[int]]
+
+
+class Metrics(TypedDict):
+    """All metrics that may be present for a given execution report.
+
+    Note that some metrics are optional and present only for specific platforms
+    or execution modes.
+    """
+
+    transaction_per_second: Metric
+    gas_per_second: Metric
+    gas_block_fullness: Metric
+    ref_time_block_fullness: Metric
+    proof_size_block_fullness: Metric
+
+
+class ExecutionReport(TypedDict):
+    """Execution report for a mode containing mined blocks and metrics.
+
+    Attributes:
+        mined_block_information: Mapping from platform identifier to the list of
+            mined blocks observed for that platform.
+        metrics: The computed metrics for the execution.
+    """
+
+    mined_block_information: Mapping[str, List[MinedBlockInformation]]
+    metrics: Metrics
+
+
+class CaseReport(TypedDict):
+    """Report for a single case, keyed by mode string."""
+
+    mode_execution_reports: Mapping[str, ExecutionReport]
+
+
+class MetadataFileReport(TypedDict):
+    """Report subtree keyed by case indices for a metadata file path."""
+
+    case_reports: Mapping[str, CaseReport]
+
+
+class ReportRoot(TypedDict):
+    """Top-level report schema with execution information keyed by metadata path."""
+
+    execution_information: Mapping[str, MetadataFileReport]
+
+
+BlockInformation = TypedDict(
+    "BlockInformation",
+    {
+        "Block Number": int,
+        "Timestamp": int,
+        "Datetime": None,
+        "Transaction Count": int,
+        "TPS": int | None,
+        "GPS": int | None,
+        "Ref Time": int,
+        "Max Ref Time": int,
+        "Block Fullness Ref Time": int,
+        "Proof Size": int,
+        "Max Proof Size": int,
+        "Block Fullness Proof Size": int,
+    },
+)
+"""A typed dictionary used to hold all of the block information"""
+
+
+def load_report(path: str) -> ReportRoot:
+    """Load the report JSON from disk.
+
+    Args:
+        path: Absolute or relative filesystem path to the JSON report file.
+
+    Returns:
+        The parsed report as a typed dictionary structure.
+    """
+
+    with open(path, "r", encoding="utf-8") as f:
+        data: ReportRoot = json.load(f)
+    return data
+
+
+def main() -> None:
+    report_path: str = sys.argv[1]
+    report: ReportRoot = load_report(report_path)
+
+    # TODO: Remove this in the future, but for now, the target is fixed.
+    target: str = "revive-dev-node-revm-solc"
+
+    csv_writer = csv.writer(sys.stdout)
+
+    for _, metadata_file_report in report["execution_information"].items():
+        for _, case_report in metadata_file_report["case_reports"].items():
+            for _, execution_report in case_report["mode_execution_reports"].items():
+                blocks_information: list[MinedBlockInformation] = execution_report[
+                    "mined_block_information"
+                ][target]
+
+                resolved_blocks: list[BlockInformation] = []
+                for i, block_information in enumerate(blocks_information):
+                    resolved_blocks.append(
+                        {
+                            "Block Number": block_information[
+                                "ethereum_block_information"
+                            ]["block_number"],
+                            "Timestamp": block_information[
+                                "ethereum_block_information"
+                            ]["block_timestamp"],
+                            "Datetime": None,
+                            "Transaction Count": len(
+                                block_information["ethereum_block_information"][
+                                    "transaction_hashes"
+                                ]
+                            ),
+                            "TPS": (
+                                None
+                                if i == 0
+                                else execution_report["metrics"][
+                                    "transaction_per_second"
+                                ]["raw"][target][i - 1]
+                            ),
+                            "GPS": (
+                                None
+                                if i == 0
+                                else execution_report["metrics"]["gas_per_second"][
+                                    "raw"
+                                ][target][i - 1]
+                            ),
+                            "Ref Time": block_information[
+                                "substrate_block_information"
+                            ]["ref_time"],
+                            "Max Ref Time": block_information[
+                                "substrate_block_information"
+                            ]["max_ref_time"],
+                            "Block Fullness Ref Time": execution_report["metrics"][
+                                "ref_time_block_fullness"
+                            ]["raw"][target][i],
+                            "Proof Size": block_information[
+                                "substrate_block_information"
+                            ]["proof_size"],
+                            "Max Proof Size": block_information[
+                                "substrate_block_information"
+                            ]["max_proof_size"],
+                            "Block Fullness Proof Size": execution_report["metrics"][
+                                "proof_size_block_fullness"
+                            ]["raw"][target][i],
+                        }
+                    )
+
+                csv_writer = csv.DictWriter(sys.stdout, resolved_blocks[0].keys())
+                csv_writer.writeheader()
+                csv_writer.writerows(resolved_blocks)
+
+
+if __name__ == "__main__":
+    main()

scripts/process-differential-tests-report.py

@@ -0,0 +1,226 @@
+"""
+This script is used to turn the JSON report produced by the revive differential tests tool into an
+easy to consume markdown document for the purpose of reporting this information in the Polkadot SDK
+CI. The full models used in the JSON report can be found in the revive differential tests repo and
+the models used in this script are just a partial reproduction of the full report models.
+"""
+
+from typing import TypedDict, Literal, Union
+
+import json, io
+
+
+class Report(TypedDict):
+    context: "Context"
+    execution_information: dict[
+        "MetadataFilePathString",
+        dict["ModeString", dict["CaseIdxString", "CaseReport"]],
+    ]
+
+
+class Context(TypedDict):
+    Test: "TestContext"
+
+
+class TestContext(TypedDict):
+    corpus_configuration: "CorpusConfiguration"
+
+
+class CorpusConfiguration(TypedDict):
+    test_specifiers: list["TestSpecifier"]
+
+
+class CaseReport(TypedDict):
+    status: "CaseStatus"
+
+
+class CaseStatusSuccess(TypedDict):
+    status: Literal["Succeeded"]
+    steps_executed: int
+
+
+class CaseStatusFailure(TypedDict):
+    status: Literal["Failed"]
+    reason: str
+
+
+class CaseStatusIgnored(TypedDict):
+    status: Literal["Ignored"]
+    reason: str
+
+
+CaseStatus = Union[CaseStatusSuccess, CaseStatusFailure, CaseStatusIgnored]
+"""A union type of all of the possible statuses that could be reported for a case."""
+
+TestSpecifier = str
+"""A test specifier string. For example resolc-compiler-tests/fixtures/solidity/test.json::0::Y+"""
+
+ModeString = str
+"""The mode string. For example Y+ >=0.8.13"""
+
+MetadataFilePathString = str
+"""The path to a metadata file. For example resolc-compiler-tests/fixtures/solidity/test.json"""
+
+CaseIdxString = str
+"""The index of a case as a string. For example '0'"""
+
+
+def path_relative_to_resolc_compiler_test_directory(path: str) -> str:
+    """
+    Given a path, this function returns the path relative to the resolc-compiler-test directory. The
+    following is an example of an input and an output:
+
+    Input: ~/polkadot-sdk/revive-differential-tests/resolc-compiler-tests/fixtures/solidity/test.json
+    Output: test.json
+    """
+
+    return f"{path.split('resolc-compiler-tests/fixtures/solidity')[-1].strip('/')}"
+
+
+def main() -> None:
+    with open("report.json", "r") as file:
+        report: Report = json.load(file)
+
+    # Starting the markdown document and adding information to it as we go.
+    markdown_document: io.TextIOWrapper = open("report.md", "w")
+    print("# Differential Tests Results", file=markdown_document)
+
+    # Getting all of the test specifiers from the report and making them relative to the tests dir.
+    test_specifiers: list[str] = list(
+        map(
+            path_relative_to_resolc_compiler_test_directory,
+            report["context"]["Test"]["corpus_configuration"]["test_specifiers"],
+        )
+    )
+    print("## Specified Tests", file=markdown_document)
+    for test_specifier in test_specifiers:
+        print(f"* `{test_specifier}`", file=markdown_document)
+
+    # Counting the total number of test cases, successes, failures, and ignored tests
+    total_number_of_cases: int = 0
+    total_number_of_successes: int = 0
+    total_number_of_failures: int = 0
+    total_number_of_ignores: int = 0
+    for _, mode_to_case_mapping in report["execution_information"].items():
+        for _, case_idx_to_report_mapping in mode_to_case_mapping.items():
+            for _, case_report in case_idx_to_report_mapping.items():
+                status: CaseStatus = case_report["status"]
+
+                total_number_of_cases += 1
+                if status["status"] == "Succeeded":
+                    total_number_of_successes += 1
+                elif status["status"] == "Failed":
+                    total_number_of_failures += 1
+                elif status["status"] == "Ignored":
+                    total_number_of_ignores += 1
+                else:
+                    raise Exception(
+                        f"Encountered a status that's unknown to the script: {status}"
+                    )
+
+    print("## Counts", file=markdown_document)
+    print(
+        f"* **Total Number of Test Cases:** {total_number_of_cases}",
+        file=markdown_document,
+    )
+    print(
+        f"* **Total Number of Successes:** {total_number_of_successes}",
+        file=markdown_document,
+    )
+    print(
+        f"* **Total Number of Failures:** {total_number_of_failures}",
+        file=markdown_document,
+    )
+    print(
+        f"* **Total Number of Ignores:** {total_number_of_ignores}",
+        file=markdown_document,
+    )
+
+    # Grouping the various test cases into dictionaries and groups depending on their status to make
+    # them easier to include in the markdown document later on.
+    successful_cases: dict[
+        MetadataFilePathString, dict[CaseIdxString, set[ModeString]]
+    ] = {}
+    for metadata_file_path, mode_to_case_mapping in report[
+        "execution_information"
+    ].items():
+        for mode_string, case_idx_to_report_mapping in mode_to_case_mapping.items():
+            for case_idx_string, case_report in case_idx_to_report_mapping.items():
+                status: CaseStatus = case_report["status"]
+                metadata_file_path: str = (
+                    path_relative_to_resolc_compiler_test_directory(metadata_file_path)
+                )
+                mode_string: str = mode_string.replace(" M3", "+").replace(" M0", "-")
+
+                if status["status"] == "Succeeded":
+                    successful_cases.setdefault(
+                        metadata_file_path,
+                        {},
+                    ).setdefault(
+                        case_idx_string, set()
+                    ).add(mode_string)
+
+    print("## Failures", file=markdown_document)
+    print(
+        "The test specifiers seen in this section have the format 'path::case_idx::compilation_mode'\
+          and they're compatible with the revive differential tests framework and can be specified\
+          to it directly in the same way that they're provided through the `--test` argument of the\
+          framework.\n",
+        file=markdown_document,
+    )
+    print(
+        "The failures are provided in an expandable section to ensure that the PR does not get \
+        polluted with information. Please click on the section below for more information",
+        file=markdown_document,
+    )
+    print(
+        "<details><summary>Detailed Differential Tests Failure Information</summary>\n\n",
+        file=markdown_document,
+    )
+    print("| Test Specifier | Failure Reason | Note |", file=markdown_document)
+    print("| -- | -- | -- |", file=markdown_document)
+
+    for metadata_file_path, mode_to_case_mapping in report[
+        "execution_information"
+    ].items():
+        for mode_string, case_idx_to_report_mapping in mode_to_case_mapping.items():
+            for case_idx_string, case_report in case_idx_to_report_mapping.items():
+                status: CaseStatus = case_report["status"]
+                metadata_file_path: str = (
+                    path_relative_to_resolc_compiler_test_directory(metadata_file_path)
+                )
+                mode_string: str = mode_string.replace(" M3", "+").replace(" M0", "-")
+
+                if status["status"] != "Failed":
+                    continue
+
+                failure_reason: str = status["reason"].replace("\n", " ")
+
+                note: str = ""
+                modes_where_this_case_succeeded: set[ModeString] = (
+                    successful_cases.setdefault(
+                        metadata_file_path,
+                        {},
+                    ).setdefault(case_idx_string, set())
+                )
+                if len(modes_where_this_case_succeeded) != 0:
+                    note: str = (
+                        f"This test case succeeded with other compilation modes: {modes_where_this_case_succeeded}"
+                    )
+
+                test_specifier: str = (
+                    f"{metadata_file_path}::{case_idx_string}::{mode_string}"
+                )
+                print(
+                    f"| `{test_specifier}` | `{failure_reason}` | {note} |",
+                    file=markdown_document,
+                )
+    print("\n\n</details>", file=markdown_document)
+
+    # The primary downside of not using `with`, but I guess it's better since I don't want to over
+    # indent the code.
+    markdown_document.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/run_tests.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 # Revive Differential Tests - Quick Start Script
-# This script clones the test repository, sets up the corpus file, and runs the tool
+# This script clones the test repository, and runs the tool
 
 set -e  # Exit on any error
 
@@ -14,7 +14,6 @@ NC='\033[0m' # No Color
 # Configuration
 TEST_REPO_URL="https://github.com/paritytech/resolc-compiler-tests"
 TEST_REPO_DIR="resolc-compiler-tests"
-CORPUS_FILE="./corpus.json"
 WORKDIR="workdir"
 
 # Optional positional argument: path to polkadot-sdk directory
@@ -23,7 +22,6 @@ POLKADOT_SDK_DIR="${1:-}"
 # Binary paths (default to names in $PATH)
 REVIVE_DEV_NODE_BIN="revive-dev-node"
 ETH_RPC_BIN="eth-rpc"
-SUBSTRATE_NODE_BIN="substrate-node"
 
 echo -e "${GREEN}=== Revive Differential Tests Quick Start ===${NC}"
 echo ""
@@ -51,14 +49,13 @@ if [ -n "$POLKADOT_SDK_DIR" ]; then
 
     REVIVE_DEV_NODE_BIN="$POLKADOT_SDK_DIR/target/release/revive-dev-node"
     ETH_RPC_BIN="$POLKADOT_SDK_DIR/target/release/eth-rpc"
-    SUBSTRATE_NODE_BIN="$POLKADOT_SDK_DIR/target/release/substrate-node"
 
-    if [ ! -x "$REVIVE_DEV_NODE_BIN" ] || [ ! -x "$ETH_RPC_BIN" ] || [ ! -x "$SUBSTRATE_NODE_BIN" ]; then
+    if [ ! -x "$REVIVE_DEV_NODE_BIN" ] || [ ! -x "$ETH_RPC_BIN" ]; then
         echo -e "${YELLOW}Required binaries not found in release target. Building...${NC}"
         (cd "$POLKADOT_SDK_DIR" && cargo build --release --package staging-node-cli --package pallet-revive-eth-rpc --package revive-dev-node)
     fi
 
-    for bin in "$REVIVE_DEV_NODE_BIN" "$ETH_RPC_BIN" "$SUBSTRATE_NODE_BIN"; do
+    for bin in "$REVIVE_DEV_NODE_BIN" "$ETH_RPC_BIN"; do
         if [ ! -x "$bin" ]; then
             echo -e "${RED}Expected binary not found after build: $bin${NC}"
             exit 1
@@ -68,21 +65,6 @@ else
     echo -e "${YELLOW}No polkadot-sdk path provided. Using binaries from $PATH.${NC}"
 fi
 
-# Create corpus file with absolute path resolved at runtime
-echo -e "${GREEN}Creating corpus file...${NC}"
-ABSOLUTE_PATH=$(realpath "$TEST_REPO_DIR/fixtures/solidity/")
-
-cat > "$CORPUS_FILE" << EOF
-{
-  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
-  "paths": [
-    "$(realpath "$TEST_REPO_DIR/fixtures/solidity/simple")"
-  ]
-}
-EOF
-
-echo -e "${GREEN}Corpus file created: $CORPUS_FILE${NC}"
-
 # Create workdir if it doesn't exist
 mkdir -p "$WORKDIR"
 
@@ -93,14 +75,13 @@ echo ""
 # Run the tool
 cargo build --release;
 RUST_LOG="info,alloy_pubsub::service=error" ./target/release/retester test \
-    --platform revive-dev-node-revm-solc \
+    --platform revive-dev-node-polkavm-resolc \
-    --corpus "$CORPUS_FILE" \
+    --test $(realpath "$TEST_REPO_DIR/fixtures/solidity") \
     --working-directory "$WORKDIR" \
     --concurrency.number-of-nodes 10 \
     --concurrency.number-of-threads 5 \
-    --concurrency.number-of-concurrent-tasks 1000 \
+    --concurrency.number-of-concurrent-tasks 500 \
     --wallet.additional-keys 100000 \
-    --kitchensink.path "$SUBSTRATE_NODE_BIN" \
     --revive-dev-node.path "$REVIVE_DEV_NODE_BIN" \
     --eth-rpc.path "$ETH_RPC_BIN" \
     > logs.log \