Update the initial balance

Revert "Add extra comments"
This reverts commit bd4de2c83d.
2026-04-22 09:08:02 +00:00 · 2025-07-24 11:40:33 +03:00 · 2025-07-24 10:38:23 +03:00 · 2025-07-24 09:48:18 +03:00 · 2025-07-24 09:39:08 +03:00 · 2025-07-24 09:39:00 +03:00
22 changed files with 1926 additions and 759 deletions
@@ -67,9 +67,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+[[package]]
+name = "alloy-tx-macros"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1154c8187a5ff985c95a8b2daa2fedcf778b17d7668e5e50e556c4ff9c881154"
+dependencies = [
+ "alloy-primitives",
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -2400,7 +2417,7 @@ dependencies = [
 "futures-core",
 "futures-sink",
 "http",
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "slab",
 "tokio",
 "tokio-util",
@@ -2842,9 +2859,9 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
 "equivalent",
 "hashbrown 0.15.3",
@@ -3268,13 +3285,14 @@ dependencies = [

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

 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
 "rand_chacha 0.9.0",
 "rand_core 0.9.3",
@@ -3962,6 +3980,7 @@ dependencies = [
 "alloy",
 "anyhow",
 "clap",
+ "indexmap 2.10.0",
 "rayon",
 "revive-dt-compiler",
 "revive-dt-config",
@@ -4112,7 +4131,7 @@ dependencies = [
 "primitive-types 0.12.2",
 "proptest",
 "rand 0.8.5",
- "rand 0.9.1",
+ "rand 0.9.2",
 "rlp",
 "ruint-macro",
 "serde",
@@ -4507,7 +4526,7 @@ dependencies = [
 "chrono",
 "hex",
 "indexmap 1.9.3",
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "serde",
 "serde_derive",
 "serde_json",
@@ -5396,7 +5415,7 @@ version = "0.22.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
 dependencies = [
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "serde",
 "serde_spanned",
 "toml_datetime",
@@ -5488,18 +5507,6 @@ dependencies = [
 "valuable",
 ]

-[[package]]
-name = "tracing-futures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
-dependencies = [
- "futures",
- "futures-task",
- "pin-project",
- "tracing",
-]
-
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -51,6 +51,7 @@ tracing-subscriber = { version = "0.3.19", default-features = false, features =
    "json",
    "env-filter",
 ] }
+indexmap = { version = "2.10.0", default-features = false }

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

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

 [profile.bench]
@@ -0,0 +1,326 @@
+{
+    "modes": [
+        "Y >=0.8.9",
+        "E",
+        "I"
+    ],
+    "cases": [
+        {
+            "name": "first",
+            "inputs": [
+                {
+                    "instance": "WBTC_1",
+                    "method": "#deployer",
+                    "calldata": [
+                        "0x40",
+                        "0x80",
+                        "4",
+                        "0x5742544300000000000000000000000000000000000000000000000000000000",
+                        "14",
+                        "0x5772617070656420425443000000000000000000000000000000000000000000"
+                    ],
+                    "expected": [
+                        "WBTC_1.address"
+                    ]
+                },
+                {
+                    "instance": "WBTC_2",
+                    "method": "#deployer",
+                    "calldata": [
+                        "0x40",
+                        "0x80",
+                        "4",
+                        "0x5742544300000000000000000000000000000000000000000000000000000000",
+                        "14",
+                        "0x5772617070656420425443000000000000000000000000000000000000000000"
+                    ],
+                    "expected": [
+                        "WBTC_2.address"
+                    ]
+                },
+                {
+                    "instance": "Mooniswap",
+                    "method": "#deployer",
+                    "calldata": [
+                        "0x0000000000000000000000000000000000000000000000000000000000000060",
+                        "0x00000000000000000000000000000000000000000000000000000000000000c0",
+                        "0x0000000000000000000000000000000000000000000000000000000000000100",
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                        "WBTC_1.address",
+                        "WBTC_2.address",
+                        "4",
+                        "0x5742544300000000000000000000000000000000000000000000000000000000",
+                        "14",
+                        "0x5772617070656420425443000000000000000000000000000000000000000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "Mooniswap.address"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef01000000000000000000000000000000"
+                                ],
+                                "values": []
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_1",
+                    "method": "_mint",
+                    "calldata": [
+                        "0xdeadbeef00000000000000000000000000000042",
+                        "1000000000"
+                    ],
+                    "expected": {
+                        "return_data": [],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "1000000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_2",
+                    "method": "_mint",
+                    "calldata": [
+                        "0xdeadbeef00000000000000000000000000000042",
+                        "1000000000"
+                    ],
+                    "expected": {
+                        "return_data": [],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "1000000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_1",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "approve",
+                    "calldata": [
+                        "Mooniswap.address",
+                        "500000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "0x0000000000000000000000000000000000000000000000000000000000000001"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "500000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "WBTC_2",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "approve",
+                    "calldata": [
+                        "Mooniswap.address",
+                        "500000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "0x0000000000000000000000000000000000000000000000000000000000000001"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "500000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "Mooniswap",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "deposit",
+                    "calldata": [
+                        "0x0000000000000000000000000000000000000000000000000000000000000040",
+                        "0x00000000000000000000000000000000000000000000000000000000000000a0",
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                        "10000000",
+                        "10000000",
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                        "1000000",
+                        "1000000"
+                    ],
+                    "expected": {
+                        "return_data": [
+                            "10000000"
+                        ],
+                        "events": [
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "1000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "490000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                                    "0xdeadbeef00000000000000000000000000000042",
+                                    "Mooniswap.address"
+                                ],
+                                "values": [
+                                    "490000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            },
+                            {
+                                "topics": [
+                                    "0x2da466a7b24304f47e87fa2e1e5a81b9831ce54fec19055ce277ca2f39ba42c4",
+                                    "0xdeadbeef00000000000000000000000000000042"
+                                ],
+                                "values": [
+                                    "10000000"
+                                ]
+                            }
+                        ],
+                        "exception": false
+                    }
+                },
+                {
+                    "instance": "Mooniswap",
+                    "caller": "0xdeadbeef00000000000000000000000000000042",
+                    "method": "swap",
+                    "calldata": [
+                        "WBTC_1.address",
+                        "WBTC_2.address",
+                        "5000",
+                        "5000",
+                        "0"
+                    ]
+                }
+            ],
+            "expected": {
+                "return_data": [
+                    "5000"
+                ],
+                "events": [
+                    {
+                        "topics": [
+                            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                            "0xdeadbeef00000000000000000000000000000042",
+                            "Mooniswap.address"
+                        ],
+                        "values": [
+                            "5000"
+                        ]
+                    },
+                    {
+                        "topics": [
+                            "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                            "0xdeadbeef00000000000000000000000000000042",
+                            "Mooniswap.address"
+                        ],
+                        "values": [
+                            "489995000"
+                        ]
+                    }
+                ],
+                "exception": false
+            }
+        }
+    ],
+    "contracts": {
+        "Mooniswap": "Mooniswap.sol:Mooniswap",
+        "WBTC_1": "ERC20/ERC20.sol:ERC20",
+        "WBTC_2": "ERC20/ERC20.sol:ERC20",
+        "VirtualBalance": "Mooniswap.sol:VirtualBalance",
+        "Math": "math/Math.sol:Math"
+    },
+    "libraries": {
+        "Mooniswap.sol": {
+            "VirtualBalance": "VirtualBalance"
+        },
+        "math/Math.sol": {
+            "Math": "Math"
+        }
+    },
+    "group": "Real life"
+}
@@ -73,6 +73,12 @@ pub struct Arguments {
    )]
    pub account: String,

+    /// This argument controls which private keys the nodes should have access to and be added to
+    /// its wallet signers. With a value of N, private keys (0, N] will be added to the signer set
+    /// of the node.
+    #[arg(long = "private-keys-count", default_value_t = 30)]
+    pub private_keys_to_add: usize,
+
    /// The differential testing leader node implementation.
    #[arg(short, long = "leader", default_value = "geth")]
    pub leader: TestingPlatform,
@@ -23,6 +23,7 @@ revive-dt-report = { workspace = true }
 alloy = { workspace = true }
 anyhow = { workspace = true }
 clap = { workspace = true }
+indexmap = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 rayon = { workspace = true }
@@ -0,0 +1,73 @@
+use std::{borrow::Cow, collections::HashSet, path::PathBuf};
+
+/// An iterator that finds files of a certain extension in the provided directory. You can think of
+/// this a glob pattern similar to: `${path}/**/*.md`
+pub struct FilesWithExtensionIterator {
+    /// The set of allowed extensions that that match the requirement and that should be returned
+    /// when found.
+    allowed_extensions: HashSet<Cow<'static, str>>,
+
+    /// The set of directories to visit next. This iterator does BFS and so these directories will
+    /// only be visited if we can't find any files in our state.
+    directories_to_search: Vec<PathBuf>,
+
+    /// The set of files matching the allowed extensions that were found. If there are entries in
+    /// this vector then they will be returned when the [`Iterator::next`] method is called. If not
+    /// then we visit one of the next directories to visit.
+    files_matching_allowed_extensions: Vec<PathBuf>,
+}
+
+impl FilesWithExtensionIterator {
+    pub fn new(root_directory: PathBuf) -> Self {
+        Self {
+            allowed_extensions: Default::default(),
+            directories_to_search: vec![root_directory],
+            files_matching_allowed_extensions: Default::default(),
+        }
+    }
+
+    pub fn with_allowed_extension(
+        mut self,
+        allowed_extension: impl Into<Cow<'static, str>>,
+    ) -> Self {
+        self.allowed_extensions.insert(allowed_extension.into());
+        self
+    }
+}
+
+impl Iterator for FilesWithExtensionIterator {
+    type Item = PathBuf;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(file_path) = self.files_matching_allowed_extensions.pop() {
+            return Some(file_path);
+        };
+
+        let directory_to_search = self.directories_to_search.pop()?;
+
+        // Read all of the entries in the directory. If we failed to read this dir's entires then we
+        // elect to just ignore it and look in the next directory, we do that by calling the next
+        // method again on the iterator, which is an intentional decision that we made here instead
+        // of panicking.
+        let Ok(dir_entries) = std::fs::read_dir(directory_to_search) else {
+            return self.next();
+        };
+
+        for entry in dir_entries.flatten() {
+            let entry_path = entry.path();
+            if entry_path.is_dir() {
+                self.directories_to_search.push(entry_path)
+            } else if entry_path.is_file()
+                && entry_path.extension().is_some_and(|ext| {
+                    self.allowed_extensions
+                        .iter()
+                        .any(|allowed| ext.eq_ignore_ascii_case(allowed.as_ref()))
+                })
+            {
+                self.files_matching_allowed_extensions.push(entry_path)
+            }
+        }
+
+        self.next()
+    }
+}
@@ -1,20 +1,21 @@
 //! The revive differential testing core library.
 //!
 //! This crate defines the testing configuration and
-//! provides a helper utilty to execute tests.
+//! provides a helper utility to execute tests.

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

+pub mod common;
 pub mod driver;

 /// One platform can be tested differentially against another.
 ///
 /// For this we need a blockchain node implementation and a compiler.
 pub trait Platform {
-    type Blockchain: EthereumNode;
+    type Blockchain: EthereumNode + Node;
    type Compiler: SolidityCompiler;

    /// Returns the matching [TestingPlatform] of the [revive_dt_config::Arguments].
@@ -1,6 +1,10 @@
 use serde::Deserialize;

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

 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct Case {
@@ -9,4 +13,37 @@ pub struct Case {
    pub modes: Option<Vec<Mode>>,
    pub inputs: Vec<Input>,
    pub group: Option<String>,
+    pub expected: Option<Expected>,
 }
+
+impl Case {
+    pub fn inputs_iterator(&self) -> impl Iterator<Item = Input> {
+        let inputs_len = self.inputs.len();
+        self.inputs
+            .clone()
+            .into_iter()
+            .enumerate()
+            .map(move |(idx, mut input)| {
+                if idx + 1 == inputs_len {
+                    if input.expected.is_none() {
+                        input.expected = self.expected.clone();
+                    }
+
+                    // TODO: What does it mean for us to have an `expected` field on the case itself
+                    // but the final input also has an expected field that doesn't match the one on
+                    // the case? What are we supposed to do with that final expected field on the
+                    // case?
+
+                    input
+                } else {
+                    input
+                }
+            })
+    }
+}
+
+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)]
+    CaseIdx(usize);
+);
@@ -7,23 +7,26 @@ use alloy::{
    primitives::{Address, Bytes, U256},
    rpc::types::TransactionRequest,
 };
+use alloy_primitives::{FixedBytes, utils::parse_units};
 use semver::VersionReq;
-use serde::Deserialize;
-use serde_json::Value;
+use serde::{Deserialize, Serialize};

 use revive_dt_node_interaction::EthereumNode;

+use crate::{define_wrapper_type, metadata::ContractInstance};
+
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct Input {
    #[serde(default = "default_caller")]
    pub caller: Address,
    pub comment: Option<String>,
    #[serde(default = "default_instance")]
-    pub instance: String,
+    pub instance: ContractInstance,
    pub method: Method,
-    pub calldata: Option<Calldata>,
+    #[serde(default)]
+    pub calldata: Calldata,
    pub expected: Option<Expected>,
-    pub value: Option<String>,
+    pub value: Option<EtherValue>,
    pub storage: Option<HashMap<String, Calldata>>,
 }

@@ -37,16 +40,24 @@ pub enum Expected {

 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct ExpectedOutput {
-    compiler_version: Option<VersionReq>,
-    return_data: Option<Calldata>,
-    events: Option<Value>,
-    exception: Option<bool>,
+    pub compiler_version: Option<VersionReq>,
+    pub return_data: Option<Calldata>,
+    pub events: Option<Vec<Event>>,
+    #[serde(default)]
+    pub exception: bool,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
+pub struct Event {
+    pub address: Option<Address>,
+    pub topics: Vec<String>,
+    pub values: Calldata,
 }

 #[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
 #[serde(untagged)]
 pub enum Calldata {
-    Single(String),
+    Single(Bytes),
    Compound(Vec<String>),
 }

@@ -71,109 +82,248 @@ pub enum Method {
    FunctionName(String),
 }

+define_wrapper_type!(
+    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    EtherValue(U256);
+);
+
+impl Serialize for EtherValue {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        format!("{} wei", self.0).serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for EtherValue {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let string = String::deserialize(deserializer)?;
+        let mut splitted = string.split(' ');
+        let (Some(value), Some(unit)) = (splitted.next(), splitted.next()) else {
+            return Err(serde::de::Error::custom("Failed to parse the value"));
+        };
+        let parsed = parse_units(value, unit.replace("eth", "ether"))
+            .map_err(|_| serde::de::Error::custom("Failed to parse units"))?
+            .into();
+        Ok(Self(parsed))
+    }
+}
+
+impl ExpectedOutput {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn with_success(mut self) -> Self {
+        self.exception = false;
+        self
+    }
+
+    pub fn with_failure(mut self) -> Self {
+        self.exception = true;
+        self
+    }
+
+    pub fn with_calldata(mut self, calldata: Calldata) -> Self {
+        self.return_data = Some(calldata);
+        self
+    }
+}
+
+impl Default for Calldata {
+    fn default() -> Self {
+        Self::Compound(Default::default())
+    }
+}
+
+impl Calldata {
+    pub fn find_all_contract_instances(&self, vec: &mut Vec<ContractInstance>) {
+        if let Calldata::Compound(compound) = self {
+            for item in compound {
+                if let Some(instance) = item.strip_suffix(".address") {
+                    vec.push(ContractInstance::new_from(instance))
+                }
+            }
+        }
+    }
+
+    pub fn calldata(
+        &self,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl EthereumNode,
+    ) -> anyhow::Result<Vec<u8>> {
+        let mut buffer = Vec::<u8>::with_capacity(self.size_requirement());
+        self.calldata_into_slice(&mut buffer, deployed_contracts, chain_state_provider)?;
+        Ok(buffer)
+    }
+
+    pub fn calldata_into_slice(
+        &self,
+        buffer: &mut Vec<u8>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl EthereumNode,
+    ) -> anyhow::Result<()> {
+        match self {
+            Calldata::Single(bytes) => {
+                buffer.extend_from_slice(bytes);
+            }
+            Calldata::Compound(items) => {
+                for (arg_idx, arg) in items.iter().enumerate() {
+                    match resolve_argument(arg, deployed_contracts, chain_state_provider) {
+                        Ok(resolved) => {
+                            buffer.extend(resolved.to_be_bytes::<32>());
+                        }
+                        Err(error) => {
+                            tracing::error!(arg, arg_idx, ?error, "Failed to resolve argument");
+                            return Err(error);
+                        }
+                    };
+                }
+            }
+        };
+        Ok(())
+    }
+
+    pub fn size_requirement(&self) -> usize {
+        match self {
+            Calldata::Single(single) => single.len(),
+            Calldata::Compound(items) => items.len() * 32,
+        }
+    }
+
+    /// Checks if this [`Calldata`] is equivalent to the passed calldata bytes.
+    pub fn is_equivalent(
+        &self,
+        other: &[u8],
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl EthereumNode,
+    ) -> anyhow::Result<bool> {
+        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 == "*" {
+                        continue;
+                    }
+
+                    let other = if other.len() < 32 {
+                        let mut vec = other.to_vec();
+                        vec.resize(32, 0);
+                        std::borrow::Cow::Owned(vec)
+                    } else {
+                        std::borrow::Cow::Borrowed(other)
+                    };
+
+                    let this = resolve_argument(this, deployed_contracts, chain_state_provider)?;
+                    let other = U256::from_be_slice(&other);
+                    if this != other {
+                        return Ok(false);
+                    }
+                }
+                Ok(true)
+            }
+        }
+    }
+}
+
 impl Input {
    fn instance_to_address(
        &self,
-        instance: &str,
-        deployed_contracts: &HashMap<String, Address>,
+        instance: &ContractInstance,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
    ) -> anyhow::Result<Address> {
        deployed_contracts
            .get(instance)
-            .copied()
-            .ok_or_else(|| anyhow::anyhow!("instance {instance} not deployed"))
+            .map(|(a, _)| *a)
+            .ok_or_else(|| anyhow::anyhow!("instance {instance:?} not deployed"))
    }

    pub fn encoded_input(
        &self,
-        deployed_abis: &HashMap<String, JsonAbi>,
-        deployed_contracts: &HashMap<String, Address>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
        chain_state_provider: &impl EthereumNode,
    ) -> anyhow::Result<Bytes> {
-        let Method::FunctionName(ref function_name) = self.method else {
-            return Ok(Bytes::default()); // fallback or deployer — no input
-        };
+        match self.method {
+            Method::Deployer | Method::Fallback => {
+                let calldata = self
+                    .calldata
+                    .calldata(deployed_contracts, chain_state_provider)?;

-        let Some(abi) = deployed_abis.get(&self.instance) else {
-            tracing::error!(
-                contract_name = self.instance,
-                available_abis = ?deployed_abis.keys().collect::<Vec<_>>(),
-                "Attempted to lookup ABI of contract but it wasn't found"
-            );
-            anyhow::bail!("ABI for instance '{}' not found", &self.instance);
-        };
+                Ok(calldata.into())
+            }
+            Method::FunctionName(ref function_name) => {
+                let Some(abi) = deployed_contracts.get(&self.instance).map(|(_, a)| a) else {
+                    tracing::error!(
+                        contract_name = self.instance.as_ref(),
+                        available_abis = ?deployed_contracts.keys().collect::<Vec<_>>(),
+                        "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);
+                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.
-        // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
-        let function = abi
-            .functions()
-            .find(|function| function.name.starts_with(function_name))
-            .ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Function with name {:?} not found in ABI for the instance {:?}",
-                    function_name,
-                    &self.instance
-                )
-            })?;
+                // 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.
+                // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
+                let function = abi
+                    .functions()
+                    .find(|function| function.signature().starts_with(function_name))
+                    .ok_or_else(|| {
+                        anyhow::anyhow!(
+                            "Function with name {:?} not found in ABI for the instance {:?}",
+                            function_name,
+                            &self.instance
+                        )
+                    })?;

-        tracing::trace!("Functions found for instance: {}", &self.instance);
+                tracing::trace!("Functions found for instance: {}", self.instance.as_ref());

-        let calldata_args = match &self.calldata {
-            Some(Calldata::Compound(args)) => args,
-            _ => anyhow::bail!("Expected compound calldata for function call"),
-        };
+                tracing::trace!(
+                    "Starting encoding ABI's parameters for instance: {}",
+                    self.instance.as_ref()
+                );

-        if calldata_args.len() != function.inputs.len() {
-            anyhow::bail!(
-                "Function expects {} args, but got {}",
-                function.inputs.len(),
-                calldata_args.len()
-            );
+                // 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).
+                //
+                // We're using indices in the following code in order to avoid the need for us to allocate
+                // a new buffer for each one of the resolved arguments.
+                let mut calldata = Vec::<u8>::with_capacity(4 + self.calldata.size_requirement());
+                calldata.extend(function.selector().0);
+                self.calldata.calldata_into_slice(
+                    &mut calldata,
+                    deployed_contracts,
+                    chain_state_provider,
+                )?;
+
+                Ok(calldata.into())
+            }
        }
-
-        tracing::trace!(
-            "Starting encoding ABI's parameters for instance: {}",
-            &self.instance
-        );
-
-        // 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).
-        //
-        // We're using indices in the following code in order to avoid the need for us to allocate
-        // a new buffer for each one of the resolved arguments.
-        let mut calldata = Vec::<u8>::with_capacity(4 + calldata_args.len() * 32);
-        calldata.extend(function.selector().0);
-
-        for (arg_idx, arg) in calldata_args.iter().enumerate() {
-            match resolve_argument(arg, deployed_contracts, chain_state_provider) {
-                Ok(resolved) => {
-                    calldata.extend(resolved.to_be_bytes::<32>());
-                }
-                Err(error) => {
-                    tracing::error!(arg, arg_idx, ?error, "Failed to resolve argument");
-                    return Err(error);
-                }
-            };
-        }
-
-        Ok(calldata.into())
    }

    /// Parse this input into a legacy transaction.
    pub fn legacy_transaction(
        &self,
-        nonce: u64,
-        deployed_contracts: &HashMap<String, Address>,
-        deployed_abis: &HashMap<String, JsonAbi>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
        chain_state_provider: &impl EthereumNode,
    ) -> anyhow::Result<TransactionRequest> {
-        let input_data =
-            self.encoded_input(deployed_abis, deployed_contracts, chain_state_provider)?;
-        let transaction_request = TransactionRequest::default().nonce(nonce);
+        let input_data = self.encoded_input(deployed_contracts, chain_state_provider)?;
+        let transaction_request = TransactionRequest::default().from(self.caller).value(
+            self.value
+                .map(|value| value.into_inner())
+                .unwrap_or_default(),
+        );
        match self.method {
            Method::Deployer => Ok(transaction_request.with_deploy_code(input_data)),
            _ => Ok(transaction_request
@@ -181,14 +331,25 @@ impl Input {
                .input(input_data.into())),
        }
    }
+
+    pub fn find_all_contract_instances(&self) -> Vec<ContractInstance> {
+        let mut vec = Vec::new();
+        vec.push(self.instance.clone());
+
+        self.calldata.find_all_contract_instances(&mut vec);
+
+        vec
+    }
 }

-fn default_instance() -> String {
-    "Test".to_string()
+fn default_instance() -> ContractInstance {
+    ContractInstance::new_from("Test")
 }

-fn default_caller() -> Address {
-    "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1".parse().unwrap()
+pub const fn default_caller() -> Address {
+    Address(FixedBytes(alloy::hex!(
+        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1"
+    )))
 }

 /// This function takes in the string calldata argument provided in the JSON input and resolves it
@@ -201,13 +362,14 @@ fn default_caller() -> Address {
 /// https://github.com/matter-labs/era-compiler-tester/blob/0ed598a27f6eceee7008deab3ff2311075a2ec69/compiler_tester/src/test/case/input/value.rs#L43-L146
 fn resolve_argument(
    value: &str,
-    deployed_contracts: &HashMap<String, Address>,
+    deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
    chain_state_provider: &impl EthereumNode,
 ) -> anyhow::Result<U256> {
    if let Some(instance) = value.strip_suffix(".address") {
        Ok(U256::from_be_slice(
            deployed_contracts
-                .get(instance)
+                .get(&ContractInstance::new_from(instance))
+                .map(|(a, _)| *a)
                .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))?
                .as_ref(),
        ))
@@ -282,22 +444,19 @@ mod tests {

        fn trace_transaction(
            &self,
-            _: alloy::rpc::types::TransactionReceipt,
+            _: &alloy::rpc::types::TransactionReceipt,
+            _: alloy::rpc::types::trace::geth::GethDebugTracingOptions,
        ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
            unimplemented!()
        }

        fn state_diff(
            &self,
-            _: alloy::rpc::types::TransactionReceipt,
+            _: &alloy::rpc::types::TransactionReceipt,
        ) -> anyhow::Result<alloy::rpc::types::trace::geth::DiffMode> {
            unimplemented!()
        }

-        fn fetch_add_nonce(&self, _: Address) -> anyhow::Result<u64> {
-            unimplemented!()
-        }
-
        fn chain_id(&self) -> anyhow::Result<alloy_primitives::ChainId> {
            Ok(0x123)
        }
@@ -357,19 +516,19 @@ mod tests {
            .0;

        let input = Input {
-            instance: "Contract".to_string(),
+            instance: ContractInstance::new_from("Contract"),
            method: Method::FunctionName("store".to_owned()),
-            calldata: Some(Calldata::Compound(vec!["42".into()])),
+            calldata: Calldata::Compound(vec!["42".into()]),
            ..Default::default()
        };

-        let mut deployed_abis = HashMap::new();
-        deployed_abis.insert("Contract".to_string(), parsed_abi);
-        let deployed_contracts = HashMap::new();
+        let mut contracts = HashMap::new();
+        contracts.insert(
+            ContractInstance::new_from("Contract"),
+            (Address::ZERO, parsed_abi),
+        );

-        let encoded = input
-            .encoded_input(&deployed_abis, &deployed_contracts, &DummyEthereumNode)
-            .unwrap();
+        let encoded = input.encoded_input(&contracts, &DummyEthereumNode).unwrap();
        assert!(encoded.0.starts_with(&selector));

        type T = (u64,);
@@ -377,6 +536,53 @@ mod tests {
        assert_eq!(decoded.0, 42);
    }

+    #[test]
+    fn test_encoded_input_address_with_signature() {
+        let raw_abi = r#"[
+        {
+            "inputs": [{"name": "recipient", "type": "address"}],
+            "name": "send",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+        ]"#;
+
+        let parsed_abi: JsonAbi = serde_json::from_str(raw_abi).unwrap();
+        let selector = parsed_abi
+            .function("send")
+            .unwrap()
+            .first()
+            .unwrap()
+            .selector()
+            .0;
+
+        let input: Input = Input {
+            instance: "Contract".to_owned().into(),
+            method: Method::FunctionName("send(address)".to_owned()),
+            calldata: Calldata::Compound(vec![
+                "0x1000000000000000000000000000000000000001".to_string(),
+            ]),
+            ..Default::default()
+        };
+
+        let mut contracts = HashMap::new();
+        contracts.insert(
+            ContractInstance::new_from("Contract"),
+            (Address::ZERO, parsed_abi),
+        );
+
+        let encoded = input.encoded_input(&contracts, &DummyEthereumNode).unwrap();
+        assert!(encoded.0.starts_with(&selector));
+
+        type T = (alloy_primitives::Address,);
+        let decoded: T = T::abi_decode(&encoded.0[4..]).unwrap();
+        assert_eq!(
+            decoded.0,
+            address!("0x1000000000000000000000000000000000000001")
+        );
+    }
+
    #[test]
    fn test_encoded_input_address() {
        let raw_abi = r#"[
@@ -399,21 +605,21 @@ mod tests {
            .0;

        let input: Input = Input {
-            instance: "Contract".to_string(),
+            instance: ContractInstance::new_from("Contract"),
            method: Method::FunctionName("send".to_owned()),
-            calldata: Some(Calldata::Compound(vec![
+            calldata: Calldata::Compound(vec![
                "0x1000000000000000000000000000000000000001".to_string(),
-            ])),
+            ]),
            ..Default::default()
        };

-        let mut abis = HashMap::new();
-        abis.insert("Contract".to_string(), parsed_abi);
-        let contracts = HashMap::new();
+        let mut contracts = HashMap::new();
+        contracts.insert(
+            ContractInstance::new_from("Contract"),
+            (Address::ZERO, parsed_abi),
+        );

-        let encoded = input
-            .encoded_input(&abis, &contracts, &DummyEthereumNode)
-            .unwrap();
+        let encoded = input.encoded_input(&contracts, &DummyEthereumNode).unwrap();
        assert!(encoded.0.starts_with(&selector));

        type T = (alloy_primitives::Address,);
@@ -3,5 +3,6 @@
 pub mod case;
 pub mod corpus;
 pub mod input;
+pub mod macros;
 pub mod metadata;
 pub mod mode;
@@ -0,0 +1,106 @@
+/// Defines wrappers around types.
+///
+/// For example, the macro invocation seen below:
+///
+/// ```rust,ignore
+/// define_wrapper_type!(CaseId => usize);
+/// ```
+///
+/// Would define a wrapper type that looks like the following:
+///
+/// ```rust,ignore
+/// pub struct CaseId(usize);
+/// ```
+///
+/// And would also implement a number of methods on this type making it easier
+/// to use.
+///
+/// These wrapper types become very useful as they make the code a lot easier
+/// to read.
+///
+/// Take the following as an example:
+///
+/// ```rust,ignore
+/// struct State {
+///     contracts: HashMap<usize, HashMap<String, Vec<u8>>>
+/// }
+/// ```
+///
+/// In the above code it's hard to understand what the various types refer to or
+/// what to expect them to contain.
+///
+/// With these wrapper types we're able to create code that's self-documenting
+/// in that the types tell us what the code is referring to. The above code is
+/// transformed into
+///
+/// ```rust,ignore
+/// struct State {
+///     contracts: HashMap<CaseId, HashMap<ContractName, ContractByteCode>>
+/// }
+/// ```
+#[macro_export]
+macro_rules! define_wrapper_type {
+    (
+        $(#[$meta: meta])*
+        $ident: ident($ty: ty) $(;)?
+    ) => {
+        $(#[$meta])*
+        pub struct $ident($ty);
+
+        impl $ident {
+            pub fn new(value: $ty) -> Self {
+                Self(value)
+            }
+
+            pub fn new_from<T: Into<$ty>>(value: T) -> Self {
+                Self(value.into())
+            }
+
+            pub fn into_inner(self) -> $ty {
+                self.0
+            }
+
+            pub fn as_inner(&self) -> &$ty {
+                &self.0
+            }
+        }
+
+        impl AsRef<$ty> for $ident {
+            fn as_ref(&self) -> &$ty {
+                &self.0
+            }
+        }
+
+        impl AsMut<$ty> for $ident {
+            fn as_mut(&mut self) -> &mut $ty {
+                &mut self.0
+            }
+        }
+
+        impl std::ops::Deref for $ident {
+            type Target = $ty;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl std::ops::DerefMut for $ident {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.0
+            }
+        }
+
+        impl From<$ty> for $ident {
+            fn from(value: $ty) -> Self {
+                Self(value)
+            }
+        }
+
+        impl From<$ident> for $ty {
+            fn from(value: $ident) -> Self {
+                value.0
+            }
+        }
+    };
+}
@@ -1,14 +1,17 @@
 use std::{
    collections::BTreeMap,
+    fmt::Display,
    fs::{File, read_to_string},
    ops::Deref,
    path::{Path, PathBuf},
+    str::FromStr,
 };

-use serde::Deserialize;
+use serde::{Deserialize, Serialize};

 use crate::{
    case::Case,
+    define_wrapper_type,
    mode::{Mode, SolcMode},
 };

@@ -41,8 +44,10 @@ impl Deref for MetadataFile {

 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct Metadata {
+    pub targets: Option<Vec<String>>,
    pub cases: Vec<Case>,
-    pub contracts: Option<BTreeMap<String, String>>,
+    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdentifier>>,
+    // TODO: Convert into wrapper types for clarity.
    pub libraries: Option<BTreeMap<String, BTreeMap<String, String>>>,
    pub ignore: Option<bool>,
    pub modes: Option<Vec<Mode>>,
@@ -77,28 +82,35 @@ impl Metadata {
            .to_path_buf())
    }

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

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

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

        Ok(sources)
@@ -178,12 +190,16 @@ impl Metadata {
        match serde_json::from_str::<Self>(&spec) {
            Ok(mut metadata) => {
                metadata.file_path = Some(path.to_path_buf());
-                let name = path
-                    .file_name()
-                    .expect("this should be the path to a Solidity file")
-                    .to_str()
-                    .expect("the file name should be valid UTF-8k");
-                metadata.contracts = Some([(String::from("Test"), format!("{name}:Test"))].into());
+                metadata.contracts = Some(
+                    [(
+                        ContractInstance::new_from("test"),
+                        ContractPathAndIdentifier {
+                            contract_source_path: path.to_path_buf(),
+                            contract_ident: ContractIdent::new_from("Test"),
+                        },
+                    )]
+                    .into(),
+                );
                Some(metadata)
            }
            Err(error) => {
@@ -196,3 +212,139 @@ impl Metadata {
        }
    }
 }
+
+define_wrapper_type!(
+    /// Represents a contract instance found a metadata file.
+    ///
+    /// Typically, this is used as the key to the "contracts" field of metadata files.
+    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[serde(transparent)]
+    ContractInstance(String);
+);
+
+define_wrapper_type!(
+    /// Represents a contract identifier found a metadata file.
+    ///
+    /// A contract identifier is the name of the contract in the source code.
+    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[serde(transparent)]
+    ContractIdent(String);
+);
+
+/// Represents an identifier used for contracts.
+///
+/// The type supports serialization from and into the following string format:
+///
+/// ```text
+/// ${path}:${contract_ident}
+/// ```
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(try_from = "String", into = "String")]
+pub struct ContractPathAndIdentifier {
+    /// The path of the contract source code relative to the directory containing the metadata file.
+    pub contract_source_path: PathBuf,
+
+    /// The identifier of the contract.
+    pub contract_ident: ContractIdent,
+}
+
+impl Display for ContractPathAndIdentifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}:{}",
+            self.contract_source_path.display(),
+            self.contract_ident.as_ref()
+        )
+    }
+}
+
+impl FromStr for ContractPathAndIdentifier {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut splitted_string = s.split(":").peekable();
+        let mut path = None::<String>;
+        let mut identifier = None::<String>;
+        loop {
+            let Some(next_item) = splitted_string.next() else {
+                break;
+            };
+            if splitted_string.peek().is_some() {
+                match path {
+                    Some(ref mut path) => {
+                        path.push(':');
+                        path.push_str(next_item);
+                    }
+                    None => path = Some(next_item.to_owned()),
+                }
+            } else {
+                identifier = Some(next_item.to_owned())
+            }
+        }
+        let Some(path) = path else {
+            anyhow::bail!("Path is not defined");
+        };
+        let Some(identifier) = identifier else {
+            anyhow::bail!("Contract identifier is not defined")
+        };
+        Ok(Self {
+            contract_source_path: PathBuf::from(path),
+            contract_ident: ContractIdent::new(identifier),
+        })
+    }
+}
+
+impl TryFrom<String> for ContractPathAndIdentifier {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::from_str(&value)
+    }
+}
+
+impl From<ContractPathAndIdentifier> for String {
+    fn from(value: ContractPathAndIdentifier) -> Self {
+        value.to_string()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn contract_identifier_respects_roundtrip_property() {
+        // Arrange
+        let string = "ERC20/ERC20.sol:ERC20";
+
+        // Act
+        let identifier = ContractPathAndIdentifier::from_str(string);
+
+        // Assert
+        let identifier = identifier.expect("Failed to parse");
+        assert_eq!(
+            identifier.contract_source_path.display().to_string(),
+            "ERC20/ERC20.sol"
+        );
+        assert_eq!(identifier.contract_ident, "ERC20".to_owned().into());
+
+        // Act
+        let reserialized = identifier.to_string();
+
+        // Assert
+        assert_eq!(string, reserialized);
+    }
+
+    #[test]
+    fn complex_metadata_file_can_be_deserialized() {
+        // Arrange
+        const JSON: &str = include_str!("../../../assets/test_metadata.json");
+
+        // Act
+        let metadata = serde_json::from_str::<Metadata>(JSON);
+
+        // Assert
+        metadata.expect("Failed to deserialize metadata");
+    }
+}
@@ -9,6 +9,7 @@ use tokio::{
    runtime::Builder,
    sync::{mpsc::UnboundedSender, oneshot},
 };
+use tracing::Instrument;

 /// A blocking async executor.
 ///
@@ -63,6 +64,11 @@ impl BlockingExecutor {
            let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<TaskMessage>();

            thread::spawn(move || {
+                tracing::info!(
+                    thread_id = ?std::thread::current().id(),
+                    "Starting async runtime thread"
+                );
+
                let runtime = Builder::new_current_thread()
                    .enable_all()
                    .build()
@@ -107,7 +113,9 @@ impl BlockingExecutor {
        // in the task message. In doing this conversion, we lose some of the type information since
        // we're converting R => dyn Any. However, we will perform down-casting on the result to
        // convert it back into R.
-        let future = Box::pin(async move { Box::new(future.await) as Box<dyn Any + Send> });
+        let future = Box::pin(
+            async move { Box::new(future.await) as Box<dyn Any + Send> }.in_current_span(),
+        );

        let task = TaskMessage::new(future, response_tx);
        if let Err(error) = STATE.tx.send(task) {
@@ -2,7 +2,7 @@

 use alloy::eips::BlockNumberOrTag;
 use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
-use alloy::rpc::types::trace::geth::{DiffMode, GethTrace};
+use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
 use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
 use anyhow::Result;

@@ -15,13 +15,14 @@ pub trait EthereumNode {
    fn execute_transaction(&self, transaction: TransactionRequest) -> Result<TransactionReceipt>;

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

    /// Returns the state diff of the transaction hash in the [TransactionReceipt].
-    fn state_diff(&self, transaction: TransactionReceipt) -> Result<DiffMode>;
-
-    /// Returns the next available nonce for the given [Address].
-    fn fetch_add_nonce(&self, address: Address) -> Result<u64>;
+    fn state_diff(&self, receipt: &TransactionReceipt) -> Result<DiffMode>;

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

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

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

-use crate::Node;
+use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};

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

@@ -54,7 +52,7 @@ pub struct Instance {
    network_id: u64,
    start_timeout: u64,
    wallet: EthereumWallet,
-    nonces: Mutex<HashMap<Address, u64>>,
+    nonce_manager: CachedNonceManager,
    /// This vector stores [`File`] objects that we use for logging which we want to flush when the
    /// node object is dropped. We do not store them in a structured fashion at the moment (in
    /// separate fields) as the logic that we need to apply to them is all the same regardless of
@@ -82,8 +80,19 @@ impl Instance {
        create_dir_all(&self.base_directory)?;
        create_dir_all(&self.logs_directory)?;

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

        let mut child = Command::new(&self.geth)
            .arg("init")
@@ -206,8 +215,19 @@ impl Instance {
    > + '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(500_000_000, 500_000_000, 1))
+                .filler(ChainIdFiller::default())
+                .filler(NonceFiller::new(nonce_manager))
                .wallet(wallet)
                .connect(&connection_string)
                .await
@@ -224,7 +244,7 @@ impl EthereumNode for Instance {
    ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
        let provider = self.provider();
        BlockingExecutor::execute(async move {
-            let outer_span = tracing::debug_span!("Submitting transaction", ?transaction,);
+            let outer_span = tracing::debug_span!("Submitting transaction", ?transaction);
            let _outer_guard = outer_span.enter();

            let provider = provider.await?;
@@ -305,30 +325,28 @@ impl EthereumNode for Instance {
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn trace_transaction(
        &self,
-        transaction: TransactionReceipt,
+        transaction: &TransactionReceipt,
+        trace_options: GethDebugTracingOptions,
    ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
-            diff_mode: Some(true),
-            disable_code: None,
-            disable_storage: None,
-        });
+        let tx_hash = transaction.transaction_hash;
        let provider = self.provider();
-
        BlockingExecutor::execute(async move {
            Ok(provider
                .await?
-                .debug_trace_transaction(transaction.transaction_hash, trace_options)
+                .debug_trace_transaction(tx_hash, trace_options)
                .await?)
        })?
    }

    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    fn state_diff(
-        &self,
-        transaction: alloy::rpc::types::TransactionReceipt,
-    ) -> anyhow::Result<DiffMode> {
+    fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
+        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
+            diff_mode: Some(true),
+            disable_code: None,
+            disable_storage: None,
+        });
        match self
-            .trace_transaction(transaction)?
+            .trace_transaction(transaction, trace_options)?
            .try_into_pre_state_frame()?
        {
            PreStateFrame::Diff(diff) => Ok(diff),
@@ -336,24 +354,6 @@ impl EthereumNode for Instance {
        }
    }

-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64> {
-        let provider = self.provider();
-        let onchain_nonce = BlockingExecutor::execute::<anyhow::Result<_>>(async move {
-            provider
-                .await?
-                .get_transaction_count(address)
-                .await
-                .map_err(Into::into)
-        })??;
-
-        let mut nonces = self.nonces.lock().unwrap();
-        let current = nonces.entry(address).or_insert(onchain_nonce);
-        let value = *current;
-        *current += 1;
-        Ok(value)
-    }
-
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
        let provider = self.provider();
@@ -442,6 +442,15 @@ impl Node for Instance {
        let id = NODE_COUNT.fetch_add(1, Ordering::SeqCst);
        let base_directory = geth_directory.join(id.to_string());

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

@@ -505,6 +514,14 @@ impl Node for Instance {
            .stdout;
        Ok(String::from_utf8_lossy(&output).into())
    }
+
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    fn matches_target(&self, targets: Option<&[String]>) -> bool {
+        match targets {
+            None => true,
+            Some(targets) => targets.iter().any(|str| str.as_str() == "evm"),
+        }
+    }
 }

 impl Drop for Instance {
@@ -517,6 +534,7 @@ impl Drop for Instance {
 #[cfg(test)]
 mod tests {
    use revive_dt_config::Arguments;
+
    use temp_dir::TempDir;

    use crate::{GENESIS_JSON, Node};
@@ -1,35 +1,34 @@
 use std::{
-    collections::HashMap,
    fs::{File, OpenOptions, create_dir_all, remove_dir_all},
    io::{BufRead, Write},
    path::{Path, PathBuf},
    process::{Child, Command, Stdio},
-    sync::{
-        Mutex,
-        atomic::{AtomicU32, Ordering},
-    },
+    sync::atomic::{AtomicU32, Ordering},
    time::Duration,
 };

 use alloy::{
    consensus::{BlockHeader, TxEnvelope},
    eips::BlockNumberOrTag,
-    hex,
+    genesis::{Genesis, GenesisAccount},
    network::{
-        Ethereum, EthereumWallet, Network, TransactionBuilder, TransactionBuilderError,
-        UnbuiltTransactionError,
+        Ethereum, EthereumWallet, Network, NetworkWallet, TransactionBuilder,
+        TransactionBuilderError, UnbuiltTransactionError,
+    },
+    primitives::{
+        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes, U256,
    },
-    primitives::{Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, U256},
    providers::{
        Provider, ProviderBuilder,
        ext::DebugApi,
-        fillers::{FillProvider, TxFiller},
+        fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
    },
    rpc::types::{
        TransactionReceipt,
        eth::{Block, Header, Transaction},
        trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
    },
+    signers::local::PrivateKeySigner,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{Value as JsonValue, json};
@@ -40,7 +39,7 @@ use tracing::Level;
 use revive_dt_config::Arguments;
 use revive_dt_node_interaction::{BlockingExecutor, EthereumNode};

-use crate::Node;
+use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};

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

@@ -55,7 +54,7 @@ pub struct KitchensinkNode {
    logs_directory: PathBuf,
    process_substrate: Option<Child>,
    process_proxy: Option<Child>,
-    nonces: Mutex<HashMap<Address, u64>>,
+    nonce_manager: CachedNonceManager,
    /// This vector stores [`File`] objects that we use for logging which we want to flush when the
    /// node object is dropped. We do not store them in a structured fashion at the moment (in
    /// separate fields) as the logic that we need to apply to them is all the same regardless of
@@ -127,7 +126,20 @@ impl KitchensinkNode {
                None
            })
            .collect();
-        let mut eth_balances = self.extract_balance_from_genesis_file(genesis)?;
+        let mut eth_balances = {
+            let mut genesis = serde_json::from_str::<Genesis>(genesis)?;
+            for signer_address in
+                <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
+            {
+                // Note, the use of the entry API here means that we only modify the entries for any
+                // account that is not in the `alloc` field of the genesis state.
+                genesis
+                    .alloc
+                    .entry(signer_address)
+                    .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
+            }
+            self.extract_balance_from_genesis_file(&genesis)?
+        };
        merged_balances.append(&mut eth_balances);

        chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"] =
@@ -241,42 +253,27 @@ impl KitchensinkNode {
    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
    fn extract_balance_from_genesis_file(
        &self,
-        genesis_str: &str,
+        genesis: &Genesis,
    ) -> anyhow::Result<Vec<(String, u128)>> {
-        let genesis_json: JsonValue = serde_json::from_str(genesis_str)?;
-        let alloc = genesis_json
-            .get("alloc")
-            .and_then(|a| a.as_object())
-            .ok_or_else(|| anyhow::anyhow!("Missing 'alloc' in genesis"))?;
-
-        let mut balances = Vec::new();
-        for (eth_addr, obj) in alloc.iter() {
-            let balance_str = obj.get("balance").and_then(|b| b.as_str()).unwrap_or("0");
-            let balance = if balance_str.starts_with("0x") {
-                u128::from_str_radix(balance_str.trim_start_matches("0x"), 16)?
-            } else {
-                balance_str.parse::<u128>()?
-            };
-            let substrate_addr = Self::eth_to_substrate_address(eth_addr)?;
-            balances.push((substrate_addr.clone(), balance));
-        }
-        Ok(balances)
+        genesis
+            .alloc
+            .iter()
+            .try_fold(Vec::new(), |mut vec, (address, acc)| {
+                let substrate_address = Self::eth_to_substrate_address(address);
+                let balance = acc.balance.try_into()?;
+                vec.push((substrate_address, balance));
+                Ok(vec)
+            })
    }

-    fn eth_to_substrate_address(eth_addr: &str) -> anyhow::Result<String> {
-        let eth_bytes = hex::decode(eth_addr.trim_start_matches("0x"))?;
-        if eth_bytes.len() != 20 {
-            anyhow::bail!(
-                "Invalid Ethereum address length: expected 20 bytes, got {}",
-                eth_bytes.len()
-            );
-        }
+    fn eth_to_substrate_address(address: &Address) -> String {
+        let eth_bytes = address.0.0;

        let mut padded = [0xEEu8; 32];
        padded[..20].copy_from_slice(&eth_bytes);

        let account_id = AccountId32::from(padded);
-        Ok(account_id.to_ss58check())
+        account_id.to_ss58check()
    }

    fn wait_ready(logs_file_path: &Path, marker: &str, timeout: Duration) -> anyhow::Result<()> {
@@ -350,9 +347,24 @@ impl KitchensinkNode {
    > + 'static {
        let connection_string = self.connection_string();
        let wallet = self.wallet.clone();
+
+        // Note: We would like all providers to make use of the same nonce manager so that we have
+        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
+        // its implementation and therefore it means that when we clone it then it still references
+        // the same state.
+        let nonce_manager = self.nonce_manager.clone();
+
        Box::pin(async move {
            ProviderBuilder::new()
+                .disable_recommended_fillers()
                .network::<KitchenSinkNetwork>()
+                .filler(FallbackGasFiller::new(
+                    30_000_000,
+                    200_000_000_000,
+                    3_000_000_000,
+                ))
+                .filler(ChainIdFiller::default())
+                .filler(NonceFiller::new(nonce_manager))
                .wallet(wallet)
                .connect(&connection_string)
                .await
@@ -384,27 +396,28 @@ impl EthereumNode for KitchensinkNode {
    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
    fn trace_transaction(
        &self,
-        transaction: TransactionReceipt,
+        transaction: &TransactionReceipt,
+        trace_options: GethDebugTracingOptions,
    ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
-            diff_mode: Some(true),
-            disable_code: None,
-            disable_storage: None,
-        });
+        let tx_hash = transaction.transaction_hash;
        let provider = self.provider();
-
        BlockingExecutor::execute(async move {
            Ok(provider
                .await?
-                .debug_trace_transaction(transaction.transaction_hash, trace_options)
+                .debug_trace_transaction(tx_hash, trace_options)
                .await?)
        })?
    }

    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
-    fn state_diff(&self, transaction: TransactionReceipt) -> anyhow::Result<DiffMode> {
+    fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
+        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
+            diff_mode: Some(true),
+            disable_code: None,
+            disable_storage: None,
+        });
        match self
-            .trace_transaction(transaction)?
+            .trace_transaction(transaction, trace_options)?
            .try_into_pre_state_frame()?
        {
            PreStateFrame::Diff(diff) => Ok(diff),
@@ -412,24 +425,6 @@ impl EthereumNode for KitchensinkNode {
        }
    }

-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64> {
-        let provider = self.provider();
-        let onchain_nonce = BlockingExecutor::execute::<anyhow::Result<_>>(async move {
-            provider
-                .await?
-                .get_transaction_count(address)
-                .await
-                .map_err(Into::into)
-        })??;
-
-        let mut nonces = self.nonces.lock().unwrap();
-        let current = nonces.entry(address).or_insert(onchain_nonce);
-        let value = *current;
-        *current += 1;
-        Ok(value)
-    }
-
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
        let provider = self.provider();
@@ -519,17 +514,26 @@ impl Node for KitchensinkNode {
        let base_directory = kitchensink_directory.join(id.to_string());
        let logs_directory = base_directory.join(Self::LOGS_DIRECTORY);

+        let mut wallet = config.wallet();
+        for signer in (1..=config.private_keys_to_add)
+            .map(|id| U256::from(id))
+            .map(|id| id.to_be_bytes::<32>())
+            .map(|id| PrivateKeySigner::from_bytes(&FixedBytes(id)).unwrap())
+        {
+            wallet.register_signer(signer);
+        }
+
        Self {
            id,
            substrate_binary: config.kitchensink.clone(),
            eth_proxy_binary: config.eth_proxy.clone(),
            rpc_url: String::new(),
-            wallet: config.wallet(),
+            wallet,
            base_directory,
            logs_directory,
            process_substrate: None,
            process_proxy: None,
-            nonces: Mutex::new(HashMap::new()),
+            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.
            logs_file_to_flush: Vec::with_capacity(4),
@@ -585,6 +589,14 @@ impl Node for KitchensinkNode {
            .stdout;
        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 {
+        match targets {
+            None => true,
+            Some(targets) => targets.iter().any(|str| str.as_str() == "pvm"),
+        }
+    }
 }

 impl Drop for KitchensinkNode {
@@ -640,6 +652,12 @@ impl TransactionBuilder<KitchenSinkNetwork> for <Ethereum as Network>::Transacti
        )
    }

+    fn take_nonce(&mut self) -> Option<u64> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::take_nonce(
+            self,
+        )
+    }
+
    fn input(&self) -> Option<&alloy::primitives::Bytes> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::input(self)
    }
@@ -1020,7 +1038,7 @@ mod tests {
    use alloy::rpc::types::TransactionRequest;
    use revive_dt_config::Arguments;
    use std::path::PathBuf;
-    use std::sync::LazyLock;
+    use std::sync::{LazyLock, Mutex};
    use temp_dir::TempDir;

    use std::fs;
@@ -1129,12 +1147,12 @@ mod tests {
        let contents = fs::read_to_string(&final_chainspec_path).expect("Failed to read chainspec");

        // Validate that the Substrate addresses derived from the Ethereum addresses are in the file
-        let first_eth_addr =
-            KitchensinkNode::eth_to_substrate_address("90F8bf6A479f320ead074411a4B0e7944Ea8c9C1")
-                .unwrap();
-        let second_eth_addr =
-            KitchensinkNode::eth_to_substrate_address("Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2")
-                .unwrap();
+        let first_eth_addr = KitchensinkNode::eth_to_substrate_address(
+            &"90F8bf6A479f320ead074411a4B0e7944Ea8c9C1".parse().unwrap(),
+        );
+        let second_eth_addr = KitchensinkNode::eth_to_substrate_address(
+            &"Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2".parse().unwrap(),
+        );

        assert!(
            contents.contains(&first_eth_addr),
@@ -1162,7 +1180,7 @@ mod tests {
        let node = KitchensinkNode::new(&test_config().0);

        let result = node
-            .extract_balance_from_genesis_file(genesis_json)
+            .extract_balance_from_genesis_file(&serde_json::from_str(genesis_json).unwrap())
            .unwrap();

        let result_map: std::collections::HashMap<_, _> = result.into_iter().collect();
@@ -1192,7 +1210,7 @@ mod tests {
        ];

        for eth_addr in eth_addresses {
-            let ss58 = KitchensinkNode::eth_to_substrate_address(eth_addr).unwrap();
+            let ss58 = KitchensinkNode::eth_to_substrate_address(&eth_addr.parse().unwrap());

            println!("Ethereum: {eth_addr} -> Substrate SS58: {ss58}");
        }
@@ -1220,7 +1238,7 @@ mod tests {
        ];

        for (eth_addr, expected_ss58) in cases {
-            let result = KitchensinkNode::eth_to_substrate_address(eth_addr).unwrap();
+            let result = KitchensinkNode::eth_to_substrate_address(&eth_addr.parse().unwrap());
            assert_eq!(
                result, expected_ss58,
                "Mismatch for Ethereum address {eth_addr}"
@@ -1296,8 +1314,7 @@ mod tests {
        let coinbase = node.block_coinbase(BlockNumberOrTag::Latest);

        // Assert
-        let coinbase = coinbase.expect("Failed to get the coinbase");
-        assert_eq!(coinbase, Address::ZERO)
+        let _ = coinbase.expect("Failed to get the coinbase");
    }

    #[test]
@@ -1309,8 +1326,7 @@ mod tests {
        let block_difficulty = node.block_difficulty(BlockNumberOrTag::Latest);

        // Assert
-        let block_difficulty = block_difficulty.expect("Failed to get the block difficulty");
-        assert_eq!(block_difficulty, U256::ZERO)
+        let _ = block_difficulty.expect("Failed to get the block difficulty");
    }

    #[test]
@@ -1346,7 +1362,6 @@ mod tests {
        let block_number = node.last_block_number();

        // Assert
-        let block_number = block_number.expect("Failed to get the block number");
-        assert_eq!(block_number, 0)
+        let _ = block_number.expect("Failed to get the block number");
    }
 }
@@ -3,6 +3,8 @@
 use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;

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

    /// Returns the node version.
    fn version(&self) -> anyhow::Result<String>;
+
+    /// Given a list of targets from the metadata file, this function determines if the metadata
+    /// file can be ran on this node or not.
+    fn matches_target(&self, targets: Option<&[String]>) -> bool;
 }
@@ -110,37 +110,25 @@ mod tests {

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

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

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

    #[test]
    fn try_get_wasm() {
-        let version = List::download(List::WASM_URL)
-            .unwrap()
-            .latest_release
-            .into();
+        let version = List::download(List::WASM_URL).unwrap().latest_release;
        GHDownloader::wasm(version).download().unwrap();
    }
 }
@@ -33,9 +33,5 @@
    "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "timestamp": "0x00",
-    "alloc": {
-        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
-            "balance": "1000000000000000000"
-        }
-    }
+    "alloc": {}
 }
Author	SHA1	Message	Date
Omar Abdulla	2a9d497827	Update the initial balance	2025-07-24 11:40:33 +03:00
Omar Abdulla	4763d763f6	Revert "Add extra comments" This reverts commit `bd4de2c83d`.	2025-07-24 10:38:23 +03:00
Omar Abdulla	bd4de2c83d	Add extra comments	2025-07-24 09:48:18 +03:00
Omar Abdulla	3c70e0ac76	Revert "Bump commit hash of polkadot SDK" This reverts commit `8aaa69780e`.	2025-07-24 09:39:08 +03:00
Omar Abdulla	995ef80940	Revert "Change how the cache key is computed" This reverts commit `75afdd9cfd`.	2025-07-24 09:39:00 +03:00
Omar Abdulla	75afdd9cfd	Change how the cache key is computed	2025-07-24 08:31:50 +03:00
Omar Abdulla	8aaa69780e	Bump commit hash of polkadot SDK	2025-07-24 08:19:05 +03:00
Omar Abdulla	d7795fff9d	Pre-seed accounts with more ETH. This commit fixes and solves some issues around how much ETH we seed an account with in genesis. Currently, any account that the node has keys to sign for will be seeded with u128::MAX WEI in genesis. This also includes the default signer account.	2025-07-24 06:58:46 +03:00
Omar	6f4aa731ab	Handle exceptions (#54 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order * Handle calldata better * Allow for the use of function signatures * Add support for exceptions * Cached nonce allocator * Fix tests * Add support for address replacement * Cleanup implementation * Cleanup mutability * Wire up address replacement with rest of code * Implement caller replacement * Switch to callframe trace for exceptions * Add a way to skip tests if they don't match the target * Handle values from the metadata files * Remove address replacement * Correct the arguments * Remove empty impl * Remove address replacement * Correct the arguments * Remove empty impl * Fix size_requirement underflow * Add support for wildcards in exceptions * Fix calldata construction of single calldata * Better handling for length in equivalency checks * Make initial balance a constant * Fix size_requirement underflow * Add support for wildcards in exceptions * Fix calldata construction of single calldata * Better handling for length in equivalency checks * Fix tests	2025-07-24 03:45:53 +00:00
Omar	589a5dc988	Handle calldata better (#49 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order * Handle calldata better * Remove todo	2025-07-22 03:39:35 +00:00
Omar	c6d55515be	Allow for the use of function signatures (#50 ) * Allow for the use of function signatures * Add test	2025-07-21 10:43:17 +00:00
Omar	a9970eb2bb	Refactor the input handling logic (#48 ) * Add support for wrapper types * Move `FilesWithExtensionIterator` to `core::common` * Remove unneeded use of two `HashMap`s * Make metadata structs more typed * Impl new_from for wrapper types * Implement the new input handling logic * Fix edge-case in input handling * Ignore macro doc comment tests * Correct comment * Fix edge-case in deployment order	2025-07-21 09:01:52 +00:00