Update the initial balance

Revert "Add extra comments"
This reverts commit bd4de2c83d.
2026-04-22 10:17:56 +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
33 changed files with 3804 additions and 1090 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",
@@ -3984,6 +4003,7 @@ dependencies = [
 "alloy-primitives",
 "alloy-sol-types",
 "anyhow",
 "revive-dt-node-interaction",
 "semver 1.0.26",
 "serde",
 "serde_json",
@@ -3998,6 +4018,7 @@ dependencies = [
 "anyhow",
 "revive-dt-config",
 "revive-dt-node-interaction",
 "serde",
 "serde_json",
 "sp-core",
 "sp-runtime",
@@ -4012,6 +4033,7 @@ version = "0.1.0"
 dependencies = [
 "alloy",
 "anyhow",
 "futures",
 "once_cell",
 "tokio",
 "tracing",
@@ -4109,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",
@@ -4504,7 +4526,7 @@ dependencies = [
 "chrono",
 "hex",
 "indexmap 1.9.3",
- "indexmap 2.9.0",
+ "indexmap 2.10.0",
 "serde",
 "serde_derive",
 "serde_json",
@@ -5393,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",
@@ -5485,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"
@@ -25,6 +25,7 @@ alloy-primitives = "1.2.1"
 alloy-sol-types = "1.2.1"
 anyhow = "1.0"
 clap = { version = "4", features = ["derive"] }
 futures = { version = "0.3.31" }
 hex = "0.4.3"
 reqwest = { version = "0.12.15", features = ["blocking", "json"] }
 once_cell = "1.21"
@@ -50,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" }
@@ -57,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",
@@ -71,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"
 }
@@ -44,9 +44,12 @@ pub trait SolidityCompiler {
 pub struct CompilerInput<T: PartialEq + Eq + Hash> {
    pub extra_options: T,
    pub input: SolcStandardJsonInput,
    pub allow_paths: Vec<PathBuf>,
    pub base_path: Option<PathBuf>,
 }
 /// The generic compilation output configuration.
 #[derive(Debug)]
 pub struct CompilerOutput<T: PartialEq + Eq + Hash> {
    /// The solc standard JSON input.
    pub input: CompilerInput<T>,
@@ -83,8 +86,8 @@ where
 pub struct Compiler<T: SolidityCompiler> {
    input: SolcStandardJsonInput,
    extra_options: T::Options,
-    allow_paths: Vec<String>,
+    allow_paths: Vec<PathBuf>,
-    base_path: Option<String>,
+    base_path: Option<PathBuf>,
 }
 impl Default for Compiler<solc::Solc> {
@@ -145,12 +148,12 @@ where
        self
    }
-    pub fn allow_path(mut self, path: String) -> Self {
+    pub fn allow_path(mut self, path: PathBuf) -> Self {
        self.allow_paths.push(path);
        self
    }
-    pub fn base_path(mut self, base_path: String) -> Self {
+    pub fn base_path(mut self, base_path: PathBuf) -> Self {
        self.base_path = Some(base_path);
        self
    }
@@ -159,6 +162,8 @@ where
        T::new(solc_path).build(CompilerInput {
            extra_options: self.extra_options,
            input: self.input,
            allow_paths: self.allow_paths,
            base_path: self.base_path,
        })
    }
@@ -11,6 +11,7 @@ use revive_dt_config::Arguments;
 use revive_solc_json_interface::SolcStandardJsonOutput;
 /// A wrapper around the `resolc` binary, emitting PVM-compatible bytecode.
 #[derive(Debug)]
 pub struct Resolc {
    /// Path to the `resolc` executable
    resolc_path: PathBuf,
@@ -19,17 +20,32 @@ pub struct Resolc {
 impl SolidityCompiler for Resolc {
    type Options = Vec<String>;
    #[tracing::instrument(level = "debug", ret)]
    fn build(
        &self,
        input: CompilerInput<Self::Options>,
    ) -> anyhow::Result<CompilerOutput<Self::Options>> {
-        let mut child = Command::new(&self.resolc_path)
+        let mut command = Command::new(&self.resolc_path);
-            .arg("--standard-json")
+        command
            .args(&input.extra_options)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
-            .spawn()?;
+            .arg("--standard-json");
        if let Some(ref base_path) = input.base_path {
            command.arg("--base-path").arg(base_path);
        }
        if !input.allow_paths.is_empty() {
            command.arg("--allow-paths").arg(
                input
                    .allow_paths
                    .iter()
                    .map(|path| path.display().to_string())
                    .collect::<Vec<_>>()
                    .join(","),
            );
        }
        let mut child = command.spawn()?;
        let stdin_pipe = child.stdin.as_mut().expect("stdin must be piped");
        serde_json::to_writer(stdin_pipe, &input.input)?;
@@ -55,12 +71,64 @@ impl SolidityCompiler for Resolc {
            });
        }
-        let parsed: SolcStandardJsonOutput = serde_json::from_slice(&stdout).map_err(|e| {
+        let mut parsed =
-            anyhow::anyhow!(
+            serde_json::from_slice::<SolcStandardJsonOutput>(&stdout).map_err(|e| {
-                "failed to parse resolc JSON output: {e}\nstderr: {}",
+                anyhow::anyhow!(
-                String::from_utf8_lossy(&stderr)
+                    "failed to parse resolc JSON output: {e}\nstderr: {}",
-            )
+                    String::from_utf8_lossy(&stderr)
-        })?;
+                )
            })?;
        // Detecting if the compiler output contained errors and reporting them through logs and
        // errors instead of returning the compiler output that might contain errors.
        for error in parsed.errors.iter().flatten() {
            if error.severity == "error" {
                tracing::error!(?error, ?input, "Encountered an error in the compilation");
                anyhow::bail!("Encountered an error in the compilation: {error}")
            }
        }
        // We need to do some post processing on the output to make it in the same format that solc
        // outputs. More specifically, for each contract, the `.metadata` field should be replaced
        // with the `.metadata.solc_metadata` field which contains the ABI and other information
        // about the compiled contracts. We do this because we do not want any downstream logic to
        // need to differentiate between which compiler is being used when extracting the ABI of the
        // contracts.
        if let Some(ref mut contracts) = parsed.contracts {
            for (contract_path, contracts_map) in contracts.iter_mut() {
                for (contract_name, contract_info) in contracts_map.iter_mut() {
                    let Some(metadata) = contract_info.metadata.take() else {
                        continue;
                    };
                    // Get the `solc_metadata` in the metadata of the contract.
                    let Some(solc_metadata) = metadata
                        .get("solc_metadata")
                        .and_then(|metadata| metadata.as_str())
                    else {
                        tracing::error!(
                            contract_path,
                            contract_name,
                            metadata = serde_json::to_string(&metadata).unwrap(),
                            "Encountered a contract compiled with resolc that has no solc_metadata"
                        );
                        anyhow::bail!(
                            "Contract {} compiled with resolc that has no solc_metadata",
                            contract_name
                        );
                    };
                    // Replace the original metadata with the new solc_metadata.
                    contract_info.metadata =
                        Some(serde_json::Value::String(solc_metadata.to_string()));
                }
            }
        }
        tracing::debug!(
            output = %serde_json::to_string(&parsed).unwrap(),
            "Compiled successfully"
        );
        Ok(CompilerOutput {
            input,
@@ -9,7 +9,9 @@ use std::{
 use crate::{CompilerInput, CompilerOutput, SolidityCompiler};
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
 use revive_solc_json_interface::SolcStandardJsonOutput;
 #[derive(Debug)]
 pub struct Solc {
    solc_path: PathBuf,
 }
@@ -17,16 +19,32 @@ pub struct Solc {
 impl SolidityCompiler for Solc {
    type Options = ();
    #[tracing::instrument(level = "debug", ret)]
    fn build(
        &self,
        input: CompilerInput<Self::Options>,
    ) -> anyhow::Result<CompilerOutput<Self::Options>> {
-        let mut child = Command::new(&self.solc_path)
+        let mut command = Command::new(&self.solc_path);
        command
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
-            .arg("--standard-json")
+            .arg("--standard-json");
-            .spawn()?;
+
        if let Some(ref base_path) = input.base_path {
            command.arg("--base-path").arg(base_path);
        }
        if !input.allow_paths.is_empty() {
            command.arg("--allow-paths").arg(
                input
                    .allow_paths
                    .iter()
                    .map(|path| path.display().to_string())
                    .collect::<Vec<_>>()
                    .join(","),
            );
        }
        let mut child = command.spawn()?;
        let stdin = child.stdin.as_mut().expect("should be piped");
        serde_json::to_writer(stdin, &input.input)?;
@@ -42,9 +60,31 @@ impl SolidityCompiler for Solc {
            });
        }
        let parsed =
            serde_json::from_slice::<SolcStandardJsonOutput>(&output.stdout).map_err(|e| {
                anyhow::anyhow!(
                    "failed to parse resolc JSON output: {e}\nstderr: {}",
                    String::from_utf8_lossy(&output.stdout)
                )
            })?;
        // Detecting if the compiler output contained errors and reporting them through logs and
        // errors instead of returning the compiler output that might contain errors.
        for error in parsed.errors.iter().flatten() {
            if error.severity == "error" {
                tracing::error!(?error, ?input, "Encountered an error in the compilation");
                anyhow::bail!("Encountered an error in the compilation: {error}")
            }
        }
        tracing::debug!(
            output = %String::from_utf8_lossy(&output.stdout).to_string(),
            "Compiled successfully"
        );
        Ok(CompilerOutput {
            input,
-            output: serde_json::from_slice(&output.stdout)?,
+            output: parsed,
            error: None,
        })
    }
@@ -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].
@@ -13,7 +13,7 @@ use revive_dt_node::pool::NodePool;
 use revive_dt_report::reporter::{Report, Span};
 use temp_dir::TempDir;
 use tracing::Level;
-use tracing_subscriber::{EnvFilter, FmtSubscriber, fmt::format::FmtSpan};
+use tracing_subscriber::{EnvFilter, FmtSubscriber};
 static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
@@ -39,7 +39,7 @@ fn init_cli() -> anyhow::Result<Arguments> {
        .with_thread_ids(true)
        .with_thread_names(true)
        .with_env_filter(EnvFilter::from_default_env())
-        .with_span_events(FmtSpan::ENTER | FmtSpan::CLOSE)
+        .with_ansi(false)
        .pretty()
        .finish();
    tracing::subscriber::set_global_default(subscriber)?;
@@ -116,20 +116,25 @@ where
                follower_nodes.round_robbin(),
            );
-            match driver.execute(span) {
+            let execution_result = driver.execute(span);
-                Ok(_) => {
+            tracing::info!(
-                    tracing::info!(
+                case_success_count = execution_result.successful_cases_count,
-                        "metadata {} success",
+                case_failure_count = execution_result.failed_cases_count,
-                        metadata.directory().as_ref().unwrap().display()
+                "Execution completed"
-                    );
+            );
-                }
+
-                Err(error) => {
+            let mut error_count = 0;
-                    tracing::warn!(
+            for result in execution_result.results.iter() {
-                        "metadata {} failure: {error:?}",
+                if !result.is_success() {
-                        metadata.file_path.as_ref().unwrap().display()
+                    tracing::error!(execution_error = ?result, "Encountered an error");
-                    );
+                    error_count += 1;
                }
            }
            if error_count == 0 {
                tracing::info!("Execution succeeded");
            } else {
                tracing::info!("Execution failed");
            }
        },
    );
@@ -9,6 +9,8 @@ repository.workspace = true
 rust-version.workspace = true
 [dependencies]
 revive-dt-node-interaction = { workspace = true }
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
@@ -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);
 );
@@ -1,17 +1,19 @@
 use std::collections::HashMap;
 use alloy::{
-    hex,
+    eips::BlockNumberOrTag,
-    json_abi::{Function, JsonAbi},
+    json_abi::JsonAbi,
    network::TransactionBuilder,
-    primitives::{Address, Bytes},
+    primitives::{Address, Bytes, U256},
    rpc::types::TransactionRequest,
 };
-use alloy_primitives::U256;
+use alloy_primitives::{FixedBytes, utils::parse_units};
 use alloy_sol_types::SolValue;
 use semver::VersionReq;
-use serde::{Deserialize, de::Deserializer};
+use serde::{Deserialize, Serialize};
-use serde_json::Value;
+
 use revive_dt_node_interaction::EthereumNode;
 use crate::{define_wrapper_type, metadata::ContractInstance};
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct Input {
@@ -19,12 +21,12 @@ pub struct Input {
    pub caller: Address,
    pub comment: Option<String>,
    #[serde(default = "default_instance")]
-    pub instance: String,
+    pub instance: ContractInstance,
    #[serde(deserialize_with = "deserialize_method")]
    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>>,
 }
@@ -38,195 +40,290 @@ pub enum Expected {
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct ExpectedOutput {
-    compiler_version: Option<VersionReq>,
+    pub compiler_version: Option<VersionReq>,
-    return_data: Option<Calldata>,
+    pub return_data: Option<Calldata>,
-    events: Option<Value>,
+    pub events: Option<Vec<Event>>,
-    exception: Option<bool>,
+    #[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<CalldataArg>),
+    Compound(Vec<String>),
 }
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
 #[serde(untagged)]
 pub enum CalldataArg {
    Literal(String),
    /// For example: `Contract.address`
    AddressRef(String),
 }
 /// Specify how the contract is called.
-#[derive(Debug, Default, Clone, Eq, PartialEq)]
+#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub enum Method {
    /// Initiate a deploy transaction, calling contracts constructor.
    ///
    /// Indicated by `#deployer`.
    #[serde(rename = "#deployer")]
    Deployer,
    /// Does not calculate and insert a function selector.
    ///
    /// Indicated by `#fallback`.
    #[default]
    #[serde(rename = "#fallback")]
    Fallback,
-    /// Call the public function with this selector.
+
-    ///
+    /// Call the public function with the given name.
-    /// Calculates the selector if neither deployer or fallback matches.
+    #[serde(untagged)]
-    Function([u8; 4]),
+    FunctionName(String),
 }
-fn deserialize_method<'de, D>(deserializer: D) -> Result<Method, D::Error>
+define_wrapper_type!(
-where
+    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    D: Deserializer<'de>,
+    EtherValue(U256);
-{
+);
-    Ok(match String::deserialize(deserializer)?.as_str() {
+
-        "#deployer" => Method::Deployer,
+impl Serialize for EtherValue {
-        "#fallback" => Method::Fallback,
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        signature => {
+    where
-            let signature = if signature.ends_with(')') {
+        S: serde::Serializer,
-                signature.to_string()
+    {
-            } else {
+        format!("{} wei", self.0).serialize(serializer)
-                format!("{signature}()")
+    }
-            };
+}
-            match Function::parse(&signature) {
+
-                Ok(function) => Method::Function(function.selector().0),
+impl<'de> Deserialize<'de> for EtherValue {
-                Err(error) => {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                    return Err(serde::de::Error::custom(format!(
+    where
-                        "parsing function signature '{signature}' error: {error}"
+        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,
+        instance: &ContractInstance,
-        deployed_contracts: &HashMap<String, Address>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
    ) -> anyhow::Result<Address> {
        deployed_contracts
            .get(instance)
-            .copied()
+            .map(|(a, _)| *a)
-            .ok_or_else(|| anyhow::anyhow!("instance {instance} not deployed"))
+            .ok_or_else(|| anyhow::anyhow!("instance {instance:?} not deployed"))
    }
    pub fn encoded_input(
        &self,
-        deployed_abis: &HashMap<String, JsonAbi>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        deployed_contracts: &HashMap<String, Address>,
+        chain_state_provider: &impl EthereumNode,
    ) -> anyhow::Result<Bytes> {
-        let Method::Function(selector) = self.method else {
+        match self.method {
-            return Ok(Bytes::default()); // fallback or deployer — no input
+            Method::Deployer | Method::Fallback => {
-        };
+                let calldata = self
                    .calldata
                    .calldata(deployed_contracts, chain_state_provider)?;
-        let abi = deployed_abis
+                Ok(calldata.into())
-            .get(&self.instance)
+            }
-            .ok_or_else(|| anyhow::anyhow!("ABI for instance '{}' not found", &self.instance))?;
+            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());
-        // Find function by selector
+                // We follow the same logic that's implemented in the matter-labs-tester where they resolve
-        let function = abi
+                // the function name into a function selector and they assume that he function doesn't have
-            .functions()
+                // any existing overloads.
-            .find(|f| f.selector().0 == selector)
+                // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
-            .ok_or_else(|| {
+                let function = abi
-                anyhow::anyhow!(
+                    .functions()
-                    "Function with selector {:?} not found in ABI for the instance {:?}",
+                    .find(|function| function.signature().starts_with(function_name))
-                    selector,
+                    .ok_or_else(|| {
-                    &self.instance
+                        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 {
+                tracing::trace!(
-            Some(Calldata::Compound(args)) => args,
+                    "Starting encoding ABI's parameters for instance: {}",
-            _ => anyhow::bail!("Expected compound calldata for function call"),
+                    self.instance.as_ref()
-        };
+                );
-        if calldata_args.len() != function.inputs.len() {
+                // Allocating a vector that we will be using for the calldata. The vector size will be:
-            anyhow::bail!(
+                // 4 bytes for the function selector.
-                "Function expects {} args, but got {}",
+                // function.inputs.len() * 32 bytes for the arguments (each argument is a U256).
-                function.inputs.len(),
+                //
-                calldata_args.len()
+                // 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
        );
        let mut encoded = selector.to_vec();
        for (i, param) in function.inputs.iter().enumerate() {
            let arg = calldata_args.get(i).unwrap();
            let encoded_arg = match arg {
                CalldataArg::Literal(value) => match param.ty.as_str() {
                    "uint256" | "uint" => {
                        let val: U256 = value.parse()?;
                        val.abi_encode()
                    }
                    "uint24" => {
                        let val: u32 = value.parse()?;
                        (val & 0xFFFFFF).abi_encode()
                    }
                    "bool" => {
                        let val: bool = value.parse()?;
                        val.abi_encode()
                    }
                    "address" => {
                        let addr: Address = value.parse()?;
                        addr.abi_encode()
                    }
                    "string" => value.abi_encode(),
                    "bytes32" => {
                        let val = hex::decode(value.trim_start_matches("0x"))?;
                        let mut fixed = [0u8; 32];
                        fixed[..val.len()].copy_from_slice(&val);
                        fixed.abi_encode()
                    }
                    "uint256[]" | "uint[]" => {
                        let nums: Vec<u64> = serde_json::from_str(value)?;
                        nums.abi_encode()
                    }
                    "bytes" => {
                        let val = hex::decode(value.trim_start_matches("0x"))?;
                        val.abi_encode()
                    }
                    _ => anyhow::bail!("Unsupported type: {}", param.ty),
                },
                CalldataArg::AddressRef(name) => {
                    let contract_name = name.trim_end_matches(".address");
                    let addr = deployed_contracts
                        .get(contract_name)
                        .copied()
                        .ok_or_else(|| {
                            anyhow::anyhow!("Address for '{}' not found", contract_name)
                        })?;
                    addr.abi_encode()
                }
            };
            encoded.extend(encoded_arg);
        }
        Ok(Bytes::from(encoded))
    }
    /// Parse this input into a legacy transaction.
    pub fn legacy_transaction(
        &self,
-        nonce: u64,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        deployed_contracts: &HashMap<String, Address>,
+        chain_state_provider: &impl EthereumNode,
        deployed_abis: &HashMap<String, JsonAbi>,
    ) -> anyhow::Result<TransactionRequest> {
-        let input_data = self.encoded_input(deployed_abis, deployed_contracts)?;
+        let input_data = self.encoded_input(deployed_contracts, chain_state_provider)?;
-        let transaction_request = TransactionRequest::default().nonce(nonce);
+        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
@@ -234,14 +331,96 @@ 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 {
+fn default_instance() -> ContractInstance {
-    "Test".to_string()
+    ContractInstance::new_from("Test")
 }
-fn default_caller() -> Address {
+pub const fn default_caller() -> Address {
-    "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1".parse().unwrap()
+    Address(FixedBytes(alloy::hex!(
        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1"
    )))
 }
 /// This function takes in the string calldata argument provided in the JSON input and resolves it
 /// into a [`U256`] which is later used to construct the calldata.
 ///
 /// # Note
 ///
 /// This piece of code is taken from the matter-labs-tester repository which is licensed under MIT
 /// or Apache. The original source code can be found here:
 /// 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<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(&ContractInstance::new_from(instance))
                .map(|(a, _)| *a)
                .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))?
                .as_ref(),
        ))
    } else if let Some(value) = value.strip_prefix('-') {
        let value = U256::from_str_radix(value, 10)
            .map_err(|error| anyhow::anyhow!("Invalid decimal literal after `-`: {}", error))?;
        if value > U256::ONE << 255u8 {
            anyhow::bail!("Decimal literal after `-` is too big");
        }
        let value = value
            .checked_sub(U256::ONE)
            .ok_or_else(|| anyhow::anyhow!("`-0` is invalid literal"))?;
        Ok(U256::MAX.checked_sub(value).expect("Always valid"))
    } else if let Some(value) = value.strip_prefix("0x") {
        Ok(U256::from_str_radix(value, 16)
            .map_err(|error| anyhow::anyhow!("Invalid hexadecimal literal: {}", error))?)
    } else if value == "$CHAIN_ID" {
        let chain_id = chain_state_provider.chain_id()?;
        Ok(U256::from(chain_id))
    } else if value == "$GAS_LIMIT" {
        let gas_limit = chain_state_provider.block_gas_limit(BlockNumberOrTag::Latest)?;
        Ok(U256::from(gas_limit))
    } else if value == "$COINBASE" {
        let coinbase = chain_state_provider.block_coinbase(BlockNumberOrTag::Latest)?;
        Ok(U256::from_be_slice(coinbase.as_ref()))
    } else if value == "$DIFFICULTY" {
        let block_difficulty = chain_state_provider.block_difficulty(BlockNumberOrTag::Latest)?;
        Ok(block_difficulty)
    } else if value.starts_with("$BLOCK_HASH") {
        let offset: u64 = value
            .split(':')
            .next_back()
            .and_then(|value| value.parse().ok())
            .unwrap_or_default();
        let current_block_number = chain_state_provider.last_block_number()?;
        let desired_block_number = current_block_number - offset;
        let block_hash = chain_state_provider.block_hash(desired_block_number.into())?;
        Ok(U256::from_be_bytes(block_hash.0))
    } else if value == "$BLOCK_NUMBER" {
        let current_block_number = chain_state_provider.last_block_number()?;
        Ok(U256::from(current_block_number))
    } else if value == "$BLOCK_TIMESTAMP" {
        let timestamp = chain_state_provider.block_timestamp(BlockNumberOrTag::Latest)?;
        Ok(U256::from(timestamp))
    } else {
        Ok(U256::from_str_radix(value, 10)
            .map_err(|error| anyhow::anyhow!("Invalid decimal literal: {}", error))?)
    }
 }
 #[cfg(test)]
@@ -249,9 +428,70 @@ mod tests {
    use super::*;
    use alloy::json_abi::JsonAbi;
-    use alloy_primitives::{address, keccak256};
+    use alloy_primitives::address;
    use alloy_sol_types::SolValue;
    use std::collections::HashMap;
    struct DummyEthereumNode;
    impl EthereumNode for DummyEthereumNode {
        fn execute_transaction(
            &self,
            _: TransactionRequest,
        ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
            unimplemented!()
        }
        fn trace_transaction(
            &self,
            _: &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,
        ) -> anyhow::Result<alloy::rpc::types::trace::geth::DiffMode> {
            unimplemented!()
        }
        fn chain_id(&self) -> anyhow::Result<alloy_primitives::ChainId> {
            Ok(0x123)
        }
        fn block_gas_limit(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<u128> {
            Ok(0x1234)
        }
        fn block_coinbase(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<Address> {
            Ok(Address::ZERO)
        }
        fn block_difficulty(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<U256> {
            Ok(U256::from(0x12345u128))
        }
        fn block_hash(
            &self,
            _: alloy::eips::BlockNumberOrTag,
        ) -> anyhow::Result<alloy_primitives::BlockHash> {
            Ok([0xEE; 32].into())
        }
        fn block_timestamp(
            &self,
            _: alloy::eips::BlockNumberOrTag,
        ) -> anyhow::Result<alloy_primitives::BlockTimestamp> {
            Ok(0x123456)
        }
        fn last_block_number(&self) -> anyhow::Result<alloy_primitives::BlockNumber> {
            Ok(0x1234567)
        }
    }
    #[test]
    fn test_encoded_input_uint256() {
        let raw_metadata = r#"
@@ -267,26 +507,28 @@ mod tests {
        "#;
        let parsed_abi: JsonAbi = serde_json::from_str(raw_metadata).unwrap();
-        let selector = keccak256("store(uint256)".as_bytes())[0..4]
+        let selector = parsed_abi
-            .try_into()
+            .function("store")
-            .unwrap();
+            .unwrap()
            .first()
            .unwrap()
            .selector()
            .0;
        let input = Input {
-            instance: "Contract".to_string(),
+            instance: ContractInstance::new_from("Contract"),
-            method: Method::Function(selector),
+            method: Method::FunctionName("store".to_owned()),
-            calldata: Some(Calldata::Compound(vec![CalldataArg::Literal(
+            calldata: Calldata::Compound(vec!["42".into()]),
                "42".to_string(),
            )])),
            ..Default::default()
        };
-        let mut deployed_abis = HashMap::new();
+        let mut contracts = HashMap::new();
-        deployed_abis.insert("Contract".to_string(), parsed_abi);
+        contracts.insert(
-        let deployed_contracts = HashMap::new();
+            ContractInstance::new_from("Contract"),
            (Address::ZERO, parsed_abi),
        );
-        let encoded = input
+        let encoded = input.encoded_input(&contracts, &DummyEthereumNode).unwrap();
            .encoded_input(&deployed_abis, &deployed_contracts)
            .unwrap();
        assert!(encoded.0.starts_with(&selector));
        type T = (u64,);
@@ -295,83 +537,11 @@ mod tests {
    }
    #[test]
-    fn test_encoded_input_bool() {
+    fn test_encoded_input_address_with_signature() {
        let raw_abi = r#"[
            {
                "inputs": [{"name": "flag", "type": "bool"}],
                "name": "toggle",
                "outputs": [],
                "stateMutability": "nonpayable",
                "type": "function"
            }
        ]"#;
        let parsed_abi: JsonAbi = serde_json::from_str(raw_abi).unwrap();
        let selector = keccak256("toggle(bool)".as_bytes())[0..4]
            .try_into()
            .unwrap();
        let input = Input {
            instance: "Contract".to_string(),
            method: Method::Function(selector),
            calldata: Some(Calldata::Compound(vec![CalldataArg::Literal(
                "true".to_string(),
            )])),
            ..Default::default()
        };
        let mut abis = HashMap::new();
        abis.insert("Contract".to_string(), parsed_abi);
        let contracts = HashMap::new();
        let encoded = input.encoded_input(&abis, &contracts).unwrap();
        assert!(encoded.0.starts_with(&selector));
        type T = (bool,);
        let decoded: T = T::abi_decode(&encoded.0[4..]).unwrap();
        assert_eq!(decoded.0, true);
    }
    #[test]
    fn test_encoded_input_string() {
        let raw_abi = r#"[
            {
                "inputs": [{"name": "msg", "type": "string"}],
                "name": "echo",
                "outputs": [],
                "stateMutability": "nonpayable",
                "type": "function"
            }
        ]"#;
        let parsed_abi: JsonAbi = serde_json::from_str(raw_abi).unwrap();
        let selector = keccak256("echo(string)".as_bytes())[0..4]
            .try_into()
            .unwrap();
        let input = Input {
            instance: "Contract".to_string(),
            method: Method::Function(selector),
            calldata: Some(Calldata::Compound(vec![CalldataArg::Literal(
                "hello".to_string(),
            )])),
            ..Default::default()
        };
        let mut abis = HashMap::new();
        abis.insert("Contract".to_string(), parsed_abi);
        let contracts = HashMap::new();
        let encoded = input.encoded_input(&abis, &contracts).unwrap();
        assert!(encoded.0.starts_with(&selector));
    }
    #[test]
    fn test_encoded_input_uint256_array() {
        let raw_abi = r#"[
        {
-            "inputs": [{"name": "arr", "type": "uint256[]"}],
+            "inputs": [{"name": "recipient", "type": "address"}],
-            "name": "sum",
+            "name": "send",
            "outputs": [],
            "stateMutability": "nonpayable",
            "type": "function"
@@ -379,25 +549,38 @@ mod tests {
        ]"#;
        let parsed_abi: JsonAbi = serde_json::from_str(raw_abi).unwrap();
-        let selector = keccak256("sum(uint256[])".as_bytes())[0..4]
+        let selector = parsed_abi
-            .try_into()
+            .function("send")
-            .unwrap();
+            .unwrap()
            .first()
            .unwrap()
            .selector()
            .0;
-        let input = Input {
+        let input: Input = Input {
-            instance: "Contract".to_string(),
+            instance: "Contract".to_owned().into(),
-            method: Method::Function(selector),
+            method: Method::FunctionName("send(address)".to_owned()),
-            calldata: Some(Calldata::Compound(vec![CalldataArg::Literal(
+            calldata: Calldata::Compound(vec![
-                "[1,2,3]".to_string(),
+                "0x1000000000000000000000000000000000000001".to_string(),
-            )])),
+            ]),
            ..Default::default()
        };
-        let mut abis = HashMap::new();
+        let mut contracts = HashMap::new();
-        abis.insert("Contract".to_string(), parsed_abi);
+        contracts.insert(
-        let contracts = HashMap::new();
+            ContractInstance::new_from("Contract"),
            (Address::ZERO, parsed_abi),
        );
-        let encoded = input.encoded_input(&abis, &contracts).unwrap();
+        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]
@@ -413,24 +596,30 @@ mod tests {
        ]"#;
        let parsed_abi: JsonAbi = serde_json::from_str(raw_abi).unwrap();
-        let selector = keccak256("send(address)".as_bytes())[0..4]
+        let selector = parsed_abi
-            .try_into()
+            .function("send")
-            .unwrap();
+            .unwrap()
            .first()
            .unwrap()
            .selector()
            .0;
-        let input = Input {
+        let input: Input = Input {
-            instance: "Contract".to_string(),
+            instance: ContractInstance::new_from("Contract"),
-            method: Method::Function(selector),
+            method: Method::FunctionName("send".to_owned()),
-            calldata: Some(Calldata::Compound(vec![CalldataArg::Literal(
+            calldata: Calldata::Compound(vec![
                "0x1000000000000000000000000000000000000001".to_string(),
-            )])),
+            ]),
            ..Default::default()
        };
-        let mut abis = HashMap::new();
+        let mut contracts = HashMap::new();
-        abis.insert("Contract".to_string(), parsed_abi);
+        contracts.insert(
-        let contracts = HashMap::new();
+            ContractInstance::new_from("Contract"),
            (Address::ZERO, parsed_abi),
        );
-        let encoded = input.encoded_input(&abis, &contracts).unwrap();
+        let encoded = input.encoded_input(&contracts, &DummyEthereumNode).unwrap();
        assert!(encoded.0.starts_with(&selector));
        type T = (alloy_primitives::Address,);
@@ -440,4 +629,128 @@ mod tests {
            address!("0x1000000000000000000000000000000000000001")
        );
    }
    #[test]
    fn resolver_can_resolve_chain_id_variable() {
        // Arrange
        let input = "$CHAIN_ID";
        // Act
        let resolved = resolve_argument(input, &Default::default(), &DummyEthereumNode);
        // Assert
        let resolved = resolved.expect("Failed to resolve argument");
        assert_eq!(resolved, U256::from(DummyEthereumNode.chain_id().unwrap()))
    }
    #[test]
    fn resolver_can_resolve_gas_limit_variable() {
        // Arrange
        let input = "$GAS_LIMIT";
        // Act
        let resolved = resolve_argument(input, &Default::default(), &DummyEthereumNode);
        // Assert
        let resolved = resolved.expect("Failed to resolve argument");
        assert_eq!(
            resolved,
            U256::from(
                DummyEthereumNode
                    .block_gas_limit(Default::default())
                    .unwrap()
            )
        )
    }
    #[test]
    fn resolver_can_resolve_coinbase_variable() {
        // Arrange
        let input = "$COINBASE";
        // Act
        let resolved = resolve_argument(input, &Default::default(), &DummyEthereumNode);
        // Assert
        let resolved = resolved.expect("Failed to resolve argument");
        assert_eq!(
            resolved,
            U256::from_be_slice(
                DummyEthereumNode
                    .block_coinbase(Default::default())
                    .unwrap()
                    .as_ref()
            )
        )
    }
    #[test]
    fn resolver_can_resolve_block_difficulty_variable() {
        // Arrange
        let input = "$DIFFICULTY";
        // Act
        let resolved = resolve_argument(input, &Default::default(), &DummyEthereumNode);
        // Assert
        let resolved = resolved.expect("Failed to resolve argument");
        assert_eq!(
            resolved,
            DummyEthereumNode
                .block_difficulty(Default::default())
                .unwrap()
        )
    }
    #[test]
    fn resolver_can_resolve_block_hash_variable() {
        // Arrange
        let input = "$BLOCK_HASH";
        // Act
        let resolved = resolve_argument(input, &Default::default(), &DummyEthereumNode);
        // Assert
        let resolved = resolved.expect("Failed to resolve argument");
        assert_eq!(
            resolved,
            U256::from_be_bytes(DummyEthereumNode.block_hash(Default::default()).unwrap().0)
        )
    }
    #[test]
    fn resolver_can_resolve_block_number_variable() {
        // Arrange
        let input = "$BLOCK_NUMBER";
        // Act
        let resolved = resolve_argument(input, &Default::default(), &DummyEthereumNode);
        // Assert
        let resolved = resolved.expect("Failed to resolve argument");
        assert_eq!(
            resolved,
            U256::from(DummyEthereumNode.last_block_number().unwrap())
        )
    }
    #[test]
    fn resolver_can_resolve_block_timestamp_variable() {
        // Arrange
        let input = "$BLOCK_TIMESTAMP";
        // Act
        let resolved = resolve_argument(input, &Default::default(), &DummyEthereumNode);
        // Assert
        let resolved = resolved.expect("Failed to resolve argument");
        assert_eq!(
            resolved,
            U256::from(
                DummyEthereumNode
                    .block_timestamp(Default::default())
                    .unwrap()
            )
        )
    }
 }
@@ -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 the contract sources with canonicalized paths for the files
-    ///
+    pub fn contract_sources(
-    /// Returns a mapping of contract IDs to their source path and contract name.
+        &self,
-    pub fn contract_sources(&self) -> anyhow::Result<BTreeMap<String, (PathBuf, String)>> {
+    ) -> 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 {
+        for (
-            // TODO: broken if a colon is in the dir name..
+            alias,
-            let mut parts = contract.split(':');
+            ContractPathAndIdentifier {
-            let (Some(file_name), Some(contract_name)) = (parts.next(), parts.next()) else {
+                contract_source_path,
-                anyhow::bail!("metadata contains invalid contract: {contract}");
+                contract_ident,
-            };
+            },
-            let file = directory.to_path_buf().join(file_name);
+        ) in contracts
-            if !file.is_file() {
+        {
-                anyhow::bail!("contract {id} is not a file: {}", file.display());
+            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
+                metadata.contracts = Some(
-                    .file_name()
+                    [(
-                    .expect("this should be the path to a Solidity file")
+                        ContractInstance::new_from("test"),
-                    .to_str()
+                        ContractPathAndIdentifier {
-                    .expect("the file name should be valid UTF-8k");
+                            contract_source_path: path.to_path_buf(),
-                metadata.contracts = Some([(String::from("Test"), format!("{name}:Test"))].into());
+                            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");
    }
 }
@@ -11,6 +11,7 @@ rust-version.workspace = true
 [dependencies]
 alloy = { workspace = true }
 anyhow = { workspace = true }
 futures = { workspace = true }
 tracing = { workspace = true }
 once_cell = { workspace = true }
 tokio = { workspace = true }
@@ -0,0 +1,228 @@
 //! The alloy crate __requires__ a tokio runtime.
 //! We contain any async rust right here.
 use std::{any::Any, panic::AssertUnwindSafe, pin::Pin, thread};
 use futures::FutureExt;
 use once_cell::sync::Lazy;
 use tokio::{
    runtime::Builder,
    sync::{mpsc::UnboundedSender, oneshot},
 };
 use tracing::Instrument;
 /// A blocking async executor.
 ///
 /// This struct exposes the abstraction of a blocking async executor. It is a global and static
 /// executor which means that it doesn't require for new instances of it to be created, it's a
 /// singleton and can be accessed by any thread that wants to perform some async computation on the
 /// blocking executor thread.
 ///
 /// The API of the blocking executor is created in a way so that it's very natural, simple to use,
 /// and unbounded to specific tasks or return types. The following is an example of using this
 /// executor to drive an async computation:
 ///
 /// ```rust
 /// use revive_dt_node_interaction::*;
 ///
 /// fn blocking_function() {
 ///     let result = BlockingExecutor::execute(async move {
 ///         tokio::time::sleep(std::time::Duration::from_secs(1)).await;
 ///         0xFFu8
 ///     })
 ///     .expect("Computation failed");
 ///
 ///     assert_eq!(result, 0xFF);
 /// }
 /// ```
 ///
 /// Users get to pass in their async tasks without needing to worry about putting them in a [`Box`],
 /// [`Pin`], needing to perform down-casting, or the internal channel mechanism used by the runtime.
 /// To the user, it just looks like a function that converts some async code into sync code.
 ///
 /// This struct also handled panics that occur in the passed futures and converts them into errors
 /// that can be handled by the user. This is done to allow the executor to be robust.
 ///
 /// Internally, the executor communicates with the tokio runtime thread through channels which carry
 /// the [`TaskMessage`] and the results of the execution.
 pub struct BlockingExecutor;
 impl BlockingExecutor {
    pub fn execute<R>(future: impl Future<Output = R> + Send + 'static) -> Result<R, anyhow::Error>
    where
        R: Send + 'static,
    {
        // Note: The blocking executor is a singleton and therefore we store its state in a static
        // so that it's assigned only once. Additionally, when we set the state of the executor we
        // spawn the thread where the async runtime runs.
        static STATE: Lazy<ExecutorState> = Lazy::new(|| {
            tracing::trace!("Initializing the BlockingExecutor state");
            // All communication with the tokio runtime thread happens over mspc channels where the
            // producers here are the threads that want to run async tasks and the consumer here is
            // the tokio runtime thread.
            let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<TaskMessage>();
            thread::spawn(move || {
                tracing::info!(
                    thread_id = ?std::thread::current().id(),
                    "Starting async runtime thread"
                );
                let runtime = Builder::new_current_thread()
                    .enable_all()
                    .build()
                    .expect("Failed to create the async runtime");
                runtime.block_on(async move {
                    while let Some(TaskMessage {
                        future: task,
                        response_tx: response_channel,
                    }) = rx.recv().await
                    {
                        tracing::trace!("Received a new future to execute");
                        tokio::spawn(async move {
                            // One of the things that the blocking executor does is that it allows
                            // us to catch panics if they occur. By wrapping the given future in an
                            // AssertUnwindSafe::catch_unwind we are able to catch all panic unwinds
                            // in the given future and convert them into errors.
                            let task = AssertUnwindSafe(task).catch_unwind();
                            let result = task.await;
                            let _ = response_channel.send(result);
                        });
                    }
                })
            });
            ExecutorState { tx }
        });
        // We need to perform blocking synchronous communication between the current thread and the
        // tokio runtime thread with the result of the async computation and the oneshot channels
        // from tokio allows us to do that. The sender side of the channel will be given to the
        // tokio runtime thread to send the result when the computation is completed and the receive
        // side of the channel will be kept with this thread to await for the response of the async
        // task to come back.
        let (response_tx, response_rx) =
            oneshot::channel::<Result<Box<dyn Any + Send>, Box<dyn Any + Send>>>();
        // The tokio runtime thread expects a Future<Output = Box<dyn Any + Send>> + Send to be
        // sent to it to execute. However, this function has a typed Future<Output = R> + Send and
        // therefore we need to change the type of the future to fit what the runtime thread expects
        // in the task message. In doing this conversion, we lose some of the type information since
        // we're converting R => dyn Any. However, we will perform down-casting on the result to
        // convert it back into R.
        let future = Box::pin(
            async move { Box::new(future.await) as Box<dyn Any + Send> }.in_current_span(),
        );
        let task = TaskMessage::new(future, response_tx);
        if let Err(error) = STATE.tx.send(task) {
            tracing::error!(?error, "Failed to send the task to the blocking executor");
            anyhow::bail!("Failed to send the task to the blocking executor: {error:?}")
        }
        let result = match response_rx.blocking_recv() {
            Ok(result) => result,
            Err(error) => {
                tracing::error!(
                    ?error,
                    "Failed to get the response from the blocking executor"
                );
                anyhow::bail!("Failed to get the response from the blocking executor: {error:?}")
            }
        };
        match result.map(|result| {
            *result
                .downcast::<R>()
                .expect("Type mismatch in the downcast")
        }) {
            Ok(result) => Ok(result),
            Err(error) => {
                tracing::error!(
                    ?error,
                    "Failed to downcast the returned result into the expected type"
                );
                anyhow::bail!(
                    "Failed to downcast the returned result into the expected type: {error:?}"
                )
            }
        }
    }
 }
 /// Represents the state of the async runtime. This runtime is designed to be a singleton runtime
 /// which means that in the current running program there's just a single thread that has an async
 /// runtime.
 struct ExecutorState {
    /// The sending side of the task messages channel. This is used by all of the other threads to
    /// communicate with the async runtime thread.
    tx: UnboundedSender<TaskMessage>,
 }
 /// Represents a message that contains an asynchronous task that's to be executed by the runtime
 /// as well as a way for the runtime to report back on the result of the execution.
 struct TaskMessage {
    /// The task that's being requested to run. This is a future that returns an object that does
    /// implement [`Any`] and [`Send`] to allow it to be sent between the requesting thread and the
    /// async thread.
    future: Pin<Box<dyn Future<Output = Box<dyn Any + Send>> + Send>>,
    /// A one shot sender channel where the sender of the task is expecting to hear back on the
    /// result of the task.
    response_tx: oneshot::Sender<Result<Box<dyn Any + Send>, Box<dyn Any + Send>>>,
 }
 impl TaskMessage {
    pub fn new(
        future: Pin<Box<dyn Future<Output = Box<dyn Any + Send>> + Send>>,
        response_tx: oneshot::Sender<Result<Box<dyn Any + Send>, Box<dyn Any + Send>>>,
    ) -> Self {
        Self {
            future,
            response_tx,
        }
    }
 }
 #[cfg(test)]
 mod test {
    use super::*;
    #[test]
    fn simple_future_works() {
        // Act
        let result = BlockingExecutor::execute(async move {
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            0xFFu8
        })
        .unwrap();
        // Assert
        assert_eq!(result, 0xFFu8);
    }
    #[test]
    #[allow(unreachable_code, clippy::unreachable)]
    fn panics_in_futures_are_caught() {
        // Act
        let result = BlockingExecutor::execute(async move {
            panic!("This is a panic!");
            0xFFu8
        });
        // Assert
        assert!(result.is_err());
        // Act
        let result = BlockingExecutor::execute(async move {
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            0xFFu8
        })
        .unwrap();
        // Assert
        assert_eq!(result, 0xFFu8)
    }
 }
@@ -1,29 +1,49 @@
 //! This crate implements all node interactions.
-use alloy::primitives::Address;
+use alloy::eips::BlockNumberOrTag;
-use alloy::rpc::types::trace::geth::{DiffMode, GethTrace};
+use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
 use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
 use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
-use tokio_runtime::TO_TOKIO;
+use anyhow::Result;
-pub mod nonce;
+mod blocking_executor;
-mod tokio_runtime;
+pub use blocking_executor::*;
 pub mod trace;
 pub mod transaction;
 /// An interface for all interactions with Ethereum compatible nodes.
 pub trait EthereumNode {
    /// Execute the [TransactionRequest] and return a [TransactionReceipt].
-    fn execute_transaction(
+    fn execute_transaction(&self, transaction: TransactionRequest) -> Result<TransactionReceipt>;
        &self,
        transaction: TransactionRequest,
    ) -> anyhow::Result<TransactionReceipt>;
    /// Trace the transaction in the [TransactionReceipt] and return a [GethTrace].
-    fn trace_transaction(&self, transaction: TransactionReceipt) -> anyhow::Result<GethTrace>;
+    fn trace_transaction(
        &self,
        receipt: &TransactionReceipt,
        trace_options: GethDebugTracingOptions,
    ) -> Result<GethTrace>;
    /// Returns the state diff of the transaction hash in the [TransactionReceipt].
-    fn state_diff(&self, transaction: TransactionReceipt) -> anyhow::Result<DiffMode>;
+    fn state_diff(&self, receipt: &TransactionReceipt) -> Result<DiffMode>;
-    /// Returns the next available nonce for the given [Address].
+    /// Returns the ID of the chain that the node is on.
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64>;
+    fn chain_id(&self) -> Result<ChainId>;
    // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
    // when we implement the changes to the gas we need to adjust this to be a u64.
    /// Returns the gas limit of the specified block.
    fn block_gas_limit(&self, number: BlockNumberOrTag) -> Result<u128>;
    /// Returns the coinbase of the specified block.
    fn block_coinbase(&self, number: BlockNumberOrTag) -> Result<Address>;
    /// Returns the difficulty of the specified block.
    fn block_difficulty(&self, number: BlockNumberOrTag) -> Result<U256>;
    /// Returns the hash of the specified block.
    fn block_hash(&self, number: BlockNumberOrTag) -> Result<BlockHash>;
    /// Returns the timestamp of the specified block,
    fn block_timestamp(&self, number: BlockNumberOrTag) -> Result<BlockTimestamp>;
    /// Returns the number of the last block.
    fn last_block_number(&self) -> Result<BlockNumber>;
 }
@@ -1,55 +0,0 @@
 use std::pin::Pin;
 use alloy::{
    primitives::Address,
    providers::{Provider, ProviderBuilder},
 };
 use tokio::sync::oneshot;
 use crate::{TO_TOKIO, tokio_runtime::AsyncNodeInteraction};
 pub type Task = Pin<Box<dyn Future<Output = anyhow::Result<u64>> + Send>>;
 pub(crate) struct Nonce {
    sender: oneshot::Sender<anyhow::Result<u64>>,
    task: Task,
 }
 impl AsyncNodeInteraction for Nonce {
    type Output = anyhow::Result<u64>;
    fn split(
        self,
    ) -> (
        std::pin::Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    ) {
        (self.task, self.sender)
    }
 }
 /// This is like `trace_transaction`, just for nonces.
 pub fn fetch_onchain_nonce(
    connection: String,
    wallet: alloy::network::EthereumWallet,
    address: Address,
 ) -> anyhow::Result<u64> {
    let sender = TO_TOKIO.lock().unwrap().nonce_sender.clone();
    let (tx, rx) = oneshot::channel();
    let task: Task = Box::pin(async move {
        let provider = ProviderBuilder::new()
            .wallet(wallet)
            .connect(&connection)
            .await?;
        let onchain = provider.get_transaction_count(address).await?;
        Ok(onchain)
    });
    sender
        .blocking_send(Nonce { task, sender: tx })
        .expect("not in async context");
    rx.blocking_recv()
        .unwrap_or_else(|err| anyhow::bail!("nonce fetch failed: {err}"))
 }
@@ -1,87 +0,0 @@
 //! The alloy crate __requires__ a tokio runtime.
 //! We contain any async rust right here.
 use once_cell::sync::Lazy;
 use std::pin::Pin;
 use std::sync::Mutex;
 use std::thread;
 use tokio::runtime::Runtime;
 use tokio::spawn;
 use tokio::sync::{mpsc, oneshot};
 use tokio::task::JoinError;
 use crate::nonce::Nonce;
 use crate::trace::Trace;
 use crate::transaction::Transaction;
 pub(crate) static TO_TOKIO: Lazy<Mutex<TokioRuntime>> =
    Lazy::new(|| Mutex::new(TokioRuntime::spawn()));
 /// Common interface for executing async node interactions from a non-async context.
 #[allow(clippy::type_complexity)]
 pub(crate) trait AsyncNodeInteraction: Send + 'static {
    type Output: Send;
    //// Returns the task and the output sender.
    fn split(
        self,
    ) -> (
        Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    );
 }
 pub(crate) struct TokioRuntime {
    pub(crate) transaction_sender: mpsc::Sender<Transaction>,
    pub(crate) trace_sender: mpsc::Sender<Trace>,
    pub(crate) nonce_sender: mpsc::Sender<Nonce>,
 }
 impl TokioRuntime {
    fn spawn() -> Self {
        let rt = Runtime::new().expect("should be able to create the tokio runtime");
        let (transaction_sender, transaction_receiver) = mpsc::channel::<Transaction>(1024);
        let (trace_sender, trace_receiver) = mpsc::channel::<Trace>(1024);
        let (nonce_sender, nonce_receiver) = mpsc::channel::<Nonce>(1024);
        thread::spawn(move || {
            rt.block_on(async move {
                let transaction_task = spawn(interaction::<Transaction>(transaction_receiver));
                let trace_task = spawn(interaction::<Trace>(trace_receiver));
                let nonce_task = spawn(interaction::<Nonce>(nonce_receiver));
                if let Err(error) = transaction_task.await {
                    tracing::error!("tokio transaction task failed: {error}");
                }
                if let Err(error) = trace_task.await {
                    tracing::error!("tokio trace transaction task failed: {error}");
                }
                if let Err(error) = nonce_task.await {
                    tracing::error!("tokio nonce task failed: {error}");
                }
            });
        });
        Self {
            transaction_sender,
            trace_sender,
            nonce_sender,
        }
    }
 }
 async fn interaction<T>(mut receiver: mpsc::Receiver<T>) -> Result<(), JoinError>
 where
    T: AsyncNodeInteraction,
 {
    while let Some(task) = receiver.recv().await {
        spawn(async move {
            let (task, sender) = task.split();
            sender
                .send(task.await)
                .unwrap_or_else(|_| panic!("failed to send task output"));
        });
    }
    Ok(())
 }
@@ -1,43 +0,0 @@
 //! Trace transactions in a sync context.
 use std::pin::Pin;
 use alloy::rpc::types::trace::geth::GethTrace;
 use tokio::sync::oneshot;
 use crate::TO_TOKIO;
 use crate::tokio_runtime::AsyncNodeInteraction;
 pub type Task = Pin<Box<dyn Future<Output = anyhow::Result<GethTrace>> + Send>>;
 pub(crate) struct Trace {
    sender: oneshot::Sender<anyhow::Result<GethTrace>>,
    task: Task,
 }
 impl AsyncNodeInteraction for Trace {
    type Output = anyhow::Result<GethTrace>;
    fn split(
        self,
    ) -> (
        std::pin::Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    ) {
        (self.task, self.sender)
    }
 }
 /// Execute some [Task] that return a [GethTrace] result.
 pub fn trace_transaction(task: Task) -> anyhow::Result<GethTrace> {
    let task_sender = TO_TOKIO.lock().unwrap().trace_sender.clone();
    let (sender, receiver) = oneshot::channel();
    task_sender
        .blocking_send(Trace { task, sender })
        .expect("we are not calling this from an async context");
    receiver
        .blocking_recv()
        .unwrap_or_else(|error| anyhow::bail!("no trace received: {error}"))
 }
@@ -1,46 +0,0 @@
 //! Execute transactions in a sync context.
 use std::pin::Pin;
 use alloy::rpc::types::TransactionReceipt;
 use tokio::sync::oneshot;
 use crate::TO_TOKIO;
 use crate::tokio_runtime::AsyncNodeInteraction;
 pub type Task = Pin<Box<dyn Future<Output = anyhow::Result<TransactionReceipt>> + Send>>;
 pub(crate) struct Transaction {
    receipt_sender: oneshot::Sender<anyhow::Result<TransactionReceipt>>,
    task: Task,
 }
 impl AsyncNodeInteraction for Transaction {
    type Output = anyhow::Result<TransactionReceipt>;
    fn split(
        self,
    ) -> (
        Pin<Box<dyn Future<Output = Self::Output> + Send>>,
        oneshot::Sender<Self::Output>,
    ) {
        (self.task, self.receipt_sender)
    }
 }
 /// Execute some [Task] that returns a [TransactionReceipt].
 pub fn execute_transaction(task: Task) -> anyhow::Result<TransactionReceipt> {
    let request_sender = TO_TOKIO.lock().unwrap().transaction_sender.clone();
    let (receipt_sender, receipt_receiver) = oneshot::channel();
    request_sender
        .blocking_send(Transaction {
            receipt_sender,
            task,
        })
        .expect("we are not calling this from an async context");
    receipt_receiver
        .blocking_recv()
        .unwrap_or_else(|error| anyhow::bail!("no receipt received: {error}"))
 }
@@ -17,6 +17,7 @@ tokio = { workspace = true }
 revive-dt-node-interaction = { workspace = true }
 revive-dt-config = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 sp-core = { workspace = true }
@@ -24,3 +25,4 @@ sp-runtime = { workspace = true }
 [dev-dependencies]
 temp-dir = { workspace = true }
 tokio = { workspace = true }
@@ -0,0 +1,78 @@
 use alloy::{
    network::{Network, TransactionBuilder},
    providers::{
        Provider, SendableTx,
        fillers::{GasFiller, TxFiller},
    },
    transports::TransportResult,
 };
 #[derive(Clone, Debug)]
 pub struct FallbackGasFiller {
    inner: GasFiller,
    default_gas_limit: u64,
    default_max_fee_per_gas: u128,
    default_priority_fee: u128,
 }
 impl FallbackGasFiller {
    pub fn new(
        default_gas_limit: u64,
        default_max_fee_per_gas: u128,
        default_priority_fee: u128,
    ) -> Self {
        Self {
            inner: GasFiller,
            default_gas_limit,
            default_max_fee_per_gas,
            default_priority_fee,
        }
    }
 }
 impl<N> TxFiller<N> for FallbackGasFiller
 where
    N: Network,
 {
    type Fillable = Option<<GasFiller as TxFiller<N>>::Fillable>;
    fn status(
        &self,
        tx: &<N as Network>::TransactionRequest,
    ) -> alloy::providers::fillers::FillerControlFlow {
        <GasFiller as TxFiller<N>>::status(&self.inner, tx)
    }
    fn fill_sync(&self, _: &mut alloy::providers::SendableTx<N>) {}
    async fn prepare<P: Provider<N>>(
        &self,
        provider: &P,
        tx: &<N as Network>::TransactionRequest,
    ) -> TransportResult<Self::Fillable> {
        // Try to fetch GasFiller’s “fillable” (gas_price, base_fee, estimate_gas, …)
        // If it errors (i.e. tx would revert under eth_estimateGas), swallow it.
        match self.inner.prepare(provider, tx).await {
            Ok(fill) => Ok(Some(fill)),
            Err(_) => Ok(None),
        }
    }
    async fn fill(
        &self,
        fillable: Self::Fillable,
        mut tx: alloy::providers::SendableTx<N>,
    ) -> TransportResult<SendableTx<N>> {
        if let Some(fill) = fillable {
            // our inner GasFiller succeeded — use it
            self.inner.fill(fill, tx).await
        } else {
            if let Some(builder) = tx.as_mut_builder() {
                builder.set_gas_limit(self.default_gas_limit);
                builder.set_max_fee_per_gas(self.default_max_fee_per_gas);
                builder.set_max_priority_fee_per_gas(self.default_priority_fee);
            }
            Ok(tx)
        }
    }
 }
@@ -0,0 +1,5 @@
 /// This constant defines how much Wei accounts are pre-seeded with in genesis.
 ///
 /// Note: After changing this number, check that the tests for kitchensink work as we encountered
 /// some issues with different values of the initial balance on Kitchensink.
 pub const INITIAL_BALANCE: u128 = 10u128.pow(37);
@@ -1,35 +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::{
+    sync::atomic::{AtomicU32, Ordering},
        Mutex,
        atomic::{AtomicU32, Ordering},
    },
    time::{Duration, Instant},
 };
 use alloy::{
-    network::EthereumWallet,
+    eips::BlockNumberOrTag,
-    primitives::Address,
+    genesis::{Genesis, GenesisAccount},
-    providers::{Provider, ProviderBuilder, ext::DebugApi},
+    network::{Ethereum, EthereumWallet, NetworkWallet},
    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, U256},
    providers::{
        Provider, ProviderBuilder,
        ext::DebugApi,
        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::{
+use revive_dt_node_interaction::{BlockingExecutor, EthereumNode};
    EthereumNode, nonce::fetch_onchain_nonce, trace::trace_transaction,
    transaction::execute_transaction,
 };
 use tracing::Level;
-use crate::Node;
+use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
@@ -52,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
@@ -80,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")
@@ -194,6 +205,35 @@ impl Instance {
    fn geth_stderr_log_file_path(&self) -> PathBuf {
        self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
    }
    fn provider(
        &self,
    ) -> impl Future<
        Output = anyhow::Result<
            FillProvider<impl TxFiller<Ethereum>, impl Provider<Ethereum>, Ethereum>,
        >,
    > + 'static {
        let connection_string = self.connection_string();
        let wallet = self.wallet.clone();
        // Note: We would like all providers to make use of the same nonce manager so that we have
        // monotonically increasing nonces that are cached. The cached nonce manager uses Arc's in
        // its implementation and therefore it means that when we clone it then it still references
        // the same state.
        let nonce_manager = self.nonce_manager.clone();
        Box::pin(async move {
            ProviderBuilder::new()
                .disable_recommended_fillers()
                .filler(FallbackGasFiller::new(500_000_000, 500_000_000, 1))
                .filler(ChainIdFiller::default())
                .filler(NonceFiller::new(nonce_manager))
                .wallet(wallet)
                .connect(&connection_string)
                .await
                .map_err(Into::into)
        })
    }
 }
 impl EthereumNode for Instance {
@@ -202,17 +242,12 @@ impl EthereumNode for Instance {
        &self,
        transaction: TransactionRequest,
    ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let connection_string = self.connection_string();
+        let provider = self.provider();
-        let wallet = self.wallet.clone();
+        BlockingExecutor::execute(async move {
-
+            let outer_span = tracing::debug_span!("Submitting transaction", ?transaction);
        execute_transaction(Box::pin(async move {
            let outer_span = tracing::debug_span!("Submitting transaction", ?transaction,);
            let _outer_guard = outer_span.enter();
-            let provider = ProviderBuilder::new()
+            let provider = provider.await?;
                .wallet(wallet)
                .connect(&connection_string)
                .await?;
            let pending_transaction = provider.send_transaction(transaction).await?;
            let transaction_hash = pending_transaction.tx_hash();
@@ -284,39 +319,34 @@ 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 connection_string = self.connection_string();
+        let tx_hash = transaction.transaction_hash;
        let provider = self.provider();
        BlockingExecutor::execute(async move {
            Ok(provider
                .await?
                .debug_trace_transaction(tx_hash, trace_options)
                .await?)
        })?
    }
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
        let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
            diff_mode: Some(true),
            disable_code: None,
            disable_storage: None,
        });
        let wallet = self.wallet.clone();
        trace_transaction(Box::pin(async move {
            Ok(ProviderBuilder::new()
                .wallet(wallet)
                .connect(&connection_string)
                .await?
                .debug_trace_transaction(transaction.transaction_hash, trace_options)
                .await?)
        }))
    }
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn state_diff(
        &self,
        transaction: alloy::rpc::types::TransactionReceipt,
    ) -> anyhow::Result<DiffMode> {
        match self
-            .trace_transaction(transaction)?
+            .trace_transaction(transaction, trace_options)?
            .try_into_pre_state_frame()?
        {
            PreStateFrame::Diff(diff) => Ok(diff),
@@ -325,17 +355,84 @@ impl EthereumNode for Instance {
    }
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64> {
+    fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
-        let connection_string = self.connection_string.clone();
+        let provider = self.provider();
-        let wallet = self.wallet.clone();
+        BlockingExecutor::execute(async move {
            provider.await?.get_chain_id().await.map_err(Into::into)
        })?
    }
-        let onchain_nonce = fetch_onchain_nonce(connection_string, wallet, address)?;
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
        let provider = self.provider();
        BlockingExecutor::execute(async move {
            provider
                .await?
                .get_block_by_number(number)
                .await?
                .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
                .map(|block| block.header.gas_limit as _)
        })?
    }
-        let mut nonces = self.nonces.lock().unwrap();
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-        let current = nonces.entry(address).or_insert(onchain_nonce);
+    fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
-        let value = *current;
+        let provider = self.provider();
-        *current += 1;
+        BlockingExecutor::execute(async move {
-        Ok(value)
+            provider
                .await?
                .get_block_by_number(number)
                .await?
                .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
                .map(|block| block.header.beneficiary)
        })?
    }
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
        let provider = self.provider();
        BlockingExecutor::execute(async move {
            provider
                .await?
                .get_block_by_number(number)
                .await?
                .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
                .map(|block| block.header.difficulty)
        })?
    }
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
        let provider = self.provider();
        BlockingExecutor::execute(async move {
            provider
                .await?
                .get_block_by_number(number)
                .await?
                .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
                .map(|block| block.header.hash)
        })?
    }
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
        let provider = self.provider();
        BlockingExecutor::execute(async move {
            provider
                .await?
                .get_block_by_number(number)
                .await?
                .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
                .map(|block| block.header.timestamp)
        })?
    }
    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
    fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
        let provider = self.provider();
        BlockingExecutor::execute(async move {
            provider.await?.get_block_number().await.map_err(Into::into)
        })?
    }
 }
@@ -345,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),
@@ -355,11 +461,11 @@ impl Node for Instance {
            handle: None,
            network_id: config.network_id,
            start_timeout: config.geth_start_timeout,
-            wallet: config.wallet(),
+            wallet,
            nonces: Mutex::new(HashMap::new()),
            // 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(),
        }
    }
@@ -408,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 {
@@ -420,11 +534,12 @@ impl Drop for Instance {
 #[cfg(test)]
 mod tests {
    use revive_dt_config::Arguments;
    use temp_dir::TempDir;
    use crate::{GENESIS_JSON, Node};
-    use super::Instance;
+    use super::*;
    fn test_config() -> (Arguments, TempDir) {
        let mut config = Arguments::default();
@@ -434,6 +549,16 @@ mod tests {
        (config, temp_dir)
    }
    fn new_node() -> (Instance, TempDir) {
        let (args, temp_dir) = test_config();
        let mut node = Instance::new(&args);
        node.init(GENESIS_JSON.to_owned())
            .expect("Failed to initialize the node")
            .spawn_process()
            .expect("Failed to spawn the node process");
        (node, temp_dir)
    }
    #[test]
    fn init_works() {
        Instance::new(&test_config().0)
@@ -456,4 +581,93 @@ mod tests {
            "expected version string, got: '{version}'"
        );
    }
    #[test]
    fn can_get_chain_id_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let chain_id = node.chain_id();
        // Assert
        let chain_id = chain_id.expect("Failed to get the chain id");
        assert_eq!(chain_id, 420_420_420);
    }
    #[test]
    fn can_get_gas_limit_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let gas_limit = node.block_gas_limit(BlockNumberOrTag::Latest);
        // Assert
        let gas_limit = gas_limit.expect("Failed to get the gas limit");
        assert_eq!(gas_limit, u32::MAX as u128)
    }
    #[test]
    fn can_get_coinbase_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let coinbase = node.block_coinbase(BlockNumberOrTag::Latest);
        // Assert
        let coinbase = coinbase.expect("Failed to get the coinbase");
        assert_eq!(coinbase, Address::new([0xFF; 20]))
    }
    #[test]
    fn can_get_block_difficulty_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        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)
    }
    #[test]
    fn can_get_block_hash_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let block_hash = node.block_hash(BlockNumberOrTag::Latest);
        // Assert
        let _ = block_hash.expect("Failed to get the block hash");
    }
    #[test]
    fn can_get_block_timestamp_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        let block_timestamp = node.block_timestamp(BlockNumberOrTag::Latest);
        // Assert
        let _ = block_timestamp.expect("Failed to get the block timestamp");
    }
    #[test]
    fn can_get_block_number_from_node() {
        // Arrange
        let (node, _temp_dir) = new_node();
        // Act
        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)
    }
 }
@@ -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)
+        let version = List::download(List::WINDOWS_URL).unwrap().latest_release;
            .unwrap()
            .latest_release
            .into();
        GHDownloader::windows(version).download().unwrap();
    }
    #[test]
    fn try_get_macosx() {
-        let version = List::download(List::MACOSX_URL)
+        let version = List::download(List::MACOSX_URL).unwrap().latest_release;
            .unwrap()
            .latest_release
            .into();
        GHDownloader::macosx(version).download().unwrap();
    }
    #[test]
    fn try_get_linux() {
-        let version = List::download(List::LINUX_URL)
+        let version = List::download(List::LINUX_URL).unwrap().latest_release;
            .unwrap()
            .latest_release
            .into();
        GHDownloader::linux(version).download().unwrap();
    }
    #[test]
    fn try_get_wasm() {
-        let version = List::download(List::WASM_URL)
+        let version = List::download(List::WASM_URL).unwrap().latest_release;
            .unwrap()
            .latest_release
            .into();
        GHDownloader::wasm(version).download().unwrap();
    }
 }
@@ -33,9 +33,5 @@
    "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "timestamp": "0x00",
-    "alloc": {
+    "alloc": {}
        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
            "balance": "1000000000000000000"
        }
    }
 }
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
Omar	2259942363	Cleanup execution logic (#45 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning * Fix the ABI finding logic * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Implement ABI fix in the compiler trait impl * Update the async runtime with syntactic sugar. * Fix tests * Fix doc test * Give nodes a standard way to get their alloy provider * Add ability to get the chain_id from node * Get kitchensink provider to use kitchensink network * Use provider method in tests * Add support for getting the gas limit from the node * Add a way to get the coinbase address * Add a way to get the block difficulty from the node * Add a way to get block info from the node * Expose APIs for getting the info of a specific block * Add resolution logic for other matterlabs variables * Fix tests * Add comment on alternative solutions * Change kitchensink gas limit assertion * Cleanup execution logic	2025-07-18 12:08:13 +00:00
Omar	0b97d7dc29	Support other matterlabs variables (#43 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Update the async runtime with syntactic sugar. * Fix tests * Fix doc test * Give nodes a standard way to get their alloy provider * Add ability to get the chain_id from node * Get kitchensink provider to use kitchensink network * Use provider method in tests * Add support for getting the gas limit from the node * Add a way to get the coinbase address * Add a way to get the block difficulty from the node * Add a way to get block info from the node * Expose APIs for getting the info of a specific block * Add resolution logic for other matterlabs variables * Fix tests * Add comment on alternative solutions * Change kitchensink gas limit assertion * Remove un-needed profile config	2025-07-18 12:06:40 +00:00
Omar	2bee2d5c8b	Fix the ABI finding logic (#38 ) * Fix the ABI finding logic * Implement ABI fix in the compiler trait impl	2025-07-18 11:22:51 +00:00
Omar	854e8d9690	Fix `deserialization error: invalid value: string "0x2d79dd80ff729c000"` (#34 ) * Introduce a custom kitchensink network * fix formatting * Added `--dev` to `substrate-node` arguments. This commit adds the `--dev` argument to the `substrate-node` to allow the chain to keep advancing as time goes own. We have found that if this option is not added then the chain won't advance forward. * fix clippy warning * fix clippy warning	2025-07-18 11:22:13 +00:00
Omar	2d517784dd	Better logging for contract deployment (#46 ) * Log certain errors better * Remove unneeded code	2025-07-16 18:16:12 +00:00
Omar	baa11ad28f	Correctly identify which contracts to compile (#44 ) * Compile all contracts for a test file * Fix compilation errors related to paths * Set the base path if specified	2025-07-16 11:52:40 +00:00
Omar	c2e65f9e33	Fix function selector & argument encoding (#39 ) * Fix function selector and argument encoding * Avoid extra buffer allocation * Remove reliance on the web3 crate * Fix tests	2025-07-15 20:00:10 +00:00
Omar	14888f9767	Update the async runtime (#42 ) * Update the async runtime with syntactic sugar. * Fix doc test * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Update crates/node-interaction/src/blocking_executor.rs Co-authored-by: xermicus <cyrill@parity.io> * Improve the comments * Update the release profile --------- Co-authored-by: xermicus <cyrill@parity.io>	2025-07-15 11:19:17 +00:00