Add a cached fs abstraction

Add compiler directives to metadata (#139 )
Misc features/improvements (#138 )
2026-04-22 21:57:58 +00:00 · 2025-08-14 17:38:12 +03:00 · 2025-08-14 07:38:56 +00:00 · 2025-08-13 13:50:06 +00:00 · 2025-08-13 13:10:26 +00:00 · 2025-08-12 10:19:59 +00:00
56 changed files with 6602 additions and 1655 deletions
@@ -99,9 +99,12 @@ jobs:
      - name: Install Geth on Ubuntu
        if: matrix.os == 'ubuntu-24.04'
        run: |
+          sudo add-apt-repository -y ppa:ethereum/ethereum
          sudo apt-get update
          sudo apt-get install -y protobuf-compiler

+          sudo apt-get install -y solc
+
          # We were facing some issues in CI with the 1.16.* versions of geth, and specifically on
          # Ubuntu. Eventually, we found out that the last version of geth that worked in our CI was
          # version 1.15.11. Thus, this is the version that we want to use in CI. The PPA sadly does
@@ -122,12 +125,22 @@ jobs:
          wget -qO- "$URL" | sudo tar xz -C /usr/local/bin --strip-components=1
          geth --version

+          curl -sL https://github.com/paritytech/revive/releases/download/v0.3.0/resolc-x86_64-unknown-linux-musl -o resolc
+          chmod +x resolc
+          sudo mv resolc /usr/local/bin
+
      - name: Install Geth on macOS
        if: matrix.os == 'macos-14'
        run: |
          brew tap ethereum/ethereum
          brew install ethereum protobuf

+          brew install solidity
+
+          curl -sL https://github.com/paritytech/revive/releases/download/v0.3.0/resolc-universal-apple-darwin -o resolc
+          chmod +x resolc
+          sudo mv resolc /usr/local/bin
+
      - name: Machete
        uses: bnjbvr/cargo-machete@v0.7.1

@@ -143,5 +156,8 @@ jobs:
      - name: Check eth-rpc version
        run: eth-rpc --version

+      - name: Check resolc version
+        run: resolc --version
+
      - name: Test cargo workspace
        run: make test
@@ -67,9 +67,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"

 [[package]]
 name = "alloy"
-version = "1.0.20"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae58d888221eecf621595e2096836ce7cfc37be06bfa39d7f64aa6a3ea4c9e5b"
+checksum = "8ad4eb51e7845257b70c51b38ef8d842d5e5e93196701fcbd757577971a043c6"
 dependencies = [
 "alloy-consensus",
 "alloy-contract",
@@ -102,15 +102,16 @@ dependencies = [

 [[package]]
 name = "alloy-consensus"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad451f9a70c341d951bca4e811d74dbe1e193897acd17e9dbac1353698cc430b"
+checksum = "ca3b746060277f3d7f9c36903bb39b593a741cb7afcb0044164c28f0e9b673f0"
 dependencies = [
 "alloy-eips",
 "alloy-primitives",
 "alloy-rlp",
 "alloy-serde",
 "alloy-trie",
+ "alloy-tx-macros",
 "auto_impl",
 "c-kzg",
 "derive_more 2.0.1",
@@ -126,9 +127,9 @@ dependencies = [

 [[package]]
 name = "alloy-consensus-any"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "142daffb15d5be1a2b20d2cd540edbcef03037b55d4ff69dc06beb4d06286dba"
+checksum = "bf98679329fa708fa809ea596db6d974da892b068ad45e48ac1956f582edf946"
 dependencies = [
 "alloy-consensus",
 "alloy-eips",
@@ -140,9 +141,9 @@ dependencies = [

 [[package]]
 name = "alloy-contract"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebf25443920ecb9728cb087fe4dc04a0b290bd6ac85638c58fe94aba70f1a44e"
+checksum = "a10e47f5305ea08c37b1772086c1573e9a0a257227143996841172d37d3831bb"
 dependencies = [
 "alloy-consensus",
 "alloy-dyn-abi",
@@ -157,6 +158,7 @@ dependencies = [
 "alloy-transport",
 "futures",
 "futures-util",
+ "serde_json",
 "thiserror 2.0.12",
 ]

@@ -227,9 +229,9 @@ dependencies = [

 [[package]]
 name = "alloy-eips"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3056872f6da48046913e76edb5ddced272861f6032f09461aea1a2497be5ae5d"
+checksum = "f562a81278a3ed83290e68361f2d1c75d018ae3b8589a314faf9303883e18ec9"
 dependencies = [
 "alloy-eip2124",
 "alloy-eip2930",
@@ -247,15 +249,16 @@ dependencies = [

 [[package]]
 name = "alloy-genesis"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c98fb40f07997529235cc474de814cd7bd9de561e101716289095696c0e4639d"
+checksum = "dc41384e9ab8c9b2fb387c52774d9d432656a28edcda1c2d4083e96051524518"
 dependencies = [
 "alloy-eips",
 "alloy-primitives",
 "alloy-serde",
 "alloy-trie",
 "serde",
+ "serde_with",
 ]

 [[package]]
@@ -272,12 +275,13 @@ dependencies = [

 [[package]]
 name = "alloy-json-rpc"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc08b31ebf9273839bd9a01f9333cbb7a3abb4e820c312ade349dd18bdc79581"
+checksum = "12c454fcfcd5d26ed3b8cae5933cbee9da5f0b05df19b46d4bd4446d1f082565"
 dependencies = [
 "alloy-primitives",
 "alloy-sol-types",
+ "http",
 "serde",
 "serde_json",
 "thiserror 2.0.12",
@@ -286,9 +290,9 @@ dependencies = [

 [[package]]
 name = "alloy-network"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed117b08f0cc190312bf0c38c34cf4f0dabfb4ea8f330071c587cd7160a88cb2"
+checksum = "42d6d39eabe5c7b3d8f23ac47b0b683b99faa4359797114636c66e0743103d05"
 dependencies = [
 "alloy-consensus",
 "alloy-consensus-any",
@@ -312,9 +316,9 @@ dependencies = [

 [[package]]
 name = "alloy-network-primitives"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7162ff7be8649c0c391f4e248d1273e85c62076703a1f3ec7daf76b283d886d"
+checksum = "3704fa8b7ba9ba3f378d99b3d628c8bc8c2fc431b709947930f154e22a8368b6"
 dependencies = [
 "alloy-consensus",
 "alloy-eips",
@@ -335,14 +339,15 @@ dependencies = [
 "const-hex",
 "derive_more 2.0.1",
 "foldhash",
+ "getrandom 0.3.3",
 "hashbrown 0.15.3",
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "itoa",
 "k256",
 "keccak-asm",
 "paste",
 "proptest",
- "rand 0.9.1",
+ "rand 0.9.2",
 "ruint",
 "rustc-hash",
 "serde",
@@ -352,9 +357,9 @@ dependencies = [

 [[package]]
 name = "alloy-provider"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d84eba1fd8b6fe8b02f2acd5dd7033d0f179e304bd722d11e817db570d1fa6c4"
+checksum = "08800e8cbe70c19e2eb7cf3d7ff4b28bdd9b3933f8e1c8136c7d910617ba03bf"
 dependencies = [
 "alloy-chains",
 "alloy-consensus",
@@ -380,6 +385,7 @@ dependencies = [
 "either",
 "futures",
 "futures-utils-wasm",
+ "http",
 "lru",
 "parking_lot",
 "pin-project",
@@ -395,9 +401,9 @@ dependencies = [

 [[package]]
 name = "alloy-pubsub"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8550f7306e0230fc835eb2ff4af0a96362db4b6fc3f25767d161e0ad0ac765bf"
+checksum = "ae68457a2c2ead6bd7d7acb5bf5f1623324b1962d4f8e7b0250657a3c3ab0a0b"
 dependencies = [
 "alloy-json-rpc",
 "alloy-primitives",
@@ -438,9 +444,9 @@ dependencies = [

 [[package]]
 name = "alloy-rpc-client"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "518a699422a3eab800f3dac2130d8f2edba8e4fff267b27a9c7dc6a2b0d313ee"
+checksum = "162301b5a57d4d8f000bf30f4dcb82f9f468f3e5e846eeb8598dd39e7886932c"
 dependencies = [
 "alloy-json-rpc",
 "alloy-primitives",
@@ -448,7 +454,6 @@ dependencies = [
 "alloy-transport",
 "alloy-transport-http",
 "alloy-transport-ipc",
- "async-stream",
 "futures",
 "pin-project",
 "reqwest",
@@ -458,16 +463,15 @@ dependencies = [
 "tokio-stream",
 "tower",
 "tracing",
- "tracing-futures",
 "url",
 "wasmtimer",
 ]

 [[package]]
 name = "alloy-rpc-types"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c000cab4ec26a4b3e29d144e999e1c539c2fa0abed871bf90311eb3466187ca8"
+checksum = "6cd8ca94ae7e2b32cc3895d9981f3772aab0b4756aa60e9ed0bcfee50f0e1328"
 dependencies = [
 "alloy-primitives",
 "alloy-rpc-types-eth",
@@ -478,9 +482,9 @@ dependencies = [

 [[package]]
 name = "alloy-rpc-types-any"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "508b2fbe66d952089aa694e53802327798806498cd29ff88c75135770ecaabfc"
+checksum = "076b47e834b367d8618c52dd0a0d6a711ddf66154636df394805300af4923b8a"
 dependencies = [
 "alloy-consensus-any",
 "alloy-rpc-types-eth",
@@ -489,9 +493,9 @@ dependencies = [

 [[package]]
 name = "alloy-rpc-types-debug"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c832f2e851801093928dbb4b7bd83cd22270faf76b2e080646b806a285c8757"
+checksum = "94a2a86ad7b7d718c15e79d0779bd255561b6b22968dc5ed2e7c0fbc43bb55fe"
 dependencies = [
 "alloy-primitives",
 "serde",
@@ -499,9 +503,9 @@ dependencies = [

 [[package]]
 name = "alloy-rpc-types-eth"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcaf7dff0fdd756a714d58014f4f8354a1706ebf9fa2cf73431e0aeec3c9431e"
+checksum = "2c2f847e635ec0be819d06e2ada4bcc4e4204026a83c4bfd78ae8d550e027ae7"
 dependencies = [
 "alloy-consensus",
 "alloy-consensus-any",
@@ -514,14 +518,15 @@ dependencies = [
 "itertools 0.14.0",
 "serde",
 "serde_json",
+ "serde_with",
 "thiserror 2.0.12",
 ]

 [[package]]
 name = "alloy-rpc-types-trace"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e3507a04e868dd83219ad3cd6a8c58aefccb64d33f426b3934423a206343e84"
+checksum = "6fc58180302a94c934d455eeedb3ecb99cdc93da1dbddcdbbdb79dd6fe618b2a"
 dependencies = [
 "alloy-primitives",
 "alloy-rpc-types-eth",
@@ -533,9 +538,9 @@ dependencies = [

 [[package]]
 name = "alloy-serde"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "730e8f2edf2fc224cabd1c25d090e1655fa6137b2e409f92e5eec735903f1507"
+checksum = "ae699248d02ade9db493bbdae61822277dc14ae0f82a5a4153203b60e34422a6"
 dependencies = [
 "alloy-primitives",
 "serde",
@@ -544,9 +549,9 @@ dependencies = [

 [[package]]
 name = "alloy-signer"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b0d2428445ec13edc711909e023d7779618504c4800be055a5b940025dbafe3"
+checksum = "3cf7d793c813515e2b627b19a15693960b3ed06670f9f66759396d06ebe5747b"
 dependencies = [
 "alloy-primitives",
 "async-trait",
@@ -559,9 +564,9 @@ dependencies = [

 [[package]]
 name = "alloy-signer-local"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14fe6fedb7fe6e0dfae47fe020684f1d8e063274ef14bca387ddb7a6efa8ec1"
+checksum = "51a424bc5a11df0d898ce0fd15906b88ebe2a6e4f17a514b51bc93946bb756bd"
 dependencies = [
 "alloy-consensus",
 "alloy-network",
@@ -597,7 +602,7 @@ dependencies = [
 "alloy-sol-macro-input",
 "const-hex",
 "heck",
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "proc-macro-error2",
 "proc-macro2",
 "quote",
@@ -648,9 +653,9 @@ dependencies = [

 [[package]]
 name = "alloy-transport"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a712bdfeff42401a7dd9518f72f617574c36226a9b5414537fedc34350b73bf9"
+checksum = "4f317d20f047b3de4d9728c556e2e9a92c9a507702d2016424cd8be13a74ca5e"
 dependencies = [
 "alloy-json-rpc",
 "alloy-primitives",
@@ -671,9 +676,9 @@ dependencies = [

 [[package]]
 name = "alloy-transport-http"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ea5a76d7f2572174a382aedf36875bedf60bcc41116c9f031cf08040703a2dc"
+checksum = "ff084ac7b1f318c87b579d221f11b748341d68b9ddaa4ffca5e62ed2b8cfefb4"
 dependencies = [
 "alloy-json-rpc",
 "alloy-transport",
@@ -686,9 +691,9 @@ dependencies = [

 [[package]]
 name = "alloy-transport-ipc"
-version = "1.0.9"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "606af17a7e064d219746f6d2625676122c79d78bf73dfe746d6db9ecd7dbcb85"
+checksum = "edb099cdad8ed2e6a80811cdf9bbf715ebf4e34c981b4a6e2d1f9daacbf8b218"
 dependencies = [
 "alloy-json-rpc",
 "alloy-pubsub",
@@ -706,9 +711,9 @@ dependencies = [

 [[package]]
 name = "alloy-trie"
-version = "0.8.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "983d99aa81f586cef9dae38443245e585840fcf0fc58b09aee0b1f27aed1d500"
+checksum = "bada1fc392a33665de0dc50d401a3701b62583c655e3522a323490a5da016962"
 dependencies = [
 "alloy-primitives",
 "alloy-rlp",
@@ -720,6 +725,19 @@ dependencies = [
 "tracing",
 ]

+[[package]]
+name = "alloy-tx-macros"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1154c8187a5ff985c95a8b2daa2fedcf778b17d7668e5e50e556c4ff9c881154"
+dependencies = [
+ "alloy-primitives",
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -1626,6 +1644,15 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"

+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -2210,6 +2237,66 @@ dependencies = [
 "percent-encoding",
 ]

+[[package]]
+name = "foundry-compilers-artifacts"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2676d70082ed23680fe2d08c0b750d5f7f2438c6d946f1cb140a76c5e5e0392"
+dependencies = [
+ "foundry-compilers-artifacts-solc",
+ "foundry-compilers-artifacts-vyper",
+]
+
+[[package]]
+name = "foundry-compilers-artifacts-solc"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3ada94dc5946334bb08df574855ba345ab03ba8c6f233560c72c8d61fa9db80"
+dependencies = [
+ "alloy-json-abi",
+ "alloy-primitives",
+ "foundry-compilers-core",
+ "path-slash",
+ "regex",
+ "semver 1.0.26",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.12",
+ "tracing",
+ "yansi",
+]
+
+[[package]]
+name = "foundry-compilers-artifacts-vyper"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "372052af72652e375a6e7eed22179bd8935114e25e1c5a8cca7f00e8f20bd94c"
+dependencies = [
+ "alloy-json-abi",
+ "alloy-primitives",
+ "foundry-compilers-artifacts-solc",
+ "foundry-compilers-core",
+ "path-slash",
+ "semver 1.0.26",
+ "serde",
+]
+
+[[package]]
+name = "foundry-compilers-core"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf0962c46855979300f6526ed57f987ccf6a025c2b92ce574b281d9cb2ef666b"
+dependencies = [
+ "alloy-primitives",
+ "cfg-if",
+ "dunce",
+ "path-slash",
+ "semver 1.0.26",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "fs-err"
 version = "2.11.0"
@@ -2321,6 +2408,20 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9"

+[[package]]
+name = "generator"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d18470a76cb7f8ff746cf1f7470914f900252ec36bbc40b569d74b1258446827"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "log",
+ "rustversion",
+ "windows",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -2400,7 +2501,7 @@ dependencies = [
 "futures-core",
 "futures-sink",
 "http",
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "slab",
 "tokio",
 "tokio-util",
@@ -2635,7 +2736,7 @@ dependencies = [
 "libc",
 "percent-encoding",
 "pin-project-lite",
- "socket2",
+ "socket2 0.5.10",
 "system-configuration",
 "tokio",
 "tower-service",
@@ -2842,9 +2943,9 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
 "equivalent",
 "hashbrown 0.15.3",
@@ -2875,6 +2976,17 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "io-uring"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4"
+dependencies = [
+ "bitflags 2.9.1",
+ "cfg-if",
+ "libc",
+]
+
 [[package]]
 name = "ipnet"
 version = "2.11.0"
@@ -3076,6 +3188,19 @@ version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"

+[[package]]
+name = "loom"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
+dependencies = [
+ "cfg-if",
+ "generator",
+ "scoped-tls",
+ "tracing",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "lru"
 version = "0.13.0"
@@ -3158,6 +3283,25 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

+[[package]]
+name = "moka"
+version = "0.12.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9321642ca94a4282428e6ea4af8cc2ca4eac48ac7a6a4ea8f33f76d0ce70926"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "loom",
+ "parking_lot",
+ "portable-atomic",
+ "rustc_version 0.4.1",
+ "smallvec",
+ "tagptr",
+ "thiserror 1.0.69",
+ "uuid",
+]
+
 [[package]]
 name = "native-tls"
 version = "0.2.14"
@@ -3268,13 +3412,14 @@ dependencies = [

 [[package]]
 name = "nybbles"
-version = "0.3.4"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8983bb634df7248924ee0c4c3a749609b5abcb082c28fffe3254b3eb3602b307"
+checksum = "675b3a54e5b12af997abc8b6638b0aee51a28caedab70d4967e0d5db3a3f1d06"
 dependencies = [
 "alloy-rlp",
- "const-hex",
+ "cfg-if",
 "proptest",
+ "ruint",
 "serde",
 "smallvec",
 ]
@@ -3438,6 +3583,12 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

+[[package]]
+name = "path-slash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e91099d4268b0e11973f036e885d652fb0b21fedcf69738c627f94db6a44f42"
+
 [[package]]
 name = "pbkdf2"
 version = "0.12.2"
@@ -3550,6 +3701,12 @@ dependencies = [
 "syn 2.0.101",
 ]

+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
 [[package]]
 name = "potential_utf"
 version = "0.1.2"
@@ -3719,9 +3876,9 @@ dependencies = [

 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
 "rand_chacha 0.9.0",
 "rand_core 0.9.3",
@@ -3884,9 +4041,7 @@ dependencies = [
 "base64",
 "bytes",
 "encoding_rs",
- "futures-channel",
 "futures-core",
- "futures-util",
 "h2",
 "http",
 "http-body",
@@ -3931,16 +4086,33 @@ dependencies = [
 ]

 [[package]]
-name = "revive-dt-compiler"
+name = "revive-dt-common"
 version = "0.1.0"
 dependencies = [
 "anyhow",
+ "moka",
+ "once_cell",
+ "semver 1.0.26",
+ "tokio",
+]
+
+[[package]]
+name = "revive-dt-compiler"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "alloy-primitives",
+ "anyhow",
+ "foundry-compilers-artifacts",
 "revive-common",
+ "revive-dt-common",
 "revive-dt-config",
 "revive-dt-solc-binaries",
 "revive-solc-json-interface",
 "semver 1.0.26",
+ "serde",
 "serde_json",
+ "tokio",
 "tracing",
 ]

@@ -3962,16 +4134,19 @@ dependencies = [
 "alloy",
 "anyhow",
 "clap",
- "rayon",
+ "futures",
+ "indexmap 2.10.0",
+ "revive-dt-common",
 "revive-dt-compiler",
 "revive-dt-config",
 "revive-dt-format",
 "revive-dt-node",
 "revive-dt-node-interaction",
 "revive-dt-report",
- "revive-solc-json-interface",
+ "semver 1.0.26",
 "serde_json",
 "temp-dir",
+ "tokio",
 "tracing",
 "tracing-subscriber",
 ]
@@ -3984,9 +4159,12 @@ dependencies = [
 "alloy-primitives",
 "alloy-sol-types",
 "anyhow",
+ "revive-common",
+ "revive-dt-common",
 "semver 1.0.26",
 "serde",
 "serde_json",
+ "tokio",
 "tracing",
 ]

@@ -3996,8 +4174,12 @@ version = "0.1.0"
 dependencies = [
 "alloy",
 "anyhow",
+ "revive-common",
+ "revive-dt-common",
 "revive-dt-config",
+ "revive-dt-format",
 "revive-dt-node-interaction",
+ "serde",
 "serde_json",
 "sp-core",
 "sp-runtime",
@@ -4012,10 +4194,6 @@ version = "0.1.0"
 dependencies = [
 "alloy",
 "anyhow",
- "futures",
- "once_cell",
- "tokio",
- "tracing",
 ]

 [[package]]
@@ -4023,9 +4201,9 @@ name = "revive-dt-report"
 version = "0.1.0"
 dependencies = [
 "anyhow",
+ "revive-dt-compiler",
 "revive-dt-config",
 "revive-dt-format",
- "revive-solc-json-interface",
 "serde",
 "serde_json",
 "tracing",
@@ -4038,9 +4216,11 @@ dependencies = [
 "anyhow",
 "hex",
 "reqwest",
+ "revive-dt-common",
 "semver 1.0.26",
 "serde",
 "sha2 0.10.9",
+ "tokio",
 "tracing",
 ]

@@ -4110,7 +4290,7 @@ dependencies = [
 "primitive-types 0.12.2",
 "proptest",
 "rand 0.8.5",
- "rand 0.9.1",
+ "rand 0.9.2",
 "rlp",
 "ruint-macro",
 "serde",
@@ -4135,6 +4315,9 @@ name = "rustc-hash"
 version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+dependencies = [
+ "rand 0.8.5",
+]

 [[package]]
 name = "rustc-hex"
@@ -4304,6 +4487,12 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -4505,7 +4694,7 @@ dependencies = [
 "chrono",
 "hex",
 "indexmap 1.9.3",
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "serde",
 "serde_derive",
 "serde_json",
@@ -4594,6 +4783,15 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"

+[[package]]
+name = "signal-hook-registry"
+version = "1.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "signature"
 version = "2.2.0"
@@ -4638,6 +4836,16 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "socket2"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "sp-application-crypto"
 version = "40.1.0"
@@ -5137,6 +5345,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -5297,18 +5511,21 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

 [[package]]
 name = "tokio"
-version = "1.45.1"
+version = "1.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75ef51a33ef1da925cea3e4eb122833cb377c61439ca401b770f54902b806779"
+checksum = "43864ed400b6043a4757a25c7a64a8efde741aed79a056a2fb348a406701bb35"
 dependencies = [
 "backtrace",
 "bytes",
+ "io-uring",
 "libc",
 "mio",
 "pin-project-lite",
- "socket2",
+ "signal-hook-registry",
+ "slab",
+ "socket2 0.6.0",
 "tokio-macros",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -5394,7 +5611,7 @@ version = "0.22.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
 dependencies = [
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "serde",
 "serde_spanned",
 "toml_datetime",
@@ -5486,18 +5703,6 @@ dependencies = [
 "valuable",
 ]

-[[package]]
-name = "tracing-futures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
-dependencies = [
- "futures",
- "futures-task",
- "pin-project",
- "tracing",
-]
-
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -5678,6 +5883,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"

+[[package]]
+name = "uuid"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
+dependencies = [
+ "getrandom 0.3.3",
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.1"
@@ -5939,6 +6155,28 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core",
+ "windows-future",
+ "windows-link",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.61.2"
@@ -5952,6 +6190,17 @@ dependencies = [
 "windows-strings 0.4.2",
 ]

+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core",
+ "windows-link",
+ "windows-threading",
+]
+
 [[package]]
 name = "windows-implement"
 version = "0.60.0"
@@ -5976,9 +6225,19 @@ dependencies = [

 [[package]]
 name = "windows-link"
-version = "0.1.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core",
+ "windows-link",
+]

 [[package]]
 name = "windows-registry"
@@ -6068,6 +6327,15 @@ dependencies = [
 "windows_x86_64_msvc 0.53.0",
 ]

+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -6197,6 +6465,12 @@ dependencies = [
 "tap",
 ]

+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+
 [[package]]
 name = "yoke"
 version = "0.8.0"
@@ -8,9 +8,10 @@ authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT/Apache-2.0"
 edition = "2024"
 repository = "https://github.com/paritytech/revive-differential-testing.git"
-rust-version = "1.85.0"
+rust-version = "1.87.0"

 [workspace.dependencies]
+revive-dt-common = { version = "0.1.0", path = "crates/common" }
 revive-dt-compiler = { version = "0.1.0", path = "crates/compiler" }
 revive-dt-config = { version = "0.1.0", path = "crates/config" }
 revive-dt-core = { version = "0.1.0", path = "crates/core" }
@@ -25,24 +26,28 @@ alloy-primitives = "1.2.1"
 alloy-sol-types = "1.2.1"
 anyhow = "1.0"
 clap = { version = "4", features = ["derive"] }
+foundry-compilers-artifacts = { version = "0.18.0" }
 futures = { version = "0.3.31" }
 hex = "0.4.3"
-reqwest = { version = "0.12.15", features = ["blocking", "json"] }
+moka = "0.12.10"
+reqwest = { version = "0.12.15", features = ["json"] }
 once_cell = "1.21"
-rayon = { version = "1.10" }
 semver = { version = "1.0", features = ["serde"] }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0", default-features = false, features = [
    "arbitrary_precision",
    "std",
+    "unbounded_depth",
 ] }
 sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"
 sp-runtime = "41.1.0"
 temp-dir = { version = "0.1.16" }
 tempfile = "3.3"
-tokio = { version = "1", default-features = false, features = [
+tokio = { version = "1.47.0", default-features = false, features = [
    "rt-multi-thread",
+    "process",
+    "rt",
 ] }
 uuid = { version = "1.8", features = ["v4"] }
 tracing = "0.1.41"
@@ -51,6 +56,7 @@ tracing-subscriber = { version = "0.3.19", default-features = false, features =
    "json",
    "env-filter",
 ] }
+indexmap = { version = "2.10.0", default-features = false }

 # revive compiler
 revive-solc-json-interface = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
@@ -58,7 +64,7 @@ revive-common = { git = "https://github.com/paritytech/revive", rev = "3389865af
 revive-differential = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }

 [workspace.dependencies.alloy]
-version = "1.0"
+version = "1.0.22"
 default-features = false
 features = [
    "json-abi",
@@ -72,6 +78,7 @@ features = [
    "network",
    "serde",
    "rpc-types-eth",
+    "genesis",
 ]

 [profile.bench]
@@ -0,0 +1,338 @@
+{
+    "modes": [
+        "Y >=0.8.9",
+        "E",
+        "I"
+    ],
+    "cases": [
+        {
+            "name": "first",
+            "inputs": [
+                {
+                    "address": "0xdeadbeef00000000000000000000000000000042",
+                    "expected_balance": "1233"
+                },
+                {
+                    "address": "0xdeadbeef00000000000000000000000000000042",
+                    "is_storage_empty": true
+                },
+                {
+                    "address": "0xdeadbeef00000000000000000000000000000042",
+                    "is_storage_empty": false
+                },
+                {
+                    "instance": "WBTC_1",
+                    "method": "#deployer",
+                    "calldata": [
+                        "0x40",
+                        "0x80",
+                        "4",
+                        "0x5742544300000000000000000000000000000000000000000000000000000000",
+                        "14",
+                        "0x5772617070656420425443000000000000000000000000000000000000000000"
+                    ],
+                    "expected": [
+                        "WBTC_1.address"
+                    ]
+                },
+                {
+                    "instance": "WBTC_2",
+                    "method": "#deployer",
+                    "calldata": [
+                        "0x40",
+                        "0x80",
+                        "4",
+                        "0x5742544300000000000000000000000000000000000000000000000000000000",
+                        "14",
+                        "0x5772617070656420425443000000000000000000000000000000000000000000"
+                    ],
+                    "expected": [
+                        "WBTC_2.address"
+                    ]
+                },
+                {
+                    "instance": "Mooniswap",
+                    "method": "#deployer",
+                    "calldata": [
+                        "0x0000000000000000000000000000000000000000000000000000000000000060",
+                        "0x00000000000000000000000000000000000000000000000000000000000000c0",
+                        "0x0000000000000000000000000000000000000000000000000000000000000100",
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                        "WBTC_1.address",
+                        "WBTC_2.address",
+                        "4",
+                        "0x5742544300000000000000000000000000000000000000000000000000000000",
+                        "14",
+                        "0x5772617070656420425443000000000000000000000000000000000000000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "Mooniswap.address"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef01000000000000000000000000000000"
+                                ],
+                                "values": []
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_1",
+                    "method": "_mint",
+                    "calldata": [
+                        "0xdeadbeef00000000000000000000000000000042",
+                        "1000000000"
+                    ],
+                    "expected": {
+                        "return_data": [],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "1000000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_2",
+                    "method": "_mint",
+                    "calldata": [
+                        "0xdeadbeef00000000000000000000000000000042",
+                        "1000000000"
+                    ],
+                    "expected": {
+                        "return_data": [],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "1000000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_1",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "approve",
+                    "calldata": [
+                        "Mooniswap.address",
+                        "500000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "0x0000000000000000000000000000000000000000000000000000000000000001"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "500000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_2",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "approve",
+                    "calldata": [
+                        "Mooniswap.address",
+                        "500000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "0x0000000000000000000000000000000000000000000000000000000000000001"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "500000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "Mooniswap",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "deposit",
+                    "calldata": [
+                        "0x0000000000000000000000000000000000000000000000000000000000000040",
+                        "0x00000000000000000000000000000000000000000000000000000000000000a0",
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                        "10000000",
+                        "10000000",
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                        "1000000",
+                        "1000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "10000000"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "1000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "490000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "490000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0x2da466a7b24304f47e87fa2e1e5a81b9831ce54fec19055ce277ca2f39ba42c4",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "Mooniswap",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "swap",
+                    "calldata": [
+                        "WBTC_1.address",
+                        "WBTC_2.address",
+                        "5000",
+                        "5000",
+                        "0"
+                    ]
+                }
+            ],
+            "expected": {
+                "return_data": [
+                    "5000"
+                ],
+                "events": [
+                    {
+                        "topics": [
+                            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                            "0xdeadbeef00000000000000000000000000000042",
+                            "Mooniswap.address"
+                        ],
+                        "values": [
+                            "5000"
+                        ]
+                    },
+                    {
+                        "topics": [
+                            "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                            "0xdeadbeef00000000000000000000000000000042",
+                            "Mooniswap.address"
+                        ],
+                        "values": [
+                            "489995000"
+                        ]
+                    }
+                ],
+                "exception": false
+            }
+        }
+    ],
+    "contracts": {
+        "Mooniswap": "Mooniswap.sol:Mooniswap",
+        "WBTC_1": "ERC20/ERC20.sol:ERC20",
+        "WBTC_2": "ERC20/ERC20.sol:ERC20",
+        "VirtualBalance": "Mooniswap.sol:VirtualBalance",
+        "Math": "math/Math.sol:Math"
+    },
+    "libraries": {
+        "Mooniswap.sol": {
+            "VirtualBalance": "VirtualBalance"
+        },
+        "math/Math.sol": {
+            "Math": "Math"
+        }
+    },
+    "group": "Real life"
+}
@@ -0,0 +1,16 @@
+[package]
+name = "revive-dt-common"
+description = "A library containing common concepts that other crates in the workspace can rely on"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+moka = { workspace = true, features = ["sync"] }
+once_cell = { workspace = true }
+semver = { workspace = true }
+tokio = { workspace = true, default-features = false, features = ["time"] }
@@ -0,0 +1,49 @@
+//! This module implements a cached file system allowing for results to be stored in-memory rather
+//! rather being queried from the file system again.
+
+use std::fs;
+use std::io::{Error, Result};
+use std::path::{Path, PathBuf};
+
+use moka::sync::Cache;
+use once_cell::sync::Lazy;
+
+pub fn read(path: impl AsRef<Path>) -> Result<Vec<u8>> {
+    static READ_CACHE: Lazy<Cache<PathBuf, Vec<u8>>> = Lazy::new(|| Cache::new(10_000));
+
+    let path = path.as_ref().canonicalize()?;
+    match READ_CACHE.get(path.as_path()) {
+        Some(content) => Ok(content),
+        None => {
+            let content = fs::read(path.as_path())?;
+            READ_CACHE.insert(path, content.clone());
+            Ok(content)
+        }
+    }
+}
+
+pub fn read_to_string(path: impl AsRef<Path>) -> Result<String> {
+    let content = read(path)?;
+    String::from_utf8(content).map_err(|_| {
+        Error::new(
+            std::io::ErrorKind::InvalidData,
+            "The contents of the file are not valid UTF8",
+        )
+    })
+}
+
+pub fn read_dir(path: impl AsRef<Path>) -> Result<Box<dyn Iterator<Item = Result<PathBuf>>>> {
+    static READ_DIR_CACHE: Lazy<Cache<PathBuf, Vec<PathBuf>>> = Lazy::new(|| Cache::new(10_000));
+
+    let path = path.as_ref().canonicalize()?;
+    match READ_DIR_CACHE.get(path.as_path()) {
+        Some(entries) => Ok(Box::new(entries.into_iter().map(Ok)) as Box<_>),
+        None => {
+            let entries = fs::read_dir(path.as_path())?
+                .flat_map(|maybe_entry| maybe_entry.map(|entry| entry.path()))
+                .collect();
+            READ_DIR_CACHE.insert(path.clone(), entries);
+            Ok(read_dir(path).unwrap())
+        }
+    }
+}
@@ -0,0 +1,22 @@
+use std::{
+    fs::{read_dir, remove_dir_all, remove_file},
+    path::Path,
+};
+
+use anyhow::Result;
+
+/// This method clears the passed directory of all of the files and directories contained within
+/// without deleting the directory.
+pub fn clear_directory(path: impl AsRef<Path>) -> Result<()> {
+    for entry in read_dir(path.as_ref())? {
+        let entry = entry?;
+        let entry_path = entry.path();
+
+        if entry_path.is_file() {
+            remove_file(entry_path)?
+        } else {
+            remove_dir_all(entry_path)?
+        }
+    }
+    Ok(())
+}
@@ -0,0 +1,3 @@
+mod clear_dir;
+
+pub use clear_dir::*;
@@ -0,0 +1,3 @@
+mod poll;
+
+pub use poll::*;
@@ -0,0 +1,69 @@
+use std::ops::ControlFlow;
+use std::time::Duration;
+
+use anyhow::{Result, anyhow};
+
+const EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION: Duration = Duration::from_secs(60);
+
+/// A function that polls for a fallible future for some period of time and errors if it fails to
+/// get a result after polling.
+///
+/// Given a future that returns a [`Result<ControlFlow<O, ()>>`], this function calls the future
+/// repeatedly (with some wait period) until the future returns a [`ControlFlow::Break`] or until it
+/// returns an [`Err`] in which case the function stops polling and returns the error.
+///
+/// If the future keeps returning [`ControlFlow::Continue`] and fails to return a [`Break`] within
+/// the permitted polling duration then this function returns an [`Err`]
+///
+/// [`Break`]: ControlFlow::Break
+/// [`Continue`]: ControlFlow::Continue
+pub async fn poll<F, O>(
+    polling_duration: Duration,
+    polling_wait_behavior: PollingWaitBehavior,
+    mut future: impl FnMut() -> F,
+) -> Result<O>
+where
+    F: Future<Output = Result<ControlFlow<O, ()>>>,
+{
+    let mut retries = 0;
+    let mut total_wait_duration = Duration::ZERO;
+    let max_allowed_wait_duration = polling_duration;
+
+    loop {
+        if total_wait_duration >= max_allowed_wait_duration {
+            break Err(anyhow!(
+                "Polling failed after {} retries and a total of {:?} of wait time",
+                retries,
+                total_wait_duration
+            ));
+        }
+
+        match future().await? {
+            ControlFlow::Continue(()) => {
+                let next_wait_duration = match polling_wait_behavior {
+                    PollingWaitBehavior::Constant(duration) => duration,
+                    PollingWaitBehavior::ExponentialBackoff => {
+                        Duration::from_secs(2u64.pow(retries))
+                            .min(EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION)
+                    }
+                };
+                let next_wait_duration =
+                    next_wait_duration.min(max_allowed_wait_duration - total_wait_duration);
+                total_wait_duration += next_wait_duration;
+                retries += 1;
+
+                tokio::time::sleep(next_wait_duration).await;
+            }
+            ControlFlow::Break(output) => {
+                break Ok(output);
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub enum PollingWaitBehavior {
+    Constant(Duration),
+    #[default]
+    ExponentialBackoff,
+}
@@ -0,0 +1,91 @@
+use std::{
+    borrow::Cow,
+    collections::HashSet,
+    path::{Path, PathBuf},
+};
+
+/// An iterator that finds files of a certain extension in the provided directory. You can think of
+/// this a glob pattern similar to: `${path}/**/*.md`
+pub struct FilesWithExtensionIterator {
+    /// The set of allowed extensions that that match the requirement and that should be returned
+    /// when found.
+    allowed_extensions: HashSet<Cow<'static, str>>,
+
+    /// The set of directories to visit next. This iterator does BFS and so these directories will
+    /// only be visited if we can't find any files in our state.
+    directories_to_search: Vec<PathBuf>,
+
+    /// The set of files matching the allowed extensions that were found. If there are entries in
+    /// this vector then they will be returned when the [`Iterator::next`] method is called. If not
+    /// then we visit one of the next directories to visit.
+    files_matching_allowed_extensions: Vec<PathBuf>,
+
+    /// This option controls if the the cached file system should be used or not. This could be
+    /// better for certain cases where the entries in the directories do not change and therefore
+    /// caching can be used.
+    use_cached_fs: bool,
+}
+
+impl FilesWithExtensionIterator {
+    pub fn new(root_directory: impl AsRef<Path>) -> Self {
+        Self {
+            allowed_extensions: Default::default(),
+            directories_to_search: vec![root_directory.as_ref().to_path_buf()],
+            files_matching_allowed_extensions: Default::default(),
+            use_cached_fs: Default::default(),
+        }
+    }
+
+    pub fn with_allowed_extension(
+        mut self,
+        allowed_extension: impl Into<Cow<'static, str>>,
+    ) -> Self {
+        self.allowed_extensions.insert(allowed_extension.into());
+        self
+    }
+
+    pub fn with_use_cached_fs(mut self, use_cached_fs: bool) -> Self {
+        self.use_cached_fs = use_cached_fs;
+        self
+    }
+}
+
+impl Iterator for FilesWithExtensionIterator {
+    type Item = PathBuf;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(file_path) = self.files_matching_allowed_extensions.pop() {
+            return Some(file_path);
+        };
+
+        let directory_to_search = self.directories_to_search.pop()?;
+
+        let iterator = if self.use_cached_fs {
+            let Ok(dir_entries) = crate::cached_fs::read_dir(directory_to_search.as_path()) else {
+                return self.next();
+            };
+            Box::new(dir_entries) as Box<dyn Iterator<Item = std::io::Result<PathBuf>>>
+        } else {
+            let Ok(dir_entries) = std::fs::read_dir(directory_to_search) else {
+                return self.next();
+            };
+            Box::new(dir_entries.map(|maybe_entry| maybe_entry.map(|entry| entry.path()))) as Box<_>
+        };
+
+        for entry_path in iterator.flatten() {
+            if entry_path.is_dir() {
+                self.directories_to_search.push(entry_path)
+            } else if entry_path.is_file()
+                && entry_path.extension().is_some_and(|ext| {
+                    self.allowed_extensions
+                        .iter()
+                        .any(|allowed| ext.eq_ignore_ascii_case(allowed.as_ref()))
+                })
+            {
+                self.files_matching_allowed_extensions.push(entry_path)
+            }
+        }
+
+        self.next()
+    }
+}
@@ -0,0 +1,3 @@
+mod files_with_extension_iterator;
+
+pub use files_with_extension_iterator::*;
@@ -0,0 +1,9 @@
+//! This crate provides common concepts, functionality, types, macros, and more that other crates in
+//! the workspace can benefit from.
+
+pub mod cached_fs;
+pub mod fs;
+pub mod futures;
+pub mod iterators;
+pub mod macros;
+pub mod types;
@@ -0,0 +1,106 @@
+/// Defines wrappers around types.
+///
+/// For example, the macro invocation seen below:
+///
+/// ```rust,ignore
+/// define_wrapper_type!(CaseId => usize);
+/// ```
+///
+/// Would define a wrapper type that looks like the following:
+///
+/// ```rust,ignore
+/// pub struct CaseId(usize);
+/// ```
+///
+/// And would also implement a number of methods on this type making it easier to use.
+///
+/// These wrapper types become very useful as they make the code a lot easier to read.
+///
+/// Take the following as an example:
+///
+/// ```rust,ignore
+/// struct State {
+///     contracts: HashMap<usize, HashMap<String, Vec<u8>>>
+/// }
+/// ```
+///
+/// In the above code it's hard to understand what the various types refer to or what to expect them
+/// to contain.
+///
+/// With these wrapper types we're able to create code that's self-documenting in that the types
+/// tell us what the code is referring to. The above code is transformed into
+///
+/// ```rust,ignore
+/// struct State {
+///     contracts: HashMap<CaseId, HashMap<ContractName, ContractByteCode>>
+/// }
+/// ```
+///
+/// Note that we follow the same syntax for defining wrapper structs but we do not permit the use of
+/// generics.
+#[macro_export]
+macro_rules! define_wrapper_type {
+    (
+        $(#[$meta: meta])*
+        $vis:vis struct $ident: ident($ty: ty);
+    ) => {
+        $(#[$meta])*
+        $vis struct $ident($ty);
+
+        impl $ident {
+            pub fn new(value: impl Into<$ty>) -> Self {
+                Self(value.into())
+            }
+
+            pub fn into_inner(self) -> $ty {
+                self.0
+            }
+
+            pub fn as_inner(&self) -> &$ty {
+                &self.0
+            }
+        }
+
+        impl AsRef<$ty> for $ident {
+            fn as_ref(&self) -> &$ty {
+                &self.0
+            }
+        }
+
+        impl AsMut<$ty> for $ident {
+            fn as_mut(&mut self) -> &mut $ty {
+                &mut self.0
+            }
+        }
+
+        impl std::ops::Deref for $ident {
+            type Target = $ty;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl std::ops::DerefMut for $ident {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.0
+            }
+        }
+
+        impl From<$ty> for $ident {
+            fn from(value: $ty) -> Self {
+                Self(value)
+            }
+        }
+
+        impl From<$ident> for $ty {
+            fn from(value: $ident) -> Self {
+                value.0
+            }
+        }
+    };
+}
+
+/// Technically not needed but this allows for the macro to be found in the `macros` module of the
+/// crate in addition to being found in the root of the crate.
+pub use define_wrapper_type;
@@ -0,0 +1,3 @@
+mod define_wrapper_type;
+
+pub use define_wrapper_type::*;
@@ -0,0 +1,3 @@
+mod version_or_requirement;
+
+pub use version_or_requirement::*;
@@ -0,0 +1,41 @@
+use semver::{Version, VersionReq};
+
+#[derive(Clone, Debug)]
+pub enum VersionOrRequirement {
+    Version(Version),
+    Requirement(VersionReq),
+}
+
+impl From<Version> for VersionOrRequirement {
+    fn from(value: Version) -> Self {
+        Self::Version(value)
+    }
+}
+
+impl From<VersionReq> for VersionOrRequirement {
+    fn from(value: VersionReq) -> Self {
+        Self::Requirement(value)
+    }
+}
+
+impl TryFrom<VersionOrRequirement> for Version {
+    type Error = anyhow::Error;
+
+    fn try_from(value: VersionOrRequirement) -> Result<Self, Self::Error> {
+        let VersionOrRequirement::Version(version) = value else {
+            anyhow::bail!("Version or requirement was not a version");
+        };
+        Ok(version)
+    }
+}
+
+impl TryFrom<VersionOrRequirement> for VersionReq {
+    type Error = anyhow::Error;
+
+    fn try_from(value: VersionOrRequirement) -> Result<Self, Self::Error> {
+        let VersionOrRequirement::Requirement(requirement) = value else {
+            anyhow::bail!("Version or requirement was not a requirement");
+        };
+        Ok(requirement)
+    }
+}
@@ -9,11 +9,18 @@ repository.workspace = true
 rust-version.workspace = true

 [dependencies]
-anyhow = { workspace = true }
 revive-solc-json-interface = { workspace = true }
+revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-solc-binaries = { workspace = true }
 revive-common = { workspace = true }
+
+alloy = { workspace = true }
+alloy-primitives = { workspace = true }
+anyhow = { workspace = true }
+foundry-compilers-artifacts = { workspace = true }
 semver = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 tracing = { workspace = true }
+tokio = { workspace = true }
@@ -4,20 +4,20 @@
 //! - Polkadot revive Wasm compiler

 use std::{
-    fs::read_to_string,
+    collections::HashMap,
    hash::Hash,
    path::{Path, PathBuf},
 };

-use revive_dt_config::Arguments;
+use alloy::json_abi::JsonAbi;
+use alloy_primitives::Address;
+use semver::Version;
+use serde::{Deserialize, Serialize};

 use revive_common::EVMVersion;
-use revive_solc_json_interface::{
-    SolcStandardJsonInput, SolcStandardJsonInputLanguage, SolcStandardJsonInputSettings,
-    SolcStandardJsonInputSettingsOptimizer, SolcStandardJsonInputSettingsSelection,
-    SolcStandardJsonOutput,
-};
-use semver::Version;
+use revive_dt_common::cached_fs::read_to_string;
+use revive_dt_common::types::VersionOrRequirement;
+use revive_dt_config::Arguments;

 pub mod revive_js;
 pub mod revive_resolc;
@@ -31,62 +31,45 @@ pub trait SolidityCompiler {
    /// The low-level compiler interface.
    fn build(
        &self,
-        input: CompilerInput<Self::Options>,
-    ) -> anyhow::Result<CompilerOutput<Self::Options>>;
+        input: CompilerInput,
+        additional_options: Self::Options,
+    ) -> impl Future<Output = anyhow::Result<CompilerOutput>>;

    fn new(solc_executable: PathBuf) -> Self;

-    fn get_compiler_executable(config: &Arguments, version: Version) -> anyhow::Result<PathBuf>;
+    fn get_compiler_executable(
+        config: &Arguments,
+        version: impl Into<VersionOrRequirement>,
+    ) -> impl Future<Output = anyhow::Result<PathBuf>>;
+
+    fn version(&self) -> anyhow::Result<Version>;
 }

 /// The generic compilation input configuration.
-#[derive(Debug)]
-pub struct CompilerInput<T: PartialEq + Eq + Hash> {
-    pub extra_options: T,
-    pub input: SolcStandardJsonInput,
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CompilerInput {
+    pub enable_optimization: Option<bool>,
+    pub via_ir: Option<bool>,
+    pub evm_version: Option<EVMVersion>,
    pub allow_paths: Vec<PathBuf>,
    pub base_path: Option<PathBuf>,
+    pub sources: HashMap<PathBuf, String>,
+    pub libraries: HashMap<PathBuf, HashMap<String, Address>>,
+    pub revert_string_handling: Option<RevertString>,
 }

 /// The generic compilation output configuration.
-pub struct CompilerOutput<T: PartialEq + Eq + Hash> {
-    /// The solc standard JSON input.
-    pub input: CompilerInput<T>,
-    /// The produced solc standard JSON output.
-    pub output: SolcStandardJsonOutput,
-    /// The error message in case the compiler returns abnormally.
-    pub error: Option<String>,
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CompilerOutput {
+    /// The compiled contracts. The bytecode of the contract is kept as a string incase linking is
+    /// required and the compiled source has placeholders.
+    pub contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
 }

-impl<T> PartialEq for CompilerInput<T>
-where
-    T: PartialEq + Eq + Hash,
-{
-    fn eq(&self, other: &Self) -> bool {
-        let self_input = serde_json::to_vec(&self.input).unwrap_or_default();
-        let other_input = serde_json::to_vec(&self.input).unwrap_or_default();
-        self.extra_options.eq(&other.extra_options) && self_input == other_input
-    }
-}
-
-impl<T> Eq for CompilerInput<T> where T: PartialEq + Eq + Hash {}
-
-impl<T> Hash for CompilerInput<T>
-where
-    T: PartialEq + Eq + Hash,
-{
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.extra_options.hash(state);
-        state.write(&serde_json::to_vec(&self.input).unwrap_or_default());
-    }
-}
-
-/// A generic builder style interface for configuring all compiler options.
+/// A generic builder style interface for configuring the supported compiler options.
 pub struct Compiler<T: SolidityCompiler> {
-    input: SolcStandardJsonInput,
-    extra_options: T::Options,
-    allow_paths: Vec<PathBuf>,
-    base_path: Option<PathBuf>,
+    input: CompilerInput,
+    additional_options: T::Options,
 }

 impl Default for Compiler<solc::Solc> {
@@ -101,73 +84,101 @@ where
 {
    pub fn new() -> Self {
        Self {
-            input: SolcStandardJsonInput {
-                language: SolcStandardJsonInputLanguage::Solidity,
+            input: CompilerInput {
+                enable_optimization: Default::default(),
+                via_ir: Default::default(),
+                evm_version: Default::default(),
+                allow_paths: Default::default(),
+                base_path: Default::default(),
                sources: Default::default(),
-                settings: SolcStandardJsonInputSettings::new(
-                    None,
-                    Default::default(),
-                    None,
-                    SolcStandardJsonInputSettingsSelection::new_required(),
-                    SolcStandardJsonInputSettingsOptimizer::new(
-                        false,
-                        None,
-                        &Version::new(0, 0, 0),
-                        false,
-                    ),
-                    None,
-                    None,
-                ),
+                libraries: Default::default(),
+                revert_string_handling: Default::default(),
            },
-            extra_options: Default::default(),
-            allow_paths: Default::default(),
-            base_path: None,
+            additional_options: T::Options::default(),
        }
    }

-    pub fn solc_optimizer(mut self, enabled: bool) -> Self {
-        self.input.settings.optimizer.enabled = enabled;
+    pub fn with_optimization(mut self, value: impl Into<Option<bool>>) -> Self {
+        self.input.enable_optimization = value.into();
        self
    }

-    pub fn with_source(mut self, path: &Path) -> anyhow::Result<Self> {
+    pub fn with_via_ir(mut self, value: impl Into<Option<bool>>) -> Self {
+        self.input.via_ir = value.into();
+        self
+    }
+
+    pub fn with_evm_version(mut self, version: impl Into<Option<EVMVersion>>) -> Self {
+        self.input.evm_version = version.into();
+        self
+    }
+
+    pub fn with_allow_path(mut self, path: impl AsRef<Path>) -> Self {
+        self.input.allow_paths.push(path.as_ref().into());
+        self
+    }
+
+    pub fn with_base_path(mut self, path: impl Into<Option<PathBuf>>) -> Self {
+        self.input.base_path = path.into();
+        self
+    }
+
+    pub fn with_source(mut self, path: impl AsRef<Path>) -> anyhow::Result<Self> {
        self.input
            .sources
-            .insert(path.display().to_string(), read_to_string(path)?.into());
+            .insert(path.as_ref().to_path_buf(), read_to_string(path.as_ref())?);
        Ok(self)
    }

-    pub fn evm_version(mut self, evm_version: EVMVersion) -> Self {
-        self.input.settings.evm_version = Some(evm_version);
+    pub fn with_library(
+        mut self,
+        path: impl AsRef<Path>,
+        name: impl AsRef<str>,
+        address: Address,
+    ) -> Self {
+        self.input
+            .libraries
+            .entry(path.as_ref().to_path_buf())
+            .or_default()
+            .insert(name.as_ref().into(), address);
        self
    }

-    pub fn extra_options(mut self, extra_options: T::Options) -> Self {
-        self.extra_options = extra_options;
+    pub fn with_revert_string_handling(
+        mut self,
+        revert_string_handling: impl Into<Option<RevertString>>,
+    ) -> Self {
+        self.input.revert_string_handling = revert_string_handling.into();
        self
    }

-    pub fn allow_path(mut self, path: PathBuf) -> Self {
-        self.allow_paths.push(path);
+    pub fn with_additional_options(mut self, options: impl Into<T::Options>) -> Self {
+        self.additional_options = options.into();
        self
    }

-    pub fn base_path(mut self, base_path: PathBuf) -> Self {
-        self.base_path = Some(base_path);
-        self
+    pub async fn try_build(
+        self,
+        compiler_path: impl AsRef<Path>,
+    ) -> anyhow::Result<CompilerOutput> {
+        T::new(compiler_path.as_ref().to_path_buf())
+            .build(self.input, self.additional_options)
+            .await
    }

-    pub fn try_build(self, solc_path: PathBuf) -> anyhow::Result<CompilerOutput<T::Options>> {
-        T::new(solc_path).build(CompilerInput {
-            extra_options: self.extra_options,
-            input: self.input,
-            allow_paths: self.allow_paths,
-            base_path: self.base_path,
-        })
-    }
-
-    /// Returns the compiler JSON input.
-    pub fn input(&self) -> SolcStandardJsonInput {
+    pub fn input(&self) -> CompilerInput {
        self.input.clone()
    }
 }
+
+/// Defines how the compiler should handle revert strings.
+#[derive(
+    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
+)]
+pub enum RevertString {
+    #[default]
+    Default,
+    Debug,
+    Strip,
+    VerboseDebug,
+}
@@ -6,11 +6,27 @@ use std::{
    process::{Command, Stdio},
 };

-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
-use revive_solc_json_interface::SolcStandardJsonOutput;
+use revive_solc_json_interface::{
+    SolcStandardJsonInput, SolcStandardJsonInputLanguage, SolcStandardJsonInputSettings,
+    SolcStandardJsonInputSettingsOptimizer, SolcStandardJsonInputSettingsSelection,
+    SolcStandardJsonOutput,
+};
+
+use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+
+use alloy::json_abi::JsonAbi;
+use anyhow::Context;
+use semver::Version;
+use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
+
+// TODO: I believe that we need to also pass the solc compiler to resolc so that resolc uses the
+// specified solc compiler. I believe that currently we completely ignore the specified solc binary
+// when invoking resolc which doesn't seem right if we're using solc as a compiler frontend.

 /// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
+#[derive(Debug)]
 pub struct Resolc {
    /// Path to the `resolc` executable
    resolc_path: PathBuf,
@@ -19,24 +35,75 @@ pub struct Resolc {
 impl SolidityCompiler for Resolc {
    type Options = Vec<String>;

-    fn build(
+    #[tracing::instrument(level = "debug", ret)]
+    async fn build(
        &self,
-        input: CompilerInput<Self::Options>,
-    ) -> anyhow::Result<CompilerOutput<Self::Options>> {
-        let mut command = Command::new(&self.resolc_path);
+        CompilerInput {
+            enable_optimization,
+            // Ignored and not honored since this is required for the resolc compilation.
+            via_ir: _via_ir,
+            evm_version,
+            allow_paths,
+            base_path,
+            sources,
+            libraries,
+            // TODO: this is currently not being handled since there is no way to pass it into
+            // resolc. So, we need to go back to this later once it's supported.
+            revert_string_handling: _,
+        }: CompilerInput,
+        additional_options: Self::Options,
+    ) -> anyhow::Result<CompilerOutput> {
+        let input = SolcStandardJsonInput {
+            language: SolcStandardJsonInputLanguage::Solidity,
+            sources: sources
+                .into_iter()
+                .map(|(path, source)| (path.display().to_string(), source.into()))
+                .collect(),
+            settings: SolcStandardJsonInputSettings {
+                evm_version,
+                libraries: Some(
+                    libraries
+                        .into_iter()
+                        .map(|(source_code, libraries_map)| {
+                            (
+                                source_code.display().to_string(),
+                                libraries_map
+                                    .into_iter()
+                                    .map(|(library_ident, library_address)| {
+                                        (library_ident, library_address.to_string())
+                                    })
+                                    .collect(),
+                            )
+                        })
+                        .collect(),
+                ),
+                remappings: None,
+                output_selection: Some(SolcStandardJsonInputSettingsSelection::new_required()),
+                via_ir: Some(true),
+                optimizer: SolcStandardJsonInputSettingsOptimizer::new(
+                    enable_optimization.unwrap_or(false),
+                    None,
+                    &Version::new(0, 0, 0),
+                    false,
+                ),
+                metadata: None,
+                polkavm: None,
+            },
+        };
+
+        let mut command = AsyncCommand::new(&self.resolc_path);
        command
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .arg("--standard-json");

-        if let Some(ref base_path) = input.base_path {
+        if let Some(ref base_path) = base_path {
            command.arg("--base-path").arg(base_path);
        }
-        if !input.allow_paths.is_empty() {
+        if !allow_paths.is_empty() {
            command.arg("--allow-paths").arg(
-                input
-                    .allow_paths
+                allow_paths
                    .iter()
                    .map(|path| path.display().to_string())
                    .collect::<Vec<_>>()
@@ -46,27 +113,23 @@ impl SolidityCompiler for Resolc {
        let mut child = command.spawn()?;

        let stdin_pipe = child.stdin.as_mut().expect("stdin must be piped");
-        serde_json::to_writer(stdin_pipe, &input.input)?;
+        let serialized_input = serde_json::to_vec(&input)?;
+        stdin_pipe.write_all(&serialized_input).await?;

-        let json_in = serde_json::to_string_pretty(&input.input)?;
-
-        let output = child.wait_with_output()?;
+        let output = child.wait_with_output().await?;
        let stdout = output.stdout;
        let stderr = output.stderr;

        if !output.status.success() {
+            let json_in = serde_json::to_string_pretty(&input)?;
            let message = String::from_utf8_lossy(&stderr);
            tracing::error!(
-                "resolc failed exit={} stderr={} JSON-in={} ",
-                output.status,
-                &message,
-                json_in,
+                status = %output.status,
+                message = %message,
+                json_input = json_in,
+                "Compilation using resolc failed"
            );
-            return Ok(CompilerOutput {
-                input,
-                output: Default::default(),
-                error: Some(message.into()),
-            });
+            anyhow::bail!("Compilation failed with an error: {message}");
        }

        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout).map_err(|e| {
@@ -76,29 +139,70 @@ impl SolidityCompiler for Resolc {
            )
        })?;

+        tracing::debug!(
+            output = %serde_json::to_string(&parsed).unwrap(),
+            "Compiled successfully"
+        );
+
        // Detecting if the compiler output contained errors and reporting them through logs and
        // errors instead of returning the compiler output that might contain errors.
        for error in parsed.errors.iter().flatten() {
            if error.severity == "error" {
-                tracing::error!(?error, ?input, "Encountered an error in the compilation");
+                tracing::error!(
+                    ?error,
+                    ?input,
+                    output = %serde_json::to_string(&parsed).unwrap(),
+                    "Encountered an error in the compilation"
+                );
                anyhow::bail!("Encountered an error in the compilation: {error}")
            }
        }

-        Ok(CompilerOutput {
-            input,
-            output: parsed,
-            error: None,
-        })
+        let Some(contracts) = parsed.contracts else {
+            anyhow::bail!("Unexpected error - resolc output doesn't have a contracts section");
+        };
+
+        let mut compiler_output = CompilerOutput::default();
+        for (source_path, contracts) in contracts.into_iter() {
+            let source_path = PathBuf::from(source_path).canonicalize()?;
+
+            let map = compiler_output.contracts.entry(source_path).or_default();
+            for (contract_name, contract_information) in contracts.into_iter() {
+                let bytecode = contract_information
+                    .evm
+                    .and_then(|evm| evm.bytecode.clone())
+                    .context("Unexpected - Contract compiled with resolc has no bytecode")?;
+                let abi = contract_information
+                    .metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.as_object())
+                    .and_then(|metadata| metadata.get("solc_metadata"))
+                    .and_then(|solc_metadata| solc_metadata.as_str())
+                    .and_then(|metadata| serde_json::from_str::<serde_json::Value>(metadata).ok())
+                    .and_then(|metadata| {
+                        metadata.get("output").and_then(|output| {
+                            output
+                                .get("abi")
+                                .and_then(|abi| serde_json::from_value::<JsonAbi>(abi.clone()).ok())
+                        })
+                    })
+                    .context(
+                        "Unexpected - Failed to get the ABI for a contract compiled with resolc",
+                    )?;
+                map.insert(contract_name, (bytecode.object, abi));
+            }
+        }
+
+        Ok(compiler_output)
    }

    fn new(resolc_path: PathBuf) -> Self {
        Resolc { resolc_path }
    }

-    fn get_compiler_executable(
+    async fn get_compiler_executable(
        config: &Arguments,
-        _version: semver::Version,
+        _version: impl Into<VersionOrRequirement>,
    ) -> anyhow::Result<PathBuf> {
        if !config.resolc.as_os_str().is_empty() {
            return Ok(config.resolc.clone());
@@ -106,4 +210,47 @@ impl SolidityCompiler for Resolc {

        Ok(PathBuf::from("resolc"))
    }
+
+    fn version(&self) -> anyhow::Result<semver::Version> {
+        // Logic for parsing the resolc version from the following string:
+        // Solidity frontend for the revive compiler version 0.3.0+commit.b238913.llvm-18.1.8
+
+        let output = Command::new(self.resolc_path.as_path())
+            .arg("--version")
+            .stdout(Stdio::piped())
+            .spawn()?
+            .wait_with_output()?
+            .stdout;
+        let output = String::from_utf8_lossy(&output);
+        let version_string = output
+            .split("version ")
+            .nth(1)
+            .context("Version parsing failed")?
+            .split("+")
+            .next()
+            .context("Version parsing failed")?;
+
+        Version::parse(version_string).map_err(Into::into)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained() {
+        // Arrange
+        let args = Arguments::default();
+        let path = Resolc::get_compiler_executable(&args, Version::new(0, 7, 6))
+            .await
+            .unwrap();
+        let compiler = Resolc::new(path);
+
+        // Act
+        let version = compiler.version();
+
+        // Assert
+        let _ = version.expect("Failed to get version");
+    }
 }
@@ -6,11 +6,24 @@ use std::{
    process::{Command, Stdio},
 };

-use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
-use revive_solc_json_interface::SolcStandardJsonOutput;

+use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
+
+use anyhow::Context;
+use foundry_compilers_artifacts::{
+    output_selection::{
+        BytecodeOutputSelection, ContractOutputSelection, EvmOutputSelection, OutputSelection,
+    },
+    solc::CompilerOutput as SolcOutput,
+    solc::*,
+};
+use semver::Version;
+use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
+
+#[derive(Debug)]
 pub struct Solc {
    solc_path: PathBuf,
 }
@@ -18,24 +31,89 @@ pub struct Solc {
 impl SolidityCompiler for Solc {
    type Options = ();

-    fn build(
+    #[tracing::instrument(level = "debug", ret)]
+    async fn build(
        &self,
-        input: CompilerInput<Self::Options>,
-    ) -> anyhow::Result<CompilerOutput<Self::Options>> {
-        let mut command = Command::new(&self.solc_path);
+        CompilerInput {
+            enable_optimization,
+            via_ir,
+            evm_version,
+            allow_paths,
+            base_path,
+            sources,
+            libraries,
+            revert_string_handling,
+        }: CompilerInput,
+        _: Self::Options,
+    ) -> anyhow::Result<CompilerOutput> {
+        let input = SolcInput {
+            language: SolcLanguage::Solidity,
+            sources: Sources(
+                sources
+                    .into_iter()
+                    .map(|(source_path, source_code)| (source_path, Source::new(source_code)))
+                    .collect(),
+            ),
+            settings: Settings {
+                optimizer: Optimizer {
+                    enabled: enable_optimization,
+                    details: Some(Default::default()),
+                    ..Default::default()
+                },
+                output_selection: OutputSelection::common_output_selection(
+                    [
+                        ContractOutputSelection::Abi,
+                        ContractOutputSelection::Evm(EvmOutputSelection::ByteCode(
+                            BytecodeOutputSelection::Object,
+                        )),
+                    ]
+                    .into_iter()
+                    .map(|item| item.to_string()),
+                ),
+                evm_version: evm_version.map(|version| version.to_string().parse().unwrap()),
+                via_ir,
+                libraries: Libraries {
+                    libs: libraries
+                        .into_iter()
+                        .map(|(file_path, libraries)| {
+                            (
+                                file_path,
+                                libraries
+                                    .into_iter()
+                                    .map(|(library_name, library_address)| {
+                                        (library_name, library_address.to_string())
+                                    })
+                                    .collect(),
+                            )
+                        })
+                        .collect(),
+                },
+                debug: revert_string_handling.map(|revert_string_handling| DebuggingSettings {
+                    revert_strings: match revert_string_handling {
+                        crate::RevertString::Default => Some(RevertStrings::Default),
+                        crate::RevertString::Debug => Some(RevertStrings::Debug),
+                        crate::RevertString::Strip => Some(RevertStrings::Strip),
+                        crate::RevertString::VerboseDebug => Some(RevertStrings::VerboseDebug),
+                    },
+                    debug_info: Default::default(),
+                }),
+                ..Default::default()
+            },
+        };
+
+        let mut command = AsyncCommand::new(&self.solc_path);
        command
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .arg("--standard-json");

-        if let Some(ref base_path) = input.base_path {
+        if let Some(ref base_path) = base_path {
            command.arg("--base-path").arg(base_path);
        }
-        if !input.allow_paths.is_empty() {
+        if !allow_paths.is_empty() {
            command.arg("--allow-paths").arg(
-                input
-                    .allow_paths
+                allow_paths
                    .iter()
                    .map(|path| path.display().to_string())
                    .collect::<Vec<_>>()
@@ -45,52 +123,150 @@ impl SolidityCompiler for Solc {
        let mut child = command.spawn()?;

        let stdin = child.stdin.as_mut().expect("should be piped");
-        serde_json::to_writer(stdin, &input.input)?;
-        let output = child.wait_with_output()?;
+        let serialized_input = serde_json::to_vec(&input)?;
+        stdin.write_all(&serialized_input).await?;
+        let output = child.wait_with_output().await?;

        if !output.status.success() {
+            let json_in = serde_json::to_string_pretty(&input)?;
            let message = String::from_utf8_lossy(&output.stderr);
-            tracing::error!("solc failed exit={} stderr={}", output.status, &message);
-            return Ok(CompilerOutput {
-                input,
-                output: Default::default(),
-                error: Some(message.into()),
-            });
+            tracing::error!(
+                status = %output.status,
+                message = %message,
+                json_input = json_in,
+                "Compilation using solc failed"
+            );
+            anyhow::bail!("Compilation failed with an error: {message}");
        }

-        let parsed =
-            serde_json::from_slice::<SolcStandardJsonOutput>(&output.stdout).map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to parse resolc JSON output: {e}\nstderr: {}",
-                    String::from_utf8_lossy(&output.stdout)
-                )
-            })?;
+        let parsed = serde_json::from_slice::<SolcOutput>(&output.stdout).map_err(|e| {
+            anyhow::anyhow!(
+                "failed to parse resolc JSON output: {e}\nstderr: {}",
+                String::from_utf8_lossy(&output.stdout)
+            )
+        })?;

        // Detecting if the compiler output contained errors and reporting them through logs and
        // errors instead of returning the compiler output that might contain errors.
-        for error in parsed.errors.iter().flatten() {
-            if error.severity == "error" {
+        for error in parsed.errors.iter() {
+            if error.severity == Severity::Error {
                tracing::error!(?error, ?input, "Encountered an error in the compilation");
                anyhow::bail!("Encountered an error in the compilation: {error}")
            }
        }

-        Ok(CompilerOutput {
-            input,
-            output: parsed,
-            error: None,
-        })
+        tracing::debug!(
+            output = %String::from_utf8_lossy(&output.stdout).to_string(),
+            "Compiled successfully"
+        );
+
+        let mut compiler_output = CompilerOutput::default();
+        for (contract_path, contracts) in parsed.contracts {
+            let map = compiler_output
+                .contracts
+                .entry(contract_path.canonicalize()?)
+                .or_default();
+            for (contract_name, contract_info) in contracts.into_iter() {
+                let source_code = contract_info
+                    .evm
+                    .and_then(|evm| evm.bytecode)
+                    .map(|bytecode| match bytecode.object {
+                        BytecodeObject::Bytecode(bytecode) => bytecode.to_string(),
+                        BytecodeObject::Unlinked(unlinked) => unlinked,
+                    })
+                    .context("Unexpected - contract compiled with solc has no source code")?;
+                let abi = contract_info
+                    .abi
+                    .context("Unexpected - contract compiled with solc as no ABI")?;
+                map.insert(contract_name, (source_code, abi));
+            }
+        }
+
+        Ok(compiler_output)
    }

    fn new(solc_path: PathBuf) -> Self {
        Self { solc_path }
    }

-    fn get_compiler_executable(
+    async fn get_compiler_executable(
        config: &Arguments,
-        version: semver::Version,
+        version: impl Into<VersionOrRequirement>,
    ) -> anyhow::Result<PathBuf> {
-        let path = download_solc(config.directory(), version, config.wasm)?;
+        let path = download_solc(config.directory(), version, config.wasm).await?;
        Ok(path)
    }
+
+    fn version(&self) -> anyhow::Result<semver::Version> {
+        // The following is the parsing code for the version from the solc version strings which
+        // look like the following:
+        // ```
+        // solc, the solidity compiler commandline interface
+        // Version: 0.8.30+commit.73712a01.Darwin.appleclang
+        // ```
+
+        let child = Command::new(self.solc_path.as_path())
+            .arg("--version")
+            .stdout(Stdio::piped())
+            .spawn()?;
+        let output = child.wait_with_output()?;
+        let output = String::from_utf8_lossy(&output.stdout);
+        let version_line = output
+            .split("Version: ")
+            .nth(1)
+            .context("Version parsing failed")?;
+        let version_string = version_line
+            .split("+")
+            .next()
+            .context("Version parsing failed")?;
+
+        Version::parse(version_string).map_err(Into::into)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained() {
+        // Arrange
+        let args = Arguments::default();
+        println!("Getting compiler path");
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 7, 6))
+            .await
+            .unwrap();
+        println!("Got compiler path");
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version();
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 7, 6)
+        )
+    }
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained1() {
+        // Arrange
+        let args = Arguments::default();
+        println!("Getting compiler path");
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
+            .await
+            .unwrap();
+        println!("Got compiler path");
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version();
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 4, 21)
+        )
+    }
 }
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.9;
+
+contract Callable {
+    function f(uint[1] memory p1) public pure returns(uint) {
+        return p1[0];
+    }
+}
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+// Report https://linear.app/matterlabs/issue/CPR-269/call-with-calldata-variable-bug
+
+pragma solidity >=0.6.9;
+
+import "./callable.sol";
+
+contract Main {
+    function main(uint[1] calldata p1, Callable callable) public returns(uint) {
+        return callable.f(p1);
+    }
+}
@@ -0,0 +1,21 @@
+{ "cases": [ {
+    "name": "first",
+    "inputs": [
+        {
+            "instance": "Main",
+            "method": "main",
+            "calldata": [
+                "1",
+                "Callable.address"
+            ]
+        }
+    ],
+    "expected": [
+        "1"
+    ]
+} ],
+    "contracts": {
+        "Main": "main.sol:Main",
+        "Callable": "callable.sol:Callable"
+    }
+}
@@ -0,0 +1,88 @@
+use std::path::PathBuf;
+
+use revive_dt_compiler::{Compiler, SolidityCompiler, revive_resolc::Resolc, solc::Solc};
+use revive_dt_config::Arguments;
+use semver::Version;
+
+#[tokio::test]
+async fn contracts_can_be_compiled_with_solc() {
+    // Arrange
+    let args = Arguments::default();
+    let compiler_path = Solc::get_compiler_executable(&args, Version::new(0, 8, 30))
+        .await
+        .unwrap();
+    println!("About to assert");
+
+    // Act
+    let output = Compiler::<Solc>::new()
+        .with_source("./tests/assets/array_one_element/callable.sol")
+        .unwrap()
+        .with_source("./tests/assets/array_one_element/main.sol")
+        .unwrap()
+        .try_build(compiler_path)
+        .await;
+
+    // Assert
+    let output = output.expect("Failed to compile");
+    assert_eq!(output.contracts.len(), 2);
+
+    let main_file_contracts = output
+        .contracts
+        .get(
+            &PathBuf::from("./tests/assets/array_one_element/main.sol")
+                .canonicalize()
+                .unwrap(),
+        )
+        .unwrap();
+    let callable_file_contracts = output
+        .contracts
+        .get(
+            &PathBuf::from("./tests/assets/array_one_element/callable.sol")
+                .canonicalize()
+                .unwrap(),
+        )
+        .unwrap();
+    assert!(main_file_contracts.contains_key("Main"));
+    assert!(callable_file_contracts.contains_key("Callable"));
+}
+
+#[tokio::test]
+async fn contracts_can_be_compiled_with_resolc() {
+    // Arrange
+    let args = Arguments::default();
+    let compiler_path = Resolc::get_compiler_executable(&args, Version::new(0, 8, 30))
+        .await
+        .unwrap();
+
+    // Act
+    let output = Compiler::<Resolc>::new()
+        .with_source("./tests/assets/array_one_element/callable.sol")
+        .unwrap()
+        .with_source("./tests/assets/array_one_element/main.sol")
+        .unwrap()
+        .try_build(compiler_path)
+        .await;
+
+    // Assert
+    let output = output.expect("Failed to compile");
+    assert_eq!(output.contracts.len(), 2);
+
+    let main_file_contracts = output
+        .contracts
+        .get(
+            &PathBuf::from("./tests/assets/array_one_element/main.sol")
+                .canonicalize()
+                .unwrap(),
+        )
+        .unwrap();
+    let callable_file_contracts = output
+        .contracts
+        .get(
+            &PathBuf::from("./tests/assets/array_one_element/callable.sol")
+                .canonicalize()
+                .unwrap(),
+        )
+        .unwrap();
+    assert!(main_file_contracts.contains_key("Main"));
+    assert!(callable_file_contracts.contains_key("Callable"));
+}
@@ -3,6 +3,7 @@
 use std::{
    fmt::Display,
    path::{Path, PathBuf},
+    sync::LazyLock,
 };

 use alloy::{network::EthereumWallet, signers::local::PrivateKeySigner};
@@ -54,7 +55,7 @@ pub struct Arguments {
    pub geth: PathBuf,

    /// The maximum time in milliseconds to wait for geth to start.
-    #[arg(long = "geth-start-timeout", default_value = "2000")]
+    #[arg(long = "geth-start-timeout", default_value = "5000")]
    pub geth_start_timeout: u64,

    /// The test network chain ID.
@@ -73,6 +74,12 @@ pub struct Arguments {
    )]
    pub account: String,

+    /// This argument controls which private keys the nodes should have access to and be added to
+    /// its wallet signers. With a value of N, private keys (0, N] will be added to the signer set
+    /// of the node.
+    #[arg(long = "private-keys-count", default_value_t = 100_000)]
+    pub private_keys_to_add: usize,
+
    /// The differential testing leader node implementation.
    #[arg(short, long = "leader", default_value = "geth")]
    pub leader: TestingPlatform,
@@ -85,9 +92,22 @@ pub struct Arguments {
    #[arg(long = "compile-only")]
    pub compile_only: Option<TestingPlatform>,

-    /// Determines the amount of tests that are executed in parallel.
-    #[arg(long = "workers", default_value = "12")]
-    pub workers: usize,
+    /// Determines the amount of nodes that will be spawned for each chain.
+    #[arg(long, default_value = "1")]
+    pub number_of_nodes: usize,
+
+    /// Determines the amount of tokio worker threads that will will be used.
+    #[arg(
+        long,
+        default_value_t = std::thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(1)
+    )]
+    pub number_of_threads: usize,
+
+    /// Determines the amount of concurrent tasks that will be spawned to run tests. Defaults to 10 x the number of nodes.
+    #[arg(long)]
+    pub number_concurrent_tasks: Option<usize>,

    /// Extract problems back to the test corpus.
    #[arg(short, long = "extract-problems")]
@@ -123,6 +143,13 @@ impl Arguments {
        panic!("should have a workdir configured")
    }

+    /// Return the number of concurrent tasks to run. This is provided via the
+    /// `--number-concurrent-tasks` argument, and otherwise defaults to --number-of-nodes * 20.
+    pub fn number_of_concurrent_tasks(&self) -> usize {
+        self.number_concurrent_tasks
+            .unwrap_or(20 * self.number_of_nodes)
+    }
+
    /// Try to parse `self.account` into a [PrivateKeySigner],
    /// panicing on error.
    pub fn wallet(&self) -> EthereumWallet {
@@ -138,14 +165,23 @@ impl Arguments {

 impl Default for Arguments {
    fn default() -> Self {
-        Arguments::parse_from(["retester"])
+        static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
+
+        let default = Arguments::parse_from(["retester"]);
+
+        Arguments {
+            temp_dir: Some(&TEMP_DIR),
+            ..default
+        }
    }
 }

 /// The Solidity compatible node implementation.
 ///
 /// This describes the solutions to be tested against on a high level.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, ValueEnum, Serialize, Deserialize)]
+#[derive(
+    Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, ValueEnum, Serialize, Deserialize,
+)]
 #[clap(rename_all = "lower")]
 pub enum TestingPlatform {
    /// The go-ethereum reference full node EVM implementation.
@@ -13,6 +13,7 @@ name = "retester"
 path = "src/main.rs"

 [dependencies]
+revive-dt-common = { workspace = true }
 revive-dt-compiler = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
@@ -23,9 +24,11 @@ revive-dt-report = { workspace = true }
 alloy = { workspace = true }
 anyhow = { workspace = true }
 clap = { workspace = true }
+futures = { workspace = true }
+indexmap = { workspace = true }
+tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
-rayon = { workspace = true }
-revive-solc-json-interface = { workspace = true }
+semver = { workspace = true }
 serde_json = { workspace = true }
 temp-dir = { workspace = true }
@@ -1,11 +1,12 @@
 //! The revive differential testing core library.
 //!
 //! This crate defines the testing configuration and
-//! provides a helper utilty to execute tests.
+//! provides a helper utility to execute tests.

 use revive_dt_compiler::{SolidityCompiler, revive_resolc, solc};
 use revive_dt_config::TestingPlatform;
-use revive_dt_node::{geth, kitchensink::KitchensinkNode};
+use revive_dt_format::traits::ResolverApi;
+use revive_dt_node::{Node, geth, kitchensink::KitchensinkNode};
 use revive_dt_node_interaction::EthereumNode;

 pub mod driver;
@@ -14,7 +15,7 @@ pub mod driver;
 ///
 /// For this we need a blockchain node implementation and a compiler.
 pub trait Platform {
-    type Blockchain: EthereumNode;
+    type Blockchain: EthereumNode + Node + ResolverApi;
    type Compiler: SolidityCompiler;

    /// Returns the matching [TestingPlatform] of the [revive_dt_config::Arguments].
@@ -25,7 +26,7 @@ pub trait Platform {
 pub struct Geth;

 impl Platform for Geth {
-    type Blockchain = geth::Instance;
+    type Blockchain = geth::GethNode;
    type Compiler = solc::Solc;

    fn config_id() -> TestingPlatform {
@@ -1,37 +1,89 @@
-use std::{collections::HashMap, sync::LazyLock};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::{Arc, LazyLock},
+    time::Instant,
+};

+use alloy::{
+    json_abi::JsonAbi,
+    network::{Ethereum, TransactionBuilder},
+    primitives::Address,
+    rpc::types::TransactionRequest,
+};
+use anyhow::Context;
 use clap::Parser;
-use rayon::{ThreadPoolBuilder, prelude::*};
+use futures::StreamExt;
+use revive_dt_common::iterators::FilesWithExtensionIterator;
+use revive_dt_node_interaction::EthereumNode;
+use semver::Version;
+use temp_dir::TempDir;
+use tokio::sync::{Mutex, RwLock, mpsc};
+use tracing::{Instrument, Level};
+use tracing_subscriber::{EnvFilter, FmtSubscriber};

+use revive_dt_compiler::SolidityCompiler;
+use revive_dt_compiler::{Compiler, CompilerOutput};
 use revive_dt_config::*;
 use revive_dt_core::{
    Geth, Kitchensink, Platform,
-    driver::{Driver, State},
+    driver::{CaseDriver, CaseState},
+};
+use revive_dt_format::{
+    case::{Case, CaseIdx},
+    corpus::Corpus,
+    input::{Input, Step},
+    metadata::{ContractInstance, ContractPathAndIdent, Metadata, MetadataFile},
+    mode::SolcMode,
 };
-use revive_dt_format::{corpus::Corpus, metadata::MetadataFile};
 use revive_dt_node::pool::NodePool;
 use revive_dt_report::reporter::{Report, Span};
-use temp_dir::TempDir;
-use tracing::Level;
-use tracing_subscriber::{EnvFilter, FmtSubscriber, fmt::format::FmtSpan};

 static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());

+type CompilationCache = Arc<
+    RwLock<
+        HashMap<
+            (PathBuf, SolcMode, TestingPlatform),
+            Arc<Mutex<Option<Arc<(Version, CompilerOutput)>>>>,
+        >,
+    >,
+>;
+
+/// this represents a single "test"; a mode, path and collection of cases.
+#[derive(Clone)]
+struct Test {
+    metadata: Metadata,
+    path: PathBuf,
+    mode: SolcMode,
+    case_idx: usize,
+    case: Case,
+}
+
+/// This represents the results that we gather from running test cases.
+type CaseResult = Result<usize, anyhow::Error>;
+
 fn main() -> anyhow::Result<()> {
    let args = init_cli()?;

-    for (corpus, tests) in collect_corpora(&args)? {
-        let span = Span::new(corpus, args.clone())?;
-
-        match &args.compile_only {
-            Some(platform) => compile_corpus(&args, &tests, platform, span),
-            None => execute_corpus(&args, &tests, span)?,
+    let body = async {
+        for (corpus, tests) in collect_corpora(&args)? {
+            let span = Span::new(corpus, args.clone())?;
+            match &args.compile_only {
+                Some(platform) => compile_corpus(&args, &tests, platform, span).await,
+                None => execute_corpus(&args, &tests, span).await?,
+            }
+            Report::save()?;
        }
+        Ok(())
+    };

-        Report::save()?;
-    }
-
-    Ok(())
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(args.number_of_threads)
+        .enable_all()
+        .build()
+        .expect("Failed building the Runtime")
+        .block_on(body)
 }

 fn init_cli() -> anyhow::Result<Arguments> {
@@ -39,7 +91,7 @@ fn init_cli() -> anyhow::Result<Arguments> {
        .with_thread_ids(true)
        .with_thread_names(true)
        .with_env_filter(EnvFilter::from_default_env())
-        .with_span_events(FmtSpan::ENTER | FmtSpan::CLOSE)
+        .with_ansi(false)
        .pretty()
        .finish();
    tracing::subscriber::set_global_default(subscriber)?;
@@ -62,10 +114,6 @@ fn init_cli() -> anyhow::Result<Arguments> {
    }
    tracing::info!("workdir: {}", args.directory().display());

-    ThreadPoolBuilder::new()
-        .num_threads(args.workers)
-        .build_global()?;
-
    Ok(args)
 }

@@ -83,66 +131,611 @@ fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<Metad
    Ok(corpora)
 }

-fn run_driver<L, F>(args: &Arguments, tests: &[MetadataFile], span: Span) -> anyhow::Result<()>
+async fn run_driver<L, F>(
+    args: &Arguments,
+    metadata_files: &[MetadataFile],
+    span: Span,
+) -> anyhow::Result<()>
 where
    L: Platform,
    F: Platform,
    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let leader_nodes = NodePool::<L::Blockchain>::new(args)?;
-    let follower_nodes = NodePool::<F::Blockchain>::new(args)?;
+    let (report_tx, report_rx) = mpsc::unbounded_channel::<(Test, CaseResult)>();

-    tests.par_iter().for_each(
-        |MetadataFile {
-             content: metadata,
-             path: metadata_file_path,
-         }| {
-            // Starting a new tracing span for this metadata file. This allows our logs to be clear
-            // about which metadata file the logs belong to. We can add other information into this
-            // as well to be able to associate the logs with the correct metadata file and case
-            // that's being executed.
-            let tracing_span = tracing::span!(
-                Level::INFO,
-                "Running driver",
-                metadata_file_path = metadata_file_path.display().to_string(),
-            );
-            let _guard = tracing_span.enter();
+    let tests = prepare_tests::<L, F>(metadata_files);
+    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx)?;
+    let status_reporter_task = start_reporter_task(report_rx);

-            let mut driver = Driver::<L, F>::new(
-                metadata,
-                args,
-                leader_nodes.round_robbin(),
-                follower_nodes.round_robbin(),
-            );
-
-            match driver.execute(span) {
-                Ok(_) => {
-                    tracing::info!(
-                        "metadata {} success",
-                        metadata.directory().as_ref().unwrap().display()
-                    );
-                }
-                Err(error) => {
-                    tracing::warn!(
-                        "metadata {} failure: {error:?}",
-                        metadata.file_path.as_ref().unwrap().display()
-                    );
-                }
-            }
-        },
-    );
+    tokio::join!(status_reporter_task, driver_task);

    Ok(())
 }

-fn execute_corpus(args: &Arguments, tests: &[MetadataFile], span: Span) -> anyhow::Result<()> {
+fn prepare_tests<L, F>(metadata_files: &[MetadataFile]) -> impl Iterator<Item = Test>
+where
+    L: Platform,
+    F: Platform,
+    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+{
+    metadata_files
+        .iter()
+        .flat_map(
+            |MetadataFile {
+                 path,
+                 content: metadata,
+             }| {
+                metadata
+                    .cases
+                    .iter()
+                    .enumerate()
+                    .flat_map(move |(case_idx, case)| {
+                        metadata
+                            .solc_modes()
+                            .into_iter()
+                            .map(move |solc_mode| (path, metadata, case_idx, case, solc_mode))
+                    })
+            },
+        )
+        .filter(
+            |(metadata_file_path, metadata, _, _, _)| match metadata.ignore {
+                Some(true) => {
+                    tracing::warn!(
+                        metadata_file_path = %metadata_file_path.display(),
+                        "Ignoring metadata file"
+                    );
+                    false
+                }
+                Some(false) | None => true,
+            },
+        )
+        .filter(
+            |(metadata_file_path, _, case_idx, case, _)| match case.ignore {
+                Some(true) => {
+                    tracing::warn!(
+                        metadata_file_path = %metadata_file_path.display(),
+                        case_idx,
+                        case_name = ?case.name,
+                        "Ignoring case"
+                    );
+                    false
+                }
+                Some(false) | None => true,
+            },
+        )
+        .filter(|(metadata_file_path, metadata, ..)| match metadata.required_evm_version {
+            Some(evm_version_requirement) => {
+                let is_allowed = evm_version_requirement
+                    .matches(&<L::Blockchain as revive_dt_node::Node>::evm_version())
+                    && evm_version_requirement
+                        .matches(&<F::Blockchain as revive_dt_node::Node>::evm_version());
+
+                if !is_allowed {
+                    tracing::warn!(
+                        metadata_file_path = %metadata_file_path.display(),
+                        leader_evm_version = %<L::Blockchain as revive_dt_node::Node>::evm_version(),
+                        follower_evm_version = %<F::Blockchain as revive_dt_node::Node>::evm_version(),
+                        version_requirement = %evm_version_requirement,
+                        "Skipped test since the EVM version requirement was not fulfilled."
+                    );
+                }
+
+                is_allowed
+            }
+            None => true,
+        })
+        .map(|(metadata_file_path, metadata, case_idx, case, solc_mode)| {
+            Test {
+                metadata: metadata.clone(),
+                path: metadata_file_path.to_path_buf(),
+                mode: solc_mode,
+                case_idx,
+                case: case.clone(),
+            }
+        })
+}
+
+fn start_driver_task<L, F>(
+    args: &Arguments,
+    tests: impl Iterator<Item = Test>,
+    span: Span,
+    report_tx: mpsc::UnboundedSender<(Test, CaseResult)>,
+) -> anyhow::Result<impl Future<Output = ()>>
+where
+    L: Platform,
+    F: Platform,
+    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+{
+    let leader_nodes = Arc::new(NodePool::<L::Blockchain>::new(args)?);
+    let follower_nodes = Arc::new(NodePool::<F::Blockchain>::new(args)?);
+    let compilation_cache = Arc::new(RwLock::new(HashMap::new()));
+    let number_concurrent_tasks = args.number_of_concurrent_tasks();
+
+    Ok(futures::stream::iter(tests).for_each_concurrent(
+        // We want to limit the concurrent tasks here because:
+        //
+        // 1. We don't want to overwhelm the nodes with too many requests, leading to responses timing out.
+        // 2. We don't want to open too many files at once, leading to the OS running out of file descriptors.
+        //
+        // By default, we allow maximum of 10 ongoing requests per node in order to limit (1), and assume that
+        // this number will automatically be low enough to address (2). The user can override this.
+        Some(number_concurrent_tasks),
+        move |test| {
+            let leader_nodes = leader_nodes.clone();
+            let follower_nodes = follower_nodes.clone();
+            let compilation_cache = compilation_cache.clone();
+            let report_tx = report_tx.clone();
+
+            async move {
+                let leader_node = leader_nodes.round_robbin();
+                let follower_node = follower_nodes.round_robbin();
+
+                let tracing_span = tracing::span!(
+                    Level::INFO,
+                    "Running driver",
+                    metadata_file_path = %test.path.display(),
+                    case_idx = ?test.case_idx,
+                    solc_mode = ?test.mode,
+                );
+
+                let result = handle_case_driver::<L, F>(
+                    &test.path,
+                    &test.metadata,
+                    test.case_idx.into(),
+                    &test.case,
+                    test.mode.clone(),
+                    args,
+                    compilation_cache.clone(),
+                    leader_node,
+                    follower_node,
+                    span,
+                )
+                .instrument(tracing_span)
+                .await;
+
+                report_tx
+                    .send((test, result))
+                    .expect("Failed to send report");
+            }
+        },
+    ))
+}
+
+async fn start_reporter_task(mut report_rx: mpsc::UnboundedReceiver<(Test, CaseResult)>) {
+    let start = Instant::now();
+
+    const GREEN: &str = "\x1B[32m";
+    const RED: &str = "\x1B[31m";
+    const COLOUR_RESET: &str = "\x1B[0m";
+    const BOLD: &str = "\x1B[1m";
+    const BOLD_RESET: &str = "\x1B[22m";
+
+    let mut number_of_successes = 0;
+    let mut number_of_failures = 0;
+    let mut failures = vec![];
+
+    // Wait for reports to come from our test runner. When the channel closes, this ends.
+    while let Some((test, case_result)) = report_rx.recv().await {
+        let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
+        let case_idx = test.case_idx;
+        let test_path = test.path.display();
+        let test_mode = test.mode.clone();
+
+        match case_result {
+            Ok(_inputs) => {
+                number_of_successes += 1;
+                eprintln!(
+                    "{GREEN}Case Succeeded:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?})"
+                );
+            }
+            Err(err) => {
+                number_of_failures += 1;
+                eprintln!(
+                    "{RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?})"
+                );
+                failures.push((test, err));
+            }
+        }
+    }
+
+    eprintln!();
+    let elapsed = start.elapsed();
+
+    // Now, log the failures with more complete errors at the bottom, like `cargo test` does, so
+    // that we don't have to scroll through the entire output to find them.
+    if !failures.is_empty() {
+        eprintln!("{BOLD}Failures:{BOLD_RESET}\n");
+
+        for failure in failures {
+            let (test, err) = failure;
+            let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
+            let case_idx = test.case_idx;
+            let test_path = test.path.display();
+            let test_mode = test.mode.clone();
+
+            eprintln!(
+                "---- {RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?}) ----\n\n{err}\n"
+            );
+        }
+    }
+
+    // Summary at the end.
+    eprintln!(
+        "{} cases: {GREEN}{number_of_successes}{COLOUR_RESET} cases succeeded, {RED}{number_of_failures}{COLOUR_RESET} cases failed in {} seconds",
+        number_of_successes + number_of_failures,
+        elapsed.as_secs()
+    );
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn handle_case_driver<L, F>(
+    metadata_file_path: &Path,
+    metadata: &Metadata,
+    case_idx: CaseIdx,
+    case: &Case,
+    mode: SolcMode,
+    config: &Arguments,
+    compilation_cache: CompilationCache,
+    leader_node: &L::Blockchain,
+    follower_node: &F::Blockchain,
+    _: Span,
+) -> anyhow::Result<usize>
+where
+    L: Platform,
+    F: Platform,
+    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+{
+    let leader_pre_link_contracts = get_or_build_contracts::<L>(
+        metadata,
+        metadata_file_path,
+        mode.clone(),
+        config,
+        compilation_cache.clone(),
+        &HashMap::new(),
+    )
+    .await?;
+    let follower_pre_link_contracts = get_or_build_contracts::<F>(
+        metadata,
+        metadata_file_path,
+        mode.clone(),
+        config,
+        compilation_cache.clone(),
+        &HashMap::new(),
+    )
+    .await?;
+
+    let mut leader_deployed_libraries = HashMap::new();
+    let mut follower_deployed_libraries = HashMap::new();
+    let mut contract_sources = metadata.contract_sources()?;
+    for library_instance in metadata
+        .libraries
+        .iter()
+        .flatten()
+        .flat_map(|(_, map)| map.values())
+    {
+        let ContractPathAndIdent {
+            contract_source_path: library_source_path,
+            contract_ident: library_ident,
+        } = contract_sources
+            .remove(library_instance)
+            .context("Failed to find the contract source")?;
+
+        let (leader_code, leader_abi) = leader_pre_link_contracts
+            .1
+            .contracts
+            .get(&library_source_path)
+            .and_then(|contracts| contracts.get(library_ident.as_str()))
+            .context("Declared library was not compiled")?;
+        let (follower_code, follower_abi) = follower_pre_link_contracts
+            .1
+            .contracts
+            .get(&library_source_path)
+            .and_then(|contracts| contracts.get(library_ident.as_str()))
+            .context("Declared library was not compiled")?;
+
+        let leader_code = match alloy::hex::decode(leader_code) {
+            Ok(code) => code,
+            Err(error) => {
+                tracing::error!(
+                    ?error,
+                    contract_source_path = library_source_path.display().to_string(),
+                    contract_ident = library_ident.as_ref(),
+                    "Failed to hex-decode byte code - This could possibly mean that the bytecode requires linking"
+                );
+                anyhow::bail!("Failed to hex-decode the byte code {}", error)
+            }
+        };
+        let follower_code = match alloy::hex::decode(follower_code) {
+            Ok(code) => code,
+            Err(error) => {
+                tracing::error!(
+                    ?error,
+                    contract_source_path = library_source_path.display().to_string(),
+                    contract_ident = library_ident.as_ref(),
+                    "Failed to hex-decode byte code - This could possibly mean that the bytecode requires linking"
+                );
+                anyhow::bail!("Failed to hex-decode the byte code {}", error)
+            }
+        };
+
+        // Getting the deployer address from the cases themselves. This is to ensure that we're
+        // doing the deployments from different accounts and therefore we're not slowed down by
+        // the nonce.
+        let deployer_address = case
+            .steps
+            .iter()
+            .filter_map(|step| match step {
+                Step::FunctionCall(input) => Some(input.caller),
+                Step::BalanceAssertion(..) => None,
+                Step::StorageEmptyAssertion(..) => None,
+            })
+            .next()
+            .unwrap_or(Input::default_caller());
+        let leader_tx = TransactionBuilder::<Ethereum>::with_deploy_code(
+            TransactionRequest::default().from(deployer_address),
+            leader_code,
+        );
+        let follower_tx = TransactionBuilder::<Ethereum>::with_deploy_code(
+            TransactionRequest::default().from(deployer_address),
+            follower_code,
+        );
+
+        let leader_receipt = match leader_node.execute_transaction(leader_tx).await {
+            Ok(receipt) => receipt,
+            Err(error) => {
+                tracing::error!(
+                    node = std::any::type_name::<L>(),
+                    ?error,
+                    "Contract deployment transaction failed."
+                );
+                return Err(error);
+            }
+        };
+        let follower_receipt = match follower_node.execute_transaction(follower_tx).await {
+            Ok(receipt) => receipt,
+            Err(error) => {
+                tracing::error!(
+                    node = std::any::type_name::<F>(),
+                    ?error,
+                    "Contract deployment transaction failed."
+                );
+                return Err(error);
+            }
+        };
+
+        tracing::info!(
+            ?library_instance,
+            library_address = ?leader_receipt.contract_address,
+            "Deployed library to leader"
+        );
+        tracing::info!(
+            ?library_instance,
+            library_address = ?follower_receipt.contract_address,
+            "Deployed library to follower"
+        );
+
+        let Some(leader_library_address) = leader_receipt.contract_address else {
+            anyhow::bail!("Contract deployment didn't return an address");
+        };
+        let Some(follower_library_address) = follower_receipt.contract_address else {
+            anyhow::bail!("Contract deployment didn't return an address");
+        };
+
+        leader_deployed_libraries.insert(
+            library_instance.clone(),
+            (leader_library_address, leader_abi.clone()),
+        );
+        follower_deployed_libraries.insert(
+            library_instance.clone(),
+            (follower_library_address, follower_abi.clone()),
+        );
+    }
+
+    let metadata_file_contains_libraries = metadata
+        .libraries
+        .iter()
+        .flat_map(|map| map.iter())
+        .flat_map(|(_, value)| value.iter())
+        .next()
+        .is_some();
+    let compiled_contracts_require_linking = leader_pre_link_contracts
+        .1
+        .contracts
+        .values()
+        .chain(follower_pre_link_contracts.1.contracts.values())
+        .flat_map(|value| value.values())
+        .any(|(code, _)| !code.chars().all(|char| char.is_ascii_hexdigit()));
+    let (leader_compiled_contracts, follower_compiled_contracts) =
+        if metadata_file_contains_libraries && compiled_contracts_require_linking {
+            let leader_key = (
+                metadata_file_path.to_path_buf(),
+                mode.clone(),
+                L::config_id(),
+            );
+            let follower_key = (
+                metadata_file_path.to_path_buf(),
+                mode.clone(),
+                F::config_id(),
+            );
+            {
+                let mut cache = compilation_cache.write().await;
+                cache.remove(&leader_key);
+                cache.remove(&follower_key);
+            }
+
+            let leader_post_link_contracts = get_or_build_contracts::<L>(
+                metadata,
+                metadata_file_path,
+                mode.clone(),
+                config,
+                compilation_cache.clone(),
+                &leader_deployed_libraries,
+            )
+            .await?;
+            let follower_post_link_contracts = get_or_build_contracts::<F>(
+                metadata,
+                metadata_file_path,
+                mode.clone(),
+                config,
+                compilation_cache,
+                &follower_deployed_libraries,
+            )
+            .await?;
+
+            (leader_post_link_contracts, follower_post_link_contracts)
+        } else {
+            (leader_pre_link_contracts, follower_pre_link_contracts)
+        };
+
+    let leader_state = CaseState::<L>::new(
+        leader_compiled_contracts.0.clone(),
+        leader_compiled_contracts.1.contracts.clone(),
+        leader_deployed_libraries,
+    );
+    let follower_state = CaseState::<F>::new(
+        follower_compiled_contracts.0.clone(),
+        follower_compiled_contracts.1.contracts.clone(),
+        follower_deployed_libraries,
+    );
+
+    let mut driver = CaseDriver::<L, F>::new(
+        metadata,
+        case,
+        case_idx,
+        leader_node,
+        follower_node,
+        leader_state,
+        follower_state,
+    );
+    driver.execute().await
+}
+
+async fn get_or_build_contracts<P: Platform>(
+    metadata: &Metadata,
+    metadata_file_path: &Path,
+    mode: SolcMode,
+    config: &Arguments,
+    compilation_cache: CompilationCache,
+    deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
+) -> anyhow::Result<Arc<(Version, CompilerOutput)>> {
+    let key = (
+        metadata_file_path.to_path_buf(),
+        mode.clone(),
+        P::config_id(),
+    );
+    if let Some(compilation_artifact) = compilation_cache.read().await.get(&key).cloned() {
+        let mut compilation_artifact = compilation_artifact.lock().await;
+        match *compilation_artifact {
+            Some(ref compiled_contracts) => {
+                tracing::debug!(?key, "Compiled contracts cache hit");
+                return Ok(compiled_contracts.clone());
+            }
+            None => {
+                tracing::debug!(?key, "Compiled contracts cache miss");
+                let compiled_contracts = Arc::new(
+                    compile_contracts::<P>(
+                        metadata,
+                        metadata_file_path,
+                        &mode,
+                        config,
+                        deployed_libraries,
+                    )
+                    .await?,
+                );
+                *compilation_artifact = Some(compiled_contracts.clone());
+                return Ok(compiled_contracts.clone());
+            }
+        }
+    };
+
+    tracing::debug!(?key, "Compiled contracts cache miss");
+    let mutex = {
+        let mut compilation_cache = compilation_cache.write().await;
+        let mutex = Arc::new(Mutex::new(None));
+        compilation_cache.insert(key, mutex.clone());
+        mutex
+    };
+    let mut compilation_artifact = mutex.lock().await;
+    let compiled_contracts = Arc::new(
+        compile_contracts::<P>(
+            metadata,
+            metadata_file_path,
+            &mode,
+            config,
+            deployed_libraries,
+        )
+        .await?,
+    );
+    *compilation_artifact = Some(compiled_contracts.clone());
+    Ok(compiled_contracts.clone())
+}
+
+async fn compile_contracts<P: Platform>(
+    metadata: &Metadata,
+    metadata_file_path: &Path,
+    mode: &SolcMode,
+    config: &Arguments,
+    deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
+) -> anyhow::Result<(Version, CompilerOutput)> {
+    let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
+    let compiler_path =
+        P::Compiler::get_compiler_executable(config, compiler_version_or_requirement).await?;
+    let compiler_version = P::Compiler::new(compiler_path.clone()).version()?;
+
+    tracing::info!(
+        %compiler_version,
+        metadata_file_path = %metadata_file_path.display(),
+        mode = ?mode,
+        "Compiling contracts"
+    );
+
+    let compiler = Compiler::<P::Compiler>::new()
+        .with_allow_path(metadata.directory()?)
+        .with_optimization(mode.solc_optimize());
+    let mut compiler = metadata
+        .files_to_compile()?
+        .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
+    for (library_instance, (library_address, _)) in deployed_libraries.iter() {
+        let library_ident = &metadata
+            .contracts
+            .as_ref()
+            .and_then(|contracts| contracts.get(library_instance))
+            .expect("Impossible for library to not be found in contracts")
+            .contract_ident;
+
+        // Note the following: we need to tell solc which files require the libraries to be linked
+        // into them. We do not have access to this information and therefore we choose an easier,
+        // yet more compute intensive route, of telling solc that all of the files need to link the
+        // library and it will only perform the linking for the files that do actually need the
+        // library.
+        compiler = FilesWithExtensionIterator::new(metadata.directory()?)
+            .with_allowed_extension("sol")
+            .with_use_cached_fs(true)
+            .fold(compiler, |compiler, path| {
+                compiler.with_library(&path, library_ident.as_str(), *library_address)
+            });
+    }
+
+    let compiler_output = compiler.try_build(compiler_path).await?;
+
+    Ok((compiler_version, compiler_output))
+}
+
+async fn execute_corpus(
+    args: &Arguments,
+    tests: &[MetadataFile],
+    span: Span,
+) -> anyhow::Result<()> {
    match (&args.leader, &args.follower) {
        (TestingPlatform::Geth, TestingPlatform::Kitchensink) => {
-            run_driver::<Geth, Kitchensink>(args, tests, span)?
+            run_driver::<Geth, Kitchensink>(args, tests, span).await?
        }
        (TestingPlatform::Geth, TestingPlatform::Geth) => {
-            run_driver::<Geth, Geth>(args, tests, span)?
+            run_driver::<Geth, Geth>(args, tests, span).await?
        }
        _ => unimplemented!(),
    }
@@ -150,24 +743,43 @@ fn execute_corpus(args: &Arguments, tests: &[MetadataFile], span: Span) -> anyho
    Ok(())
 }

-fn compile_corpus(
+async fn compile_corpus(
    config: &Arguments,
    tests: &[MetadataFile],
    platform: &TestingPlatform,
-    span: Span,
+    _: Span,
 ) {
-    tests.par_iter().for_each(|metadata| {
-        for mode in &metadata.solc_modes() {
+    let tests = tests.iter().flat_map(|metadata| {
+        metadata
+            .solc_modes()
+            .into_iter()
+            .map(move |solc_mode| (metadata, solc_mode))
+    });
+
+    futures::stream::iter(tests)
+        .for_each_concurrent(None, |(metadata, mode)| async move {
            match platform {
                TestingPlatform::Geth => {
-                    let mut state = State::<Geth>::new(config, span);
-                    let _ = state.build_contracts(mode, metadata);
+                    let _ = compile_contracts::<Geth>(
+                        &metadata.content,
+                        &metadata.path,
+                        &mode,
+                        config,
+                        &Default::default(),
+                    )
+                    .await;
                }
                TestingPlatform::Kitchensink => {
-                    let mut state = State::<Kitchensink>::new(config, span);
-                    let _ = state.build_contracts(mode, metadata);
+                    let _ = compile_contracts::<Geth>(
+                        &metadata.content,
+                        &metadata.path,
+                        &mode,
+                        config,
+                        &Default::default(),
+                    )
+                    .await;
                }
-            };
-        }
-    });
+            }
+        })
+        .await;
 }
@@ -9,6 +9,10 @@ repository.workspace = true
 rust-version.workspace = true

 [dependencies]
+revive-dt-common = { workspace = true }
+
+revive-common = { workspace = true }
+
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
@@ -17,3 +21,6 @@ tracing = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true }
@@ -1,12 +1,69 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};

-use crate::{input::Input, mode::Mode};
+use revive_dt_common::macros::define_wrapper_type;

-#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
+use crate::{
+    input::{Expected, Step},
+    mode::Mode,
+};
+
+#[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Case {
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub modes: Option<Vec<Mode>>,
-    pub inputs: Vec<Input>,
+
+    #[serde(rename = "inputs")]
+    pub steps: Vec<Step>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub expected: Option<Expected>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ignore: Option<bool>,
 }
+
+impl Case {
+    #[allow(irrefutable_let_patterns)]
+    pub fn steps_iterator(&self) -> impl Iterator<Item = Step> {
+        let steps_len = self.steps.len();
+        self.steps
+            .clone()
+            .into_iter()
+            .enumerate()
+            .map(move |(idx, mut step)| {
+                let Step::FunctionCall(ref mut input) = step else {
+                    return step;
+                };
+
+                if idx + 1 == steps_len {
+                    if input.expected.is_none() {
+                        input.expected = self.expected.clone();
+                    }
+
+                    // TODO: What does it mean for us to have an `expected` field on the case itself
+                    // but the final input also has an expected field that doesn't match the one on
+                    // the case? What are we supposed to do with that final expected field on the
+                    // case?
+
+                    step
+                } else {
+                    step
+                }
+            })
+    }
+}
+
+define_wrapper_type!(
+    /// A wrapper type for the index of test cases found in metadata file.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct CaseIdx(usize);
+);
@@ -3,6 +3,7 @@ use std::{
    path::{Path, PathBuf},
 };

+use revive_dt_common::cached_fs::read_dir;
 use serde::{Deserialize, Serialize};

 use crate::metadata::MetadataFile;
@@ -17,7 +18,25 @@ impl Corpus {
    /// Try to read and parse the corpus definition file at given `path`.
    pub fn try_from_path(path: &Path) -> anyhow::Result<Self> {
        let file = File::open(path)?;
-        Ok(serde_json::from_reader(file)?)
+        let mut corpus: Corpus = serde_json::from_reader(file)?;
+
+        // Ensure that the path mentioned in the corpus is relative to the corpus file.
+        // Canonicalizing also helps make the path in any errors unambiguous.
+        corpus.path = path
+            .parent()
+            .ok_or_else(|| {
+                anyhow::anyhow!("Corpus path '{}' does not point to a file", path.display())
+            })?
+            .canonicalize()
+            .map_err(|error| {
+                anyhow::anyhow!(
+                    "Failed to canonicalize path to corpus '{}': {error}",
+                    path.display()
+                )
+            })?
+            .join(corpus.path);
+
+        Ok(corpus)
    }

    /// Scan the corpus base directory and return all tests found.
@@ -35,33 +54,46 @@ impl Corpus {
 ///
 /// `path` is expected to be a directory.
 pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
-    let dir_entry = match std::fs::read_dir(path) {
-        Ok(dir_entry) => dir_entry,
-        Err(error) => {
-            tracing::error!("failed to read dir '{}': {error}", path.display());
-            return;
-        }
-    };
-
-    for entry in dir_entry {
-        let entry = match entry {
-            Ok(entry) => entry,
+    if path.is_dir() {
+        let dir_entry = match read_dir(path) {
+            Ok(dir_entry) => dir_entry,
            Err(error) => {
-                tracing::error!("error reading dir entry: {error}");
-                continue;
+                tracing::error!("failed to read dir '{}': {error}", path.display());
+                return;
            }
        };

-        let path = entry.path();
-        if path.is_dir() {
-            collect_metadata(&path, tests);
-            continue;
-        }
+        for path in dir_entry {
+            let path = match path {
+                Ok(entry) => entry,
+                Err(error) => {
+                    tracing::error!("error reading dir entry: {error}");
+                    continue;
+                }
+            };

-        if path.is_file() {
-            if let Some(metadata) = MetadataFile::try_from_file(&path) {
+            if path.is_dir() {
+                collect_metadata(&path, tests);
+                continue;
+            }
+
+            if path.is_file() {
+                if let Some(metadata) = MetadataFile::try_from_file(&path) {
+                    tests.push(metadata)
+                }
+            }
+        }
+    } else {
+        let Some(extension) = path.extension() else {
+            tracing::error!("Failed to get file extension");
+            return;
+        };
+        if extension.eq_ignore_ascii_case("sol") || extension.eq_ignore_ascii_case("json") {
+            if let Some(metadata) = MetadataFile::try_from_file(path) {
                tests.push(metadata)
            }
+        } else {
+            tracing::error!(?extension, "Unsupported file extension");
        }
    }
 }
@@ -5,3 +5,4 @@ pub mod corpus;
 pub mod input;
 pub mod metadata;
 pub mod mode;
+pub mod traits;
@@ -1,11 +1,19 @@
 use std::{
+    cmp::Ordering,
    collections::BTreeMap,
-    fs::{File, read_to_string},
+    fmt::Display,
+    fs::File,
    ops::Deref,
    path::{Path, PathBuf},
+    str::FromStr,
 };

-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
+
+use revive_common::EVMVersion;
+use revive_dt_common::{
+    cached_fs::read_to_string, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
+};

 use crate::{
    case::Case,
@@ -39,14 +47,42 @@ impl Deref for MetadataFile {
    }
 }

-#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
+#[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Metadata {
-    pub cases: Vec<Case>,
-    pub contracts: Option<BTreeMap<String, String>>,
-    pub libraries: Option<BTreeMap<String, BTreeMap<String, String>>>,
+    /// A comment on the test case that's added for human-readability.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub comment: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub ignore: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub targets: Option<Vec<String>>,
+
+    pub cases: Vec<Case>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdent>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub modes: Option<Vec<Mode>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_path: Option<PathBuf>,
+
+    /// This field specifies an EVM version requirement that the test case has where the test might
+    /// be run of the evm version of the nodes match the evm version specified here.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub required_evm_version: Option<EvmVersionRequirement>,
+
+    /// A set of compilation directives that will be passed to the compiler whenever the contracts for
+    /// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
+    /// just a filter for when a test can run whereas this is an instruction to the compiler.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub compiler_directives: Option<CompilationDirectives>,
 }

 impl Metadata {
@@ -77,28 +113,35 @@ impl Metadata {
            .to_path_buf())
    }

-    /// Extract the contract sources.
-    ///
-    /// Returns a mapping of contract IDs to their source path and contract name.
-    pub fn contract_sources(&self) -> anyhow::Result<BTreeMap<String, (PathBuf, String)>> {
+    /// Returns the contract sources with canonicalized paths for the files
+    pub fn contract_sources(
+        &self,
+    ) -> anyhow::Result<BTreeMap<ContractInstance, ContractPathAndIdent>> {
        let directory = self.directory()?;
        let mut sources = BTreeMap::new();
        let Some(contracts) = &self.contracts else {
            return Ok(sources);
        };

-        for (id, contract) in contracts {
-            // TODO: broken if a colon is in the dir name..
-            let mut parts = contract.split(':');
-            let (Some(file_name), Some(contract_name)) = (parts.next(), parts.next()) else {
-                anyhow::bail!("metadata contains invalid contract: {contract}");
-            };
-            let file = directory.to_path_buf().join(file_name);
-            if !file.is_file() {
-                anyhow::bail!("contract {id} is not a file: {}", file.display());
-            }
+        for (
+            alias,
+            ContractPathAndIdent {
+                contract_source_path,
+                contract_ident,
+            },
+        ) in contracts
+        {
+            let alias = alias.clone();
+            let absolute_path = directory.join(contract_source_path).canonicalize()?;
+            let contract_ident = contract_ident.clone();

-            sources.insert(id.clone(), (file, contract_name.to_string()));
+            sources.insert(
+                alias,
+                ContractPathAndIdent {
+                    contract_source_path: absolute_path,
+                    contract_ident,
+                },
+            );
        }

        Ok(sources)
@@ -178,12 +221,16 @@ impl Metadata {
        match serde_json::from_str::<Self>(&spec) {
            Ok(mut metadata) => {
                metadata.file_path = Some(path.to_path_buf());
-                let name = path
-                    .file_name()
-                    .expect("this should be the path to a Solidity file")
-                    .to_str()
-                    .expect("the file name should be valid UTF-8k");
-                metadata.contracts = Some([(String::from("Test"), format!("{name}:Test"))].into());
+                metadata.contracts = Some(
+                    [(
+                        ContractInstance::new("Test"),
+                        ContractPathAndIdent {
+                            contract_source_path: path.to_path_buf(),
+                            contract_ident: ContractIdent::new("Test"),
+                        },
+                    )]
+                    .into(),
+                );
                Some(metadata)
            }
            Err(error) => {
@@ -195,4 +242,325 @@ impl Metadata {
            }
        }
    }
+
+    /// Returns an iterator over all of the solidity files that needs to be compiled for this
+    /// [`Metadata`] object
+    ///
+    /// Note: if the metadata is contained within a solidity file then this is the only file that
+    /// we wish to compile since this is a self-contained test. Otherwise, if it's a JSON file
+    /// then we need to compile all of the contracts that are in the directory since imports are
+    /// allowed in there.
+    pub fn files_to_compile(&self) -> anyhow::Result<Box<dyn Iterator<Item = PathBuf>>> {
+        let Some(ref metadata_file_path) = self.file_path else {
+            anyhow::bail!("The metadata file path is not defined");
+        };
+        if metadata_file_path
+            .extension()
+            .is_some_and(|extension| extension.eq_ignore_ascii_case("sol"))
+        {
+            Ok(Box::new(std::iter::once(metadata_file_path.clone())))
+        } else {
+            Ok(Box::new(
+                FilesWithExtensionIterator::new(self.directory()?)
+                    .with_allowed_extension("sol")
+                    .with_use_cached_fs(true),
+            ))
+        }
+    }
+}
+
+define_wrapper_type!(
+    /// Represents a contract instance found a metadata file.
+    ///
+    /// Typically, this is used as the key to the "contracts" field of metadata files.
+    #[derive(
+        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+    )]
+    #[serde(transparent)]
+    pub struct ContractInstance(String);
+);
+
+define_wrapper_type!(
+    /// Represents a contract identifier found a metadata file.
+    ///
+    /// A contract identifier is the name of the contract in the source code.
+    #[derive(
+        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+    )]
+    #[serde(transparent)]
+    pub struct ContractIdent(String);
+);
+
+/// Represents an identifier used for contracts.
+///
+/// The type supports serialization from and into the following string format:
+///
+/// ```text
+/// ${path}:${contract_ident}
+/// ```
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(try_from = "String", into = "String")]
+pub struct ContractPathAndIdent {
+    /// The path of the contract source code relative to the directory containing the metadata file.
+    pub contract_source_path: PathBuf,
+
+    /// The identifier of the contract.
+    pub contract_ident: ContractIdent,
+}
+
+impl Display for ContractPathAndIdent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}:{}",
+            self.contract_source_path.display(),
+            self.contract_ident.as_ref()
+        )
+    }
+}
+
+impl FromStr for ContractPathAndIdent {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut splitted_string = s.split(":").peekable();
+        let mut path = None::<String>;
+        let mut identifier = None::<String>;
+        loop {
+            let Some(next_item) = splitted_string.next() else {
+                break;
+            };
+            if splitted_string.peek().is_some() {
+                match path {
+                    Some(ref mut path) => {
+                        path.push(':');
+                        path.push_str(next_item);
+                    }
+                    None => path = Some(next_item.to_owned()),
+                }
+            } else {
+                identifier = Some(next_item.to_owned())
+            }
+        }
+        match (path, identifier) {
+            (Some(path), Some(identifier)) => Ok(Self {
+                contract_source_path: PathBuf::from(path),
+                contract_ident: ContractIdent::new(identifier),
+            }),
+            (None, Some(path)) | (Some(path), None) => {
+                let Some(identifier) = path.split(".").next().map(ToOwned::to_owned) else {
+                    anyhow::bail!("Failed to find identifier");
+                };
+                Ok(Self {
+                    contract_source_path: PathBuf::from(path),
+                    contract_ident: ContractIdent::new(identifier),
+                })
+            }
+            (None, None) => anyhow::bail!("Failed to find the path and identifier"),
+        }
+    }
+}
+
+impl TryFrom<String> for ContractPathAndIdent {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::from_str(&value)
+    }
+}
+
+impl From<ContractPathAndIdent> for String {
+    fn from(value: ContractPathAndIdent) -> Self {
+        value.to_string()
+    }
+}
+
+/// An EVM version requirement that the test case has. This gets serialized and
+/// deserialized from and into [`String`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(try_from = "String", into = "String")]
+pub struct EvmVersionRequirement {
+    ordering: Ordering,
+    or_equal: bool,
+    evm_version: EVMVersion,
+}
+
+impl EvmVersionRequirement {
+    pub fn new_greater_than_or_equals(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Greater,
+            or_equal: true,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_greater_than(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Greater,
+            or_equal: false,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_equals(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Equal,
+            or_equal: false,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_less_than(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Less,
+            or_equal: false,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_less_than_or_equals(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Less,
+            or_equal: true,
+            evm_version: version,
+        }
+    }
+
+    pub fn matches(&self, other: &EVMVersion) -> bool {
+        let ordering = other.cmp(&self.evm_version);
+        ordering == self.ordering || (self.or_equal && matches!(ordering, Ordering::Equal))
+    }
+}
+
+impl Display for EvmVersionRequirement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let Self {
+            ordering,
+            or_equal,
+            evm_version,
+        } = self;
+        match ordering {
+            Ordering::Less => write!(f, "<")?,
+            Ordering::Equal => write!(f, "=")?,
+            Ordering::Greater => write!(f, ">")?,
+        }
+        if *or_equal && !matches!(ordering, Ordering::Equal) {
+            write!(f, "=")?;
+        }
+        write!(f, "{evm_version}")
+    }
+}
+
+impl FromStr for EvmVersionRequirement {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.as_bytes() {
+            [b'>', b'=', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Greater,
+                or_equal: true,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'>', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Greater,
+                or_equal: false,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'<', b'=', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Less,
+                or_equal: true,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'<', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Less,
+                or_equal: false,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'=', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Equal,
+                or_equal: false,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            _ => anyhow::bail!("Invalid EVM version requirement {s}"),
+        }
+    }
+}
+
+impl TryFrom<String> for EvmVersionRequirement {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        value.parse()
+    }
+}
+
+impl From<EvmVersionRequirement> for String {
+    fn from(value: EvmVersionRequirement) -> Self {
+        value.to_string()
+    }
+}
+
+/// A set of compilation directives that will be passed to the compiler whenever the contracts for
+/// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
+/// just a filter for when a test can run whereas this is an instruction to the compiler.
+/// Defines how the compiler should handle revert strings.
+#[derive(
+    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
+)]
+pub struct CompilationDirectives {
+    /// Defines how the revert strings should be handled.
+    pub revert_string_handling: Option<RevertString>,
+}
+
+/// Defines how the compiler should handle revert strings.
+#[derive(
+    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
+)]
+#[serde(rename_all = "camelCase")]
+pub enum RevertString {
+    #[default]
+    Default,
+    Debug,
+    Strip,
+    VerboseDebug,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn contract_identifier_respects_roundtrip_property() {
+        // Arrange
+        let string = "ERC20/ERC20.sol:ERC20";
+
+        // Act
+        let identifier = ContractPathAndIdent::from_str(string);
+
+        // Assert
+        let identifier = identifier.expect("Failed to parse");
+        assert_eq!(
+            identifier.contract_source_path.display().to_string(),
+            "ERC20/ERC20.sol"
+        );
+        assert_eq!(identifier.contract_ident, "ERC20".to_owned().into());
+
+        // Act
+        let reserialized = identifier.to_string();
+
+        // Assert
+        assert_eq!(string, reserialized);
+    }
+
+    #[test]
+    fn complex_metadata_file_can_be_deserialized() {
+        // Arrange
+        const JSON: &str = include_str!("../../../assets/test_metadata.json");
+
+        // Act
+        let metadata = serde_json::from_str::<Metadata>(JSON);
+
+        // Assert
+        metadata.expect("Failed to deserialize metadata");
+    }
 }
@@ -1,3 +1,4 @@
+use revive_dt_common::types::VersionOrRequirement;
 use semver::Version;
 use serde::de::Deserializer;
 use serde::{Deserialize, Serialize};
@@ -15,6 +16,7 @@ pub struct SolcMode {
    pub solc_version: Option<semver::VersionReq>,
    solc_optimize: Option<bool>,
    pub llvm_optimizer_settings: Vec<String>,
+    mode_string: String,
 }

 impl SolcMode {
@@ -28,7 +30,10 @@ impl SolcMode {
    /// - A solc `SemVer version requirement` string
    /// - One or more `-OX` where X is a supposed to be an LLVM opt mode
    pub fn parse_from_mode_string(mode_string: &str) -> Option<Self> {
-        let mut result = Self::default();
+        let mut result = Self {
+            mode_string: mode_string.to_string(),
+            ..Default::default()
+        };

        let mut parts = mode_string.trim().split(" ");

@@ -78,6 +83,15 @@ impl SolcMode {

        None
    }
+
+    /// Resolves the [`SolcMode`]'s solidity version requirement into a [`VersionOrRequirement`] if
+    /// the requirement is present on the object. Otherwise, the passed default version is used.
+    pub fn compiler_version_to_use(&self, default: Version) -> VersionOrRequirement {
+        match self.solc_version {
+            Some(ref requirement) => requirement.clone().into(),
+            None => default.into(),
+        }
+    }
 }

 impl<'de> Deserialize<'de> for Mode {
@@ -94,3 +108,16 @@ impl<'de> Deserialize<'de> for Mode {
        Ok(Self::Unknown(mode_string))
    }
 }
+
+impl Serialize for Mode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let string = match self {
+            Mode::Solidity(solc_mode) => &solc_mode.mode_string,
+            Mode::Unknown(string) => string,
+        };
+        string.serialize(serializer)
+    }
+}
@@ -0,0 +1,150 @@
+use std::collections::HashMap;
+
+use alloy::eips::BlockNumberOrTag;
+use alloy::json_abi::JsonAbi;
+use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
+use alloy_primitives::TxHash;
+use anyhow::Result;
+
+use crate::metadata::ContractInstance;
+
+/// A trait of the interface are required to implement to be used by the resolution logic that this
+/// crate implements to go from string calldata and into the bytes calldata.
+pub trait ResolverApi {
+    /// Returns the ID of the chain that the node is on.
+    fn chain_id(&self) -> impl Future<Output = Result<ChainId>>;
+
+    /// Returns the gas price for the specified transaction.
+    fn transaction_gas_price(&self, tx_hash: &TxHash) -> impl Future<Output = Result<u128>>;
+
+    // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
+    // when we implement the changes to the gas we need to adjust this to be a u64.
+    /// Returns the gas limit of the specified block.
+    fn block_gas_limit(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<u128>>;
+
+    /// Returns the coinbase of the specified block.
+    fn block_coinbase(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<Address>>;
+
+    /// Returns the difficulty of the specified block.
+    fn block_difficulty(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<U256>>;
+
+    /// Returns the base fee of the specified block.
+    fn block_base_fee(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<u64>>;
+
+    /// Returns the hash of the specified block.
+    fn block_hash(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<BlockHash>>;
+
+    /// Returns the timestamp of the specified block,
+    fn block_timestamp(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> impl Future<Output = Result<BlockTimestamp>>;
+
+    /// Returns the number of the last block.
+    fn last_block_number(&self) -> impl Future<Output = Result<BlockNumber>>;
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+/// Contextual information required by the code that's performing the resolution.
+pub struct ResolutionContext<'a> {
+    /// When provided the contracts provided here will be used for resolutions.
+    deployed_contracts: Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>,
+
+    /// When provided the variables in here will be used for performing resolutions.
+    variables: Option<&'a HashMap<String, U256>>,
+
+    /// When provided this block number will be treated as the tip of the chain.
+    block_number: Option<&'a BlockNumber>,
+
+    /// When provided the resolver will use this transaction hash for all of its resolutions.
+    transaction_hash: Option<&'a TxHash>,
+}
+
+impl<'a> ResolutionContext<'a> {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn new_from_parts(
+        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>>,
+        block_number: impl Into<Option<&'a BlockNumber>>,
+        transaction_hash: impl Into<Option<&'a TxHash>>,
+    ) -> Self {
+        Self {
+            deployed_contracts: deployed_contracts.into(),
+            variables: variables.into(),
+            block_number: block_number.into(),
+            transaction_hash: transaction_hash.into(),
+        }
+    }
+
+    pub fn with_deployed_contracts(
+        mut self,
+        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+    ) -> Self {
+        self.deployed_contracts = deployed_contracts.into();
+        self
+    }
+
+    pub fn with_variables(
+        mut self,
+        variables: impl Into<Option<&'a HashMap<String, U256>>>,
+    ) -> Self {
+        self.variables = variables.into();
+        self
+    }
+
+    pub fn with_block_number(mut self, block_number: impl Into<Option<&'a BlockNumber>>) -> Self {
+        self.block_number = block_number.into();
+        self
+    }
+
+    pub fn with_transaction_hash(
+        mut self,
+        transaction_hash: impl Into<Option<&'a TxHash>>,
+    ) -> Self {
+        self.transaction_hash = transaction_hash.into();
+        self
+    }
+
+    pub fn resolve_block_number(&self, number: BlockNumberOrTag) -> BlockNumberOrTag {
+        match self.block_number {
+            Some(block_number) => match number {
+                BlockNumberOrTag::Latest => BlockNumberOrTag::Number(*block_number),
+                n @ (BlockNumberOrTag::Finalized
+                | BlockNumberOrTag::Safe
+                | BlockNumberOrTag::Earliest
+                | BlockNumberOrTag::Pending
+                | BlockNumberOrTag::Number(_)) => n,
+            },
+            None => number,
+        }
+    }
+
+    pub fn deployed_contract(&self, instance: &ContractInstance) -> Option<&(Address, JsonAbi)> {
+        self.deployed_contracts
+            .and_then(|deployed_contracts| deployed_contracts.get(instance))
+    }
+
+    pub fn deployed_contract_address(&self, instance: &ContractInstance) -> Option<&Address> {
+        self.deployed_contract(instance).map(|(a, _)| a)
+    }
+
+    pub fn deployed_contract_abi(&self, instance: &ContractInstance) -> Option<&JsonAbi> {
+        self.deployed_contract(instance).map(|(_, a)| a)
+    }
+
+    pub fn variable(&self, name: impl AsRef<str>) -> Option<&U256> {
+        self.variables
+            .and_then(|variables| variables.get(name.as_ref()))
+    }
+
+    pub fn tip_block_number(&self) -> Option<&'a BlockNumber> {
+        self.block_number
+    }
+
+    pub fn transaction_hash(&self) -> Option<&'a TxHash> {
+        self.transaction_hash
+    }
+}
@@ -11,7 +11,3 @@ rust-version.workspace = true
 [dependencies]
 alloy = { workspace = true }
 anyhow = { workspace = true }
-futures = { workspace = true }
-tracing = { workspace = true }
-once_cell = { workspace = true }
-tokio = { workspace = true }
@@ -1,221 +0,0 @@
-//! The alloy crate __requires__ a tokio runtime.
-//! We contain any async rust right here.
-
-use std::{any::Any, panic::AssertUnwindSafe, pin::Pin, thread};
-
-use futures::FutureExt;
-use once_cell::sync::Lazy;
-use tokio::{
-    runtime::Builder,
-    sync::{mpsc::UnboundedSender, oneshot},
-};
-
-/// A blocking async executor.
-///
-/// This struct exposes the abstraction of a blocking async executor. It is a global and static
-/// executor which means that it doesn't require for new instances of it to be created, it's a
-/// singleton and can be accessed by any thread that wants to perform some async computation on the
-/// blocking executor thread.
-///
-/// The API of the blocking executor is created in a way so that it's very natural, simple to use,
-/// and unbounded to specific tasks or return types. The following is an example of using this
-/// executor to drive an async computation:
-///
-/// ```rust
-/// use revive_dt_node_interaction::*;
-///
-/// fn blocking_function() {
-///     let result = BlockingExecutor::execute(async move {
-///         tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-///         0xFFu8
-///     })
-///     .expect("Computation failed");
-///
-///     assert_eq!(result, 0xFF);
-/// }
-/// ```
-///
-/// Users get to pass in their async tasks without needing to worry about putting them in a [`Box`],
-/// [`Pin`], needing to perform down-casting, or the internal channel mechanism used by the runtime.
-/// To the user, it just looks like a function that converts some async code into sync code.
-///
-/// This struct also handled panics that occur in the passed futures and converts them into errors
-/// that can be handled by the user. This is done to allow the executor to be robust.
-///
-/// Internally, the executor communicates with the tokio runtime thread through channels which carry
-/// the [`TaskMessage`] and the results of the execution.
-pub struct BlockingExecutor;
-
-impl BlockingExecutor {
-    pub fn execute<R>(future: impl Future<Output = R> + Send + 'static) -> Result<R, anyhow::Error>
-    where
-        R: Send + 'static,
-    {
-        // Note: The blocking executor is a singleton and therefore we store its state in a static
-        // so that it's assigned only once. Additionally, when we set the state of the executor we
-        // spawn the thread where the async runtime runs.
-        static STATE: Lazy<ExecutorState> = Lazy::new(|| {
-            tracing::trace!("Initializing the BlockingExecutor state");
-
-            // All communication with the tokio runtime thread happens over mspc channels where the
-            // producers here are the threads that want to run async tasks and the consumer here is
-            // the tokio runtime thread.
-            let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<TaskMessage>();
-
-            thread::spawn(move || {
-                let runtime = Builder::new_current_thread()
-                    .enable_all()
-                    .build()
-                    .expect("Failed to create the async runtime");
-
-                runtime.block_on(async move {
-                    while let Some(TaskMessage {
-                        future: task,
-                        response_tx: response_channel,
-                    }) = rx.recv().await
-                    {
-                        tracing::trace!("Received a new future to execute");
-                        tokio::spawn(async move {
-                            // One of the things that the blocking executor does is that it allows
-                            // us to catch panics if they occur. By wrapping the given future in an
-                            // AssertUnwindSafe::catch_unwind we are able to catch all panic unwinds
-                            // in the given future and convert them into errors.
-                            let task = AssertUnwindSafe(task).catch_unwind();
-
-                            let result = task.await;
-                            let _ = response_channel.send(result);
-                        });
-                    }
-                })
-            });
-
-            ExecutorState { tx }
-        });
-
-        // We need to perform blocking synchronous communication between the current thread and the
-        // tokio runtime thread with the result of the async computation and the oneshot channels
-        // from tokio allows us to do that. The sender side of the channel will be given to the
-        // tokio runtime thread to send the result when the computation is completed and the receive
-        // side of the channel will be kept with this thread to await for the response of the async
-        // task to come back.
-        let (response_tx, response_rx) =
-            oneshot::channel::<Result<Box<dyn Any + Send>, Box<dyn Any + Send>>>();
-
-        // The tokio runtime thread expects a Future<Output = Box<dyn Any + Send>> + Send to be
-        // sent to it to execute. However, this function has a typed Future<Output = R> + Send and
-        // therefore we need to change the type of the future to fit what the runtime thread expects
-        // in the task message. In doing this conversion, we lose some of the type information since
-        // we're converting R => dyn Any. However, we will perform down-casting on the result to
-        // convert it back into R.
-        let future = Box::pin(async move { Box::new(future.await) as Box<dyn Any + Send> });
-
-        let task = TaskMessage::new(future, response_tx);
-        if let Err(error) = STATE.tx.send(task) {
-            tracing::error!(?error, "Failed to send the task to the blocking executor");
-            anyhow::bail!("Failed to send the task to the blocking executor: {error:?}")
-        }
-
-        let result = match response_rx.blocking_recv() {
-            Ok(result) => result,
-            Err(error) => {
-                tracing::error!(
-                    ?error,
-                    "Failed to get the response from the blocking executor"
-                );
-                anyhow::bail!("Failed to get the response from the blocking executor: {error:?}")
-            }
-        };
-
-        match result.map(|result| {
-            *result
-                .downcast::<R>()
-                .expect("Type mismatch in the downcast")
-        }) {
-            Ok(result) => Ok(result),
-            Err(error) => {
-                tracing::error!(
-                    ?error,
-                    "Failed to downcast the returned result into the expected type"
-                );
-                anyhow::bail!(
-                    "Failed to downcast the returned result into the expected type: {error:?}"
-                )
-            }
-        }
-    }
-}
-
-/// Represents the state of the async runtime. This runtime is designed to be a singleton runtime
-/// which means that in the current running program there's just a single thread that has an async
-/// runtime.
-struct ExecutorState {
-    /// The sending side of the task messages channel. This is used by all of the other threads to
-    /// communicate with the async runtime thread.
-    tx: UnboundedSender<TaskMessage>,
-}
-
-/// Represents a message that contains an asynchronous task that's to be executed by the runtime
-/// as well as a way for the runtime to report back on the result of the execution.
-struct TaskMessage {
-    /// The task that's being requested to run. This is a future that returns an object that does
-    /// implement [`Any`] and [`Send`] to allow it to be sent between the requesting thread and the
-    /// async thread.
-    future: Pin<Box<dyn Future<Output = Box<dyn Any + Send>> + Send>>,
-
-    /// A one shot sender channel where the sender of the task is expecting to hear back on the
-    /// result of the task.
-    response_tx: oneshot::Sender<Result<Box<dyn Any + Send>, Box<dyn Any + Send>>>,
-}
-
-impl TaskMessage {
-    pub fn new(
-        future: Pin<Box<dyn Future<Output = Box<dyn Any + Send>> + Send>>,
-        response_tx: oneshot::Sender<Result<Box<dyn Any + Send>, Box<dyn Any + Send>>>,
-    ) -> Self {
-        Self {
-            future,
-            response_tx,
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn simple_future_works() {
-        // Act
-        let result = BlockingExecutor::execute(async move {
-            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-            0xFFu8
-        })
-        .unwrap();
-
-        // Assert
-        assert_eq!(result, 0xFFu8);
-    }
-
-    #[test]
-    #[allow(unreachable_code, clippy::unreachable)]
-    fn panics_in_futures_are_caught() {
-        // Act
-        let result = BlockingExecutor::execute(async move {
-            panic!("This is a panic!");
-            0xFFu8
-        });
-
-        // Assert
-        assert!(result.is_err());
-
-        // Act
-        let result = BlockingExecutor::execute(async move {
-            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-            0xFFu8
-        })
-        .unwrap();
-
-        // Assert
-        assert_eq!(result, 0xFFu8)
-    }
-}
@@ -1,11 +1,9 @@
 //! This crate implements all node interactions.

-use alloy::primitives::Address;
-use alloy::rpc::types::trace::geth::{DiffMode, GethTrace};
-use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
-
-mod blocking_executor;
-pub use blocking_executor::*;
+use alloy::primitives::{Address, StorageKey, U256};
+use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
+use alloy::rpc::types::{EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest};
+use anyhow::Result;

 /// An interface for all interactions with Ethereum compatible nodes.
 pub trait EthereumNode {
@@ -13,14 +11,25 @@ pub trait EthereumNode {
    fn execute_transaction(
        &self,
        transaction: TransactionRequest,
-    ) -> anyhow::Result<TransactionReceipt>;
+    ) -> impl Future<Output = Result<TransactionReceipt>>;

    /// Trace the transaction in the [TransactionReceipt] and return a [GethTrace].
-    fn trace_transaction(&self, transaction: TransactionReceipt) -> anyhow::Result<GethTrace>;
+    fn trace_transaction(
+        &self,
+        receipt: &TransactionReceipt,
+        trace_options: GethDebugTracingOptions,
+    ) -> impl Future<Output = Result<GethTrace>>;

    /// Returns the state diff of the transaction hash in the [TransactionReceipt].
-    fn state_diff(&self, transaction: TransactionReceipt) -> anyhow::Result<DiffMode>;
+    fn state_diff(&self, receipt: &TransactionReceipt) -> impl Future<Output = Result<DiffMode>>;

-    /// Returns the next available nonce for the given [Address].
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64>;
+    /// Returns the balance of the provided [`Address`] back.
+    fn balance_of(&self, address: Address) -> impl Future<Output = Result<U256>>;
+
+    /// Returns the latest storage proof of the provided [`Address`]
+    fn latest_state_proof(
+        &self,
+        address: Address,
+        keys: Vec<StorageKey>,
+    ) -> impl Future<Output = Result<EIP1186AccountProofResponse>>;
 }
@@ -14,9 +14,13 @@ alloy = { workspace = true }
 tracing = { workspace = true }
 tokio = { workspace = true }

-revive-dt-node-interaction = { workspace = true }
+revive-common = { workspace = true }
+revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
+revive-dt-format = { workspace = true }
+revive-dt-node-interaction = { workspace = true }

+serde = { workspace = true }
 serde_json = { workspace = true }

 sp-core = { workspace = true }
@@ -24,3 +28,4 @@ sp-runtime = { workspace = true }

 [dev-dependencies]
 temp-dir = { workspace = true }
+tokio = { workspace = true }
@@ -0,0 +1,78 @@
+use alloy::{
+    network::{Network, TransactionBuilder},
+    providers::{
+        Provider, SendableTx,
+        fillers::{GasFiller, TxFiller},
+    },
+    transports::TransportResult,
+};
+
+#[derive(Clone, Debug)]
+pub struct FallbackGasFiller {
+    inner: GasFiller,
+    default_gas_limit: u64,
+    default_max_fee_per_gas: u128,
+    default_priority_fee: u128,
+}
+
+impl FallbackGasFiller {
+    pub fn new(
+        default_gas_limit: u64,
+        default_max_fee_per_gas: u128,
+        default_priority_fee: u128,
+    ) -> Self {
+        Self {
+            inner: GasFiller,
+            default_gas_limit,
+            default_max_fee_per_gas,
+            default_priority_fee,
+        }
+    }
+}
+
+impl<N> TxFiller<N> for FallbackGasFiller
+where
+    N: Network,
+{
+    type Fillable = Option<<GasFiller as TxFiller<N>>::Fillable>;
+
+    fn status(
+        &self,
+        tx: &<N as Network>::TransactionRequest,
+    ) -> alloy::providers::fillers::FillerControlFlow {
+        <GasFiller as TxFiller<N>>::status(&self.inner, tx)
+    }
+
+    fn fill_sync(&self, _: &mut alloy::providers::SendableTx<N>) {}
+
+    async fn prepare<P: Provider<N>>(
+        &self,
+        provider: &P,
+        tx: &<N as Network>::TransactionRequest,
+    ) -> TransportResult<Self::Fillable> {
+        // Try to fetch GasFiller’s “fillable” (gas_price, base_fee, estimate_gas, …)
+        // If it errors (i.e. tx would revert under eth_estimateGas), swallow it.
+        match self.inner.prepare(provider, tx).await {
+            Ok(fill) => Ok(Some(fill)),
+            Err(_) => Ok(None),
+        }
+    }
+
+    async fn fill(
+        &self,
+        fillable: Self::Fillable,
+        mut tx: alloy::providers::SendableTx<N>,
+    ) -> TransportResult<SendableTx<N>> {
+        if let Some(fill) = fillable {
+            // our inner GasFiller succeeded — use it
+            self.inner.fill(fill, tx).await
+        } else {
+            if let Some(builder) = tx.as_mut_builder() {
+                builder.set_gas_limit(self.default_gas_limit);
+                builder.set_max_fee_per_gas(self.default_max_fee_per_gas);
+                builder.set_max_priority_fee_per_gas(self.default_priority_fee);
+            }
+            Ok(tx)
+        }
+    }
+}
@@ -0,0 +1,5 @@
+/// This constant defines how much Wei accounts are pre-seeded with in genesis.
+///
+/// Note: After changing this number, check that the tests for kitchensink work as we encountered
+/// some issues with different values of the initial balance on Kitchensink.
+pub const INITIAL_BALANCE: u128 = 10u128.pow(37);
@@ -1,32 +1,46 @@
 //! The go-ethereum node implementation.

 use std::{
-    collections::HashMap,
    fs::{File, OpenOptions, create_dir_all, remove_dir_all},
    io::{BufRead, BufReader, Read, Write},
+    ops::ControlFlow,
    path::PathBuf,
    process::{Child, Command, Stdio},
    sync::{
-        Mutex,
+        Arc,
        atomic::{AtomicU32, Ordering},
    },
    time::{Duration, Instant},
 };

 use alloy::{
-    network::EthereumWallet,
-    primitives::Address,
-    providers::{Provider, ProviderBuilder, ext::DebugApi},
+    eips::BlockNumberOrTag,
+    genesis::{Genesis, GenesisAccount},
+    network::{Ethereum, EthereumWallet, NetworkWallet},
+    primitives::{
+        Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, StorageKey, TxHash, U256,
+    },
+    providers::{
+        Provider, ProviderBuilder,
+        ext::DebugApi,
+        fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
+    },
    rpc::types::{
-        TransactionReceipt, TransactionRequest,
+        EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
        trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
    },
+    signers::local::PrivateKeySigner,
 };
-use revive_dt_config::Arguments;
-use revive_dt_node_interaction::{BlockingExecutor, EthereumNode};
-use tracing::Level;
+use anyhow::Context;
+use revive_common::EVMVersion;
+use tracing::{Instrument, Level};

-use crate::Node;
+use revive_dt_common::{fs::clear_directory, futures::poll};
+use revive_dt_config::Arguments;
+use revive_dt_format::traits::ResolverApi;
+use revive_dt_node_interaction::EthereumNode;
+
+use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};

 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);

@@ -38,7 +52,7 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
-pub struct Instance {
+pub struct GethNode {
    connection_string: String,
    base_directory: PathBuf,
    data_directory: PathBuf,
@@ -49,7 +63,7 @@ pub struct Instance {
    network_id: u64,
    start_timeout: u64,
    wallet: EthereumWallet,
-    nonces: Mutex<HashMap<Address, u64>>,
+    nonce_manager: CachedNonceManager,
    /// This vector stores [`File`] objects that we use for logging which we want to flush when the
    /// node object is dropped. We do not store them in a structured fashion at the moment (in
    /// separate fields) as the logic that we need to apply to them is all the same regardless of
@@ -57,7 +71,7 @@ pub struct Instance {
    logs_file_to_flush: Vec<File>,
 }

-impl Instance {
+impl GethNode {
    const BASE_DIRECTORY: &str = "geth";
    const DATA_DIRECTORY: &str = "data";
    const LOGS_DIRECTORY: &str = "logs";
@@ -71,16 +85,38 @@ impl Instance {
    const GETH_STDOUT_LOG_FILE_NAME: &str = "node_stdout.log";
    const GETH_STDERR_LOG_FILE_NAME: &str = "node_stderr.log";

+    const TRANSACTION_INDEXING_ERROR: &str = "transaction indexing is in progress";
+    const TRANSACTION_TRACING_ERROR: &str = "historical state not available in path scheme yet";
+
+    const RECEIPT_POLLING_DURATION: Duration = Duration::from_secs(5 * 60);
+    const TRACE_POLLING_DURATION: Duration = Duration::from_secs(60);
+
    /// Create the node directory and call `geth init` to configure the genesis.
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
+        let _ = clear_directory(&self.base_directory);
+        let _ = clear_directory(&self.logs_directory);
+
        create_dir_all(&self.base_directory)?;
        create_dir_all(&self.logs_directory)?;

+        let mut genesis = serde_json::from_str::<Genesis>(&genesis)?;
+        for signer_address in
+            <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
+        {
+            // Note, the use of the entry API here means that we only modify the entries for any
+            // account that is not in the `alloc` field of the genesis state.
+            genesis
+                .alloc
+                .entry(signer_address)
+                .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
+        }
        let genesis_path = self.base_directory.join(Self::GENESIS_JSON_FILE);
-        File::create(&genesis_path)?.write_all(genesis.as_bytes())?;
+        serde_json::to_writer(File::create(&genesis_path)?, &genesis)?;

        let mut child = Command::new(&self.geth)
+            .arg("--state.scheme")
+            .arg("hash")
            .arg("init")
            .arg("--datadir")
            .arg(&self.data_directory)
@@ -106,7 +142,7 @@ impl Instance {
    /// Spawn the go-ethereum node child process.
    ///
    /// [Instance::init] must be called prior.
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn spawn_process(&mut self) -> anyhow::Result<&mut Self> {
        // This is the `OpenOptions` that we wish to use for all of the log files that we will be
        // opening in this method. We need to construct it in this way to:
@@ -134,6 +170,16 @@ impl Instance {
            .arg("--nodiscover")
            .arg("--maxpeers")
            .arg("0")
+            .arg("--txlookuplimit")
+            .arg("0")
+            .arg("--cache.blocklogs")
+            .arg("512")
+            .arg("--state.scheme")
+            .arg("hash")
+            .arg("--syncmode")
+            .arg("full")
+            .arg("--gcmode")
+            .arg("archive")
            .stderr(stderr_logs_file.try_clone()?)
            .stdout(stdout_logs_file.try_clone()?)
            .spawn()?
@@ -154,7 +200,7 @@ impl Instance {
    /// Wait for the g-ethereum node child process getting ready.
    ///
    /// [Instance::spawn_process] must be called priorly.
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn wait_ready(&mut self) -> anyhow::Result<&mut Self> {
        let start_time = Instant::now();

@@ -191,129 +237,137 @@ impl Instance {
    fn geth_stderr_log_file_path(&self) -> PathBuf {
        self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
    }
-}

-impl EthereumNode for Instance {
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    fn execute_transaction(
+    fn provider(
        &self,
-        transaction: TransactionRequest,
-    ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
+    ) -> impl Future<
+        Output = anyhow::Result<
+            FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>,
+        >,
+    > + 'static {
        let connection_string = self.connection_string();
        let wallet = self.wallet.clone();

-        BlockingExecutor::execute(async move {
-            let outer_span = tracing::debug_span!("Submitting transaction", ?transaction,);
-            let _outer_guard = outer_span.enter();
+        // Note: We would like all providers to make use of the same nonce manager so that we have
+        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
+        // its implementation and therefore it means that when we clone it then it still references
+        // the same state.
+        let nonce_manager = self.nonce_manager.clone();

-            let provider = ProviderBuilder::new()
+        Box::pin(async move {
+            ProviderBuilder::new()
+                .disable_recommended_fillers()
+                .filler(FallbackGasFiller::new(500_000_000, 500_000_000, 1))
+                .filler(ChainIdFiller::default())
+                .filler(NonceFiller::new(nonce_manager))
                .wallet(wallet)
                .connect(&connection_string)
-                .await?;
+                .await
+                .map_err(Into::into)
+        })
+    }
+}

-            let pending_transaction = provider.send_transaction(transaction).await?;
-            let transaction_hash = pending_transaction.tx_hash();
+impl EthereumNode for GethNode {
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn execute_transaction(
+        &self,
+        transaction: TransactionRequest,
+    ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
+        let span = tracing::debug_span!("Submitting transaction", ?transaction);
+        let _guard = span.enter();

-            let span = tracing::info_span!("Awaiting transaction receipt", ?transaction_hash);
-            let _guard = span.enter();
+        let provider = Arc::new(self.provider().await?);
+        let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();

-            // The following is a fix for the "transaction indexing is in progress" error that we
-            // used to get. You can find more information on this in the following GH issue in geth
-            // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
-            // before we can get the receipt of the transaction it needs to have been indexed by the
-            // node's indexer. Just because the transaction has been confirmed it doesn't mean that
-            // it has been indexed. When we call alloy's `get_receipt` it checks if the transaction
-            // was confirmed. If it has been, then it will call `eth_getTransactionReceipt` method
-            // which _might_ return the above error if the tx has not yet been indexed yet. So, we
-            // need to implement a retry mechanism for the receipt to keep retrying to get it until
-            // it eventually works, but we only do that if the error we get back is the "transaction
-            // indexing is in progress" error or if the receipt is None.
-            //
-            // At the moment we do not allow for the 60 seconds to be modified and we take it as
-            // being an implementation detail that's invisible to anything outside of this module.
-            //
-            // We allow a total of 60 retries for getting the receipt with one second between each
-            // retry and the next which means that we allow for a total of 60 seconds of waiting
-            // before we consider that we're unable to get the transaction receipt.
-            let mut retries = 0;
-            loop {
-                match provider.get_transaction_receipt(*transaction_hash).await {
-                    Ok(Some(receipt)) => {
-                        tracing::info!("Obtained the transaction receipt");
-                        break Ok(receipt);
-                    }
-                    Ok(None) => {
-                        if retries == 60 {
-                            tracing::error!(
-                                "Polled for transaction receipt for 60 seconds but failed to get it"
-                            );
-                            break Err(anyhow::anyhow!("Failed to get the transaction receipt"));
-                        } else {
-                            tracing::trace!(
-                                retries,
-                                "Sleeping for 1 second and trying to get the receipt again"
-                            );
-                            retries += 1;
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            continue;
-                        }
-                    }
-                    Err(error) => {
-                        let error_string = error.to_string();
-                        if error_string.contains("transaction indexing is in progress") {
-                            if retries == 60 {
-                                tracing::error!(
-                                    "Polled for transaction receipt for 60 seconds but failed to get it"
-                                );
-                                break Err(error.into());
-                            } else {
-                                tracing::trace!(
-                                    retries,
-                                    "Sleeping for 1 second and trying to get the receipt again"
-                                );
-                                retries += 1;
-                                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                                continue;
+        // The following is a fix for the "transaction indexing is in progress" error that we
+        // used to get. You can find more information on this in the following GH issue in geth
+        // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
+        // before we can get the receipt of the transaction it needs to have been indexed by the
+        // node's indexer. Just because the transaction has been confirmed it doesn't mean that
+        // it has been indexed. When we call alloy's `get_receipt` it checks if the transaction
+        // was confirmed. If it has been, then it will call `eth_getTransactionReceipt` method
+        // which _might_ return the above error if the tx has not yet been indexed yet. So, we
+        // need to implement a retry mechanism for the receipt to keep retrying to get it until
+        // it eventually works, but we only do that if the error we get back is the "transaction
+        // indexing is in progress" error or if the receipt is None.
+        //
+        // Getting the transaction indexed and taking a receipt can take a long time especially
+        // when a lot of transactions are being submitted to the node. Thus, while initially we
+        // only allowed for 60 seconds of waiting with a 1 second delay in polling, we need to
+        // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
+        // with exponential backoff each time we attempt to get the receipt and find that it's
+        // not available.
+        poll(
+            Self::RECEIPT_POLLING_DURATION,
+            Default::default(),
+            move || {
+                let provider = provider.clone();
+                async move {
+                    match provider.get_transaction_receipt(transaction_hash).await {
+                        Ok(Some(receipt)) => Ok(ControlFlow::Break(receipt)),
+                        Ok(None) => Ok(ControlFlow::Continue(())),
+                        Err(error) => {
+                            let error_string = error.to_string();
+                            match error_string.contains(Self::TRANSACTION_INDEXING_ERROR) {
+                                true => Ok(ControlFlow::Continue(())),
+                                false => Err(error.into()),
                            }
-                        } else {
-                            break Err(error.into());
                        }
                    }
                }
-            }
-        })?
+            },
+        )
+        .instrument(tracing::info_span!(
+            "Awaiting transaction receipt",
+            ?transaction_hash
+        ))
+        .await
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    fn trace_transaction(
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn trace_transaction(
        &self,
-        transaction: TransactionReceipt,
+        transaction: &TransactionReceipt,
+        trace_options: GethDebugTracingOptions,
    ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let connection_string = self.connection_string();
+        let provider = Arc::new(self.provider().await?);
+        poll(
+            Self::TRACE_POLLING_DURATION,
+            Default::default(),
+            move || {
+                let provider = provider.clone();
+                let trace_options = trace_options.clone();
+                async move {
+                    match provider
+                        .debug_trace_transaction(transaction.transaction_hash, trace_options)
+                        .await
+                    {
+                        Ok(trace) => Ok(ControlFlow::Break(trace)),
+                        Err(error) => {
+                            let error_string = error.to_string();
+                            match error_string.contains(Self::TRANSACTION_TRACING_ERROR) {
+                                true => Ok(ControlFlow::Continue(())),
+                                false => Err(error.into()),
+                            }
+                        }
+                    }
+                }
+            },
+        )
+        .await
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
            diff_mode: Some(true),
            disable_code: None,
            disable_storage: None,
        });
-        let wallet = self.wallet.clone();
-
-        BlockingExecutor::execute(async move {
-            Ok(ProviderBuilder::new()
-                .wallet(wallet)
-                .connect(&connection_string)
-                .await?
-                .debug_trace_transaction(transaction.transaction_hash, trace_options)
-                .await?)
-        })?
-    }
-
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    fn state_diff(
-        &self,
-        transaction: alloy::rpc::types::TransactionReceipt,
-    ) -> anyhow::Result<DiffMode> {
        match self
-            .trace_transaction(transaction)?
+            .trace_transaction(transaction, trace_options)
+            .await?
            .try_into_pre_state_frame()?
        {
            PreStateFrame::Diff(diff) => Ok(diff),
@@ -321,35 +375,140 @@ impl EthereumNode for Instance {
        }
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64> {
-        let connection_string = self.connection_string.clone();
-        let wallet = self.wallet.clone();
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
+        self.provider()
+            .await?
+            .get_balance(address)
+            .await
+            .map_err(Into::into)
+    }

-        let onchain_nonce = BlockingExecutor::execute::<anyhow::Result<_>>(async move {
-            ProviderBuilder::new()
-                .wallet(wallet)
-                .connect(&connection_string)
-                .await?
-                .get_transaction_count(address)
-                .await
-                .map_err(Into::into)
-        })??;
-
-        let mut nonces = self.nonces.lock().unwrap();
-        let current = nonces.entry(address).or_insert(onchain_nonce);
-        let value = *current;
-        *current += 1;
-        Ok(value)
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn latest_state_proof(
+        &self,
+        address: Address,
+        keys: Vec<StorageKey>,
+    ) -> anyhow::Result<EIP1186AccountProofResponse> {
+        self.provider()
+            .await?
+            .get_proof(address, keys)
+            .latest()
+            .await
+            .map_err(Into::into)
    }
 }

-impl Node for Instance {
+impl ResolverApi for GethNode {
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
+        self.provider()
+            .await?
+            .get_chain_id()
+            .await
+            .map_err(Into::into)
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
+        self.provider()
+            .await?
+            .get_transaction_receipt(*tx_hash)
+            .await?
+            .context("Failed to get the transaction receipt")
+            .map(|receipt| receipt.effective_gas_price)
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .map(|block| block.header.gas_limit as _)
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .map(|block| block.header.beneficiary)
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .and_then(|block| {
+                block
+                    .header
+                    .base_fee_per_gas
+                    .context("Failed to get the base fee per gas")
+            })
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .map(|block| block.header.hash)
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .map(|block| block.header.timestamp)
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
+        self.provider()
+            .await?
+            .get_block_number()
+            .await
+            .map_err(Into::into)
+    }
+}
+
+impl Node for GethNode {
    fn new(config: &Arguments) -> Self {
        let geth_directory = config.directory().join(Self::BASE_DIRECTORY);
        let id = NODE_COUNT.fetch_add(1, Ordering::SeqCst);
        let base_directory = geth_directory.join(id.to_string());

+        let mut wallet = config.wallet();
+        for signer in (1..=config.private_keys_to_add)
+            .map(|id| U256::from(id))
+            .map(|id| id.to_be_bytes::<32>())
+            .map(|id| PrivateKeySigner::from_bytes(&FixedBytes(id)).unwrap())
+        {
+            wallet.register_signer(signer);
+        }
+
        Self {
            connection_string: base_directory.join(Self::IPC_FILE).display().to_string(),
            data_directory: base_directory.join(Self::DATA_DIRECTORY),
@@ -360,20 +519,20 @@ impl Node for Instance {
            handle: None,
            network_id: config.network_id,
            start_timeout: config.geth_start_timeout,
-            wallet: config.wallet(),
-            nonces: Mutex::new(HashMap::new()),
+            wallet,
            // We know that we only need to be storing 2 files so we can specify that when creating
            // the vector. It's the stdout and stderr of the geth node.
            logs_file_to_flush: Vec::with_capacity(2),
+            nonce_manager: Default::default(),
        }
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn connection_string(&self) -> String {
        self.connection_string.clone()
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    fn shutdown(&mut self) -> anyhow::Result<()> {
        // Terminate the processes in a graceful manner to allow for the output to be flushed.
        if let Some(mut child) = self.handle.take() {
@@ -395,13 +554,13 @@ impl Node for Instance {
        Ok(())
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
        self.init(genesis)?.spawn_process()?;
        Ok(())
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
    fn version(&self) -> anyhow::Result<String> {
        let output = Command::new(&self.geth)
            .arg("--version")
@@ -413,10 +572,22 @@ impl Node for Instance {
            .stdout;
        Ok(String::from_utf8_lossy(&output).into())
    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    fn matches_target(&self, targets: Option<&[String]>) -> bool {
+        match targets {
+            None => true,
+            Some(targets) => targets.iter().any(|str| str.as_str() == "evm"),
+        }
+    }
+
+    fn evm_version() -> EVMVersion {
+        EVMVersion::Cancun
+    }
 }

-impl Drop for Instance {
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+impl Drop for GethNode {
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn drop(&mut self) {
        self.shutdown().expect("Failed to shutdown")
    }
@@ -425,11 +596,12 @@ impl Drop for Instance {
 #[cfg(test)]
 mod tests {
    use revive_dt_config::Arguments;
+
    use temp_dir::TempDir;

    use crate::{GENESIS_JSON, Node};

-    use super::Instance;
+    use super::*;

    fn test_config() -> (Arguments, TempDir) {
        let mut config = Arguments::default();
@@ -439,26 +611,125 @@ mod tests {
        (config, temp_dir)
    }

+    fn new_node() -> (GethNode, TempDir) {
+        let (args, temp_dir) = test_config();
+        let mut node = GethNode::new(&args);
+        node.init(GENESIS_JSON.to_owned())
+            .expect("Failed to initialize the node")
+            .spawn_process()
+            .expect("Failed to spawn the node process");
+        (node, temp_dir)
+    }
+
    #[test]
    fn init_works() {
-        Instance::new(&test_config().0)
+        GethNode::new(&test_config().0)
            .init(GENESIS_JSON.to_string())
            .unwrap();
    }

    #[test]
    fn spawn_works() {
-        Instance::new(&test_config().0)
+        GethNode::new(&test_config().0)
            .spawn(GENESIS_JSON.to_string())
            .unwrap();
    }

    #[test]
    fn version_works() {
-        let version = Instance::new(&test_config().0).version().unwrap();
+        let version = GethNode::new(&test_config().0).version().unwrap();
        assert!(
            version.starts_with("geth version"),
            "expected version string, got: '{version}'"
        );
    }
+
+    #[tokio::test]
+    async fn can_get_chain_id_from_node() {
+        // Arrange
+        let (node, _temp_dir) = new_node();
+
+        // Act
+        let chain_id = node.chain_id().await;
+
+        // Assert
+        let chain_id = chain_id.expect("Failed to get the chain id");
+        assert_eq!(chain_id, 420_420_420);
+    }
+
+    #[tokio::test]
+    async fn can_get_gas_limit_from_node() {
+        // Arrange
+        let (node, _temp_dir) = new_node();
+
+        // Act
+        let gas_limit = node.block_gas_limit(BlockNumberOrTag::Latest).await;
+
+        // Assert
+        let gas_limit = gas_limit.expect("Failed to get the gas limit");
+        assert_eq!(gas_limit, u32::MAX as u128)
+    }
+
+    #[tokio::test]
+    async fn can_get_coinbase_from_node() {
+        // Arrange
+        let (node, _temp_dir) = new_node();
+
+        // Act
+        let coinbase = node.block_coinbase(BlockNumberOrTag::Latest).await;
+
+        // Assert
+        let coinbase = coinbase.expect("Failed to get the coinbase");
+        assert_eq!(coinbase, Address::new([0xFF; 20]))
+    }
+
+    #[tokio::test]
+    async fn can_get_block_difficulty_from_node() {
+        // Arrange
+        let (node, _temp_dir) = new_node();
+
+        // Act
+        let block_difficulty = node.block_difficulty(BlockNumberOrTag::Latest).await;
+
+        // Assert
+        let block_difficulty = block_difficulty.expect("Failed to get the block difficulty");
+        assert_eq!(block_difficulty, U256::ZERO)
+    }
+
+    #[tokio::test]
+    async fn can_get_block_hash_from_node() {
+        // Arrange
+        let (node, _temp_dir) = new_node();
+
+        // Act
+        let block_hash = node.block_hash(BlockNumberOrTag::Latest).await;
+
+        // Assert
+        let _ = block_hash.expect("Failed to get the block hash");
+    }
+
+    #[tokio::test]
+    async fn can_get_block_timestamp_from_node() {
+        // Arrange
+        let (node, _temp_dir) = new_node();
+
+        // Act
+        let block_timestamp = node.block_timestamp(BlockNumberOrTag::Latest).await;
+
+        // Assert
+        let _ = block_timestamp.expect("Failed to get the block timestamp");
+    }
+
+    #[tokio::test]
+    async fn can_get_block_number_from_node() {
+        // Arrange
+        let (node, _temp_dir) = new_node();
+
+        // Act
+        let block_number = node.last_block_number().await;
+
+        // Assert
+        let block_number = block_number.expect("Failed to get the block number");
+        assert_eq!(block_number, 0)
+    }
 }
@@ -1,8 +1,11 @@
 //! This crate implements the testing nodes.

+use revive_common::EVMVersion;
 use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;

+pub mod common;
+pub mod constants;
 pub mod geth;
 pub mod kitchensink;
 pub mod pool;
@@ -30,4 +33,11 @@ pub trait Node: EthereumNode {

    /// Returns the node version.
    fn version(&self) -> anyhow::Result<String>;
+
+    /// Given a list of targets from the metadata file, this function determines if the metadata
+    /// file can be ran on this node or not.
+    fn matches_target(&self, targets: Option<&[String]>) -> bool;
+
+    /// Returns the EVM version of the node.
+    fn evm_version() -> EVMVersion;
 }
@@ -1,11 +1,12 @@
 //! This crate implements concurrent handling of testing node.

 use std::{
-    fs::read_to_string,
    sync::atomic::{AtomicUsize, Ordering},
    thread,
 };

+use revive_dt_common::cached_fs::read_to_string;
+
 use anyhow::Context;
 use revive_dt_config::Arguments;

@@ -24,7 +25,7 @@ where
 {
    /// Create a new Pool. This will start as many nodes as there are workers in `config`.
    pub fn new(config: &Arguments) -> anyhow::Result<Self> {
-        let nodes = config.workers;
+        let nodes = config.number_of_nodes;
        let genesis = read_to_string(&config.genesis_file).context(format!(
            "can not read genesis file: {}",
            config.genesis_file.display()
@@ -10,9 +10,9 @@ rust-version.workspace = true
 [dependencies]
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
+revive-dt-compiler = { workspace = true }

 anyhow = { workspace = true }
 tracing = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-revive-solc-json-interface = { workspace = true }
@@ -1,5 +1,6 @@
 //! The report analyzer enriches the raw report data.

+use revive_dt_compiler::CompilerOutput;
 use serde::{Deserialize, Serialize};

 use crate::reporter::CompilationTask;
@@ -13,41 +14,27 @@ pub struct CompilerStatistics {
    pub mean_code_size: usize,
    /// The mean size of the optimized YUL IR.
    pub mean_yul_size: usize,
-    /// Is a proxy because the YUL also containes a lot of comments.
+    /// Is a proxy because the YUL also contains a lot of comments.
    pub yul_to_bytecode_size_ratio: f32,
 }

 impl CompilerStatistics {
    /// Cumulatively update the statistics with the next compiler task.
    pub fn sample(&mut self, compilation_task: &CompilationTask) {
-        let Some(output) = &compilation_task.json_output else {
-            return;
-        };
-
-        let Some(contracts) = &output.contracts else {
+        let Some(CompilerOutput { contracts }) = &compilation_task.json_output else {
            return;
        };

        for (_solidity, contracts) in contracts.iter() {
-            for (_name, contract) in contracts.iter() {
-                let Some(evm) = &contract.evm else {
-                    continue;
-                };
-                let Some(deploy_code) = &evm.deployed_bytecode else {
-                    continue;
-                };
-
+            for (_name, (bytecode, _)) in contracts.iter() {
                // The EVM bytecode can be unlinked and thus is not necessarily a decodable hex
                // string; for our statistics this is a good enough approximation.
-                let bytecode_size = deploy_code.object.len() / 2;
+                let bytecode_size = bytecode.len() / 2;

-                let yul_size = contract
-                    .ir_optimized
-                    .as_ref()
-                    .expect("if the contract has a deploy code it should also have the opimized IR")
-                    .len();
+                // TODO: for the time being we set the yul_size to be zero. We need to change this
+                // when we overhaul the reporting.

-                self.update_sizes(bytecode_size, yul_size);
+                self.update_sizes(bytecode_size, 0);
            }
        }
    }
@@ -12,11 +12,11 @@ use std::{
 };

 use anyhow::Context;
+use revive_dt_compiler::{CompilerInput, CompilerOutput};
 use serde::{Deserialize, Serialize};

 use revive_dt_config::{Arguments, TestingPlatform};
 use revive_dt_format::{corpus::Corpus, mode::SolcMode};
-use revive_solc_json_interface::{SolcStandardJsonInput, SolcStandardJsonOutput};

 use crate::analyzer::CompilerStatistics;

@@ -44,9 +44,9 @@ pub struct Report {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CompilationTask {
    /// The observed compiler input.
-    pub json_input: SolcStandardJsonInput,
+    pub json_input: CompilerInput,
    /// The observed compiler output.
-    pub json_output: Option<SolcStandardJsonOutput>,
+    pub json_output: Option<CompilerOutput>,
    /// The observed compiler mode.
    pub mode: SolcMode,
    /// The observed compiler version.
@@ -152,15 +152,7 @@ impl Report {
        for (platform, results) in self.compiler_results.iter() {
            for result in results {
                // ignore if there were no errors
-                if result.compilation_task.error.is_none()
-                    && result
-                        .compilation_task
-                        .json_output
-                        .as_ref()
-                        .and_then(|output| output.errors.as_ref())
-                        .map(|errors| errors.is_empty())
-                        .unwrap_or(true)
-                {
+                if result.compilation_task.error.is_none() {
                    continue;
                }

@@ -9,9 +9,12 @@ repository.workspace = true
 rust-version.workspace = true

 [dependencies]
+revive-dt-common = { workspace = true }
+
 anyhow = { workspace = true }
 hex = { workspace = true }
 tracing = { workspace = true }
+tokio = { workspace = true }
 reqwest = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
@@ -6,37 +6,39 @@ use std::{
    io::{BufWriter, Write},
    os::unix::fs::PermissionsExt,
    path::{Path, PathBuf},
-    sync::{LazyLock, Mutex},
+    sync::LazyLock,
 };

-use crate::download::GHDownloader;
+use tokio::sync::Mutex;
+
+use crate::download::SolcDownloader;

 pub const SOLC_CACHE_DIRECTORY: &str = "solc";
 pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);

-pub(crate) fn get_or_download(
+pub(crate) async fn get_or_download(
    working_directory: &Path,
-    downloader: &GHDownloader,
+    downloader: &SolcDownloader,
 ) -> anyhow::Result<PathBuf> {
    let target_directory = working_directory
        .join(SOLC_CACHE_DIRECTORY)
        .join(downloader.version.to_string());
    let target_file = target_directory.join(downloader.target);

-    let mut cache = SOLC_CACHER.lock().unwrap();
+    let mut cache = SOLC_CACHER.lock().await;
    if cache.contains(&target_file) {
        tracing::debug!("using cached solc: {}", target_file.display());
        return Ok(target_file);
    }

    create_dir_all(target_directory)?;
-    download_to_file(&target_file, downloader)?;
+    download_to_file(&target_file, downloader).await?;
    cache.insert(target_file.clone());

    Ok(target_file)
 }

-fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()> {
+async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::Result<()> {
    tracing::info!("caching file: {}", path.display());

    let Ok(file) = File::create_new(path) else {
@@ -52,7 +54,7 @@ fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()
    }

    let mut file = BufWriter::new(file);
-    file.write_all(&downloader.download()?)?;
+    file.write_all(&downloader.download().await?)?;
    file.flush()?;
    drop(file);

@@ -5,6 +5,8 @@ use std::{
    sync::{LazyLock, Mutex},
 };

+use revive_dt_common::types::VersionOrRequirement;
+
 use semver::Version;
 use sha2::{Digest, Sha256};

@@ -23,12 +25,12 @@ impl List {
    ///
    /// Caches the list retrieved from the `url` into [LIST_CACHE],
    /// subsequent calls with the same `url` will return the cached list.
-    pub fn download(url: &'static str) -> anyhow::Result<Self> {
+    pub async fn download(url: &'static str) -> anyhow::Result<Self> {
        if let Some(list) = LIST_CACHE.lock().unwrap().get(url) {
            return Ok(list.clone());
        }

-        let body: List = reqwest::blocking::get(url)?.json()?;
+        let body: List = reqwest::get(url).await?.json().await?;

        LIST_CACHE.lock().unwrap().insert(url, body.clone());

@@ -36,65 +38,91 @@ impl List {
    }
 }

-/// Download solc binaries from GitHub releases (IPFS links aren't reliable).
+/// Download solc binaries from the official SolidityLang site
 #[derive(Clone, Debug)]
-pub struct GHDownloader {
+pub struct SolcDownloader {
    pub version: Version,
    pub target: &'static str,
    pub list: &'static str,
 }

-impl GHDownloader {
-    pub const BASE_URL: &str = "https://github.com/ethereum/solidity/releases/download";
+impl SolcDownloader {
+    pub const BASE_URL: &str = "https://binaries.soliditylang.org";

-    pub const LINUX_NAME: &str = "solc-static-linux";
-    pub const MACOSX_NAME: &str = "solc-macos";
-    pub const WINDOWS_NAME: &str = "solc-windows.exe";
-    pub const WASM_NAME: &str = "soljson.js";
+    pub const LINUX_NAME: &str = "linux-amd64";
+    pub const MACOSX_NAME: &str = "macosx-amd64";
+    pub const WINDOWS_NAME: &str = "windows-amd64";
+    pub const WASM_NAME: &str = "wasm";

-    fn new(version: Version, target: &'static str, list: &'static str) -> Self {
-        Self {
-            version,
-            target,
-            list,
+    async fn new(
+        version: impl Into<VersionOrRequirement>,
+        target: &'static str,
+        list: &'static str,
+    ) -> anyhow::Result<Self> {
+        let version_or_requirement = version.into();
+        match version_or_requirement {
+            VersionOrRequirement::Version(version) => Ok(Self {
+                version,
+                target,
+                list,
+            }),
+            VersionOrRequirement::Requirement(requirement) => {
+                let Some(version) = List::download(list)
+                    .await?
+                    .builds
+                    .into_iter()
+                    .map(|build| build.version)
+                    .filter(|version| requirement.matches(version))
+                    .max()
+                else {
+                    anyhow::bail!("Failed to find a version that satisfies {requirement:?}");
+                };
+                Ok(Self {
+                    version,
+                    target,
+                    list,
+                })
+            }
        }
    }

-    pub fn linux(version: Version) -> Self {
-        Self::new(version, Self::LINUX_NAME, List::LINUX_URL)
+    pub async fn linux(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::LINUX_NAME, List::LINUX_URL).await
    }

-    pub fn macosx(version: Version) -> Self {
-        Self::new(version, Self::MACOSX_NAME, List::MACOSX_URL)
+    pub async fn macosx(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::MACOSX_NAME, List::MACOSX_URL).await
    }

-    pub fn windows(version: Version) -> Self {
-        Self::new(version, Self::WINDOWS_NAME, List::WINDOWS_URL)
+    pub async fn windows(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::WINDOWS_NAME, List::WINDOWS_URL).await
    }

-    pub fn wasm(version: Version) -> Self {
-        Self::new(version, Self::WASM_NAME, List::WASM_URL)
-    }
-
-    /// Returns the download link.
-    pub fn url(&self) -> String {
-        format!("{}/v{}/{}", Self::BASE_URL, &self.version, &self.target)
+    pub async fn wasm(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
+        Self::new(version, Self::WASM_NAME, List::WASM_URL).await
    }

    /// Download the solc binary.
    ///
    /// Errors out if the download fails or the digest of the downloaded file
    /// mismatches the expected digest from the release [List].
-    pub fn download(&self) -> anyhow::Result<Vec<u8>> {
+    pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
        tracing::info!("downloading solc: {self:?}");
-        let expected_digest = List::download(self.list)?
-            .builds
+        let builds = List::download(self.list).await?.builds;
+        let build = builds
            .iter()
            .find(|build| build.version == self.version)
-            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))
-            .map(|b| b.sha256.strip_prefix("0x").unwrap_or(&b.sha256).to_string())?;
+            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))?;

-        let file = reqwest::blocking::get(self.url())?.bytes()?.to_vec();
+        let path = build.path.clone();
+        let expected_digest = build
+            .sha256
+            .strip_prefix("0x")
+            .unwrap_or(&build.sha256)
+            .to_string();
+        let url = format!("{}/{}/{}", Self::BASE_URL, self.target, path.display());
+
+        let file = reqwest::get(url).await?.bytes().await?.to_vec();

        if hex::encode(Sha256::digest(&file)) != expected_digest {
            anyhow::bail!("sha256 mismatch for solc version {}", self.version);
@@ -106,41 +134,58 @@ impl GHDownloader {

 #[cfg(test)]
 mod tests {
-    use crate::{download::GHDownloader, list::List};
+    use crate::{download::SolcDownloader, list::List};

-    #[test]
-    fn try_get_windows() {
+    #[tokio::test]
+    async fn try_get_windows() {
        let version = List::download(List::WINDOWS_URL)
+            .await
            .unwrap()
-            .latest_release
-            .into();
-        GHDownloader::windows(version).download().unwrap();
+            .latest_release;
+        SolcDownloader::windows(version)
+            .await
+            .unwrap()
+            .download()
+            .await
+            .unwrap();
    }

-    #[test]
-    fn try_get_macosx() {
+    #[tokio::test]
+    async fn try_get_macosx() {
        let version = List::download(List::MACOSX_URL)
+            .await
            .unwrap()
-            .latest_release
-            .into();
-        GHDownloader::macosx(version).download().unwrap();
+            .latest_release;
+        SolcDownloader::macosx(version)
+            .await
+            .unwrap()
+            .download()
+            .await
+            .unwrap();
    }

-    #[test]
-    fn try_get_linux() {
+    #[tokio::test]
+    async fn try_get_linux() {
        let version = List::download(List::LINUX_URL)
+            .await
            .unwrap()
-            .latest_release
-            .into();
-        GHDownloader::linux(version).download().unwrap();
+            .latest_release;
+        SolcDownloader::linux(version)
+            .await
+            .unwrap()
+            .download()
+            .await
+            .unwrap();
    }

-    #[test]
-    fn try_get_wasm() {
-        let version = List::download(List::WASM_URL)
+    #[tokio::test]
+    async fn try_get_wasm() {
+        let version = List::download(List::WASM_URL).await.unwrap().latest_release;
+        SolcDownloader::wasm(version)
+            .await
            .unwrap()
-            .latest_release
-            .into();
-        GHDownloader::wasm(version).download().unwrap();
+            .download()
+            .await
+            .unwrap();
    }
 }
@@ -6,8 +6,9 @@
 use std::path::{Path, PathBuf};

 use cache::get_or_download;
-use download::GHDownloader;
-use semver::Version;
+use download::SolcDownloader;
+
+use revive_dt_common::types::VersionOrRequirement;

 pub mod cache;
 pub mod download;
@@ -18,22 +19,22 @@ pub mod list;
 ///
 /// Subsequent calls for the same version will use a cached artifact
 /// and not download it again.
-pub fn download_solc(
+pub async fn download_solc(
    cache_directory: &Path,
-    version: Version,
+    version: impl Into<VersionOrRequirement>,
    wasm: bool,
 ) -> anyhow::Result<PathBuf> {
    let downloader = if wasm {
-        GHDownloader::wasm(version)
+        SolcDownloader::wasm(version).await
    } else if cfg!(target_os = "linux") {
-        GHDownloader::linux(version)
+        SolcDownloader::linux(version).await
    } else if cfg!(target_os = "macos") {
-        GHDownloader::macosx(version)
+        SolcDownloader::macosx(version).await
    } else if cfg!(target_os = "windows") {
-        GHDownloader::windows(version)
+        SolcDownloader::windows(version).await
    } else {
        unimplemented!()
-    };
+    }?;

-    get_or_download(cache_directory, &downloader)
+    get_or_download(cache_directory, &downloader).await
 }
@@ -33,9 +33,5 @@
    "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "timestamp": "0x00",
-    "alloc": {
-        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
-            "balance": "1000000000000000000"
-        }
-    }
+    "alloc": {}
 }
Author	SHA1	Message	Date
Omar Abdulla	7247eca2e8	Add a cached fs abstraction	2025-08-14 17:38:12 +03:00
Omar	f2045db0e9	Add compiler directives to metadata (#139 )	2025-08-14 07:38:56 +00:00
Omar	5a11f44673	Misc features/improvements (#138 ) * Implement various needed features and improvements * Reorder the metadata struct * Format comments	2025-08-13 13:50:06 +00:00
James Wilson	46aea0890d	Split reporter and case runner, use channels to pass test reports (#137 ) * Use channels to send data to reporting thread and avoid hangs / mutex / duration. Limit max concurrent tasks to avoid too many open files * More appropriate name for dirver/reporter task fns * Back to parallelise individual cases, report individual cases, address grumbles * newline before 'Failures' title in report	2025-08-13 13:10:26 +00:00
Omar	9b40c9b9e3	Add an EVM version filter (#136 ) * Add an EVM version filter * Update naming	2025-08-12 10:19:59 +00:00
Omar	f67a9bf643	Refactor/ignore null values (#135 ) * Skip serialization of null values * Add support for comments in various steps	2025-08-12 08:55:21 +00:00
Omar	67d767ffde	Implement storage empty assertion (#134 )	2025-08-11 13:17:19 +00:00
Omar	f7fbe094ec	Balance assertions (#133 ) * Make metadata serializable * Refactor tests to use steps * Add a balance assertion test step * Test balance deserialization * Box the test steps * Permit size difference in step output	2025-08-11 12:11:16 +00:00
Omar	90b2dd4cfe	Make metadata serializable (#132 )	2025-08-10 21:57:41 +00:00
Omar	64d63ef999	Remove the provider cache (#121 ) * Remove the provider cache * Add timing information to the CLI report	2025-08-07 03:55:24 +00:00
Omar	757bfbe116	Add more resolvable variables (#120 ) * Allow resolution of base fee * Fix block difficulty resolution * Allow for the resolution of gas price	2025-08-06 15:17:36 +00:00
Omar	8619e7feb0	Fix the transaction tracing issues (#118 ) * Set the gc mode to archive in geth * Add a maximum to the exponential backoff wait duration * Edit the formatting of the CLI case reporter	2025-08-06 12:25:39 +00:00
Omar	edba49b301	Use SolidityLang for solc downloads (#117 )	2025-08-06 10:35:05 +00:00
Omar	9980926d40	Add a case ignore flag (#114 ) * Added a resolver tied to a specific block * Increase the number of private keys * Increase kitchensink wait time to 60 seconds * Add a case ignore flag	2025-08-04 16:40:53 +00:00
Omar	ff993d44a5	Added a resolver tied to a specific block (#111 ) * Added a resolver tied to a specific block * Increase the number of private keys * Increase kitchensink wait time to 60 seconds	2025-08-04 12:45:47 +00:00
Omar	8cbb1a9f77	Added basic console reporting (#110 ) * Added basic console reporting * Add some waiting period to the printing task * Print to the stderr and print logs to stdout	2025-08-04 06:05:49 +00:00
Omar	56c2fe8c0c	Parallelize Cases (#109 ) * Parallelize over cases * Rename the state and driver * Parallelize execution * Update the default config of the tool * Make codebase async * Fix machete * Fix tests & clear node directories before startup * Cleanup the cleanup logic * Rename geth node	2025-08-01 11:00:08 +00:00
Omar	330a773a1c	Add variables support (#96 )	2025-07-30 08:41:03 +00:00
Omar	f51693cb9f	Support multiple compiler versions (#92 ) * Allow for downloader to use version requirements. We will soon add support for the compiler version requirement from the metadata files to be honored. The compiler version is specified in the solc modes section of the file and its specified as a `VersionReq` and not as a version. Therefore, we need to have the ability to honor this version requirement and find the best version that satisfies the requirement. * Request `VersionOrRequirement` in compiler interface * Honor the compiler version requirement in metadata This commit honors the compiler version requirement listed in the solc modes of the metadata file. If this version requirement is provided then it overrides what was passed in the CLI. Otherwise, the CLI version will be used. * Make compiler IO completely generic. Before this commit, the types that were used for the compiler input and output were the resolc compiler types which was a leaky abstraction as we have traits to abstract the compilers away but we expose their internal types out to other crates. This commit did the following: 1. Made the compiler IO types fully generic so that all of the logic for constructing the map of compiled contracts is all done by the compiler implementation and not by the consuming code. 2. Changed the input types used for Solc to be the forge standard JSON types for Solc instead of resolc. * Fix machete * Add resolc to CI * Add resolc to CI * Add resolc to CI * Add resolc to CI	2025-07-30 04:56:23 +00:00
James Wilson	4db7009640	Ensure path in corpus is relative to corpus file (#85 )	2025-07-29 13:12:16 +00:00
Omar	5a36e242ec	Allow for files in corpus definitions (#87 ) * Allow for files to be specified in the corpus file * Attempt to improve the geth tx indexing issue. We're facing an issue where Geth transaction indexing can sometimes stall on some of the nodes we're running. The logs show that for all transactions we always need 1 second of waiting time. However, during certain runs we sometimes run into an issue with some of the nodes where it seems like their transaction indexer fails (either at the start or after some amount of time) which leads us to never get the receipts back from these specific nodes. This is not a load issue as it appears like all of the other nodes handle it just fine. However, it looks like once a node gets into this state it can not get out of it and its bricked for the entire run. This commit adds some more command line arguments to the geth command in hopes of improving this issue.	2025-07-29 13:02:53 +00:00
James Wilson	33329632b5	Increase geth instantiate timeout from 2s to 5s (#86 )	2025-07-29 10:34:31 +00:00
Omar	429f2e92a2	Fix contract discovery for simple tests (#83 )	2025-07-28 07:05:53 +00:00
Omar	65f41f2038	Correct the type of address in matterlabs events (#82 )	2025-07-28 05:01:52 +00:00
Omar	3ed8a1ca1c	Support compiler-version aware exceptions (#81 )	2025-07-25 14:23:17 +00:00
Omar	2923d675cd	Support Compile-time Linking (#79 ) * Use wrappers for libraries in metadata. * Create a unified way to access deployed contracts * Support linking at compile time	2025-07-25 07:03:21 +00:00
Omar	8f5bcf08ad	Support `Calldata` arithmetic (#77 ) * Re-order the input file. This commit reorders the input file such that we have a definitions section and an implementations section and such that the the order of the items in both sections is the same. * Implement a reverse polish calculator for calldata arithmetic	2025-07-24 15:35:25 +00:00
Omar	90fb89adc0	Add a `common` crate (#75 ) * Add a barebones common crate * Refactor some code into the common crate * Add a `ResolverApi` interface. This commit adds a `ResolverApi` trait to the `format` crate that can be implemented by any type that can act as a resolver. A resolver is able to provide information on the chain state. This chain state could be fresh or it could be cached (which is something that we will do in a future PR). This cleans up our crate graph so that `format` is not depending on the node interactions crate for the `EthereumNode` trait. * Cleanup the blocking executor	2025-07-24 12:42:45 +00:00
Omar	b03ad3027e	Pre-seed accounts with more ETH. (#73 ) * Pre-seed accounts with more ETH. This commit fixes and solves some issues around how much ETH we seed an account with in genesis. Currently, any account that the node has keys to sign for will be seeded with u128::MAX WEI in genesis. This also includes the default signer account. * Bump commit hash of polkadot SDK * Change how the cache key is computed * Revert "Change how the cache key is computed" This reverts commit `75afdd9cfd`. * Revert "Bump commit hash of polkadot SDK" This reverts commit `8aaa69780e`. * Add extra comments * Revert "Add extra comments" This reverts commit `bd4de2c83d`. * Update the initial balance	2025-07-24 08:46:14 +00:00
Omar	972f3b6d5b	Wait longer for geth receipts (#74 )	2025-07-24 04:40:19 +00:00
Omar	6f4aa731ab	Handle exceptions (#54 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order * Handle calldata better * Allow for the use of function signatures * Add support for exceptions * Cached nonce allocator * Fix tests * Add support for address replacement * Cleanup implementation * Cleanup mutability * Wire up address replacement with rest of code * Implement caller replacement * Switch to callframe trace for exceptions * Add a way to skip tests if they don't match the target * Handle values from the metadata files * Remove address replacement * Correct the arguments * Remove empty impl * Remove address replacement * Correct the arguments * Remove empty impl * Fix size_requirement underflow * Add support for wildcards in exceptions * Fix calldata construction of single calldata * Better handling for length in equivalency checks * Make initial balance a constant * Fix size_requirement underflow * Add support for wildcards in exceptions * Fix calldata construction of single calldata * Better handling for length in equivalency checks * Fix tests	2025-07-24 03:45:53 +00:00
Omar	589a5dc988	Handle calldata better (#49 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order * Handle calldata better * Remove todo	2025-07-22 03:39:35 +00:00
Omar	c6d55515be	Allow for the use of function signatures (#50 ) * Allow for the use of function signatures * Add test	2025-07-21 10:43:17 +00:00
Omar	a9970eb2bb	Refactor the input handling logic (#48 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order	2025-07-21 09:01:52 +00:00
Omar	2259942363	Cleanup execution logic (#45 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning * Fix the ABI finding logic * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Implement ABI fix in the compiler trait impl * Update the async runtime with syntactic sugar. * Fix tests * Fix doc test * Give nodes a standard way to get their alloy provider * Add ability to get the chain_id from node * Get kitchensink provider to use kitchensink network * Use provider method in tests * Add support for getting the gas limit from the node * Add a way to get the coinbase address * Add a way to get the block difficulty from the node * Add a way to get block info from the node * Expose APIs for getting the info of a specific block * Add resolution logic for other matterlabs variables * Fix tests * Add comment on alternative solutions * Change kitchensink gas limit assertion * Cleanup execution logic	2025-07-18 12:08:13 +00:00
Omar	0b97d7dc29	Support other matterlabs variables (#43 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Update the async runtime with syntactic sugar. * Fix tests * Fix doc test * Give nodes a standard way to get their alloy provider * Add ability to get the chain_id from node * Get kitchensink provider to use kitchensink network * Use provider method in tests * Add support for getting the gas limit from the node * Add a way to get the coinbase address * Add a way to get the block difficulty from the node * Add a way to get block info from the node * Expose APIs for getting the info of a specific block * Add resolution logic for other matterlabs variables * Fix tests * Add comment on alternative solutions * Change kitchensink gas limit assertion * Remove un-needed profile config	2025-07-18 12:06:40 +00:00
Omar	2bee2d5c8b	Fix the ABI finding logic (#38 ) * Fix the ABI finding logic * Implement ABI fix in the compiler trait impl	2025-07-18 11:22:51 +00:00
Omar	854e8d9690	Fix `deserialization error: invalid value: string "0x2d79dd80ff729c000"` (#34 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning	2025-07-18 11:22:13 +00:00
Omar	2d517784dd	Better logging for contract deployment (#46 ) * Log certain errors better * Remove unneeded code	2025-07-16 18:16:12 +00:00