Lower gas limit for failed estimates

.gitignore

@@ -6,8 +6,4 @@ node_modules
 
 # We do not want to commit any log files that we produce from running the code locally so this is 
 # added to the .gitignore file.
-*.log
-
-profile.json.gz
-resolc-compiler-tests
-workdir
+*.log

Cargo.lock

@@ -659,7 +659,7 @@ checksum = "4f317d20f047b3de4d9728c556e2e9a92c9a507702d2016424cd8be13a74ca5e"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
- "base64 0.22.1",
+ "base64",
  "derive_more 2.0.1",
  "futures",
  "futures-utils-wasm",
@@ -1189,151 +1189,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "async-channel"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35"
-dependencies = [
- "concurrent-queue",
- "event-listener 2.5.3",
- "futures-core",
-]
-
-[[package]]
-name = "async-channel"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
-dependencies = [
- "concurrent-queue",
- "event-listener-strategy",
- "futures-core",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-executor"
-version = "1.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb812ffb58524bdd10860d7d974e2f01cc0950c2438a74ee5ec2e2280c6c4ffa"
-dependencies = [
- "async-task",
- "concurrent-queue",
- "fastrand",
- "futures-lite",
- "pin-project-lite",
- "slab",
-]
-
-[[package]]
-name = "async-global-executor"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c"
-dependencies = [
- "async-channel 2.5.0",
- "async-executor",
- "async-io",
- "async-lock",
- "blocking",
- "futures-lite",
- "once_cell",
-]
-
-[[package]]
-name = "async-io"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1237c0ae75a0f3765f58910ff9cdd0a12eeb39ab2f4c7de23262f337f0aacbb3"
-dependencies = [
- "async-lock",
- "cfg-if",
- "concurrent-queue",
- "futures-io",
- "futures-lite",
- "parking",
- "polling",
- "rustix",
- "slab",
- "tracing",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "async-lock"
-version = "3.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
-dependencies = [
- "event-listener 5.4.1",
- "event-listener-strategy",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-process"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65daa13722ad51e6ab1a1b9c01299142bc75135b337923cfa10e79bbbd669f00"
-dependencies = [
- "async-channel 2.5.0",
- "async-io",
- "async-lock",
- "async-signal",
- "async-task",
- "blocking",
- "cfg-if",
- "event-listener 5.4.1",
- "futures-lite",
- "rustix",
-]
-
-[[package]]
-name = "async-signal"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7605a4e50d4b06df3898d5a70bf5fde51ed9059b0434b73105193bc27acce0d"
-dependencies = [
- "async-io",
- "async-lock",
- "atomic-waker",
- "cfg-if",
- "futures-core",
- "futures-io",
- "rustix",
- "signal-hook-registry",
- "slab",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "async-std"
-version = "1.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c8e079a4ab67ae52b7403632e4618815d6db36d2a010cfe41b02c1b1578f93b"
-dependencies = [
- "async-channel 1.9.0",
- "async-global-executor",
- "async-io",
- "async-lock",
- "async-process",
- "crossbeam-utils",
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-lite",
- "gloo-timers",
- "kv-log-macro",
- "log",
- "memchr",
- "once_cell",
- "pin-project-lite",
- "pin-utils",
- "slab",
- "wasm-bindgen-futures",
-]
-
 [[package]]
 name = "async-stream"
 version = "0.3.6"
@@ -1356,12 +1211,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "async-task"
-version = "4.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
-
 [[package]]
 name = "async-trait"
 version = "0.1.88"
@@ -1417,12 +1266,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
-[[package]]
-name = "base64"
-version = "0.21.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
-
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -1561,19 +1404,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "blocking"
-version = "1.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
-dependencies = [
- "async-channel 2.5.0",
- "async-task",
- "futures-io",
- "futures-lite",
- "piper",
-]
-
 [[package]]
 name = "blst"
 version = "0.3.14"
@@ -1607,29 +1437,6 @@ dependencies = [
  "tinyvec",
 ]
 
-[[package]]
-name = "bson"
-version = "2.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969a9ba84b0ff843813e7249eed1678d9b6607ce5a3b8f0a47af3fcf7978e6e"
-dependencies = [
- "ahash",
- "base64 0.22.1",
- "bitvec",
- "getrandom 0.2.16",
- "getrandom 0.3.3",
- "hex",
- "indexmap 2.10.0",
- "js-sys",
- "once_cell",
- "rand 0.9.2",
- "serde",
- "serde_bytes",
- "serde_json",
- "time",
- "uuid",
-]
-
 [[package]]
 name = "bumpalo"
 version = "3.17.0"
@@ -1672,32 +1479,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "cacache"
-version = "13.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5063741c7b2e260bbede781cf4679632dd90e2718e99f7715e46824b65670b"
-dependencies = [
- "async-std",
- "digest 0.10.7",
- "either",
- "futures",
- "hex",
- "libc",
- "memmap2",
- "miette",
- "reflink-copy",
- "serde",
- "serde_derive",
- "serde_json",
- "sha1",
- "sha2 0.10.9",
- "ssri",
- "tempfile",
- "thiserror 1.0.69",
- "walkdir",
-]
-
 [[package]]
 name = "cc"
 version = "1.2.25"
@@ -1778,15 +1559,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2382f75942f4b3be3690fe4f86365e9c853c1587d6ee58212cebf6e2a9ccd101"
 
-[[package]]
-name = "concurrent-queue"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
-dependencies = [
- "crossbeam-utils",
-]
-
 [[package]]
 name = "const-hex"
 version = "1.14.1"
@@ -2348,33 +2120,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "event-listener"
-version = "2.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
-
-[[package]]
-name = "event-listener"
-version = "5.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
-dependencies = [
- "concurrent-queue",
- "parking",
- "pin-project-lite",
-]
-
-[[package]]
-name = "event-listener-strategy"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
-dependencies = [
- "event-listener 5.4.1",
- "pin-project-lite",
-]
-
 [[package]]
 name = "expander"
 version = "2.2.1"
@@ -2616,19 +2361,6 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
-[[package]]
-name = "futures-lite"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
-dependencies = [
- "fastrand",
- "futures-core",
- "futures-io",
- "parking",
- "pin-project-lite",
-]
-
 [[package]]
 name = "futures-macro"
 version = "0.3.31"
@@ -2708,10 +2440,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -2721,11 +2451,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "r-efi",
  "wasi 0.14.2+wasi-0.2.4",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -2750,18 +2478,6 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
-[[package]]
-name = "gloo-timers"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994"
-dependencies = [
- "futures-channel",
- "futures-core",
- "js-sys",
- "wasm-bindgen",
-]
-
 [[package]]
 name = "group"
 version = "0.13.0"
@@ -2856,12 +2572,6 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
-[[package]]
-name = "hermit-abi"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
-
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -3014,7 +2724,7 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1c293b6b3d21eca78250dc7dbebd6b9210ec5530e038cbfe0661b5c47ab06e8"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "bytes",
  "futures-channel",
  "futures-core",
@@ -3384,15 +3094,6 @@ dependencies = [
  "sha3-asm",
 ]
 
-[[package]]
-name = "kv-log-macro"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f"
-dependencies = [
- "log",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -3418,7 +3119,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e79019718125edc905a079a70cfa5f3820bc76139fc91d6f9abc27ea2a887139"
 dependencies = [
  "arrayref",
- "base64 0.22.1",
+ "base64",
  "digest 0.9.0",
  "hmac-drbg",
  "libsecp256k1-core",
@@ -3486,9 +3187,6 @@ name = "log"
 version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
-dependencies = [
- "value-bag",
-]
 
 [[package]]
 name = "loom"
@@ -3538,15 +3236,6 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
-[[package]]
-name = "memmap2"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "memory-db"
 version = "0.32.0"
@@ -3568,29 +3257,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "miette"
-version = "5.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59bb584eaeeab6bd0226ccf3509a69d7936d148cf3d036ad350abe35e8c6856e"
-dependencies = [
- "miette-derive",
- "once_cell",
- "thiserror 1.0.69",
- "unicode-width",
-]
-
-[[package]]
-name = "miette-derive"
-version = "5.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49e7bc1560b95a3c4a25d03de42fe76ca718ab92d1a22a55b9b4cf67b3ae635c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.101",
-]
-
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -3720,7 +3386,7 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi 0.3.9",
+ "hermit-abi",
  "libc",
 ]
 
@@ -3877,12 +3543,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "parking"
-version = "2.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
-
 [[package]]
 name = "parking_lot"
 version = "0.12.4"
@@ -3988,17 +3648,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
-[[package]]
-name = "piper"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
-dependencies = [
- "atomic-waker",
- "fastrand",
- "futures-io",
-]
-
 [[package]]
 name = "pkcs8"
 version = "0.10.2"
@@ -4052,21 +3701,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "polling"
-version = "3.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b53a684391ad002dd6a596ceb6c74fd004fdce75f4be2e3f615068abbea5fd50"
-dependencies = [
- "cfg-if",
- "concurrent-queue",
- "hermit-abi 0.5.2",
- "pin-project-lite",
- "rustix",
- "tracing",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"
@@ -4354,18 +3988,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "reflink-copy"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78c81d000a2c524133cc00d2f92f019d399e57906c3b7119271a2495354fe895"
-dependencies = [
- "cfg-if",
- "libc",
- "rustix",
- "windows",
-]
-
 [[package]]
 name = "regex"
 version = "1.11.1"
@@ -4416,7 +4038,7 @@ version = "0.12.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e98ff6b0dbbe4d5a37318f433d4fc82babd21631f194d370409ceb2e40b2f0b5"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "bytes",
  "encoding_rs",
  "futures-core",
@@ -4471,7 +4093,6 @@ dependencies = [
  "moka",
  "once_cell",
  "semver 1.0.26",
- "serde",
  "tokio",
 ]
 
@@ -4482,7 +4103,6 @@ dependencies = [
  "alloy",
  "alloy-primitives",
  "anyhow",
- "dashmap",
  "foundry-compilers-artifacts",
  "revive-common",
  "revive-dt-common",
@@ -4513,8 +4133,6 @@ version = "0.1.0"
 dependencies = [
  "alloy",
  "anyhow",
- "bson",
- "cacache",
  "clap",
  "futures",
  "indexmap 2.10.0",
@@ -4526,12 +4144,10 @@ dependencies = [
  "revive-dt-node-interaction",
  "revive-dt-report",
  "semver 1.0.26",
- "serde",
  "serde_json",
  "temp-dir",
  "tokio",
  "tracing",
- "tracing-appender",
  "tracing-subscriber",
 ]
 
@@ -4543,8 +4159,6 @@ dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
  "anyhow",
- "futures",
- "regex",
  "revive-common",
  "revive-dt-common",
  "semver 1.0.26",
@@ -4586,19 +4200,12 @@ dependencies = [
 name = "revive-dt-report"
 version = "0.1.0"
 dependencies = [
- "alloy-primitives",
  "anyhow",
- "indexmap 2.10.0",
- "paste",
- "revive-dt-common",
  "revive-dt-compiler",
  "revive-dt-config",
  "revive-dt-format",
- "semver 1.0.26",
  "serde",
  "serde_json",
- "serde_with",
- "tokio",
  "tracing",
 ]
 
@@ -4850,30 +4457,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "schemars"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
-dependencies = [
- "dyn-clone",
- "ref-cast",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "schemars"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
-dependencies = [
- "dyn-clone",
- "ref-cast",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "schnellru"
 version = "0.2.4"
@@ -5064,7 +4647,6 @@ version = "1.0.140"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
 dependencies = [
- "indexmap 2.10.0",
  "itoa",
  "memchr",
  "ryu",
@@ -5104,17 +4686,15 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.14.0"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2c45cd61fefa9db6f254525d46e392b852e0e61d9a1fd36e5bd183450a556d5"
+checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "chrono",
  "hex",
  "indexmap 1.9.3",
  "indexmap 2.10.0",
- "schemars 0.9.0",
- "schemars 1.0.4",
  "serde",
  "serde_derive",
  "serde_json",
@@ -5124,9 +4704,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.14.0"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de90945e6565ce0d9a25098082ed4ee4002e047cb59892c318d66821e14bb30f"
+checksum = "8d00caa5193a3c8362ac2b73be6b9e768aa5a4b2f721d8f4b339600c3cb51f8e"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -5144,28 +4724,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "sha-1"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5058ada175748e33390e40e872bd0fe59a19f265d0158daa551c5a88a76009c"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest 0.10.7",
-]
-
-[[package]]
-name = "sha1"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest 0.10.7",
-]
-
 [[package]]
 name = "sha2"
 version = "0.9.9"
@@ -5640,23 +5198,6 @@ dependencies = [
  "unicode-xid",
 ]
 
-[[package]]
-name = "ssri"
-version = "9.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da7a2b3c2bc9693bcb40870c4e9b5bf0d79f9cb46273321bf855ec513e919082"
-dependencies = [
- "base64 0.21.7",
- "digest 0.10.7",
- "hex",
- "miette",
- "serde",
- "sha-1",
- "sha2 0.10.9",
- "thiserror 1.0.69",
- "xxhash-rust",
-]
-
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@@ -6141,18 +5682,6 @@ dependencies = [
  "tracing-core",
 ]
 
-[[package]]
-name = "tracing-appender"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3566e8ce28cc0a3fe42519fc80e6b4c943cc4c8cef275620eb8dac2d3d4e06cf"
-dependencies = [
- "crossbeam-channel",
- "thiserror 1.0.69",
- "time",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "tracing-attributes"
 version = "0.1.28"
@@ -6319,12 +5848,6 @@ dependencies = [
  "tinyvec",
 ]
 
-[[package]]
-name = "unicode-width"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
-
 [[package]]
 name = "unicode-xid"
 version = "0.2.6"
@@ -6368,7 +5891,6 @@ checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
 dependencies = [
  "getrandom 0.3.3",
  "js-sys",
- "serde",
  "wasm-bindgen",
 ]
 
@@ -6378,12 +5900,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
-[[package]]
-name = "value-bag"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "943ce29a8a743eb10d6082545d861b24f9d1b160b7d741e0f2cdf726bec909c5"
-
 [[package]]
 name = "vcpkg"
 version = "0.2.15"
@@ -6949,12 +6465,6 @@ dependencies = [
  "tap",
 ]
 
-[[package]]
-name = "xxhash-rust"
-version = "0.8.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3"
-
 [[package]]
 name = "yansi"
 version = "1.0.1"

Cargo.toml

@@ -25,16 +25,11 @@ revive-dt-solc-binaries = { version = "0.1.0", path = "crates/solc-binaries" }
 alloy-primitives = "1.2.1"
 alloy-sol-types = "1.2.1"
 anyhow = "1.0"
-bson = { version = "2.15.0" }
-cacache = { version = "13.1.0" }
 clap = { version = "4", features = ["derive"] }
-dashmap = { version = "6.1.0" }
 foundry-compilers-artifacts = { version = "0.18.0" }
 futures = { version = "0.3.31" }
 hex = "0.4.3"
-regex = "1"
 moka = "0.12.10"
-paste = "1.0.15"
 reqwest = { version = "0.12.15", features = ["json"] }
 once_cell = "1.21"
 semver = { version = "1.0", features = ["serde"] }
@@ -44,21 +39,18 @@ serde_json = { version = "1.0", default-features = false, features = [
     "std",
     "unbounded_depth",
 ] }
-serde_with = { version = "3.14.0" }
 sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"
 sp-runtime = "41.1.0"
 temp-dir = { version = "0.1.16" }
 tempfile = "3.3"
-thiserror = "2"
 tokio = { version = "1.47.0", default-features = false, features = [
     "rt-multi-thread",
     "process",
     "rt",
 ] }
 uuid = { version = "1.8", features = ["v4"] }
-tracing = { version = "0.1.41" }
-tracing-appender = { version = "0.2.3" }
+tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", default-features = false, features = [
     "fmt",
     "json",
@@ -93,5 +85,3 @@ features = [
 inherits = "release"
 lto = true
 codegen-units = 1
-
-[workspace.lints.clippy]

README.md

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

assets/test_metadata.json

@@ -1,7 +1,8 @@
 {
     "modes": [
         "Y >=0.8.9",
-        "E"
+        "E",
+        "I"
     ],
     "cases": [
         {

clippy.toml

@@ -1 +0,0 @@
-

crates/common/Cargo.toml

@@ -13,8 +13,4 @@ anyhow = { workspace = true }
 moka = { workspace = true, features = ["sync"] }
 once_cell = { workspace = true }
 semver = { workspace = true }
-serde = { workspace = true }
 tokio = { workspace = true, default-features = false, features = ["time"] }
-
-[lints]
-workspace = true

crates/common/src/cached_fs/mod.rs

@@ -47,3 +47,27 @@ pub fn read_dir(path: impl AsRef<Path>) -> Result<Box<dyn Iterator<Item = Result
         }
     }
 }
+
+pub trait PathExt {
+    fn cached_canonicalize(&self) -> Result<PathBuf>;
+}
+
+impl<T> PathExt for T
+where
+    T: AsRef<Path>,
+{
+    fn cached_canonicalize(&self) -> Result<PathBuf> {
+        static CANONICALIZATION_CACHE: Lazy<Cache<PathBuf, PathBuf>> =
+            Lazy::new(|| Cache::new(10_000));
+
+        let path = self.as_ref().to_path_buf();
+        match CANONICALIZATION_CACHE.get(&path) {
+            Some(canonicalized) => Ok(canonicalized),
+            None => {
+                let canonicalized = path.canonicalize()?;
+                CANONICALIZATION_CACHE.insert(path, canonicalized.clone());
+                Ok(canonicalized)
+            }
+        }
+    }
+}

crates/common/src/fs/clear_dir.rs

@@ -3,28 +3,19 @@ use std::{
     path::Path,
 };
 
-use anyhow::{Context, Result};
+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())
-        .with_context(|| format!("Failed to read directory: {}", path.as_ref().display()))?
-    {
-        let entry = entry.with_context(|| {
-            format!(
-                "Failed to read an entry in directory: {}",
-                path.as_ref().display()
-            )
-        })?;
+    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)
-                .with_context(|| format!("Failed to remove file: {}", entry_path.display()))?
+            remove_file(entry_path)?
         } else {
-            remove_dir_all(&entry_path)
-                .with_context(|| format!("Failed to remove directory: {}", entry_path.display()))?
+            remove_dir_all(entry_path)?
         }
     }
     Ok(())

crates/common/src/futures/poll.rs

@@ -1,7 +1,7 @@
 use std::ops::ControlFlow;
 use std::time::Duration;
 
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{Result, anyhow};
 
 const EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION: Duration = Duration::from_secs(60);
 
@@ -38,10 +38,7 @@ where
             ));
         }
 
-        match future()
-            .await
-            .context("Polled future returned an error during polling loop")?
-        {
+        match future().await? {
             ControlFlow::Continue(()) => {
                 let next_wait_duration = match polling_wait_behavior {
                     PollingWaitBehavior::Constant(duration) => duration,

crates/common/src/iterators/either_iter.rs

@@ -1,21 +0,0 @@
-/// An iterator that could be either of two iterators.
-#[derive(Clone, Debug)]
-pub enum EitherIter<A, B> {
-    A(A),
-    B(B),
-}
-
-impl<A, B, T> Iterator for EitherIter<A, B>
-where
-    A: Iterator<Item = T>,
-    B: Iterator<Item = T>,
-{
-    type Item = T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self {
-            EitherIter::A(iter) => iter.next(),
-            EitherIter::B(iter) => iter.next(),
-        }
-    }
-}

crates/common/src/iterators/mod.rs

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

crates/common/src/macros/define_wrapper_type.rs

@@ -1,25 +1,3 @@
-#[macro_export]
-macro_rules! impl_for_wrapper {
-    (Display, $ident: ident) => {
-        #[automatically_derived]
-        impl std::fmt::Display for $ident {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                std::fmt::Display::fmt(&self.0, f)
-            }
-        }
-    };
-    (FromStr, $ident: ident) => {
-        #[automatically_derived]
-        impl std::str::FromStr for $ident {
-            type Err = anyhow::Error;
-
-            fn from_str(s: &str) -> anyhow::Result<Self> {
-                s.parse().map(Self).map_err(Into::into)
-            }
-        }
-    };
-}
-
 /// Defines wrappers around types.
 ///
 /// For example, the macro invocation seen below:
@@ -64,13 +42,7 @@ macro_rules! impl_for_wrapper {
 macro_rules! define_wrapper_type {
     (
         $(#[$meta: meta])*
-        $vis:vis struct $ident: ident($ty: ty)
-
-        $(
-            impl $($trait_ident: ident),*
-        )?
-
-        ;
+        $vis:vis struct $ident: ident($ty: ty);
     ) => {
         $(#[$meta])*
         $vis struct $ident($ty);
@@ -126,15 +98,9 @@ macro_rules! define_wrapper_type {
                 value.0
             }
         }
-
-        $(
-            $(
-                $crate::macros::impl_for_wrapper!($trait_ident, $ident);
-            )*
-        )?
     };
 }
 
 /// Technically not needed but this allows for the macro to be found in the `macros` module of the
 /// crate in addition to being found in the root of the crate.
-pub use {define_wrapper_type, impl_for_wrapper};
+pub use define_wrapper_type;

crates/common/src/types/mod.rs

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

crates/common/src/types/mode.rs

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

crates/common/src/types/version_or_requirement.rs

@@ -1,6 +1,9 @@
+use std::{fmt::Display, str::FromStr};
+
+use anyhow::{Error, bail};
 use semver::{Version, VersionReq};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum VersionOrRequirement {
     Version(Version),
     Requirement(VersionReq),
@@ -39,3 +42,26 @@ impl TryFrom<VersionOrRequirement> for VersionReq {
         Ok(requirement)
     }
 }
+
+impl FromStr for VersionOrRequirement {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Ok(version) = Version::parse(s) {
+            Ok(Self::Version(version))
+        } else if let Ok(version_req) = VersionReq::parse(s) {
+            Ok(Self::Requirement(version_req))
+        } else {
+            bail!("Not a valid version or version requirement")
+        }
+    }
+}
+
+impl Display for VersionOrRequirement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            VersionOrRequirement::Version(version) => version.fmt(f),
+            VersionOrRequirement::Requirement(version_req) => version_req.fmt(f),
+        }
+    }
+}

crates/compiler/Cargo.toml

@@ -18,13 +18,9 @@ revive-common = { workspace = true }
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
-dashmap = { workspace = true }
 foundry-compilers-artifacts = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 tracing = { workspace = true }
 tokio = { workspace = true }
-
-[lints]
-workspace = true

crates/compiler/src/lib.rs

@@ -11,7 +11,6 @@ use std::{
 
 use alloy::json_abi::JsonAbi;
 use alloy_primitives::Address;
-use anyhow::{Context, Result};
 use semver::Version;
 use serde::{Deserialize, Serialize};
 
@@ -20,47 +19,37 @@ use revive_dt_common::cached_fs::read_to_string;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 
-// Re-export this as it's a part of the compiler interface.
-pub use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
-
 pub mod revive_js;
 pub mod revive_resolc;
 pub mod solc;
 
 /// A common interface for all supported Solidity compilers.
-pub trait SolidityCompiler: Sized {
-    /// Instantiates a new compiler object.
-    ///
-    /// Based on the given [`Arguments`] and [`VersionOrRequirement`] this function instantiates a
-    /// new compiler object. Certain implementations of this trait might choose to cache cache the
-    /// compiler objects and return the same ones over and over again.
-    fn new(
-        config: &Arguments,
-        version: impl Into<Option<VersionOrRequirement>>,
-    ) -> impl Future<Output = Result<Self>>;
-
-    /// Returns the version of the compiler.
-    fn version(&self) -> &Version;
-
-    /// Returns the path of the compiler executable.
-    fn path(&self) -> &Path;
+pub trait SolidityCompiler {
+    /// Extra options specific to the compiler.
+    type Options: Default + PartialEq + Eq + Hash;
 
     /// The low-level compiler interface.
-    fn build(&self, input: CompilerInput) -> impl Future<Output = Result<CompilerOutput>>;
-
-    /// Does the compiler support the provided mode and version settings.
-    fn supports_mode(
+    fn build(
         &self,
-        optimizer_setting: ModeOptimizerSetting,
-        pipeline: ModePipeline,
-    ) -> bool;
+        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: impl Into<VersionOrRequirement>,
+    ) -> impl Future<Output = anyhow::Result<PathBuf>>;
+
+    fn version(&self) -> anyhow::Result<Version>;
 }
 
 /// The generic compilation input configuration.
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CompilerInput {
-    pub pipeline: Option<ModePipeline>,
-    pub optimization: Option<ModeOptimizerSetting>,
+    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>,
@@ -78,17 +67,26 @@ pub struct CompilerOutput {
 }
 
 /// A generic builder style interface for configuring the supported compiler options.
-#[derive(Default)]
-pub struct Compiler {
+pub struct Compiler<T: SolidityCompiler> {
     input: CompilerInput,
+    additional_options: T::Options,
 }
 
-impl Compiler {
+impl Default for Compiler<solc::Solc> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> Compiler<T>
+where
+    T: SolidityCompiler,
+{
     pub fn new() -> Self {
         Self {
             input: CompilerInput {
-                pipeline: Default::default(),
-                optimization: Default::default(),
+                enable_optimization: Default::default(),
+                via_ir: Default::default(),
                 evm_version: Default::default(),
                 allow_paths: Default::default(),
                 base_path: Default::default(),
@@ -96,16 +94,17 @@ impl Compiler {
                 libraries: Default::default(),
                 revert_string_handling: Default::default(),
             },
+            additional_options: T::Options::default(),
         }
     }
 
-    pub fn with_optimization(mut self, value: impl Into<Option<ModeOptimizerSetting>>) -> Self {
-        self.input.optimization = value.into();
+    pub fn with_optimization(mut self, value: impl Into<Option<bool>>) -> Self {
+        self.input.enable_optimization = value.into();
         self
     }
 
-    pub fn with_pipeline(mut self, value: impl Into<Option<ModePipeline>>) -> Self {
-        self.input.pipeline = value.into();
+    pub fn with_via_ir(mut self, value: impl Into<Option<bool>>) -> Self {
+        self.input.via_ir = value.into();
         self
     }
 
@@ -124,11 +123,10 @@ impl Compiler {
         self
     }
 
-    pub fn with_source(mut self, path: impl AsRef<Path>) -> Result<Self> {
-        self.input.sources.insert(
-            path.as_ref().to_path_buf(),
-            read_to_string(path.as_ref()).context("Failed to read the contract source")?,
-        );
+    pub fn with_source(mut self, path: impl AsRef<Path>) -> anyhow::Result<Self> {
+        self.input
+            .sources
+            .insert(path.as_ref().to_path_buf(), read_to_string(path.as_ref())?);
         Ok(self)
     }
 
@@ -154,20 +152,22 @@ impl Compiler {
         self
     }
 
-    pub fn then(self, callback: impl FnOnce(Self) -> Self) -> Self {
-        callback(self)
+    pub fn with_additional_options(mut self, options: impl Into<T::Options>) -> Self {
+        self.additional_options = options.into();
+        self
     }
 
-    pub fn try_then<E>(self, callback: impl FnOnce(Self) -> Result<Self, E>) -> Result<Self, E> {
-        callback(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 async fn try_build(self, compiler: &impl SolidityCompiler) -> Result<CompilerOutput> {
-        compiler.build(self.input).await
-    }
-
-    pub fn input(&self) -> &CompilerInput {
-        &self.input
+    pub fn input(&self) -> CompilerInput {
+        self.input.clone()
     }
 }
 

crates/compiler/src/revive_resolc.rs

@@ -2,12 +2,11 @@
 //! compiling contracts to PolkaVM (PVM) bytecode.
 
 use std::{
+    os::unix::process::CommandExt,
     path::PathBuf,
-    process::Stdio,
-    sync::{Arc, LazyLock},
+    process::{Command, Stdio},
 };
 
-use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_solc_json_interface::{
@@ -16,68 +15,34 @@ use revive_solc_json_interface::{
     SolcStandardJsonOutput,
 };
 
-use crate::{
-    CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler, solc::Solc,
-};
+use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
 
 use alloy::json_abi::JsonAbi;
-use anyhow::{Context, Result};
+use anyhow::Context;
 use semver::Version;
 use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
 
-/// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Resolc(Arc<ResolcInner>);
+// 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.
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct ResolcInner {
-    /// The internal solc compiler that the resolc compiler uses as a compiler frontend.
-    solc: Solc,
+/// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
+#[derive(Debug)]
+pub struct Resolc {
     /// Path to the `resolc` executable
     resolc_path: PathBuf,
 }
 
 impl SolidityCompiler for Resolc {
-    async fn new(
-        config: &Arguments,
-        version: impl Into<Option<VersionOrRequirement>>,
-    ) -> Result<Self> {
-        /// This is a cache of all of the resolc compiler objects. Since we do not currently support
-        /// multiple resolc compiler versions, so our cache is just keyed by the solc compiler and
-        /// its version to the resolc compiler.
-        static COMPILERS_CACHE: LazyLock<DashMap<Solc, Resolc>> = LazyLock::new(Default::default);
-
-        let solc = Solc::new(config, version)
-            .await
-            .context("Failed to create the solc compiler frontend for resolc")?;
-
-        Ok(COMPILERS_CACHE
-            .entry(solc.clone())
-            .or_insert_with(|| {
-                Self(Arc::new(ResolcInner {
-                    solc,
-                    resolc_path: config.resolc.clone(),
-                }))
-            })
-            .clone())
-    }
-
-    fn version(&self) -> &Version {
-        // We currently return the solc compiler version since we do not support multiple resolc
-        // compiler versions.
-        self.0.solc.version()
-    }
-
-    fn path(&self) -> &std::path::Path {
-        &self.0.resolc_path
-    }
+    type Options = Vec<String>;
 
     #[tracing::instrument(level = "debug", ret)]
     async fn build(
         &self,
         CompilerInput {
-            pipeline,
-            optimization,
+            enable_optimization,
+            // Ignored and not honored since this is required for the resolc compilation.
+            via_ir: _via_ir,
             evm_version,
             allow_paths,
             base_path,
@@ -87,13 +52,8 @@ impl SolidityCompiler for Resolc {
             // resolc. So, we need to go back to this later once it's supported.
             revert_string_handling: _,
         }: CompilerInput,
-    ) -> Result<CompilerOutput> {
-        if !matches!(pipeline, None | Some(ModePipeline::ViaYulIR)) {
-            anyhow::bail!(
-                "Resolc only supports the Y (via Yul IR) pipeline, but the provided pipeline is {pipeline:?}"
-            );
-        }
-
+        additional_options: Self::Options,
+    ) -> anyhow::Result<CompilerOutput> {
         let input = SolcStandardJsonInput {
             language: SolcStandardJsonInputLanguage::Solidity,
             sources: sources
@@ -122,9 +82,7 @@ impl SolidityCompiler for Resolc {
                 output_selection: Some(SolcStandardJsonInputSettingsSelection::new_required()),
                 via_ir: Some(true),
                 optimizer: SolcStandardJsonInputSettingsOptimizer::new(
-                    optimization
-                        .unwrap_or(ModeOptimizerSetting::M0)
-                        .optimizations_enabled(),
+                    enable_optimization.unwrap_or(false),
                     None,
                     &Version::new(0, 0, 0),
                     false,
@@ -134,12 +92,15 @@ impl SolidityCompiler for Resolc {
             },
         };
 
-        let mut command = AsyncCommand::new(self.path());
-        command
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .arg("--standard-json");
+        let mut command = AsyncCommand::new(&self.resolc_path);
+        unsafe {
+            command
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .arg("--standard-json")
+                .pre_exec(|| Ok(()))
+        };
 
         if let Some(ref base_path) = base_path {
             command.arg("--base-path").arg(base_path);
@@ -153,28 +114,18 @@ impl SolidityCompiler for Resolc {
                     .join(","),
             );
         }
-        let mut child = command
-            .spawn()
-            .with_context(|| format!("Failed to spawn resolc at {}", self.path().display()))?;
+        let mut child = command.spawn()?;
 
         let stdin_pipe = child.stdin.as_mut().expect("stdin must be piped");
-        let serialized_input = serde_json::to_vec(&input)
-            .context("Failed to serialize Standard JSON input for resolc")?;
-        stdin_pipe
-            .write_all(&serialized_input)
-            .await
-            .context("Failed to write Standard JSON to resolc stdin")?;
+        let serialized_input = serde_json::to_vec(&input)?;
+        stdin_pipe.write_all(&serialized_input).await?;
 
-        let output = child
-            .wait_with_output()
-            .await
-            .context("Failed while waiting for resolc process to finish")?;
+        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)
-                .context("Failed to pretty-print Standard JSON input for logging")?;
+            let json_in = serde_json::to_string_pretty(&input)?;
             let message = String::from_utf8_lossy(&stderr);
             tracing::error!(
                 status = %output.status,
@@ -185,14 +136,12 @@ impl SolidityCompiler for Resolc {
             anyhow::bail!("Compilation failed with an error: {message}");
         }
 
-        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout)
-            .map_err(|e| {
-                anyhow::anyhow!(
-                    "failed to parse resolc JSON output: {e}\nstderr: {}",
-                    String::from_utf8_lossy(&stderr)
-                )
-            })
-            .context("Failed to parse resolc standard JSON output")?;
+        let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout).map_err(|e| {
+            anyhow::anyhow!(
+                "failed to parse resolc JSON output: {e}\nstderr: {}",
+                String::from_utf8_lossy(&stderr)
+            )
+        })?;
 
         tracing::debug!(
             output = %serde_json::to_string(&parsed).unwrap(),
@@ -219,10 +168,7 @@ impl SolidityCompiler for Resolc {
 
         let mut compiler_output = CompilerOutput::default();
         for (source_path, contracts) in contracts.into_iter() {
-            let src_for_msg = source_path.clone();
-            let source_path = PathBuf::from(source_path)
-                .canonicalize()
-                .with_context(|| format!("Failed to canonicalize path {src_for_msg}"))?;
+            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() {
@@ -230,41 +176,23 @@ impl SolidityCompiler for Resolc {
                     .evm
                     .and_then(|evm| evm.bytecode.clone())
                     .context("Unexpected - Contract compiled with resolc has no bytecode")?;
-                let abi = {
-                    let metadata = contract_information
-                        .metadata
-                        .as_ref()
-                        .context("No metadata found for the contract")?;
-                    let solc_metadata_str = match metadata {
-                        serde_json::Value::String(solc_metadata_str) => solc_metadata_str.as_str(),
-                        serde_json::Value::Object(metadata_object) => {
-                            let solc_metadata_value = metadata_object
-                                .get("solc_metadata")
-                                .context("Contract doesn't have a 'solc_metadata' field")?;
-                            solc_metadata_value
-                                .as_str()
-                                .context("The 'solc_metadata' field is not a string")?
-                        }
-                        serde_json::Value::Null
-                        | serde_json::Value::Bool(_)
-                        | serde_json::Value::Number(_)
-                        | serde_json::Value::Array(_) => {
-                            anyhow::bail!("Unsupported type of metadata {metadata:?}")
-                        }
-                    };
-                    let solc_metadata =
-                        serde_json::from_str::<serde_json::Value>(solc_metadata_str).context(
-                            "Failed to deserialize the solc_metadata as a serde_json generic value",
-                        )?;
-                    let output_value = solc_metadata
-                        .get("output")
-                        .context("solc_metadata doesn't have an output field")?;
-                    let abi_value = output_value
-                        .get("abi")
-                        .context("solc_metadata output doesn't contain an abi field")?;
-                    serde_json::from_value::<JsonAbi>(abi_value.clone())
-                        .context("ABI found in solc_metadata output is not valid ABI")?
-                };
+                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));
             }
         }
@@ -272,11 +200,64 @@ impl SolidityCompiler for Resolc {
         Ok(compiler_output)
     }
 
-    fn supports_mode(
-        &self,
-        optimize_setting: ModeOptimizerSetting,
-        pipeline: ModePipeline,
-    ) -> bool {
-        pipeline == ModePipeline::ViaYulIR && self.0.solc.supports_mode(optimize_setting, pipeline)
+    fn new(resolc_path: PathBuf) -> Self {
+        Resolc { resolc_path }
+    }
+
+    async fn get_compiler_executable(
+        config: &Arguments,
+        _version: impl Into<VersionOrRequirement>,
+    ) -> anyhow::Result<PathBuf> {
+        if !config.resolc.as_os_str().is_empty() {
+            return Ok(config.resolc.clone());
+        }
+
+        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 = unsafe {
+            Command::new(self.resolc_path.as_path())
+                .arg("--version")
+                .stdout(Stdio::piped())
+                .pre_exec(|| Ok(()))
+                .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");
     }
 }

crates/compiler/src/solc.rs

@@ -2,19 +2,18 @@
 //! compiling contracts to EVM bytecode.
 
 use std::{
+    os::unix::process::CommandExt,
     path::PathBuf,
-    process::Stdio,
-    sync::{Arc, LazyLock},
+    process::{Command, Stdio},
 };
 
-use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
 
-use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
+use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
 
-use anyhow::{Context, Result};
+use anyhow::Context;
 use foundry_compilers_artifacts::{
     output_selection::{
         BytecodeOutputSelection, ContractOutputSelection, EvmOutputSelection, OutputSelection,
@@ -25,61 +24,20 @@ use foundry_compilers_artifacts::{
 use semver::Version;
 use tokio::{io::AsyncWriteExt, process::Command as AsyncCommand};
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Solc(Arc<SolcInner>);
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct SolcInner {
-    /// The path of the solidity compiler executable that this object uses.
+#[derive(Debug)]
+pub struct Solc {
     solc_path: PathBuf,
-    /// The version of the solidity compiler executable that this object uses.
-    solc_version: Version,
 }
 
 impl SolidityCompiler for Solc {
-    async fn new(
-        config: &Arguments,
-        version: impl Into<Option<VersionOrRequirement>>,
-    ) -> Result<Self> {
-        // This is a cache for the compiler objects so that whenever the same compiler version is
-        // requested the same object is returned. We do this as we do not want to keep cloning the
-        // compiler around.
-        static COMPILERS_CACHE: LazyLock<DashMap<Version, Solc>> = LazyLock::new(Default::default);
+    type Options = ();
 
-        // We attempt to download the solc binary. Note the following: this call does the version
-        // resolution for us. Therefore, even if the download didn't proceed, this function will
-        // resolve the version requirement into a canonical version of the compiler. It's then up
-        // to us to either use the provided path or not.
-        let version = version.into().unwrap_or_else(|| config.solc.clone().into());
-        let (version, path) = download_solc(config.directory(), version, false)
-            .await
-            .context("Failed to download/get path to solc binary")?;
-
-        Ok(COMPILERS_CACHE
-            .entry(version.clone())
-            .or_insert_with(|| {
-                Self(Arc::new(SolcInner {
-                    solc_path: path,
-                    solc_version: version,
-                }))
-            })
-            .clone())
-    }
-
-    fn version(&self) -> &Version {
-        &self.0.solc_version
-    }
-
-    fn path(&self) -> &std::path::Path {
-        &self.0.solc_path
-    }
-
-    #[tracing::instrument(level = "debug", ret)]
+    #[tracing::instrument(level = "info", ret)]
     async fn build(
         &self,
         CompilerInput {
-            pipeline,
-            optimization,
+            enable_optimization,
+            via_ir,
             evm_version,
             allow_paths,
             base_path,
@@ -87,16 +45,8 @@ impl SolidityCompiler for Solc {
             libraries,
             revert_string_handling,
         }: CompilerInput,
-    ) -> Result<CompilerOutput> {
-        // Be careful to entirely omit the viaIR field if the compiler does not support it,
-        // as it will error if you provide fields it does not know about. Because
-        // `supports_mode` is called prior to instantiating a compiler, we should never
-        // ask for something which is invalid.
-        let via_ir = match (pipeline, self.compiler_supports_yul()) {
-            (pipeline, true) => pipeline.map(|p| p.via_yul_ir()),
-            (_pipeline, false) => None,
-        };
-
+        _: Self::Options,
+    ) -> anyhow::Result<CompilerOutput> {
         let input = SolcInput {
             language: SolcLanguage::Solidity,
             sources: Sources(
@@ -107,7 +57,7 @@ impl SolidityCompiler for Solc {
             ),
             settings: Settings {
                 optimizer: Optimizer {
-                    enabled: optimization.map(|o| o.optimizations_enabled()),
+                    enabled: enable_optimization,
                     details: Some(Default::default()),
                     ..Default::default()
                 },
@@ -152,12 +102,15 @@ impl SolidityCompiler for Solc {
             },
         };
 
-        let mut command = AsyncCommand::new(self.path());
-        command
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .arg("--standard-json");
+        let mut command = AsyncCommand::new(&self.solc_path);
+        unsafe {
+            command
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .arg("--standard-json")
+                .pre_exec(|| Ok(()))
+        };
 
         if let Some(ref base_path) = base_path {
             command.arg("--base-path").arg(base_path);
@@ -173,23 +126,21 @@ impl SolidityCompiler for Solc {
         }
         let mut child = command
             .spawn()
-            .with_context(|| format!("Failed to spawn solc at {}", self.path().display()))?;
+            .inspect_err(|err| tracing::error!(%err, "Failed to spawn the solc command"))?;
 
         let stdin = child.stdin.as_mut().expect("should be piped");
-        let serialized_input = serde_json::to_vec(&input)
-            .context("Failed to serialize Standard JSON input for solc")?;
+        let serialized_input = serde_json::to_vec(&input)?;
         stdin
             .write_all(&serialized_input)
             .await
-            .context("Failed to write Standard JSON to solc stdin")?;
+            .inspect_err(|err| tracing::error!(%err, "Failed to write standard JSON to stdin"))?;
         let output = child
             .wait_with_output()
             .await
-            .context("Failed while waiting for solc process to finish")?;
+            .inspect_err(|err| tracing::error!(%err, "Failed to get the output of solc"))?;
 
         if !output.status.success() {
-            let json_in = serde_json::to_string_pretty(&input)
-                .context("Failed to pretty-print Standard JSON input for logging")?;
+            let json_in = serde_json::to_string_pretty(&input)?;
             let message = String::from_utf8_lossy(&output.stderr);
             tracing::error!(
                 status = %output.status,
@@ -200,14 +151,12 @@ impl SolidityCompiler for Solc {
             anyhow::bail!("Compilation failed with an error: {message}");
         }
 
-        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)
-                )
-            })
-            .context("Failed to parse solc standard JSON output")?;
+        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.
@@ -225,15 +174,13 @@ impl SolidityCompiler for Solc {
 
         let mut compiler_output = CompilerOutput::default();
         for (contract_path, contracts) in parsed.contracts {
-            let map = compiler_output
-                .contracts
-                .entry(contract_path.canonicalize().with_context(|| {
-                    format!(
-                        "Failed to canonicalize contract path {}",
-                        contract_path.display()
-                    )
-                })?)
-                .or_default();
+            let map =
+                compiler_output
+                    .contracts
+                    .entry(contract_path.canonicalize().inspect_err(
+                        |err| tracing::error!(%err, "Canonicalization of path failed"),
+                    )?)
+                    .or_default();
             for (contract_name, contract_info) in contracts.into_iter() {
                 let source_code = contract_info
                     .evm
@@ -253,21 +200,91 @@ impl SolidityCompiler for Solc {
         Ok(compiler_output)
     }
 
-    fn supports_mode(
-        &self,
-        _optimize_setting: ModeOptimizerSetting,
-        pipeline: ModePipeline,
-    ) -> bool {
-        // solc 0.8.13 and above supports --via-ir, and less than that does not. Thus, we support mode E
-        // (ie no Yul IR) in either case, but only support Y (via Yul IR) if the compiler is new enough.
-        pipeline == ModePipeline::ViaEVMAssembly
-            || (pipeline == ModePipeline::ViaYulIR && self.compiler_supports_yul())
+    fn new(solc_path: PathBuf) -> Self {
+        Self { solc_path }
+    }
+
+    async fn get_compiler_executable(
+        config: &Arguments,
+        version: impl Into<VersionOrRequirement>,
+    ) -> anyhow::Result<PathBuf> {
+        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 = unsafe {
+            Command::new(self.solc_path.as_path())
+                .arg("--version")
+                .stdout(Stdio::piped())
+                .pre_exec(|| Ok(()))
+                .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)
     }
 }
 
-impl Solc {
-    fn compiler_supports_yul(&self) -> bool {
-        const SOLC_VERSION_SUPPORTING_VIA_YUL_IR: Version = Version::new(0, 8, 13);
-        self.version() >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained() {
+        // Arrange
+        let args = Arguments::default();
+        println!("Getting compiler path");
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 7, 6))
+            .await
+            .unwrap();
+        println!("Got compiler path");
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version();
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 7, 6)
+        )
+    }
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained1() {
+        // Arrange
+        let args = Arguments::default();
+        println!("Getting compiler path");
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
+            .await
+            .unwrap();
+        println!("Got compiler path");
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version();
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 4, 21)
+        )
     }
 }

crates/compiler/tests/lib.rs

@@ -1,6 +1,5 @@
 use std::path::PathBuf;
 
-use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_compiler::{Compiler, SolidityCompiler, revive_resolc::Resolc, solc::Solc};
 use revive_dt_config::Arguments;
 use semver::Version;
@@ -9,17 +8,18 @@ use semver::Version;
 async fn contracts_can_be_compiled_with_solc() {
     // Arrange
     let args = Arguments::default();
-    let solc = Solc::new(&args, VersionOrRequirement::Version(Version::new(0, 8, 30)))
+    let compiler_path = Solc::get_compiler_executable(&args, Version::new(0, 8, 30))
         .await
         .unwrap();
+    println!("About to assert");
 
     // Act
-    let output = Compiler::new()
+    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(&solc)
+        .try_build(compiler_path)
         .await;
 
     // Assert
@@ -50,17 +50,17 @@ async fn contracts_can_be_compiled_with_solc() {
 async fn contracts_can_be_compiled_with_resolc() {
     // Arrange
     let args = Arguments::default();
-    let resolc = Resolc::new(&args, VersionOrRequirement::Version(Version::new(0, 8, 30)))
+    let compiler_path = Resolc::get_compiler_executable(&args, Version::new(0, 8, 30))
         .await
         .unwrap();
 
     // Act
-    let output = Compiler::new()
+    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(&resolc)
+        .try_build(compiler_path)
         .await;
 
     // Assert

crates/config/Cargo.toml

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

crates/config/src/lib.rs

@@ -58,6 +58,10 @@ pub struct Arguments {
     #[arg(long = "geth-start-timeout", default_value = "5000")]
     pub geth_start_timeout: u64,
 
+    /// The test network chain ID.
+    #[arg(short, long = "network-id", default_value = "420420420")]
+    pub network_id: u64,
+
     /// Configure nodes according to this genesis.json file.
     #[arg(long = "genesis", default_value = "genesis.json")]
     pub genesis_file: PathBuf,
@@ -84,6 +88,10 @@ pub struct Arguments {
     #[arg(short, long = "follower", default_value = "kitchensink")]
     pub follower: TestingPlatform,
 
+    /// Only compile against this testing platform (doesn't execute the tests).
+    #[arg(long = "compile-only")]
+    pub compile_only: Option<TestingPlatform>,
+
     /// Determines the amount of nodes that will be spawned for each chain.
     #[arg(long, default_value = "1")]
     pub number_of_nodes: usize,
@@ -111,35 +119,11 @@ pub struct Arguments {
     #[arg(short, long = "kitchensink", default_value = "substrate-node")]
     pub kitchensink: PathBuf,
 
-    /// The path to the `revive-dev-node` executable.
-    ///
-    /// By default it uses `revive-dev-node` binary found in `$PATH`.
-    #[arg(long = "revive-dev-node", default_value = "revive-dev-node")]
-    pub revive_dev_node: PathBuf,
-
-    /// By default the tool uses the revive-dev-node when it's running differential tests against
-    /// PolkaVM since the dev-node is much faster than kitchensink. This flag allows the caller to
-    /// configure the tool to use kitchensink rather than the dev-node.
-    #[arg(long)]
-    pub use_kitchensink_not_dev_node: bool,
-
     /// The path to the `eth_proxy` executable.
     ///
     /// By default it uses `eth-rpc` binary found in `$PATH`.
     #[arg(short = 'p', long = "eth_proxy", default_value = "eth-rpc")]
     pub eth_proxy: PathBuf,
-
-    /// Controls if the compilation cache should be invalidated or not.
-    #[arg(short, long)]
-    pub invalidate_compilation_cache: bool,
-
-    /// Controls if the compiler input is included in the final report.
-    #[clap(long = "report.include-compiler-input")]
-    pub report_include_compiler_input: bool,
-
-    /// Controls if the compiler output is included in the final report.
-    #[clap(long = "report.include-compiler-output")]
-    pub report_include_compiler_output: bool,
 }
 
 impl Arguments {

crates/core/Cargo.toml

@@ -23,19 +23,12 @@ revive-dt-report = { workspace = true }
 
 alloy = { workspace = true }
 anyhow = { workspace = true }
-bson = { workspace = true }
-cacache = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }
 indexmap = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
-tracing-appender = { workspace = true }
 tracing-subscriber = { workspace = true }
 semver = { workspace = true }
-serde = { workspace = true }
 serde_json = { workspace = true }
 temp-dir = { workspace = true }
-
-[lints]
-workspace = true

crates/core/src/cached_compiler.rs

@@ -1,359 +0,0 @@
-//! A wrapper around the compiler which allows for caching of compilation artifacts so that they can
-//! be reused between runs.
-
-use std::{
-    borrow::Cow,
-    collections::HashMap,
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-
-use futures::FutureExt;
-use revive_dt_common::iterators::FilesWithExtensionIterator;
-use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
-use revive_dt_config::TestingPlatform;
-use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
-
-use alloy::{hex::ToHexExt, json_abi::JsonAbi, primitives::Address};
-use anyhow::{Context as _, Error, Result};
-use revive_dt_report::ExecutionSpecificReporter;
-use semver::Version;
-use serde::{Deserialize, Serialize};
-use tokio::sync::{Mutex, RwLock};
-use tracing::{Instrument, debug, debug_span, instrument};
-
-use crate::Platform;
-
-pub struct CachedCompiler<'a> {
-    /// The cache that stores the compiled contracts.
-    artifacts_cache: ArtifactsCache,
-
-    /// This is a mechanism that the cached compiler uses so that if multiple compilation requests
-    /// come in for the same contract we never compile all of them and only compile it once and all
-    /// other tasks that request this same compilation concurrently get the cached version.
-    cache_key_lock: RwLock<HashMap<CacheKey<'a>, Arc<Mutex<()>>>>,
-}
-
-impl<'a> CachedCompiler<'a> {
-    pub async fn new(path: impl AsRef<Path>, invalidate_cache: bool) -> Result<Self> {
-        let mut cache = ArtifactsCache::new(path);
-        if invalidate_cache {
-            cache = cache
-                .with_invalidated_cache()
-                .await
-                .context("Failed to invalidate compilation cache directory")?;
-        }
-        Ok(Self {
-            artifacts_cache: cache,
-            cache_key_lock: Default::default(),
-        })
-    }
-
-    /// Compiles or gets the compilation artifacts from the cache.
-    #[allow(clippy::too_many_arguments)]
-    #[instrument(
-        level = "debug",
-        skip_all,
-        fields(
-            metadata_file_path = %metadata_file_path.display(),
-            %mode,
-            platform = P::config_id().to_string()
-        ),
-        err
-    )]
-    pub async fn compile_contracts<P: Platform>(
-        &self,
-        metadata: &'a Metadata,
-        metadata_file_path: &'a Path,
-        mode: Cow<'a, Mode>,
-        deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-        compiler: &P::Compiler,
-        reporter: &ExecutionSpecificReporter,
-    ) -> Result<CompilerOutput> {
-        let cache_key = CacheKey {
-            platform_key: P::config_id(),
-            compiler_version: compiler.version().clone(),
-            metadata_file_path,
-            solc_mode: mode.clone(),
-        };
-
-        let compilation_callback = || {
-            async move {
-                compile_contracts::<P>(
-                    metadata
-                        .directory()
-                        .context("Failed to get metadata directory while preparing compilation")?,
-                    metadata
-                        .files_to_compile()
-                        .context("Failed to enumerate files to compile from metadata")?,
-                    &mode,
-                    deployed_libraries,
-                    compiler,
-                    reporter,
-                )
-                .map(|compilation_result| compilation_result.map(CacheValue::new))
-                .await
-            }
-            .instrument(debug_span!(
-                "Running compilation for the cache key",
-                cache_key.platform_key = %cache_key.platform_key,
-                cache_key.compiler_version = %cache_key.compiler_version,
-                cache_key.metadata_file_path = %cache_key.metadata_file_path.display(),
-                cache_key.solc_mode = %cache_key.solc_mode,
-            ))
-        };
-
-        let compiled_contracts = match deployed_libraries {
-            // If deployed libraries have been specified then we will re-compile the contract as it
-            // means that linking is required in this case.
-            Some(_) => {
-                debug!("Deployed libraries defined, recompilation must take place");
-                debug!("Cache miss");
-                compilation_callback()
-                    .await
-                    .context("Compilation callback for deployed libraries failed")?
-                    .compiler_output
-            }
-            // If no deployed libraries are specified then we can follow the cached flow and attempt
-            // to lookup the compilation artifacts in the cache.
-            None => {
-                debug!("Deployed libraries undefined, attempting to make use of cache");
-
-                // Lock this specific cache key such that we do not get inconsistent state. We want
-                // that when multiple cases come in asking for the compilation artifacts then they
-                // don't all trigger a compilation if there's a cache miss. Hence, the lock here.
-                let read_guard = self.cache_key_lock.read().await;
-                let mutex = match read_guard.get(&cache_key).cloned() {
-                    Some(value) => {
-                        drop(read_guard);
-                        value
-                    }
-                    None => {
-                        drop(read_guard);
-                        self.cache_key_lock
-                            .write()
-                            .await
-                            .entry(cache_key.clone())
-                            .or_default()
-                            .clone()
-                    }
-                };
-                let _guard = mutex.lock().await;
-
-                match self.artifacts_cache.get(&cache_key).await {
-                    Some(cache_value) => {
-                        if deployed_libraries.is_some() {
-                            reporter
-                                .report_post_link_contracts_compilation_succeeded_event(
-                                    compiler.version().clone(),
-                                    compiler.path(),
-                                    true,
-                                    None,
-                                    cache_value.compiler_output.clone(),
-                                )
-                                .expect("Can't happen");
-                        } else {
-                            reporter
-                                .report_pre_link_contracts_compilation_succeeded_event(
-                                    compiler.version().clone(),
-                                    compiler.path(),
-                                    true,
-                                    None,
-                                    cache_value.compiler_output.clone(),
-                                )
-                                .expect("Can't happen");
-                        }
-                        cache_value.compiler_output
-                    }
-                    None => {
-                        compilation_callback()
-                            .await
-                            .context("Compilation callback failed (cache miss path)")?
-                            .compiler_output
-                    }
-                }
-            }
-        };
-
-        Ok(compiled_contracts)
-    }
-}
-
-async fn compile_contracts<P: Platform>(
-    metadata_directory: impl AsRef<Path>,
-    mut files_to_compile: impl Iterator<Item = PathBuf>,
-    mode: &Mode,
-    deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-    compiler: &P::Compiler,
-    reporter: &ExecutionSpecificReporter,
-) -> Result<CompilerOutput> {
-    let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
-        .with_allowed_extension("sol")
-        .with_use_cached_fs(true)
-        .collect::<Vec<_>>();
-
-    let compilation = Compiler::new()
-        .with_allow_path(metadata_directory)
-        // Handling the modes
-        .with_optimization(mode.optimize_setting)
-        .with_pipeline(mode.pipeline)
-        // Adding the contract sources to the compiler.
-        .try_then(|compiler| {
-            files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
-        })?
-        // Adding the deployed libraries to the compiler.
-        .then(|compiler| {
-            deployed_libraries
-                .iter()
-                .flat_map(|value| value.iter())
-                .map(|(instance, (ident, address, abi))| (instance, ident, address, abi))
-                .flat_map(|(_, ident, address, _)| {
-                    all_sources_in_dir
-                        .iter()
-                        .map(move |path| (ident, address, path))
-                })
-                .fold(compiler, |compiler, (ident, address, path)| {
-                    compiler.with_library(path, ident.as_str(), *address)
-                })
-        });
-
-    let input = compilation.input().clone();
-    let output = compilation.try_build(compiler).await;
-
-    match (output.as_ref(), deployed_libraries.is_some()) {
-        (Ok(output), true) => {
-            reporter
-                .report_post_link_contracts_compilation_succeeded_event(
-                    compiler.version().clone(),
-                    compiler.path(),
-                    false,
-                    input,
-                    output.clone(),
-                )
-                .expect("Can't happen");
-        }
-        (Ok(output), false) => {
-            reporter
-                .report_pre_link_contracts_compilation_succeeded_event(
-                    compiler.version().clone(),
-                    compiler.path(),
-                    false,
-                    input,
-                    output.clone(),
-                )
-                .expect("Can't happen");
-        }
-        (Err(err), true) => {
-            reporter
-                .report_post_link_contracts_compilation_failed_event(
-                    compiler.version().clone(),
-                    compiler.path().to_path_buf(),
-                    input,
-                    format!("{err:#}"),
-                )
-                .expect("Can't happen");
-        }
-        (Err(err), false) => {
-            reporter
-                .report_pre_link_contracts_compilation_failed_event(
-                    compiler.version().clone(),
-                    compiler.path().to_path_buf(),
-                    input,
-                    format!("{err:#}"),
-                )
-                .expect("Can't happen");
-        }
-    }
-
-    output
-}
-
-struct ArtifactsCache {
-    path: PathBuf,
-}
-
-impl ArtifactsCache {
-    pub fn new(path: impl AsRef<Path>) -> Self {
-        Self {
-            path: path.as_ref().to_path_buf(),
-        }
-    }
-
-    #[instrument(level = "debug", skip_all, err)]
-    pub async fn with_invalidated_cache(self) -> Result<Self> {
-        cacache::clear(self.path.as_path())
-            .await
-            .map_err(Into::<Error>::into)
-            .with_context(|| format!("Failed to clear cache at {}", self.path.display()))?;
-        Ok(self)
-    }
-
-    #[instrument(level = "debug", skip_all, err)]
-    pub async fn insert(&self, key: &CacheKey<'_>, value: &CacheValue) -> Result<()> {
-        let key = bson::to_vec(key).context("Failed to serialize cache key (bson)")?;
-        let value = bson::to_vec(value).context("Failed to serialize cache value (bson)")?;
-        cacache::write(self.path.as_path(), key.encode_hex(), value)
-            .await
-            .with_context(|| {
-                format!("Failed to write cache entry under {}", self.path.display())
-            })?;
-        Ok(())
-    }
-
-    pub async fn get(&self, key: &CacheKey<'_>) -> Option<CacheValue> {
-        let key = bson::to_vec(key).ok()?;
-        let value = cacache::read(self.path.as_path(), key.encode_hex())
-            .await
-            .ok()?;
-        let value = bson::from_slice::<CacheValue>(&value).ok()?;
-        Some(value)
-    }
-
-    #[instrument(level = "debug", skip_all, err)]
-    pub async fn get_or_insert_with(
-        &self,
-        key: &CacheKey<'_>,
-        callback: impl AsyncFnOnce() -> Result<CacheValue>,
-    ) -> Result<CacheValue> {
-        match self.get(key).await {
-            Some(value) => {
-                debug!("Cache hit");
-                Ok(value)
-            }
-            None => {
-                debug!("Cache miss");
-                let value = callback().await?;
-                self.insert(key, &value).await?;
-                Ok(value)
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-struct CacheKey<'a> {
-    /// The platform name that this artifact was compiled for. For example, this could be EVM or
-    /// PVM.
-    platform_key: &'a TestingPlatform,
-
-    /// The version of the compiler that was used to compile the artifacts.
-    compiler_version: Version,
-
-    /// The path of the metadata file that the compilation artifacts are for.
-    metadata_file_path: &'a Path,
-
-    /// The mode that the compilation artifacts where compiled with.
-    solc_mode: Cow<'a, Mode>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-struct CacheValue {
-    /// The compiler output from the compilation run.
-    compiler_output: CompilerOutput,
-}
-
-impl CacheValue {
-    pub fn new(compiler_output: CompilerOutput) -> Self {
-        Self { compiler_output }
-    }
-}

crates/core/src/driver/mod.rs

@@ -16,25 +16,26 @@ use alloy::rpc::types::trace::geth::{
 };
 use alloy::{
     primitives::Address,
-    rpc::types::{TransactionRequest, trace::geth::DiffMode},
+    rpc::types::{
+        TransactionRequest,
+        trace::geth::{AccountState, DiffMode},
+    },
 };
 use anyhow::Context;
-use futures::TryStreamExt;
 use indexmap::IndexMap;
 use revive_dt_format::traits::{ResolutionContext, ResolverApi};
-use revive_dt_report::ExecutionSpecificReporter;
 use semver::Version;
 
-use revive_dt_format::case::Case;
+use revive_dt_format::case::{Case, CaseIdx};
 use revive_dt_format::input::{
-    BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method, StepIdx,
+    BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method,
     StorageEmptyAssertion,
 };
-use revive_dt_format::metadata::{ContractIdent, ContractInstance, ContractPathAndIdent};
+use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Step, metadata::Metadata};
+use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
-use tokio::try_join;
-use tracing::{Instrument, info, info_span, instrument};
+use tracing::Instrument;
 
 use crate::Platform;
 
@@ -43,7 +44,7 @@ pub struct CaseState<T: Platform> {
     compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
 
     /// This map stores the contracts deployments for this case.
-    deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
+    deployed_contracts: HashMap<ContractInstance, (Address, JsonAbi)>,
 
     /// This map stores the variables used for each one of the cases contained in the metadata
     /// file.
@@ -52,9 +53,6 @@ pub struct CaseState<T: Platform> {
     /// Stores the version used for the current case.
     compiler_version: Version,
 
-    /// The execution reporter.
-    execution_reporter: ExecutionSpecificReporter,
-
     phantom: PhantomData<T>,
 }
 
@@ -65,15 +63,13 @@ where
     pub fn new(
         compiler_version: Version,
         compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
-        deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
-        execution_reporter: ExecutionSpecificReporter,
+        deployed_contracts: HashMap<ContractInstance, (Address, JsonAbi)>,
     ) -> Self {
         Self {
             compiled_contracts,
             deployed_contracts,
             variables: Default::default(),
             compiler_version,
-            execution_reporter,
             phantom: PhantomData,
         }
     }
@@ -81,102 +77,95 @@ where
     pub async fn handle_step(
         &mut self,
         metadata: &Metadata,
+        case_idx: CaseIdx,
         step: &Step,
         node: &T::Blockchain,
     ) -> anyhow::Result<StepOutput> {
         match step {
             Step::FunctionCall(input) => {
-                let (receipt, geth_trace, diff_mode) = self
-                    .handle_input(metadata, input, node)
-                    .await
-                    .context("Failed to handle function call step")?;
+                let (receipt, geth_trace, diff_mode) =
+                    self.handle_input(metadata, case_idx, input, node).await?;
                 Ok(StepOutput::FunctionCall(receipt, geth_trace, diff_mode))
             }
             Step::BalanceAssertion(balance_assertion) => {
-                self.handle_balance_assertion(metadata, balance_assertion, node)
-                    .await
-                    .context("Failed to handle balance assertion step")?;
+                self.handle_balance_assertion(metadata, case_idx, balance_assertion, node)
+                    .await?;
                 Ok(StepOutput::BalanceAssertion)
             }
             Step::StorageEmptyAssertion(storage_empty) => {
-                self.handle_storage_empty(metadata, storage_empty, node)
-                    .await
-                    .context("Failed to handle storage empty assertion step")?;
+                self.handle_storage_empty(metadata, case_idx, storage_empty, node)
+                    .await?;
                 Ok(StepOutput::StorageEmptyAssertion)
             }
         }
-        .inspect(|_| info!("Step Succeeded"))
     }
 
-    #[instrument(level = "info", name = "Handling Input", skip_all)]
     pub async fn handle_input(
         &mut self,
         metadata: &Metadata,
+        case_idx: CaseIdx,
         input: &Input,
         node: &T::Blockchain,
     ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
         let deployment_receipts = self
-            .handle_input_contract_deployment(metadata, input, node)
-            .await
-            .context("Failed during contract deployment phase of input handling")?;
+            .handle_input_contract_deployment(metadata, case_idx, input, node)
+            .await?;
         let execution_receipt = self
             .handle_input_execution(input, deployment_receipts, node)
-            .await
-            .context("Failed during transaction execution phase of input handling")?;
+            .await?;
         let tracing_result = self
             .handle_input_call_frame_tracing(&execution_receipt, node)
+            .await?;
+        self.handle_input_variable_assignment(input, &tracing_result)?;
+        self.handle_input_expectations(input, &execution_receipt, node, &tracing_result)
+            .await?;
+        self.handle_input_diff(case_idx, execution_receipt, node)
             .await
-            .context("Failed during callframe tracing phase of input handling")?;
-        self.handle_input_variable_assignment(input, &tracing_result)
-            .context("Failed to assign variables from callframe output")?;
-        let (_, (geth_trace, diff_mode)) = try_join!(
-            self.handle_input_expectations(input, &execution_receipt, node, &tracing_result),
-            self.handle_input_diff(&execution_receipt, node)
-        )
-        .context("Failed while evaluating expectations and diffs in parallel")?;
-        Ok((execution_receipt, geth_trace, diff_mode))
     }
 
-    #[instrument(level = "info", name = "Handling Balance Assertion", skip_all)]
     pub async fn handle_balance_assertion(
         &mut self,
         metadata: &Metadata,
+        _: CaseIdx,
         balance_assertion: &BalanceAssertion,
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
         self.handle_balance_assertion_contract_deployment(metadata, balance_assertion, node)
-            .await
-            .context("Failed to deploy contract for balance assertion")?;
+            .await?;
         self.handle_balance_assertion_execution(balance_assertion, node)
-            .await
-            .context("Failed to execute balance assertion")?;
+            .await?;
         Ok(())
     }
 
-    #[instrument(level = "info", name = "Handling Storage Assertion", skip_all)]
     pub async fn handle_storage_empty(
         &mut self,
         metadata: &Metadata,
+        _: CaseIdx,
         storage_empty: &StorageEmptyAssertion,
         node: &T::Blockchain,
     ) -> anyhow::Result<()> {
         self.handle_storage_empty_assertion_contract_deployment(metadata, storage_empty, node)
-            .await
-            .context("Failed to deploy contract for storage empty assertion")?;
+            .await?;
         self.handle_storage_empty_assertion_execution(storage_empty, node)
-            .await
-            .context("Failed to execute storage empty assertion")?;
+            .await?;
         Ok(())
     }
 
     /// Handles the contract deployment for a given input performing it if it needs to be performed.
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_contract_deployment(
         &mut self,
         metadata: &Metadata,
+        case_idx: CaseIdx,
         input: &Input,
         node: &T::Blockchain,
     ) -> anyhow::Result<HashMap<ContractInstance, TransactionReceipt>> {
+        let span = tracing::debug_span!(
+            "Handling contract deployment",
+            ?case_idx,
+            instance = ?input.instance
+        );
+        let _guard = span.enter();
+
         let mut instances_we_must_deploy = IndexMap::<ContractInstance, bool>::new();
         for instance in input.find_all_contract_instances().into_iter() {
             if !self.deployed_contracts.contains_key(&instance) {
@@ -188,6 +177,11 @@ where
             instances_we_must_deploy.insert(input.instance.clone(), true);
         }
 
+        tracing::debug!(
+            instances_to_deploy = instances_we_must_deploy.len(),
+            "Computed the number of required deployments for input"
+        );
+
         let mut receipts = HashMap::new();
         for (instance, deploy_with_constructor_arguments) in instances_we_must_deploy.into_iter() {
             let calldata = deploy_with_constructor_arguments.then_some(&input.calldata);
@@ -204,8 +198,7 @@ where
                     value,
                     node,
                 )
-                .await
-                .context("Failed to get or deploy contract instance during input execution")?
+                .await?
             {
                 receipts.insert(instance.clone(), receipt);
             }
@@ -215,7 +208,6 @@ where
     }
 
     /// Handles the execution of the input in terms of the calls that need to be made.
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_execution(
         &mut self,
         input: &Input,
@@ -227,27 +219,39 @@ where
             // lookup the transaction receipt in this case and continue on.
             Method::Deployer => deployment_receipts
                 .remove(&input.instance)
-                .context("Failed to find deployment receipt for constructor call"),
+                .context("Failed to find deployment receipt"),
             Method::Fallback | Method::FunctionName(_) => {
                 let tx = match input
                     .legacy_transaction(node, self.default_resolution_context())
                     .await
                 {
-                    Ok(tx) => tx,
+                    Ok(tx) => {
+                        tracing::debug!("Legacy transaction data: {tx:#?}");
+                        tx
+                    }
                     Err(err) => {
+                        tracing::error!("Failed to construct legacy transaction: {err:?}");
                         return Err(err);
                     }
                 };
 
+                tracing::trace!("Executing transaction for input: {input:?}");
+
                 match node.execute_transaction(tx).await {
                     Ok(receipt) => Ok(receipt),
-                    Err(err) => Err(err),
+                    Err(err) => {
+                        tracing::error!(
+                            "Failed to execute transaction when executing the contract: {}, {:?}",
+                            &*input.instance,
+                            err
+                        );
+                        Err(err)
+                    }
                 }
             }
         }
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_call_frame_tracing(
         &self,
         execution_receipt: &TransactionReceipt,
@@ -262,10 +266,7 @@ where
                 tracer_config: GethDebugTracerConfig(serde_json::json! {{
                     "onlyTopCall": true,
                     "withLog": false,
-                    "withStorage": false,
-                    "withMemory": false,
-                    "withStack": false,
-                    "withReturnData": true
+                    "withReturnData": false
                 }}),
                 ..Default::default()
             },
@@ -278,7 +279,6 @@ where
         })
     }
 
-    #[instrument(level = "info", skip_all)]
     fn handle_input_variable_assignment(
         &mut self,
         input: &Input,
@@ -309,14 +309,16 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_expectations(
-        &self,
+        &mut self,
         input: &Input,
         execution_receipt: &TransactionReceipt,
         resolver: &impl ResolverApi,
         tracing_result: &CallFrame,
     ) -> anyhow::Result<()> {
+        let span = tracing::info_span!("Handling input expectations");
+        let _guard = span.enter();
+
         // Resolving the `input.expected` into a series of expectations that we can then assert on.
         let mut expectations = match input {
             Input {
@@ -345,25 +347,24 @@ where
             }
         }
 
-        futures::stream::iter(expectations.into_iter().map(Ok))
-            .try_for_each_concurrent(None, |expectation| async move {
-                self.handle_input_expectation_item(
-                    execution_receipt,
-                    resolver,
-                    expectation,
-                    tracing_result,
-                )
-                .await
-            })
-            .await
+        for expectation in expectations.iter() {
+            self.handle_input_expectation_item(
+                execution_receipt,
+                resolver,
+                expectation,
+                tracing_result,
+            )
+            .await?;
+        }
+
+        Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_expectation_item(
-        &self,
+        &mut self,
         execution_receipt: &TransactionReceipt,
         resolver: &impl ResolverApi,
-        expectation: ExpectedOutput,
+        expectation: &ExpectedOutput,
         tracing_result: &CallFrame,
     ) -> anyhow::Result<()> {
         if let Some(ref version_requirement) = expectation.compiler_version {
@@ -399,8 +400,7 @@ where
             let actual = &tracing_result.output.as_ref().unwrap_or_default();
             if !expected
                 .is_equivalent(actual, resolver, resolution_context)
-                .await
-                .context("Failed to resolve calldata equivalence for return data assertion")?
+                .await?
             {
                 tracing::error!(
                     ?execution_receipt,
@@ -463,8 +463,7 @@ where
                     let expected = Calldata::new_compound([expected]);
                     if !expected
                         .is_equivalent(&actual.0, resolver, resolution_context)
-                        .await
-                        .context("Failed to resolve event topic equivalence")?
+                        .await?
                     {
                         tracing::error!(
                             event_idx,
@@ -484,8 +483,7 @@ where
                 let actual = &actual_event.data().data;
                 if !expected
                     .is_equivalent(&actual.0, resolver, resolution_context)
-                    .await
-                    .context("Failed to resolve event value equivalence")?
+                    .await?
                 {
                     tracing::error!(
                         event_idx,
@@ -504,12 +502,15 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     async fn handle_input_diff(
-        &self,
-        execution_receipt: &TransactionReceipt,
+        &mut self,
+        _: CaseIdx,
+        execution_receipt: TransactionReceipt,
         node: &T::Blockchain,
-    ) -> anyhow::Result<(GethTrace, DiffMode)> {
+    ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
+        let span = tracing::info_span!("Handling input diff");
+        let _guard = span.enter();
+
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
             disable_code: None,
@@ -517,18 +518,13 @@ where
         });
 
         let trace = node
-            .trace_transaction(execution_receipt, trace_options)
-            .await
-            .context("Failed to obtain geth prestate tracer output")?;
-        let diff = node
-            .state_diff(execution_receipt)
-            .await
-            .context("Failed to obtain state diff for transaction")?;
+            .trace_transaction(&execution_receipt, trace_options)
+            .await?;
+        let diff = node.state_diff(&execution_receipt).await?;
 
-        Ok((trace, diff))
+        Ok((execution_receipt, trace, diff))
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_balance_assertion_contract_deployment(
         &mut self,
         metadata: &Metadata,
@@ -554,7 +550,6 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_balance_assertion_execution(
         &mut self,
         BalanceAssertion {
@@ -590,7 +585,6 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_storage_empty_assertion_contract_deployment(
         &mut self,
         metadata: &Metadata,
@@ -616,7 +610,6 @@ where
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all)]
     pub async fn handle_storage_empty_assertion_execution(
         &mut self,
         StorageEmptyAssertion {
@@ -669,7 +662,7 @@ where
         value: Option<EtherValue>,
         node: &T::Blockchain,
     ) -> anyhow::Result<(Address, JsonAbi, Option<TransactionReceipt>)> {
-        if let Some((_, address, abi)) = self.deployed_contracts.get(contract_instance) {
+        if let Some((address, abi)) = self.deployed_contracts.get(contract_instance) {
             return Ok((*address, abi.clone(), None));
         }
 
@@ -678,6 +671,7 @@ where
             contract_ident,
         }) = metadata.contract_sources()?.remove(contract_instance)
         else {
+            tracing::error!("Contract source not found for instance");
             anyhow::bail!(
                 "Contract source not found for instance {:?}",
                 contract_instance
@@ -690,6 +684,11 @@ where
             .and_then(|source_file_contracts| source_file_contracts.get(contract_ident.as_ref()))
             .cloned()
         else {
+            tracing::error!(
+                contract_source_path = contract_source_path.display().to_string(),
+                contract_ident = contract_ident.as_ref(),
+                "Failed to find information for contract"
+            );
             anyhow::bail!(
                 "Failed to find information for contract {:?}",
                 contract_instance
@@ -738,6 +737,7 @@ where
         };
 
         let Some(address) = receipt.contract_address else {
+            tracing::error!("Contract deployment transaction didn't return an address");
             anyhow::bail!("Contract deployment didn't return an address");
         };
         tracing::info!(
@@ -745,13 +745,9 @@ where
             instance_address = ?address,
             "Deployed contract"
         );
-        self.execution_reporter
-            .report_contract_deployed_event(contract_instance.clone(), address)?;
 
-        self.deployed_contracts.insert(
-            contract_instance.clone(),
-            (contract_ident, address, abi.clone()),
-        );
+        self.deployed_contracts
+            .insert(contract_instance.clone(), (address, abi.clone()));
 
         Ok((address, abi, Some(receipt)))
     }
@@ -766,6 +762,7 @@ where
 pub struct CaseDriver<'a, Leader: Platform, Follower: Platform> {
     metadata: &'a Metadata,
     case: &'a Case,
+    case_idx: CaseIdx,
     leader_node: &'a Leader::Blockchain,
     follower_node: &'a Follower::Blockchain,
     leader_state: CaseState<Leader>,
@@ -781,6 +778,7 @@ where
     pub fn new(
         metadata: &'a Metadata,
         case: &'a Case,
+        case_idx: impl Into<CaseIdx>,
         leader_node: &'a L::Blockchain,
         follower_node: &'a F::Blockchain,
         leader_state: CaseState<L>,
@@ -789,6 +787,7 @@ where
         Self {
             metadata,
             case,
+            case_idx: case_idx.into(),
             leader_node,
             follower_node,
             leader_state,
@@ -796,44 +795,79 @@ where
         }
     }
 
-    #[instrument(level = "info", name = "Executing Case", skip_all)]
-    pub async fn execute(&mut self) -> anyhow::Result<usize> {
-        let mut steps_executed = 0;
-        for (step_idx, step) in self
-            .case
-            .steps_iterator()
-            .enumerate()
-            .map(|(idx, v)| (StepIdx::new(idx), v))
-        {
-            let (leader_step_output, follower_step_output) = try_join!(
-                self.leader_state
-                    .handle_step(self.metadata, &step, self.leader_node)
-                    .instrument(info_span!(
-                        "Handling Step",
-                        %step_idx,
-                        target = "Leader",
-                    )),
-                self.follower_state
-                    .handle_step(self.metadata, &step, self.follower_node)
-                    .instrument(info_span!(
-                        "Handling Step",
-                        %step_idx,
-                        target = "Follower",
-                    ))
-            )?;
+    pub fn trace_diff_mode(label: &str, diff: &DiffMode) {
+        tracing::trace!("{label} - PRE STATE:");
+        for (addr, state) in &diff.pre {
+            Self::trace_account_state("  [pre]", addr, state);
+        }
 
+        tracing::trace!("{label} - POST STATE:");
+        for (addr, state) in &diff.post {
+            Self::trace_account_state("  [post]", addr, state);
+        }
+    }
+
+    fn trace_account_state(prefix: &str, addr: &Address, state: &AccountState) {
+        tracing::trace!("{prefix} 0x{addr:x}");
+
+        if let Some(balance) = &state.balance {
+            tracing::trace!("{prefix}   balance: {balance}");
+        }
+        if let Some(nonce) = &state.nonce {
+            tracing::trace!("{prefix}   nonce: {nonce}");
+        }
+        if let Some(code) = &state.code {
+            tracing::trace!("{prefix}   code: {code}");
+        }
+    }
+
+    pub async fn execute(&mut self) -> anyhow::Result<usize> {
+        if !self
+            .leader_node
+            .matches_target(self.metadata.targets.as_deref())
+            || !self
+                .follower_node
+                .matches_target(self.metadata.targets.as_deref())
+        {
+            tracing::warn!(
+                targets = ?self.metadata.targets,
+                "Either the leader or follower node do not support the targets of the file"
+            );
+            return Ok(0);
+        }
+
+        let mut steps_executed = 0;
+        for (step_idx, step) in self.case.steps_iterator().enumerate() {
+            let tracing_span = tracing::info_span!("Handling input", step_idx);
+
+            let leader_step_output = self
+                .leader_state
+                .handle_step(self.metadata, self.case_idx, &step, self.leader_node)
+                .instrument(tracing_span.clone())
+                .await?;
+            let follower_step_output = self
+                .follower_state
+                .handle_step(self.metadata, self.case_idx, &step, self.follower_node)
+                .instrument(tracing_span)
+                .await?;
             match (leader_step_output, follower_step_output) {
-                (StepOutput::FunctionCall(..), StepOutput::FunctionCall(..)) => {
-                    // TODO: We need to actually work out how/if we will compare the diff between
-                    // the leader and the follower. The diffs are almost guaranteed to be different
-                    // from leader and follower and therefore without an actual strategy for this
-                    // we have something that's guaranteed to fail. Even a simple call to some
-                    // contract will produce two non-equal diffs because on the leader the contract
-                    // has address X and on the follower it has address Y. On the leader contract X
-                    // contains address A in the state and on the follower it contains address B. So
-                    // this isn't exactly a straightforward thing to do and I'm not even sure that
-                    // it's possible to do. Once we have an actual strategy for doing the diffs we
-                    // will implement it here. Until then, this remains empty.
+                (
+                    StepOutput::FunctionCall(leader_receipt, _, leader_diff),
+                    StepOutput::FunctionCall(follower_receipt, _, follower_diff),
+                ) => {
+                    if leader_diff == follower_diff {
+                        tracing::debug!("State diffs match between leader and follower.");
+                    } else {
+                        tracing::debug!("State diffs mismatch between leader and follower.");
+                        Self::trace_diff_mode("Leader", &leader_diff);
+                        Self::trace_diff_mode("Follower", &follower_diff);
+                    }
+
+                    if leader_receipt.logs() != follower_receipt.logs() {
+                        tracing::debug!("Log/event mismatch between leader and follower.");
+                        tracing::trace!("Leader logs: {:?}", leader_receipt.logs());
+                        tracing::trace!("Follower logs: {:?}", follower_receipt.logs());
+                    }
                 }
                 (StepOutput::BalanceAssertion, StepOutput::BalanceAssertion) => {}
                 (StepOutput::StorageEmptyAssertion, StepOutput::StorageEmptyAssertion) => {}

crates/core/src/lib.rs

@@ -19,7 +19,7 @@ pub trait Platform {
     type Compiler: SolidityCompiler;
 
     /// Returns the matching [TestingPlatform] of the [revive_dt_config::Arguments].
-    fn config_id() -> &'static TestingPlatform;
+    fn config_id() -> TestingPlatform;
 }
 
 #[derive(Default)]
@@ -29,8 +29,8 @@ impl Platform for Geth {
     type Blockchain = geth::GethNode;
     type Compiler = solc::Solc;
 
-    fn config_id() -> &'static TestingPlatform {
-        &TestingPlatform::Geth
+    fn config_id() -> TestingPlatform {
+        TestingPlatform::Geth
     }
 }
 
@@ -41,7 +41,7 @@ impl Platform for Kitchensink {
     type Blockchain = KitchensinkNode;
     type Compiler = revive_resolc::Resolc;
 
-    fn config_id() -> &'static TestingPlatform {
-        &TestingPlatform::Kitchensink
+    fn config_id() -> TestingPlatform {
+        TestingPlatform::Kitchensink
     }
 }

crates/format/Cargo.toml

@@ -17,8 +17,6 @@ alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
-futures = { workspace = true }
-regex = { workspace = true }
 tracing = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
@@ -26,6 +24,3 @@ serde_json = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true }
-
-[lints]
-workspace = true

crates/format/src/case.rs

@@ -1,10 +1,13 @@
+use std::collections::HashSet;
+
 use serde::{Deserialize, Serialize};
 
-use revive_dt_common::{macros::define_wrapper_type, types::Mode};
+use revive_dt_common::macros::define_wrapper_type;
 
 use crate::{
     input::{Expected, Step},
-    mode::ParsedMode,
+    metadata::{deserialize_compilation_modes, serialize_compilation_modes},
+    mode::Mode,
 };
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
@@ -15,8 +18,13 @@ pub struct Case {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub modes: Option<Vec<ParsedMode>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "deserialize_compilation_modes",
+        serialize_with = "serialize_compilation_modes"
+    )]
+    pub modes: Option<HashSet<Mode>>,
 
     #[serde(rename = "inputs")]
     pub steps: Vec<Step>,
@@ -32,7 +40,6 @@ pub struct Case {
 }
 
 impl Case {
-    #[allow(irrefutable_let_patterns)]
     pub fn steps_iterator(&self) -> impl Iterator<Item = Step> {
         let steps_len = self.steps.len();
         self.steps
@@ -60,18 +67,10 @@ impl Case {
                 }
             })
     }
-
-    pub fn solc_modes(&self) -> Vec<Mode> {
-        match &self.modes {
-            Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
-            None => Mode::all().cloned().collect(),
-        }
-    }
 }
 
 define_wrapper_type!(
     /// A wrapper type for the index of test cases found in metadata file.
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-    #[serde(transparent)]
-    pub struct CaseIdx(usize) impl Display, FromStr;
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct CaseIdx(usize);
 );

crates/format/src/corpus.rs

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

crates/format/src/input.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use alloy::{
     eips::BlockNumberOrTag,
+    hex::ToHexExt,
     json_abi::Function,
     network::TransactionBuilder,
     primitives::{Address, Bytes, U256},
@@ -9,12 +10,10 @@ use alloy::{
 };
 use alloy_primitives::{FixedBytes, utils::parse_units};
 use anyhow::Context;
-use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, stream};
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
 
 use revive_dt_common::macros::define_wrapper_type;
-use tracing::{Instrument, info_span, instrument};
 
 use crate::traits::ResolverApi;
 use crate::{metadata::ContractInstance, traits::ResolutionContext};
@@ -34,11 +33,6 @@ pub enum Step {
     StorageEmptyAssertion(Box<StorageEmptyAssertion>),
 }
 
-define_wrapper_type!(
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-    pub struct StepIdx(usize) impl Display;
-);
-
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Input {
     #[serde(default = "Input::default_caller")]
@@ -194,7 +188,7 @@ define_wrapper_type! {
     /// This represents an item in the [`Calldata::Compound`] variant.
     #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
     #[serde(transparent)]
-    pub struct CalldataItem(String) impl Display;
+    pub struct CalldataItem(String);
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
@@ -239,7 +233,7 @@ pub enum Method {
 
 define_wrapper_type!(
     #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub struct EtherValue(U256) impl Display;
+    pub struct EtherValue(U256);
 );
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
@@ -268,34 +262,35 @@ impl Input {
     ) -> anyhow::Result<Bytes> {
         match self.method {
             Method::Deployer | Method::Fallback => {
-                let calldata = self
-                    .calldata
-                    .calldata(resolver, context)
-                    .await
-                    .context("Failed to produce calldata for deployer/fallback method")?;
+                let calldata = self.calldata.calldata(resolver, context).await?;
 
                 Ok(calldata.into())
             }
             Method::FunctionName(ref function_name) => {
                 let Some(abi) = context.deployed_contract_abi(&self.instance) else {
+                    tracing::error!(
+                        contract_name = self.instance.as_ref(),
+                        "Attempted to lookup ABI of contract but it wasn't found"
+                    );
                     anyhow::bail!("ABI for instance '{}' not found", self.instance.as_ref());
                 };
 
+                tracing::trace!("ABI found for instance: {}", &self.instance.as_ref());
+
                 // We follow the same logic that's implemented in the matter-labs-tester where they resolve
                 // the function name into a function selector and they assume that he function doesn't have
                 // any existing overloads.
                 // Overloads are handled by providing the full function signature in the "function
                 // name".
                 // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
-                let selector =
-                    if function_name.contains('(') && function_name.contains(')') {
-                        Function::parse(function_name)
+                let selector = if function_name.contains('(') && function_name.contains(')') {
+                    Function::parse(function_name)
                         .context(
                             "Failed to parse the provided function name into a function signature",
                         )?
                         .selector()
-                    } else {
-                        abi.functions()
+                } else {
+                    abi.functions()
                         .find(|function| function.signature().starts_with(function_name))
                         .ok_or_else(|| {
                             anyhow::anyhow!(
@@ -303,13 +298,16 @@ impl Input {
                                 function_name,
                                 &self.instance
                             )
-                        })
-                        .with_context(|| format!(
-                            "Failed to resolve function selector for {:?} on instance {:?}",
-                            function_name, &self.instance
-                        ))?
+                        })?
                         .selector()
-                    };
+                };
+
+                tracing::trace!("Functions found for instance: {}", self.instance.as_ref());
+
+                tracing::trace!(
+                    "Starting encoding ABI's parameters for instance: {}",
+                    self.instance.as_ref()
+                );
 
                 // Allocating a vector that we will be using for the calldata. The vector size will be:
                 // 4 bytes for the function selector.
@@ -321,8 +319,7 @@ impl Input {
                 calldata.extend(selector.0);
                 self.calldata
                     .calldata_into_slice(&mut calldata, resolver, context)
-                    .await
-                    .context("Failed to append encoded argument to calldata buffer")?;
+                    .await?;
 
                 Ok(calldata.into())
             }
@@ -335,10 +332,7 @@ impl Input {
         resolver: &impl ResolverApi,
         context: ResolutionContext<'_>,
     ) -> anyhow::Result<TransactionRequest> {
-        let input_data = self
-            .encoded_input(resolver, context)
-            .await
-            .context("Failed to encode input bytes for transaction request")?;
+        let input_data = self.encoded_input(resolver, context).await?;
         let transaction_request = TransactionRequest::default().from(self.caller).value(
             self.value
                 .map(|value| value.into_inner())
@@ -441,19 +435,17 @@ impl Calldata {
                 buffer.extend_from_slice(bytes);
             }
             Calldata::Compound(items) => {
-                let resolved = stream::iter(items.iter().enumerate())
-                    .map(|(arg_idx, arg)| async move {
-                        arg.resolve(resolver, context)
-                            .instrument(info_span!("Resolving argument", %arg, arg_idx))
-                            .map_ok(|value| value.to_be_bytes::<32>())
-                            .await
-                    })
-                    .buffered(0xFF)
-                    .try_collect::<Vec<_>>()
-                    .await
-                    .context("Failed to resolve one or more calldata arguments")?;
-
-                buffer.extend(resolved.into_iter().flatten());
+                for (arg_idx, arg) in items.iter().enumerate() {
+                    match arg.resolve(resolver, context).await {
+                        Ok(resolved) => {
+                            buffer.extend(resolved.to_be_bytes::<32>());
+                        }
+                        Err(error) => {
+                            tracing::error!(?arg, arg_idx, ?error, "Failed to resolve argument");
+                            return Err(error);
+                        }
+                    };
+                }
             }
         };
         Ok(())
@@ -476,40 +468,36 @@ impl Calldata {
         match self {
             Calldata::Single(calldata) => Ok(calldata == other),
             Calldata::Compound(items) => {
-                stream::iter(items.iter().zip(other.chunks(32)))
-                    .map(|(this, other)| async move {
-                        // The matterlabs format supports wildcards and therefore we
-                        // also need to support them.
-                        if this.as_ref() == "*" {
-                            return Ok::<_, anyhow::Error>(true);
-                        }
+                // Chunking the "other" calldata into 32 byte chunks since each
+                // one of the items in the compound calldata represents 32 bytes
+                for (this, other) in items.iter().zip(other.chunks(32)) {
+                    // The matterlabs format supports wildcards and therefore we
+                    // also need to support them.
+                    if this.as_ref() == "*" {
+                        continue;
+                    }
 
-                        let other = if other.len() < 32 {
-                            let mut vec = other.to_vec();
-                            vec.resize(32, 0);
-                            std::borrow::Cow::Owned(vec)
-                        } else {
-                            std::borrow::Cow::Borrowed(other)
-                        };
+                    let other = if other.len() < 32 {
+                        let mut vec = other.to_vec();
+                        vec.resize(32, 0);
+                        std::borrow::Cow::Owned(vec)
+                    } else {
+                        std::borrow::Cow::Borrowed(other)
+                    };
 
-                        let this = this
-                            .resolve(resolver, context)
-                            .await
-                            .context("Failed to resolve calldata item during equivalence check")?;
-                        let other = U256::from_be_slice(&other);
-                        Ok(this == other)
-                    })
-                    .buffered(0xFF)
-                    .all(|v| async move { v.is_ok_and(|v| v) })
-                    .map(Ok)
-                    .await
+                    let this = this.resolve(resolver, context).await?;
+                    let other = U256::from_be_slice(&other);
+                    if this != other {
+                        return Ok(false);
+                    }
+                }
+                Ok(true)
             }
         }
     }
 }
 
 impl CalldataItem {
-    #[instrument(level = "info", skip_all, err)]
     async fn resolve(
         &self,
         resolver: &impl ResolverApi,
@@ -560,7 +548,14 @@ impl CalldataItem {
         match stack.as_slice() {
             // Empty stack means that we got an empty compound calldata which we resolve to zero.
             [] => Ok(U256::ZERO),
-            [CalldataToken::Item(item)] => Ok(*item),
+            [CalldataToken::Item(item)] => {
+                tracing::debug!(
+                    original = self.0,
+                    resolved = item.to_be_bytes::<32>().encode_hex(),
+                    "Resolved a Calldata item"
+                );
+                Ok(*item)
+            }
             _ => Err(anyhow::anyhow!(
                 "Invalid calldata arithmetic operation - Invalid stack"
             )),
@@ -681,24 +676,17 @@ impl<T: AsRef<str>> CalldataToken<T> {
 
                     let current_block_number = match context.tip_block_number() {
                         Some(block_number) => *block_number,
-                        None => resolver.last_block_number().await.context(
-                            "Failed to query last block number while resolving $BLOCK_HASH",
-                        )?,
+                        None => resolver.last_block_number().await?,
                     };
                     let desired_block_number = current_block_number.saturating_sub(offset);
 
-                    let block_hash = resolver
-                        .block_hash(desired_block_number.into())
-                        .await
-                        .context("Failed to resolve block hash for desired block number")?;
+                    let block_hash = resolver.block_hash(desired_block_number.into()).await?;
 
                     Ok(U256::from_be_bytes(block_hash.0))
                 } else if item == Self::BLOCK_NUMBER_VARIABLE {
                     let current_block_number = match context.tip_block_number() {
                         Some(block_number) => *block_number,
-                        None => resolver.last_block_number().await.context(
-                            "Failed to query last block number while resolving $BLOCK_NUMBER",
-                        )?,
+                        None => resolver.last_block_number().await?,
                     };
                     Ok(U256::from(current_block_number))
                 } else if item == Self::BLOCK_TIMESTAMP_VARIABLE {
@@ -751,14 +739,12 @@ impl<'de> Deserialize<'de> for EtherValue {
 #[cfg(test)]
 mod tests {
 
+    use super::*;
     use alloy::{eips::BlockNumberOrTag, json_abi::JsonAbi};
     use alloy_primitives::{BlockHash, BlockNumber, BlockTimestamp, ChainId, TxHash, address};
     use alloy_sol_types::SolValue;
     use std::collections::HashMap;
 
-    use super::*;
-    use crate::metadata::ContractIdent;
-
     struct MockResolver;
 
     impl ResolverApi for MockResolver {
@@ -832,11 +818,11 @@ mod tests {
         let mut contracts = HashMap::new();
         contracts.insert(
             ContractInstance::new("Contract"),
-            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
+            (Address::ZERO, parsed_abi),
         );
 
         let resolver = MockResolver;
-        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
+        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
         let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
@@ -876,11 +862,11 @@ mod tests {
         let mut contracts = HashMap::new();
         contracts.insert(
             ContractInstance::new("Contract"),
-            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
+            (Address::ZERO, parsed_abi),
         );
 
         let resolver = MockResolver;
-        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
+        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
         let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
@@ -923,11 +909,11 @@ mod tests {
         let mut contracts = HashMap::new();
         contracts.insert(
             ContractInstance::new("Contract"),
-            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
+            (Address::ZERO, parsed_abi),
         );
 
         let resolver = MockResolver;
-        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
+        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
         let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
@@ -941,10 +927,10 @@ mod tests {
 
     async fn resolve_calldata_item(
         input: &str,
-        deployed_contracts: &HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
         resolver: &impl ResolverApi,
     ) -> anyhow::Result<U256> {
-        let context = ResolutionContext::default().with_deployed_contracts(deployed_contracts);
+        let context = ResolutionContext::new_from_parts(deployed_contracts, None, None, None);
         CalldataItem::new(input).resolve(resolver, context).await
     }
 

crates/format/src/metadata.rs

@@ -1,6 +1,6 @@
 use std::{
     cmp::Ordering,
-    collections::BTreeMap,
+    collections::{BTreeMap, HashSet},
     fmt::Display,
     fs::File,
     ops::Deref,
@@ -8,16 +8,17 @@ use std::{
     str::FromStr,
 };
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use revive_common::EVMVersion;
 use revive_dt_common::{
     cached_fs::read_to_string, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
-    types::Mode,
 };
-use tracing::error;
 
-use crate::{case::Case, mode::ParsedMode};
+use crate::{
+    case::Case,
+    mode::{Mode, SolcMode},
+};
 
 pub const METADATA_FILE_EXTENSION: &str = "json";
 pub const SOLIDITY_CASE_FILE_EXTENSION: &str = "sol";
@@ -25,26 +26,16 @@ pub const SOLIDITY_CASE_COMMENT_MARKER: &str = "//!";
 
 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct MetadataFile {
-    /// The path of the metadata file. This will either be a JSON or solidity file.
-    pub metadata_file_path: PathBuf,
-
-    /// This is the path contained within the corpus file. This could either be the path of some dir
-    /// or could be the actual metadata file path.
-    pub corpus_file_path: PathBuf,
-
-    /// The metadata contained within the file.
+    pub path: PathBuf,
     pub content: Metadata,
 }
 
 impl MetadataFile {
-    pub fn relative_path(&self) -> &Path {
-        if self.corpus_file_path.is_file() {
-            &self.corpus_file_path
-        } else {
-            self.metadata_file_path
-                .strip_prefix(&self.corpus_file_path)
-                .unwrap()
-        }
+    pub fn try_from_file(path: &Path) -> Option<Self> {
+        Metadata::try_from_file(path).map(|metadata| Self {
+            path: path.to_owned(),
+            content: metadata,
+        })
     }
 }
 
@@ -76,8 +67,13 @@ pub struct Metadata {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub modes: Option<Vec<ParsedMode>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "deserialize_compilation_modes",
+        serialize_with = "serialize_compilation_modes"
+    )]
+    pub modes: Option<HashSet<Mode>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub file_path: Option<PathBuf>,
@@ -95,12 +91,21 @@ pub struct Metadata {
 }
 
 impl Metadata {
-    /// Returns the modes that we should test from this metadata.
-    pub fn solc_modes(&self) -> Vec<Mode> {
-        match &self.modes {
-            Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
-            None => Mode::all().cloned().collect(),
-        }
+    /// Returns the solc modes of this metadata, inserting a default mode if not present.
+    pub fn solc_modes(&self) -> Vec<SolcMode> {
+        self.modes
+            .to_owned()
+            .unwrap_or_else(|| SolcMode::ALL.map(Mode::Solidity).iter().cloned().collect())
+            .iter()
+            .filter_map(|mode| match mode {
+                Mode::Solidity(solc_mode) => Some(solc_mode),
+                Mode::Unknown(mode) => {
+                    tracing::debug!("compiler: ignoring unknown mode '{mode}'");
+                    None
+                }
+            })
+            .cloned()
+            .collect()
     }
 
     /// Returns the base directory of this metadata.
@@ -132,15 +137,7 @@ impl Metadata {
         ) in contracts
         {
             let alias = alias.clone();
-            let absolute_path = directory
-                .join(contract_source_path)
-                .canonicalize()
-                .map_err(|error| {
-                    anyhow::anyhow!(
-                        "Failed to canonicalize contract source path '{}': {error}",
-                        directory.join(contract_source_path).display()
-                    )
-                })?;
+            let absolute_path = directory.join(contract_source_path).canonicalize()?;
             let contract_ident = contract_ident.clone();
 
             sources.insert(
@@ -164,7 +161,10 @@ impl Metadata {
     pub fn try_from_file(path: &Path) -> Option<Self> {
         assert!(path.is_file(), "not a file: {}", path.display());
 
-        let file_extension = path.extension()?;
+        let Some(file_extension) = path.extension() else {
+            tracing::debug!("skipping corpus file: {}", path.display());
+            return None;
+        };
 
         if file_extension == METADATA_FILE_EXTENSION {
             return Self::try_from_json(path);
@@ -174,12 +174,18 @@ impl Metadata {
             return Self::try_from_solidity(path);
         }
 
+        tracing::debug!("ignoring invalid corpus file: {}", path.display());
         None
     }
 
     fn try_from_json(path: &Path) -> Option<Self> {
         let file = File::open(path)
-            .inspect_err(|err| error!(path = %path.display(), %err, "Failed to open file"))
+            .inspect_err(|error| {
+                tracing::error!(
+                    "opening JSON test metadata file '{}' error: {error}",
+                    path.display()
+                );
+            })
             .ok()?;
 
         match serde_json::from_reader::<_, Metadata>(file) {
@@ -187,8 +193,11 @@ impl Metadata {
                 metadata.file_path = Some(path.to_path_buf());
                 Some(metadata)
             }
-            Err(err) => {
-                error!(path = %path.display(), %err, "Deserialization of metadata failed");
+            Err(error) => {
+                tracing::error!(
+                    "parsing JSON test metadata file '{}' error: {error}",
+                    path.display()
+                );
                 None
             }
         }
@@ -196,7 +205,12 @@ impl Metadata {
 
     fn try_from_solidity(path: &Path) -> Option<Self> {
         let spec = read_to_string(path)
-            .inspect_err(|err| error!(path = %path.display(), %err, "Failed to read file content"))
+            .inspect_err(|error| {
+                tracing::error!(
+                    "opening JSON test metadata file '{}' error: {error}",
+                    path.display()
+                );
+            })
             .ok()?
             .lines()
             .filter_map(|line| line.strip_prefix(SOLIDITY_CASE_COMMENT_MARKER))
@@ -224,8 +238,11 @@ impl Metadata {
                 );
                 Some(metadata)
             }
-            Err(err) => {
-                error!(path = %path.display(), %err, "Failed to deserialize metadata");
+            Err(error) => {
+                tracing::error!(
+                    "parsing Solidity test metadata file '{}' error: '{error}' from data: {spec}",
+                    path.display()
+                );
                 None
             }
         }
@@ -257,6 +274,37 @@ impl Metadata {
     }
 }
 
+pub fn deserialize_compilation_modes<'de, D>(
+    deserializer: D,
+) -> Result<Option<HashSet<Mode>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let maybe_strings = Option::<Vec<String>>::deserialize(deserializer)?;
+    Ok(maybe_strings.map(|strings| {
+        strings
+            .into_iter()
+            .flat_map(Mode::parse_from_string)
+            .collect()
+    }))
+}
+
+pub fn serialize_compilation_modes<S>(
+    value: &Option<HashSet<Mode>>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match value {
+        None => serializer.serialize_none(),
+        Some(modes) => {
+            let strings: Vec<String> = modes.iter().cloned().map(Into::<String>::into).collect();
+            serializer.serialize_some(&strings)
+        }
+    }
+}
+
 define_wrapper_type!(
     /// Represents a contract instance found a metadata file.
     ///
@@ -265,7 +313,7 @@ define_wrapper_type!(
         Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
     )]
     #[serde(transparent)]
-    pub struct ContractInstance(String) impl Display;
+    pub struct ContractInstance(String);
 );
 
 define_wrapper_type!(
@@ -276,7 +324,7 @@ define_wrapper_type!(
         Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
     )]
     #[serde(transparent)]
-    pub struct ContractIdent(String) impl Display;
+    pub struct ContractIdent(String);
 );
 
 /// Represents an identifier used for contracts.

crates/format/src/mode.rs

@@ -1,255 +1,392 @@
-use anyhow::Context;
-use regex::Regex;
-use revive_dt_common::iterators::EitherIter;
-use revive_dt_common::types::{Mode, ModeOptimizerSetting, ModePipeline};
-use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
-use std::fmt::Display;
-use std::str::FromStr;
-use std::sync::LazyLock;
+use std::{fmt::Display, str::FromStr};
 
-/// This represents a mode that has been parsed from test metadata.
+use revive_dt_common::types::VersionOrRequirement;
+use semver::Version;
+use serde::Serialize;
+
+/// Specifies a compilation mode for the test artifact that it requires. This is used as a filter
+/// when used in the [`Metadata`] and is used as a directive when used in the core crate.
 ///
-/// Mode strings can take the following form (in pseudo-regex):
-///
-/// ```text
-/// [YEILV][+-]? (M[0123sz])? <semver>?
-/// ```
-///
-/// We can parse valid mode strings into [`ParsedMode`] using [`ParsedMode::from_str`].
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
-#[serde(try_from = "String", into = "String")]
-pub struct ParsedMode {
-    pub pipeline: Option<ModePipeline>,
-    pub optimize_flag: Option<bool>,
-    pub optimize_setting: Option<ModeOptimizerSetting>,
-    pub version: Option<semver::VersionReq>,
+/// [`Metadata`]: crate::metadata::Metadata
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Mode {
+    /// A compilation mode that's been parsed from a String and into its contents.
+    Solidity(SolcMode),
+    /// An unknown compilation mode.
+    Unknown(String),
 }
 
-impl FromStr for ParsedMode {
-    type Err = anyhow::Error;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        static REGEX: LazyLock<Regex> = LazyLock::new(|| {
-            Regex::new(r"(?x)
-                ^
-                (?:(?P<pipeline>[YEILV])(?P<optimize_flag>[+-])?)? # Pipeline to use eg Y, E+, E-
-                \s*
-                (?P<optimize_setting>M[a-zA-Z0-9])?                # Optimize setting eg M0, Ms, Mz
-                \s*
-                (?P<version>[>=<]*\d+(?:\.\d+)*)?                  # Optional semver version eg >=0.8.0, 0.7, <0.8
-                $
-            ").unwrap()
-        });
-
-        let Some(caps) = REGEX.captures(s) else {
-            anyhow::bail!("Cannot parse mode '{s}' from string");
-        };
-
-        let pipeline = match caps.name("pipeline") {
-            Some(m) => Some(
-                ModePipeline::from_str(m.as_str())
-                    .context("Failed to parse mode pipeline from string")?,
-            ),
-            None => None,
-        };
-
-        let optimize_flag = caps.name("optimize_flag").map(|m| m.as_str() == "+");
-
-        let optimize_setting = match caps.name("optimize_setting") {
-            Some(m) => Some(
-                ModeOptimizerSetting::from_str(m.as_str())
-                    .context("Failed to parse optimizer setting from string")?,
-            ),
-            None => None,
-        };
-
-        let version = match caps.name("version") {
-            Some(m) => Some(
-                semver::VersionReq::parse(m.as_str())
-                    .map_err(|e| {
-                        anyhow::anyhow!(
-                            "Cannot parse the version requirement '{}': {e}",
-                            m.as_str()
-                        )
-                    })
-                    .context("Failed to parse semver requirement from mode string")?,
-            ),
-            None => None,
-        };
-
-        Ok(ParsedMode {
-            pipeline,
-            optimize_flag,
-            optimize_setting,
-            version,
-        })
+impl From<Mode> for String {
+    fn from(value: Mode) -> Self {
+        value.to_string()
     }
 }
 
-impl Display for ParsedMode {
+impl Display for Mode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut has_written = false;
+        match self {
+            Mode::Solidity(mode) => mode.fmt(f),
+            Mode::Unknown(string) => string.fmt(f),
+        }
+    }
+}
 
-        if let Some(pipeline) = self.pipeline {
-            pipeline.fmt(f)?;
-            if let Some(optimize_flag) = self.optimize_flag {
-                f.write_str(if optimize_flag { "+" } else { "-" })?;
+impl Mode {
+    pub fn parse_from_string(str: impl AsRef<str>) -> Vec<Self> {
+        let mut chars = str.as_ref().chars().peekable();
+
+        let compile_via_ir = match chars.next() {
+            Some('Y') => true,
+            Some('E') => false,
+            _ => {
+                tracing::warn!("Encountered an unknown mode {}", str.as_ref());
+                return vec![Self::Unknown(str.as_ref().to_string())];
             }
-            has_written = true;
+        };
+
+        let optimize_flag = match chars.peek() {
+            Some('+') => {
+                let _ = chars.next();
+                Some(true)
+            }
+            Some('-') => {
+                let _ = chars.next();
+                Some(false)
+            }
+            _ => None,
+        };
+
+        let mut chars = chars.skip_while(|char| *char == ' ').peekable();
+
+        let version_requirement = match chars.peek() {
+            Some('=' | '>' | '<' | '~' | '^' | '*' | '0'..='9') => {
+                let version_requirement = chars.take_while(|char| *char != ' ').collect::<String>();
+                let Ok(version_requirement) = VersionOrRequirement::from_str(&version_requirement)
+                else {
+                    return vec![Self::Unknown(str.as_ref().to_string())];
+                };
+                Some(version_requirement)
+            }
+            _ => None,
+        };
+
+        match optimize_flag {
+            Some(flag) => {
+                vec![Self::Solidity(SolcMode {
+                    via_ir: compile_via_ir,
+                    optimize: flag,
+                    compiler_version_requirement: version_requirement,
+                })]
+            }
+            None => {
+                vec![
+                    Self::Solidity(SolcMode {
+                        via_ir: compile_via_ir,
+                        optimize: true,
+                        compiler_version_requirement: version_requirement.clone(),
+                    }),
+                    Self::Solidity(SolcMode {
+                        via_ir: compile_via_ir,
+                        optimize: false,
+                        compiler_version_requirement: version_requirement,
+                    }),
+                ]
+            }
+        }
+    }
+
+    pub fn matches(&self, other: &Self) -> bool {
+        match (self, other) {
+            (
+                Mode::Solidity(SolcMode {
+                    via_ir: self_via_ir,
+                    optimize: self_optimize,
+                    compiler_version_requirement: self_compiler_version_requirement,
+                }),
+                Mode::Solidity(SolcMode {
+                    via_ir: other_via_ir,
+                    optimize: other_optimize,
+                    compiler_version_requirement: other_compiler_version_requirement,
+                }),
+            ) => {
+                let mut matches = true;
+                matches &= self_via_ir == other_via_ir;
+                matches &= self_optimize == other_optimize;
+                match (
+                    self_compiler_version_requirement,
+                    other_compiler_version_requirement,
+                ) {
+                    (
+                        Some(VersionOrRequirement::Version(self_version)),
+                        Some(VersionOrRequirement::Version(other_version)),
+                    ) => {
+                        matches &= self_version == other_version;
+                    }
+                    (
+                        Some(VersionOrRequirement::Version(version)),
+                        Some(VersionOrRequirement::Requirement(requirement)),
+                    )
+                    | (
+                        Some(VersionOrRequirement::Requirement(requirement)),
+                        Some(VersionOrRequirement::Version(version)),
+                    ) => matches &= requirement.matches(version),
+                    (
+                        Some(VersionOrRequirement::Requirement(..)),
+                        Some(VersionOrRequirement::Requirement(..)),
+                    ) => matches = false,
+                    (Some(_), None) | (None, Some(_)) | (None, None) => {}
+                }
+                matches
+            }
+            (Mode::Solidity { .. }, Mode::Unknown(_))
+            | (Mode::Unknown(_), Mode::Solidity { .. })
+            | (Mode::Unknown(_), Mode::Unknown(_)) => false,
+        }
+    }
+
+    pub fn as_solc_mode(&self) -> Option<&SolcMode> {
+        if let Self::Solidity(mode) = self {
+            Some(mode)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+#[serde(into = "String")]
+pub struct SolcMode {
+    pub via_ir: bool,
+    pub optimize: bool,
+    pub compiler_version_requirement: Option<VersionOrRequirement>,
+}
+
+impl SolcMode {
+    pub const ALL: [Self; 4] = [
+        SolcMode {
+            via_ir: false,
+            optimize: false,
+            compiler_version_requirement: None,
+        },
+        SolcMode {
+            via_ir: false,
+            optimize: true,
+            compiler_version_requirement: None,
+        },
+        SolcMode {
+            via_ir: true,
+            optimize: false,
+            compiler_version_requirement: None,
+        },
+        SolcMode {
+            via_ir: true,
+            optimize: true,
+            compiler_version_requirement: None,
+        },
+    ];
+
+    pub fn matches(&self, other: &Self) -> bool {
+        Mode::Solidity(self.clone()).matches(&Mode::Solidity(other.clone()))
+    }
+
+    /// 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.compiler_version_requirement {
+            Some(ref requirement) => requirement.clone(),
+            None => default.into(),
+        }
+    }
+}
+
+impl Display for SolcMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let Self {
+            via_ir,
+            optimize,
+            compiler_version_requirement,
+        } = self;
+
+        if *via_ir {
+            write!(f, "Y")?;
+        } else {
+            write!(f, "E")?;
         }
 
-        if let Some(optimize_setting) = self.optimize_setting {
-            if has_written {
-                f.write_str(" ")?;
-            }
-            optimize_setting.fmt(f)?;
-            has_written = true;
+        if *optimize {
+            write!(f, "+")?;
+        } else {
+            write!(f, "-")?;
         }
 
-        if let Some(version) = &self.version {
-            if has_written {
-                f.write_str(" ")?;
-            }
-            version.fmt(f)?;
+        if let Some(req) = compiler_version_requirement {
+            write!(f, " {req}")?;
         }
 
         Ok(())
     }
 }
 
-impl From<ParsedMode> for String {
-    fn from(parsed_mode: ParsedMode) -> Self {
-        parsed_mode.to_string()
-    }
-}
-
-impl TryFrom<String> for ParsedMode {
-    type Error = anyhow::Error;
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        ParsedMode::from_str(&value)
-    }
-}
-
-impl ParsedMode {
-    /// This takes a [`ParsedMode`] and expands it into a list of [`Mode`]s that we should try.
-    pub fn to_modes(&self) -> impl Iterator<Item = Mode> {
-        let pipeline_iter = self.pipeline.as_ref().map_or_else(
-            || EitherIter::A(ModePipeline::test_cases()),
-            |p| EitherIter::B(std::iter::once(*p)),
-        );
-
-        let optimize_flag_setting = self.optimize_flag.map(|flag| {
-            if flag {
-                ModeOptimizerSetting::M3
-            } else {
-                ModeOptimizerSetting::M0
-            }
-        });
-
-        let optimize_flag_iter = match optimize_flag_setting {
-            Some(setting) => EitherIter::A(std::iter::once(setting)),
-            None => EitherIter::B(ModeOptimizerSetting::test_cases()),
-        };
-
-        let optimize_settings_iter = self.optimize_setting.as_ref().map_or_else(
-            || EitherIter::A(optimize_flag_iter),
-            |s| EitherIter::B(std::iter::once(*s)),
-        );
-
-        pipeline_iter.flat_map(move |pipeline| {
-            optimize_settings_iter
-                .clone()
-                .map(move |optimize_setting| Mode {
-                    pipeline,
-                    optimize_setting,
-                    version: self.version.clone(),
-                })
-        })
-    }
-
-    /// Return a set of [`Mode`]s that correspond to the given [`ParsedMode`]s.
-    /// This avoids any duplicate entries.
-    pub fn many_to_modes<'a>(
-        parsed: impl Iterator<Item = &'a ParsedMode>,
-    ) -> impl Iterator<Item = Mode> {
-        let modes: HashSet<_> = parsed.flat_map(|p| p.to_modes()).collect();
-        modes.into_iter()
+impl From<SolcMode> for String {
+    fn from(value: SolcMode) -> Self {
+        value.to_string()
     }
 }
 
 #[cfg(test)]
-mod tests {
+mod test {
+    use semver::Version;
+
     use super::*;
 
     #[test]
-    fn test_parsed_mode_from_str() {
-        let strings = vec![
-            ("Mz", "Mz"),
-            ("Y", "Y"),
-            ("Y+", "Y+"),
-            ("Y-", "Y-"),
-            ("E", "E"),
-            ("E+", "E+"),
-            ("E-", "E-"),
-            ("Y M0", "Y M0"),
-            ("Y M1", "Y M1"),
-            ("Y M2", "Y M2"),
-            ("Y M3", "Y M3"),
-            ("Y Ms", "Y Ms"),
-            ("Y Mz", "Y Mz"),
-            ("E M0", "E M0"),
-            ("E M1", "E M1"),
-            ("E M2", "E M2"),
-            ("E M3", "E M3"),
-            ("E Ms", "E Ms"),
-            ("E Mz", "E Mz"),
-            // When stringifying semver again, 0.8.0 becomes ^0.8.0 (same meaning)
-            ("Y 0.8.0", "Y ^0.8.0"),
-            ("E+ 0.8.0", "E+ ^0.8.0"),
-            ("Y M3 >=0.8.0", "Y M3 >=0.8.0"),
-            ("E Mz <0.7.0", "E Mz <0.7.0"),
-            // We can parse +- _and_ M1/M2 but the latter takes priority.
-            ("Y+ M1 0.8.0", "Y+ M1 ^0.8.0"),
-            ("E- M2 0.7.0", "E- M2 ^0.7.0"),
-            // We don't see this in the wild but it is parsed.
-            ("<=0.8", "<=0.8"),
+    fn mode_can_be_parsed_as_expected() {
+        // Arrange
+        let fixtures = [
+            (
+                "Y",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: true,
+                        compiler_version_requirement: None,
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: false,
+                        compiler_version_requirement: None,
+                    }),
+                ],
+            ),
+            (
+                "Y+",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: true,
+                    optimize: true,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "Y-",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: true,
+                    optimize: false,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "E",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: false,
+                        optimize: true,
+                        compiler_version_requirement: None,
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: false,
+                        optimize: false,
+                        compiler_version_requirement: None,
+                    }),
+                ],
+            ),
+            (
+                "E+",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: false,
+                    optimize: true,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "E-",
+                vec![Mode::Solidity(SolcMode {
+                    via_ir: false,
+                    optimize: false,
+                    compiler_version_requirement: None,
+                })],
+            ),
+            (
+                "Y >=0.8.3",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: true,
+                        compiler_version_requirement: Some(VersionOrRequirement::Requirement(
+                            ">=0.8.3".parse().unwrap(),
+                        )),
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: false,
+                        compiler_version_requirement: Some(VersionOrRequirement::Requirement(
+                            ">=0.8.3".parse().unwrap(),
+                        )),
+                    }),
+                ],
+            ),
+            (
+                "Y 0.8.3",
+                vec![
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: true,
+                        compiler_version_requirement: Some(VersionOrRequirement::Version(
+                            Version {
+                                major: 0,
+                                minor: 8,
+                                patch: 3,
+                                pre: Default::default(),
+                                build: Default::default(),
+                            },
+                        )),
+                    }),
+                    Mode::Solidity(SolcMode {
+                        via_ir: true,
+                        optimize: false,
+                        compiler_version_requirement: Some(VersionOrRequirement::Version(
+                            Version {
+                                major: 0,
+                                minor: 8,
+                                patch: 3,
+                                pre: Default::default(),
+                                build: Default::default(),
+                            },
+                        )),
+                    }),
+                ],
+            ),
         ];
 
-        for (actual, expected) in strings {
-            let parsed = ParsedMode::from_str(actual)
-                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
+        for (string, expectation) in fixtures {
+            // Act
+            let actual = Mode::parse_from_string(string);
+
+            // Assert
             assert_eq!(
-                expected,
-                parsed.to_string(),
-                "Mode string '{actual}' did not parse to '{expected}': got '{parsed}'"
-            );
+                actual, expectation,
+                "Parsed {string} into {actual:?} but expected {expectation:?}"
+            )
         }
     }
 
     #[test]
-    fn test_parsed_mode_to_test_modes() {
-        let strings = vec![
-            ("Mz", vec!["Y Mz", "E Mz"]),
-            ("Y", vec!["Y M0", "Y M3"]),
-            ("E", vec!["E M0", "E M3"]),
-            ("Y+", vec!["Y M3"]),
-            ("Y-", vec!["Y M0"]),
-            ("Y <=0.8", vec!["Y M0 <=0.8", "Y M3 <=0.8"]),
-            (
-                "<=0.8",
-                vec!["Y M0 <=0.8", "Y M3 <=0.8", "E M0 <=0.8", "E M3 <=0.8"],
-            ),
-        ];
+    #[allow(clippy::uninlined_format_args)]
+    fn mode_matches_as_expected() {
+        // Arrange
+        let fixtures = [("Y+", "Y+", true), ("Y+ >=0.8.3", "Y+", true)];
 
-        for (actual, expected) in strings {
-            let parsed = ParsedMode::from_str(actual)
-                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
-            let expected_set: HashSet<_> = expected.into_iter().map(|s| s.to_owned()).collect();
-            let actual_set: HashSet<_> = parsed.to_modes().map(|m| m.to_string()).collect();
+        for (self_mode, other_mode, expected_result) in fixtures {
+            let self_mode = Mode::parse_from_string(self_mode).pop().unwrap();
+            let other_mode = Mode::parse_from_string(other_mode).pop().unwrap();
 
+            // Act
+            let actual = self_mode.matches(&other_mode);
+
+            // Assert
             assert_eq!(
-                expected_set, actual_set,
-                "Mode string '{actual}' did not expand to '{expected_set:?}': got '{actual_set:?}'"
+                actual, expected_result,
+                "Match of {} and {} failed. Expected {} but got {}",
+                self_mode, other_mode, expected_result, actual
             );
         }
     }

crates/format/src/traits.rs

@@ -6,7 +6,7 @@ use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId
 use alloy_primitives::TxHash;
 use anyhow::Result;
 
-use crate::metadata::{ContractIdent, ContractInstance};
+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.
@@ -48,7 +48,7 @@ pub trait ResolverApi {
 /// Contextual information required by the code that's performing the resolution.
 pub struct ResolutionContext<'a> {
     /// When provided the contracts provided here will be used for resolutions.
-    deployed_contracts: Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+    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>>,
@@ -66,9 +66,7 @@ impl<'a> ResolutionContext<'a> {
     }
 
     pub fn new_from_parts(
-        deployed_contracts: impl Into<
-            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-        >,
+        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>>,
@@ -83,9 +81,7 @@ impl<'a> ResolutionContext<'a> {
 
     pub fn with_deployed_contracts(
         mut self,
-        deployed_contracts: impl Into<
-            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
-        >,
+        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
     ) -> Self {
         self.deployed_contracts = deployed_contracts.into();
         self
@@ -126,20 +122,17 @@ impl<'a> ResolutionContext<'a> {
         }
     }
 
-    pub fn deployed_contract(
-        &self,
-        instance: &ContractInstance,
-    ) -> Option<&(ContractIdent, Address, JsonAbi)> {
+    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)
+        self.deployed_contract(instance).map(|(a, _)| a)
     }
 
     pub fn deployed_contract_abi(&self, instance: &ContractInstance) -> Option<&JsonAbi> {
-        self.deployed_contract(instance).map(|(_, _, a)| a)
+        self.deployed_contract(instance).map(|(_, a)| a)
     }
 
     pub fn variable(&self, name: impl AsRef<str>) -> Option<&U256> {

crates/node-interaction/Cargo.toml

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

crates/node/Cargo.toml

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

crates/node/src/geth.rs

@@ -33,12 +33,9 @@ use alloy::{
 };
 use anyhow::Context;
 use revive_common::EVMVersion;
-use tracing::{Instrument, instrument};
+use tracing::Instrument;
 
-use revive_dt_common::{
-    fs::clear_directory,
-    futures::{PollingWaitBehavior, poll},
-};
+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;
@@ -51,11 +48,10 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Implements helpers to initialize, spawn and wait the node.
 ///
-/// Assumes dev mode and IPC only (`P2P`, `http`` etc. are kept disabled).
+/// Assumes dev mode and IPC only (`P2P`, `http` etc. are kept disabled).
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
-#[allow(clippy::type_complexity)]
 pub struct GethNode {
     connection_string: String,
     base_directory: PathBuf,
@@ -64,10 +60,10 @@ pub struct GethNode {
     geth: PathBuf,
     id: u32,
     handle: Option<Child>,
+    network_id: u64,
     start_timeout: u64,
-    wallet: Arc<EthereumWallet>,
+    wallet: EthereumWallet,
     nonce_manager: CachedNonceManager,
-    chain_id_filler: ChainIdFiller,
     /// This vector stores [`File`] objects that we use for logging which we want to flush when the
     /// node object is dropped. We do not store them in a structured fashion at the moment (in
     /// separate fields) as the logic that we need to apply to them is all the same regardless of
@@ -96,18 +92,15 @@ impl GethNode {
     const TRACE_POLLING_DURATION: Duration = Duration::from_secs(60);
 
     /// Create the node directory and call `geth init` to configure the genesis.
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
-        create_dir_all(&self.base_directory)
-            .context("Failed to create base directory for geth node")?;
-        create_dir_all(&self.logs_directory)
-            .context("Failed to create logs directory for geth node")?;
+        create_dir_all(&self.base_directory)?;
+        create_dir_all(&self.logs_directory)?;
 
-        let mut genesis = serde_json::from_str::<Genesis>(&genesis)
-            .context("Failed to deserialize geth genesis JSON")?;
+        let mut genesis = serde_json::from_str::<Genesis>(&genesis)?;
         for signer_address in
             <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
         {
@@ -119,11 +112,7 @@ impl GethNode {
                 .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
         }
         let genesis_path = self.base_directory.join(Self::GENESIS_JSON_FILE);
-        serde_json::to_writer(
-            File::create(&genesis_path).context("Failed to create geth genesis file")?,
-            &genesis,
-        )
-        .context("Failed to serialize geth genesis JSON to file")?;
+        serde_json::to_writer(File::create(&genesis_path)?, &genesis)?;
 
         let mut child = Command::new(&self.geth)
             .arg("--state.scheme")
@@ -134,22 +123,16 @@ impl GethNode {
             .arg(genesis_path)
             .stderr(Stdio::piped())
             .stdout(Stdio::null())
-            .spawn()
-            .context("Failed to spawn geth --init process")?;
+            .spawn()?;
 
         let mut stderr = String::new();
         child
             .stderr
             .take()
             .expect("should be piped")
-            .read_to_string(&mut stderr)
-            .context("Failed to read geth --init stderr")?;
+            .read_to_string(&mut stderr)?;
 
-        if !child
-            .wait()
-            .context("Failed waiting for geth --init process to finish")?
-            .success()
-        {
+        if !child.wait()?.success() {
             anyhow::bail!("failed to initialize geth node #{:?}: {stderr}", &self.id);
         }
 
@@ -159,7 +142,7 @@ impl GethNode {
     /// Spawn the go-ethereum node child process.
     ///
     /// [Instance::init] must be called prior.
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn spawn_process(&mut self) -> anyhow::Result<&mut Self> {
         // This is the `OpenOptions` that we wish to use for all of the log files that we will be
         // opening in this method. We need to construct it in this way to:
@@ -174,17 +157,16 @@ impl GethNode {
 
         let stdout_logs_file = open_options
             .clone()
-            .open(self.geth_stdout_log_file_path())
-            .context("Failed to open geth stdout logs file")?;
-        let stderr_logs_file = open_options
-            .open(self.geth_stderr_log_file_path())
-            .context("Failed to open geth stderr logs file")?;
+            .open(self.geth_stdout_log_file_path())?;
+        let stderr_logs_file = open_options.open(self.geth_stderr_log_file_path())?;
         self.handle = Command::new(&self.geth)
             .arg("--dev")
             .arg("--datadir")
             .arg(&self.data_directory)
             .arg("--ipcpath")
             .arg(&self.connection_string)
+            .arg("--networkid")
+            .arg(self.network_id.to_string())
             .arg("--nodiscover")
             .arg("--maxpeers")
             .arg("0")
@@ -198,24 +180,14 @@ impl GethNode {
             .arg("full")
             .arg("--gcmode")
             .arg("archive")
-            .stderr(
-                stderr_logs_file
-                    .try_clone()
-                    .context("Failed to clone geth stderr log file handle")?,
-            )
-            .stdout(
-                stdout_logs_file
-                    .try_clone()
-                    .context("Failed to clone geth stdout log file handle")?,
-            )
-            .spawn()
-            .context("Failed to spawn geth node process")?
+            .stderr(stderr_logs_file.try_clone()?)
+            .stdout(stdout_logs_file.try_clone()?)
+            .spawn()?
             .into();
 
         if let Err(error) = self.wait_ready() {
             tracing::error!(?error, "Failed to start geth, shutting down gracefully");
-            self.shutdown()
-                .context("Failed to gracefully shutdown after geth start error")?;
+            self.shutdown()?;
             return Err(error);
         }
 
@@ -228,7 +200,7 @@ impl GethNode {
     /// Wait for the g-ethereum node child process getting ready.
     ///
     /// [Instance::spawn_process] must be called priorly.
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn wait_ready(&mut self) -> anyhow::Result<&mut Self> {
         let start_time = Instant::now();
 
@@ -237,12 +209,10 @@ impl GethNode {
             .write(false)
             .append(false)
             .truncate(false)
-            .open(self.geth_stderr_log_file_path())
-            .context("Failed to open geth stderr logs file for readiness check")?;
+            .open(self.geth_stderr_log_file_path())?;
 
         let maximum_wait_time = Duration::from_millis(self.start_timeout);
         let mut stderr = BufReader::new(logs_file).lines();
-        let mut lines = vec![];
         loop {
             if let Some(Ok(line)) = stderr.next() {
                 if line.contains(Self::ERROR_MARKER) {
@@ -251,72 +221,69 @@ impl GethNode {
                 if line.contains(Self::READY_MARKER) {
                     return Ok(self);
                 }
-                lines.push(line);
             }
             if Instant::now().duration_since(start_time) > maximum_wait_time {
-                anyhow::bail!(
-                    "Timeout in starting geth: took longer than {}ms. stdout:\n\n{}\n",
-                    self.start_timeout,
-                    lines.join("\n")
-                );
+                anyhow::bail!("Timeout in starting geth");
             }
         }
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = "trace")]
     fn geth_stdout_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::GETH_STDOUT_LOG_FILE_NAME)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = "trace")]
     fn geth_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
     }
 
-    async fn provider(
+    fn provider(
         &self,
-    ) -> anyhow::Result<FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>>
-    {
-        ProviderBuilder::new()
-            .disable_recommended_fillers()
-            .filler(FallbackGasFiller::new(
-                25_000_000,
-                1_000_000_000,
-                1_000_000_000,
-            ))
-            .filler(self.chain_id_filler.clone())
-            .filler(NonceFiller::new(self.nonce_manager.clone()))
-            .wallet(self.wallet.clone())
-            .connect(&self.connection_string)
-            .await
-            .map_err(Into::into)
+    ) -> impl Future<
+        Output = anyhow::Result<
+            FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>,
+        >,
+    > + 'static {
+        let connection_string = self.connection_string();
+        let wallet = self.wallet.clone();
+
+        // Note: We would like all providers to make use of the same nonce manager so that we have
+        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
+        // its implementation and therefore it means that when we clone it then it still references
+        // the same state.
+        let nonce_manager = self.nonce_manager.clone();
+
+        Box::pin(async move {
+            ProviderBuilder::new()
+                .disable_recommended_fillers()
+                .filler(FallbackGasFiller::new(
+                    25_000_000,
+                    100_000_000_000,
+                    1_000_000_000,
+                ))
+                .filler(ChainIdFiller::default())
+                .filler(NonceFiller::new(nonce_manager))
+                .wallet(wallet)
+                .connect(&connection_string)
+                .await
+                .map_err(Into::into)
+                .inspect_err(|err| tracing::error!(%err, "Failed to create the alloy provider"))
+        })
     }
 }
 
 impl EthereumNode for GethNode {
-    #[instrument(
-        level = "info",
-        skip_all,
-        fields(geth_node_id = self.id, connection_string = self.connection_string),
-        err,
-    )]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn execute_transaction(
         &self,
         transaction: TransactionRequest,
     ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let provider = self
-            .provider()
-            .await
-            .context("Failed to create provider for transaction submission")?;
+        let span = tracing::debug_span!("Submitting transaction", ?transaction);
+        let _guard = span.enter();
 
-        let pending_transaction = provider
-            .send_transaction(transaction)
-            .await
-            .inspect_err(
-                |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
-            )
-            .context("Failed to submit transaction to geth node")?;
-        let transaction_hash = *pending_transaction.tx_hash();
+        let provider = self.provider().await.map(Arc::new)?;
+        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
@@ -330,15 +297,14 @@ impl EthereumNode for GethNode {
         // 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
+        // Getting the transaction indexed and taking a receipt can take a long time especially
+        // when a lot of transactions are being submitted to the node. Thus, while initially we only
         // allowed for 60 seconds of waiting with a 1 second delay in polling, we need to allow for
         // a larger wait time. Therefore, in here we allow for 5 minutes of waiting with exponential
         // backoff each time we attempt to get the receipt and find that it's not available.
-        let provider = Arc::new(provider);
         poll(
             Self::RECEIPT_POLLING_DURATION,
-            PollingWaitBehavior::Constant(Duration::from_millis(200)),
+            Default::default(),
             move || {
                 let provider = provider.clone();
                 async move {
@@ -361,22 +327,19 @@ impl EthereumNode for GethNode {
             ?transaction_hash
         ))
         .await
+        .inspect(|receipt| tracing::info!(gas_used = receipt.gas_used, "Gas used on transaction"))
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let provider = Arc::new(
-            self.provider()
-                .await
-                .context("Failed to create provider for tracing")?,
-        );
+        let provider = Arc::new(self.provider().await?);
         poll(
             Self::TRACE_POLLING_DURATION,
-            PollingWaitBehavior::Constant(Duration::from_millis(200)),
+            Default::default(),
             move || {
                 let provider = provider.clone();
                 let trace_options = trace_options.clone();
@@ -400,7 +363,7 @@ impl EthereumNode for GethNode {
         .await
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
@@ -409,35 +372,31 @@ impl EthereumNode for GethNode {
         });
         match self
             .trace_transaction(transaction, trace_options)
-            .await
-            .context("Failed to trace transaction for prestate diff")?
-            .try_into_pre_state_frame()
-            .context("Failed to convert trace into pre-state frame")?
+            .await?
+            .try_into_pre_state_frame()?
         {
             PreStateFrame::Diff(diff) => Ok(diff),
             _ => anyhow::bail!("expected a diff mode trace"),
         }
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_balance(address)
             .await
             .map_err(Into::into)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn latest_state_proof(
         &self,
         address: Address,
         keys: Vec<StorageKey>,
     ) -> anyhow::Result<EIP1186AccountProofResponse> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_proof(address, keys)
             .latest()
             .await
@@ -446,72 +405,62 @@ impl EthereumNode for GethNode {
 }
 
 impl ResolverApi for GethNode {
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_chain_id()
             .await
             .map_err(Into::into)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_transaction_receipt(*tx_hash)
             .await?
             .context("Failed to get the transaction receipt")
             .map(|receipt| receipt.effective_gas_price)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.gas_limit as _)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.beneficiary)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .and_then(|block| {
                 block
                     .header
@@ -520,35 +469,30 @@ impl ResolverApi for GethNode {
             })
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
-            .await
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.hash)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the geth block")?
-            .context("Failed to get the Geth block, perhaps there are no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.timestamp)
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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
-            .context("Failed to get the Geth provider")?
+            .await?
             .get_block_number()
             .await
             .map_err(Into::into)
@@ -578,27 +522,22 @@ impl Node for GethNode {
             geth: config.geth.clone(),
             id,
             handle: None,
+            network_id: config.network_id,
             start_timeout: config.geth_start_timeout,
-            wallet: Arc::new(wallet),
-            chain_id_filler: Default::default(),
-            nonce_manager: Default::default(),
+            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(),
         }
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-    fn id(&self) -> usize {
-        self.id as _
-    }
-
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn connection_string(&self) -> String {
         self.connection_string.clone()
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn shutdown(&mut self) -> anyhow::Result<()> {
         // Terminate the processes in a graceful manner to allow for the output to be flushed.
         if let Some(mut child) = self.handle.take() {
@@ -620,28 +559,27 @@ impl Node for GethNode {
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
         self.init(genesis)?.spawn_process()?;
         Ok(())
     }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.geth)
             .arg("--version")
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::null())
-            .spawn()
-            .context("Failed to spawn geth --version process")?
-            .wait_with_output()
-            .context("Failed to wait for geth --version output")?
+            .spawn()?
+            .wait_with_output()?
             .stdout;
         Ok(String::from_utf8_lossy(&output).into())
     }
 
-    fn matches_target(targets: Option<&[String]>) -> bool {
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    fn matches_target(&self, targets: Option<&[String]>) -> bool {
         match targets {
             None => true,
             Some(targets) => targets.iter().any(|str| str.as_str() == "evm"),
@@ -654,7 +592,7 @@ impl Node for GethNode {
 }
 
 impl Drop for GethNode {
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn drop(&mut self) {
         self.shutdown().expect("Failed to shutdown")
     }

crates/node/src/kitchensink.rs

@@ -3,10 +3,7 @@ use std::{
     io::{BufRead, Write},
     path::{Path, PathBuf},
     process::{Child, Command, Stdio},
-    sync::{
-        Arc,
-        atomic::{AtomicU32, Ordering},
-    },
+    sync::atomic::{AtomicU32, Ordering},
     time::Duration,
 };
 
@@ -42,6 +39,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Value as JsonValue, json};
 use sp_core::crypto::Ss58Codec;
 use sp_runtime::AccountId32;
+use tracing::Level;
 
 use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;
@@ -54,17 +52,14 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 pub struct KitchensinkNode {
     id: u32,
     substrate_binary: PathBuf,
-    dev_node_binary: PathBuf,
     eth_proxy_binary: PathBuf,
     rpc_url: String,
+    wallet: EthereumWallet,
     base_directory: PathBuf,
     logs_directory: PathBuf,
     process_substrate: Option<Child>,
     process_proxy: Option<Child>,
-    wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
-    chain_id_filler: ChainIdFiller,
-    use_kitchensink_not_dev_node: bool,
     /// This vector stores [`File`] objects that we use for logging which we want to flush when the
     /// node object is dropped. We do not store them in a structured fashion at the moment (in
     /// separate fields) as the logic that we need to apply to them is all the same regardless of
@@ -92,34 +87,23 @@ impl KitchensinkNode {
     const PROXY_STDOUT_LOG_FILE_NAME: &str = "proxy_stdout.log";
     const PROXY_STDERR_LOG_FILE_NAME: &str = "proxy_stderr.log";
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
     fn init(&mut self, genesis: &str) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
-        create_dir_all(&self.base_directory)
-            .context("Failed to create base directory for kitchensink node")?;
-        create_dir_all(&self.logs_directory)
-            .context("Failed to create logs directory for kitchensink node")?;
+        create_dir_all(&self.base_directory)?;
+        create_dir_all(&self.logs_directory)?;
 
         let template_chainspec_path = self.base_directory.join(Self::CHAIN_SPEC_JSON_FILE);
 
         // Note: we do not pipe the logs of this process to a separate file since this is just a
         // once-off export of the default chain spec and not part of the long-running node process.
-        let output = if self.use_kitchensink_not_dev_node {
-            Command::new(&self.substrate_binary)
-                .arg("export-chain-spec")
-                .arg("--chain")
-                .arg("dev")
-                .output()
-                .context("Failed to export the chain-spec")?
-        } else {
-            Command::new(&self.dev_node_binary)
-                .arg("build-spec")
-                .arg("--chain")
-                .arg("dev")
-                .output()
-                .context("Failed to export the chain-spec")?
-        };
+        let output = Command::new(&self.substrate_binary)
+            .arg("export-chain-spec")
+            .arg("--chain")
+            .arg("dev")
+            .output()?;
 
         if !output.status.success() {
             anyhow::bail!(
@@ -128,10 +112,8 @@ impl KitchensinkNode {
             );
         }
 
-        let content = String::from_utf8(output.stdout)
-            .context("Failed to decode substrate export-chain-spec output as UTF-8")?;
-        let mut chainspec_json: JsonValue =
-            serde_json::from_str(&content).context("Failed to parse substrate chain spec JSON")?;
+        let content = String::from_utf8(output.stdout)?;
+        let mut chainspec_json: JsonValue = serde_json::from_str(&content)?;
 
         let existing_chainspec_balances =
             chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
@@ -153,8 +135,7 @@ impl KitchensinkNode {
             })
             .collect();
         let mut eth_balances = {
-            let mut genesis = serde_json::from_str::<Genesis>(genesis)
-                .context("Failed to deserialize EVM genesis JSON for kitchensink")?;
+            let mut genesis = serde_json::from_str::<Genesis>(genesis)?;
             for signer_address in
                 <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
             {
@@ -165,8 +146,7 @@ impl KitchensinkNode {
                     .entry(signer_address)
                     .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
             }
-            self.extract_balance_from_genesis_file(&genesis)
-                .context("Failed to extract balances from EVM genesis JSON")?
+            self.extract_balance_from_genesis_file(&genesis)?
         };
         merged_balances.append(&mut eth_balances);
 
@@ -174,14 +154,13 @@ impl KitchensinkNode {
             json!(merged_balances);
 
         serde_json::to_writer_pretty(
-            std::fs::File::create(&template_chainspec_path)
-                .context("Failed to create kitchensink template chainspec file")?,
+            std::fs::File::create(&template_chainspec_path)?,
             &chainspec_json,
-        )
-        .context("Failed to write kitchensink template chainspec JSON")?;
+        )?;
         Ok(self)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn spawn_process(&mut self) -> anyhow::Result<()> {
         let substrate_rpc_port = Self::BASE_SUBSTRATE_RPC_PORT + self.id as u16;
         let proxy_rpc_port = Self::BASE_PROXY_RPC_PORT + self.id as u16;
@@ -204,18 +183,11 @@ impl KitchensinkNode {
         // Start Substrate node
         let kitchensink_stdout_logs_file = open_options
             .clone()
-            .open(self.kitchensink_stdout_log_file_path())
-            .context("Failed to open kitchensink stdout logs file")?;
+            .open(self.kitchensink_stdout_log_file_path())?;
         let kitchensink_stderr_logs_file = open_options
             .clone()
-            .open(self.kitchensink_stderr_log_file_path())
-            .context("Failed to open kitchensink stderr logs file")?;
-        let node_binary_path = if self.use_kitchensink_not_dev_node {
-            self.substrate_binary.as_path()
-        } else {
-            self.dev_node_binary.as_path()
-        };
-        self.process_substrate = Command::new(node_binary_path)
+            .open(self.kitchensink_stderr_log_file_path())?;
+        self.process_substrate = Command::new(&self.substrate_binary)
             .arg("--dev")
             .arg("--chain")
             .arg(chainspec_path)
@@ -230,21 +202,10 @@ impl KitchensinkNode {
             .arg("Unsafe")
             .arg("--rpc-cors")
             .arg("all")
-            .arg("--rpc-max-connections")
-            .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::SUBSTRATE_LOG_ENV)
-            .stdout(
-                kitchensink_stdout_logs_file
-                    .try_clone()
-                    .context("Failed to clone kitchensink stdout log file handle")?,
-            )
-            .stderr(
-                kitchensink_stderr_logs_file
-                    .try_clone()
-                    .context("Failed to clone kitchensink stderr log file handle")?,
-            )
-            .spawn()
-            .context("Failed to spawn substrate node process")?
+            .stdout(kitchensink_stdout_logs_file.try_clone()?)
+            .stderr(kitchensink_stderr_logs_file.try_clone()?)
+            .spawn()?
             .into();
 
         // Give the node a moment to boot
@@ -253,39 +214,28 @@ impl KitchensinkNode {
             Self::SUBSTRATE_READY_MARKER,
             Duration::from_secs(60),
         ) {
-            self.shutdown()
-                .context("Failed to gracefully shutdown after substrate start error")?;
+            tracing::error!(
+                ?error,
+                "Failed to start substrate, shutting down gracefully"
+            );
+            self.shutdown()?;
             return Err(error);
         };
 
         let eth_proxy_stdout_logs_file = open_options
             .clone()
-            .open(self.proxy_stdout_log_file_path())
-            .context("Failed to open eth-proxy stdout logs file")?;
-        let eth_proxy_stderr_logs_file = open_options
-            .open(self.proxy_stderr_log_file_path())
-            .context("Failed to open eth-proxy stderr logs file")?;
+            .open(self.proxy_stdout_log_file_path())?;
+        let eth_proxy_stderr_logs_file = open_options.open(self.proxy_stderr_log_file_path())?;
         self.process_proxy = Command::new(&self.eth_proxy_binary)
             .arg("--dev")
             .arg("--rpc-port")
             .arg(proxy_rpc_port.to_string())
             .arg("--node-rpc-url")
             .arg(format!("ws://127.0.0.1:{substrate_rpc_port}"))
-            .arg("--rpc-max-connections")
-            .arg(u32::MAX.to_string())
             .env("RUST_LOG", Self::PROXY_LOG_ENV)
-            .stdout(
-                eth_proxy_stdout_logs_file
-                    .try_clone()
-                    .context("Failed to clone eth-proxy stdout log file handle")?,
-            )
-            .stderr(
-                eth_proxy_stderr_logs_file
-                    .try_clone()
-                    .context("Failed to clone eth-proxy stderr log file handle")?,
-            )
-            .spawn()
-            .context("Failed to spawn eth-proxy process")?
+            .stdout(eth_proxy_stdout_logs_file.try_clone()?)
+            .stderr(eth_proxy_stderr_logs_file.try_clone()?)
+            .spawn()?
             .into();
 
         if let Err(error) = Self::wait_ready(
@@ -293,8 +243,8 @@ impl KitchensinkNode {
             Self::ETH_PROXY_READY_MARKER,
             Duration::from_secs(60),
         ) {
-            self.shutdown()
-                .context("Failed to gracefully shutdown after eth-proxy start error")?;
+            tracing::error!(?error, "Failed to start proxy, shutting down gracefully");
+            self.shutdown()?;
             return Err(error);
         };
 
@@ -308,6 +258,7 @@ impl KitchensinkNode {
         Ok(())
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn extract_balance_from_genesis_file(
         &self,
         genesis: &Genesis,
@@ -356,6 +307,7 @@ impl KitchensinkNode {
         }
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     pub fn eth_rpc_version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.eth_proxy_binary)
             .arg("--version")
@@ -368,82 +320,100 @@ impl KitchensinkNode {
         Ok(String::from_utf8_lossy(&output).trim().to_string())
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn kitchensink_stdout_log_file_path(&self) -> PathBuf {
         self.logs_directory
             .join(Self::KITCHENSINK_STDOUT_LOG_FILE_NAME)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn kitchensink_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory
             .join(Self::KITCHENSINK_STDERR_LOG_FILE_NAME)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn proxy_stdout_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::PROXY_STDOUT_LOG_FILE_NAME)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), level = Level::TRACE)]
     fn proxy_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::PROXY_STDERR_LOG_FILE_NAME)
     }
 
-    async fn provider(
+    fn provider(
         &self,
-    ) -> anyhow::Result<
-        FillProvider<
-            impl TxFiller<KitchenSinkNetwork>,
-            impl Provider<KitchenSinkNetwork>,
-            KitchenSinkNetwork,
+    ) -> impl Future<
+        Output = anyhow::Result<
+            FillProvider<
+                impl TxFiller<KitchenSinkNetwork>,
+                impl Provider<KitchenSinkNetwork>,
+                KitchenSinkNetwork,
+            >,
         >,
-    > {
-        ProviderBuilder::new()
-            .disable_recommended_fillers()
-            .network::<KitchenSinkNetwork>()
-            .filler(FallbackGasFiller::new(
-                25_000_000,
-                1_000_000_000,
-                1_000_000_000,
-            ))
-            .filler(self.chain_id_filler.clone())
-            .filler(NonceFiller::new(self.nonce_manager.clone()))
-            .wallet(self.wallet.clone())
-            .connect(&self.rpc_url)
-            .await
-            .map_err(Into::into)
+    > + 'static {
+        let connection_string = self.connection_string();
+        let wallet = self.wallet.clone();
+
+        // Note: We would like all providers to make use of the same nonce manager so that we have
+        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
+        // its implementation and therefore it means that when we clone it then it still references
+        // the same state.
+        let nonce_manager = self.nonce_manager.clone();
+
+        Box::pin(async move {
+            ProviderBuilder::new()
+                .disable_recommended_fillers()
+                .network::<KitchenSinkNetwork>()
+                .filler(FallbackGasFiller::new(
+                    30_000_000,
+                    200_000_000_000,
+                    3_000_000_000,
+                ))
+                .filler(ChainIdFiller::default())
+                .filler(NonceFiller::new(nonce_manager))
+                .wallet(wallet)
+                .connect(&connection_string)
+                .await
+                .map_err(Into::into)
+        })
     }
 }
 
 impl EthereumNode for KitchensinkNode {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn execute_transaction(
         &self,
         transaction: alloy::rpc::types::TransactionRequest,
     ) -> anyhow::Result<TransactionReceipt> {
+        tracing::debug!(?transaction, "Submitting transaction");
         let receipt = self
             .provider()
-            .await
-            .context("Failed to create provider for transaction submission")?
+            .await?
             .send_transaction(transaction)
-            .await
-            .context("Failed to submit transaction to kitchensink proxy")?
+            .await?
             .get_receipt()
-            .await
-            .context("Failed to fetch transaction receipt from kitchensink proxy")?;
+            .await?;
+        tracing::info!(?receipt, "Submitted tx to kitchensink");
         Ok(receipt)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
         let tx_hash = transaction.transaction_hash;
-        self.provider()
-            .await
-            .context("Failed to create provider for debug tracing")?
+        Ok(self
+            .provider()
+            .await?
             .debug_trace_transaction(tx_hash, trace_options)
-            .await
-            .context("Failed to obtain debug trace from kitchensink proxy")
+            .await?)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
@@ -460,23 +430,23 @@ impl EthereumNode for KitchensinkNode {
         }
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_balance(address)
             .await
             .map_err(Into::into)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn latest_state_proof(
         &self,
         address: Address,
         keys: Vec<StorageKey>,
     ) -> anyhow::Result<EIP1186AccountProofResponse> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_proof(address, keys)
             .latest()
             .await
@@ -485,66 +455,62 @@ impl EthereumNode for KitchensinkNode {
 }
 
 impl ResolverApi for KitchensinkNode {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_chain_id()
             .await
             .map_err(Into::into)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_transaction_receipt(*tx_hash)
             .await?
             .context("Failed to get the transaction receipt")
             .map(|receipt| receipt.effective_gas_price)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.gas_limit as _)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.beneficiary)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .and_then(|block| {
                 block
                     .header
@@ -553,32 +519,30 @@ impl ResolverApi for KitchensinkNode {
             })
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.hash)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_by_number(number)
-            .await
-            .context("Failed to get the kitchensink block")?
-            .context("Failed to get the Kitchensink block, perhaps the chain has no blocks?")
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
             .map(|block| block.header.timestamp)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
-            .await
-            .context("Failed to get the Kitchensink provider")?
+            .await?
             .get_block_number()
             .await
             .map_err(Into::into)
@@ -604,31 +568,26 @@ impl Node for KitchensinkNode {
         Self {
             id,
             substrate_binary: config.kitchensink.clone(),
-            dev_node_binary: config.revive_dev_node.clone(),
             eth_proxy_binary: config.eth_proxy.clone(),
             rpc_url: String::new(),
+            wallet,
             base_directory,
             logs_directory,
             process_substrate: None,
             process_proxy: None,
-            wallet: Arc::new(wallet),
-            chain_id_filler: Default::default(),
             nonce_manager: Default::default(),
-            use_kitchensink_not_dev_node: config.use_kitchensink_not_dev_node,
             // We know that we only need to be storing 4 files so we can specify that when creating
             // the vector. It's the stdout and stderr of the substrate-node and the eth-rpc.
             logs_file_to_flush: Vec::with_capacity(4),
         }
     }
 
-    fn id(&self) -> usize {
-        self.id as _
-    }
-
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
     fn connection_string(&self) -> String {
         self.rpc_url.clone()
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn shutdown(&mut self) -> anyhow::Result<()> {
         // Terminate the processes in a graceful manner to allow for the output to be flushed.
         if let Some(mut child) = self.process_proxy.take() {
@@ -655,25 +614,26 @@ impl Node for KitchensinkNode {
         Ok(())
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
         self.init(&genesis)?.spawn_process()
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.substrate_binary)
             .arg("--version")
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::null())
-            .spawn()
-            .context("Failed to spawn kitchensink --version")?
-            .wait_with_output()
-            .context("Failed to wait for kitchensink --version")?
+            .spawn()?
+            .wait_with_output()?
             .stdout;
         Ok(String::from_utf8_lossy(&output).into())
     }
 
-    fn matches_target(targets: Option<&[String]>) -> bool {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    fn matches_target(&self, targets: Option<&[String]>) -> bool {
         match targets {
             None => true,
             Some(targets) => targets.iter().any(|str| str.as_str() == "pvm"),
@@ -686,6 +646,7 @@ impl Node for KitchensinkNode {
 }
 
 impl Drop for KitchensinkNode {
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
     fn drop(&mut self) {
         self.shutdown().expect("Failed to shutdown")
     }
@@ -1134,7 +1095,6 @@ mod tests {
         Arguments {
             kitchensink: PathBuf::from("substrate-node"),
             eth_proxy: PathBuf::from("eth-rpc"),
-            use_kitchensink_not_dev_node: true,
             ..Default::default()
         }
     }

crates/node/src/lib.rs

@@ -18,9 +18,6 @@ pub trait Node: EthereumNode {
     /// Create a new uninitialized instance.
     fn new(config: &Arguments) -> Self;
 
-    /// Returns the identifier of the node.
-    fn id(&self) -> usize;
-
     /// Spawns a node configured according to the genesis json.
     ///
     /// Blocking until it's ready to accept transactions.
@@ -39,7 +36,7 @@ pub trait Node: EthereumNode {
 
     /// Given a list of targets from the metadata file, this function determines if the metadata
     /// file can be ran on this node or not.
-    fn matches_target(targets: Option<&[String]>) -> bool;
+    fn matches_target(&self, targets: Option<&[String]>) -> bool;
 
     /// Returns the EVM version of the node.
     fn evm_version() -> EVMVersion;

crates/node/src/pool.rs

@@ -9,7 +9,6 @@ use revive_dt_common::cached_fs::read_to_string;
 
 use anyhow::Context;
 use revive_dt_config::Arguments;
-use tracing::info;
 
 use crate::Node;
 
@@ -44,10 +43,8 @@ where
             nodes.push(
                 handle
                     .join()
-                    .map_err(|error| anyhow::anyhow!("failed to spawn node: {:?}", error))
-                    .context("Failed to join node spawn thread")?
-                    .map_err(|error| anyhow::anyhow!("node failed to spawn: {error}"))
-                    .context("Node failed to spawn")?,
+                    .map_err(|error| anyhow::anyhow!("failed to spawn node: {:?}", error))?
+                    .map_err(|error| anyhow::anyhow!("node failed to spawn: {error}"))?,
             );
         }
 
@@ -66,17 +63,7 @@ where
 
 fn spawn_node<T: Node + Send>(args: &Arguments, genesis: String) -> anyhow::Result<T> {
     let mut node = T::new(args);
-    info!(
-        id = node.id(),
-        connection_string = node.connection_string(),
-        "Spawning node"
-    );
-    node.spawn(genesis)
-        .context("Failed to spawn node process")?;
-    info!(
-        id = node.id(),
-        connection_string = node.connection_string(),
-        "Spawned node"
-    );
+    tracing::info!("starting node: {}", node.connection_string());
+    node.spawn(genesis)?;
     Ok(node)
 }

crates/report/Cargo.toml

@@ -8,21 +8,11 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
 revive-dt-compiler = { workspace = true }
 
-alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
-paste = { workspace = true }
-indexmap = { workspace = true, features = ["serde"] }
-semver = { workspace = true }
+tracing = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-serde_with = { workspace = true }
-tokio = { workspace = true }
-tracing = { workspace = true }
-
-[lints]
-workspace = true

crates/report/src/aggregator.rs

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

crates/report/src/analyzer.rs

@@ -0,0 +1,81 @@
+//! The report analyzer enriches the raw report data.
+
+use revive_dt_compiler::CompilerOutput;
+use serde::{Deserialize, Serialize};
+
+use crate::reporter::CompilationTask;
+
+/// Provides insights into how well the compilers perform.
+#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
+pub struct CompilerStatistics {
+    /// The sum of contracts observed.
+    pub n_contracts: usize,
+    /// The mean size of compiled contracts.
+    pub mean_code_size: usize,
+    /// The mean size of the optimized YUL IR.
+    pub mean_yul_size: usize,
+    /// Is a proxy because the YUL also contains a lot of comments.
+    pub yul_to_bytecode_size_ratio: f32,
+}
+
+impl CompilerStatistics {
+    /// Cumulatively update the statistics with the next compiler task.
+    pub fn sample(&mut self, compilation_task: &CompilationTask) {
+        let Some(CompilerOutput { contracts }) = &compilation_task.json_output else {
+            return;
+        };
+
+        for (_solidity, contracts) in contracts.iter() {
+            for (_name, (bytecode, _)) in contracts.iter() {
+                // The EVM bytecode can be unlinked and thus is not necessarily a decodable hex
+                // string; for our statistics this is a good enough approximation.
+                let bytecode_size = bytecode.len() / 2;
+
+                // TODO: for the time being we set the yul_size to be zero. We need to change this
+                // when we overhaul the reporting.
+
+                self.update_sizes(bytecode_size, 0);
+            }
+        }
+    }
+
+    /// Updates the size statistics cumulatively.
+    fn update_sizes(&mut self, bytecode_size: usize, yul_size: usize) {
+        let n_previous = self.n_contracts;
+        let n_current = self.n_contracts + 1;
+
+        self.n_contracts = n_current;
+
+        self.mean_code_size = (n_previous * self.mean_code_size + bytecode_size) / n_current;
+        self.mean_yul_size = (n_previous * self.mean_yul_size + yul_size) / n_current;
+
+        if self.mean_code_size > 0 {
+            self.yul_to_bytecode_size_ratio =
+                self.mean_yul_size as f32 / self.mean_code_size as f32;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CompilerStatistics;
+
+    #[test]
+    fn compiler_statistics() {
+        let mut received = CompilerStatistics::default();
+        received.update_sizes(0, 0);
+        received.update_sizes(3, 37);
+        received.update_sizes(123, 456);
+
+        let mean_code_size = 41; // rounding error from integer truncation
+        let mean_yul_size = 164;
+        let expected = CompilerStatistics {
+            n_contracts: 3,
+            mean_code_size,
+            mean_yul_size,
+            yul_to_bytecode_size_ratio: mean_yul_size as f32 / mean_code_size as f32,
+        };
+
+        assert_eq!(received, expected);
+    }
+}

crates/report/src/common.rs

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

crates/report/src/lib.rs

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

crates/report/src/reporter.rs

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

crates/report/src/reporter_event.rs

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

crates/report/src/runner_event.rs

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

crates/solc-binaries/Cargo.toml

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

crates/solc-binaries/src/cache.rs

@@ -9,11 +9,9 @@ use std::{
     sync::LazyLock,
 };
 
-use semver::Version;
 use tokio::sync::Mutex;
 
 use crate::download::SolcDownloader;
-use anyhow::Context;
 
 pub const SOLC_CACHE_DIRECTORY: &str = "solc";
 pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
@@ -21,7 +19,7 @@ pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new
 pub(crate) async fn get_or_download(
     working_directory: &Path,
     downloader: &SolcDownloader,
-) -> anyhow::Result<(Version, PathBuf)> {
+) -> anyhow::Result<PathBuf> {
     let target_directory = working_directory
         .join(SOLC_CACHE_DIRECTORY)
         .join(downloader.version.to_string());
@@ -30,55 +28,34 @@ pub(crate) async fn get_or_download(
     let mut cache = SOLC_CACHER.lock().await;
     if cache.contains(&target_file) {
         tracing::debug!("using cached solc: {}", target_file.display());
-        return Ok((downloader.version.clone(), target_file));
+        return Ok(target_file);
     }
 
-    create_dir_all(&target_directory).with_context(|| {
-        format!(
-            "Failed to create solc cache directory: {}",
-            target_directory.display()
-        )
-    })?;
-    download_to_file(&target_file, downloader)
-        .await
-        .with_context(|| {
-            format!(
-                "Failed to write downloaded solc to {}",
-                target_file.display()
-            )
-        })?;
+    create_dir_all(target_directory)?;
+    download_to_file(&target_file, downloader).await?;
     cache.insert(target_file.clone());
 
-    Ok((downloader.version.clone(), target_file))
+    Ok(target_file)
 }
 
 async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::Result<()> {
+    tracing::info!("caching file: {}", path.display());
+
     let Ok(file) = File::create_new(path) else {
+        tracing::debug!("cache file already exists: {}", path.display());
         return Ok(());
     };
 
     #[cfg(unix)]
     {
-        let mut permissions = file
-            .metadata()
-            .with_context(|| format!("Failed to read metadata for {}", path.display()))?
-            .permissions();
+        let mut permissions = file.metadata()?.permissions();
         permissions.set_mode(permissions.mode() | 0o111);
-        file.set_permissions(permissions).with_context(|| {
-            format!("Failed to set executable permissions on {}", path.display())
-        })?;
+        file.set_permissions(permissions)?;
     }
 
     let mut file = BufWriter::new(file);
-    file.write_all(
-        &downloader
-            .download()
-            .await
-            .context("Failed to download solc binary bytes")?,
-    )
-    .with_context(|| format!("Failed to write solc binary to {}", path.display()))?;
-    file.flush()
-        .with_context(|| format!("Failed to flush file {}", path.display()))?;
+    file.write_all(&downloader.download().await?)?;
+    file.flush()?;
     drop(file);
 
     #[cfg(target_os = "macos")]
@@ -89,20 +66,8 @@ async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::R
         .stderr(std::process::Stdio::null())
         .stdout(std::process::Stdio::null())
         .stdout(std::process::Stdio::null())
-        .spawn()
-        .with_context(|| {
-            format!(
-                "Failed to spawn xattr to remove quarantine attribute on {}",
-                path.display()
-            )
-        })?
-        .wait()
-        .with_context(|| {
-            format!(
-                "Failed waiting for xattr operation to complete on {}",
-                path.display()
-            )
-        })?;
+        .spawn()?
+        .wait()?;
 
     Ok(())
 }

crates/solc-binaries/src/download.rs

@@ -11,7 +11,6 @@ use semver::Version;
 use sha2::{Digest, Sha256};
 
 use crate::list::List;
-use anyhow::Context;
 
 pub static LIST_CACHE: LazyLock<Mutex<HashMap<&'static str, List>>> =
     LazyLock::new(Default::default);
@@ -31,12 +30,7 @@ impl List {
             return Ok(list.clone());
         }
 
-        let body: List = reqwest::get(url)
-            .await
-            .with_context(|| format!("Failed to GET solc list from {url}"))?
-            .json()
-            .await
-            .with_context(|| format!("Failed to deserialize solc list JSON from {url}"))?;
+        let body: List = reqwest::get(url).await?.json().await?;
 
         LIST_CACHE.lock().unwrap().insert(url, body.clone());
 
@@ -74,8 +68,7 @@ impl SolcDownloader {
             }),
             VersionOrRequirement::Requirement(requirement) => {
                 let Some(version) = List::download(list)
-                    .await
-                    .with_context(|| format!("Failed to download solc builds list from {list}"))?
+                    .await?
                     .builds
                     .into_iter()
                     .map(|build| build.version)
@@ -114,20 +107,12 @@ impl SolcDownloader {
     /// Errors out if the download fails or the digest of the downloaded file
     /// mismatches the expected digest from the release [List].
     pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
-        let builds = List::download(self.list)
-            .await
-            .with_context(|| format!("Failed to download solc builds list from {}", self.list))?
-            .builds;
+        tracing::info!("downloading solc: {self:?}");
+        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))
-            .with_context(|| {
-                format!(
-                    "Requested solc version {} was not found in builds list fetched from {}",
-                    self.version, self.list
-                )
-            })?;
+            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))?;
 
         let path = build.path.clone();
         let expected_digest = build
@@ -137,13 +122,7 @@ impl SolcDownloader {
             .to_string();
         let url = format!("{}/{}/{}", Self::BASE_URL, self.target, path.display());
 
-        let file = reqwest::get(&url)
-            .await
-            .with_context(|| format!("Failed to GET solc binary from {url}"))?
-            .bytes()
-            .await
-            .with_context(|| format!("Failed to read solc binary bytes from {url}"))?
-            .to_vec();
+        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);

crates/solc-binaries/src/lib.rs

@@ -5,12 +5,10 @@
 
 use std::path::{Path, PathBuf};
 
-use anyhow::Context;
 use cache::get_or_download;
 use download::SolcDownloader;
 
 use revive_dt_common::types::VersionOrRequirement;
-use semver::Version;
 
 pub mod cache;
 pub mod download;
@@ -25,7 +23,7 @@ pub async fn download_solc(
     cache_directory: &Path,
     version: impl Into<VersionOrRequirement>,
     wasm: bool,
-) -> anyhow::Result<(Version, PathBuf)> {
+) -> anyhow::Result<PathBuf> {
     let downloader = if wasm {
         SolcDownloader::wasm(version).await
     } else if cfg!(target_os = "linux") {
@@ -36,8 +34,7 @@ pub async fn download_solc(
         SolcDownloader::windows(version).await
     } else {
         unimplemented!()
-    }
-    .context("Failed to initialize the Solc Downloader")?;
+    }?;
 
     get_or_download(cache_directory, &downloader).await
 }

run_tests.sh

@@ -1,102 +0,0 @@
-#!/bin/bash
-
-# Revive Differential Tests - Quick Start Script
-# This script clones the test repository, sets up the corpus file, and runs the tool
-
-set -e  # Exit on any error
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Configuration
-TEST_REPO_URL="https://github.com/paritytech/resolc-compiler-tests"
-TEST_REPO_DIR="resolc-compiler-tests"
-CORPUS_FILE="./corpus.json"
-WORKDIR="workdir"
-
-# Optional positional argument: path to polkadot-sdk directory
-POLKADOT_SDK_DIR="${1:-}"
-
-# Binary paths (default to names in $PATH)
-REVIVE_DEV_NODE_BIN="revive-dev-node"
-ETH_RPC_BIN="eth-rpc"
-SUBSTRATE_NODE_BIN="substrate-node"
-
-echo -e "${GREEN}=== Revive Differential Tests Quick Start ===${NC}"
-echo ""
-
-# Check if test repo already exists
-if [ -d "$TEST_REPO_DIR" ]; then
-    echo -e "${YELLOW}Test repository already exists. Pulling latest changes...${NC}"
-    cd "$TEST_REPO_DIR"
-    git pull
-    cd ..
-else
-    echo -e "${GREEN}Cloning test repository...${NC}"
-    git clone "$TEST_REPO_URL"
-fi
-
-# If polkadot-sdk path is provided, verify and use binaries from there; build if needed
-if [ -n "$POLKADOT_SDK_DIR" ]; then
-    if [ ! -d "$POLKADOT_SDK_DIR" ]; then
-        echo -e "${RED}Provided polkadot-sdk directory does not exist: $POLKADOT_SDK_DIR${NC}"
-        exit 1
-    fi
-
-    POLKADOT_SDK_DIR=$(realpath "$POLKADOT_SDK_DIR")
-    echo -e "${GREEN}Using polkadot-sdk at: $POLKADOT_SDK_DIR${NC}"
-
-    REVIVE_DEV_NODE_BIN="$POLKADOT_SDK_DIR/target/release/revive-dev-node"
-    ETH_RPC_BIN="$POLKADOT_SDK_DIR/target/release/eth-rpc"
-    SUBSTRATE_NODE_BIN="$POLKADOT_SDK_DIR/target/release/substrate-node"
-
-    if [ ! -x "$REVIVE_DEV_NODE_BIN" ] || [ ! -x "$ETH_RPC_BIN" ] || [ ! -x "$SUBSTRATE_NODE_BIN" ]; then
-        echo -e "${YELLOW}Required binaries not found in release target. Building...${NC}"
-        (cd "$POLKADOT_SDK_DIR" && cargo build --release --package staging-node-cli --package pallet-revive-eth-rpc --package revive-dev-node)
-    fi
-
-    for bin in "$REVIVE_DEV_NODE_BIN" "$ETH_RPC_BIN" "$SUBSTRATE_NODE_BIN"; do
-        if [ ! -x "$bin" ]; then
-            echo -e "${RED}Expected binary not found after build: $bin${NC}"
-            exit 1
-        fi
-    done
-else
-    echo -e "${YELLOW}No polkadot-sdk path provided. Using binaries from $PATH.${NC}"
-fi
-
-# Create corpus file with absolute path resolved at runtime
-echo -e "${GREEN}Creating corpus file...${NC}"
-ABSOLUTE_PATH=$(realpath "$TEST_REPO_DIR/fixtures/solidity/")
-
-cat > "$CORPUS_FILE" << EOF
-{
-  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
-  "path": "$ABSOLUTE_PATH"
-}
-EOF
-
-echo -e "${GREEN}Corpus file created: $CORPUS_FILE${NC}"
-
-# Create workdir if it doesn't exist
-mkdir -p "$WORKDIR"
-
-echo -e "${GREEN}Starting differential tests...${NC}"
-echo "This may take a while..."
-echo ""
-
-# Run the tool
-RUST_LOG="error" cargo run --release -- \
-    --corpus "$CORPUS_FILE" \
-    --workdir "$WORKDIR" \
-    --number-of-nodes 5 \
-    --kitchensink "$SUBSTRATE_NODE_BIN" \
-    --revive-dev-node "$REVIVE_DEV_NODE_BIN" \
-    --eth_proxy "$ETH_RPC_BIN" \
-    > logs.log \
-    2> output.log
-
-echo -e "${GREEN}=== Test run completed! ===${NC}"