Update the readme

Fix concurrency issues (#142 )
* Fix the OS FD error * Cache the compiler versions * Allow for auto display impl in declare wrapper type macro * Better logging and fix concurrency issues * Fix tests * Format * Make the code even more concurrent
2026-04-22 10:17:56 +00:00 · 2025-08-19 20:40:35 +03:00 · 2025-08-19 06:47:36 +00:00 · 2025-08-16 16:04:17 +00:00 · 2025-08-16 16:04:13 +00:00
37 changed files with 1846 additions and 1016 deletions
@@ -6,4 +6,6 @@ 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
+*.log
+
+profile.json.gz
@@ -659,7 +659,7 @@ checksum = "4f317d20f047b3de4d9728c556e2e9a92c9a507702d2016424cd8be13a74ca5e"
 dependencies = [
 "alloy-json-rpc",
 "alloy-primitives",
- "base64",
+ "base64 0.22.1",
 "derive_more 2.0.1",
 "futures",
 "futures-utils-wasm",
@@ -1189,6 +1189,151 @@ 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"
@@ -1211,6 +1356,12 @@ 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"
@@ -1266,6 +1417,12 @@ 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"
@@ -1404,6 +1561,19 @@ 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"
@@ -1437,6 +1607,29 @@ 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"
@@ -1479,6 +1672,32 @@ 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"
@@ -1559,6 +1778,15 @@ 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"
@@ -2120,6 +2348,33 @@ 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"
@@ -2361,6 +2616,19 @@ 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"
@@ -2440,8 +2708,10 @@ 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]]
@@ -2451,9 +2721,11 @@ 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]]
@@ -2478,6 +2750,18 @@ 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"
@@ -2572,6 +2856,12 @@ 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"
@@ -2724,7 +3014,7 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1c293b6b3d21eca78250dc7dbebd6b9210ec5530e038cbfe0661b5c47ab06e8"
 dependencies = [
- "base64",
+ "base64 0.22.1",
 "bytes",
 "futures-channel",
 "futures-core",
@@ -3094,6 +3384,15 @@ 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"
@@ -3119,7 +3418,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e79019718125edc905a079a70cfa5f3820bc76139fc91d6f9abc27ea2a887139"
 dependencies = [
 "arrayref",
- "base64",
+ "base64 0.22.1",
 "digest 0.9.0",
 "hmac-drbg",
 "libsecp256k1-core",
@@ -3187,6 +3486,9 @@ name = "log"
 version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+dependencies = [
+ "value-bag",
+]

 [[package]]
 name = "loom"
@@ -3236,6 +3538,15 @@ 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"
@@ -3257,6 +3568,29 @@ 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"
@@ -3386,7 +3720,7 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.3.9",
 "libc",
 ]

@@ -3543,6 +3877,12 @@ 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"
@@ -3648,6 +3988,17 @@ 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"
@@ -3701,6 +4052,21 @@ 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"
@@ -3988,6 +4354,18 @@ 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"
@@ -4038,7 +4416,7 @@ version = "0.12.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e98ff6b0dbbe4d5a37318f433d4fc82babd21631f194d370409ceb2e40b2f0b5"
 dependencies = [
- "base64",
+ "base64 0.22.1",
 "bytes",
 "encoding_rs",
 "futures-core",
@@ -4104,6 +4482,7 @@ dependencies = [
 "alloy",
 "alloy-primitives",
 "anyhow",
+ "dashmap",
 "foundry-compilers-artifacts",
 "revive-common",
 "revive-dt-common",
@@ -4134,9 +4513,12 @@ version = "0.1.0"
 dependencies = [
 "alloy",
 "anyhow",
+ "bson",
+ "cacache",
 "clap",
 "futures",
 "indexmap 2.10.0",
+ "once_cell",
 "revive-dt-common",
 "revive-dt-compiler",
 "revive-dt-config",
@@ -4145,10 +4527,13 @@ dependencies = [
 "revive-dt-node-interaction",
 "revive-dt-report",
 "semver 1.0.26",
+ "serde",
 "serde_json",
 "temp-dir",
+ "tempfile",
 "tokio",
 "tracing",
+ "tracing-appender",
 "tracing-subscriber",
 ]

@@ -4160,6 +4545,7 @@ dependencies = [
 "alloy-primitives",
 "alloy-sol-types",
 "anyhow",
+ "futures",
 "regex",
 "revive-common",
 "revive-dt-common",
@@ -4209,7 +4595,6 @@ dependencies = [
 "revive-dt-format",
 "serde",
 "serde_json",
- "tracing",
 ]

 [[package]]
@@ -4650,6 +5035,7 @@ version = "1.0.140"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
 dependencies = [
+ "indexmap 2.10.0",
 "itoa",
 "memchr",
 "ryu",
@@ -4693,7 +5079,7 @@ version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa"
 dependencies = [
- "base64",
+ "base64 0.22.1",
 "chrono",
 "hex",
 "indexmap 1.9.3",
@@ -4727,6 +5113,28 @@ 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"
@@ -5201,6 +5609,23 @@ 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"
@@ -5685,6 +6110,18 @@ 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"
@@ -5851,6 +6288,12 @@ 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"
@@ -5894,6 +6337,7 @@ checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
 dependencies = [
 "getrandom 0.3.3",
 "js-sys",
+ "serde",
 "wasm-bindgen",
 ]

@@ -5903,6 +6347,12 @@ 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"
@@ -6468,6 +6918,12 @@ 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"
@@ -25,7 +25,10 @@ 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"
@@ -52,7 +55,8 @@ tokio = { version = "1.47.0", default-features = false, features = [
    "rt",
 ] }
 uuid = { version = "1.8", features = ["v4"] }
-tracing = "0.1.41"
+tracing = { version = "0.1.41" }
+tracing-appender = { version = "0.2.3" }
 tracing-subscriber = { version = "0.3.19", default-features = false, features = [
    "fmt",
    "json",
@@ -87,3 +91,5 @@ features = [
 inherits = "release"
 lto = true
 codegen-units = 1
+
+[workspace.lints.clippy]
@@ -1,34 +1,210 @@
-# revive-differential-tests
+<div align="center">
+  <h1><code>Revive Differential Tests</code></h1>

-The revive differential testing framework allows to define smart contract tests in a declarative manner in order to compile and execute them against different Ethereum-compatible blockchain implmentations. This is useful to:
- 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.
+  <p>
+    <strong>Differential testing for Ethereum-compatible smart contract stacks</strong>
+  </p>
+</div>

-# Declarative test format
+This project compiles and executes declarative smart-contract tests against multiple platforms, then compares behavior (status, return data, events, and state diffs). Today it supports:

-For now, the format used to write tests is the [matter-labs era compiler format](https://github.com/matter-labs/era-compiler-tests?tab=readme-ov-file#matter-labs-simplecomplex-format). This allows us to re-use many tests from their corpora.
+- Geth (EVM reference implementation)
+- Revive Kitchensink (Substrate-based PolkaVM + `eth-rpc` proxy)

-# The `retester` utility
+Use it to:

-The `retester` helper utilty is used to run the tests. To get an idea of what `retester` can do, please consults its command line help: 
+- Detect observable differences between platforms (execution success, logs, state changes)
+- Ensure reproducible builds across compilers/hosts
+- Run end-to-end regression suites

-```
-cargo run -p revive-dt-core -- --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')
 ```

-For example, to run the [complex Solidity tests](https://github.com/matter-labs/era-compiler-tests/tree/main/solidity/complex), define a corpus structure as follows:
+To run tests with this tool you need a corpus JSON file that defines the tests included in the corpus. The simplest corpus file looks like the following:

 ```json
 {
-    "name": "ML Solidity Complex",
-    "path": "/path/to/era-compiler-tests/solidity/complex"
+  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
+  "path": "resolc-compiler-tests/fixtures/solidity"
 }
 ```

-Assuming this to be saved in a `ml-solidity-complex.json` file, the following command will try to compile and execute the tests found inside the corpus:
+> [!NOTE]  
+> Note that the tests can be found in the [`resolc-compiler-tests`](https://github.com/paritytech/resolc-compiler-tests) repository.
+
+The above corpus file instructs the tool to look for all of the test cases contained within all of the metadata files of the specified directory.
+
+The simplest command to run this tool is the following:

 ```bash
-RUST_LOG=debug cargo r --release -p revive-dt-core  -- --corpus ml-solidity-complex.json 
+RUST_LOG="info" cargo run --release -- \
+    --corpus path_to_your_corpus_file.json \
+    --workdir path_to_a_temporary_directory_to_cache_things_in \
+    --number-of-nodes 5 \
+    > logs.log \
+    2> output.log
+```
+
+The above command will run the tool executing every one of the tests discovered in the path specified in the corpus file. All of the logs from the execution will be persisted in the `logs.log` file and all of the output of the tool will be persisted to the `output.log` file. If all that you're looking for is to run the tool and check which tests succeeded and failed, then the `output.log` file is what you need to be looking at. However, if you're contributing the to the tool then the `logs.log` file will be very valuable.
+
+If you only want to run a subset of tests, then you can specify that in your corpus file. The following is an example:
+
+```json
+{
+  "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
+  "paths": [
+    "path/to/a/single/metadata/file/I/want/to/run.json",
+    "path/to/a/directory/to/find/all/metadata/files/within"
+  ]
+}
 ```
@@ -0,0 +1 @@
+
@@ -15,3 +15,6 @@ once_cell = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 tokio = { workspace = true, default-features = false, features = ["time"] }
+
+[lints]
+workspace = true
@@ -1,3 +1,14 @@
+#[macro_export]
+macro_rules! impl_for_wrapper {
+    (Display, $ident: ident) => {
+        impl std::fmt::Display for $ident {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                std::fmt::Display::fmt(&self.0, f)
+            }
+        }
+    };
+}
+
 /// Defines wrappers around types.
 ///
 /// For example, the macro invocation seen below:
@@ -42,7 +53,13 @@
 macro_rules! define_wrapper_type {
    (
        $(#[$meta: meta])*
-        $vis:vis struct $ident: ident($ty: ty);
+        $vis:vis struct $ident: ident($ty: ty)
+
+        $(
+            impl $($trait_ident: ident),*
+        )?
+
+        ;
    ) => {
        $(#[$meta])*
        $vis struct $ident($ty);
@@ -98,9 +115,15 @@ 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;
+pub use {define_wrapper_type, impl_for_wrapper};
@@ -10,7 +10,7 @@ use std::str::FromStr;
 /// 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)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Mode {
    pub pipeline: ModePipeline,
    pub optimize_setting: ModeOptimizerSetting,
@@ -18,9 +18,13 @@ 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
@@ -47,7 +47,7 @@ pub trait SolidityCompiler {
        version: impl Into<VersionOrRequirement>,
    ) -> impl Future<Output = anyhow::Result<PathBuf>>;

-    fn version(&self) -> anyhow::Result<Version>;
+    fn version(&self) -> impl Future<Output = anyhow::Result<Version>>;

    /// Does the compiler support the provided mode and version settings?
    fn supports_mode(
@@ -169,6 +169,14 @@ where
        self
    }

+    pub fn then(self, callback: impl FnOnce(Self) -> Self) -> Self {
+        callback(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>,
@@ -4,8 +4,10 @@
 use std::{
    path::PathBuf,
    process::{Command, Stdio},
+    sync::LazyLock,
 };

+use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_solc_json_interface::{
@@ -219,26 +221,39 @@ impl SolidityCompiler for Resolc {
        Ok(PathBuf::from("resolc"))
    }

-    fn version(&self) -> anyhow::Result<semver::Version> {
-        // Logic for parsing the resolc version from the following string:
-        // Solidity frontend for the revive compiler version 0.3.0+commit.b238913.llvm-18.1.8
+    async fn version(&self) -> anyhow::Result<semver::Version> {
+        /// This is a cache of the path of the compiler to the version number of the compiler. We
+        /// choose to cache the version in this way rather than through a field on the struct since
+        /// compiler objects are being created all the time from the path and the compiler object is
+        /// not reused over time.
+        static VERSION_CACHE: LazyLock<DashMap<PathBuf, Version>> = LazyLock::new(Default::default);

-        let output = Command::new(self.resolc_path.as_path())
-            .arg("--version")
-            .stdout(Stdio::piped())
-            .spawn()?
-            .wait_with_output()?
-            .stdout;
-        let output = String::from_utf8_lossy(&output);
-        let version_string = output
-            .split("version ")
-            .nth(1)
-            .context("Version parsing failed")?
-            .split("+")
-            .next()
-            .context("Version parsing failed")?;
+        match VERSION_CACHE.entry(self.resolc_path.clone()) {
+            dashmap::Entry::Occupied(occupied_entry) => Ok(occupied_entry.get().clone()),
+            dashmap::Entry::Vacant(vacant_entry) => {
+                let output = Command::new(self.resolc_path.as_path())
+                    .arg("--version")
+                    .stdout(Stdio::piped())
+                    .spawn()?
+                    .wait_with_output()?
+                    .stdout;

-        Version::parse(version_string).map_err(Into::into)
+                let output = String::from_utf8_lossy(&output);
+                let version_string = output
+                    .split("version ")
+                    .nth(1)
+                    .context("Version parsing failed")?
+                    .split("+")
+                    .next()
+                    .context("Version parsing failed")?;
+
+                let version = Version::parse(version_string)?;
+
+                vacant_entry.insert(version.clone());
+
+                Ok(version)
+            }
+        }
    }

    fn supports_mode(
@@ -268,7 +283,7 @@ mod test {
        let compiler = Resolc::new(path);

        // Act
-        let version = compiler.version();
+        let version = compiler.version().await;

        // Assert
        let _ = version.expect("Failed to get version");
@@ -4,8 +4,10 @@
 use std::{
    path::PathBuf,
    process::{Command, Stdio},
+    sync::LazyLock,
 };

+use dashmap::DashMap;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
@@ -47,7 +49,7 @@ impl SolidityCompiler for Solc {
        }: CompilerInput,
        _: Self::Options,
    ) -> anyhow::Result<CompilerOutput> {
-        let compiler_supports_via_ir = self.version()? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
+        let compiler_supports_via_ir = self.version().await? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;

        // Be careful to entirely omit the viaIR field if the compiler does not support it,
        // as it will error if you provide fields it does not know about. Because
@@ -209,30 +211,44 @@ impl SolidityCompiler for Solc {
        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
-        // ```
+    async fn version(&self) -> anyhow::Result<semver::Version> {
+        /// This is a cache of the path of the compiler to the version number of the compiler. We
+        /// choose to cache the version in this way rather than through a field on the struct since
+        /// compiler objects are being created all the time from the path and the compiler object is
+        /// not reused over time.
+        static VERSION_CACHE: LazyLock<DashMap<PathBuf, Version>> = LazyLock::new(Default::default);

-        let child = Command::new(self.solc_path.as_path())
-            .arg("--version")
-            .stdout(Stdio::piped())
-            .spawn()?;
-        let output = child.wait_with_output()?;
-        let output = String::from_utf8_lossy(&output.stdout);
-        let version_line = output
-            .split("Version: ")
-            .nth(1)
-            .context("Version parsing failed")?;
-        let version_string = version_line
-            .split("+")
-            .next()
-            .context("Version parsing failed")?;
+        match VERSION_CACHE.entry(self.solc_path.clone()) {
+            dashmap::Entry::Occupied(occupied_entry) => Ok(occupied_entry.get().clone()),
+            dashmap::Entry::Vacant(vacant_entry) => {
+                // The following is the parsing code for the version from the solc version strings
+                // which look like the following:
+                // ```
+                // solc, the solidity compiler commandline interface
+                // Version: 0.8.30+commit.73712a01.Darwin.appleclang
+                // ```
+                let child = Command::new(self.solc_path.as_path())
+                    .arg("--version")
+                    .stdout(Stdio::piped())
+                    .spawn()?;
+                let output = child.wait_with_output()?;
+                let output = String::from_utf8_lossy(&output.stdout);
+                let version_line = output
+                    .split("Version: ")
+                    .nth(1)
+                    .context("Version parsing failed")?;
+                let version_string = version_line
+                    .split("+")
+                    .next()
+                    .context("Version parsing failed")?;

-        Version::parse(version_string).map_err(Into::into)
+                let version = Version::parse(version_string)?;
+
+                vacant_entry.insert(version.clone());
+
+                Ok(version)
+            }
+        }
    }

    fn supports_mode(
@@ -256,15 +272,13 @@ mod test {
    async fn compiler_version_can_be_obtained() {
        // Arrange
        let args = Arguments::default();
-        println!("Getting compiler path");
        let path = Solc::get_compiler_executable(&args, Version::new(0, 7, 6))
            .await
            .unwrap();
-        println!("Got compiler path");
        let compiler = Solc::new(path);

        // Act
-        let version = compiler.version();
+        let version = compiler.version().await;

        // Assert
        assert_eq!(
@@ -277,15 +291,13 @@ mod test {
    async fn compiler_version_can_be_obtained1() {
        // Arrange
        let args = Arguments::default();
-        println!("Getting compiler path");
        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
            .await
            .unwrap();
-        println!("Got compiler path");
        let compiler = Solc::new(path);

        // Act
-        let version = compiler.version();
+        let version = compiler.version().await;

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

    // Act
    let output = Compiler::<Solc>::new()
@@ -15,3 +15,5 @@ semver = { workspace = true }
 temp-dir = { workspace = true }
 serde = { workspace = true }

+[lints]
+workspace = true
@@ -120,6 +120,10 @@ pub struct Arguments {
    /// By default it uses `eth-rpc` binary found in `$PATH`.
    #[arg(short = 'p', long = "eth_proxy", default_value = "eth-rpc")]
    pub eth_proxy: PathBuf,
+
+    /// Controls if the compilation cache should be invalidated or not.
+    #[arg(short, long)]
+    pub invalidate_compilation_cache: bool,
 }

 impl Arguments {
@@ -23,12 +23,21 @@ revive-dt-report = { workspace = true }

 alloy = { workspace = true }
 anyhow = { workspace = true }
+bson = { workspace = true }
+cacache = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }
 indexmap = { workspace = true }
+once_cell = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
+tracing-appender = { workspace = true }
 tracing-subscriber = { workspace = true }
 semver = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 temp-dir = { workspace = true }
+tempfile = { workspace = true }
+
+[lints]
+workspace = true
@@ -0,0 +1,262 @@
+//! A wrapper around the compiler which allows for caching of compilation artifacts so that they can
+//! be reused between runs.
+
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use futures::FutureExt;
+use revive_dt_common::iterators::FilesWithExtensionIterator;
+use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
+use revive_dt_config::Arguments;
+use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
+
+use alloy::{hex::ToHexExt, json_abi::JsonAbi, primitives::Address};
+use anyhow::{Error, Result};
+use once_cell::sync::Lazy;
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use tokio::sync::{Mutex, RwLock};
+use tracing::{Instrument, debug, debug_span, instrument};
+
+use crate::Platform;
+
+pub struct CachedCompiler(ArtifactsCache);
+
+impl CachedCompiler {
+    pub async fn new(path: impl AsRef<Path>, invalidate_cache: bool) -> Result<Self> {
+        let mut cache = ArtifactsCache::new(path);
+        if invalidate_cache {
+            cache = cache.with_invalidated_cache().await?;
+        }
+        Ok(Self(cache))
+    }
+
+    /// Compiles or gets the compilation artifacts from the cache.
+    #[instrument(
+        level = "debug",
+        skip_all,
+        fields(
+            metadata_file_path = %metadata_file_path.as_ref().display(),
+            %mode,
+            platform = P::config_id().to_string()
+        ),
+        err
+    )]
+    pub async fn compile_contracts<P: Platform>(
+        &self,
+        metadata: &Metadata,
+        metadata_file_path: impl AsRef<Path>,
+        mode: &Mode,
+        config: &Arguments,
+        deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+    ) -> Result<(CompilerOutput, Version)> {
+        static CACHE_KEY_LOCK: Lazy<RwLock<HashMap<CacheKey, Arc<Mutex<()>>>>> =
+            Lazy::new(Default::default);
+
+        let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
+        let compiler_path = <P::Compiler as SolidityCompiler>::get_compiler_executable(
+            config,
+            compiler_version_or_requirement,
+        )
+        .await?;
+        let compiler_version = <P::Compiler as SolidityCompiler>::new(compiler_path.clone())
+            .version()
+            .await?;
+
+        let cache_key = CacheKey {
+            platform_key: P::config_id().to_string(),
+            compiler_version: compiler_version.clone(),
+            metadata_file_path: metadata_file_path.as_ref().to_path_buf(),
+            solc_mode: mode.clone(),
+        };
+
+        let compilation_callback = || {
+            async move {
+                compile_contracts::<P>(
+                    metadata.directory()?,
+                    compiler_path,
+                    metadata.files_to_compile()?,
+                    mode,
+                    deployed_libraries,
+                )
+                .map(|compilation_result| compilation_result.map(CacheValue::new))
+                .await
+            }
+            .instrument(debug_span!(
+                "Running compilation for the cache key",
+                cache_key.platform_key = %cache_key.platform_key,
+                cache_key.compiler_version = %cache_key.compiler_version,
+                cache_key.metadata_file_path = %cache_key.metadata_file_path.display(),
+                cache_key.solc_mode = %cache_key.solc_mode,
+            ))
+        };
+
+        let compiled_contracts = match deployed_libraries {
+            // If deployed libraries have been specified then we will re-compile the contract as it
+            // means that linking is required in this case.
+            Some(_) => {
+                debug!("Deployed libraries defined, recompilation must take place");
+                debug!("Cache miss");
+                compilation_callback().await?.compiler_output
+            }
+            // If no deployed libraries are specified then we can follow the cached flow and attempt
+            // to lookup the compilation artifacts in the cache.
+            None => {
+                debug!("Deployed libraries undefined, attempting to make use of cache");
+
+                // Lock this specific cache key such that we do not get inconsistent state. We want
+                // that when multiple cases come in asking for the compilation artifacts then they
+                // don't all trigger a compilation if there's a cache miss. Hence, the lock here.
+                let read_guard = CACHE_KEY_LOCK.read().await;
+                let mutex = match read_guard.get(&cache_key).cloned() {
+                    Some(value) => value,
+                    None => {
+                        drop(read_guard);
+                        CACHE_KEY_LOCK
+                            .write()
+                            .await
+                            .entry(cache_key.clone())
+                            .or_default()
+                            .clone()
+                    }
+                };
+                let _guard = mutex.lock().await;
+
+                self.0
+                    .get_or_insert_with(&cache_key, compilation_callback)
+                    .await
+                    .map(|value| value.compiler_output)?
+            }
+        };
+
+        Ok((compiled_contracts, compiler_version))
+    }
+}
+
+async fn compile_contracts<P: Platform>(
+    metadata_directory: impl AsRef<Path>,
+    compiler_path: impl AsRef<Path>,
+    mut files_to_compile: impl Iterator<Item = PathBuf>,
+    mode: &Mode,
+    deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+) -> Result<CompilerOutput> {
+    let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
+        .with_allowed_extension("sol")
+        .with_use_cached_fs(true)
+        .collect::<Vec<_>>();
+
+    Compiler::<P::Compiler>::new()
+        .with_allow_path(metadata_directory)
+        // Handling the modes
+        .with_optimization(mode.optimize_setting)
+        .with_pipeline(mode.pipeline)
+        // Adding the contract sources to the compiler.
+        .try_then(|compiler| {
+            files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
+        })?
+        // Adding the deployed libraries to the compiler.
+        .then(|compiler| {
+            deployed_libraries
+                .iter()
+                .flat_map(|value| value.iter())
+                .map(|(instance, (ident, address, abi))| (instance, ident, address, abi))
+                .flat_map(|(_, ident, address, _)| {
+                    all_sources_in_dir
+                        .iter()
+                        .map(move |path| (ident, address, path))
+                })
+                .fold(compiler, |compiler, (ident, address, path)| {
+                    compiler.with_library(path, ident.as_str(), *address)
+                })
+        })
+        .try_build(compiler_path)
+        .await
+}
+
+struct ArtifactsCache {
+    path: PathBuf,
+}
+
+impl ArtifactsCache {
+    pub fn new(path: impl AsRef<Path>) -> Self {
+        Self {
+            path: path.as_ref().to_path_buf(),
+        }
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn with_invalidated_cache(self) -> Result<Self> {
+        cacache::clear(self.path.as_path())
+            .await
+            .map_err(Into::<Error>::into)?;
+        Ok(self)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn insert(&self, key: &CacheKey, value: &CacheValue) -> Result<()> {
+        let key = bson::to_vec(key)?;
+        let value = bson::to_vec(value)?;
+        cacache::write(self.path.as_path(), key.encode_hex(), value).await?;
+        Ok(())
+    }
+
+    pub async fn get(&self, key: &CacheKey) -> Option<CacheValue> {
+        let key = bson::to_vec(key).ok()?;
+        let value = cacache::read(self.path.as_path(), key.encode_hex())
+            .await
+            .ok()?;
+        let value = bson::from_slice::<CacheValue>(&value).ok()?;
+        Some(value)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn get_or_insert_with(
+        &self,
+        key: &CacheKey,
+        callback: impl AsyncFnOnce() -> Result<CacheValue>,
+    ) -> Result<CacheValue> {
+        match self.get(key).await {
+            Some(value) => {
+                debug!("Cache hit");
+                Ok(value)
+            }
+            None => {
+                debug!("Cache miss");
+                let value = callback().await?;
+                self.insert(key, &value).await?;
+                Ok(value)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+struct CacheKey {
+    /// The platform name that this artifact was compiled for. For example, this could be EVM or
+    /// PVM.
+    platform_key: String,
+
+    /// The version of the compiler that was used to compile the artifacts.
+    compiler_version: Version,
+
+    /// The path of the metadata file that the compilation artifacts are for.
+    metadata_file_path: PathBuf,
+
+    /// The mode that the compilation artifacts where compiled with.
+    solc_mode: Mode,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct CacheValue {
+    /// The compiler output from the compilation run.
+    compiler_output: CompilerOutput,
+}
+
+impl CacheValue {
+    pub fn new(compiler_output: CompilerOutput) -> Self {
+        Self { compiler_output }
+    }
+}
@@ -16,26 +16,24 @@ use alloy::rpc::types::trace::geth::{
 };
 use alloy::{
    primitives::Address,
-    rpc::types::{
-        TransactionRequest,
-        trace::geth::{AccountState, DiffMode},
-    },
+    rpc::types::{TransactionRequest, trace::geth::DiffMode},
 };
 use anyhow::Context;
+use futures::TryStreamExt;
 use indexmap::IndexMap;
 use revive_dt_format::traits::{ResolutionContext, ResolverApi};
 use semver::Version;

-use revive_dt_format::case::{Case, CaseIdx};
+use revive_dt_format::case::Case;
 use revive_dt_format::input::{
-    BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method,
+    BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method, StepIdx,
    StorageEmptyAssertion,
 };
-use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
+use revive_dt_format::metadata::{ContractIdent, ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Step, metadata::Metadata};
-use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
-use tracing::Instrument;
+use tokio::try_join;
+use tracing::{Instrument, info, info_span, instrument};

 use crate::Platform;

@@ -44,7 +42,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, (Address, JsonAbi)>,
+    deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,

    /// This map stores the variables used for each one of the cases contained in the metadata
    /// file.
@@ -63,7 +61,7 @@ where
    pub fn new(
        compiler_version: Version,
        compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
-        deployed_contracts: HashMap<ContractInstance, (Address, JsonAbi)>,
+        deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
    ) -> Self {
        Self {
            compiled_contracts,
@@ -77,38 +75,38 @@ where
    pub async fn handle_step(
        &mut self,
        metadata: &Metadata,
-        case_idx: CaseIdx,
        step: &Step,
        node: &T::Blockchain,
    ) -> anyhow::Result<StepOutput> {
        match step {
            Step::FunctionCall(input) => {
                let (receipt, geth_trace, diff_mode) =
-                    self.handle_input(metadata, case_idx, input, node).await?;
+                    self.handle_input(metadata, input, node).await?;
                Ok(StepOutput::FunctionCall(receipt, geth_trace, diff_mode))
            }
            Step::BalanceAssertion(balance_assertion) => {
-                self.handle_balance_assertion(metadata, case_idx, balance_assertion, node)
+                self.handle_balance_assertion(metadata, balance_assertion, node)
                    .await?;
                Ok(StepOutput::BalanceAssertion)
            }
            Step::StorageEmptyAssertion(storage_empty) => {
-                self.handle_storage_empty(metadata, case_idx, storage_empty, node)
+                self.handle_storage_empty(metadata, 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, case_idx, input, node)
+            .handle_input_contract_deployment(metadata, input, node)
            .await?;
        let execution_receipt = self
            .handle_input_execution(input, deployment_receipts, node)
@@ -117,16 +115,17 @@ where
            .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
+        let (_, (geth_trace, diff_mode)) = try_join!(
+            self.handle_input_expectations(input, &execution_receipt, node, &tracing_result),
+            self.handle_input_diff(&execution_receipt, node)
+        )?;
+        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<()> {
@@ -137,10 +136,10 @@ where
        Ok(())
    }

+    #[instrument(level = "info", name = "Handling Storage Assertion", skip_all)]
    pub async fn handle_storage_empty(
        &mut self,
        metadata: &Metadata,
-        _: CaseIdx,
        storage_empty: &StorageEmptyAssertion,
        node: &T::Blockchain,
    ) -> anyhow::Result<()> {
@@ -152,20 +151,13 @@ where
    }

    /// Handles the contract deployment for a given input performing it if it needs to be performed.
+    #[instrument(level = "info", skip_all)]
    async fn handle_input_contract_deployment(
        &mut self,
        metadata: &Metadata,
-        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) {
@@ -177,11 +169,6 @@ 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);
@@ -208,6 +195,7 @@ 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,
@@ -225,33 +213,21 @@ where
                    .legacy_transaction(node, self.default_resolution_context())
                    .await
                {
-                    Ok(tx) => {
-                        tracing::debug!("Legacy transaction data: {tx:#?}");
-                        tx
-                    }
+                    Ok(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) => {
-                        tracing::error!(
-                            "Failed to execute transaction when executing the contract: {}, {:?}",
-                            &*input.instance,
-                            err
-                        );
-                        Err(err)
-                    }
+                    Err(err) => Err(err),
                }
            }
        }
    }

+    #[instrument(level = "info", skip_all)]
    async fn handle_input_call_frame_tracing(
        &self,
        execution_receipt: &TransactionReceipt,
@@ -266,7 +242,10 @@ where
                tracer_config: GethDebugTracerConfig(serde_json::json! {{
                    "onlyTopCall": true,
                    "withLog": false,
-                    "withReturnData": false
+                    "withStorage": false,
+                    "withMemory": false,
+                    "withStack": false,
+                    "withReturnData": true
                }}),
                ..Default::default()
            },
@@ -279,6 +258,7 @@ where
        })
    }

+    #[instrument(level = "info", skip_all)]
    fn handle_input_variable_assignment(
        &mut self,
        input: &Input,
@@ -309,16 +289,14 @@ where
        Ok(())
    }

+    #[instrument(level = "info", skip_all)]
    async fn handle_input_expectations(
-        &mut self,
+        &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 {
@@ -347,24 +325,25 @@ where
            }
        }

-        for expectation in expectations.iter() {
-            self.handle_input_expectation_item(
-                execution_receipt,
-                resolver,
-                expectation,
-                tracing_result,
-            )
-            .await?;
-        }
-
-        Ok(())
+        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
    }

+    #[instrument(level = "info", skip_all)]
    async fn handle_input_expectation_item(
-        &mut self,
+        &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 {
@@ -502,15 +481,12 @@ where
        Ok(())
    }

+    #[instrument(level = "info", skip_all)]
    async fn handle_input_diff(
-        &mut self,
-        _: CaseIdx,
-        execution_receipt: TransactionReceipt,
+        &self,
+        execution_receipt: &TransactionReceipt,
        node: &T::Blockchain,
-    ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
-        let span = tracing::info_span!("Handling input diff");
-        let _guard = span.enter();
-
+    ) -> anyhow::Result<(GethTrace, DiffMode)> {
        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
            diff_mode: Some(true),
            disable_code: None,
@@ -518,13 +494,14 @@ where
        });

        let trace = node
-            .trace_transaction(&execution_receipt, trace_options)
+            .trace_transaction(execution_receipt, trace_options)
            .await?;
-        let diff = node.state_diff(&execution_receipt).await?;
+        let diff = node.state_diff(execution_receipt).await?;

-        Ok((execution_receipt, trace, diff))
+        Ok((trace, diff))
    }

+    #[instrument(level = "info", skip_all)]
    pub async fn handle_balance_assertion_contract_deployment(
        &mut self,
        metadata: &Metadata,
@@ -550,6 +527,7 @@ where
        Ok(())
    }

+    #[instrument(level = "info", skip_all)]
    pub async fn handle_balance_assertion_execution(
        &mut self,
        BalanceAssertion {
@@ -585,6 +563,7 @@ where
        Ok(())
    }

+    #[instrument(level = "info", skip_all)]
    pub async fn handle_storage_empty_assertion_contract_deployment(
        &mut self,
        metadata: &Metadata,
@@ -610,6 +589,7 @@ where
        Ok(())
    }

+    #[instrument(level = "info", skip_all)]
    pub async fn handle_storage_empty_assertion_execution(
        &mut self,
        StorageEmptyAssertion {
@@ -662,7 +642,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));
        }

@@ -671,7 +651,6 @@ 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
@@ -684,11 +663,6 @@ 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
@@ -737,7 +711,6 @@ 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!(
@@ -746,8 +719,10 @@ where
            "Deployed contract"
        );

-        self.deployed_contracts
-            .insert(contract_instance.clone(), (address, abi.clone()));
+        self.deployed_contracts.insert(
+            contract_instance.clone(),
+            (contract_ident, address, abi.clone()),
+        );

        Ok((address, abi, Some(receipt)))
    }
@@ -762,7 +737,6 @@ 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>,
@@ -778,7 +752,6 @@ 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>,
@@ -787,7 +760,6 @@ where
        Self {
            metadata,
            case,
-            case_idx: case_idx.into(),
            leader_node,
            follower_node,
            leader_state,
@@ -795,79 +767,44 @@ where
        }
    }

-    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}");
-        }
-    }
-
+    #[instrument(level = "info", name = "Executing Case", skip_all)]
    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);
+        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",
+                    ))
+            )?;

-            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(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::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::BalanceAssertion, StepOutput::BalanceAssertion) => {}
                (StepOutput::StorageEmptyAssertion, StepOutput::StorageEmptyAssertion) => {}
@@ -17,6 +17,7 @@ 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 }
@@ -25,3 +26,6 @@ serde_json = { workspace = true }

 [dev-dependencies]
 tokio = { workspace = true }
+
+[lints]
+workspace = true
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};

-use revive_dt_common::macros::define_wrapper_type;
+use revive_dt_common::{macros::define_wrapper_type, types::Mode};

 use crate::{
    input::{Expected, Step},
@@ -60,16 +60,17 @@ impl Case {
                }
            })
    }
+
+    pub fn solc_modes(&self) -> Vec<Mode> {
+        match &self.modes {
+            Some(modes) => ParsedMode::many_to_modes(modes.iter()).collect(),
+            None => Mode::all().collect(),
+        }
+    }
 }

 define_wrapper_type!(
    /// A wrapper type for the index of test cases found in metadata file.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub struct CaseIdx(usize);
+    pub struct CaseIdx(usize) impl Display;
 );
-
-impl std::fmt::Display for CaseIdx {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
@@ -3,97 +3,127 @@ use std::{
    path::{Path, PathBuf},
 };

-use revive_dt_common::cached_fs::read_dir;
+use revive_dt_common::iterators::FilesWithExtensionIterator;
 use serde::{Deserialize, Serialize};
+use tracing::{debug, info};

-use crate::metadata::MetadataFile;
+use crate::metadata::{Metadata, MetadataFile};

-#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq, Hash)]
-pub struct Corpus {
-    pub name: String,
-    pub path: PathBuf,
+#[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> },
 }

 impl Corpus {
-    /// Try to read and parse the corpus definition file at given `path`.
-    pub fn try_from_path(path: &Path) -> anyhow::Result<Self> {
-        let file = File::open(path)?;
-        let mut corpus: Corpus = serde_json::from_reader(file)?;
+    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))?;

-        // Ensure that the path mentioned in the corpus is relative to the corpus file.
-        // Canonicalizing also helps make the path in any errors unambiguous.
-        corpus.path = path
-            .parent()
-            .ok_or_else(|| {
-                anyhow::anyhow!("Corpus path '{}' does not point to a file", path.display())
-            })?
-            .canonicalize()
-            .map_err(|error| {
-                anyhow::anyhow!(
-                    "Failed to canonicalize path to corpus '{}': {error}",
-                    path.display()
-                )
-            })?
-            .join(corpus.path);
+        for path in corpus.paths_iter_mut() {
+            *path = file_path
+                .as_ref()
+                .parent()
+                .ok_or_else(|| {
+                    anyhow::anyhow!("Corpus path '{}' does not point to a file", path.display())
+                })?
+                .canonicalize()
+                .map_err(|error| {
+                    anyhow::anyhow!(
+                        "Failed to canonicalize path to corpus '{}': {error}",
+                        path.display()
+                    )
+                })?
+                .join(path.as_path())
+        }

        Ok(corpus)
    }

-    /// Scan the corpus base directory and return all tests found.
    pub fn enumerate_tests(&self) -> Vec<MetadataFile> {
-        let mut tests = Vec::new();
-        collect_metadata(&self.path, &mut tests);
+        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"
+        );
        tests
    }
-}

-/// 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;
+    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 = _>>
            }
-        };
-
-        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)
-                }
+            Corpus::MultiplePaths { paths, .. } => {
+                Box::new(paths.iter().map(|path| path.as_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)
+    }
+
+    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 {
-            tracing::error!(?extension, "Unsupported file extension");
+            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(),
        }
    }
 }
@@ -2,7 +2,6 @@ use std::collections::HashMap;

 use alloy::{
    eips::BlockNumberOrTag,
-    hex::ToHexExt,
    json_abi::Function,
    network::TransactionBuilder,
    primitives::{Address, Bytes, U256},
@@ -10,10 +9,12 @@ 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};
@@ -33,6 +34,11 @@ 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")]
@@ -188,7 +194,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);
+    pub struct CalldataItem(String) impl Display;
 }

 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
@@ -233,7 +239,7 @@ pub enum Method {

 define_wrapper_type!(
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub struct EtherValue(U256);
+    pub struct EtherValue(U256) impl Display;
 );

 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
@@ -268,15 +274,9 @@ impl Input {
            }
            Method::FunctionName(ref function_name) => {
                let Some(abi) = context.deployed_contract_abi(&self.instance) else {
-                    tracing::error!(
-                        contract_name = self.instance.as_ref(),
-                        "Attempted to lookup ABI of contract but it wasn't found"
-                    );
                    anyhow::bail!("ABI for instance '{}' not found", self.instance.as_ref());
                };

-                tracing::trace!("ABI found for instance: {}", &self.instance.as_ref());
-
                // We follow the same logic that's implemented in the matter-labs-tester where they resolve
                // the function name into a function selector and they assume that he function doesn't have
                // any existing overloads.
@@ -302,13 +302,6 @@ impl Input {
                        .selector()
                };

-                tracing::trace!("Functions found for instance: {}", self.instance.as_ref());
-
-                tracing::trace!(
-                    "Starting encoding ABI's parameters for instance: {}",
-                    self.instance.as_ref()
-                );
-
                // Allocating a vector that we will be using for the calldata. The vector size will be:
                // 4 bytes for the function selector.
                // function.inputs.len() * 32 bytes for the arguments (each argument is a U256).
@@ -435,17 +428,18 @@ impl Calldata {
                buffer.extend_from_slice(bytes);
            }
            Calldata::Compound(items) => {
-                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);
-                        }
-                    };
-                }
+                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?;
+
+                buffer.extend(resolved.into_iter().flatten());
            }
        };
        Ok(())
@@ -468,36 +462,37 @@ impl Calldata {
        match self {
            Calldata::Single(calldata) => Ok(calldata == other),
            Calldata::Compound(items) => {
-                // 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;
-                    }
+                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);
+                        }

-                    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?;
-                    let other = U256::from_be_slice(&other);
-                    if this != other {
-                        return Ok(false);
-                    }
-                }
-                Ok(true)
+                        let this = this.resolve(resolver, context).await?;
+                        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
            }
        }
    }
 }

 impl CalldataItem {
+    #[instrument(level = "info", skip_all, err)]
    async fn resolve(
        &self,
        resolver: &impl ResolverApi,
@@ -548,14 +543,7 @@ 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)] => {
-                tracing::debug!(
-                    original = self.0,
-                    resolved = item.to_be_bytes::<32>().encode_hex(),
-                    "Resolved a Calldata item"
-                );
-                Ok(*item)
-            }
+            [CalldataToken::Item(item)] => Ok(*item),
            _ => Err(anyhow::anyhow!(
                "Invalid calldata arithmetic operation - Invalid stack"
            )),
@@ -739,12 +727,14 @@ 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 {
@@ -818,11 +808,11 @@ mod tests {
        let mut contracts = HashMap::new();
        contracts.insert(
            ContractInstance::new("Contract"),
-            (Address::ZERO, parsed_abi),
+            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
        );

        let resolver = MockResolver;
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
        let encoded = input.encoded_input(&resolver, context).await.unwrap();
        assert!(encoded.0.starts_with(&selector));

@@ -862,11 +852,11 @@ mod tests {
        let mut contracts = HashMap::new();
        contracts.insert(
            ContractInstance::new("Contract"),
-            (Address::ZERO, parsed_abi),
+            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
        );

        let resolver = MockResolver;
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
        let encoded = input.encoded_input(&resolver, context).await.unwrap();
        assert!(encoded.0.starts_with(&selector));

@@ -909,11 +899,11 @@ mod tests {
        let mut contracts = HashMap::new();
        contracts.insert(
            ContractInstance::new("Contract"),
-            (Address::ZERO, parsed_abi),
+            (ContractIdent::new("Contract"), Address::ZERO, parsed_abi),
        );

        let resolver = MockResolver;
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(&contracts);
        let encoded = input.encoded_input(&resolver, context).await.unwrap();
        assert!(encoded.0.starts_with(&selector));

@@ -927,10 +917,10 @@ mod tests {

    async fn resolve_calldata_item(
        input: &str,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        deployed_contracts: &HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
        resolver: &impl ResolverApi,
    ) -> anyhow::Result<U256> {
-        let context = ResolutionContext::new_from_parts(deployed_contracts, None, None, None);
+        let context = ResolutionContext::default().with_deployed_contracts(deployed_contracts);
        CalldataItem::new(input).resolve(resolver, context).await
    }

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

@@ -24,16 +25,26 @@ pub const SOLIDITY_CASE_COMMENT_MARKER: &str = "//!";

 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct MetadataFile {
-    pub path: PathBuf,
+    /// The path of the metadata file. This will either be a JSON or solidity file.
+    pub metadata_file_path: PathBuf,
+
+    /// This is the path contained within the corpus file. This could either be the path of some dir
+    /// or could be the actual metadata file path.
+    pub corpus_file_path: PathBuf,
+
+    /// The metadata contained within the file.
    pub content: Metadata,
 }

 impl MetadataFile {
-    pub fn try_from_file(path: &Path) -> Option<Self> {
-        Metadata::try_from_file(path).map(|metadata| Self {
-            path: path.to_owned(),
-            content: metadata,
-        })
+    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()
+        }
    }
 }

@@ -145,10 +156,7 @@ impl Metadata {
    pub fn try_from_file(path: &Path) -> Option<Self> {
        assert!(path.is_file(), "not a file: {}", path.display());

-        let Some(file_extension) = path.extension() else {
-            tracing::debug!("skipping corpus file: {}", path.display());
-            return None;
-        };
+        let file_extension = path.extension()?;

        if file_extension == METADATA_FILE_EXTENSION {
            return Self::try_from_json(path);
@@ -158,18 +166,12 @@ impl Metadata {
            return Self::try_from_solidity(path);
        }

-        tracing::debug!("ignoring invalid corpus file: {}", path.display());
        None
    }

    fn try_from_json(path: &Path) -> Option<Self> {
        let file = File::open(path)
-            .inspect_err(|error| {
-                tracing::error!(
-                    "opening JSON test metadata file '{}' error: {error}",
-                    path.display()
-                );
-            })
+            .inspect_err(|err| error!(path = %path.display(), %err, "Failed to open file"))
            .ok()?;

        match serde_json::from_reader::<_, Metadata>(file) {
@@ -177,11 +179,8 @@ impl Metadata {
                metadata.file_path = Some(path.to_path_buf());
                Some(metadata)
            }
-            Err(error) => {
-                tracing::error!(
-                    "parsing JSON test metadata file '{}' error: {error}",
-                    path.display()
-                );
+            Err(err) => {
+                error!(path = %path.display(), %err, "Deserialization of metadata failed");
                None
            }
        }
@@ -189,12 +188,7 @@ impl Metadata {

    fn try_from_solidity(path: &Path) -> Option<Self> {
        let spec = read_to_string(path)
-            .inspect_err(|error| {
-                tracing::error!(
-                    "opening JSON test metadata file '{}' error: {error}",
-                    path.display()
-                );
-            })
+            .inspect_err(|err| error!(path = %path.display(), %err, "Failed to read file content"))
            .ok()?
            .lines()
            .filter_map(|line| line.strip_prefix(SOLIDITY_CASE_COMMENT_MARKER))
@@ -222,11 +216,8 @@ impl Metadata {
                );
                Some(metadata)
            }
-            Err(error) => {
-                tracing::error!(
-                    "parsing Solidity test metadata file '{}' error: '{error}' from data: {spec}",
-                    path.display()
-                );
+            Err(err) => {
+                error!(path = %path.display(), %err, "Failed to deserialize metadata");
                None
            }
        }
@@ -266,7 +257,7 @@ define_wrapper_type!(
        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
    )]
    #[serde(transparent)]
-    pub struct ContractInstance(String);
+    pub struct ContractInstance(String) impl Display;
 );

 define_wrapper_type!(
@@ -277,7 +268,7 @@ define_wrapper_type!(
        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
    )]
    #[serde(transparent)]
-    pub struct ContractIdent(String);
+    pub struct ContractIdent(String) impl Display;
 );

 /// Represents an identifier used for contracts.
@@ -223,7 +223,7 @@ mod tests {

        for (actual, expected) in strings {
            let parsed = ParsedMode::from_str(actual)
-                .expect(format!("Failed to parse mode string '{actual}'").as_str());
+                .unwrap_or_else(|_| panic!("Failed to parse mode string '{actual}'"));
            assert_eq!(
                expected,
                parsed.to_string(),
@@ -249,7 +249,7 @@ mod tests {

        for (actual, expected) in strings {
            let parsed = ParsedMode::from_str(actual)
-                .expect(format!("Failed to parse mode string '{actual}'").as_str());
+                .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();

@@ -6,7 +6,7 @@ use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId
 use alloy_primitives::TxHash;
 use anyhow::Result;

-use crate::metadata::ContractInstance;
+use crate::metadata::{ContractIdent, ContractInstance};

 /// A trait of the interface are required to implement to be used by the resolution logic that this
 /// crate implements to go from string calldata and into the bytes calldata.
@@ -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, (Address, JsonAbi)>>,
+    deployed_contracts: Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,

    /// When provided the variables in here will be used for performing resolutions.
    variables: Option<&'a HashMap<String, U256>>,
@@ -66,7 +66,9 @@ impl<'a> ResolutionContext<'a> {
    }

    pub fn new_from_parts(
-        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+        deployed_contracts: impl Into<
+            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+        >,
        variables: impl Into<Option<&'a HashMap<String, U256>>>,
        block_number: impl Into<Option<&'a BlockNumber>>,
        transaction_hash: impl Into<Option<&'a TxHash>>,
@@ -81,7 +83,9 @@ impl<'a> ResolutionContext<'a> {

    pub fn with_deployed_contracts(
        mut self,
-        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+        deployed_contracts: impl Into<
+            Option<&'a HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+        >,
    ) -> Self {
        self.deployed_contracts = deployed_contracts.into();
        self
@@ -122,17 +126,20 @@ impl<'a> ResolutionContext<'a> {
        }
    }

-    pub fn deployed_contract(&self, instance: &ContractInstance) -> Option<&(Address, JsonAbi)> {
+    pub fn deployed_contract(
+        &self,
+        instance: &ContractInstance,
+    ) -> Option<&(ContractIdent, Address, JsonAbi)> {
        self.deployed_contracts
            .and_then(|deployed_contracts| deployed_contracts.get(instance))
    }

    pub fn deployed_contract_address(&self, instance: &ContractInstance) -> Option<&Address> {
-        self.deployed_contract(instance).map(|(a, _)| a)
+        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> {
@@ -11,3 +11,6 @@ rust-version.workspace = true
 [dependencies]
 alloy = { workspace = true }
 anyhow = { workspace = true }
+
+[lints]
+workspace = true
@@ -29,3 +29,6 @@ sp-runtime = { workspace = true }
 [dev-dependencies]
 temp-dir = { workspace = true }
 tokio = { workspace = true }
+
+[lints]
+workspace = true
@@ -33,9 +33,12 @@ use alloy::{
 };
 use anyhow::Context;
 use revive_common::EVMVersion;
-use tracing::{Instrument, Level};
+use tracing::{Instrument, instrument};

-use revive_dt_common::{fs::clear_directory, futures::poll};
+use revive_dt_common::{
+    fs::clear_directory,
+    futures::{PollingWaitBehavior, poll},
+};
 use revive_dt_config::Arguments;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::EthereumNode;
@@ -52,6 +55,7 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
+#[allow(clippy::type_complexity)]
 pub struct GethNode {
    connection_string: String,
    base_directory: PathBuf,
@@ -61,8 +65,9 @@ pub struct GethNode {
    id: u32,
    handle: Option<Child>,
    start_timeout: u64,
-    wallet: EthereumWallet,
+    wallet: Arc<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
@@ -91,7 +96,7 @@ impl GethNode {
    const TRACE_POLLING_DURATION: Duration = Duration::from_secs(60);

    /// Create the node directory and call `geth init` to configure the genesis.
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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);
@@ -141,7 +146,7 @@ impl GethNode {
    /// Spawn the go-ethereum node child process.
    ///
    /// [Instance::init] must be called prior.
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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:
@@ -197,7 +202,7 @@ impl GethNode {
    /// Wait for the g-ethereum node child process getting ready.
    ///
    /// [Instance::spawn_process] must be called priorly.
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[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();

@@ -231,83 +236,75 @@ impl GethNode {
        }
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn geth_stdout_log_file_path(&self) -> PathBuf {
        self.logs_directory.join(Self::GETH_STDOUT_LOG_FILE_NAME)
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn geth_stderr_log_file_path(&self) -> PathBuf {
        self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
    }

-    fn provider(
+    async fn provider(
        &self,
-    ) -> 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,
-                    1_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)
-        })
+    ) -> anyhow::Result<FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>>
+    {
+        ProviderBuilder::new()
+            .disable_recommended_fillers()
+            .filler(FallbackGasFiller::new(
+                25_000_000,
+                1_000_000_000,
+                1_000_000_000,
+            ))
+            .filler(self.chain_id_filler.clone())
+            .filler(NonceFiller::new(self.nonce_manager.clone()))
+            .wallet(self.wallet.clone())
+            .connect(&self.connection_string)
+            .await
+            .map_err(Into::into)
    }
 }

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

-        let provider = Arc::new(self.provider().await?);
-        let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();
+        let pending_transaction = provider.send_transaction(transaction).await.inspect_err(
+            |err| tracing::error!(%err, "Encountered an error when submitting the transaction"),
+        )?;
+        let transaction_hash = *pending_transaction.tx_hash();

-        // The following is a fix for the "transaction indexing is in progress" error that we
-        // used to get. You can find more information on this in the following GH issue in geth
+        // The following is a fix for the "transaction indexing is in progress" error that we used
+        // to get. You can find more information on this in the following GH issue in geth
        // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
        // before we can get the receipt of the transaction it needs to have been indexed by the
-        // node's indexer. Just because the transaction has been confirmed it doesn't mean that
-        // it has been indexed. When we call alloy's `get_receipt` it checks if the transaction
-        // was confirmed. If it has been, then it will call `eth_getTransactionReceipt` method
-        // which _might_ return the above error if the tx has not yet been indexed yet. So, we
-        // need to implement a retry mechanism for the receipt to keep retrying to get it until
-        // it eventually works, but we only do that if the error we get back is the "transaction
+        // node's indexer. Just because the transaction has been confirmed it doesn't mean that it
+        // has been indexed. When we call alloy's `get_receipt` it checks if the transaction was
+        // confirmed. If it has been, then it will call `eth_getTransactionReceipt` method which
+        // _might_ return the above error if the tx has not yet been indexed yet. So, we need to
+        // implement a retry mechanism for the receipt to keep retrying to get it until it
+        // eventually works, but we only do that if the error we get back is the "transaction
        // indexing is in progress" error or if the receipt is None.
        //
-        // Getting the transaction indexed and taking a receipt can take a long time especially
-        // when a lot of transactions are being submitted to the node. Thus, while initially we
-        // only allowed for 60 seconds of waiting with a 1 second delay in polling, we need to
-        // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
-        // with exponential backoff each time we attempt to get the receipt and find that it's
-        // not available.
+        // 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,
-            Default::default(),
+            PollingWaitBehavior::Constant(Duration::from_millis(200)),
            move || {
                let provider = provider.clone();
                async move {
@@ -332,7 +329,7 @@ impl EthereumNode for GethNode {
        .await
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn trace_transaction(
        &self,
        transaction: &TransactionReceipt,
@@ -341,7 +338,7 @@ impl EthereumNode for GethNode {
        let provider = Arc::new(self.provider().await?);
        poll(
            Self::TRACE_POLLING_DURATION,
-            Default::default(),
+            PollingWaitBehavior::Constant(Duration::from_millis(200)),
            move || {
                let provider = provider.clone();
                let trace_options = trace_options.clone();
@@ -365,7 +362,7 @@ impl EthereumNode for GethNode {
        .await
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
            diff_mode: Some(true),
@@ -382,7 +379,7 @@ impl EthereumNode for GethNode {
        }
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
        self.provider()
            .await?
@@ -391,7 +388,7 @@ impl EthereumNode for GethNode {
            .map_err(Into::into)
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn latest_state_proof(
        &self,
        address: Address,
@@ -407,7 +404,7 @@ impl EthereumNode for GethNode {
 }

 impl ResolverApi for GethNode {
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
        self.provider()
            .await?
@@ -416,7 +413,7 @@ impl ResolverApi for GethNode {
            .map_err(Into::into)
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
        self.provider()
            .await?
@@ -426,7 +423,7 @@ impl ResolverApi for GethNode {
            .map(|receipt| receipt.effective_gas_price)
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
        self.provider()
            .await?
@@ -436,7 +433,7 @@ impl ResolverApi for GethNode {
            .map(|block| block.header.gas_limit as _)
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
        self.provider()
            .await?
@@ -446,7 +443,7 @@ impl ResolverApi for GethNode {
            .map(|block| block.header.beneficiary)
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
        self.provider()
            .await?
@@ -456,7 +453,7 @@ impl ResolverApi for GethNode {
            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
        self.provider()
            .await?
@@ -471,7 +468,7 @@ impl ResolverApi for GethNode {
            })
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
        self.provider()
            .await?
@@ -481,7 +478,7 @@ impl ResolverApi for GethNode {
            .map(|block| block.header.hash)
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
        self.provider()
            .await?
@@ -491,7 +488,7 @@ impl ResolverApi for GethNode {
            .map(|block| block.header.timestamp)
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
        self.provider()
            .await?
@@ -525,20 +522,26 @@ impl Node for GethNode {
            id,
            handle: None,
            start_timeout: config.geth_start_timeout,
-            wallet,
+            wallet: Arc::new(wallet),
+            chain_id_filler: Default::default(),
+            nonce_manager: Default::default(),
            // We know that we only need to be storing 2 files so we can specify that when creating
            // the vector. It's the stdout and stderr of the geth node.
            logs_file_to_flush: Vec::with_capacity(2),
-            nonce_manager: Default::default(),
        }
    }

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

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

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

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn version(&self) -> anyhow::Result<String> {
        let output = Command::new(&self.geth)
            .arg("--version")
@@ -579,8 +582,7 @@ impl Node for GethNode {
        Ok(String::from_utf8_lossy(&output).into())
    }

-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-    fn matches_target(&self, targets: Option<&[String]>) -> bool {
+    fn matches_target(targets: Option<&[String]>) -> bool {
        match targets {
            None => true,
            Some(targets) => targets.iter().any(|str| str.as_str() == "evm"),
@@ -593,7 +595,7 @@ impl Node for GethNode {
 }

 impl Drop for GethNode {
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
    fn drop(&mut self) {
        self.shutdown().expect("Failed to shutdown")
    }
@@ -3,7 +3,10 @@ use std::{
    io::{BufRead, Write},
    path::{Path, PathBuf},
    process::{Child, Command, Stdio},
-    sync::atomic::{AtomicU32, Ordering},
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering},
+    },
    time::Duration,
 };

@@ -39,7 +42,6 @@ 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,12 +56,13 @@ pub struct KitchensinkNode {
    substrate_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,
    /// 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
@@ -87,7 +90,6 @@ 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);
@@ -160,7 +162,6 @@ impl KitchensinkNode {
        Ok(self)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    fn spawn_process(&mut self) -> anyhow::Result<()> {
        let substrate_rpc_port = Self::BASE_SUBSTRATE_RPC_PORT + self.id as u16;
        let proxy_rpc_port = Self::BASE_PROXY_RPC_PORT + self.id as u16;
@@ -214,10 +215,6 @@ impl KitchensinkNode {
            Self::SUBSTRATE_READY_MARKER,
            Duration::from_secs(60),
        ) {
-            tracing::error!(
-                ?error,
-                "Failed to start substrate, shutting down gracefully"
-            );
            self.shutdown()?;
            return Err(error);
        };
@@ -243,7 +240,6 @@ impl KitchensinkNode {
            Self::ETH_PROXY_READY_MARKER,
            Duration::from_secs(60),
        ) {
-            tracing::error!(?error, "Failed to start proxy, shutting down gracefully");
            self.shutdown()?;
            return Err(error);
        };
@@ -258,7 +254,6 @@ impl KitchensinkNode {
        Ok(())
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    fn extract_balance_from_genesis_file(
        &self,
        genesis: &Genesis,
@@ -307,7 +302,6 @@ 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")
@@ -320,74 +314,55 @@ 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)
    }

-    fn provider(
+    async fn provider(
        &self,
-    ) -> impl Future<
-        Output = anyhow::Result<
-            FillProvider<
-                impl TxFiller<KitchenSinkNetwork>,
-                impl Provider<KitchenSinkNetwork>,
-                KitchenSinkNetwork,
-            >,
+    ) -> anyhow::Result<
+        FillProvider<
+            impl TxFiller<KitchenSinkNetwork>,
+            impl Provider<KitchenSinkNetwork>,
+            KitchenSinkNetwork,
        >,
-    > + 'static {
-        let connection_string = self.connection_string();
-        let wallet = self.wallet.clone();
-
-        // Note: We would like all providers to make use of the same nonce manager so that we have
-        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
-        // its implementation and therefore it means that when we clone it then it still references
-        // the same state.
-        let nonce_manager = self.nonce_manager.clone();
-
-        Box::pin(async move {
-            ProviderBuilder::new()
-                .disable_recommended_fillers()
-                .network::<KitchenSinkNetwork>()
-                .filler(FallbackGasFiller::new(
-                    25_000_000,
-                    1_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)
-        })
+    > {
+        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)
    }
 }

 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?
@@ -395,11 +370,9 @@ impl EthereumNode for KitchensinkNode {
            .await?
            .get_receipt()
            .await?;
-        tracing::info!(?receipt, "Submitted tx to kitchensink");
        Ok(receipt)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn trace_transaction(
        &self,
        transaction: &TransactionReceipt,
@@ -413,7 +386,6 @@ impl EthereumNode for KitchensinkNode {
            .await?)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
            diff_mode: Some(true),
@@ -430,7 +402,6 @@ 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?
@@ -439,7 +410,6 @@ impl EthereumNode for KitchensinkNode {
            .map_err(Into::into)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn latest_state_proof(
        &self,
        address: Address,
@@ -455,7 +425,6 @@ 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?
@@ -464,7 +433,6 @@ impl ResolverApi for KitchensinkNode {
            .map_err(Into::into)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
        self.provider()
            .await?
@@ -474,7 +442,6 @@ impl ResolverApi for KitchensinkNode {
            .map(|receipt| receipt.effective_gas_price)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
        self.provider()
            .await?
@@ -484,7 +451,6 @@ impl ResolverApi for KitchensinkNode {
            .map(|block| block.header.gas_limit as _)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
        self.provider()
            .await?
@@ -494,7 +460,6 @@ impl ResolverApi for KitchensinkNode {
            .map(|block| block.header.beneficiary)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
        self.provider()
            .await?
@@ -504,7 +469,6 @@ impl ResolverApi for KitchensinkNode {
            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
        self.provider()
            .await?
@@ -519,7 +483,6 @@ 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?
@@ -529,7 +492,6 @@ impl ResolverApi for KitchensinkNode {
            .map(|block| block.header.hash)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
        self.provider()
            .await?
@@ -539,7 +501,6 @@ impl ResolverApi for KitchensinkNode {
            .map(|block| block.header.timestamp)
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
        self.provider()
            .await?
@@ -570,11 +531,12 @@ impl Node for KitchensinkNode {
            substrate_binary: config.kitchensink.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(),
            // 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.
@@ -582,12 +544,14 @@ impl Node for KitchensinkNode {
        }
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    fn id(&self) -> usize {
+        self.id as _
+    }
+
    fn connection_string(&self) -> String {
        self.rpc_url.clone()
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
    fn shutdown(&mut self) -> anyhow::Result<()> {
        // Terminate the processes in a graceful manner to allow for the output to be flushed.
        if let Some(mut child) = self.process_proxy.take() {
@@ -614,12 +578,10 @@ 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")
@@ -632,8 +594,7 @@ impl Node for KitchensinkNode {
        Ok(String::from_utf8_lossy(&output).into())
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
-    fn matches_target(&self, targets: Option<&[String]>) -> bool {
+    fn matches_target(targets: Option<&[String]>) -> bool {
        match targets {
            None => true,
            Some(targets) => targets.iter().any(|str| str.as_str() == "pvm"),
@@ -646,7 +607,6 @@ 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")
    }
@@ -18,6 +18,9 @@ pub trait Node: EthereumNode {
    /// Create a new uninitialized instance.
    fn new(config: &Arguments) -> Self;

+    /// Returns the identifier of the node.
+    fn id(&self) -> usize;
+
    /// Spawns a node configured according to the genesis json.
    ///
    /// Blocking until it's ready to accept transactions.
@@ -36,7 +39,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(&self, targets: Option<&[String]>) -> bool;
+    fn matches_target(targets: Option<&[String]>) -> bool;

    /// Returns the EVM version of the node.
    fn evm_version() -> EVMVersion;
@@ -63,7 +63,6 @@ where

 fn spawn_node<T: Node + Send>(args: &Arguments, genesis: String) -> anyhow::Result<T> {
    let mut node = T::new(args);
-    tracing::info!("starting node: {}", node.connection_string());
    node.spawn(genesis)?;
    Ok(node)
 }
@@ -14,6 +14,8 @@ revive-dt-format = { workspace = true }
 revive-dt-compiler = { workspace = true }

 anyhow = { workspace = true }
-tracing = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+
+[lints]
+workspace = true
@@ -185,8 +185,6 @@ impl Report {
        let file = File::create(&path).context(path.display().to_string())?;
        serde_json::to_writer_pretty(file, &self)?;

-        tracing::info!("report written to: {}", path.display());
-
        Ok(())
    }
 }
@@ -19,3 +19,6 @@ reqwest = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 sha2 = { workspace = true }
+
+[lints]
+workspace = true
@@ -39,10 +39,7 @@ pub(crate) async fn get_or_download(
 }

 async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::Result<()> {
-    tracing::info!("caching file: {}", path.display());
-
    let Ok(file) = File::create_new(path) else {
-        tracing::debug!("cache file already exists: {}", path.display());
        return Ok(());
    };

@@ -107,7 +107,6 @@ impl SolcDownloader {
    /// Errors out if the download fails or the digest of the downloaded file
    /// mismatches the expected digest from the release [List].
    pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
-        tracing::info!("downloading solc: {self:?}");
        let builds = List::download(self.list).await?.builds;
        let build = builds
            .iter()
Author	SHA1	Message	Date
Omar Abdulla	b4a06e1ac5	Update the readme	2025-08-19 20:40:35 +03:00
Omar	76d6a154c1	Fix concurrency issues (#142 ) * Fix the OS FD error * Cache the compiler versions * Allow for auto display impl in declare wrapper type macro * Better logging and fix concurrency issues * Fix tests * Format * Make the code even more concurrent	2025-08-19 06:47:36 +00:00
Omar	c58551803d	Allow multiple files in corpus (#144 )	2025-08-16 16:04:17 +00:00
Omar	185edcfad9	Cached compiler artifacts (#143 ) * WIP compilation cache * Implement a persistent compilation cache * Correct the key and value encoding for the cache	2025-08-16 16:04:13 +00:00