diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 723704ffba1..1f7d54d15a2 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -53,3 +53,15 @@ jobs:
         shell: 'script -q -e -c "bash {0}"' # required to workaround /dev/tty not being available
         run: |
           ./.github/scripts/compare_iai.sh
+
+  # Checks that benchmarks not run in CI compile
+  bench-check:
+    name: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Check if benchmarks build
+        run: cargo bench --all --all-features --all-targets --no-run
diff --git a/.github/workflows/project.yml b/.github/workflows/project.yml
deleted file mode 100644
index 4315ebf1aaf..00000000000
--- a/.github/workflows/project.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-name: project
-
-on:
-  issues:
-    types:
-      - opened
-
-jobs:
-  add:
-    name: add issue/pr
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/add-to-project@v0.4.0
-        with:
-          project-url: https://github.com/orgs/paradigmxyz/projects/1
-          github-token: ${{ secrets.GH_PROJECT_TOKEN }}
diff --git a/.github/workflows/sanity.yml b/.github/workflows/sanity.yml
index 59de0b5b9bd..1b33133fde8 100644
--- a/.github/workflows/sanity.yml
+++ b/.github/workflows/sanity.yml
@@ -25,7 +25,6 @@ jobs:
       - name: Install toolchain
         uses: dtolnay/rust-toolchain@nightly
         with:
-          toolchain: nightly-2022-12-27
           components: llvm-tools-preview
       - uses: Swatinem/rust-cache@v2
         with:
diff --git a/Cargo.lock b/Cargo.lock
index 114e99007c0..4ad04cc2b35 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,16 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "Inflector"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
+dependencies = [
+ "lazy_static",
+ "regex",
+]
+
 [[package]]
 name = "addr2line"
 version = "0.19.0"
@@ -128,21 +138,21 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anyhow"
-version = "1.0.68"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61"
+checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800"
 
 [[package]]
 name = "aquamarine"
-version = "0.2.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7cba9b073f771a6f76683be98624dd68e867ff9e6adcad3afbb3d2044c3afa"
+checksum = "759d98a5db12e9c9d98ef2b92f794ae5c7ded6ec18d21c3fa485c9c65bec237d"
 dependencies = [
- "itertools 0.9.0",
+ "itertools",
  "proc-macro-error",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -182,44 +192,22 @@ dependencies = [
 
 [[package]]
 name = "async-lock"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8101efe8695a6c17e02911402145357e718ac92d3ff88ae8419e84b1707b685"
+checksum = "fa24f727524730b077666307f2734b4a1a1c57acb79193127dcc8914d5242dd7"
 dependencies = [
  "event-listener",
- "futures-lite",
-]
-
-[[package]]
-name = "async-stream"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dad5c83079eae9969be7fadefe640a1c566901f05ff91ab221de4b6f68d9507e"
-dependencies = [
- "async-stream-impl",
- "futures-core",
-]
-
-[[package]]
-name = "async-stream-impl"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f203db73a71dfa2fb6dd22763990fa26f3d2625a6da2da900d23b87d26be27"
-dependencies = [
- "proc-macro2 1.0.51",
- "quote 1.0.23",
- "syn 1.0.107",
 ]
 
 [[package]]
 name = "async-trait"
-version = "0.1.64"
+version = "0.1.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd7fce9ba8c3c042128ce72d8b2ddbf3a05747efb67ea0313c635e10bda47a2"
+checksum = "095183a3539c7c7649b2beb87c2d3f0591f3a7fed07761cc546d244e27e0238c"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -265,18 +253,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "auto_impl"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7862e21c893d65a1650125d157eaeec691439379a1cee17ee49031b79236ada4"
-dependencies = [
- "proc-macro-error",
- "proc-macro2 1.0.51",
- "quote 1.0.23",
- "syn 1.0.107",
-]
-
 [[package]]
 name = "auto_impl"
 version = "1.0.1"
@@ -284,9 +260,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a8c1df849285fbacd587de7818cc7d13be6cd2cbcd47a04fb1801b0e2706e33"
 dependencies = [
  "proc-macro-error",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -328,6 +304,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce"
 
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
 [[package]]
 name = "base58"
 version = "0.1.0"
@@ -364,9 +346,9 @@ checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
 
 [[package]]
 name = "base64ct"
-version = "1.5.3"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b645a089122eccb6111b4f81cbc1a49f5900ac4666bb93ac027feaecf15607bf"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
 name = "basic-toml"
@@ -413,12 +395,12 @@ dependencies = [
  "lazy_static",
  "lazycell",
  "peeking_take_while",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "regex",
  "rustc-hash",
  "shlex",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -460,6 +442,7 @@ checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
 dependencies = [
  "funty",
  "radium 0.7.0",
+ "serde",
  "tap",
  "wyz",
 ]
@@ -550,9 +533,9 @@ checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
 
 [[package]]
 name = "bstr"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b45ea9b00a7b3f2988e9a65ad3917e62123c38dba709b666506207be96d1790b"
+checksum = "5ffdb39cb703212f3c11973452c2861b972f757b021158f3516ba10f2fa8b2c1"
 dependencies = [
  "memchr",
  "serde",
@@ -578,9 +561,9 @@ checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
 
 [[package]]
 name = "bytemuck"
-version = "1.13.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c041d3eab048880cb0b86b256447da3f18859a163c3b8d8893f4e6368abe6393"
+checksum = "17febce684fd15d89027105661fec94afb475cb995fbc59d2865198446ba2eea"
 
 [[package]]
 name = "byteorder"
@@ -599,9 +582,9 @@ dependencies = [
 
 [[package]]
 name = "camino"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77df041dc383319cc661b428b6961a005db4d6808d5e12536931b1ca9556055"
+checksum = "6031a462f977dd38968b6f23378356512feeace69cef817e1a4475108093cec3"
 dependencies = [
  "serde",
 ]
@@ -617,13 +600,13 @@ dependencies = [
 
 [[package]]
 name = "cargo_metadata"
-version = "0.15.2"
+version = "0.15.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982a0cf6a99c350d7246035613882e376d58cebe571785abc5da4f648d53ac0a"
+checksum = "08a1ec454bc3eead8719cb56e15dbbfecdbc14e4b3a3ae4936cc6e31f5fc0d07"
 dependencies = [
  "camino",
  "cargo-platform",
- "semver 1.0.16",
+ "semver 1.0.17",
  "serde",
  "serde_json",
  "thiserror",
@@ -734,9 +717,9 @@ dependencies = [
 
 [[package]]
 name = "clang-sys"
-version = "1.4.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa2e27ae6ab525c3d369ded447057bca5438d86dc3a68f6faafb8269ba82ebf3"
+checksum = "77ed9a53e5d4d9c573ae844bfac6872b159cb1d1585a83b29e7a64b7eef7332a"
 dependencies = [
  "glob",
  "libc",
@@ -757,13 +740,13 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.1.4"
+version = "4.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f13b9c79b5d1dd500d20ef541215a6423c75829ef43117e1b4d17fd8af0b5d76"
+checksum = "c3d7ae14b20b94cb02149ed21a86c423859cbe18dc7ed69845cace50e52b40a5"
 dependencies = [
  "bitflags",
  "clap_derive",
- "clap_lex 0.3.1",
+ "clap_lex 0.3.2",
  "is-terminal",
  "once_cell",
  "strsim 0.10.0",
@@ -772,15 +755,15 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.1.0"
+version = "4.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "684a277d672e91966334af371f1a7b5833f9aa00b07c84e92fbce95e00208ce8"
+checksum = "44bec8e5c9d09e439c4335b1af0abaab56dcf3b94999a936e1bb47b9134288f0"
 dependencies = [
  "heck",
  "proc-macro-error",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -794,9 +777,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "783fe232adfca04f90f56201b26d79682d4cd2625e0bc7290b95123afe558ade"
+checksum = "350b9cf31731f9957399229e9b2adc51eeabdfbe9d71d9a0552275fd12710d09"
 dependencies = [
  "os_str_bytes",
 ]
@@ -813,10 +796,10 @@ version = "0.1.0"
 dependencies = [
  "convert_case 0.6.0",
  "parity-scale-codec",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "serde",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -831,9 +814,9 @@ dependencies = [
 
 [[package]]
 name = "coins-bip32"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634c509653de24b439672164bbf56f5f582a2ab0e313d3b0f6af0b7345cf2560"
+checksum = "8a3b95d26eace980ade01e0ea8d996f7d5ae7031f9c5f258317ec82e400f33c1"
 dependencies = [
  "bincode",
  "bs58",
@@ -841,7 +824,7 @@ dependencies = [
  "digest 0.10.6",
  "getrandom 0.2.8",
  "hmac",
- "k256",
+ "k256 0.11.6",
  "lazy_static",
  "serde",
  "sha2 0.10.6",
@@ -850,26 +833,28 @@ dependencies = [
 
 [[package]]
 name = "coins-bip39"
-version = "0.7.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a11892bcac83b4c6e95ab84b5b06c76d9d70ad73548dd07418269c5c7977171"
+checksum = "a05ceda6ab4876de899fe23e8a171b200be9a346289bce12d41311e4bce2f104"
 dependencies = [
  "bitvec 0.17.4",
  "coins-bip32",
  "getrandom 0.2.8",
  "hex",
  "hmac",
+ "once_cell",
  "pbkdf2",
  "rand 0.8.5",
  "sha2 0.10.6",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
 name = "coins-core"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c94090a6663f224feae66ab01e41a2555a8296ee07b5f20dab8888bdefc9f617"
+checksum = "87637d08a1dd6bfa3bcd697f0a4de6c1b3a03e085b9d841a7e9cde4ccb61514b"
 dependencies = [
  "base58check",
  "base64 0.12.3",
@@ -912,9 +897,9 @@ dependencies = [
 
 [[package]]
 name = "const-oid"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cec318a675afcb6a1ea1d4340e2d377e56e47c266f28043ceccbf4412ddfdd3b"
+checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913"
 
 [[package]]
 name = "convert_case"
@@ -1002,7 +987,7 @@ dependencies = [
  "clap 3.2.23",
  "criterion-plot",
  "futures",
- "itertools 0.10.5",
+ "itertools",
  "lazy_static",
  "num-traits",
  "oorandom",
@@ -1023,7 +1008,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
 dependencies = [
  "cast",
- "itertools 0.10.5",
+ "itertools",
 ]
 
 [[package]]
@@ -1034,9 +1019,9 @@ checksum = "6548a0ad5d2549e111e1f6a11a6c2e2d00ce6a3dafe22948d67c2b443f775e52"
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.6"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
+checksum = "cf2b3e8478797446514c91ef04bafcb59faba183e621ad488df88983cc14128c"
 dependencies = [
  "cfg-if",
  "crossbeam-utils",
@@ -1044,9 +1029,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
+checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
 dependencies = [
  "cfg-if",
  "crossbeam-epoch",
@@ -1055,9 +1040,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.13"
+version = "0.9.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01a9af1f4c2ef74bb8aa1f7e19706bc72d03598c8a570bb5de72243c7a9d9d5a"
+checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
 dependencies = [
  "autocfg",
  "cfg-if",
@@ -1068,9 +1053,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.14"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb766fa798726286dbbb842f174001dab8abc7b627a1dd86e0b7222a95d929f"
+checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
 dependencies = [
  "cfg-if",
 ]
@@ -1118,6 +1103,18 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "crypto-bigint"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071c0f5945634bc9ba7a452f492377dd6b1993665ddb58f28704119b32f07a9a"
+dependencies = [
+ "generic-array 0.14.6",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
 [[package]]
 name = "crypto-common"
 version = "0.1.6"
@@ -1161,9 +1158,9 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.88"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "322296e2f2e5af4270b54df9e85a02ff037e271af20ba3e7fe1575515dc840b8"
+checksum = "86d3488e7665a7a483b57e25bdd90d0aeb2bc7608c8d0346acf2ad3f1caf1d62"
 dependencies = [
  "cc",
  "cxxbridge-flags",
@@ -1173,34 +1170,34 @@ dependencies = [
 
 [[package]]
 name = "cxx-build"
-version = "1.0.88"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "017a1385b05d631e7875b1f151c9f012d37b53491e2a87f65bff5c262b2111d8"
+checksum = "48fcaf066a053a41a81dfb14d57d99738b767febb8b735c3016e469fac5da690"
 dependencies = [
  "cc",
  "codespan-reporting",
  "once_cell",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "scratch",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.88"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c26bbb078acf09bc1ecda02d4223f03bdd28bd4874edcb0379138efc499ce971"
+checksum = "a2ef98b8b717a829ca5603af80e1f9e2e48013ab227b68ef37872ef84ee479bf"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.88"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357f40d1f06a24b60ae1fe122542c1fb05d28d32acb2aed064e84bc2ad1e252e"
+checksum = "086c685979a698443656e5cf7856c95c642295a38599f12fb1ff76fb28d19892"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1215,12 +1212,12 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.14.2"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0dd3cd20dc6b5a876612a6e5accfe7f3dd883db6d07acfbf14c128f61550dfa"
+checksum = "c0808e1bd8671fb44a113a14e13497557533369847788fa2ae912b6ebfce9fa8"
 dependencies = [
- "darling_core 0.14.2",
- "darling_macro 0.14.2",
+ "darling_core 0.14.3",
+ "darling_macro 0.14.3",
 ]
 
 [[package]]
@@ -1231,24 +1228,24 @@ checksum = "f0c960ae2da4de88a91b2d920c2a7233b400bc33cb28453a2987822d8392519b"
 dependencies = [
  "fnv",
  "ident_case",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "strsim 0.9.3",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
 name = "darling_core"
-version = "0.14.2"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a784d2ccaf7c98501746bf0be29b2022ba41fd62a2e622af997a03e9f972859f"
+checksum = "001d80444f28e193f30c2f293455da62dcf9a6b29918a4253152ae2b1de592cb"
 dependencies = [
  "fnv",
  "ident_case",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "strsim 0.10.0",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1259,18 +1256,18 @@ checksum = "d9b5a2f4ac4969822c62224815d069952656cadc7084fdca9751e6d959189b72"
 dependencies = [
  "darling_core 0.10.2",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.14.2"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7618812407e9402654622dd402b0a89dff9ba93badd6540781526117b92aab7e"
+checksum = "b36230598a2d5de7ec1c6f51f72d8a99a9208daff41de2084d06e3fd3ea56685"
 dependencies = [
- "darling_core 0.14.2",
+ "darling_core 0.14.3",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1283,7 +1280,7 @@ dependencies = [
  "hashbrown 0.12.3",
  "lock_api",
  "once_cell",
- "parking_lot_core 0.9.6",
+ "parking_lot_core 0.9.7",
 ]
 
 [[package]]
@@ -1321,15 +1318,25 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "der"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc906908ea6458456e5eaa160a9c08543ec3d1e6f71e2235cedd660cb65f9df0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
 [[package]]
 name = "derive_arbitrary"
 version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8beee4701e2e229e8098bbdecdca12449bc3e322f137d269182fa1291e20bd00"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1340,9 +1347,9 @@ checksum = "a2658621297f2cf68762a6f7dc0bb7e1ff2cfd6583daef8ee0fed6f7ec468ec0"
 dependencies = [
  "darling 0.10.2",
  "derive_builder_core",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1352,9 +1359,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2791ea3e372c8495c0bc2033991d76b512cd799d07491fbd6890124db9458bef"
 dependencies = [
  "darling 0.10.2",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1364,12 +1371,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
 dependencies = [
  "convert_case 0.4.0",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "rustc_version",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
 [[package]]
 name = "digest"
 version = "0.8.1"
@@ -1451,14 +1464,14 @@ dependencies = [
 
 [[package]]
 name = "discv5"
-version = "0.1.0"
-source = "git+https://github.com/sigp/discv5#97a806ccf7817a420b5f43efa23e6127b475d839"
+version = "0.2.1"
+source = "git+https://github.com/sigp/discv5#e3a6fe7c6efcdfb52b0782c232ef7a3659d46e80"
 dependencies = [
  "aes 0.7.5",
  "aes-gcm",
  "arrayvec",
  "delay_map",
- "enr 0.6.2",
+ "enr 0.7.0",
  "fnv",
  "futures",
  "hashlink",
@@ -1493,11 +1506,23 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "downcast"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1"
+
+[[package]]
+name = "dunce"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bd4b30a6560bbd9b4620f4de34c3f14f60848e58a9b7216801afcb4c7b31c3c"
+
 [[package]]
 name = "dyn-clone"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9b0705efd4599c15a38151f4721f7bc388306f61084d3bfd50bd07fbca5cb60"
+checksum = "68b0cf012f1230e43cd00ebb729c6bb58707ecfa8ad08b52ef3a4ccd2697fc30"
 
 [[package]]
 name = "ecdsa"
@@ -1505,10 +1530,22 @@ version = "0.14.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "413301934810f597c1d19ca71c8710e99a3f1ba28a0d2ebc01551a2daeea3c5c"
 dependencies = [
- "der",
- "elliptic-curve",
- "rfc6979",
- "signature",
+ "der 0.6.1",
+ "elliptic-curve 0.12.3",
+ "rfc6979 0.3.1",
+ "signature 1.6.4",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1b0a1222f8072619e8a6b667a854020a03d363738303203c09468b3424a420a"
+dependencies = [
+ "der 0.7.1",
+ "elliptic-curve 0.13.2",
+ "rfc6979 0.4.0",
+ "signature 2.0.0",
 ]
 
 [[package]]
@@ -1517,7 +1554,7 @@ version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91cff35c70bba8a626e3185d8cd48cc11b5437e1a5bcd15b9b5fa3c64b6dfee7"
 dependencies = [
- "signature",
+ "signature 1.6.4",
 ]
 
 [[package]]
@@ -1541,9 +1578,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cb0188e3c3ba8df5753894d54461f0e39bc91741dc5b22e1c46999ec2c71f4e4"
 dependencies = [
  "enum-ordinalize",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1558,25 +1595,44 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7bb888ab5300a19b8e5bceef25ac745ad065f3c9f7efc6de1b91958110891d3"
 dependencies = [
- "base16ct",
- "crypto-bigint",
- "der",
+ "base16ct 0.1.1",
+ "crypto-bigint 0.4.9",
+ "der 0.6.1",
+ "digest 0.10.6",
+ "ff 0.12.1",
+ "generic-array 0.14.6",
+ "group 0.12.1",
+ "pkcs8 0.9.0",
+ "rand_core 0.6.4",
+ "sec1 0.3.0",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea5a92946e8614bb585254898bb7dd1ddad241ace60c52149e3765e34cc039d"
+dependencies = [
+ "base16ct 0.2.0",
+ "crypto-bigint 0.5.0",
  "digest 0.10.6",
- "ff",
+ "ff 0.13.0",
  "generic-array 0.14.6",
- "group",
- "pkcs8",
+ "group 0.13.0",
+ "pkcs8 0.10.1",
  "rand_core 0.6.4",
- "sec1",
+ "sec1 0.7.1",
  "subtle",
  "zeroize",
 ]
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.31"
+version = "0.8.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9852635589dc9f9ea1b6fe9f05b50ef208c85c834a562f0c6abb1c475736ec2b"
+checksum = "071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"
 dependencies = [
  "cfg-if",
 ]
@@ -1589,16 +1645,16 @@ checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
 
 [[package]]
 name = "enr"
-version = "0.6.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26fa0a0be8915790626d5759eb51fe47435a8eac92c2f212bd2da9aa7f30ea56"
+checksum = "492a7e5fc2504d5fdce8e124d3e263b244a68b283cac67a69eda0cd43e0aebad"
 dependencies = [
  "base64 0.13.1",
  "bs58",
  "bytes",
  "ed25519-dalek",
  "hex",
- "k256",
+ "k256 0.11.6",
  "log",
  "rand 0.8.5",
  "rlp",
@@ -1609,19 +1665,18 @@ dependencies = [
 
 [[package]]
 name = "enr"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "492a7e5fc2504d5fdce8e124d3e263b244a68b283cac67a69eda0cd43e0aebad"
+checksum = "eb4d5fbf6f56acecd38f5988eb2e4ae412008a2a30268c748c701ec6322f39d4"
 dependencies = [
  "base64 0.13.1",
- "bs58",
  "bytes",
  "hex",
- "k256",
+ "k256 0.13.0",
  "log",
  "rand 0.8.5",
  "rlp",
- "secp256k1 0.24.3",
+ "secp256k1",
  "serde",
  "sha3",
  "zeroize",
@@ -1634,9 +1689,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "570d109b813e904becc80d8d5da38376818a143348413f7149f1340fe04754d4"
 dependencies = [
  "heck",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1646,9 +1701,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116"
 dependencies = [
  "heck",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1659,10 +1714,10 @@ checksum = "a62bb1df8b45ecb7ffa78dca1c17a438fb193eb083db0b1b494d2a61bcb5096a"
 dependencies = [
  "num-bigint",
  "num-traits",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "rustc_version",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1671,9 +1726,9 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e88bcb3a067a6555d577aba299e75eff9942da276e6506fc6274327daa026132"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1769,9 +1824,11 @@ dependencies = [
 
 [[package]]
 name = "ethers-contract"
-version = "1.0.2"
-source = "git+https://github.com/gakonst/ethers-rs#228f9447269e61ca7d7f868edd58c08772e38650"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
 dependencies = [
+ "ethers-contract-abigen",
+ "ethers-contract-derive",
  "ethers-core",
  "ethers-providers",
  "futures-util",
@@ -1783,31 +1840,73 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "ethers-contract-abigen"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
+dependencies = [
+ "Inflector",
+ "cfg-if",
+ "dunce",
+ "ethers-core",
+ "ethers-etherscan",
+ "eyre",
+ "getrandom 0.2.8",
+ "hex",
+ "prettyplease",
+ "proc-macro2 1.0.52",
+ "quote 1.0.23",
+ "regex",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "syn 1.0.109",
+ "tokio",
+ "toml",
+ "url",
+ "walkdir",
+]
+
+[[package]]
+name = "ethers-contract-derive"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
+dependencies = [
+ "ethers-contract-abigen",
+ "ethers-core",
+ "hex",
+ "proc-macro2 1.0.52",
+ "quote 1.0.23",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "ethers-core"
-version = "1.0.2"
-source = "git+https://github.com/gakonst/ethers-rs#228f9447269e61ca7d7f868edd58c08772e38650"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
 dependencies = [
  "arrayvec",
  "bytes",
+ "cargo_metadata",
  "chrono",
  "convert_case 0.6.0",
- "elliptic-curve",
+ "elliptic-curve 0.13.2",
  "ethabi",
  "generic-array 0.14.6",
  "getrandom 0.2.8",
  "hex",
- "k256",
+ "k256 0.13.0",
  "num_enum",
+ "once_cell",
  "open-fastrlp",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "rand 0.8.5",
  "rlp",
  "rlp-derive",
  "serde",
  "serde_json",
  "strum",
- "syn 1.0.107",
+ "syn 1.0.109",
  "tempfile",
  "thiserror",
  "tiny-keccak",
@@ -1816,13 +1915,13 @@ dependencies = [
 
 [[package]]
 name = "ethers-etherscan"
-version = "1.0.2"
-source = "git+https://github.com/gakonst/ethers-rs#228f9447269e61ca7d7f868edd58c08772e38650"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
 dependencies = [
  "ethers-core",
  "getrandom 0.2.8",
  "reqwest",
- "semver 1.0.16",
+ "semver 1.0.17",
  "serde",
  "serde-aux",
  "serde_json",
@@ -1832,11 +1931,11 @@ dependencies = [
 
 [[package]]
 name = "ethers-middleware"
-version = "1.0.2"
-source = "git+https://github.com/gakonst/ethers-rs#228f9447269e61ca7d7f868edd58c08772e38650"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
 dependencies = [
  "async-trait",
- "auto_impl 0.5.0",
+ "auto_impl",
  "ethers-contract",
  "ethers-core",
  "ethers-etherscan",
@@ -1857,13 +1956,13 @@ dependencies = [
 
 [[package]]
 name = "ethers-providers"
-version = "1.0.2"
-source = "git+https://github.com/gakonst/ethers-rs#228f9447269e61ca7d7f868edd58c08772e38650"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
 dependencies = [
  "async-trait",
- "auto_impl 1.0.1",
+ "auto_impl",
  "base64 0.21.0",
- "enr 0.7.0",
+ "enr 0.8.0",
  "ethers-core",
  "futures-channel",
  "futures-core",
@@ -1894,19 +1993,20 @@ dependencies = [
 
 [[package]]
 name = "ethers-signers"
-version = "1.0.2"
-source = "git+https://github.com/gakonst/ethers-rs#228f9447269e61ca7d7f868edd58c08772e38650"
+version = "2.0.0"
+source = "git+https://github.com/gakonst/ethers-rs#18a049b4c49965fbb4efbb394891767dc0fa1fa9"
 dependencies = [
  "async-trait",
  "coins-bip32",
  "coins-bip39",
- "elliptic-curve",
+ "elliptic-curve 0.13.2",
  "eth-keystore",
  "ethers-core",
  "hex",
  "rand 0.8.5",
  "sha2 0.10.6",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
@@ -1939,9 +2039,9 @@ checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
 
 [[package]]
 name = "fastrand"
-version = "1.8.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
+checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
 dependencies = [
  "instant",
 ]
@@ -1965,6 +2065,16 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
 [[package]]
 name = "findshlibs"
 version = "0.10.2"
@@ -1999,6 +2109,15 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "float-cmp"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -2014,6 +2133,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fragile"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa"
+
 [[package]]
 name = "funty"
 version = "2.0.0"
@@ -2068,21 +2193,6 @@ version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfb8371b6fb2aeb2d280374607aeabfc99d95c72edfe51692e42d3d7f0d08531"
 
-[[package]]
-name = "futures-lite"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
-dependencies = [
- "fastrand",
- "futures-core",
- "futures-io",
- "memchr",
- "parking",
- "pin-project-lite",
- "waker-fn",
-]
-
 [[package]]
 name = "futures-locks"
 version = "0.7.1"
@@ -2099,9 +2209,9 @@ version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95a73af87da33b5acf53acfebdc339fe592ecf5357ac7c0a7734ab9d8c876a70"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -2170,6 +2280,7 @@ checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
 dependencies = [
  "typenum",
  "version_check",
+ "zeroize",
 ]
 
 [[package]]
@@ -2282,16 +2393,27 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7"
 dependencies = [
- "ff",
+ "ff 0.12.1",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff 0.13.0",
  "rand_core 0.6.4",
  "subtle",
 ]
 
 [[package]]
 name = "h2"
-version = "0.3.15"
+version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f9f29bc9dda355256b2916cf526ab02ce0aeaaaf2bad60d65ef3f12f11dd0f4"
+checksum = "5be7b54589b581f624f566bf5d8eb2bab1db736c51528720b6bd36b96b55924d"
 dependencies = [
  "bytes",
  "fnv",
@@ -2302,7 +2424,7 @@ dependencies = [
  "indexmap",
  "slab",
  "tokio",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tracing",
 ]
 
@@ -2402,15 +2524,15 @@ dependencies = [
  "hash32",
  "rustc_version",
  "serde",
- "spin 0.9.4",
+ "spin 0.9.5",
  "stable_deref_trait",
 ]
 
 [[package]]
 name = "heck"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
 [[package]]
 name = "hermit-abi"
@@ -2491,9 +2613,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399"
+checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
 dependencies = [
  "bytes",
  "fnv",
@@ -2718,9 +2840,9 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -2782,12 +2904,12 @@ dependencies = [
 
 [[package]]
 name = "io-lifetimes"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7d6c6f8c91b4b9ed43484ad1a938e393caf35960fce7f82a040497207bd8e9e"
+checksum = "1abeb7a0dd0f8181267ff8adc397075586500b81b28a73e8a0208b00fc170fb3"
 dependencies = [
  "libc",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -2819,9 +2941,9 @@ dependencies = [
 
 [[package]]
 name = "is-terminal"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0a45d56fe973d6db23972bf5bc46f988a4a2385deac9cc29572f09daef"
+checksum = "21b6b32576413a8e69b90e952e4a026476040d81017b80445deda5f2d3921857"
 dependencies = [
  "hermit-abi 0.3.1",
  "io-lifetimes",
@@ -2829,15 +2951,6 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itertools"
 version = "0.10.5"
@@ -2849,15 +2962,15 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
 
 [[package]]
 name = "js-sys"
-version = "0.3.60"
+version = "0.3.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
+checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -2899,7 +3012,7 @@ dependencies = [
  "thiserror",
  "tokio",
  "tokio-rustls",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tracing",
  "webpki-roots",
 ]
@@ -2960,9 +3073,9 @@ checksum = "baa6da1e4199c10d7b1d0a6e5e8bd8e55f351163b6f4b3cbb044672a69bd4c1c"
 dependencies = [
  "heck",
  "proc-macro-crate",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -2982,7 +3095,7 @@ dependencies = [
  "soketto",
  "tokio",
  "tokio-stream",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tower",
  "tracing",
 ]
@@ -3045,12 +3158,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72c1e0b51e7ec0a97369623508396067a486bd0cbed95a2659a4b863d28cfc8b"
 dependencies = [
  "cfg-if",
- "ecdsa",
- "elliptic-curve",
+ "ecdsa 0.14.8",
+ "elliptic-curve 0.12.3",
  "sha2 0.10.6",
  "sha3",
 ]
 
+[[package]]
+name = "k256"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "955890845095ccf31ef83ad41a05aabb4d8cc23dc3cac5a9f5c89cf26dd0da75"
+dependencies = [
+ "cfg-if",
+ "ecdsa 0.16.1",
+ "elliptic-curve 0.13.2",
+ "once_cell",
+ "sha2 0.10.6",
+ "signature 2.0.0",
+]
+
 [[package]]
 name = "keccak"
 version = "0.1.3"
@@ -3220,18 +3347,18 @@ checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
 name = "memmap2"
-version = "0.5.8"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b182332558b18d807c4ce1ca8ca983b34c3ee32765e47b3f0f69b90355cc1dc"
+checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "memoffset"
-version = "0.7.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
+checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
 dependencies = [
  "autocfg",
 ]
@@ -3272,9 +3399,9 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "731f8ecebd9f3a4aa847dfe75455e4757a45da40a7793d2f0b1f9b6ed18b23f3"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3331,14 +3458,41 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
 dependencies = [
  "libc",
  "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "mockall"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e4a1c770583dac7ab5e2f6c139153b783a53a1bbee9729613f193e59828326"
+dependencies = [
+ "cfg-if",
+ "downcast",
+ "fragile",
+ "lazy_static",
+ "mockall_derive",
+ "predicates",
+ "predicates-tree",
+]
+
+[[package]]
+name = "mockall_derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "832663583d5fa284ca8810bf7015e46c9fff9622d3cf34bd1eea5003fec06dd0"
+dependencies = [
+ "cfg-if",
+ "proc-macro2 1.0.52",
+ "quote 1.0.23",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3357,9 +3511,9 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a7d5f7076603ebc68de2dc6a650ec331a062a13abaa346975be747bbfa4b789"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3379,13 +3533,14 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.24.3"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
+checksum = "bfdda3d196821d6af13126e40375cdf7da646a96114af134d5f417a9a1dc8e1a"
 dependencies = [
  "bitflags",
  "cfg-if",
  "libc",
+ "static_assertions",
 ]
 
 [[package]]
@@ -3399,13 +3554,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "nom8"
-version = "0.2.0"
+name = "normalize-line-endings"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
-dependencies = [
- "memchr",
-]
+checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
 
 [[package]]
 name = "nu-ansi-term"
@@ -3516,23 +3668,23 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.5.9"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d829733185c1ca374f17e52b762f24f535ec625d2cc1f070e34c8a9068f341b"
+checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
 dependencies = [
  "num_enum_derive",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.5.9"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2be1598bf1c313dcdd12092e3f1920f463462525a21b7b4e11b4168353d0123e"
+checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
 dependencies = [
  "proc-macro-crate",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3575,7 +3727,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "786393f80485445794f6043fd3138854dd109cc6c4bd1a6383db304c9ce9b9ce"
 dependencies = [
  "arrayvec",
- "auto_impl 1.0.1",
+ "auto_impl",
  "bytes",
  "ethereum-types",
  "open-fastrlp-derive",
@@ -3588,9 +3740,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "003b2be5c6c53c1cfeb0a238b8a1c3915cd410feb684457a36c10038f764bb1c"
 dependencies = [
  "bytes",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3632,9 +3784,9 @@ dependencies = [
 
 [[package]]
 name = "parity-scale-codec"
-version = "3.3.0"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3840933452adf7b3b9145e27086a5a3376c619dca1a21b1e5a5af0d54979bed"
+checksum = "637935964ff85a605d114591d4d2c13c5d1ba2806dae97cea6bf180238a749ac"
 dependencies = [
  "arrayvec",
  "bitvec 1.0.1",
@@ -3652,9 +3804,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86b26a931f824dd4eca30b3e43bb4f31cd5f0d3a403c5f5ff27106b805bfde7b"
 dependencies = [
  "proc-macro-crate",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3671,12 +3823,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "parking"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
-
 [[package]]
 name = "parking_lot"
 version = "0.11.2"
@@ -3695,7 +3841,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
 dependencies = [
  "lock_api",
- "parking_lot_core 0.9.6",
+ "parking_lot_core 0.9.7",
 ]
 
 [[package]]
@@ -3714,15 +3860,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.6"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba1ef8814b5c993410bb3adfad7a5ed269563e4a2f90c41f5d85be7fb47133bf"
+checksum = "9069cbb9f99e3a5083476ccb29ceb1de18b9118cafa53e90c9551235de2b9521"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -3777,9 +3923,9 @@ checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
 
 [[package]]
 name = "pest"
-version = "2.5.4"
+version = "2.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ab62d2fa33726dbe6321cc97ef96d8cde531e3eeaf858a058de53a8a6d40d8f"
+checksum = "8cbd939b234e95d72bc393d51788aec68aeeb5d51e748ca08ff3aad58cb722f7"
 dependencies = [
  "thiserror",
  "ucd-trie",
@@ -3810,9 +3956,9 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3833,8 +3979,18 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9eca2c590a5f85da82668fa685c09ce2888b9430e83299debf1f34b65fd4a4ba"
 dependencies = [
- "der",
- "spki",
+ "der 0.6.1",
+ "spki 0.6.0",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d2820d87d2b008616e5c27212dd9e0e694fb4c6b522de06094106813328cb49"
+dependencies = [
+ "der 0.7.1",
+ "spki 0.7.0",
 ]
 
 [[package]]
@@ -3894,9 +4050,9 @@ checksum = "26f6a7b87c2e435a3241addceeeff740ff8b7e76b74c13bf9acb17fa454ea00b"
 
 [[package]]
 name = "postcard"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c2b180dc0bade59f03fd005cb967d3f1e5f69b13922dad0cd6e047cb8af2363"
+checksum = "cfa512cd0d087cc9f99ad30a1bf64795b67871edbead083ffc3a4dfafa59aa00"
 dependencies = [
  "cobs",
  "heapless",
@@ -3905,9 +4061,9 @@ dependencies = [
 
 [[package]]
 name = "pprof"
-version = "0.11.0"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e20150f965e0e4c925982b9356da71c84bcd56cb66ef4e894825837cbcf6613e"
+checksum = "196ded5d4be535690899a4631cc9f18cdc41b7ebf24a79400f46f48e49a11059"
 dependencies = [
  "backtrace",
  "cfg-if",
@@ -3931,6 +4087,46 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
+[[package]]
+name = "predicates"
+version = "2.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
+dependencies = [
+ "difflib",
+ "float-cmp",
+ "itertools",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f883590242d3c6fc5bf50299011695fa6590c2c70eac95ee1bdb9a733ad1a2"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54ff541861505aabf6ea722d2131ee980b8276e10a1297b94e896dd8b621850d"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e97e3215779627f01ee256d2fad52f3d95e8e1c11e9fc6fd08f7cd455d5d5c78"
+dependencies = [
+ "proc-macro2 1.0.52",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "primitive-types"
 version = "0.12.1"
@@ -3947,9 +4143,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "1.3.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66618389e4ec1c7afe67d51a9bf34ff9236480f8d51e7489b7d5ab0303c13f34"
+checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
 dependencies = [
  "once_cell",
  "toml_edit",
@@ -3962,9 +4158,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
 dependencies = [
  "proc-macro-error-attr",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
  "version_check",
 ]
 
@@ -3974,7 +4170,7 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "version_check",
 ]
@@ -3990,9 +4186,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.51"
+version = "1.0.52"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
+checksum = "1d0e1ae9e836cc3beddd63db0df682593d7e2d3d891ae8c9083d2113e1744224"
 dependencies = [
  "unicode-ident",
 ]
@@ -4102,7 +4298,7 @@ version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
 ]
 
 [[package]]
@@ -4209,18 +4405,18 @@ dependencies = [
 
 [[package]]
 name = "raw-cpuid"
-version = "10.6.0"
+version = "10.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6823ea29436221176fe662da99998ad3b4db2c7f31e7b6f5fe43adccd6320bb"
+checksum = "6c297679cb867470fa8c9f67dbba74a78d78e3e98d7cf2b08d6d71540f797332"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "rayon"
-version = "1.6.1"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db3a213adf02b3bcfd2d3846bb41cb22857d131789e01df434fb7e7bc0759b7"
+checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
 dependencies = [
  "either",
  "rayon-core",
@@ -4228,9 +4424,9 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.10.2"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "356a0625f1954f730c0201cdab48611198dc6ce21f4acff55089b5a78e6e835b"
+checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-deque",
@@ -4284,15 +4480,6 @@ version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
-
 [[package]]
 name = "reqwest"
 version = "0.11.14"
@@ -4347,7 +4534,7 @@ name = "reth"
 version = "0.1.0"
 dependencies = [
  "backon",
- "clap 4.1.4",
+ "clap 4.1.8",
  "comfy-table",
  "confy",
  "crossterm",
@@ -4357,15 +4544,13 @@ dependencies = [
  "futures",
  "human_bytes",
  "jsonrpsee",
- "metrics",
  "metrics-exporter-prometheus",
  "metrics-util",
  "proptest",
- "reth-consensus",
+ "reth-beacon-consensus",
  "reth-db",
  "reth-discv4",
  "reth-downloaders",
- "reth-eth-wire",
  "reth-executor",
  "reth-interfaces",
  "reth-net-nat",
@@ -4386,12 +4571,18 @@ dependencies = [
  "serde_json",
  "shellexpand",
  "tempfile",
- "thiserror",
  "tokio",
- "tokio-stream",
  "tracing",
  "tui",
- "walkdir",
+]
+
+[[package]]
+name = "reth-beacon-consensus"
+version = "0.1.0"
+dependencies = [
+ "reth-consensus-common",
+ "reth-interfaces",
+ "reth-primitives",
 ]
 
 [[package]]
@@ -4410,14 +4601,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "reth-consensus"
+name = "reth-consensus-common"
 version = "0.1.0"
 dependencies = [
  "assert_matches",
+ "mockall",
  "reth-interfaces",
  "reth-primitives",
  "reth-provider",
- "tokio",
 ]
 
 [[package]]
@@ -4446,7 +4637,7 @@ dependencies = [
  "reth-interfaces",
  "reth-libmdbx",
  "reth-primitives",
- "secp256k1 0.24.3",
+ "secp256k1",
  "serde",
  "serde_json",
  "tempfile",
@@ -4461,7 +4652,7 @@ name = "reth-discv4"
 version = "0.1.0"
 dependencies = [
  "discv5",
- "enr 0.7.0",
+ "enr 0.8.0",
  "generic-array 0.14.6",
  "hex",
  "rand 0.8.5",
@@ -4471,7 +4662,7 @@ dependencies = [
  "reth-rlp",
  "reth-rlp-derive",
  "reth-tracing",
- "secp256k1 0.24.3",
+ "secp256k1",
  "serde",
  "thiserror",
  "tokio",
@@ -4485,15 +4676,15 @@ version = "0.1.0"
 dependencies = [
  "async-trait",
  "data-encoding",
- "enr 0.7.0",
+ "enr 0.8.0",
  "linked_hash_set",
- "lru 0.9.0",
  "parking_lot 0.12.1",
  "reth-net-common",
  "reth-primitives",
  "reth-rlp",
  "reth-tracing",
- "secp256k1 0.24.3",
+ "schnellru",
+ "secp256k1",
  "serde",
  "serde_with",
  "thiserror",
@@ -4510,7 +4701,7 @@ dependencies = [
  "assert_matches",
  "futures",
  "futures-util",
- "itertools 0.10.5",
+ "itertools",
  "metrics",
  "pin-project",
  "rayon",
@@ -4526,7 +4717,7 @@ dependencies = [
  "thiserror",
  "tokio",
  "tokio-stream",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tracing",
 ]
 
@@ -4550,13 +4741,13 @@ dependencies = [
  "reth-net-common",
  "reth-primitives",
  "reth-rlp",
- "secp256k1 0.24.3",
+ "secp256k1",
  "sha2 0.10.6",
  "sha3",
  "thiserror",
  "tokio",
  "tokio-stream",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tracing",
  "typenum",
 ]
@@ -4570,6 +4761,7 @@ dependencies = [
  "bytes",
  "ethers-core",
  "futures",
+ "hex",
  "hex-literal",
  "metrics",
  "pin-project",
@@ -4581,7 +4773,7 @@ dependencies = [
  "reth-primitives",
  "reth-rlp",
  "reth-tracing",
- "secp256k1 0.24.3",
+ "secp256k1",
  "serde",
  "smol_str",
  "snap",
@@ -4589,7 +4781,7 @@ dependencies = [
  "thiserror",
  "tokio",
  "tokio-stream",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tracing",
 ]
 
@@ -4597,16 +4789,18 @@ dependencies = [
 name = "reth-executor"
 version = "0.1.0"
 dependencies = [
+ "aquamarine",
  "async-trait",
- "auto_impl 1.0.1",
+ "auto_impl",
  "hash-db",
- "hashbrown 0.13.2",
+ "parking_lot 0.12.1",
  "plain_hasher",
  "reth-db",
  "reth-interfaces",
  "reth-primitives",
  "reth-provider",
  "reth-revm",
+ "reth-revm-inspectors",
  "reth-rlp",
  "revm",
  "rlp",
@@ -4623,7 +4817,7 @@ version = "0.1.0"
 dependencies = [
  "arbitrary",
  "async-trait",
- "auto_impl 1.0.1",
+ "auto_impl",
  "futures",
  "hex-literal",
  "modular-bitfield",
@@ -4636,7 +4830,7 @@ dependencies = [
  "reth-primitives",
  "reth-rpc-types",
  "revm-primitives",
- "secp256k1 0.24.3",
+ "secp256k1",
  "thiserror",
  "tokio",
  "tokio-stream",
@@ -4655,7 +4849,7 @@ dependencies = [
  "serde_json",
  "thiserror",
  "tokio",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tower",
  "tracing",
  "tracing-test",
@@ -4705,11 +4899,11 @@ version = "0.1.0"
 dependencies = [
  "metrics",
  "once_cell",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "regex",
  "serial_test",
- "syn 1.0.107",
+ "syn 1.0.109",
  "trybuild",
 ]
 
@@ -4742,8 +4936,8 @@ version = "0.1.0"
 dependencies = [
  "aquamarine",
  "async-trait",
- "auto_impl 1.0.1",
- "enr 0.7.0",
+ "auto_impl",
+ "enr 0.8.0",
  "ethers-core",
  "ethers-middleware",
  "ethers-providers",
@@ -4775,7 +4969,7 @@ dependencies = [
  "reth-tasks",
  "reth-tracing",
  "reth-transaction-pool",
- "secp256k1 0.24.3",
+ "secp256k1",
  "serde",
  "serde_json",
  "serial_test",
@@ -4783,7 +4977,7 @@ dependencies = [
  "thiserror",
  "tokio",
  "tokio-stream",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tracing",
 ]
 
@@ -4817,7 +5011,6 @@ dependencies = [
  "impl-serde",
  "modular-bitfield",
  "once_cell",
- "parity-scale-codec",
  "plain_hasher",
  "pprof",
  "proptest",
@@ -4827,7 +5020,7 @@ dependencies = [
  "reth-rlp",
  "reth-rlp-derive",
  "revm-primitives",
- "secp256k1 0.24.3",
+ "secp256k1",
  "serde",
  "serde_json",
  "serde_with",
@@ -4844,14 +5037,24 @@ dependencies = [
 name = "reth-provider"
 version = "0.1.0"
 dependencies = [
- "auto_impl 1.0.1",
+ "assert_matches",
+ "auto_impl",
+ "cita_trie",
+ "hasher",
+ "itertools",
  "parking_lot 0.12.1",
+ "proptest",
+ "reth-codecs",
  "reth-db",
  "reth-interfaces",
  "reth-primitives",
  "reth-revm-primitives",
+ "reth-rlp",
+ "reth-tracing",
  "revm-primitives",
  "thiserror",
+ "tracing",
+ "triehash",
 ]
 
 [[package]]
@@ -4861,6 +5064,7 @@ dependencies = [
  "reth-interfaces",
  "reth-primitives",
  "reth-provider",
+ "reth-revm-inspectors",
  "reth-revm-primitives",
  "revm",
 ]
@@ -4871,7 +5075,9 @@ version = "0.1.0"
 dependencies = [
  "hashbrown 0.13.2",
  "reth-primitives",
+ "reth-rpc-types",
  "revm",
+ "serde",
 ]
 
 [[package]]
@@ -4887,20 +5093,16 @@ name = "reth-rlp"
 version = "0.1.2"
 dependencies = [
  "arrayvec",
- "auto_impl 1.0.1",
+ "auto_impl",
  "bytes",
  "criterion",
- "enr 0.7.0",
  "ethereum-types",
  "ethnum",
  "hex-literal",
  "pprof",
- "rand 0.8.5",
  "reth-rlp",
  "reth-rlp-derive",
  "revm-primitives",
- "rlp",
- "secp256k1 0.24.3",
  "smol_str",
 ]
 
@@ -4908,9 +5110,9 @@ dependencies = [
 name = "reth-rlp-derive"
 version = "0.1.1"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -4918,6 +5120,9 @@ name = "reth-rpc"
 version = "0.1.0"
 dependencies = [
  "async-trait",
+ "bytes",
+ "ethers-core",
+ "futures",
  "hex",
  "http",
  "http-body",
@@ -4938,7 +5143,8 @@ dependencies = [
  "reth-tasks",
  "reth-transaction-pool",
  "revm",
- "secp256k1 0.26.0",
+ "schnellru",
+ "secp256k1",
  "serde",
  "serde_json",
  "thiserror",
@@ -4972,6 +5178,7 @@ dependencies = [
  "reth-rpc-api",
  "reth-rpc-engine-api",
  "reth-rpc-types",
+ "reth-tasks",
  "reth-tracing",
  "reth-transaction-pool",
  "serde",
@@ -5007,6 +5214,7 @@ version = "0.1.0"
 dependencies = [
  "jsonrpsee-types",
  "lru 0.9.0",
+ "rand 0.8.5",
  "reth-interfaces",
  "reth-network-api",
  "reth-primitives",
@@ -5023,7 +5231,7 @@ version = "0.1.0"
 dependencies = [
  "async-trait",
  "confy",
- "enr 0.7.0",
+ "enr 0.8.0",
  "ethers-core",
  "ethers-middleware",
  "ethers-providers",
@@ -5035,25 +5243,19 @@ dependencies = [
  "reth-db",
  "reth-discv4",
  "reth-downloaders",
- "reth-interfaces",
  "reth-net-nat",
  "reth-network",
  "reth-network-api",
  "reth-primitives",
  "reth-provider",
- "reth-staged-sync",
- "reth-stages",
- "reth-tasks",
  "reth-tracing",
- "secp256k1 0.24.3",
+ "secp256k1",
  "serde",
  "serde_json",
  "shellexpand",
  "tempfile",
  "thiserror",
  "tokio",
- "tokio-stream",
- "tokio-test",
  "tracing",
  "walkdir",
 ]
@@ -5063,23 +5265,19 @@ name = "reth-stages"
 version = "0.1.0"
 dependencies = [
  "aquamarine",
- "arbitrary",
  "assert_matches",
  "async-trait",
- "cita_trie",
  "criterion",
- "eyre",
  "futures-util",
- "hasher",
- "itertools 0.10.5",
+ "itertools",
  "metrics",
  "num-traits",
  "paste",
  "pin-project",
  "pprof",
- "proptest",
  "rand 0.8.5",
  "rayon",
+ "reth-codecs",
  "reth-db",
  "reth-downloaders",
  "reth-eth-wire",
@@ -5088,16 +5286,11 @@ dependencies = [
  "reth-metrics-derive",
  "reth-primitives",
  "reth-provider",
- "reth-revm",
  "reth-rlp",
- "reth-staged-sync",
- "serde",
- "tempfile",
  "thiserror",
  "tokio",
  "tokio-stream",
  "tracing",
- "triehash",
 ]
 
 [[package]]
@@ -5128,7 +5321,7 @@ version = "0.1.0"
 dependencies = [
  "aquamarine",
  "async-trait",
- "auto_impl 1.0.1",
+ "auto_impl",
  "bitflags",
  "fnv",
  "futures-util",
@@ -5138,6 +5331,7 @@ dependencies = [
  "rand 0.8.5",
  "reth-metrics-derive",
  "reth-primitives",
+ "reth-provider",
  "reth-rlp",
  "ruint",
  "serde",
@@ -5149,9 +5343,9 @@ dependencies = [
 [[package]]
 name = "revm"
 version = "3.0.0"
-source = "git+https://github.com/bluealloy/revm#4d2f0741c5f9daec0ceb7cc7733d65ea4c496170"
+source = "git+https://github.com/bluealloy/revm#3d8ca6641d2e72448c23f4596f769c8fd1c784d1"
 dependencies = [
- "auto_impl 1.0.1",
+ "auto_impl",
  "revm-interpreter",
  "revm-precompile",
 ]
@@ -5159,7 +5353,7 @@ dependencies = [
 [[package]]
 name = "revm-interpreter"
 version = "1.0.0"
-source = "git+https://github.com/bluealloy/revm#4d2f0741c5f9daec0ceb7cc7733d65ea4c496170"
+source = "git+https://github.com/bluealloy/revm#3d8ca6641d2e72448c23f4596f769c8fd1c784d1"
 dependencies = [
  "derive_more",
  "enumn",
@@ -5170,14 +5364,14 @@ dependencies = [
 [[package]]
 name = "revm-precompile"
 version = "2.0.0"
-source = "git+https://github.com/bluealloy/revm#4d2f0741c5f9daec0ceb7cc7733d65ea4c496170"
+source = "git+https://github.com/bluealloy/revm#3d8ca6641d2e72448c23f4596f769c8fd1c784d1"
 dependencies = [
- "k256",
+ "k256 0.11.6",
  "num",
  "once_cell",
  "revm-primitives",
  "ripemd",
- "secp256k1 0.26.0",
+ "secp256k1",
  "sha2 0.10.6",
  "sha3",
  "substrate-bn",
@@ -5186,10 +5380,11 @@ dependencies = [
 [[package]]
 name = "revm-primitives"
 version = "1.0.0"
-source = "git+https://github.com/bluealloy/revm#4d2f0741c5f9daec0ceb7cc7733d65ea4c496170"
+source = "git+https://github.com/bluealloy/revm#3d8ca6641d2e72448c23f4596f769c8fd1c784d1"
 dependencies = [
  "arbitrary",
- "auto_impl 1.0.1",
+ "auto_impl",
+ "bitvec 1.0.1",
  "bytes",
  "derive_more",
  "enumn",
@@ -5212,16 +5407,26 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb"
 dependencies = [
- "crypto-bigint",
+ "crypto-bigint 0.4.9",
  "hmac",
  "zeroize",
 ]
 
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
 [[package]]
 name = "rgb"
-version = "0.8.35"
+version = "0.8.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7495acf66551cdb696b7711408144bcd3194fc78e32f3a09e809bfe7dd4a7ce3"
+checksum = "20ec2d3e3fc7a92ced357df9cebd5a10b6fb2aa1ee797bf7e9ce2f17dffc8f59"
 dependencies = [
  "bytemuck",
 ]
@@ -5266,9 +5471,9 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e33d7b2abe0c340d8797fe2907d3f20d3b5ea5908683618bfe80df7f621f672a"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -5316,21 +5521,21 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "semver 1.0.16",
+ "semver 1.0.17",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.36.7"
+version = "0.36.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4fdebc4b395b7fbb9ab11e462e20ed9051e7b16e42d24042c776eca0ac81b03"
+checksum = "fd5c6ff11fecd55b40746d1995a02f2eb375bf8c00d192d521ee09f42bef37bc"
 dependencies = [
  "bitflags",
  "errno",
  "io-lifetimes",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -5386,9 +5591,9 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
 
 [[package]]
 name = "salsa20"
@@ -5427,9 +5632,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "303959cf613a6f6efd19ed4b4ad5bf79966a13352716299ad532cfb115f4205c"
 dependencies = [
  "proc-macro-crate",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -5441,6 +5646,17 @@ dependencies = [
  "windows-sys 0.42.0",
 ]
 
+[[package]]
+name = "schnellru"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "772575a524feeb803e5b0fcbc6dd9f367e579488197c94c6e4023aad2305774d"
+dependencies = [
+ "ahash 0.8.3",
+ "cfg-if",
+ "hashbrown 0.13.2",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
@@ -5449,9 +5665,9 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "scratch"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddccb15bcce173023b3fedd9436f882a0739b8dfb45e4f6b6002bee5929f61b2"
+checksum = "5d5e082f6ea090deaf0e6dd04b68360fd5cddb152af6ce8927c9d25db299f98c"
 
 [[package]]
 name = "scrypt"
@@ -5481,23 +5697,26 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928"
 dependencies = [
- "base16ct",
- "der",
+ "base16ct 0.1.1",
+ "der 0.6.1",
  "generic-array 0.14.6",
- "pkcs8",
+ "pkcs8 0.9.0",
  "subtle",
  "zeroize",
 ]
 
 [[package]]
-name = "secp256k1"
-version = "0.24.3"
+name = "sec1"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b1629c9c557ef9b293568b338dddfc8208c98a18c59d722a9d53f859d9c9b62"
+checksum = "48518a2b5775ba8ca5b46596aae011caa431e6ce7e4a67ead66d92f08884220e"
 dependencies = [
- "rand 0.8.5",
- "secp256k1-sys 0.6.1",
- "serde",
+ "base16ct 0.2.0",
+ "der 0.7.1",
+ "generic-array 0.14.6",
+ "pkcs8 0.10.1",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
@@ -5507,16 +5726,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4124a35fe33ae14259c490fd70fa199a32b9ce9502f2ee6bc4f81ec06fa65894"
 dependencies = [
  "rand 0.8.5",
- "secp256k1-sys 0.8.0",
-]
-
-[[package]]
-name = "secp256k1-sys"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83080e2c2fc1006e625be82e5d1eb6a43b7fd9578b617fcc55814daf286bba4b"
-dependencies = [
- "cc",
+ "secp256k1-sys",
+ "serde",
 ]
 
 [[package]]
@@ -5562,9 +5773,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"
+checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
 dependencies = [
  "serde",
 ]
@@ -5615,16 +5826,16 @@ version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.91"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883"
+checksum = "cad406b69c91885b5107daf2c29572f6c8cdb3c66826821e286c533490c0bc76"
 dependencies = [
  "itoa",
  "ryu",
@@ -5665,10 +5876,10 @@ version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1966009f3c05f095697c537312f5415d1e3ed31ce0a56942bac4c771c5c335e"
 dependencies = [
- "darling 0.14.2",
- "proc-macro2 1.0.51",
+ "darling 0.14.3",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -5691,9 +5902,9 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b64f9e531ce97c88b4778aad0ceee079216071cffec6ac9b904277f8f92e7fe3"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -5803,9 +6014,9 @@ checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
 
 [[package]]
 name = "signal-hook"
-version = "0.3.14"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a253b5e89e2698464fc26b545c9edceb338e18a89effeeecfea192c3025be29d"
+checksum = "732768f1176d21d09e076c23a93123d40bba92d50c4058da34d45c8de8e682b9"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -5824,9 +6035,9 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
 dependencies = [
  "libc",
 ]
@@ -5841,6 +6052,16 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "signature"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fe458c98333f9c8152221191a77e2a44e8325d0193484af2e9421a53019e57d"
+dependencies = [
+ "digest 0.10.6",
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "simple_asn1"
 version = "0.6.2"
@@ -5861,9 +6082,9 @@ checksum = "ceb945e54128e09c43d8e4f1277851bd5044c6fc540bbaa2ad888f60b3da9ae7"
 
 [[package]]
 name = "slab"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef"
+checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
 dependencies = [
  "autocfg",
 ]
@@ -5876,9 +6097,9 @@ checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
 
 [[package]]
 name = "smol_str"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7475118a28b7e3a2e157ce0131ba8c5526ea96e90ee601d9f6bb2e286a35ab44"
+checksum = "fad6c857cbab2627dcf01ec85a623ca4e7dcb5691cbaa3d7fb7653671f0d09c9"
 dependencies = [
  "serde",
 ]
@@ -5891,9 +6112,9 @@ checksum = "5e9f0ab6ef7eb7353d9119c170a436d1bf248eea575ac42d19d12f4e34130831"
 
 [[package]]
 name = "socket2"
-version = "0.4.7"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e2d2db9033d13a1567121ddd7a095ee144db4e1ca1b1bda3419bc0da294ebd"
+checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
 dependencies = [
  "libc",
  "winapi",
@@ -5923,9 +6144,9 @@ checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
 
 [[package]]
 name = "spin"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f6002a767bff9e83f8eeecf883ecb8011875a21ae8da43bffb817a57e78cc09"
+checksum = "7dccf47db1b41fa1573ed27ccf5e08e3ca771cb994f776668c5ebda893b248fc"
 dependencies = [
  "lock_api",
 ]
@@ -5937,7 +6158,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67cf02bbac7a337dc36e4f5a693db6c21e7863f45070f7064577eb4367a3212b"
 dependencies = [
  "base64ct",
- "der",
+ "der 0.6.1",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0445c905640145c7ea8c1993555957f65e7c46d0535b91ba501bc9bfc85522f"
+dependencies = [
+ "base64ct",
+ "der 0.7.1",
 ]
 
 [[package]]
@@ -5986,10 +6217,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
 dependencies = [
  "heck",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "rustversion",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -6066,11 +6297,11 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "1.0.107"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "unicode-ident",
 ]
@@ -6081,9 +6312,9 @@ version = "0.12.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
  "unicode-xid 0.2.4",
 ]
 
@@ -6095,16 +6326,15 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
-version = "3.3.0"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+checksum = "af18f7ae1acd354b992402e9ec5864359d693cd8a79dcbef59f76891701c1e95"
 dependencies = [
  "cfg-if",
  "fastrand",
- "libc",
  "redox_syscall",
- "remove_dir_all",
- "winapi",
+ "rustix",
+ "windows-sys 0.42.0",
 ]
 
 [[package]]
@@ -6116,6 +6346,12 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "termtree"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95059e91184749cb66be6dc994f67f182b6d897cb3df74a5bf66b5e709295fd8"
+
 [[package]]
 name = "test-fuzz"
 version = "3.0.5"
@@ -6135,7 +6371,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9186daca5c58cb307d09731e0ba06b13fd6c036c90672b9bfc31cecf76cf689"
 dependencies = [
  "cargo_metadata",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "serde",
  "strum_macros",
@@ -6147,13 +6383,13 @@ version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57d187b450bfb5b7939f82f9747dc1ebb15a7a9c4a93cd304a41aece7149608b"
 dependencies = [
- "darling 0.14.2",
+ "darling 0.14.3",
  "if_chain",
  "lazy_static",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
  "subprocess",
- "syn 1.0.107",
+ "syn 1.0.109",
  "test-fuzz-internal",
  "toolchain_find",
  "unzip-n",
@@ -6181,38 +6417,39 @@ checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
 
 [[package]]
 name = "thiserror"
-version = "1.0.38"
+version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
+checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.38"
+version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
+checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
 name = "thread_local"
-version = "1.1.4"
+version = "1.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
 dependencies = [
+ "cfg-if",
  "once_cell",
 ]
 
 [[package]]
 name = "time"
-version = "0.3.17"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a561bf4617eebd33bca6434b988f39ed798e527f51a1e797d0ee4f61c0a38376"
+checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
 dependencies = [
  "itoa",
  "serde",
@@ -6228,9 +6465,9 @@ checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
 
 [[package]]
 name = "time-macros"
-version = "0.2.6"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d967f99f534ca7e495c575c62638eebc2898a8c84c119b89e250477bc4ba16b2"
+checksum = "fd80a657e71da814b8e5d60d3374fc6d35045062245d80224748ae522dd76f36"
 dependencies = [
  "time-core",
 ]
@@ -6265,15 +6502,15 @@ dependencies = [
 
 [[package]]
 name = "tinyvec_macros"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.25.0"
+version = "1.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e00990ebabbe4c14c08aca901caed183ecd5c09562a12c824bb53d3c3fd3af"
+checksum = "03201d01c3c27a29c8a5cee5b55a93ddae1ccf6f08f65365c2c918f8c1b76f64"
 dependencies = [
  "autocfg",
  "bytes",
@@ -6286,7 +6523,7 @@ dependencies = [
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -6295,9 +6532,9 @@ version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d266c00fde287f55d3f1c3e96c500c362a2b8c695076ec180f27918820bc6df8"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -6313,27 +6550,14 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.11"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d660770404473ccd7bc9f8b28494a811bc18542b915c0855c51e8f419d5223ce"
+checksum = "8fb52b74f05dbf495a8fba459fdc331812b96aa086d9eb78101fa0d4569c3313"
 dependencies = [
  "futures-core",
  "pin-project-lite",
  "tokio",
- "tokio-util 0.7.4",
-]
-
-[[package]]
-name = "tokio-test"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
-dependencies = [
- "async-stream",
- "bytes",
- "futures-core",
- "tokio",
- "tokio-stream",
+ "tokio-util 0.7.7",
 ]
 
 [[package]]
@@ -6365,9 +6589,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.4"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bb2e075f03b3d66d8d8785356224ba688d2906a371015e225beeb65ca92c740"
+checksum = "5427d89453009325de0d8f342c9490009f76e999cb7672d77e46267448f7e6b2"
 dependencies = [
  "bytes",
  "futures-core",
@@ -6389,19 +6613,19 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.5.1"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4553f467ac8e3d374bc9a177a26801e5d0f9b211aa1673fb137a403afd1c9cf5"
+checksum = "3ab8ed2edee10b50132aed5f331333428b011c99402b5a534154ed15746f9622"
 
 [[package]]
 name = "toml_edit"
-version = "0.18.1"
+version = "0.19.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c59d8dd7d0dcbc6428bf7aa2f0e823e26e43b3c9aca15bbc9475d23e5fa12b"
+checksum = "9a1eb0622d28f4b9c90adc4ea4b2b46b47663fde9ac5fafcb14a1369d5508825"
 dependencies = [
  "indexmap",
- "nom8",
  "toml_datetime",
+ "winnow",
 ]
 
 [[package]]
@@ -6432,7 +6656,7 @@ dependencies = [
  "rand 0.8.5",
  "slab",
  "tokio",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tower-layer",
  "tower-service",
  "tracing",
@@ -6460,7 +6684,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "tokio",
- "tokio-util 0.7.4",
+ "tokio-util 0.7.7",
  "tower",
  "tower-layer",
  "tower-service",
@@ -6510,9 +6734,9 @@ version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -6579,9 +6803,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-test"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e3d272c44878d2bbc9f4a20ad463724f03e19dbc667c6e84ac433ab7ffcc70b"
+checksum = "3a2c0ff408fe918a94c428a3f2ad04e4afd5c95bbc08fcf868eff750c15728a4"
 dependencies = [
  "lazy_static",
  "tracing-core",
@@ -6591,13 +6815,13 @@ dependencies = [
 
 [[package]]
 name = "tracing-test-macro"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744324b12d69a9fc1edea4b38b7b1311295b662d161ad5deac17bb1358224a08"
+checksum = "258bc1c4f8e2e73a977812ab339d503e6feeb92700f6d07a6de4d321522d5c08"
 dependencies = [
  "lazy_static",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -6708,9 +6932,9 @@ checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
 
 [[package]]
 name = "trybuild"
-version = "1.0.77"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44da5a6f2164c8e14d3bbc0657d69c5966af9f5f6930d4f600b1f5c4a673413"
+checksum = "223fc354447478d08231355617eb8c37affad0e83d33aeac30a8c275786b905a"
 dependencies = [
  "basic-toml",
  "glob",
@@ -6800,9 +7024,9 @@ checksum = "d54675592c1dbefd78cbd98db9bacd89886e1ca50692a0692baefffdeb92dd58"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.6"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
+checksum = "775c11906edafc97bc378816b94585fbd9a054eabaf86fdd0ced94af449efab7"
 
 [[package]]
 name = "unicode-normalization"
@@ -6815,9 +7039,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a"
+checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
 
 [[package]]
 name = "unicode-width"
@@ -6859,9 +7083,9 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2e7e85a0596447f0f2ac090e16bc4c516c6fe91771fb0c0ccf7fa3dae896b9c"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -6921,12 +7145,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "waker-fn"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
-
 [[package]]
 name = "walkdir"
 version = "2.3.2"
@@ -6968,9 +7186,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
+checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
@@ -6978,24 +7196,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
+checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.33"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23639446165ca5a5de86ae1d8896b737ae80319560fbaa4c2887b7da6e7ebd7d"
+checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -7005,9 +7223,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
+checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
 dependencies = [
  "quote 1.0.23",
  "wasm-bindgen-macro-support",
@@ -7015,22 +7233,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
+checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
+checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
 
 [[package]]
 name = "wasm-timer"
@@ -7049,9 +7267,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.60"
+version = "0.3.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
+checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -7200,6 +7418,15 @@ version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
 
+[[package]]
+name = "winnow"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c95fb4ff192527911dd18eb138ac30908e7165b8944e528b6af93aa4c842d345"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winreg"
 version = "0.10.1"
@@ -7267,8 +7494,8 @@ version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44bf07cb3e50ea2003396695d58bf46bc9887a1f362260446fad6bc4e79bd36c"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.52",
  "quote 1.0.23",
- "syn 1.0.107",
+ "syn 1.0.109",
  "synstructure",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index c94e7294bff..0da5e418d6e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,8 @@
 [workspace]
 members = [
     "bin/reth",
-    "crates/consensus",
+    "crates/consensus/beacon",
+    "crates/consensus/common",
     "crates/executor",
     "crates/interfaces",
     "crates/metrics/metrics-derive",
@@ -41,6 +42,11 @@ members = [
 exclude = ["crate-template"]
 default-members = ["bin/reth"]
 
+# Like release, but with full debug symbols. Useful for e.g. `perf`.
+[profile.debug-fast]
+inherits = "release"
+debug = true
+
 [patch.crates-io]
 revm = { git = "https://github.com/bluealloy/revm" }
 revm-primitives = { git = "https://github.com/bluealloy/revm" }
diff --git a/bin/reth/Cargo.toml b/bin/reth/Cargo.toml
index fea91f9e8b1..ff1aa0aed3a 100644
--- a/bin/reth/Cargo.toml
+++ b/bin/reth/Cargo.toml
@@ -9,23 +9,22 @@ readme = "README.md"
 [dependencies]
 # reth
 reth-primitives = { path = "../../crates/primitives", features = ["arbitrary"] }
-reth-db = {path = "../../crates/storage/db", features = ["mdbx", "test-utils"] }
+reth-db = { path = "../../crates/storage/db", features = ["mdbx", "test-utils"] }
 # TODO: Temporary use of the test-utils feature
 reth-provider = { path = "../../crates/storage/provider", features = ["test-utils"] }
 reth-staged-sync = { path = "../../crates/staged-sync" }
 reth-stages = { path = "../../crates/stages"}
 reth-interfaces = { path = "../../crates/interfaces", features = ["test-utils"] }
 reth-transaction-pool = { path = "../../crates/transaction-pool", features = ["test-utils"] }
-reth-consensus = { path = "../../crates/consensus" }
+reth-beacon-consensus = { path = "../../crates/consensus/beacon" }
 reth-executor = { path = "../../crates/executor" }
-reth-eth-wire = { path = "../../crates/net/eth-wire" }
 reth-rpc-engine-api = { path = "../../crates/rpc/rpc-engine-api" }
 reth-rpc-builder = { path = "../../crates/rpc/rpc-builder" }
 reth-rpc = { path = "../../crates/rpc/rpc" }
 reth-rlp = { path = "../../crates/rlp" }
-reth-network = {path = "../../crates/net/network", features = ["serde"] }
-reth-network-api = {path = "../../crates/net/network-api" }
-reth-downloaders = {path = "../../crates/net/downloaders", features = ["test-utils"] }
+reth-network = { path = "../../crates/net/network", features = ["serde"] }
+reth-network-api = { path = "../../crates/net/network-api" }
+reth-downloaders = { path = "../../crates/net/downloaders", features = ["test-utils"] }
 reth-tracing = { path = "../../crates/tracing" }
 reth-tasks = { path = "../../crates/tasks" }
 reth-net-nat = { path = "../../crates/net/nat" }
@@ -36,7 +35,6 @@ tracing = "0.1"
 
 # io
 fdlimit = "0.2.1"
-walkdir = "2.3"
 serde = "1.0"
 serde_json = "1.0"
 shellexpand = "3.0.0"
@@ -44,7 +42,6 @@ dirs-next = "2.0.0"
 confy = "0.5"
 
 # rpc/metrics
-metrics = "0.20.1"
 metrics-exporter-prometheus = { version = "0.11.0", features = ["http-listener"] }
 metrics-util = "0.14.0"
 
@@ -53,10 +50,8 @@ proptest = "1.0"
 
 # misc
 eyre = "0.6.8"
-clap = { version = "4.0", features = ["derive", "cargo"] }
-thiserror = "1.0"
+clap = { version = "4", features = ["derive", "cargo"] }
 tokio = { version = "1.21", features = ["sync", "macros", "rt-multi-thread"] }
-tokio-stream = "0.1"
 futures = "0.3.25"
 tempfile = { version = "3.3.0" }
 backon = "0.4"
@@ -64,4 +59,4 @@ comfy-table = "6.1.4"
 crossterm = "0.25.0"
 tui = "0.19.0"
 jsonrpsee = { version = "0.16", features = ["server"] }
-human_bytes = "0.4.1"
\ No newline at end of file
+human_bytes = "0.4.1"
diff --git a/bin/reth/src/args/network_args.rs b/bin/reth/src/args/network_args.rs
index 6bc3212df0d..929101f5c33 100644
--- a/bin/reth/src/args/network_args.rs
+++ b/bin/reth/src/args/network_args.rs
@@ -2,12 +2,11 @@
 
 use crate::dirs::{KnownPeersPath, PlatformPath};
 use clap::Args;
-use reth_discv4::bootnodes::mainnet_nodes;
 use reth_net_nat::NatResolver;
 use reth_network::NetworkConfigBuilder;
-use reth_primitives::{ChainSpec, NodeRecord};
+use reth_primitives::{mainnet_nodes, ChainSpec, NodeRecord};
 use reth_staged_sync::Config;
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 
 /// Parameters for configuring the network more granularity via CLI
 #[derive(Debug, Args)]
@@ -50,11 +49,16 @@ pub struct NetworkArgs {
 impl NetworkArgs {
     /// Build a [`NetworkConfigBuilder`] from a [`Config`] and a [`ChainSpec`], in addition to the
     /// values in this option struct.
-    pub fn network_config(&self, config: &Config, chain_spec: ChainSpec) -> NetworkConfigBuilder {
-        let peers_file = (!self.no_persist_peers).then_some(&self.peers_file);
+    pub fn network_config(
+        &self,
+        config: &Config,
+        chain_spec: Arc<ChainSpec>,
+    ) -> NetworkConfigBuilder {
+        let chain_bootnodes = chain_spec.chain.bootnodes().unwrap_or_else(mainnet_nodes);
+
         let network_config_builder = config
-            .network_config(self.nat, peers_file.map(|f| f.as_ref().to_path_buf()))
-            .boot_nodes(self.bootnodes.clone().unwrap_or_else(mainnet_nodes))
+            .network_config(self.nat, self.persistent_peers_file())
+            .boot_nodes(self.bootnodes.clone().unwrap_or(chain_bootnodes))
             .chain_spec(chain_spec);
 
         self.discovery.apply_to_builder(network_config_builder)
@@ -87,6 +91,10 @@ pub struct DiscoveryArgs {
     /// Disable Discv4 discovery.
     #[arg(long, conflicts_with = "disable_discovery")]
     disable_discv4_discovery: bool,
+
+    /// The UDP port to use for P2P discovery/networking.
+    #[arg(long = "discovery.port")]
+    pub port: Option<u16>,
 }
 
 impl DiscoveryArgs {
diff --git a/bin/reth/src/args/rpc_server_args.rs b/bin/reth/src/args/rpc_server_args.rs
index 0afb2a016ea..5c593b84e6f 100644
--- a/bin/reth/src/args/rpc_server_args.rs
+++ b/bin/reth/src/args/rpc_server_args.rs
@@ -11,6 +11,7 @@ use reth_rpc_builder::{
     RpcServerHandle, ServerBuilder, TransportRpcModuleConfig,
 };
 use reth_rpc_engine_api::EngineApiHandle;
+use reth_tasks::TaskSpawner;
 use reth_transaction_pool::TransactionPool;
 use std::{
     net::{IpAddr, Ipv4Addr, SocketAddr},
@@ -103,11 +104,12 @@ impl RpcServerArgs {
     }
 
     /// Convenience function for starting a rpc server with configs which extracted from cli args.
-    pub(crate) async fn start_rpc_server<Client, Pool, Network>(
+    pub(crate) async fn start_rpc_server<Client, Pool, Network, Tasks>(
         &self,
         client: Client,
         pool: Pool,
         network: Network,
+        executor: Tasks,
     ) -> Result<RpcServerHandle, RpcError>
     where
         Client: BlockProvider
@@ -115,9 +117,11 @@ impl RpcServerArgs {
             + StateProviderFactory
             + EvmEnvProvider
             + Clone
+            + Unpin
             + 'static,
         Pool: TransactionPool + Clone + 'static,
         Network: NetworkInfo + Peers + Clone + 'static,
+        Tasks: TaskSpawner + Clone + 'static,
     {
         reth_rpc_builder::launch(
             client,
@@ -125,16 +129,18 @@ impl RpcServerArgs {
             network,
             self.transport_rpc_module_config(),
             self.rpc_server_config(),
+            executor,
         )
         .await
     }
 
     /// Create Engine API server.
-    pub(crate) async fn start_auth_server<Client, Pool, Network>(
+    pub(crate) async fn start_auth_server<Client, Pool, Network, Tasks>(
         &self,
         client: Client,
         pool: Pool,
         network: Network,
+        executor: Tasks,
         handle: EngineApiHandle,
     ) -> Result<ServerHandle, RpcError>
     where
@@ -143,16 +149,27 @@ impl RpcServerArgs {
             + StateProviderFactory
             + EvmEnvProvider
             + Clone
+            + Unpin
             + 'static,
         Pool: TransactionPool + Clone + 'static,
         Network: NetworkInfo + Peers + Clone + 'static,
+        Tasks: TaskSpawner + Clone + 'static,
     {
         let socket_address = SocketAddr::new(
             self.auth_addr.unwrap_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED)),
             self.auth_port.unwrap_or(constants::DEFAULT_AUTH_PORT),
         );
         let secret = self.jwt_secret().map_err(|err| RpcError::Custom(err.to_string()))?;
-        reth_rpc_builder::auth::launch(client, pool, network, handle, socket_address, secret).await
+        reth_rpc_builder::auth::launch(
+            client,
+            pool,
+            network,
+            executor,
+            handle,
+            socket_address,
+            secret,
+        )
+        .await
     }
 
     /// Creates the [TransportRpcModuleConfig] from cli args.
@@ -189,7 +206,7 @@ impl RpcServerArgs {
         if self.ws {
             let socket_address = SocketAddr::new(
                 self.ws_addr.unwrap_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED)),
-                self.ws_port.unwrap_or(constants::DEFAULT_HTTP_RPC_PORT),
+                self.ws_port.unwrap_or(constants::DEFAULT_WS_RPC_PORT),
             );
             config = config.with_ws_address(socket_address).with_http(ServerBuilder::new());
         }
diff --git a/bin/reth/src/chain/import.rs b/bin/reth/src/chain/import.rs
index f93228a3f6a..4cd314e2276 100644
--- a/bin/reth/src/chain/import.rs
+++ b/bin/reth/src/chain/import.rs
@@ -5,18 +5,16 @@ use crate::{
 use clap::{crate_version, Parser};
 use eyre::Context;
 use futures::{Stream, StreamExt};
-use reth_consensus::beacon::BeaconConsensus;
+use reth_beacon_consensus::BeaconConsensus;
 use reth_db::mdbx::{Env, WriteMap};
 use reth_downloaders::{
     bodies::bodies::BodiesDownloaderBuilder,
     headers::reverse_headers::ReverseHeadersDownloaderBuilder, test_utils::FileClient,
 };
 use reth_interfaces::{
-    consensus::{Consensus, ForkchoiceState},
-    p2p::headers::client::NoopStatusUpdater,
-    sync::SyncStateUpdater,
+    consensus::Consensus, p2p::headers::client::NoopStatusUpdater, sync::SyncStateUpdater,
 };
-use reth_primitives::ChainSpec;
+use reth_primitives::{ChainSpec, H256};
 use reth_staged_sync::{
     utils::{
         chainspec::genesis_value_parser,
@@ -26,9 +24,10 @@ use reth_staged_sync::{
 };
 use reth_stages::{
     prelude::*,
-    stages::{ExecutionStage, SenderRecoveryStage, TotalDifficultyStage},
+    stages::{ExecutionStage, HeaderSyncMode, SenderRecoveryStage, TotalDifficultyStage},
 };
 use std::sync::Arc;
+use tokio::sync::watch;
 use tracing::{debug, info};
 
 /// Syncs RLP encoded blocks from a file.
@@ -63,7 +62,7 @@ pub struct ImportCommand {
         default_value = "mainnet",
         value_parser = genesis_value_parser
     )]
-    chain: ChainSpec,
+    chain: Arc<ChainSpec>,
 
     /// The path to a block file for import.
     ///
@@ -89,6 +88,9 @@ impl ImportCommand {
 
         init_genesis(db.clone(), self.chain.clone())?;
 
+        let consensus = Arc::new(BeaconConsensus::new(self.chain.clone()));
+        info!(target: "reth::cli", "Consensus engine initialized");
+
         // create a new FileClient
         info!(target: "reth::cli", "Importing chain file");
         let file_client = Arc::new(FileClient::new(&self.path).await?);
@@ -97,18 +99,13 @@ impl ImportCommand {
         let tip = file_client.tip().expect("file client has no tip");
         info!(target: "reth::cli", "Chain file imported");
 
-        let (consensus, notifier) = BeaconConsensus::builder().build(self.chain.clone());
-        debug!(target: "reth::cli", %tip, "Tip manually set");
-        notifier.send(ForkchoiceState {
-            head_block_hash: tip,
-            safe_block_hash: tip,
-            finalized_block_hash: tip,
-        })?;
-        info!(target: "reth::cli", "Consensus engine initialized");
-
         let (mut pipeline, events) =
             self.build_import_pipeline(config, db.clone(), &consensus, file_client).await?;
 
+        // override the tip
+        pipeline.set_tip(tip);
+        debug!(target: "reth::cli", %tip, "Tip manually set");
+
         tokio::spawn(handle_events(None, events));
 
         // Run pipeline
@@ -140,26 +137,29 @@ impl ImportCommand {
             .build(file_client.clone(), consensus.clone(), db)
             .into_task();
 
+        let (tip_tx, tip_rx) = watch::channel(H256::zero());
+        let factory = reth_executor::Factory::new(self.chain.clone());
+
         let mut pipeline = Pipeline::builder()
+            .with_tip_sender(tip_tx)
             .with_sync_state_updater(file_client)
             .add_stages(
                 DefaultStages::new(
+                    HeaderSyncMode::Tip(tip_rx),
                     consensus.clone(),
                     header_downloader,
                     body_downloader,
                     NoopStatusUpdater::default(),
+                    factory.clone(),
+                )
+                .set(
+                    TotalDifficultyStage::new(consensus.clone())
+                        .with_commit_threshold(config.stages.total_difficulty.commit_threshold),
                 )
-                .set(TotalDifficultyStage {
-                    chain_spec: self.chain.clone(),
-                    commit_threshold: config.stages.total_difficulty.commit_threshold,
-                })
                 .set(SenderRecoveryStage {
                     commit_threshold: config.stages.sender_recovery.commit_threshold,
                 })
-                .set(ExecutionStage {
-                    chain_spec: self.chain.clone(),
-                    commit_threshold: config.stages.execution.commit_threshold,
-                }),
+                .set(ExecutionStage::new(factory, config.stages.execution.commit_threshold)),
             )
             .with_max_block(0)
             .build();
diff --git a/bin/reth/src/chain/init.rs b/bin/reth/src/chain/init.rs
index e8eb32afebe..0d3f395634f 100644
--- a/bin/reth/src/chain/init.rs
+++ b/bin/reth/src/chain/init.rs
@@ -36,30 +36,22 @@ pub struct InitCommand {
         default_value = "mainnet",
         value_parser = genesis_value_parser
     )]
-    chain: ChainSpec,
+    chain: Arc<ChainSpec>,
 }
 
 impl InitCommand {
     /// Execute the `init` command
     pub async fn execute(&self) -> eyre::Result<()> {
-        info!(target: "reth::cli", "reth import starting");
+        info!(target: "reth::cli", "reth init starting");
 
         info!(target: "reth::cli", path = %self.db, "Opening database");
         let db = Arc::new(init_db(&self.db)?);
         info!(target: "reth::cli", "Database opened");
 
         info!(target: "reth::cli", "Writing genesis block");
-        let genesis_hash = init_genesis(db, self.chain.clone())?;
-
-        if genesis_hash != self.chain.genesis_hash() {
-            // TODO: better error text
-            return Err(eyre::eyre!(
-                "Genesis hash mismatch: expected {}, got {}",
-                self.chain.genesis_hash(),
-                genesis_hash
-            ))
-        }
+        let hash = init_genesis(db, self.chain.clone())?;
 
+        info!(target: "reth::cli", hash = ?hash, "Genesis block written");
         Ok(())
     }
 }
diff --git a/bin/reth/src/cli.rs b/bin/reth/src/cli.rs
index e984a0b9371..4afa9093921 100644
--- a/bin/reth/src/cli.rs
+++ b/bin/reth/src/cli.rs
@@ -38,7 +38,7 @@ pub fn run() -> eyre::Result<()> {
 }
 
 /// Commands to be executed
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 pub enum Commands {
     /// Start the node
     #[command(name = "node")]
@@ -74,7 +74,7 @@ pub enum Commands {
     TestVectors(test_vectors::Command),
 }
 
-#[derive(Parser)]
+#[derive(Debug, Parser)]
 #[command(author, version = "0.1", about = "Reth", long_about = None)]
 struct Cli {
     /// The command to run
@@ -88,9 +88,10 @@ struct Cli {
     verbosity: Verbosity,
 }
 
-#[derive(Args)]
+/// The log configuration.
+#[derive(Debug, Args)]
 #[command(next_help_heading = "Logging")]
-struct Logs {
+pub struct Logs {
     /// The path to put log files in.
     #[arg(
         long = "log.directory",
@@ -112,7 +113,7 @@ struct Logs {
 
 impl Logs {
     /// Builds a tracing layer from the current log options.
-    fn layer<S>(&self) -> (BoxedLayer<S>, Option<FileWorkerGuard>)
+    pub fn layer<S>(&self) -> (BoxedLayer<S>, Option<FileWorkerGuard>)
     where
         S: Subscriber,
         for<'a> S: LookupSpan<'a>,
@@ -129,9 +130,10 @@ impl Logs {
     }
 }
 
-#[derive(Args)]
+/// The verbosity settings for the cli.
+#[derive(Debug, Copy, Clone, Args)]
 #[command(next_help_heading = "Display")]
-struct Verbosity {
+pub struct Verbosity {
     /// Set the minimum log level.
     ///
     /// -v      Errors
@@ -150,7 +152,7 @@ struct Verbosity {
 impl Verbosity {
     /// Get the corresponding [Directive] for the given verbosity, or none if the verbosity
     /// corresponds to silent.
-    fn directive(&self) -> Directive {
+    pub fn directive(&self) -> Directive {
         if self.quiet {
             LevelFilter::OFF.into()
         } else {
@@ -166,3 +168,23 @@ impl Verbosity {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::CommandFactory;
+
+    /// Tests that the help message is parsed correctly. This ensures that clap args are configured
+    /// correctly and no conflicts are introduced via attributes that would result in a panic at
+    /// runtime
+    #[test]
+    fn test_parse_help_all_subcommands() {
+        let reth = Cli::command();
+        for sub_command in reth.get_subcommands() {
+            let err = Cli::try_parse_from(["reth", sub_command.get_name(), "--help"]).unwrap_err();
+            // --help is treated as error, but
+            // > Not a true "error" as it means --help or similar was used. The help message will be sent to stdout.
+            assert_eq!(err.kind(), clap::error::ErrorKind::DisplayHelp);
+        }
+    }
+}
diff --git a/bin/reth/src/db/mod.rs b/bin/reth/src/db/mod.rs
index 6a9ccd48f41..a0830ca13f3 100644
--- a/bin/reth/src/db/mod.rs
+++ b/bin/reth/src/db/mod.rs
@@ -29,7 +29,7 @@ pub struct Command {
     /// - Linux: `$XDG_DATA_HOME/reth/db` or `$HOME/.local/share/reth/db`
     /// - Windows: `{FOLDERID_RoamingAppData}/reth/db`
     /// - macOS: `$HOME/Library/Application Support/reth/db`
-    #[arg(long, value_name = "PATH", verbatim_doc_comment, default_value_t)]
+    #[arg(global = true, long, value_name = "PATH", verbatim_doc_comment, default_value_t)]
     db: PlatformPath<DbPath>,
 
     #[clap(subcommand)]
@@ -151,8 +151,10 @@ impl Command {
                                         );
                                         return Ok(());
                                     }
-                                    let map = tool.list::<tables::$table>($start, $len)?;
-                                    tui::DbListTUI::<tables::$table>::show_tui(map, $start, total_entries)
+
+                                    tui::DbListTUI::<_, tables::$table>::new(|start, count| {
+                                        tool.list::<tables::$table>(start, count).unwrap()
+                                    }, $start, $len, total_entries).run()
                                 })??
                             },)*
                             _ => {
@@ -176,7 +178,6 @@ impl Command {
                     BlockTransitionIndex,
                     TxTransitionIndex,
                     SyncStage,
-                    TxHashNumber,
                     Transactions
                 ]);
             }
@@ -206,8 +207,8 @@ impl<'a, DB: Database> DbTool<'a, DB> {
         let chain = random_block_range(0..len, Default::default(), 0..64);
 
         self.db.update(|tx| {
-            chain.iter().try_for_each(|block| {
-                insert_canonical_block(tx, block, true)?;
+            chain.into_iter().try_for_each(|block| {
+                insert_canonical_block(tx, block, None, true)?;
                 Ok::<_, eyre::Error>(())
             })
         })??;
diff --git a/bin/reth/src/db/tui.rs b/bin/reth/src/db/tui.rs
index 1121d1af683..c4ceaf9e868 100644
--- a/bin/reth/src/db/tui.rs
+++ b/bin/reth/src/db/tui.rs
@@ -19,7 +19,14 @@ use tui::{
 };
 
 /// Available keybindings for the [DbListTUI]
-static CMDS: [(&str, &str); 3] = [("q", "Quit"), ("up", "Entry Above"), ("down", "Entry Below")];
+static CMDS: [(&str, &str); 6] = [
+    ("q", "Quit"),
+    ("↑", "Entry above"),
+    ("↓", "Entry below"),
+    ("←", "Previous page"),
+    ("→", "Next page"),
+    ("G", "Go to a specific page"),
+];
 
 /// Modified version of the [ListState] struct that exposes the `offset` field.
 /// Used to make the [DbListTUI] keys clickable.
@@ -27,26 +34,62 @@ struct ExpListState {
     pub(crate) offset: usize,
 }
 
+#[derive(Default, Eq, PartialEq)]
+pub(crate) enum ViewMode {
+    /// Normal list view mode
+    #[default]
+    Normal,
+    /// Currently wanting to go to a page
+    GoToPage,
+}
+
 #[derive(Default)]
-pub(crate) struct DbListTUI<T: Table> {
-    /// The state of the key list.
-    pub(crate) state: ListState,
+pub(crate) struct DbListTUI<F, T: Table>
+where
+    F: FnMut(usize, usize) -> BTreeMap<T::Key, T::Value>,
+{
+    /// Fetcher for the next page of items.
+    ///
+    /// The fetcher is passed the index of the first item to fetch, and the number of items to
+    /// fetch from that item.
+    fetch: F,
     /// The starting index of the key list in the DB.
-    pub(crate) start: usize,
+    start: usize,
+    /// The amount of entries to show per page
+    count: usize,
     /// The total number of entries in the database
-    pub(crate) total_entries: usize,
+    total_entries: usize,
+    /// The current view mode
+    mode: ViewMode,
+    /// The current state of the input buffer
+    input: String,
+    /// The state of the key list.
+    list_state: ListState,
     /// Entries to show in the TUI.
-    pub(crate) entries: BTreeMap<T::Key, T::Value>,
+    entries: BTreeMap<T::Key, T::Value>,
 }
 
-impl<T: Table> DbListTUI<T> {
-    fn new(entries: BTreeMap<T::Key, T::Value>, start: usize, total_entries: usize) -> Self {
-        Self { state: ListState::default(), start, total_entries, entries }
+impl<F, T: Table> DbListTUI<F, T>
+where
+    F: FnMut(usize, usize) -> BTreeMap<T::Key, T::Value>,
+{
+    /// Create a new database list TUI
+    pub(crate) fn new(fetch: F, start: usize, count: usize, total_entries: usize) -> Self {
+        Self {
+            fetch,
+            start,
+            count,
+            total_entries,
+            mode: ViewMode::Normal,
+            input: String::new(),
+            list_state: ListState::default(),
+            entries: BTreeMap::new(),
+        }
     }
 
     /// Move to the next list selection
     fn next(&mut self) {
-        let i = match self.state.selected() {
+        let i = match self.list_state.selected() {
             Some(i) => {
                 if i >= self.entries.len() - 1 {
                     0
@@ -56,12 +99,12 @@ impl<T: Table> DbListTUI<T> {
             }
             None => 0,
         };
-        self.state.select(Some(i));
+        self.list_state.select(Some(i));
     }
 
     /// Move to the previous list selection
     fn previous(&mut self) {
-        let i = match self.state.selected() {
+        let i = match self.list_state.selected() {
             Some(i) => {
                 if i == 0 {
                     self.entries.len() - 1
@@ -71,89 +114,177 @@ impl<T: Table> DbListTUI<T> {
             }
             None => 0,
         };
-        self.state.select(Some(i));
+        self.list_state.select(Some(i));
+    }
+
+    fn reset(&mut self) {
+        self.list_state.select(Some(0));
+    }
+
+    /// Fetch the next page of items
+    fn next_page(&mut self) {
+        if self.start + self.count >= self.total_entries {
+            return
+        }
+
+        self.start += self.count;
+        self.fetch_page();
+    }
+
+    /// Fetch the previous page of items
+    fn previous_page(&mut self) {
+        if self.start == 0 {
+            return
+        }
+
+        self.start -= self.count;
+        self.fetch_page();
+    }
+
+    /// Go to a specific page.
+    fn go_to_page(&mut self, page: usize) {
+        self.start = (self.count * page).min(self.total_entries - self.count);
+        self.fetch_page();
+    }
+
+    /// Fetch the current page
+    fn fetch_page(&mut self) {
+        self.entries = (self.fetch)(self.start, self.count);
+        self.reset();
     }
 
     /// Show the [DbListTUI] in the terminal.
-    pub(crate) fn show_tui(
-        entries: BTreeMap<T::Key, T::Value>,
-        start: usize,
-        total_entries: usize,
-    ) -> eyre::Result<()> {
-        // setup terminal
+    pub(crate) fn run(mut self) -> eyre::Result<()> {
+        // Setup backend
         enable_raw_mode()?;
         let mut stdout = io::stdout();
         execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
         let backend = CrosstermBackend::new(stdout);
         let mut terminal = Terminal::new(backend)?;
 
-        // create app and run it
+        // Load initial page
+        self.fetch_page();
+
+        // Run event loop
         let tick_rate = Duration::from_millis(250);
-        let mut app = DbListTUI::<T>::new(entries, start, total_entries);
-        app.state.select(Some(0));
-        let res = run(&mut terminal, app, tick_rate);
+        let res = event_loop(&mut terminal, &mut self, tick_rate);
 
-        // restore terminal
+        // Restore terminal
         disable_raw_mode()?;
         execute!(terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture)?;
         terminal.show_cursor()?;
 
+        // Handle errors
         if let Err(err) = res {
             error!("{:?}", err)
         }
-
         Ok(())
     }
 }
 
-fn run<B: Backend, T: Table>(
+/// Run the event loop
+fn event_loop<B: Backend, F, T: Table>(
     terminal: &mut Terminal<B>,
-    mut app: DbListTUI<T>,
+    app: &mut DbListTUI<F, T>,
     tick_rate: Duration,
-) -> io::Result<()> {
+) -> io::Result<()>
+where
+    F: FnMut(usize, usize) -> BTreeMap<T::Key, T::Value>,
+{
     let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &mut app))?;
+    let mut running = true;
+    while running {
+        // Render
+        terminal.draw(|f| ui(f, app))?;
 
+        // Calculate timeout
         let timeout =
             tick_rate.checked_sub(last_tick.elapsed()).unwrap_or_else(|| Duration::from_secs(0));
+
+        // Poll events
         if crossterm::event::poll(timeout)? {
-            match event::read()? {
-                Event::Key(key) => match key.code {
-                    KeyCode::Char('q') | KeyCode::Char('Q') => return Ok(()),
-                    KeyCode::Down => app.next(),
-                    KeyCode::Up => app.previous(),
-                    _ => {}
-                },
-                Event::Mouse(e) => match e.kind {
-                    MouseEventKind::ScrollDown => app.next(),
-                    MouseEventKind::ScrollUp => app.previous(),
-                    // TODO: This click event can be triggered outside of the list widget.
-                    MouseEventKind::Down(_) => {
-                        // SAFETY: The pointer to the app's state will always be valid for
-                        // reads here, and the source is larger than the destination.
-                        //
-                        // This is technically unsafe, but because the alignment requirements
-                        // in both the source and destination are the same and we can ensure
-                        // that the pointer to `app.state` is valid for reads, this is safe.
-                        let state: ExpListState = unsafe { std::mem::transmute_copy(&app.state) };
-                        let new_idx = (e.row as usize + state.offset).saturating_sub(1);
-                        if new_idx < app.entries.len() {
-                            app.state.select(Some(new_idx));
-                        }
-                    }
-                    _ => {}
-                },
-                _ => {}
-            }
+            running = !handle_event(app, event::read()?)?;
         }
+
         if last_tick.elapsed() >= tick_rate {
             last_tick = Instant::now();
         }
     }
+
+    Ok(())
+}
+
+/// Handle incoming events
+fn handle_event<F, T: Table>(app: &mut DbListTUI<F, T>, event: Event) -> io::Result<bool>
+where
+    F: FnMut(usize, usize) -> BTreeMap<T::Key, T::Value>,
+{
+    if app.mode == ViewMode::GoToPage {
+        if let Event::Key(key) = event {
+            match key.code {
+                KeyCode::Enter => {
+                    let input = std::mem::take(&mut app.input);
+                    if let Ok(page) = input.parse() {
+                        app.go_to_page(page);
+                    }
+                    app.mode = ViewMode::Normal;
+                }
+                KeyCode::Char(c) => {
+                    app.input.push(c);
+                }
+                KeyCode::Backspace => {
+                    app.input.pop();
+                }
+                KeyCode::Esc => app.mode = ViewMode::Normal,
+                _ => {}
+            }
+        }
+
+        return Ok(false)
+    }
+
+    match event {
+        Event::Key(key) => match key.code {
+            KeyCode::Char('q') | KeyCode::Char('Q') => return Ok(true),
+            KeyCode::Down => app.next(),
+            KeyCode::Up => app.previous(),
+            KeyCode::Right => app.next_page(),
+            KeyCode::Left => app.previous_page(),
+            KeyCode::Char('G') => {
+                app.mode = ViewMode::GoToPage;
+            }
+            _ => {}
+        },
+        Event::Mouse(e) => match e.kind {
+            MouseEventKind::ScrollDown => app.next(),
+            MouseEventKind::ScrollUp => app.previous(),
+            // TODO: This click event can be triggered outside of the list widget.
+            MouseEventKind::Down(_) => {
+                // SAFETY: The pointer to the app's state will always be valid for
+                // reads here, and the source is larger than the destination.
+                //
+                // This is technically unsafe, but because the alignment requirements
+                // in both the source and destination are the same and we can ensure
+                // that the pointer to `app.state` is valid for reads, this is safe.
+                let state: ExpListState = unsafe { std::mem::transmute_copy(&app.list_state) };
+                let new_idx = (e.row as usize + state.offset).saturating_sub(1);
+                if new_idx < app.entries.len() {
+                    app.list_state.select(Some(new_idx));
+                }
+            }
+            _ => {}
+        },
+        _ => {}
+    }
+
+    Ok(false)
 }
 
-fn ui<B: Backend, T: Table>(f: &mut Frame<'_, B>, app: &mut DbListTUI<T>) {
+/// Render the UI
+fn ui<B: Backend, F, T: Table>(f: &mut Frame<'_, B>, app: &mut DbListTUI<F, T>)
+where
+    F: FnMut(usize, usize) -> BTreeMap<T::Key, T::Value>,
+{
     let outer_chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints([Constraint::Percentage(95), Constraint::Percentage(5)].as_ref())
@@ -166,16 +297,19 @@ fn ui<B: Backend, T: Table>(f: &mut Frame<'_, B>, app: &mut DbListTUI<T>) {
             .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
             .split(outer_chunks[0]);
 
+        let key_length = format!("{}", app.start + app.count - 1).len();
         let formatted_keys = app
             .entries
             .keys()
             .enumerate()
-            .map(|(i, k)| ListItem::new(format!("[{}] - {k:?}", i + app.start)))
+            .map(|(i, k)| {
+                ListItem::new(format!("[{:0>width$}]: {k:?}", i + app.start, width = key_length))
+            })
             .collect::<Vec<ListItem<'_>>>();
 
         let key_list = List::new(formatted_keys)
             .block(Block::default().borders(Borders::ALL).title(format!(
-                "Keys (Showing range [{}, {}] out of {} entries)",
+                "Keys (Showing entries {}-{} out of {} entries)",
                 app.start,
                 app.start + app.entries.len() - 1,
                 app.total_entries
@@ -184,13 +318,18 @@ fn ui<B: Backend, T: Table>(f: &mut Frame<'_, B>, app: &mut DbListTUI<T>) {
             .highlight_style(Style::default().fg(Color::Cyan).add_modifier(Modifier::ITALIC))
             .highlight_symbol("➜ ")
             .start_corner(Corner::TopLeft);
-        f.render_stateful_widget(key_list, inner_chunks[0], &mut app.state);
+        f.render_stateful_widget(key_list, inner_chunks[0], &mut app.list_state);
 
+        let values = app.entries.values().collect::<Vec<_>>();
         let value_display = Paragraph::new(
-            serde_json::to_string_pretty(
-                &app.entries.values().collect::<Vec<_>>()[app.state.selected().unwrap_or(0)],
-            )
-            .unwrap_or_else(|_| String::from("Error serializing value!")),
+            app.list_state
+                .selected()
+                .and_then(|selected| values.get(selected))
+                .map(|entry| {
+                    serde_json::to_string_pretty(entry)
+                        .unwrap_or(String::from("Error serializing value"))
+                })
+                .unwrap_or("No value selected".to_string()),
         )
         .block(Block::default().borders(Borders::ALL).title("Value (JSON)"))
         .wrap(Wrap { trim: false })
@@ -199,11 +338,21 @@ fn ui<B: Backend, T: Table>(f: &mut Frame<'_, B>, app: &mut DbListTUI<T>) {
     }
 
     // Footer
-    let footer = Paragraph::new(
-        CMDS.iter().map(|(k, v)| format!("[{k}] {v}")).collect::<Vec<_>>().join(" | "),
-    )
+    let footer = match app.mode {
+        ViewMode::Normal => Paragraph::new(
+            CMDS.iter().map(|(k, v)| format!("[{k}] {v}")).collect::<Vec<_>>().join(" | "),
+        ),
+        ViewMode::GoToPage => Paragraph::new(format!(
+            "Go to page (max {}): {}",
+            app.total_entries / app.count,
+            app.input
+        )),
+    }
     .block(Block::default().borders(Borders::ALL))
-    .alignment(Alignment::Center)
+    .alignment(match app.mode {
+        ViewMode::Normal => Alignment::Center,
+        ViewMode::GoToPage => Alignment::Left,
+    })
     .style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD));
     f.render_widget(footer, outer_chunks[1]);
 }
diff --git a/bin/reth/src/dirs.rs b/bin/reth/src/dirs.rs
index b1a8aa575c5..45d61dea89d 100644
--- a/bin/reth/src/dirs.rs
+++ b/bin/reth/src/dirs.rs
@@ -44,11 +44,18 @@ pub fn logs_dir() -> Option<PathBuf> {
 
 /// Returns the path to the reth jwtsecret directory.
 ///
-/// Refer to [dirs_next::cache_dir] for cross-platform behavior.
+/// Refer to [dirs_next::data_dir] for cross-platform behavior.
 pub fn jwt_secret_dir() -> Option<PathBuf> {
     data_dir().map(|root| root.join("jwtsecret"))
 }
 
+/// Returns the path to the reth net directory.
+///
+/// Refer to [dirs_next::data_dir]
+pub fn net_dir() -> Option<PathBuf> {
+    data_dir().map(|root| root.join("net"))
+}
+
 /// Returns the path to the reth database.
 ///
 /// Refer to [dirs_next::data_dir] for cross-platform behavior.
@@ -90,14 +97,14 @@ impl XdgPath for ConfigPath {
 
 /// Returns the path to the default reth known peers file.
 ///
-/// Refer to [dirs_next::config_dir] for cross-platform behavior.
+/// Refer to [dirs_next::data_dir] for cross-platform behavior.
 #[derive(Default, Debug, Clone)]
 #[non_exhaustive]
 pub struct KnownPeersPath;
 
 impl XdgPath for KnownPeersPath {
     fn resolve() -> Option<PathBuf> {
-        database_path().map(|p| p.join("known-peers.json"))
+        net_dir().map(|p| p.join("known-peers.json"))
     }
 }
 
@@ -116,7 +123,8 @@ impl XdgPath for LogsDir {
 
 /// A small helper trait for unit structs that represent a standard path following the XDG
 /// path specification.
-trait XdgPath {
+pub trait XdgPath {
+    /// Resolve the [XdgPath] into a [PathBuf].
     fn resolve() -> Option<PathBuf>;
 }
 
diff --git a/bin/reth/src/dump_stage/execution.rs b/bin/reth/src/dump_stage/execution.rs
index 49d6de7de35..7e164d9eb45 100644
--- a/bin/reth/src/dump_stage/execution.rs
+++ b/bin/reth/src/dump_stage/execution.rs
@@ -7,9 +7,10 @@ use eyre::Result;
 use reth_db::{
     cursor::DbCursorRO, database::Database, table::TableImporter, tables, transaction::DbTx,
 };
+use reth_primitives::MAINNET;
 use reth_provider::Transaction;
 use reth_stages::{stages::ExecutionStage, Stage, StageId, UnwindInput};
-use std::ops::DerefMut;
+use std::{ops::DerefMut, sync::Arc};
 use tracing::info;
 
 pub(crate) async fn dump_execution_stage<DB: Database>(
@@ -96,7 +97,10 @@ async fn unwind_and_copy<DB: Database>(
     output_db: &reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
 ) -> eyre::Result<()> {
     let mut unwind_tx = Transaction::new(db_tool.db)?;
-    let mut exec_stage = ExecutionStage::default();
+
+    let mut exec_stage = ExecutionStage::new_default_threshold(reth_executor::Factory::new(
+        Arc::new(MAINNET.clone()),
+    ));
 
     exec_stage
         .unwind(
@@ -125,7 +129,9 @@ async fn dry_run(
     info!(target: "reth::cli", "Executing stage. [dry-run]");
 
     let mut tx = Transaction::new(&output_db)?;
-    let mut exec_stage = ExecutionStage::default();
+    let mut exec_stage = ExecutionStage::new_default_threshold(reth_executor::Factory::new(
+        Arc::new(MAINNET.clone()),
+    ));
 
     exec_stage
         .execute(
diff --git a/bin/reth/src/dump_stage/hashing_account.rs b/bin/reth/src/dump_stage/hashing_account.rs
index e5f6ccf0197..5f43ce61abd 100644
--- a/bin/reth/src/dump_stage/hashing_account.rs
+++ b/bin/reth/src/dump_stage/hashing_account.rs
@@ -36,8 +36,7 @@ pub(crate) async fn dump_hashing_account_stage<DB: Database>(
     unwind_and_copy::<DB>(db_tool, from, tip_block_number, &output_db).await?;
 
     if should_run {
-        println!("\n# AccountHashing stage does not support dry run, so it will actually be committing changes.");
-        run(output_db, to, from).await?;
+        dry_run(output_db, to, from).await?;
     }
 
     Ok(())
@@ -69,7 +68,7 @@ async fn unwind_and_copy<DB: Database>(
 }
 
 /// Try to re-execute the stage straightaway
-async fn run(
+async fn dry_run(
     output_db: reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
     to: u64,
     from: u64,
@@ -82,15 +81,21 @@ async fn run(
         ..Default::default()
     };
 
-    exec_stage
-        .execute(
-            &mut tx,
-            reth_stages::ExecInput {
-                previous_stage: Some((StageId("Another"), to)),
-                stage_progress: Some(from),
-            },
-        )
-        .await?;
+    let mut exec_output = false;
+    while !exec_output {
+        exec_output = exec_stage
+            .execute(
+                &mut tx,
+                reth_stages::ExecInput {
+                    previous_stage: Some((StageId("Another"), to)),
+                    stage_progress: Some(from),
+                },
+            )
+            .await?
+            .done;
+    }
+
+    tx.drop()?;
 
     info!(target: "reth::cli", "Success.");
 
diff --git a/bin/reth/src/dump_stage/hashing_storage.rs b/bin/reth/src/dump_stage/hashing_storage.rs
index 557c6a956d7..03cbb74a3f9 100644
--- a/bin/reth/src/dump_stage/hashing_storage.rs
+++ b/bin/reth/src/dump_stage/hashing_storage.rs
@@ -6,8 +6,9 @@ use crate::{
 use eyre::Result;
 use reth_db::{database::Database, table::TableImporter, tables};
 use reth_provider::Transaction;
-use reth_stages::{stages::StorageHashingStage, Stage, UnwindInput};
+use reth_stages::{stages::StorageHashingStage, Stage, StageId, UnwindInput};
 use std::ops::DerefMut;
+use tracing::info;
 
 pub(crate) async fn dump_hashing_storage_stage<DB: Database>(
     db_tool: &mut DbTool<'_, DB>,
@@ -16,14 +17,14 @@ pub(crate) async fn dump_hashing_storage_stage<DB: Database>(
     output_db: &PlatformPath<DbPath>,
     should_run: bool,
 ) -> Result<()> {
-    if should_run {
-        eyre::bail!("StorageHashing stage does not support dry run.")
-    }
-
     let (output_db, tip_block_number) = setup::<DB>(from, to, output_db, db_tool)?;
 
     unwind_and_copy::<DB>(db_tool, from, tip_block_number, &output_db).await?;
 
+    if should_run {
+        dry_run(output_db, to, from).await?;
+    }
+
     Ok(())
 }
 
@@ -53,3 +54,38 @@ async fn unwind_and_copy<DB: Database>(
 
     Ok(())
 }
+
+/// Try to re-execute the stage straightaway
+async fn dry_run(
+    output_db: reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
+    to: u64,
+    from: u64,
+) -> eyre::Result<()> {
+    info!(target: "reth::cli", "Executing stage.");
+
+    let mut tx = Transaction::new(&output_db)?;
+    let mut exec_stage = StorageHashingStage {
+        clean_threshold: 1, // Forces hashing from scratch
+        ..Default::default()
+    };
+
+    let mut exec_output = false;
+    while !exec_output {
+        exec_output = exec_stage
+            .execute(
+                &mut tx,
+                reth_stages::ExecInput {
+                    previous_stage: Some((StageId("Another"), to)),
+                    stage_progress: Some(from),
+                },
+            )
+            .await?
+            .done;
+    }
+
+    tx.drop()?;
+
+    info!(target: "reth::cli", "Success.");
+
+    Ok(())
+}
diff --git a/bin/reth/src/dump_stage/merkle.rs b/bin/reth/src/dump_stage/merkle.rs
new file mode 100644
index 00000000000..6e6ce370ff3
--- /dev/null
+++ b/bin/reth/src/dump_stage/merkle.rs
@@ -0,0 +1,143 @@
+use crate::{
+    db::DbTool,
+    dirs::{DbPath, PlatformPath},
+    dump_stage::setup,
+};
+use eyre::Result;
+use reth_db::{database::Database, table::TableImporter, tables, transaction::DbTx};
+use reth_primitives::MAINNET;
+use reth_provider::Transaction;
+use reth_stages::{
+    stages::{AccountHashingStage, ExecutionStage, MerkleStage, StorageHashingStage},
+    Stage, StageId, UnwindInput,
+};
+use std::{ops::DerefMut, sync::Arc};
+use tracing::info;
+
+pub(crate) async fn dump_merkle_stage<DB: Database>(
+    db_tool: &mut DbTool<'_, DB>,
+    from: u64,
+    to: u64,
+    output_db: &PlatformPath<DbPath>,
+    should_run: bool,
+) -> Result<()> {
+    let (output_db, tip_block_number) = setup::<DB>(from, to, output_db, db_tool)?;
+
+    output_db.update(|tx| {
+        tx.import_table_with_range::<tables::Headers, _>(&db_tool.db.tx()?, Some(from), to)
+    })??;
+
+    let tx = db_tool.db.tx()?;
+    let from_transition_rev =
+        tx.get::<tables::BlockTransitionIndex>(from)?.expect("there should be at least one.");
+    let to_transition_rev =
+        tx.get::<tables::BlockTransitionIndex>(to)?.expect("there should be at least one.");
+
+    output_db.update(|tx| {
+        tx.import_table_with_range::<tables::AccountChangeSet, _>(
+            &db_tool.db.tx()?,
+            Some(from_transition_rev),
+            to_transition_rev,
+        )
+    })??;
+
+    unwind_and_copy::<DB>(db_tool, (from, to), tip_block_number, &output_db).await?;
+
+    if should_run {
+        dry_run(output_db, to, from).await?;
+    }
+
+    Ok(())
+}
+
+/// Dry-run an unwind to FROM block and copy the necessary table data to the new database.
+async fn unwind_and_copy<DB: Database>(
+    db_tool: &mut DbTool<'_, DB>,
+    range: (u64, u64),
+    tip_block_number: u64,
+    output_db: &reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
+) -> eyre::Result<()> {
+    let (from, to) = range;
+    let mut unwind_tx = Transaction::new(db_tool.db)?;
+    let unwind = UnwindInput { unwind_to: from, stage_progress: tip_block_number, bad_block: None };
+    let execute_input = reth_stages::ExecInput {
+        previous_stage: Some((StageId("Another"), to)),
+        stage_progress: Some(from),
+    };
+
+    // Unwind hashes all the way to FROM
+    StorageHashingStage::default().unwind(&mut unwind_tx, unwind).await.unwrap();
+    AccountHashingStage::default().unwind(&mut unwind_tx, unwind).await.unwrap();
+
+    MerkleStage::default_unwind().unwind(&mut unwind_tx, unwind).await?;
+
+    // Bring Plainstate to TO (hashing stage execution requires it)
+    let mut exec_stage = ExecutionStage::new_default_threshold(reth_executor::Factory::new(
+        Arc::new(MAINNET.clone()),
+    ));
+
+    exec_stage.commit_threshold = u64::MAX;
+    exec_stage
+        .unwind(
+            &mut unwind_tx,
+            UnwindInput { unwind_to: to, stage_progress: tip_block_number, bad_block: None },
+        )
+        .await?;
+
+    // Bring hashes to TO
+    AccountHashingStage { clean_threshold: u64::MAX, commit_threshold: u64::MAX }
+        .execute(&mut unwind_tx, execute_input)
+        .await
+        .unwrap();
+    StorageHashingStage { clean_threshold: u64::MAX, commit_threshold: u64::MAX }
+        .execute(&mut unwind_tx, execute_input)
+        .await
+        .unwrap();
+
+    let unwind_inner_tx = unwind_tx.deref_mut();
+
+    // TODO optimize we can actually just get the entries we need
+    output_db.update(|tx| tx.import_dupsort::<tables::StorageChangeSet, _>(unwind_inner_tx))??;
+
+    output_db.update(|tx| tx.import_table::<tables::HashedAccount, _>(unwind_inner_tx))??;
+    output_db.update(|tx| tx.import_dupsort::<tables::HashedStorage, _>(unwind_inner_tx))??;
+    output_db.update(|tx| tx.import_table::<tables::AccountsTrie, _>(unwind_inner_tx))??;
+    output_db.update(|tx| tx.import_dupsort::<tables::StoragesTrie, _>(unwind_inner_tx))??;
+
+    unwind_tx.drop()?;
+
+    Ok(())
+}
+
+/// Try to re-execute the stage straightaway
+async fn dry_run(
+    output_db: reth_db::mdbx::Env<reth_db::mdbx::WriteMap>,
+    to: u64,
+    from: u64,
+) -> eyre::Result<()> {
+    info!(target: "reth::cli", "Executing stage.");
+
+    let mut tx = Transaction::new(&output_db)?;
+    let mut exec_output = false;
+    while !exec_output {
+        exec_output = MerkleStage::Execution {
+            clean_threshold: u64::MAX, /* Forces updating the root instead of calculating from
+                                        * scratch */
+        }
+        .execute(
+            &mut tx,
+            reth_stages::ExecInput {
+                previous_stage: Some((StageId("Another"), to)),
+                stage_progress: Some(from),
+            },
+        )
+        .await?
+        .done;
+    }
+
+    tx.drop()?;
+
+    info!(target: "reth::cli", "Success.");
+
+    Ok(())
+}
diff --git a/bin/reth/src/dump_stage/mod.rs b/bin/reth/src/dump_stage/mod.rs
index 0bc3863a342..4eddb3817da 100644
--- a/bin/reth/src/dump_stage/mod.rs
+++ b/bin/reth/src/dump_stage/mod.rs
@@ -8,6 +8,9 @@ use hashing_account::dump_hashing_account_stage;
 mod execution;
 use execution::dump_execution_stage;
 
+mod merkle;
+use merkle::dump_merkle_stage;
+
 use crate::{
     db::DbTool,
     dirs::{DbPath, PlatformPath},
@@ -45,6 +48,8 @@ pub enum Stages {
     StorageHashing(StageCommand),
     /// AccountHashing stage.
     AccountHashing(StageCommand),
+    /// Merkle stage.
+    Merkle(StageCommand),
 }
 
 /// Stage command that takes a range
@@ -94,6 +99,9 @@ impl Command {
             Stages::AccountHashing(StageCommand { output_db, from, to, dry_run, .. }) => {
                 dump_hashing_account_stage(&mut tool, *from, *to, output_db, *dry_run).await?
             }
+            Stages::Merkle(StageCommand { output_db, from, to, dry_run, .. }) => {
+                dump_merkle_stage(&mut tool, *from, *to, output_db, *dry_run).await?
+            }
         }
 
         Ok(())
diff --git a/bin/reth/src/lib.rs b/bin/reth/src/lib.rs
index d22105b0506..36ebcf6324a 100644
--- a/bin/reth/src/lib.rs
+++ b/bin/reth/src/lib.rs
@@ -1,4 +1,4 @@
-#![warn(missing_docs, unreachable_pub)]
+#![warn(missing_docs, unreachable_pub, unused_crate_dependencies)]
 #![deny(unused_must_use, rust_2018_idioms)]
 #![doc(test(
     no_crate_inject,
diff --git a/bin/reth/src/node/mod.rs b/bin/reth/src/node/mod.rs
index 55a4a9ef368..4a3e426a96f 100644
--- a/bin/reth/src/node/mod.rs
+++ b/bin/reth/src/node/mod.rs
@@ -13,13 +13,14 @@ use events::NodeEvent;
 use eyre::Context;
 use fdlimit::raise_fd_limit;
 use futures::{pin_mut, stream::select as stream_select, Stream, StreamExt};
-use reth_consensus::beacon::BeaconConsensus;
+use reth_beacon_consensus::BeaconConsensus;
 use reth_db::{
     database::Database,
     mdbx::{Env, WriteMap},
     tables,
     transaction::DbTx,
 };
+use reth_discv4::DEFAULT_DISCOVERY_PORT;
 use reth_downloaders::{
     bodies::bodies::BodiesDownloaderBuilder,
     headers::reverse_headers::ReverseHeadersDownloaderBuilder,
@@ -36,7 +37,7 @@ use reth_network::{
     error::NetworkError, FetchClient, NetworkConfig, NetworkHandle, NetworkManager,
 };
 use reth_network_api::NetworkInfo;
-use reth_primitives::{BlockHashOrNumber, ChainSpec, Head, H256};
+use reth_primitives::{BlockHashOrNumber, ChainSpec, Head, Header, SealedHeader, H256};
 use reth_provider::{BlockProvider, HeaderProvider, ShareableDatabase};
 use reth_rpc_engine_api::{EngineApi, EngineApiHandle};
 use reth_staged_sync::{
@@ -49,10 +50,14 @@ use reth_staged_sync::{
 };
 use reth_stages::{
     prelude::*,
-    stages::{ExecutionStage, SenderRecoveryStage, TotalDifficultyStage, FINISH},
+    stages::{ExecutionStage, HeaderSyncMode, SenderRecoveryStage, TotalDifficultyStage, FINISH},
 };
 use reth_tasks::TaskExecutor;
-use std::{net::SocketAddr, path::PathBuf, sync::Arc};
+use std::{
+    net::{Ipv4Addr, SocketAddr, SocketAddrV4},
+    path::PathBuf,
+    sync::Arc,
+};
 use tokio::sync::{mpsc::unbounded_channel, watch};
 use tracing::*;
 
@@ -90,7 +95,7 @@ pub struct Command {
         default_value = "mainnet",
         value_parser = genesis_value_parser
     )]
-    chain: ChainSpec,
+    chain: Arc<ChainSpec>,
 
     /// Enable Prometheus metrics.
     ///
@@ -101,6 +106,12 @@ pub struct Command {
     #[clap(flatten)]
     network: NetworkArgs,
 
+    /// Prompt the downloader to download blocks one at a time.
+    ///
+    /// NOTE: This is for testing purposes only.
+    #[arg(long = "debug.continuous", help_heading = "Debug")]
+    continuous: bool,
+
     /// Set the chain tip manually for testing purposes.
     ///
     /// NOTE: This is a temporary flag
@@ -143,7 +154,7 @@ impl Command {
 
         init_genesis(db.clone(), self.chain.clone())?;
 
-        let (consensus, forkchoice_state_tx) = self.init_consensus()?;
+        let consensus = Arc::new(BeaconConsensus::new(self.chain.clone())) as Arc<dyn Consensus>;
         info!(target: "reth::cli", "Consensus engine initialized");
 
         self.init_trusted_nodes(&mut config);
@@ -159,12 +170,22 @@ impl Command {
 
         let _rpc_server = self
             .rpc
-            .start_rpc_server(shareable_db.clone(), test_transaction_pool.clone(), network.clone())
+            .start_rpc_server(
+                shareable_db.clone(),
+                test_transaction_pool.clone(),
+                network.clone(),
+                ctx.task_executor.clone(),
+            )
             .await?;
         info!(target: "reth::cli", "Started RPC server");
 
-        let engine_api_handle =
-            self.init_engine_api(Arc::clone(&db), forkchoice_state_tx, &ctx.task_executor);
+        if self.continuous {
+            info!(target: "reth::cli", "Continuous sync mode enabled");
+        }
+
+        // TODO: This will be fixed with the sync controller (https://github.com/paradigmxyz/reth/pull/1662)
+        let (tx, _rx) = watch::channel(ForkchoiceState::default());
+        let engine_api_handle = self.init_engine_api(Arc::clone(&db), tx, &ctx.task_executor);
         info!(target: "reth::cli", "Engine API handler initialized");
 
         let _auth_server = self
@@ -173,6 +194,7 @@ impl Command {
                 shareable_db,
                 test_transaction_pool,
                 network.clone(),
+                ctx.task_executor.clone(),
                 engine_api_handle,
             )
             .await?;
@@ -188,6 +210,16 @@ impl Command {
             )
             .await?;
 
+        if let Some(tip) = self.tip {
+            pipeline.set_tip(tip);
+            debug!(target: "reth::cli", %tip, "Tip manually set");
+        } else {
+            let warn_msg = "No tip specified. \
+                    reth cannot communicate with consensus clients, \
+                    so a tip must manually be provided for the online stages with --debug.tip <HASH>.";
+            warn!(target: "reth::cli", warn_msg);
+        }
+
         ctx.task_executor.spawn(events::handle_events(Some(network.clone()), events));
 
         // Run pipeline
@@ -248,6 +280,7 @@ impl Command {
                 network.clone(),
                 consensus,
                 max_block,
+                self.continuous,
             )
             .await?;
 
@@ -282,26 +315,6 @@ impl Command {
         }
     }
 
-    fn init_consensus(&self) -> eyre::Result<(Arc<dyn Consensus>, watch::Sender<ForkchoiceState>)> {
-        let (consensus, notifier) = BeaconConsensus::builder().build(self.chain.clone());
-
-        if let Some(tip) = self.tip {
-            debug!(target: "reth::cli", %tip, "Tip manually set");
-            notifier.send(ForkchoiceState {
-                head_block_hash: tip,
-                safe_block_hash: tip,
-                finalized_block_hash: tip,
-            })?;
-        } else {
-            let warn_msg = "No tip specified. \
-            reth cannot communicate with consensus clients, \
-            so a tip must manually be provided for the online stages with --debug.tip <HASH>.";
-            warn!(target: "reth::cli", warn_msg);
-        }
-
-        Ok((consensus, notifier))
-    }
-
     fn init_engine_api(
         &self,
         db: Arc<Env<WriteMap>>,
@@ -315,7 +328,7 @@ impl Command {
             message_rx,
             forkchoice_state_tx,
         );
-        task_executor.spawn(engine_api);
+        task_executor.spawn_critical("engine API task", engine_api);
         message_tx
     }
 
@@ -336,11 +349,11 @@ impl Command {
             NetworkManager::builder(config).await?.request_handler(client).split_with_handle();
 
         let known_peers_file = self.network.persistent_peers_file();
-        task_executor.spawn_critical_with_signal("p2p network task", |shutdown| async move {
-            run_network_until_shutdown(shutdown, network, known_peers_file).await
+        task_executor.spawn_critical_with_signal("p2p network task", |shutdown| {
+            run_network_until_shutdown(shutdown, network, known_peers_file)
         });
 
-        task_executor.spawn_critical("p2p eth request handler", async move { eth.await });
+        task_executor.spawn_critical("p2p eth request handler", eth);
 
         // TODO spawn pool
 
@@ -380,17 +393,38 @@ impl Command {
         fetch_client: FetchClient,
         tip: H256,
     ) -> Result<u64, reth_interfaces::Error> {
-        if let Some(number) = db.view(|tx| tx.get::<tables::HeaderNumbers>(tip))?? {
-            info!(target: "reth::cli", ?tip, number, "Successfully looked up tip block number in the database");
-            return Ok(number)
+        Ok(self.fetch_tip(db, fetch_client, BlockHashOrNumber::Hash(tip)).await?.number)
+    }
+
+    /// Attempt to look up the block with the given number and return the header.
+    ///
+    /// NOTE: The download is attempted with infinite retries.
+    async fn fetch_tip(
+        &self,
+        db: Arc<Env<WriteMap>>,
+        fetch_client: FetchClient,
+        tip: BlockHashOrNumber,
+    ) -> Result<SealedHeader, reth_interfaces::Error> {
+        let header = db.view(|tx| -> Result<Option<Header>, reth_db::Error> {
+            let number = match tip {
+                BlockHashOrNumber::Hash(hash) => tx.get::<tables::HeaderNumbers>(hash)?,
+                BlockHashOrNumber::Number(number) => Some(number),
+            };
+            Ok(number.map(|number| tx.get::<tables::Headers>(number)).transpose()?.flatten())
+        })??;
+
+        // try to look up the header in the database
+        if let Some(header) = header {
+            info!(target: "reth::cli", ?tip, "Successfully looked up tip block in the database");
+            return Ok(header.seal_slow())
         }
 
-        info!(target: "reth::cli", ?tip, "Fetching tip block number from the network.");
+        info!(target: "reth::cli", ?tip, "Fetching tip block from the network.");
         loop {
-            match get_single_header(fetch_client.clone(), BlockHashOrNumber::Hash(tip)).await {
+            match get_single_header(fetch_client.clone(), tip).await {
                 Ok(tip_header) => {
-                    info!(target: "reth::cli", ?tip, number = tip_header.number, "Successfully fetched tip block number");
-                    return Ok(tip_header.number)
+                    info!(target: "reth::cli", ?tip, "Successfully fetched tip");
+                    return Ok(tip_header)
                 }
                 Err(error) => {
                     error!(target: "reth::cli", %error, "Failed to fetch the tip. Retrying...");
@@ -411,9 +445,14 @@ impl Command {
             .network_config(config, self.chain.clone())
             .with_task_executor(Box::new(executor))
             .set_head(head)
+            .listener_addr(SocketAddr::V4(SocketAddrV4::new(
+                Ipv4Addr::UNSPECIFIED,
+                self.network.discovery.port.unwrap_or(DEFAULT_DISCOVERY_PORT),
+            )))
             .build(ShareableDatabase::new(db, self.chain.clone()))
     }
 
+    #[allow(clippy::too_many_arguments)]
     async fn build_pipeline<H, B, U>(
         &self,
         config: &Config,
@@ -422,6 +461,7 @@ impl Command {
         updater: U,
         consensus: &Arc<dyn Consensus>,
         max_block: Option<u64>,
+        continuous: bool,
     ) -> eyre::Result<Pipeline<Env<WriteMap>, U>>
     where
         H: HeaderDownloader + 'static,
@@ -437,21 +477,31 @@ impl Command {
             builder = builder.with_max_block(max_block)
         }
 
+        let (tip_tx, tip_rx) = watch::channel(H256::zero());
+        let factory = reth_executor::Factory::new(self.chain.clone());
+
+        let header_mode =
+            if continuous { HeaderSyncMode::Continuous } else { HeaderSyncMode::Tip(tip_rx) };
         let pipeline = builder
             .with_sync_state_updater(updater.clone())
+            .with_tip_sender(tip_tx)
             .add_stages(
-                DefaultStages::new(consensus.clone(), header_downloader, body_downloader, updater)
-                    .set(TotalDifficultyStage {
-                        chain_spec: self.chain.clone(),
-                        commit_threshold: stage_conf.total_difficulty.commit_threshold,
-                    })
-                    .set(SenderRecoveryStage {
-                        commit_threshold: stage_conf.sender_recovery.commit_threshold,
-                    })
-                    .set(ExecutionStage {
-                        chain_spec: self.chain.clone(),
-                        commit_threshold: stage_conf.execution.commit_threshold,
-                    }),
+                DefaultStages::new(
+                    header_mode,
+                    consensus.clone(),
+                    header_downloader,
+                    body_downloader,
+                    updater,
+                    factory.clone(),
+                )
+                .set(
+                    TotalDifficultyStage::new(consensus.clone())
+                        .with_commit_threshold(stage_conf.total_difficulty.commit_threshold),
+                )
+                .set(SenderRecoveryStage {
+                    commit_threshold: stage_conf.sender_recovery.commit_threshold,
+                })
+                .set(ExecutionStage::new(factory, stage_conf.execution.commit_threshold)),
             )
             .build();
 
@@ -479,7 +529,8 @@ async fn run_network_until_shutdown<C>(
         let known_peers = network.all_peers().collect::<Vec<_>>();
         if let Ok(known_peers) = serde_json::to_string_pretty(&known_peers) {
             trace!(target : "reth::cli", peers_file =?file_path, num_peers=%known_peers.len(), "Saving current peers");
-            match std::fs::write(&file_path, known_peers) {
+            let parent_dir = file_path.parent().map(std::fs::create_dir_all).transpose();
+            match parent_dir.and_then(|_| std::fs::write(&file_path, known_peers)) {
                 Ok(_) => {
                     info!(target: "reth::cli", peers_file=?file_path, "Wrote network peers to file");
                 }
@@ -495,6 +546,12 @@ async fn run_network_until_shutdown<C>(
 mod tests {
     use super::*;
 
+    #[test]
+    fn parse_help_node_command() {
+        let err = Command::try_parse_from(["reth", "--help"]).unwrap_err();
+        assert_eq!(err.kind(), clap::error::ErrorKind::DisplayHelp);
+    }
+
     #[test]
     fn parse_common_node_command_chain_args() {
         for chain in ["mainnet", "sepolia", "goerli"] {
diff --git a/bin/reth/src/p2p/mod.rs b/bin/reth/src/p2p/mod.rs
index d8b27777ba5..44960d76c66 100644
--- a/bin/reth/src/p2p/mod.rs
+++ b/bin/reth/src/p2p/mod.rs
@@ -39,7 +39,7 @@ pub struct Command {
         default_value = "mainnet",
         value_parser = chain_spec_value_parser
     )]
-    chain: ChainSpec,
+    chain: Arc<ChainSpec>,
 
     /// Disable the discovery service.
     #[command(flatten)]
@@ -137,7 +137,7 @@ impl Command {
                 };
                 let (_, result) = (move || {
                     let client = fetch_client.clone();
-                    async move { client.get_block_bodies(vec![hash]).await }
+                    client.get_block_bodies(vec![hash])
                 })
                 .retry(&backoff)
                 .notify(|err, _| println!("Error requesting block: {err}. Retrying..."))
diff --git a/bin/reth/src/runner.rs b/bin/reth/src/runner.rs
index 84afc3847f0..d0a171f33df 100644
--- a/bin/reth/src/runner.rs
+++ b/bin/reth/src/runner.rs
@@ -37,12 +37,17 @@ impl CliRunner {
         // fires the shutdown signal to all tasks spawned via the task executor
         drop(task_manager);
 
+        // drop the tokio runtime on a separate thread because drop blocks until its pools
+        // (including blocking pool) are shutdown. In other words `drop(tokio_runtime)` would block
+        // the current thread but we want to exit right away.
+        std::thread::spawn(move || drop(tokio_runtime));
+
         // give all tasks that are now being shut down some time to finish before tokio leaks them
         // see [Runtime::shutdown_timeout](tokio::runtime::Runtime::shutdown_timeout)
         // TODO: enable this again, when pipeline/stages are not longer blocking tasks
-        std::process::exit(0);
         // warn!(target: "reth::cli", "Received shutdown signal, waiting up to 30 seconds for
         // tasks."); tokio_runtime.shutdown_timeout(Duration::from_secs(30));
+        Ok(())
     }
 
     /// Executes a regular future until completion or until external signal received.
diff --git a/bin/reth/src/stage/mod.rs b/bin/reth/src/stage/mod.rs
index 8153567a4fd..b57bb7f4544 100644
--- a/bin/reth/src/stage/mod.rs
+++ b/bin/reth/src/stage/mod.rs
@@ -7,7 +7,7 @@ use crate::{
     prometheus_exporter,
 };
 use clap::{Parser, ValueEnum};
-use reth_consensus::beacon::BeaconConsensus;
+use reth_beacon_consensus::BeaconConsensus;
 use reth_downloaders::bodies::bodies::BodiesDownloaderBuilder;
 use reth_primitives::ChainSpec;
 use reth_provider::{ShareableDatabase, Transaction};
@@ -54,7 +54,7 @@ pub struct Command {
         default_value = "mainnet",
         value_parser = chain_spec_value_parser
     )]
-    chain: ChainSpec,
+    chain: Arc<ChainSpec>,
 
     /// Enable Prometheus metrics.
     ///
@@ -123,7 +123,7 @@ impl Command {
 
         match self.stage {
             StageEnum::Bodies => {
-                let (consensus, _) = BeaconConsensus::builder().build(self.chain.clone());
+                let consensus = Arc::new(BeaconConsensus::new(self.chain.clone()));
 
                 let mut config = config;
                 config.peers.connect_trusted_nodes_only = self.network.trusted_only;
@@ -171,8 +171,9 @@ impl Command {
                 stage.execute(&mut tx, input).await?;
             }
             StageEnum::Execution => {
-                let mut stage =
-                    ExecutionStage { chain_spec: self.chain.clone(), commit_threshold: num_blocks };
+                let factory = reth_executor::Factory::new(self.chain.clone());
+                let mut stage = ExecutionStage::new(factory, 10_000);
+                stage.commit_threshold = num_blocks;
                 if !self.skip_unwind {
                     stage.unwind(&mut tx, unwind).await?;
                 }
diff --git a/bin/reth/src/test_eth_chain/runner.rs b/bin/reth/src/test_eth_chain/runner.rs
index 45c1225bf26..277c22d74bf 100644
--- a/bin/reth/src/test_eth_chain/runner.rs
+++ b/bin/reth/src/test_eth_chain/runner.rs
@@ -10,8 +10,8 @@ use reth_db::{
     Error as DbError,
 };
 use reth_primitives::{
-    keccak256, Account as RethAccount, Address, ChainSpec, ForkCondition, Hardfork, JsonU256,
-    SealedBlock, SealedHeader, StorageEntry, H256, U256,
+    keccak256, Account as RethAccount, Address, Bytecode, ChainSpec, ForkCondition, Hardfork,
+    JsonU256, SealedBlock, SealedHeader, StorageEntry, H256, U256,
 };
 use reth_provider::Transaction;
 use reth_rlp::Decodable;
@@ -20,6 +20,7 @@ use std::{
     collections::HashMap,
     ffi::OsStr,
     path::{Path, PathBuf},
+    sync::Arc,
 };
 use tracing::{debug, trace};
 
@@ -139,19 +140,19 @@ pub async fn run_test(path: PathBuf) -> eyre::Result<TestOutcome> {
         // insert genesis
         let header: SealedHeader = suite.genesis_block_header.into();
         let genesis_block = SealedBlock { header, body: vec![], ommers: vec![], withdrawals: None };
-        reth_provider::insert_canonical_block(&tx, &genesis_block, has_block_reward)?;
+        reth_provider::insert_canonical_block(&tx, genesis_block, None, has_block_reward)?;
 
         let mut last_block = None;
         suite.blocks.iter().try_for_each(|block| -> eyre::Result<()> {
             let decoded = SealedBlock::decode(&mut block.rlp.as_ref())?;
-            reth_provider::insert_canonical_block(&tx, &decoded, has_block_reward)?;
             last_block = Some(decoded.number);
+            reth_provider::insert_canonical_block(&tx, decoded, None, has_block_reward)?;
             Ok(())
         })?;
 
         pre_state.into_iter().try_for_each(|(address, account)| -> eyre::Result<()> {
             let has_code = !account.code.is_empty();
-            let code_hash = if has_code { Some(keccak256(&account.code)) } else { None };
+            let code_hash = has_code.then(|| keccak256(&account.code));
             tx.put::<tables::PlainAccountState>(
                 address,
                 RethAccount {
@@ -161,7 +162,7 @@ pub async fn run_test(path: PathBuf) -> eyre::Result<TestOutcome> {
                 },
             )?;
             if let Some(code_hash) = code_hash {
-                tx.put::<tables::Bytecodes>(code_hash, account.code.to_vec())?;
+                tx.put::<tables::Bytecodes>(code_hash, Bytecode::new_raw(account.code.0))?;
             }
             account.storage.iter().try_for_each(|(k, v)| {
                 trace!(target: "reth::cli", ?address, key = ?k.0, value = ?v.0, "Update storage");
@@ -193,7 +194,8 @@ pub async fn run_test(path: PathBuf) -> eyre::Result<TestOutcome> {
 
         // Initialize the execution stage
         // Hardcode the chain_id to Ethereum 1.
-        let mut stage = ExecutionStage::new(chain_spec, 1000);
+        let factory = reth_executor::Factory::new(Arc::new(chain_spec));
+        let mut stage = ExecutionStage::new(factory, 1_000);
 
         // Call execution stage
         let input = ExecInput {
diff --git a/crates/consensus/Cargo.toml b/crates/consensus/Cargo.toml
index bd742d0bed0..fc76b357ab2 100644
--- a/crates/consensus/Cargo.toml
+++ b/crates/consensus/Cargo.toml
@@ -21,4 +21,4 @@ reth-provider = { path = "../storage/provider", features = ["test-utils"] }
 assert_matches = "1.5.0"
 
 [features]
-optimism = []
\ No newline at end of file
+optimism = ["reth-primitives/optimism"]
diff --git a/crates/consensus/beacon/Cargo.toml b/crates/consensus/beacon/Cargo.toml
new file mode 100644
index 00000000000..1ff30c99f1f
--- /dev/null
+++ b/crates/consensus/beacon/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "reth-beacon-consensus"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/paradigmxyz/reth"
+readme = "README.md"
+
+[dependencies]
+# reth 
+reth-consensus-common = { path = "../common" }
+reth-primitives = { path = "../../primitives" }
+reth-interfaces = { path = "../../interfaces" }
+
+[dev-dependencies]
+reth-interfaces = { path = "../../interfaces", features = ["test-utils"] }
diff --git a/crates/consensus/src/beacon/beacon_consensus.rs b/crates/consensus/beacon/src/beacon_consensus.rs
similarity index 62%
rename from crates/consensus/src/beacon/beacon_consensus.rs
rename to crates/consensus/beacon/src/beacon_consensus.rs
index 779073d5031..2018d320252 100644
--- a/crates/consensus/src/beacon/beacon_consensus.rs
+++ b/crates/consensus/beacon/src/beacon_consensus.rs
@@ -1,69 +1,56 @@
 //! Consensus for ethereum network
-use crate::validation;
-use reth_interfaces::consensus::{Consensus, Error, ForkchoiceState};
+use reth_consensus_common::validation;
+use reth_interfaces::consensus::{Consensus, ConsensusError};
 use reth_primitives::{ChainSpec, Hardfork, SealedBlock, SealedHeader, EMPTY_OMMER_ROOT, U256};
-use tokio::sync::watch;
-
-use super::BeaconConsensusBuilder;
+use std::sync::Arc;
 
 /// Ethereum beacon consensus
 ///
-/// This consensus engine does basic checks as outlined in the execution specs,
-/// but otherwise defers consensus on what the current chain is to a consensus client.
+/// This consensus engine does basic checks as outlined in the execution specs.
 #[derive(Debug)]
 pub struct BeaconConsensus {
-    /// Watcher over the forkchoice state
-    forkchoice_state_rx: watch::Receiver<ForkchoiceState>,
     /// Configuration
-    chain_spec: ChainSpec,
+    chain_spec: Arc<ChainSpec>,
 }
 
 impl BeaconConsensus {
     /// Create a new instance of [BeaconConsensus]
-    pub fn new(
-        chain_spec: ChainSpec,
-        forkchoice_state_rx: watch::Receiver<ForkchoiceState>,
-    ) -> Self {
-        Self { chain_spec, forkchoice_state_rx }
-    }
-
-    /// Create new [BeaconConsensusBuilder].
-    pub fn builder() -> BeaconConsensusBuilder {
-        BeaconConsensusBuilder::default()
+    pub fn new(chain_spec: Arc<ChainSpec>) -> Self {
+        Self { chain_spec }
     }
 }
 
 impl Consensus for BeaconConsensus {
-    fn fork_choice_state(&self) -> watch::Receiver<ForkchoiceState> {
-        self.forkchoice_state_rx.clone()
-    }
-
     fn pre_validate_header(
         &self,
         header: &SealedHeader,
         parent: &SealedHeader,
-    ) -> Result<(), Error> {
+    ) -> Result<(), ConsensusError> {
         validation::validate_header_standalone(header, &self.chain_spec)?;
         validation::validate_header_regarding_parent(parent, header, &self.chain_spec)?;
 
         Ok(())
     }
 
-    fn validate_header(&self, header: &SealedHeader, total_difficulty: U256) -> Result<(), Error> {
+    fn validate_header(
+        &self,
+        header: &SealedHeader,
+        total_difficulty: U256,
+    ) -> Result<(), ConsensusError> {
         if self.chain_spec.fork(Hardfork::Paris).active_at_ttd(total_difficulty, header.difficulty)
         {
             // EIP-3675: Upgrade consensus to Proof-of-Stake:
             // https://eips.ethereum.org/EIPS/eip-3675#replacing-difficulty-with-0
             if header.difficulty != U256::ZERO {
-                return Err(Error::TheMergeDifficultyIsNotZero)
+                return Err(ConsensusError::TheMergeDifficultyIsNotZero)
             }
 
             if header.nonce != 0 {
-                return Err(Error::TheMergeNonceIsNotZero)
+                return Err(ConsensusError::TheMergeNonceIsNotZero)
             }
 
             if header.ommers_hash != EMPTY_OMMER_ROOT {
-                return Err(Error::TheMergeOmmerRootIsNotEmpty)
+                return Err(ConsensusError::TheMergeOmmerRootIsNotEmpty)
             }
 
             // mixHash is used instead of difficulty inside EVM
@@ -77,7 +64,7 @@ impl Consensus for BeaconConsensus {
         Ok(())
     }
 
-    fn pre_validate_block(&self, block: &SealedBlock) -> Result<(), Error> {
+    fn pre_validate_block(&self, block: &SealedBlock) -> Result<(), ConsensusError> {
         validation::validate_block_standalone(block, &self.chain_spec)
     }
 
@@ -88,15 +75,15 @@ impl Consensus for BeaconConsensus {
 
 #[cfg(test)]
 mod test {
+    use super::BeaconConsensus;
     use reth_interfaces::consensus::Consensus;
     use reth_primitives::{ChainSpecBuilder, U256};
-
-    use super::BeaconConsensus;
+    use std::sync::Arc;
 
     #[test]
     fn test_has_block_reward_before_paris() {
-        let chain_spec = ChainSpecBuilder::mainnet().build();
-        let (consensus, _) = BeaconConsensus::builder().build(chain_spec);
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().build());
+        let consensus = BeaconConsensus::new(chain_spec);
         assert!(consensus.has_block_reward(U256::ZERO, U256::ZERO));
     }
 }
diff --git a/crates/consensus/beacon/src/lib.rs b/crates/consensus/beacon/src/lib.rs
new file mode 100644
index 00000000000..04d5af32876
--- /dev/null
+++ b/crates/consensus/beacon/src/lib.rs
@@ -0,0 +1,10 @@
+#![warn(missing_docs, unreachable_pub, unused_crate_dependencies)]
+#![deny(unused_must_use, rust_2018_idioms)]
+#![doc(test(
+    no_crate_inject,
+    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
+))]
+//! Beacon consensus implementation.
+
+mod beacon_consensus;
+pub use beacon_consensus::BeaconConsensus;
diff --git a/crates/consensus/common/Cargo.toml b/crates/consensus/common/Cargo.toml
new file mode 100644
index 00000000000..f1f79e5d70a
--- /dev/null
+++ b/crates/consensus/common/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "reth-consensus-common"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/paradigmxyz/reth"
+readme = "README.md"
+
+[dependencies]
+# reth 
+reth-primitives = { path = "../../primitives" }
+reth-interfaces = { path = "../../interfaces" }
+reth-provider = { path = "../../storage/provider" }
+
+
+[dev-dependencies]
+reth-interfaces = { path = "../../interfaces", features = ["test-utils"] }
+reth-provider = { path = "../../storage/provider", features = ["test-utils"] }
+assert_matches = "1.5.0"
+mockall = "0.11.3"
+
+[features]
+optimism = ["reth-primitives/optimism"]
diff --git a/crates/consensus/src/lib.rs b/crates/consensus/common/src/lib.rs
similarity index 76%
rename from crates/consensus/src/lib.rs
rename to crates/consensus/common/src/lib.rs
index 35bf33b0334..4b1917d612d 100644
--- a/crates/consensus/src/lib.rs
+++ b/crates/consensus/common/src/lib.rs
@@ -4,10 +4,8 @@
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
 ))]
-//! Consensus algorithms for Ethereum.
 
-/// Beacon consensus implementation.
-pub mod beacon;
+//! Commonly used consensus methods.
 
 /// Collection of consensus validation methods.
 pub mod validation;
diff --git a/crates/consensus/src/validation.rs b/crates/consensus/common/src/validation.rs
similarity index 73%
rename from crates/consensus/src/validation.rs
rename to crates/consensus/common/src/validation.rs
index 46363405bac..3e3eee7fa0e 100644
--- a/crates/consensus/src/validation.rs
+++ b/crates/consensus/common/src/validation.rs
@@ -1,17 +1,15 @@
 //! Collection of methods for block validation.
-use reth_interfaces::{consensus::Error, Result as RethResult};
+use reth_interfaces::{consensus::ConsensusError, Result as RethResult};
 use reth_primitives::{
-    BlockNumber, ChainSpec, Hardfork, Header, SealedBlock, SealedHeader, Transaction,
-    TransactionSignedEcRecovered, TxEip1559, TxEip2930, TxLegacy,
+    constants, BlockNumber, ChainSpec, Hardfork, Header, InvalidTransactionError, SealedBlock,
+    SealedHeader, Transaction, TransactionSignedEcRecovered, TxEip1559, TxEip2930, TxLegacy,
 };
-use reth_provider::{AccountProvider, HeaderProvider};
+use reth_provider::{AccountProvider, HeaderProvider, WithdrawalsProvider};
 use std::{
     collections::{hash_map::Entry, HashMap},
     time::SystemTime,
 };
 
-use reth_primitives::constants;
-
 #[cfg(feature = "optimism")]
 use reth_primitives::TxDeposit;
 
@@ -19,10 +17,10 @@ use reth_primitives::TxDeposit;
 pub fn validate_header_standalone(
     header: &SealedHeader,
     chain_spec: &ChainSpec,
-) -> Result<(), Error> {
+) -> Result<(), ConsensusError> {
     // Gas used needs to be less then gas limit. Gas used is going to be check after execution.
     if header.gas_used > header.gas_limit {
-        return Err(Error::HeaderGasUsedExceedsGasLimit {
+        return Err(ConsensusError::HeaderGasUsedExceedsGasLimit {
             gas_used: header.gas_used,
             gas_limit: header.gas_limit,
         })
@@ -32,31 +30,34 @@ pub fn validate_header_standalone(
     let present_timestamp =
         SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs();
     if header.timestamp > present_timestamp {
-        return Err(Error::TimestampIsInFuture { timestamp: header.timestamp, present_timestamp })
+        return Err(ConsensusError::TimestampIsInFuture {
+            timestamp: header.timestamp,
+            present_timestamp,
+        })
     }
 
     // From yellow paper: extraData: An arbitrary byte array containing data
     // relevant to this block. This must be 32 bytes or fewer; formally Hx.
     if header.extra_data.len() > 32 {
-        return Err(Error::ExtraDataExceedsMax { len: header.extra_data.len() })
+        return Err(ConsensusError::ExtraDataExceedsMax { len: header.extra_data.len() })
     }
 
     // Check if base fee is set.
     if chain_spec.fork(Hardfork::London).active_at_block(header.number) &&
         header.base_fee_per_gas.is_none()
     {
-        return Err(Error::BaseFeeMissing)
+        return Err(ConsensusError::BaseFeeMissing)
     }
 
     // EIP-4895: Beacon chain push withdrawals as operations
     if chain_spec.fork(Hardfork::Shanghai).active_at_timestamp(header.timestamp) &&
         header.withdrawals_root.is_none()
     {
-        return Err(Error::WithdrawalsRootMissing)
+        return Err(ConsensusError::WithdrawalsRootMissing)
     } else if !chain_spec.fork(Hardfork::Shanghai).active_at_timestamp(header.timestamp) &&
         header.withdrawals_root.is_some()
     {
-        return Err(Error::WithdrawalsRootUnexpected)
+        return Err(ConsensusError::WithdrawalsRootUnexpected)
     }
 
     Ok(())
@@ -70,26 +71,21 @@ pub fn validate_transaction_regarding_header(
     chain_spec: &ChainSpec,
     at_block_number: BlockNumber,
     base_fee: Option<u64>,
-) -> Result<(), Error> {
+) -> Result<(), ConsensusError> {
     let chain_id = match transaction {
-        #[cfg(feature = "optimism")]
-        Transaction::Deposit(TxDeposit { .. }) => {
-            // TODO: get the chain id
-            None
-        }
         Transaction::Legacy(TxLegacy { chain_id, .. }) => {
             // EIP-155: Simple replay attack protection: https://eips.ethereum.org/EIPS/eip-155
             if chain_spec.fork(Hardfork::SpuriousDragon).active_at_block(at_block_number) &&
                 chain_id.is_some()
             {
-                return Err(Error::TransactionOldLegacyChainId)
+                return Err(InvalidTransactionError::OldLegacyChainId.into())
             }
             *chain_id
         }
         Transaction::Eip2930(TxEip2930 { chain_id, .. }) => {
             // EIP-2930: Optional access lists: https://eips.ethereum.org/EIPS/eip-2930 (New transaction type)
             if !chain_spec.fork(Hardfork::Berlin).active_at_block(at_block_number) {
-                return Err(Error::TransactionEip2930Disabled)
+                return Err(InvalidTransactionError::Eip2930Disabled.into())
             }
             Some(*chain_id)
         }
@@ -101,28 +97,33 @@ pub fn validate_transaction_regarding_header(
         }) => {
             // EIP-1559: Fee market change for ETH 1.0 chain https://eips.ethereum.org/EIPS/eip-1559
             if !chain_spec.fork(Hardfork::Berlin).active_at_block(at_block_number) {
-                return Err(Error::TransactionEip1559Disabled)
+                return Err(InvalidTransactionError::Eip1559Disabled.into())
             }
 
             // EIP-1559: add more constraints to the tx validation
             // https://github.com/ethereum/EIPs/pull/3594
             if max_priority_fee_per_gas > max_fee_per_gas {
-                return Err(Error::TransactionPriorityFeeMoreThenMaxFee)
+                return Err(InvalidTransactionError::PriorityFeeMoreThenMaxFee.into())
             }
 
             Some(*chain_id)
         }
+        #[cfg(feature = "optimism")]
+        Transaction::Deposit(TxDeposit { .. }) => {
+            // TODO: get the chain id
+            None
+        }
     };
     if let Some(chain_id) = chain_id {
         if chain_id != chain_spec.chain().id() {
-            return Err(Error::TransactionChainId)
+            return Err(InvalidTransactionError::ChainIdMismatch.into())
         }
     }
     // Check basefee and few checks that are related to that.
     // https://github.com/ethereum/EIPs/pull/3594
     if let Some(base_fee_per_gas) = base_fee {
         if transaction.max_fee_per_gas() < base_fee_per_gas as u128 {
-            return Err(Error::TransactionMaxFeeLessThenBaseFee)
+            return Err(InvalidTransactionError::MaxFeeLessThenBaseFee.into())
         }
     }
 
@@ -163,7 +164,10 @@ pub fn validate_all_transaction_regarding_block_and_nonces<
                 // Signer account shouldn't have bytecode. Presence of bytecode means this is a
                 // smartcontract.
                 if account.has_bytecode() {
-                    return Err(Error::SignerAccountHasBytecode.into())
+                    return Err(ConsensusError::from(
+                        InvalidTransactionError::SignerAccountHasBytecode,
+                    )
+                    .into())
                 }
                 let nonce = account.nonce;
                 entry.insert(account.nonce + 1);
@@ -173,7 +177,7 @@ pub fn validate_all_transaction_regarding_block_and_nonces<
 
         // check nonce
         if transaction.nonce() != nonce {
-            return Err(Error::TransactionNonceNotConsistent.into())
+            return Err(ConsensusError::from(InvalidTransactionError::NonceNotConsistent).into())
         }
     }
 
@@ -186,13 +190,16 @@ pub fn validate_all_transaction_regarding_block_and_nonces<
 /// - Compares the transactions root in the block header to the block body
 /// - Pre-execution transaction validation
 /// - (Optionally) Compares the receipts root in the block header to the block body
-pub fn validate_block_standalone(block: &SealedBlock, chain_spec: &ChainSpec) -> Result<(), Error> {
+pub fn validate_block_standalone(
+    block: &SealedBlock,
+    chain_spec: &ChainSpec,
+) -> Result<(), ConsensusError> {
     // Check ommers hash
     // TODO(onbjerg): This should probably be accessible directly on [Block]
     let ommers_hash =
         reth_primitives::proofs::calculate_ommers_root(block.ommers.iter().map(|h| h.as_ref()));
     if block.header.ommers_hash != ommers_hash {
-        return Err(Error::BodyOmmersHashDiff {
+        return Err(ConsensusError::BodyOmmersHashDiff {
             got: ommers_hash,
             expected: block.header.ommers_hash,
         })
@@ -202,7 +209,7 @@ pub fn validate_block_standalone(block: &SealedBlock, chain_spec: &ChainSpec) ->
     // TODO(onbjerg): This should probably be accessible directly on [Block]
     let transaction_root = reth_primitives::proofs::calculate_transaction_root(block.body.iter());
     if block.header.transactions_root != transaction_root {
-        return Err(Error::BodyTransactionRootDiff {
+        return Err(ConsensusError::BodyTransactionRootDiff {
             got: transaction_root,
             expected: block.header.transactions_root,
         })
@@ -210,13 +217,14 @@ pub fn validate_block_standalone(block: &SealedBlock, chain_spec: &ChainSpec) ->
 
     // EIP-4895: Beacon chain push withdrawals as operations
     if chain_spec.fork(Hardfork::Shanghai).active_at_timestamp(block.timestamp) {
-        let withdrawals = block.withdrawals.as_ref().ok_or(Error::BodyWithdrawalsMissing)?;
+        let withdrawals =
+            block.withdrawals.as_ref().ok_or(ConsensusError::BodyWithdrawalsMissing)?;
         let withdrawals_root =
             reth_primitives::proofs::calculate_withdrawals_root(withdrawals.iter());
         let header_withdrawals_root =
-            block.withdrawals_root.as_ref().ok_or(Error::WithdrawalsRootMissing)?;
+            block.withdrawals_root.as_ref().ok_or(ConsensusError::WithdrawalsRootMissing)?;
         if withdrawals_root != *header_withdrawals_root {
-            return Err(Error::BodyWithdrawalsRootDiff {
+            return Err(ConsensusError::BodyWithdrawalsRootDiff {
                 got: withdrawals_root,
                 expected: *header_withdrawals_root,
             })
@@ -228,7 +236,10 @@ pub fn validate_block_standalone(block: &SealedBlock, chain_spec: &ChainSpec) ->
             for withdrawal in withdrawals.iter().skip(1) {
                 let expected = prev_index + 1;
                 if expected != withdrawal.index {
-                    return Err(Error::WithdrawalIndexInvalid { got: withdrawal.index, expected })
+                    return Err(ConsensusError::WithdrawalIndexInvalid {
+                        got: withdrawal.index,
+                        expected,
+                    })
                 }
                 prev_index = withdrawal.index;
             }
@@ -269,10 +280,10 @@ pub fn validate_header_regarding_parent(
     parent: &SealedHeader,
     child: &SealedHeader,
     chain_spec: &ChainSpec,
-) -> Result<(), Error> {
+) -> Result<(), ConsensusError> {
     // Parent number is consistent.
     if parent.number + 1 != child.number {
-        return Err(Error::ParentBlockNumberMismatch {
+        return Err(ConsensusError::ParentBlockNumberMismatch {
             parent_block_number: parent.number,
             block_number: child.number,
         })
@@ -280,7 +291,7 @@ pub fn validate_header_regarding_parent(
 
     // timestamp in past check
     if child.timestamp < parent.timestamp {
-        return Err(Error::TimestampIsInPast {
+        return Err(ConsensusError::TimestampIsInPast {
             parent_timestamp: parent.timestamp,
             timestamp: child.timestamp,
         })
@@ -303,13 +314,13 @@ pub fn validate_header_regarding_parent(
     // Check gas limit, max diff between child/parent gas_limit should be  max_diff=parent_gas/1024
     if child.gas_limit > parent_gas_limit {
         if child.gas_limit - parent_gas_limit >= parent_gas_limit / 1024 {
-            return Err(Error::GasLimitInvalidIncrease {
+            return Err(ConsensusError::GasLimitInvalidIncrease {
                 parent_gas_limit,
                 child_gas_limit: child.gas_limit,
             })
         }
     } else if parent_gas_limit - child.gas_limit >= parent_gas_limit / 1024 {
-        return Err(Error::GasLimitInvalidDecrease {
+        return Err(ConsensusError::GasLimitInvalidDecrease {
             parent_gas_limit,
             child_gas_limit: child.gas_limit,
         })
@@ -317,7 +328,7 @@ pub fn validate_header_regarding_parent(
 
     // EIP-1559 check base fee
     if chain_spec.fork(Hardfork::London).active_at_block(child.number) {
-        let base_fee = child.base_fee_per_gas.ok_or(Error::BaseFeeMissing)?;
+        let base_fee = child.base_fee_per_gas.ok_or(ConsensusError::BaseFeeMissing)?;
 
         let expected_base_fee =
             if chain_spec.fork(Hardfork::London).transitions_at_block(child.number) {
@@ -327,11 +338,11 @@ pub fn validate_header_regarding_parent(
                 calculate_next_block_base_fee(
                     parent.gas_used,
                     parent.gas_limit,
-                    parent.base_fee_per_gas.ok_or(Error::BaseFeeMissing)?,
+                    parent.base_fee_per_gas.ok_or(ConsensusError::BaseFeeMissing)?,
                 )
             };
         if expected_base_fee != base_fee {
-            return Err(Error::BaseFeeDiff { expected: expected_base_fee, got: base_fee })
+            return Err(ConsensusError::BaseFeeDiff { expected: expected_base_fee, got: base_fee })
         }
     }
 
@@ -343,9 +354,10 @@ pub fn validate_header_regarding_parent(
 /// Checks:
 ///  If we already know the block.
 ///  If parent is known
+///  If withdarwals are valid
 ///
 /// Returns parent block header
-pub fn validate_block_regarding_chain<PROV: HeaderProvider>(
+pub fn validate_block_regarding_chain<PROV: HeaderProvider + WithdrawalsProvider>(
     block: &SealedBlock,
     provider: &PROV,
 ) -> RethResult<SealedHeader> {
@@ -353,20 +365,47 @@ pub fn validate_block_regarding_chain<PROV: HeaderProvider>(
 
     // Check if block is known.
     if provider.is_known(&hash)? {
-        return Err(Error::BlockKnown { hash, number: block.header.number }.into())
+        return Err(ConsensusError::BlockKnown { hash, number: block.header.number }.into())
     }
 
     // Check if parent is known.
     let parent = provider
         .header(&block.parent_hash)?
-        .ok_or(Error::ParentUnknown { hash: block.parent_hash })?;
+        .ok_or(ConsensusError::ParentUnknown { hash: block.parent_hash })?;
+
+    // Check if withdrawals are valid.
+    if let Some(withdrawals) = &block.withdrawals {
+        if !withdrawals.is_empty() {
+            let latest_withdrawal = provider.latest_withdrawal()?;
+            match latest_withdrawal {
+                Some(withdrawal) => {
+                    if withdrawal.index + 1 != withdrawals.first().unwrap().index {
+                        return Err(ConsensusError::WithdrawalIndexInvalid {
+                            got: withdrawals.first().unwrap().index,
+                            expected: withdrawal.index + 1,
+                        }
+                        .into())
+                    }
+                }
+                None => {
+                    if withdrawals.first().unwrap().index != 0 {
+                        return Err(ConsensusError::WithdrawalIndexInvalid {
+                            got: withdrawals.first().unwrap().index,
+                            expected: 0,
+                        }
+                        .into())
+                    }
+                }
+            }
+        }
+    }
 
     // Return parent header.
     Ok(parent.seal(block.parent_hash))
 }
 
 /// Full validation of block before execution.
-pub fn full_validation<Provider: HeaderProvider + AccountProvider>(
+pub fn full_validation<Provider: HeaderProvider + AccountProvider + WithdrawalsProvider>(
     block: &SealedBlock,
     provider: Provider,
     chain_spec: &ChainSpec,
@@ -380,7 +419,7 @@ pub fn full_validation<Provider: HeaderProvider + AccountProvider>(
     let transactions = block
         .body
         .iter()
-        .map(|tx| tx.try_ecrecovered().ok_or(Error::TransactionSignerRecoveryError))
+        .map(|tx| tx.try_ecrecovered().ok_or(ConsensusError::TransactionSignerRecoveryError))
         .collect::<Result<Vec<_>, _>>()?;
 
     validate_all_transaction_regarding_block_and_nonces(
@@ -396,10 +435,11 @@ pub fn full_validation<Provider: HeaderProvider + AccountProvider>(
 mod tests {
     use super::*;
     use assert_matches::assert_matches;
-    use reth_interfaces::Result;
+    use mockall::mock;
+    use reth_interfaces::{Error::Consensus, Result};
     use reth_primitives::{
-        hex_literal::hex, proofs, Account, Address, BlockHash, Bytes, ChainSpecBuilder, Header,
-        Signature, TransactionKind, TransactionSigned, Withdrawal, MAINNET, U256,
+        hex_literal::hex, proofs, Account, Address, BlockHash, BlockId, Bytes, ChainSpecBuilder,
+        Header, Signature, TransactionKind, TransactionSigned, Withdrawal, MAINNET, U256,
     };
     use std::ops::RangeBounds;
 
@@ -430,20 +470,45 @@ mod tests {
         }
     }
 
+    mock! {
+        WithdrawalsProvider {}
+
+        impl WithdrawalsProvider for WithdrawalsProvider {
+            fn latest_withdrawal(&self) -> Result<Option<Withdrawal>> ;
+
+            fn withdrawals_by_block(
+                &self,
+                _id: BlockId,
+                _timestamp: u64,
+            ) -> RethResult<Option<Vec<Withdrawal>>> ;
+        }
+    }
+
     struct Provider {
         is_known: bool,
         parent: Option<Header>,
         account: Option<Account>,
+        withdrawals_provider: MockWithdrawalsProvider,
     }
 
     impl Provider {
         /// New provider with parent
         fn new(parent: Option<Header>) -> Self {
-            Self { is_known: false, parent, account: None }
+            Self {
+                is_known: false,
+                parent,
+                account: None,
+                withdrawals_provider: MockWithdrawalsProvider::new(),
+            }
         }
         /// New provider where is_known is always true
         fn new_known() -> Self {
-            Self { is_known: true, parent: None, account: None }
+            Self {
+                is_known: true,
+                parent: None,
+                account: None,
+                withdrawals_provider: MockWithdrawalsProvider::new(),
+            }
         }
     }
 
@@ -479,6 +544,20 @@ mod tests {
         }
     }
 
+    impl WithdrawalsProvider for Provider {
+        fn latest_withdrawal(&self) -> Result<Option<Withdrawal>> {
+            self.withdrawals_provider.latest_withdrawal()
+        }
+
+        fn withdrawals_by_block(
+            &self,
+            _id: BlockId,
+            _timestamp: u64,
+        ) -> RethResult<Option<Vec<Withdrawal>>> {
+            self.withdrawals_provider.withdrawals_by_block(_id, _timestamp)
+        }
+    }
+
     fn mock_tx(nonce: u64) -> TransactionSignedEcRecovered {
         let request = Transaction::Eip2930(TxEip2930 {
             chain_id: 1u64,
@@ -520,7 +599,7 @@ mod tests {
             mix_hash: hex!("0000000000000000000000000000000000000000000000000000000000000000").into(),
             nonce: 0x0000000000000000,
             base_fee_per_gas: 0x28f0001df.into(),
-            withdrawals_root: None
+            withdrawals_root: None,
         };
         // size: 0x9b5
 
@@ -551,7 +630,7 @@ mod tests {
 
         assert_eq!(
             full_validation(&block, provider, &MAINNET),
-            Err(Error::BlockKnown { hash: block.hash(), number: block.number }.into()),
+            Err(ConsensusError::BlockKnown { hash: block.hash(), number: block.number }.into()),
             "Should fail with error"
         );
     }
@@ -587,7 +666,7 @@ mod tests {
                 provider,
                 &MAINNET,
             ),
-            Err(Error::TransactionNonceNotConsistent.into())
+            Err(ConsensusError::from(InvalidTransactionError::NonceNotConsistent).into())
         )
     }
 
@@ -606,7 +685,7 @@ mod tests {
                 provider,
                 &MAINNET,
             ),
-            Err(Error::TransactionNonceNotConsistent.into())
+            Err(ConsensusError::from(InvalidTransactionError::NonceNotConsistent).into())
         );
     }
 
@@ -644,13 +723,46 @@ mod tests {
         let block = create_block_with_withdrawals(&[100, 102]);
         assert_matches!(
             validate_block_standalone(&block, &chain_spec),
-            Err(Error::WithdrawalIndexInvalid { .. })
+            Err(ConsensusError::WithdrawalIndexInvalid { .. })
         );
         let block = create_block_with_withdrawals(&[5, 6, 7, 9]);
         assert_matches!(
             validate_block_standalone(&block, &chain_spec),
-            Err(Error::WithdrawalIndexInvalid { .. })
+            Err(ConsensusError::WithdrawalIndexInvalid { .. })
         );
+
+        let (_, parent) = mock_block();
+        let mut provider = Provider::new(Some(parent.clone()));
+        // Withdrawal index should be 0 if there are no withdrawals in the chain
+        let block = create_block_with_withdrawals(&[1, 2, 3]);
+        provider.withdrawals_provider.expect_latest_withdrawal().return_const(Ok(None));
+        assert_matches!(
+            validate_block_regarding_chain(&block, &provider),
+            Err(Consensus(ConsensusError::WithdrawalIndexInvalid { got: 1, expected: 0 }))
+        );
+        let block = create_block_with_withdrawals(&[0, 1, 2]);
+        let res = validate_block_regarding_chain(&block, &provider);
+        assert!(res.is_ok());
+
+        // Withdrawal index should be the last withdrawal index + 1
+        let mut provider = Provider::new(Some(parent));
+        let block = create_block_with_withdrawals(&[4, 5, 6]);
+        provider
+            .withdrawals_provider
+            .expect_latest_withdrawal()
+            .return_const(Ok(Some(Withdrawal { index: 2, ..Default::default() })));
+        assert_matches!(
+            validate_block_regarding_chain(&block, &provider),
+            Err(Consensus(ConsensusError::WithdrawalIndexInvalid { got: 4, expected: 3 }))
+        );
+
+        let block = create_block_with_withdrawals(&[3, 4, 5]);
+        provider
+            .withdrawals_provider
+            .expect_latest_withdrawal()
+            .return_const(Ok(Some(Withdrawal { index: 2, ..Default::default() })));
+        let res = validate_block_regarding_chain(&block, &provider);
+        assert!(res.is_ok());
     }
 
     #[test]
diff --git a/crates/consensus/src/beacon/builder.rs b/crates/consensus/src/beacon/builder.rs
deleted file mode 100644
index d3f2bd97b45..00000000000
--- a/crates/consensus/src/beacon/builder.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use super::BeaconConsensus;
-use reth_interfaces::consensus::ForkchoiceState;
-use reth_primitives::ChainSpec;
-use std::sync::Arc;
-use tokio::sync::watch;
-
-/// TODO:
-#[derive(Debug, Default)]
-pub struct BeaconConsensusBuilder;
-
-impl BeaconConsensusBuilder {
-    /// Create new instance of [BeaconConsensus] and forkchoice notifier. Internally, creates a
-    /// [watch::channel] for updating the forkchoice state.
-    pub fn build(
-        self,
-        chain_spec: ChainSpec,
-    ) -> (Arc<BeaconConsensus>, watch::Sender<ForkchoiceState>) {
-        let (forkchoice_state_tx, forkchoice_state_rx) = watch::channel(ForkchoiceState::default());
-        let inner = Arc::new(BeaconConsensus::new(chain_spec, forkchoice_state_rx));
-        (inner, forkchoice_state_tx)
-    }
-}
diff --git a/crates/consensus/src/beacon/mod.rs b/crates/consensus/src/beacon/mod.rs
deleted file mode 100644
index ec2d4ab5c15..00000000000
--- a/crates/consensus/src/beacon/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//! Beacon consensus implementation.
-
-mod beacon_consensus;
-mod builder;
-
-pub use beacon_consensus::BeaconConsensus;
-pub use builder::BeaconConsensusBuilder;
diff --git a/crates/executor/Cargo.toml b/crates/executor/Cargo.toml
index 18ff91ecfca..c57347abf5a 100644
--- a/crates/executor/Cargo.toml
+++ b/crates/executor/Cargo.toml
@@ -6,18 +6,24 @@ license = "MIT OR Apache-2.0"
 repository = "https://github.com/paradigmxyz/reth"
 readme = "README.md"
 
+[package.metadata.cargo-udeps.ignore]
+normal = [
+    # Used for diagrams in docs
+    "aquamarine",
+]
+
 [dependencies]
 # reth 
 reth-primitives = { path = "../primitives" }
 reth-interfaces = { path = "../interfaces" }
 reth-revm = { path = "../revm" }
+reth-revm-inspectors = { path = "../revm/revm-inspectors" }
 reth-rlp = { path = "../rlp" }
 reth-db = { path = "../storage/db" }
 reth-provider = { path = "../storage/provider" }
 
-revm = { version = "3.0.0"}
-# remove from reth and reexport from revm
-hashbrown = "0.13"
+# revm
+revm = { version = "3.0.0" }
 
 # common
 async-trait = "0.1.57"
@@ -26,6 +32,10 @@ auto_impl = "1.0"
 tracing = "0.1.37"
 tokio = { version = "1.21.2", features = ["sync"] }
 
+# mics
+aquamarine = "0.3.0"
+parking_lot = { version = "0.12", optional = true }
+
 triehash = "0.8"
 # See to replace hashers to simplify libraries
 plain_hasher = "0.2"
@@ -38,3 +48,10 @@ sha3 = { version = "0.10", default-features = false }
 
 [dev-dependencies]
 reth-db = { path = "../storage/db", features = ["test-utils"] }
+reth-interfaces = { path = "../interfaces", features = ["test-utils"] }
+reth-primitives = { path = "../primitives", features = ["test-utils"] }
+reth-provider = { path = "../storage/provider", features = ["test-utils"]  }
+parking_lot = "0.12"
+
+[features]
+test-utils = ["parking_lot"]
diff --git a/crates/executor/src/blockchain_tree/block_indices.rs b/crates/executor/src/blockchain_tree/block_indices.rs
new file mode 100644
index 00000000000..ba5c63fa9f2
--- /dev/null
+++ b/crates/executor/src/blockchain_tree/block_indices.rs
@@ -0,0 +1,308 @@
+//! Implementation of [`BlockIndices`] related to [`super::BlockchainTree`]
+
+use super::chain::{BlockChainId, Chain, ForkBlock};
+use reth_primitives::{BlockHash, BlockNumber, SealedBlockWithSenders};
+use std::collections::{hash_map::Entry, BTreeMap, BTreeSet, HashMap, HashSet};
+
+/// Internal indices of the blocks and chains.
+///
+/// This is main connection between blocks, chains and canonical chain.
+///
+/// It contains a list of canonical block hashes, forks to child blocks, and a mapping of block hash
+/// to chain ID.
+#[derive(Debug)]
+pub struct BlockIndices {
+    /// Last finalized block.
+    last_finalized_block: BlockNumber,
+    /// Canonical chain. Contains N number (depends on `finalization_depth`) of blocks.
+    /// These blocks are found in fork_to_child but not inside `blocks_to_chain` or
+    /// `number_to_block` as those are chain specific indices.
+    canonical_chain: BTreeMap<BlockNumber, BlockHash>,
+    /// Index needed when discarding the chain, so we can remove connected chains from tree.
+    /// NOTE: It contains just a blocks that are forks as a key and not all blocks.
+    fork_to_child: HashMap<BlockHash, HashSet<BlockHash>>,
+    /// Block hashes and side chain they belong
+    blocks_to_chain: HashMap<BlockHash, BlockChainId>,
+    /// Utility index. Block number to block hash. Can be used for
+    /// RPC to fetch all pending block in chain by its number.
+    index_number_to_block: HashMap<BlockNumber, HashSet<BlockHash>>,
+}
+
+impl BlockIndices {
+    /// Create new block indices structure
+    pub fn new(
+        last_finalized_block: BlockNumber,
+        canonical_chain: BTreeMap<BlockNumber, BlockHash>,
+    ) -> Self {
+        Self {
+            last_finalized_block,
+            canonical_chain,
+            fork_to_child: Default::default(),
+            blocks_to_chain: Default::default(),
+            index_number_to_block: Default::default(),
+        }
+    }
+
+    /// Return fork to child indices
+    pub fn fork_to_child(&self) -> &HashMap<BlockHash, HashSet<BlockHash>> {
+        &self.fork_to_child
+    }
+
+    /// Return block to chain id
+    pub fn blocks_to_chain(&self) -> &HashMap<BlockHash, BlockChainId> {
+        &self.blocks_to_chain
+    }
+
+    /// Check if block hash belongs to canonical chain.
+    pub fn is_block_hash_canonical(&self, block_hash: &BlockHash) -> bool {
+        self.canonical_chain.range(self.last_finalized_block..).any(|(_, &h)| h == *block_hash)
+    }
+
+    /// Last finalized block
+    pub fn last_finalized_block(&self) -> BlockNumber {
+        self.last_finalized_block
+    }
+
+    /// Insert non fork block.
+    pub fn insert_non_fork_block(
+        &mut self,
+        block_number: BlockNumber,
+        block_hash: BlockHash,
+        chain_id: BlockChainId,
+    ) {
+        self.index_number_to_block.entry(block_number).or_default().insert(block_hash);
+        self.blocks_to_chain.insert(block_hash, chain_id);
+    }
+
+    /// Insert block to chain and fork child indices of the new chain
+    pub fn insert_chain(&mut self, chain_id: BlockChainId, chain: &Chain) {
+        for (number, block) in chain.blocks().iter() {
+            // add block -> chain_id index
+            self.blocks_to_chain.insert(block.hash(), chain_id);
+            // add number -> block
+            self.index_number_to_block.entry(*number).or_default().insert(block.hash());
+        }
+        let first = chain.first();
+        // add parent block -> block index
+        self.fork_to_child.entry(first.parent_hash).or_default().insert(first.hash());
+    }
+
+    /// Get the chain ID the block belongs to
+    pub fn get_blocks_chain_id(&self, block: &BlockHash) -> Option<BlockChainId> {
+        self.blocks_to_chain.get(block).cloned()
+    }
+
+    /// Update all block hashes. iterate over present and new list of canonical hashes and compare
+    /// them. Remove all missmatches, disconnect them and return all chains that needs to be
+    /// removed.
+    pub fn update_block_hashes(
+        &mut self,
+        hashes: BTreeMap<u64, BlockHash>,
+    ) -> BTreeSet<BlockChainId> {
+        let mut new_hashes = hashes.iter();
+        let mut old_hashes = self.canonical_chain().clone().into_iter();
+
+        let mut remove = Vec::new();
+
+        let mut new_hash = new_hashes.next();
+        let mut old_hash = old_hashes.next();
+
+        loop {
+            let Some(old_block_value) = old_hash else {
+                // end of old_hashes canonical chain. New chain has more block then old chain.
+                break
+            };
+            let Some(new_block_value) = new_hash else  {
+                // Old canonical chain had more block than new chain.
+                // remove all present block.
+                // this is mostly not going to happen as reorg should make new chain in Tree.
+                while let Some(rem) = old_hash {
+                    remove.push(rem);
+                    old_hash = old_hashes.next();
+                }
+                break;
+            };
+            // compare old and new canonical block number
+            match new_block_value.0.cmp(&old_block_value.0) {
+                std::cmp::Ordering::Less => {
+                    // new chain has more past blocks than old chain
+                    new_hash = new_hashes.next();
+                }
+                std::cmp::Ordering::Equal => {
+                    if *new_block_value.1 != old_block_value.1 {
+                        // remove block hash as it is different
+                        remove.push(old_block_value);
+                    }
+                    new_hash = new_hashes.next();
+                    old_hash = old_hashes.next();
+                }
+                std::cmp::Ordering::Greater => {
+                    // old chain has more past blocks that new chain
+                    remove.push(old_block_value);
+                    old_hash = old_hashes.next()
+                }
+            }
+        }
+        self.canonical_chain = hashes;
+
+        remove.into_iter().fold(BTreeSet::new(), |mut fold, (number, hash)| {
+            fold.extend(self.remove_block(number, hash));
+            fold
+        })
+    }
+
+    /// Remove chain from indices and return dependent chains that needs to be removed.
+    /// Does the cleaning of the tree and removing blocks from the chain.
+    pub fn remove_chain(&mut self, chain: &Chain) -> BTreeSet<BlockChainId> {
+        let mut lose_chains = BTreeSet::new();
+        for (block_number, block) in chain.blocks().iter() {
+            let block_hash = block.hash();
+            lose_chains.extend(self.remove_block(*block_number, block_hash))
+        }
+        lose_chains
+    }
+
+    /// Remove Blocks from indices.
+    fn remove_block(
+        &mut self,
+        block_number: BlockNumber,
+        block_hash: BlockHash,
+    ) -> BTreeSet<BlockChainId> {
+        // rm number -> block
+        if let Entry::Occupied(mut entry) = self.index_number_to_block.entry(block_number) {
+            let set = entry.get_mut();
+            set.remove(&block_hash);
+            // remove set if empty
+            if set.is_empty() {
+                entry.remove();
+            }
+        }
+
+        // rm block -> chain_id
+        self.blocks_to_chain.remove(&block_hash);
+
+        // rm fork -> child
+        let removed_fork = self.fork_to_child.remove(&block_hash);
+        removed_fork
+            .map(|fork_blocks| {
+                fork_blocks
+                    .into_iter()
+                    .filter_map(|fork_child| self.blocks_to_chain.remove(&fork_child))
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Remove all blocks from canonical list and insert new blocks to it.
+    ///
+    /// It is assumed that blocks are interconnected and that they connect to canonical chain
+    pub fn canonicalize_blocks(&mut self, blocks: &BTreeMap<BlockNumber, SealedBlockWithSenders>) {
+        if blocks.is_empty() {
+            return
+        }
+
+        // Remove all blocks from canonical chain
+        let first_number = *blocks.first_key_value().unwrap().0;
+
+        // this will remove all blocks numbers that are going to be replaced.
+        self.canonical_chain.retain(|num, _| *num < first_number);
+
+        // remove them from block to chain_id index
+        blocks.iter().map(|(_, b)| (b.number, b.hash(), b.parent_hash)).for_each(
+            |(number, hash, parent_hash)| {
+                // rm block -> chain_id
+                self.blocks_to_chain.remove(&hash);
+
+                // rm number -> block
+                if let Entry::Occupied(mut entry) = self.index_number_to_block.entry(number) {
+                    let set = entry.get_mut();
+                    set.remove(&hash);
+                    // remove set if empty
+                    if set.is_empty() {
+                        entry.remove();
+                    }
+                }
+                // rm fork block -> hash
+                if let Entry::Occupied(mut entry) = self.fork_to_child.entry(parent_hash) {
+                    let set = entry.get_mut();
+                    set.remove(&hash);
+                    // remove set if empty
+                    if set.is_empty() {
+                        entry.remove();
+                    }
+                }
+            },
+        );
+
+        // insert new canonical
+        self.canonical_chain.extend(blocks.iter().map(|(number, block)| (*number, block.hash())))
+    }
+
+    /// this is function that is going to remove N number of last canonical hashes.
+    ///
+    /// NOTE: This is not safe standalone, as it will not disconnect
+    /// blocks that deppends on unwinded canonical chain. And should be
+    /// used when canonical chain is reinserted inside Tree.
+    pub(crate) fn unwind_canonical_chain(&mut self, unwind_to: BlockNumber) {
+        // this will remove all blocks numbers that are going to be replaced.
+        self.canonical_chain.retain(|num, _| *num <= unwind_to);
+    }
+
+    /// Used for finalization of block.
+    /// Return list of chains for removal that depend on finalized canonical chain.
+    pub fn finalize_canonical_blocks(
+        &mut self,
+        finalized_block: BlockNumber,
+        num_of_additional_canonical_hashes_to_retain: u64,
+    ) -> BTreeSet<BlockChainId> {
+        // get finalized chains. blocks between [self.last_finalized,finalized_block).
+        // Dont remove finalized_block, as sidechain can point to it.
+        let finalized_blocks: Vec<BlockHash> = self
+            .canonical_chain
+            .iter()
+            .filter(|(&number, _)| number >= self.last_finalized_block && number < finalized_block)
+            .map(|(_, hash)| *hash)
+            .collect();
+
+        // remove unneeded canonical hashes.
+        let remove_until =
+            finalized_block.saturating_sub(num_of_additional_canonical_hashes_to_retain);
+        self.canonical_chain.retain(|&number, _| number >= remove_until);
+
+        let mut lose_chains = BTreeSet::new();
+
+        for block_hash in finalized_blocks.into_iter() {
+            // there is a fork block.
+            if let Some(fork_blocks) = self.fork_to_child.remove(&block_hash) {
+                lose_chains = fork_blocks.into_iter().fold(lose_chains, |mut fold, fork_child| {
+                    if let Some(lose_chain) = self.blocks_to_chain.remove(&fork_child) {
+                        fold.insert(lose_chain);
+                    }
+                    fold
+                });
+            }
+        }
+
+        // set last finalized block.
+        self.last_finalized_block = finalized_block;
+
+        lose_chains
+    }
+
+    /// get canonical hash
+    pub fn canonical_hash(&self, block_number: &BlockNumber) -> Option<BlockHash> {
+        self.canonical_chain.get(block_number).cloned()
+    }
+
+    /// get canonical tip
+    pub fn canonical_tip(&self) -> ForkBlock {
+        let (&number, &hash) =
+            self.canonical_chain.last_key_value().expect("There is always the canonical chain");
+        ForkBlock { number, hash }
+    }
+
+    /// Canonical chain needs for execution of EVM. It should contains last 256 block hashes.
+    pub fn canonical_chain(&self) -> &BTreeMap<BlockNumber, BlockHash> {
+        &self.canonical_chain
+    }
+}
diff --git a/crates/executor/src/blockchain_tree/chain.rs b/crates/executor/src/blockchain_tree/chain.rs
new file mode 100644
index 00000000000..4391e6c8b2e
--- /dev/null
+++ b/crates/executor/src/blockchain_tree/chain.rs
@@ -0,0 +1,458 @@
+//! A chain in a [`BlockchainTree`][super::BlockchainTree].
+//!
+//! A [`Chain`] contains the state of accounts for the chain after execution of its constituent
+//! blocks, as well as a list of the blocks the chain is composed of.
+use crate::{post_state::PostState, substate::PostStateProvider};
+use reth_interfaces::{consensus::Consensus, executor::Error as ExecError, Error};
+use reth_primitives::{BlockHash, BlockNumber, SealedBlockWithSenders, SealedHeader, U256};
+use reth_provider::{BlockExecutor, ExecutorFactory, StateProvider};
+use std::collections::BTreeMap;
+
+/// The ID of a sidechain internally in a [`BlockchainTree`][super::BlockchainTree].
+pub(crate) type BlockChainId = u64;
+
+/// A side chain.
+///
+/// The sidechain contains the state of accounts after execution of its blocks,
+/// changesets for those blocks (and their transactions), as well as the blocks themselves.
+///
+/// Each chain in the tree are identified using a unique ID.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Chain {
+    /// The state of accounts after execution of the blocks in this chain.
+    ///
+    /// This state also contains the individual changes that lead to the current state.
+    state: PostState,
+    /// The blocks in this chain.
+    blocks: BTreeMap<BlockNumber, SealedBlockWithSenders>,
+    /// A mapping of each block number in the chain to the highest transition ID in the chain's
+    /// state after execution of the block.
+    ///
+    /// This is used to revert changes in the state until a certain block number when the chain is
+    /// split.
+    block_transitions: BTreeMap<BlockNumber, usize>,
+}
+
+/// Describes a fork block by its number and hash.
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct ForkBlock {
+    /// Block number of block that chains branches from
+    pub number: u64,
+    /// Block hash of block that chains branches from
+    pub hash: BlockHash,
+}
+
+impl ForkBlock {
+    /// Return the `(block_number, block_hash)` tuple for this fork block.
+    pub fn num_hash(&self) -> (BlockNumber, BlockHash) {
+        (self.number, self.hash)
+    }
+}
+
+impl Chain {
+    /// Get the blocks in this chain.
+    pub fn blocks(&self) -> &BTreeMap<BlockNumber, SealedBlockWithSenders> {
+        &self.blocks
+    }
+
+    /// Destructure the chain into its inner components, the blocks and the state.
+    pub fn into_inner(self) -> (BTreeMap<BlockNumber, SealedBlockWithSenders>, PostState) {
+        (self.blocks, self.state)
+    }
+
+    /// Get the block at which this chain forked.
+    pub fn fork_block(&self) -> ForkBlock {
+        let tip = self.first();
+        ForkBlock { number: tip.number.saturating_sub(1), hash: tip.parent_hash }
+    }
+
+    /// Get the block number at which this chain forked.
+    pub fn fork_block_number(&self) -> BlockNumber {
+        self.first().number.saturating_sub(1)
+    }
+
+    /// Get the block hash at which this chain forked.
+    pub fn fork_block_hash(&self) -> BlockHash {
+        self.first().parent_hash
+    }
+
+    /// Get the first block in this chain.
+    pub fn first(&self) -> &SealedBlockWithSenders {
+        self.blocks.first_key_value().expect("Chain has at least one block for first").1
+    }
+
+    /// Get the tip of the chain.
+    ///
+    /// # Note
+    ///
+    /// Chains always have at least one block.
+    pub fn tip(&self) -> &SealedBlockWithSenders {
+        self.blocks.last_key_value().expect("Chain should have at least one block").1
+    }
+
+    /// Create new chain with given blocks and post state.
+    pub fn new(blocks: Vec<(SealedBlockWithSenders, PostState)>) -> Self {
+        let mut state = PostState::default();
+        let mut block_transitions = BTreeMap::new();
+        let mut block_num_hash = BTreeMap::new();
+        for (block, block_state) in blocks.into_iter() {
+            state.extend(block_state);
+            block_transitions.insert(block.number, state.transitions_count());
+            block_num_hash.insert(block.number, block);
+        }
+
+        Self { state, block_transitions, blocks: block_num_hash }
+    }
+
+    /// Create a new chain that forks off of the canonical chain.
+    pub fn new_canonical_fork<SP: StateProvider, C: Consensus, EF: ExecutorFactory>(
+        block: &SealedBlockWithSenders,
+        parent_header: &SealedHeader,
+        canonical_block_hashes: &BTreeMap<BlockNumber, BlockHash>,
+        provider: &SP,
+        consensus: &C,
+        factory: &EF,
+    ) -> Result<Self, Error> {
+        let state = PostState::default();
+        let empty = BTreeMap::new();
+
+        let state_provider =
+            PostStateProvider::new(&state, provider, &empty, canonical_block_hashes);
+
+        let changeset = Self::validate_and_execute(
+            block.clone(),
+            parent_header,
+            state_provider,
+            consensus,
+            factory,
+        )?;
+
+        Ok(Self::new(vec![(block.clone(), changeset)]))
+    }
+
+    /// Create a new chain that forks off of an existing sidechain.
+    pub fn new_chain_fork<SP: StateProvider, C: Consensus, EF: ExecutorFactory>(
+        &self,
+        block: SealedBlockWithSenders,
+        side_chain_block_hashes: BTreeMap<BlockNumber, BlockHash>,
+        canonical_block_hashes: &BTreeMap<BlockNumber, BlockHash>,
+        provider: &SP,
+        consensus: &C,
+        factory: &EF,
+    ) -> Result<Self, Error> {
+        let parent_number = block.number - 1;
+        let parent = self
+            .blocks
+            .get(&parent_number)
+            .ok_or(ExecError::BlockNumberNotFoundInChain { block_number: parent_number })?;
+
+        let revert_to_transition_id = self
+            .block_transitions
+            .get(&parent.number)
+            .expect("Should have the transition ID for the parent block");
+        let mut state = self.state.clone();
+
+        // Revert state to the state after execution of the parent block
+        state.revert_to(*revert_to_transition_id);
+
+        // Revert changesets to get the state of the parent that we need to apply the change.
+        let state_provider = PostStateProvider::new(
+            &state,
+            provider,
+            &side_chain_block_hashes,
+            canonical_block_hashes,
+        );
+        let block_state =
+            Self::validate_and_execute(block.clone(), parent, state_provider, consensus, factory)?;
+        state.extend(block_state);
+
+        let chain = Self {
+            block_transitions: BTreeMap::from([(block.number, state.transitions_count())]),
+            state,
+            blocks: BTreeMap::from([(block.number, block)]),
+        };
+
+        // If all is okay, return new chain back. Present chain is not modified.
+        Ok(chain)
+    }
+
+    /// Validate and execute the given block.
+    fn validate_and_execute<SP: StateProvider, C: Consensus, EF: ExecutorFactory>(
+        block: SealedBlockWithSenders,
+        parent_block: &SealedHeader,
+        state_provider: PostStateProvider<'_, SP>,
+        consensus: &C,
+        factory: &EF,
+    ) -> Result<PostState, Error> {
+        consensus.validate_header(&block, U256::MAX)?;
+        consensus.pre_validate_header(&block, parent_block)?;
+        consensus.pre_validate_block(&block)?;
+
+        let (unseal, senders) = block.into_components();
+        let unseal = unseal.unseal();
+
+        factory
+            .with_sp(state_provider)
+            .execute_and_verify_receipt(&unseal, U256::MAX, Some(senders))
+            .map_err(Into::into)
+    }
+
+    /// Validate and execute the given block, and append it to this chain.
+    pub fn append_block<SP: StateProvider, C: Consensus, EF: ExecutorFactory>(
+        &mut self,
+        block: SealedBlockWithSenders,
+        side_chain_block_hashes: BTreeMap<BlockNumber, BlockHash>,
+        canonical_block_hashes: &BTreeMap<BlockNumber, BlockHash>,
+        provider: &SP,
+        consensus: &C,
+        factory: &EF,
+    ) -> Result<(), Error> {
+        let (_, parent_block) = self.blocks.last_key_value().expect("Chain has at least one block");
+
+        let block_state = Self::validate_and_execute(
+            block.clone(),
+            parent_block,
+            PostStateProvider::new(
+                &self.state,
+                provider,
+                &side_chain_block_hashes,
+                canonical_block_hashes,
+            ),
+            consensus,
+            factory,
+        )?;
+        self.state.extend(block_state);
+        self.block_transitions.insert(block.number, self.state.transitions_count());
+        self.blocks.insert(block.number, block);
+        Ok(())
+    }
+
+    /// Merge two chains by appending the given chain into the current one.
+    ///
+    /// The state of accounts for this chain is set to the state of the newest chain.
+    pub fn append_chain(&mut self, chain: Chain) -> Result<(), Error> {
+        let chain_tip = self.tip();
+        if chain_tip.hash != chain.fork_block_hash() {
+            return Err(ExecError::AppendChainDoesntConnect {
+                chain_tip: chain_tip.num_hash(),
+                other_chain_fork: chain.fork_block().num_hash(),
+            }
+            .into())
+        }
+
+        // Insert blocks from other chain
+        self.blocks.extend(chain.blocks.into_iter());
+        let current_transition_count = self.state.transitions_count();
+        self.state.extend(chain.state);
+
+        // Update the block transition mapping, shifting the transition ID by the current number of
+        // transitions in *this* chain
+        for (block_number, transition_id) in chain.block_transitions.iter() {
+            self.block_transitions.insert(*block_number, transition_id + current_transition_count);
+        }
+        Ok(())
+    }
+
+    /// Split this chain at the given block.
+    ///
+    /// The given block will be the first block in the first returned chain.
+    ///
+    /// If the given block is not found, [`ChainSplit::NoSplitPending`] is returned.
+    /// Split chain at the number or hash, block with given number will be included at first chain.
+    /// If any chain is empty (Does not have blocks) None will be returned.
+    ///
+    /// # Note
+    ///
+    /// The block number to transition ID mapping is only found in the second chain, making it
+    /// impossible to perform any state reverts on the first chain.
+    ///
+    /// The second chain only contains the changes that were reverted on the first chain; however,
+    /// it retains the up to date state as if the chains were one, i.e. the second chain is an
+    /// extension of the first.
+    pub fn split(mut self, split_at: SplitAt) -> ChainSplit {
+        let chain_tip = *self.blocks.last_entry().expect("chain is never empty").key();
+        let block_number = match split_at {
+            SplitAt::Hash(block_hash) => {
+                let block_number = self
+                    .blocks
+                    .iter()
+                    .find_map(|(num, block)| (block.hash() == block_hash).then_some(*num));
+                let Some(block_number) = block_number else { return ChainSplit::NoSplitPending(self)};
+                // If block number is same as tip whole chain is becoming canonical.
+                if block_number == chain_tip {
+                    return ChainSplit::NoSplitCanonical(self)
+                }
+                block_number
+            }
+            SplitAt::Number(block_number) => {
+                if block_number >= chain_tip {
+                    return ChainSplit::NoSplitCanonical(self)
+                }
+                if block_number < *self.blocks.first_entry().expect("chain is never empty").key() {
+                    return ChainSplit::NoSplitPending(self)
+                }
+                block_number
+            }
+        };
+
+        let higher_number_blocks = self.blocks.split_off(&(block_number + 1));
+
+        let mut canonical_state = std::mem::take(&mut self.state);
+        let new_state = canonical_state.split_at(
+            *self.block_transitions.get(&(block_number)).expect("Unknown block transition ID"),
+        );
+        self.state = new_state;
+
+        ChainSplit::Split {
+            canonical: Chain {
+                state: canonical_state,
+                block_transitions: BTreeMap::new(),
+                blocks: self.blocks,
+            },
+            pending: Chain {
+                state: self.state,
+                block_transitions: self.block_transitions,
+                blocks: higher_number_blocks,
+            },
+        }
+    }
+}
+
+/// Used in spliting the chain.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SplitAt {
+    /// Split at block number.
+    Number(BlockNumber),
+    /// Split at block hash.
+    Hash(BlockHash),
+}
+
+/// Result of spliting chain.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ChainSplit {
+    /// Chain is not splited. Pending chain is returned.
+    /// Given block split is higher than last block.
+    /// Or in case of split by hash when hash is unknown.
+    NoSplitPending(Chain),
+    /// Chain is not splited. Canonical chain is returned.
+    /// Given block split is lower than first block.
+    NoSplitCanonical(Chain),
+    /// Chain is splited in two.
+    /// Given block split is contained in first chain.
+    Split {
+        /// Left contains lower block number that get canonicalized.
+        /// And substate is empty and not usable.
+        canonical: Chain,
+        /// Right contains higher block number, that is still pending.
+        /// And substate from original chain is moved here.
+        pending: Chain,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reth_primitives::{Account, H160, H256};
+
+    #[test]
+    fn chain_append() {
+        let block = SealedBlockWithSenders::default();
+        let block1_hash = H256([0x01; 32]);
+        let block2_hash = H256([0x02; 32]);
+        let block3_hash = H256([0x03; 32]);
+        let block4_hash = H256([0x04; 32]);
+
+        let mut block1 = block.clone();
+        let mut block2 = block.clone();
+        let mut block3 = block.clone();
+        let mut block4 = block;
+
+        block1.block.header.hash = block1_hash;
+        block2.block.header.hash = block2_hash;
+        block3.block.header.hash = block3_hash;
+        block4.block.header.hash = block4_hash;
+
+        block3.block.header.header.parent_hash = block2_hash;
+
+        let mut chain1 =
+            Chain { blocks: BTreeMap::from([(1, block1), (2, block2)]), ..Default::default() };
+
+        let chain2 =
+            Chain { blocks: BTreeMap::from([(3, block3), (4, block4)]), ..Default::default() };
+
+        assert_eq!(chain1.append_chain(chain2.clone()), Ok(()));
+
+        // chain1 got changed so this will fail
+        assert!(chain1.append_chain(chain2).is_err());
+    }
+
+    #[test]
+    fn test_number_split() {
+        let mut base_state = PostState::default();
+        let mut account = Account::default();
+        account.nonce = 10;
+        base_state.create_account(H160([1; 20]), account);
+        base_state.finish_transition();
+
+        let mut block_state1 = PostState::default();
+        block_state1.create_account(H160([2; 20]), Account::default());
+        block_state1.finish_transition();
+
+        let mut block_state2 = PostState::default();
+        block_state2.create_account(H160([3; 20]), Account::default());
+        block_state2.finish_transition();
+
+        let mut block1 = SealedBlockWithSenders::default();
+        let block1_hash = H256([15; 32]);
+        block1.number = 1;
+        block1.hash = block1_hash;
+        block1.senders.push(H160([4; 20]));
+
+        let mut block2 = SealedBlockWithSenders::default();
+        let block2_hash = H256([16; 32]);
+        block2.number = 2;
+        block2.hash = block2_hash;
+        block2.senders.push(H160([4; 20]));
+
+        let chain = Chain::new(vec![
+            (block1.clone(), block_state1.clone()),
+            (block2.clone(), block_state2.clone()),
+        ]);
+
+        let mut split1_state = chain.state.clone();
+        let split2_state = split1_state.split_at(*chain.block_transitions.get(&1).unwrap());
+
+        let chain_split1 = Chain {
+            state: split1_state,
+            block_transitions: BTreeMap::new(),
+            blocks: BTreeMap::from([(1, block1.clone())]),
+        };
+
+        let chain_split2 = Chain {
+            state: split2_state,
+            block_transitions: chain.block_transitions.clone(),
+            blocks: BTreeMap::from([(2, block2.clone())]),
+        };
+
+        // split in two
+        assert_eq!(
+            chain.clone().split(SplitAt::Hash(block1_hash)),
+            ChainSplit::Split { canonical: chain_split1, pending: chain_split2 }
+        );
+
+        // split at unknown block hash
+        assert_eq!(
+            chain.clone().split(SplitAt::Hash(H256([100; 32]))),
+            ChainSplit::NoSplitPending(chain.clone())
+        );
+
+        // split at higher number
+        assert_eq!(
+            chain.clone().split(SplitAt::Number(10)),
+            ChainSplit::NoSplitCanonical(chain.clone())
+        );
+
+        // split at lower number
+        assert_eq!(chain.clone().split(SplitAt::Number(0)), ChainSplit::NoSplitPending(chain));
+    }
+}
diff --git a/crates/executor/src/blockchain_tree/config.rs b/crates/executor/src/blockchain_tree/config.rs
new file mode 100644
index 00000000000..d830f066fd0
--- /dev/null
+++ b/crates/executor/src/blockchain_tree/config.rs
@@ -0,0 +1,60 @@
+//! Blockchain tree configuration
+
+/// The configuration for the blockchain tree.
+#[derive(Clone, Debug)]
+pub struct BlockchainTreeConfig {
+    /// Number of blocks after the last finalized block that we are storing.
+    ///
+    /// It should be more than the finalization window for the canonical chain.
+    max_blocks_in_chain: u64,
+    /// The number of blocks that can be re-orged (finalization windows)
+    max_reorg_depth: u64,
+    /// For EVM's "BLOCKHASH" opcode we require last 256 block hashes. So we need to specify
+    /// at least `additional_canonical_block_hashes`+`max_reorg_depth`, for eth that would be
+    /// 256+64.
+    num_of_additional_canonical_block_hashes: u64,
+}
+
+impl Default for BlockchainTreeConfig {
+    fn default() -> Self {
+        // The defaults for Ethereum mainnet
+        Self {
+            // Gasper allows reorgs of any length from 1 to 64.
+            max_reorg_depth: 64,
+            // This default is just an assumption. Has to be greater than the `max_reorg_depth`.
+            max_blocks_in_chain: 65,
+            // EVM requires that last 256 block hashes are available.
+            num_of_additional_canonical_block_hashes: 256,
+        }
+    }
+}
+
+impl BlockchainTreeConfig {
+    /// Create tree configuration.
+    pub fn new(
+        max_reorg_depth: u64,
+        max_blocks_in_chain: u64,
+        num_of_additional_canonical_block_hashes: u64,
+    ) -> Self {
+        if max_reorg_depth > max_blocks_in_chain {
+            panic!("Side chain size should be more then finalization window");
+        }
+        Self { max_blocks_in_chain, max_reorg_depth, num_of_additional_canonical_block_hashes }
+    }
+
+    /// Return the maximum reorg depth.
+    pub fn max_reorg_depth(&self) -> u64 {
+        self.max_reorg_depth
+    }
+
+    /// Return the maximum number of blocks in one chain.
+    pub fn max_blocks_in_chain(&self) -> u64 {
+        self.max_blocks_in_chain
+    }
+
+    /// Return number of additional canonical block hashes that we need to retain
+    /// in order to have enough information for EVM execution.
+    pub fn num_of_additional_canonical_block_hashes(&self) -> u64 {
+        self.num_of_additional_canonical_block_hashes
+    }
+}
diff --git a/crates/executor/src/blockchain_tree/externals.rs b/crates/executor/src/blockchain_tree/externals.rs
new file mode 100644
index 00000000000..874760ff420
--- /dev/null
+++ b/crates/executor/src/blockchain_tree/externals.rs
@@ -0,0 +1,46 @@
+//! Blockchain tree externals.
+
+use reth_db::database::Database;
+use reth_primitives::ChainSpec;
+use reth_provider::ShareableDatabase;
+use std::sync::Arc;
+
+/// A container for external components.
+///
+/// This is a simple container for external components used throughout the blockchain tree
+/// implementation:
+///
+/// - A handle to the database
+/// - A handle to the consensus engine
+/// - The executor factory to exexcute blocks with
+/// - The chain spec
+#[derive(Debug)]
+pub struct TreeExternals<DB, C, EF> {
+    /// The database, used to commit the canonical chain, or unwind it.
+    pub db: Arc<DB>,
+    /// The consensus engine.
+    pub consensus: C,
+    /// The executor factory to execute blocks with.
+    pub executor_factory: EF,
+    /// The chain spec.
+    pub chain_spec: Arc<ChainSpec>,
+}
+
+impl<DB, C, EF> TreeExternals<DB, C, EF> {
+    /// Create new tree externals.
+    pub fn new(
+        db: Arc<DB>,
+        consensus: C,
+        executor_factory: EF,
+        chain_spec: Arc<ChainSpec>,
+    ) -> Self {
+        Self { db, consensus, executor_factory, chain_spec }
+    }
+}
+
+impl<DB: Database, C, EF> TreeExternals<DB, C, EF> {
+    /// Return shareable database helper structure.
+    pub fn shareable_db(&self) -> ShareableDatabase<&DB> {
+        ShareableDatabase::new(&self.db, self.chain_spec.clone())
+    }
+}
diff --git a/crates/executor/src/blockchain_tree/mod.rs b/crates/executor/src/blockchain_tree/mod.rs
new file mode 100644
index 00000000000..481c60d77d2
--- /dev/null
+++ b/crates/executor/src/blockchain_tree/mod.rs
@@ -0,0 +1,974 @@
+//! Implementation of [`BlockchainTree`]
+use chain::{BlockChainId, Chain, ForkBlock};
+use reth_db::{cursor::DbCursorRO, database::Database, tables, transaction::DbTx};
+use reth_interfaces::{consensus::Consensus, executor::Error as ExecError, Error};
+use reth_primitives::{BlockHash, BlockNumber, SealedBlock, SealedBlockWithSenders};
+use reth_provider::{
+    providers::ChainState, ExecutorFactory, HeaderProvider, StateProviderFactory, Transaction,
+};
+use std::{
+    collections::{BTreeMap, HashMap},
+    ops::DerefMut,
+};
+
+pub mod block_indices;
+use block_indices::BlockIndices;
+
+pub mod chain;
+use chain::{ChainSplit, SplitAt};
+
+pub mod config;
+use config::BlockchainTreeConfig;
+
+pub mod externals;
+use externals::TreeExternals;
+
+#[cfg_attr(doc, aquamarine::aquamarine)]
+/// Tree of chains and its identifications.
+///
+/// Mermaid flowchart represent all blocks that can appear in blockchain.
+/// Green blocks belong to canonical chain and are saved inside database table, they are our main
+/// chain. Pending blocks and sidechains are found in memory inside [`BlockchainTree`].
+/// Both pending and sidechains have same mechanisms only difference is when they got committed to
+/// database. For pending it is just append operation but for sidechains they need to move current
+/// canonical blocks to BlockchainTree flush sidechain to the database to become canonical chain.
+/// ```mermaid
+/// flowchart BT
+/// subgraph canonical chain
+/// CanonState:::state
+/// block0canon:::canon -->block1canon:::canon -->block2canon:::canon -->block3canon:::canon --> block4canon:::canon --> block5canon:::canon
+/// end
+/// block5canon --> block6pending1:::pending
+/// block5canon --> block6pending2:::pending
+/// subgraph sidechain2
+/// S2State:::state
+/// block3canon --> block4s2:::sidechain --> block5s2:::sidechain
+/// end
+/// subgraph sidechain1
+/// S1State:::state
+/// block2canon --> block3s1:::sidechain --> block4s1:::sidechain --> block5s1:::sidechain --> block6s1:::sidechain
+/// end
+/// classDef state fill:#1882C4
+/// classDef canon fill:#8AC926
+/// classDef pending fill:#FFCA3A
+/// classDef sidechain fill:#FF595E
+/// ```
+///
+///
+/// main functions:
+/// * [BlockchainTree::insert_block]: Connect block to chain, execute it and if valid insert block
+///   inside tree.
+/// * [BlockchainTree::finalize_block]: Remove chains that join to now finalized block, as chain
+///   becomes invalid.
+/// * [BlockchainTree::make_canonical]: Check if we have the hash of block that we want to finalize
+///   and commit it to db. If we dont have the block, pipeline syncing should start to fetch the
+///   blocks from p2p. Do reorg in tables if canonical chain if needed.
+#[derive(Debug)]
+pub struct BlockchainTree<DB: Database, C: Consensus, EF: ExecutorFactory> {
+    /// The tracked chains and their current data.
+    chains: HashMap<BlockChainId, Chain>,
+    /// Static blockchain ID generator
+    block_chain_id_generator: u64,
+    /// Indices to block and their connection to the canonical chain.
+    block_indices: BlockIndices,
+    /// External components (the database, consensus engine etc.)
+    externals: TreeExternals<DB, C, EF>,
+    /// Tree configuration
+    config: BlockchainTreeConfig,
+}
+
+/// From Engine API spec, block inclusion can be valid, accepted or invalid.
+/// Invalid case is already covered by error but we needs to make distinction
+/// between if it is valid (extends canonical chain) or just accepted (is side chain).
+/// If we dont know the block parent we are returning Disconnected status
+/// as we can't make a claim if block is valid or not.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum BlockStatus {
+    /// If block validation is valid and block extends canonical chain.
+    /// In BlockchainTree sense it forks on canonical tip.
+    Valid,
+    /// If block validation is valid but block does not extend canonical chain
+    /// (It is side chain) or hasn't been fully validated but ancestors of a payload are known.
+    Accepted,
+    /// If blocks is not connected to canonical chain.
+    Disconnected,
+}
+
+/// A container that wraps chains and block indices to allow searching for block hashes across all
+/// sidechains.
+pub struct BlockHashes<'a> {
+    /// The current tracked chains.
+    pub chains: &'a mut HashMap<BlockChainId, Chain>,
+    /// The block indices for all chains.
+    pub indices: &'a BlockIndices,
+}
+
+impl<DB: Database, C: Consensus, EF: ExecutorFactory> BlockchainTree<DB, C, EF> {
+    /// Create a new blockchain tree.
+    pub fn new(
+        externals: TreeExternals<DB, C, EF>,
+        config: BlockchainTreeConfig,
+    ) -> Result<Self, Error> {
+        let max_reorg_depth = config.max_reorg_depth();
+
+        let last_canonical_hashes = externals
+            .db
+            .tx()?
+            .cursor_read::<tables::CanonicalHeaders>()?
+            .walk_back(None)?
+            .take((max_reorg_depth + config.num_of_additional_canonical_block_hashes()) as usize)
+            .collect::<Result<Vec<(BlockNumber, BlockHash)>, _>>()?;
+
+        // TODO(rakita) save last finalized block inside database but for now just take
+        // tip-max_reorg_depth
+        // task: https://github.com/paradigmxyz/reth/issues/1712
+        let (last_finalized_block_number, _) =
+            if last_canonical_hashes.len() > max_reorg_depth as usize {
+                last_canonical_hashes[max_reorg_depth as usize]
+            } else {
+                // it is in reverse order from tip to N
+                last_canonical_hashes.last().cloned().unwrap_or_default()
+            };
+
+        Ok(Self {
+            externals,
+            block_chain_id_generator: 0,
+            chains: Default::default(),
+            block_indices: BlockIndices::new(
+                last_finalized_block_number,
+                BTreeMap::from_iter(last_canonical_hashes.into_iter()),
+            ),
+            config,
+        })
+    }
+
+    /// Create a new sidechain by forking the given chain, or append the block if the parent block
+    /// is the top of the given chain.
+    fn fork_side_chain(
+        &mut self,
+        block: SealedBlockWithSenders,
+        chain_id: BlockChainId,
+    ) -> Result<BlockStatus, Error> {
+        let block_hashes = self.all_chain_hashes(chain_id);
+
+        // get canonical fork.
+        let canonical_fork =
+            self.canonical_fork(chain_id).ok_or(ExecError::BlockChainIdConsistency { chain_id })?;
+
+        // get chain that block needs to join to.
+        let parent_chain = self
+            .chains
+            .get_mut(&chain_id)
+            .ok_or(ExecError::BlockChainIdConsistency { chain_id })?;
+        let chain_tip = parent_chain.tip().hash();
+
+        let canonical_block_hashes = self.block_indices.canonical_chain();
+
+        // get canonical tip
+        let (_, canonical_tip_hash) =
+            canonical_block_hashes.last_key_value().map(|(i, j)| (*i, *j)).unwrap_or_default();
+
+        let db = self.externals.shareable_db();
+        let provider = if canonical_fork.hash == canonical_tip_hash {
+            ChainState::boxed(db.latest()?)
+        } else {
+            ChainState::boxed(db.history_by_block_number(canonical_fork.number)?)
+        };
+
+        // append the block if it is continuing the chain.
+        if chain_tip == block.parent_hash {
+            let block_hash = block.hash();
+            let block_number = block.number;
+            parent_chain.append_block(
+                block,
+                block_hashes,
+                canonical_block_hashes,
+                &provider,
+                &self.externals.consensus,
+                &self.externals.executor_factory,
+            )?;
+            drop(provider);
+            self.block_indices.insert_non_fork_block(block_number, block_hash, chain_id);
+            Ok(BlockStatus::Valid)
+        } else {
+            let chain = parent_chain.new_chain_fork(
+                block,
+                block_hashes,
+                canonical_block_hashes,
+                &provider,
+                &self.externals.consensus,
+                &self.externals.executor_factory,
+            )?;
+            // release the lifetime with a drop
+            drop(provider);
+            self.insert_chain(chain);
+            Ok(BlockStatus::Accepted)
+        }
+    }
+
+    /// Create a new sidechain by forking the canonical chain.
+    // TODO(onbjerg): Is this not a specialized case of [`fork_side_chain`]? If so, can we merge?
+    pub fn fork_canonical_chain(
+        &mut self,
+        block: SealedBlockWithSenders,
+    ) -> Result<BlockStatus, Error> {
+        let canonical_block_hashes = self.block_indices.canonical_chain();
+        let (_, canonical_tip) =
+            canonical_block_hashes.last_key_value().map(|(i, j)| (*i, *j)).unwrap_or_default();
+
+        // create state provider
+        let db = self.externals.shareable_db();
+        let parent_header = db
+            .header(&block.parent_hash)?
+            .ok_or(ExecError::CanonicalChain { block_hash: block.parent_hash })?;
+
+        let block_status;
+        let provider = if block.parent_hash == canonical_tip {
+            block_status = BlockStatus::Valid;
+            ChainState::boxed(db.latest()?)
+        } else {
+            block_status = BlockStatus::Accepted;
+            ChainState::boxed(db.history_by_block_number(block.number - 1)?)
+        };
+
+        let parent_header = parent_header.seal(block.parent_hash);
+        let chain = Chain::new_canonical_fork(
+            &block,
+            &parent_header,
+            canonical_block_hashes,
+            &provider,
+            &self.externals.consensus,
+            &self.externals.executor_factory,
+        )?;
+        drop(provider);
+        self.insert_chain(chain);
+        Ok(block_status)
+    }
+
+    /// Get all block hashes from a sidechain that are not part of the canonical chain.
+    ///
+    /// This is a one time operation per block.
+    ///
+    /// # Note
+    ///
+    /// This is not cached in order to save memory.
+    fn all_chain_hashes(&self, chain_id: BlockChainId) -> BTreeMap<BlockNumber, BlockHash> {
+        // find chain and iterate over it,
+        let mut chain_id = chain_id;
+        let mut hashes = BTreeMap::new();
+        loop {
+            let Some(chain) = self.chains.get(&chain_id) else { return hashes };
+            hashes.extend(chain.blocks().values().map(|b| (b.number, b.hash())));
+
+            let fork_block = chain.fork_block_hash();
+            if let Some(next_chain_id) = self.block_indices.get_blocks_chain_id(&fork_block) {
+                chain_id = next_chain_id;
+            } else {
+                // if there is no fork block that point to other chains, break the loop.
+                // it means that this fork joins to canonical block.
+                break
+            }
+        }
+        hashes
+    }
+
+    /// Get the block at which the given chain forked from the current canonical chain.
+    ///
+    /// This is used to figure out what kind of state provider the executor should use to execute
+    /// the block.
+    ///
+    /// Returns `None` if the chain is not known.
+    fn canonical_fork(&self, chain_id: BlockChainId) -> Option<ForkBlock> {
+        let mut chain_id = chain_id;
+        let mut fork;
+        loop {
+            // chain fork block
+            fork = self.chains.get(&chain_id)?.fork_block();
+            // get fork block chain
+            if let Some(fork_chain_id) = self.block_indices.get_blocks_chain_id(&fork.hash) {
+                chain_id = fork_chain_id;
+                continue
+            }
+            break
+        }
+        (self.block_indices.canonical_hash(&fork.number) == Some(fork.hash)).then_some(fork)
+    }
+
+    /// Insert a chain into the tree.
+    ///
+    /// Inserts a chain into the tree and builds the block indices.
+    fn insert_chain(&mut self, chain: Chain) -> BlockChainId {
+        let chain_id = self.block_chain_id_generator;
+        self.block_chain_id_generator += 1;
+        self.block_indices.insert_chain(chain_id, &chain);
+        // add chain_id -> chain index
+        self.chains.insert(chain_id, chain);
+        chain_id
+    }
+
+    /// Insert a new block in the tree.
+    ///
+    /// # Note
+    ///
+    /// This recovers transaction signers (unlike [`BlockchainTree::insert_block_with_senders`]).
+    pub fn insert_block(&mut self, block: SealedBlock) -> Result<BlockStatus, Error> {
+        let block = block.seal_with_senders().ok_or(ExecError::SenderRecoveryError)?;
+        self.insert_block_with_senders(&block)
+    }
+
+    /// Insert a block (with senders recovered) in the tree.
+    ///
+    /// Returns `true` if:
+    ///
+    /// - The block is already part of a sidechain in the tree, or
+    /// - The block is already part of the canonical chain, or
+    /// - The parent is part of a sidechain in the tree, and we can fork at this block, or
+    /// - The parent is part of the canonical chain, and we can fork at this block
+    ///
+    /// Otherwise `false` is returned, indicating that neither the block nor its parent is part of
+    /// the chain or any sidechains.
+    ///
+    /// This means that if the block becomes canonical, we need to fetch the missing blocks over
+    /// P2P.
+    ///
+    /// # Note
+    ///
+    /// If the senders have not already been recovered, call [`BlockchainTree::insert_block`]
+    /// instead.
+    pub fn insert_block_with_senders(
+        &mut self,
+        block: &SealedBlockWithSenders,
+    ) -> Result<BlockStatus, Error> {
+        // check if block number is inside pending block slide
+        let last_finalized_block = self.block_indices.last_finalized_block();
+        if block.number <= last_finalized_block {
+            return Err(ExecError::PendingBlockIsFinalized {
+                block_number: block.number,
+                block_hash: block.hash(),
+                last_finalized: last_finalized_block,
+            }
+            .into())
+        }
+
+        // we will not even try to insert blocks that are too far in future.
+        if block.number > last_finalized_block + self.config.max_blocks_in_chain() {
+            return Err(ExecError::PendingBlockIsInFuture {
+                block_number: block.number,
+                block_hash: block.hash(),
+                last_finalized: last_finalized_block,
+            }
+            .into())
+        }
+
+        // check if block known and is already inside Tree
+        if let Some(chain_id) = self.block_indices.get_blocks_chain_id(&block.hash()) {
+            let canonical_fork = self.canonical_fork(chain_id).expect("Chain id is valid");
+            // if block chain extends canonical chain
+            if canonical_fork == self.block_indices.canonical_tip() {
+                return Ok(BlockStatus::Valid)
+            } else {
+                return Ok(BlockStatus::Accepted)
+            }
+        }
+
+        // check if block is part of canonical chain
+        if self.block_indices.canonical_hash(&block.number) == Some(block.hash()) {
+            // block is part of canonical chain
+            return Ok(BlockStatus::Valid)
+        }
+
+        // check if block parent can be found in Tree
+        if let Some(parent_chain) = self.block_indices.get_blocks_chain_id(&block.parent_hash) {
+            return self.fork_side_chain(block.clone(), parent_chain)
+            // TODO save pending block to database
+            // https://github.com/paradigmxyz/reth/issues/1713
+        }
+
+        // if not found, check if the parent can be found inside canonical chain.
+        if Some(block.parent_hash) == self.block_indices.canonical_hash(&(block.number - 1)) {
+            // create new chain that points to that block
+            return self.fork_canonical_chain(block.clone())
+            // TODO save pending block to database
+            // https://github.com/paradigmxyz/reth/issues/1713
+        }
+        // NOTE: Block doesn't have a parent, and if we receive this block in `make_canonical`
+        // function this could be a trigger to initiate p2p syncing, as we are missing the
+        // parent.
+        Ok(BlockStatus::Disconnected)
+    }
+
+    /// Finalize blocks up until and including `finalized_block`, and remove them from the tree.
+    pub fn finalize_block(&mut self, finalized_block: BlockNumber) {
+        let mut remove_chains = self.block_indices.finalize_canonical_blocks(
+            finalized_block,
+            self.config.num_of_additional_canonical_block_hashes(),
+        );
+
+        while let Some(chain_id) = remove_chains.pop_first() {
+            if let Some(chain) = self.chains.remove(&chain_id) {
+                remove_chains.extend(self.block_indices.remove_chain(&chain));
+            }
+        }
+    }
+
+    /// Reads the last `N` canonical hashes from the database and updates the block indices of the
+    /// tree.
+    ///
+    /// `N` is the `max_reorg_depth` plus the number of block hashes needed to satisfy the
+    /// `BLOCKHASH` opcode in the EVM.
+    ///
+    /// # Note
+    ///
+    /// This finalizes `last_finalized_block` prior to reading the canonical hashes (using
+    /// [`BlockchainTree::finalize_block`]).
+    pub fn restore_canonical_hashes(
+        &mut self,
+        last_finalized_block: BlockNumber,
+    ) -> Result<(), Error> {
+        self.finalize_block(last_finalized_block);
+
+        let num_of_canonical_hashes =
+            self.config.max_reorg_depth() + self.config.num_of_additional_canonical_block_hashes();
+
+        let last_canonical_hashes = self
+            .externals
+            .db
+            .tx()?
+            .cursor_read::<tables::CanonicalHeaders>()?
+            .walk_back(None)?
+            .take(num_of_canonical_hashes as usize)
+            .collect::<Result<BTreeMap<BlockNumber, BlockHash>, _>>()?;
+
+        let mut remove_chains = self.block_indices.update_block_hashes(last_canonical_hashes);
+
+        // remove all chains that got discarded
+        while let Some(chain_id) = remove_chains.first() {
+            if let Some(chain) = self.chains.remove(chain_id) {
+                remove_chains.extend(self.block_indices.remove_chain(&chain));
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Split a sidechain at the given point, and return the canonical part of it.
+    ///
+    /// The pending part of the chain is reinserted into the tree with the same `chain_id`.
+    fn split_chain(&mut self, chain_id: BlockChainId, chain: Chain, split_at: SplitAt) -> Chain {
+        match chain.split(split_at) {
+            ChainSplit::Split { canonical, pending } => {
+                // rest of splited chain is inserted back with same chain_id.
+                self.block_indices.insert_chain(chain_id, &pending);
+                self.chains.insert(chain_id, pending);
+                canonical
+            }
+            ChainSplit::NoSplitCanonical(canonical) => canonical,
+            ChainSplit::NoSplitPending(_) => {
+                panic!("Should not happen as block indices guarantee structure of blocks")
+            }
+        }
+    }
+
+    /// Make a block and its parent part of the canonical chain.
+    ///
+    /// # Note
+    ///
+    /// This unwinds the database if necessary, i.e. if parts of the canonical chain have been
+    /// re-orged.
+    ///
+    /// # Returns
+    ///
+    /// Returns `Ok` if the blocks were canonicalized, or if the blocks were already canonical.
+    pub fn make_canonical(&mut self, block_hash: &BlockHash) -> Result<(), Error> {
+        let chain_id = if let Some(chain_id) = self.block_indices.get_blocks_chain_id(block_hash) {
+            chain_id
+        } else {
+            // If block is already canonical don't return error.
+            if self.block_indices.is_block_hash_canonical(block_hash) {
+                return Ok(())
+            }
+            return Err(ExecError::BlockHashNotFoundInChain { block_hash: *block_hash }.into())
+        };
+        let chain = self.chains.remove(&chain_id).expect("To be present");
+
+        // we are spliting chain as there is possibility that only part of chain get canonicalized.
+        let canonical = self.split_chain(chain_id, chain, SplitAt::Hash(*block_hash));
+
+        let mut block_fork = canonical.fork_block();
+        let mut block_fork_number = canonical.fork_block_number();
+        let mut chains_to_promote = vec![canonical];
+
+        // loop while fork blocks are found in Tree.
+        while let Some(chain_id) = self.block_indices.get_blocks_chain_id(&block_fork.hash) {
+            let chain = self.chains.remove(&chain_id).expect("To fork to be present");
+            block_fork = chain.fork_block();
+            let canonical = self.split_chain(chain_id, chain, SplitAt::Number(block_fork_number));
+            block_fork_number = canonical.fork_block_number();
+            chains_to_promote.push(canonical);
+        }
+
+        let old_tip = self.block_indices.canonical_tip();
+        // Merge all chain into one chain.
+        let mut new_canon_chain = chains_to_promote.pop().expect("There is at least one block");
+        for chain in chains_to_promote.into_iter().rev() {
+            new_canon_chain.append_chain(chain).expect("We have just build the chain.");
+        }
+
+        // update canonical index
+        self.block_indices.canonicalize_blocks(new_canon_chain.blocks());
+
+        // if joins to the tip
+        if new_canon_chain.fork_block_hash() == old_tip.hash {
+            // append to database
+            self.commit_canonical(new_canon_chain)?;
+        } else {
+            // it forks to canonical block that is not the tip.
+
+            let canon_fork = new_canon_chain.fork_block();
+            // sanity check
+            if self.block_indices.canonical_hash(&canon_fork.number) != Some(canon_fork.hash) {
+                unreachable!("all chains should point to canonical chain.");
+            }
+
+            let old_canon_chain = self.revert_canonical(canon_fork.number)?;
+            // commit new canonical chain.
+            self.commit_canonical(new_canon_chain)?;
+            // insert old canon chain
+            self.insert_chain(old_canon_chain);
+        }
+
+        Ok(())
+    }
+
+    /// Canonicalize the given chain and commit it to the database.
+    fn commit_canonical(&mut self, chain: Chain) -> Result<(), Error> {
+        let mut tx = Transaction::new(&self.externals.db)?;
+        let new_tip_number = chain.tip().number;
+        let new_tip_hash = chain.tip().hash;
+        let first_transition_id =
+            tx.get_block_transition(chain.first().number.saturating_sub(1))
+                .map_err(|e| ExecError::CanonicalCommit { inner: e.to_string() })?;
+        let expected_state_root = chain.tip().state_root;
+        let fork_block = chain.fork_block_number();
+        let (blocks, state) = chain.into_inner();
+        let num_transitions = state.transitions_count();
+
+        // Write state and changesets to the database
+        state
+            .write_to_db(tx.deref_mut(), first_transition_id)
+            .map_err(|e| ExecError::CanonicalCommit { inner: e.to_string() })?;
+
+        // Insert the blocks
+        for block in blocks.into_values() {
+            tx.insert_block(block)
+                .map_err(|e| ExecError::CanonicalCommit { inner: e.to_string() })?;
+        }
+        tx.insert_hashes(
+            fork_block,
+            first_transition_id,
+            first_transition_id + num_transitions as u64,
+            new_tip_number,
+            new_tip_hash,
+            expected_state_root,
+        )
+        .map_err(|e| ExecError::CanonicalCommit { inner: e.to_string() })?;
+
+        // Update pipeline progress
+        tx.update_pipeline_stages(new_tip_number)
+            .map_err(|e| ExecError::PipelineStatusUpdate { inner: e.to_string() })?;
+
+        tx.commit()?;
+
+        Ok(())
+    }
+
+    /// Unwind tables and put it inside state
+    pub fn unwind(&mut self, unwind_to: BlockNumber) -> Result<(), Error> {
+        // nothing to be done if unwind_to is higher then the tip
+        if self.block_indices.canonical_tip().number <= unwind_to {
+            return Ok(())
+        }
+        // revert `N` blocks from current canonical chain and put them inside BlockchanTree
+        let old_canon_chain = self.revert_canonical(unwind_to)?;
+
+        // check if there is block in chain
+        if old_canon_chain.blocks().is_empty() {
+            return Ok(())
+        }
+        self.block_indices.unwind_canonical_chain(unwind_to);
+        // insert old canonical chain to BlockchainTree.
+        self.insert_chain(old_canon_chain);
+
+        Ok(())
+    }
+
+    /// Revert canonical blocks from the database and return them.
+    ///
+    /// The block, `revert_until`, is non-inclusive, i.e. `revert_until` stays in the database.
+    fn revert_canonical(&mut self, revert_until: BlockNumber) -> Result<Chain, Error> {
+        // read data that is needed for new sidechain
+
+        let mut tx = Transaction::new(&self.externals.db)?;
+
+        // read block and execution result from database. and remove traces of block from tables.
+        let blocks_and_execution = tx
+            .take_block_and_execution_range(
+                self.externals.chain_spec.as_ref(),
+                (revert_until + 1)..,
+            )
+            .map_err(|e| ExecError::CanonicalRevert { inner: e.to_string() })?;
+
+        // update pipeline progress.
+        tx.update_pipeline_stages(revert_until)
+            .map_err(|e| ExecError::PipelineStatusUpdate { inner: e.to_string() })?;
+
+        tx.commit()?;
+
+        Ok(Chain::new(blocks_and_execution))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::TestExecutorFactory;
+    use reth_db::{
+        mdbx::{test_utils::create_test_rw_db, Env, WriteMap},
+        transaction::DbTxMut,
+    };
+    use reth_interfaces::test_utils::TestConsensus;
+    use reth_primitives::{proofs::EMPTY_ROOT, ChainSpecBuilder, H256, MAINNET};
+    use reth_provider::{
+        insert_block, post_state::PostState, test_utils::blocks::BlockChainTestData,
+    };
+    use std::{collections::HashSet, sync::Arc};
+
+    fn setup_externals(
+        exec_res: Vec<PostState>,
+    ) -> TreeExternals<Env<WriteMap>, Arc<TestConsensus>, TestExecutorFactory> {
+        let db = create_test_rw_db();
+        let consensus = Arc::new(TestConsensus::default());
+        let chain_spec = Arc::new(
+            ChainSpecBuilder::default()
+                .chain(MAINNET.chain)
+                .genesis(MAINNET.genesis.clone())
+                .shanghai_activated()
+                .build(),
+        );
+        let executor_factory = TestExecutorFactory::new(chain_spec.clone());
+        executor_factory.extend(exec_res);
+
+        TreeExternals::new(db, consensus, executor_factory, chain_spec)
+    }
+
+    fn setup_genesis<DB: Database>(db: DB, mut genesis: SealedBlock) {
+        // insert genesis to db.
+
+        genesis.header.header.number = 10;
+        genesis.header.header.state_root = EMPTY_ROOT;
+        let tx_mut = db.tx_mut().unwrap();
+
+        insert_block(&tx_mut, genesis, None, false, Some((0, 0))).unwrap();
+
+        // insert first 10 blocks
+        for i in 0..10 {
+            tx_mut.put::<tables::CanonicalHeaders>(i, H256([100 + i as u8; 32])).unwrap();
+        }
+        tx_mut.commit().unwrap();
+    }
+
+    /// Test data structure that will check tree internals
+    #[derive(Default, Debug)]
+    struct TreeTester {
+        /// Number of chains
+        chain_num: Option<usize>,
+        /// Check block to chain index
+        block_to_chain: Option<HashMap<BlockHash, BlockChainId>>,
+        /// Check fork to child index
+        fork_to_child: Option<HashMap<BlockHash, HashSet<BlockHash>>>,
+    }
+
+    impl TreeTester {
+        fn with_chain_num(mut self, chain_num: usize) -> Self {
+            self.chain_num = Some(chain_num);
+            self
+        }
+        fn with_block_to_chain(mut self, block_to_chain: HashMap<BlockHash, BlockChainId>) -> Self {
+            self.block_to_chain = Some(block_to_chain);
+            self
+        }
+        fn with_fork_to_child(
+            mut self,
+            fork_to_child: HashMap<BlockHash, HashSet<BlockHash>>,
+        ) -> Self {
+            self.fork_to_child = Some(fork_to_child);
+            self
+        }
+
+        fn assert<DB: Database, C: Consensus, EF: ExecutorFactory>(
+            self,
+            tree: &BlockchainTree<DB, C, EF>,
+        ) {
+            if let Some(chain_num) = self.chain_num {
+                assert_eq!(tree.chains.len(), chain_num);
+            }
+            if let Some(block_to_chain) = self.block_to_chain {
+                assert_eq!(*tree.block_indices.blocks_to_chain(), block_to_chain);
+            }
+            if let Some(fork_to_child) = self.fork_to_child {
+                assert_eq!(*tree.block_indices.fork_to_child(), fork_to_child);
+            }
+        }
+    }
+
+    #[test]
+    fn sanity_path() {
+        let data = BlockChainTestData::default();
+        let (mut block1, exec1) = data.blocks[0].clone();
+        block1.number = 11;
+        let (mut block2, exec2) = data.blocks[1].clone();
+        block2.number = 12;
+
+        // test pops execution results from vector, so order is from last to first.ß
+        let externals = setup_externals(vec![exec2.clone(), exec1.clone(), exec2, exec1]);
+
+        // last finalized block would be number 9.
+        setup_genesis(externals.db.clone(), data.genesis);
+
+        // make tree
+        let config = BlockchainTreeConfig::new(1, 2, 3);
+        let mut tree = BlockchainTree::new(externals, config).expect("failed to create tree");
+
+        // genesis block 10 is already canonical
+        assert_eq!(tree.make_canonical(&H256::zero()), Ok(()));
+
+        // insert block2 hits max chain size
+        assert_eq!(
+            tree.insert_block_with_senders(&block2),
+            Err(ExecError::PendingBlockIsInFuture {
+                block_number: block2.number,
+                block_hash: block2.hash(),
+                last_finalized: 9,
+            }
+            .into())
+        );
+
+        // make genesis block 10 as finalized
+        tree.finalize_block(10);
+
+        // block 2 parent is not known.
+        assert_eq!(tree.insert_block_with_senders(&block2), Ok(BlockStatus::Disconnected));
+
+        // insert block1
+        assert_eq!(tree.insert_block_with_senders(&block1), Ok(BlockStatus::Valid));
+        // already inserted block will return true.
+        assert_eq!(tree.insert_block_with_senders(&block1), Ok(BlockStatus::Valid));
+
+        // insert block2
+        assert_eq!(tree.insert_block_with_senders(&block2), Ok(BlockStatus::Valid));
+
+        // Trie state:
+        //      b2 (pending block)
+        //      |
+        //      |
+        //      b1 (pending block)
+        //    /
+        //  /
+        // g1 (canonical blocks)
+        // |
+        TreeTester::default()
+            .with_chain_num(1)
+            .with_block_to_chain(HashMap::from([(block1.hash, 0), (block2.hash, 0)]))
+            .with_fork_to_child(HashMap::from([(block1.parent_hash, HashSet::from([block1.hash]))]))
+            .assert(&tree);
+
+        // make block1 canonical
+        assert_eq!(tree.make_canonical(&block1.hash()), Ok(()));
+        // make block2 canonical
+        assert_eq!(tree.make_canonical(&block2.hash()), Ok(()));
+
+        // Trie state:
+        // b2 (canonical block)
+        // |
+        // |
+        // b1 (canonical block)
+        // |
+        // |
+        // g1 (canonical blocks)
+        // |
+        TreeTester::default()
+            .with_chain_num(0)
+            .with_block_to_chain(HashMap::from([]))
+            .with_fork_to_child(HashMap::from([]))
+            .assert(&tree);
+
+        let mut block1a = block1.clone();
+        let block1a_hash = H256([0x33; 32]);
+        block1a.hash = block1a_hash;
+        let mut block2a = block2.clone();
+        let block2a_hash = H256([0x34; 32]);
+        block2a.hash = block2a_hash;
+
+        // reinsert two blocks that point to canonical chain
+        assert_eq!(tree.insert_block_with_senders(&block1a), Ok(BlockStatus::Accepted));
+
+        TreeTester::default()
+            .with_chain_num(1)
+            .with_block_to_chain(HashMap::from([(block1a_hash, 1)]))
+            .with_fork_to_child(HashMap::from([(
+                block1.parent_hash,
+                HashSet::from([block1a_hash]),
+            )]))
+            .assert(&tree);
+
+        assert_eq!(tree.insert_block_with_senders(&block2a), Ok(BlockStatus::Accepted));
+        // Trie state:
+        // b2   b2a (side chain)
+        // |   /
+        // | /
+        // b1  b1a (side chain)
+        // |  /
+        // |/
+        // g1 (10)
+        // |
+        TreeTester::default()
+            .with_chain_num(2)
+            .with_block_to_chain(HashMap::from([(block1a_hash, 1), (block2a_hash, 2)]))
+            .with_fork_to_child(HashMap::from([
+                (block1.parent_hash, HashSet::from([block1a_hash])),
+                (block1.hash(), HashSet::from([block2a_hash])),
+            ]))
+            .assert(&tree);
+
+        // make b2a canonical
+        assert_eq!(tree.make_canonical(&block2a_hash), Ok(()));
+        // Trie state:
+        // b2a   b2 (side chain)
+        // |   /
+        // | /
+        // b1  b1a (side chain)
+        // |  /
+        // |/
+        // g1 (10)
+        // |
+        TreeTester::default()
+            .with_chain_num(2)
+            .with_block_to_chain(HashMap::from([(block1a_hash, 1), (block2.hash, 3)]))
+            .with_fork_to_child(HashMap::from([
+                (block1.parent_hash, HashSet::from([block1a_hash])),
+                (block1.hash(), HashSet::from([block2.hash])),
+            ]))
+            .assert(&tree);
+
+        assert_eq!(tree.make_canonical(&block1a_hash), Ok(()));
+        // Trie state:
+        //       b2a   b2 (side chain)
+        //       |   /
+        //       | /
+        // b1a  b1 (side chain)
+        // |  /
+        // |/
+        // g1 (10)
+        // |
+        TreeTester::default()
+            .with_chain_num(2)
+            .with_block_to_chain(HashMap::from([
+                (block1.hash, 4),
+                (block2a_hash, 4),
+                (block2.hash, 3),
+            ]))
+            .with_fork_to_child(HashMap::from([
+                (block1.parent_hash, HashSet::from([block1.hash])),
+                (block1.hash(), HashSet::from([block2.hash])),
+            ]))
+            .assert(&tree);
+
+        // make b2 canonical
+        assert_eq!(tree.make_canonical(&block2.hash()), Ok(()));
+        // Trie state:
+        // b2   b2a (side chain)
+        // |   /
+        // | /
+        // b1  b1a (side chain)
+        // |  /
+        // |/
+        // g1 (10)
+        // |
+        TreeTester::default()
+            .with_chain_num(2)
+            .with_block_to_chain(HashMap::from([(block1a_hash, 5), (block2a_hash, 4)]))
+            .with_fork_to_child(HashMap::from([
+                (block1.parent_hash, HashSet::from([block1a_hash])),
+                (block1.hash(), HashSet::from([block2a_hash])),
+            ]))
+            .assert(&tree);
+
+        // finalize b1 that would make b1a removed from tree
+        tree.finalize_block(11);
+        // Trie state:
+        // b2   b2a (side chain)
+        // |   /
+        // | /
+        // b1 (canon)
+        // |
+        // g1 (10)
+        // |
+        TreeTester::default()
+            .with_chain_num(1)
+            .with_block_to_chain(HashMap::from([(block2a_hash, 4)]))
+            .with_fork_to_child(HashMap::from([(block1.hash(), HashSet::from([block2a_hash]))]))
+            .assert(&tree);
+
+        // unwind canonical
+        assert_eq!(tree.unwind(block1.number), Ok(()));
+        // Trie state:
+        //    b2   b2a (pending block)
+        //   /    /
+        //  /   /
+        // /  /
+        // b1 (canonical block)
+        // |
+        // |
+        // g1 (canonical blocks)
+        // |
+        TreeTester::default()
+            .with_chain_num(2)
+            .with_block_to_chain(HashMap::from([(block2a_hash, 4), (block2.hash, 6)]))
+            .with_fork_to_child(HashMap::from([(
+                block1.hash(),
+                HashSet::from([block2a_hash, block2.hash]),
+            )]))
+            .assert(&tree);
+
+        // commit b2a
+        assert_eq!(tree.make_canonical(&block2.hash), Ok(()));
+        // Trie state:
+        // b2   b2a (side chain)
+        // |   /
+        // | /
+        // b1 (canon)
+        // |
+        // g1 (10)
+        // |
+        TreeTester::default()
+            .with_chain_num(1)
+            .with_block_to_chain(HashMap::from([(block2a_hash, 4)]))
+            .with_fork_to_child(HashMap::from([(block1.hash(), HashSet::from([block2a_hash]))]))
+            .assert(&tree);
+
+        // update canonical block to b2, this would make b2a be removed
+        assert_eq!(tree.restore_canonical_hashes(12), Ok(()));
+        // Trie state:
+        // b2 (canon)
+        // |
+        // b1 (canon)
+        // |
+        // g1 (10)
+        // |
+        TreeTester::default()
+            .with_chain_num(0)
+            .with_block_to_chain(HashMap::from([]))
+            .with_fork_to_child(HashMap::from([]))
+            .assert(&tree);
+    }
+}
diff --git a/crates/executor/src/execution_result.rs b/crates/executor/src/execution_result.rs
deleted file mode 100644
index 3f1b433facc..00000000000
--- a/crates/executor/src/execution_result.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-use reth_db::{models::AccountBeforeTx, tables, transaction::DbTxMut, Error as DbError};
-use reth_primitives::{Account, Address, Receipt, H256, U256};
-use revm::primitives::Bytecode;
-use std::collections::BTreeMap;
-
-/// Execution Result containing vector of transaction changesets
-/// and block reward if present
-#[derive(Debug)]
-pub struct ExecutionResult {
-    /// Transaction changeset containing [Receipt], changed [Accounts][Account] and Storages.
-    pub tx_changesets: Vec<TransactionChangeSet>,
-    /// Post block account changesets. This might include block reward, uncle rewards, withdrawals
-    /// or irregular state changes (DAO fork).
-    pub block_changesets: BTreeMap<Address, AccountInfoChangeSet>,
-}
-
-/// After transaction is executed this structure contain
-/// transaction [Receipt] every change to state ([Account], Storage, [Bytecode])
-/// that this transaction made and its old values
-/// so that history account table can be updated.
-#[derive(Debug, Clone)]
-pub struct TransactionChangeSet {
-    /// Transaction receipt
-    pub receipt: Receipt,
-    /// State change that this transaction made on state.
-    pub changeset: BTreeMap<Address, AccountChangeSet>,
-    /// new bytecode created as result of transaction execution.
-    pub new_bytecodes: BTreeMap<H256, Bytecode>,
-}
-
-/// Contains old/new account changes
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum AccountInfoChangeSet {
-    /// The account is newly created.
-    Created {
-        /// The newly created account.
-        new: Account,
-    },
-    /// An account was deleted (selfdestructed) or we have touched
-    /// an empty account and we need to remove/destroy it.
-    /// (Look at state clearing [EIP-158](https://eips.ethereum.org/EIPS/eip-158))
-    Destroyed {
-        /// The account that was destroyed.
-        old: Account,
-    },
-    /// The account was changed.
-    Changed {
-        /// The account after the change.
-        new: Account,
-        /// The account prior to the change.
-        old: Account,
-    },
-    /// Nothing was changed for the account (nonce/balance).
-    NoChange,
-}
-
-impl AccountInfoChangeSet {
-    /// Apply the changes from the changeset to a database transaction.
-    pub fn apply_to_db<'a, TX: DbTxMut<'a>>(
-        self,
-        tx: &TX,
-        address: Address,
-        tx_index: u64,
-        has_state_clear_eip: bool,
-    ) -> Result<(), DbError> {
-        match self {
-            AccountInfoChangeSet::Changed { old, new } => {
-                // insert old account in AccountChangeSet
-                // check for old != new was already done
-                tx.put::<tables::AccountChangeSet>(
-                    tx_index,
-                    AccountBeforeTx { address, info: Some(old) },
-                )?;
-                tx.put::<tables::PlainAccountState>(address, new)?;
-            }
-            AccountInfoChangeSet::Created { new } => {
-                // Ignore account that are created empty and state clear (SpuriousDragon) hardfork
-                // is activated.
-                if has_state_clear_eip && new.is_empty() {
-                    return Ok(())
-                }
-                tx.put::<tables::AccountChangeSet>(
-                    tx_index,
-                    AccountBeforeTx { address, info: None },
-                )?;
-                tx.put::<tables::PlainAccountState>(address, new)?;
-            }
-            AccountInfoChangeSet::Destroyed { old } => {
-                tx.delete::<tables::PlainAccountState>(address, None)?;
-                tx.put::<tables::AccountChangeSet>(
-                    tx_index,
-                    AccountBeforeTx { address, info: Some(old) },
-                )?;
-            }
-            AccountInfoChangeSet::NoChange => {
-                // do nothing storage account didn't change
-            }
-        }
-        Ok(())
-    }
-}
-
-/// Diff change set that is needed for creating history index and updating current world state.
-#[derive(Debug, Clone)]
-pub struct AccountChangeSet {
-    /// Old and New account account change.
-    pub account: AccountInfoChangeSet,
-    /// Storage containing key -> (OldValue,NewValue). in case that old value is not existing
-    /// we can expect to have U256::ZERO, same with new value.
-    pub storage: BTreeMap<U256, (U256, U256)>,
-    /// Just to make sure that we are taking selfdestruct cleaning we have this field that wipes
-    /// storage. There are instances where storage is changed but account is not touched, so we
-    /// can't take into account that if new account is None that it is selfdestruct.
-    pub wipe_storage: bool,
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use reth_db::{
-        database::Database,
-        mdbx::{test_utils, Env, EnvKind, WriteMap},
-        transaction::DbTx,
-    };
-    use reth_primitives::H160;
-
-    use super::*;
-
-    #[test]
-    fn apply_account_info_changeset() {
-        let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
-        let address = H160::zero();
-        let tx_num = 0;
-        let acc1 = Account { balance: U256::from(1), nonce: 2, bytecode_hash: Some(H256::zero()) };
-        let acc2 = Account { balance: U256::from(3), nonce: 4, bytecode_hash: Some(H256::zero()) };
-
-        let tx = db.tx_mut().unwrap();
-
-        // check Changed changeset
-        AccountInfoChangeSet::Changed { new: acc1, old: acc2 }
-            .apply_to_db(&tx, address, tx_num, true)
-            .unwrap();
-        assert_eq!(
-            tx.get::<tables::AccountChangeSet>(tx_num),
-            Ok(Some(AccountBeforeTx { address, info: Some(acc2) }))
-        );
-        assert_eq!(tx.get::<tables::PlainAccountState>(address), Ok(Some(acc1)));
-
-        AccountInfoChangeSet::Created { new: acc1 }
-            .apply_to_db(&tx, address, tx_num, true)
-            .unwrap();
-        assert_eq!(
-            tx.get::<tables::AccountChangeSet>(tx_num),
-            Ok(Some(AccountBeforeTx { address, info: None }))
-        );
-        assert_eq!(tx.get::<tables::PlainAccountState>(address), Ok(Some(acc1)));
-
-        // delete old value, as it is dupsorted
-        tx.delete::<tables::AccountChangeSet>(tx_num, None).unwrap();
-
-        AccountInfoChangeSet::Destroyed { old: acc2 }
-            .apply_to_db(&tx, address, tx_num, true)
-            .unwrap();
-        assert_eq!(tx.get::<tables::PlainAccountState>(address), Ok(None));
-        assert_eq!(
-            tx.get::<tables::AccountChangeSet>(tx_num),
-            Ok(Some(AccountBeforeTx { address, info: Some(acc2) }))
-        );
-    }
-}
diff --git a/crates/executor/src/executor.rs b/crates/executor/src/executor.rs
index 24125d5551e..2e56a72090c 100644
--- a/crates/executor/src/executor.rs
+++ b/crates/executor/src/executor.rs
@@ -1,49 +1,73 @@
-use crate::execution_result::{
-    AccountChangeSet, AccountInfoChangeSet, ExecutionResult, TransactionChangeSet,
-};
-use hashbrown::hash_map::Entry;
-use reth_interfaces::executor::{BlockExecutor, Error};
+use crate::post_state::PostState;
+use reth_interfaces::executor::Error;
 use reth_primitives::{
-    bloom::logs_bloom, Account, Address, Block, Bloom, ChainSpec, Hardfork, Header, Log, Receipt,
-    TransactionSigned, H256, U256,
+    bloom::logs_bloom, Account, Address, Block, Bloom, Bytecode, ChainSpec, Hardfork, Header, Log,
+    Receipt, TransactionSigned, H256, U256,
 };
-use reth_provider::StateProvider;
+use reth_provider::{BlockExecutor, StateProvider};
 use reth_revm::{
     config::{WEI_2ETH, WEI_3ETH, WEI_5ETH},
     database::SubState,
     env::{fill_cfg_and_block_env, fill_tx_env},
     into_reth_log, to_reth_acc,
 };
+use reth_revm_inspectors::stack::{InspectorStack, InspectorStackConfig};
 use revm::{
     db::AccountState,
-    primitives::{Account as RevmAccount, AccountInfo, Bytecode, ResultAndState},
+    primitives::{
+        hash_map::{self, Entry},
+        Account as RevmAccount, AccountInfo, ResultAndState,
+    },
     EVM,
 };
-use std::collections::{BTreeMap, HashMap};
+use std::{
+    collections::{BTreeMap, HashMap},
+    sync::Arc,
+};
 
 /// Main block executor
-pub struct Executor<'a, DB>
+pub struct Executor<DB>
+where
+    DB: StateProvider,
+{
+    /// The configured chain-spec
+    pub chain_spec: Arc<ChainSpec>,
+    evm: EVM<SubState<DB>>,
+    stack: InspectorStack,
+}
+
+impl<DB> From<Arc<ChainSpec>> for Executor<DB>
 where
     DB: StateProvider,
 {
-    chain_spec: &'a ChainSpec,
-    evm: EVM<&'a mut SubState<DB>>,
-    /// Enable revm inspector printer.
-    /// In execution this will print opcode level traces directly to console.
-    pub use_printer_tracer: bool,
+    /// Instantiates a new executor from the chainspec. Must call
+    /// `with_db` to set the database before executing.
+    fn from(chain_spec: Arc<ChainSpec>) -> Self {
+        let evm = EVM::new();
+        Executor { chain_spec, evm, stack: InspectorStack::new(InspectorStackConfig::default()) }
+    }
 }
 
-impl<'a, DB> Executor<'a, DB>
+impl<DB> Executor<DB>
 where
     DB: StateProvider,
 {
-    fn new(chain_spec: &'a ChainSpec, db: &'a mut SubState<DB>) -> Self {
+    /// Creates a new executor from the given chain spec and database.
+    pub fn new(chain_spec: Arc<ChainSpec>, db: SubState<DB>) -> Self {
         let mut evm = EVM::new();
         evm.database(db);
-        Executor { chain_spec, evm, use_printer_tracer: false }
+
+        Executor { chain_spec, evm, stack: InspectorStack::new(InspectorStackConfig::default()) }
     }
 
-    fn db(&mut self) -> &mut SubState<DB> {
+    /// Configures the executor with the given inspectors.
+    pub fn with_stack(mut self, stack: InspectorStack) -> Self {
+        self.stack = stack;
+        self
+    }
+
+    /// Gives a reference to the database
+    pub fn db(&mut self) -> &mut SubState<DB> {
         self.evm.db().expect("db to not be moved")
     }
 
@@ -65,25 +89,25 @@ where
 
     /// Initializes the config and block env.
     fn init_env(&mut self, header: &Header, total_difficulty: U256) {
-        fill_cfg_and_block_env(&mut self.evm.env, self.chain_spec, header, total_difficulty);
+        fill_cfg_and_block_env(
+            &mut self.evm.env.cfg,
+            &mut self.evm.env.block,
+            &self.chain_spec,
+            header,
+            total_difficulty,
+        );
     }
 
-    /// Commit change to database and return change diff that is used to update state and create
-    /// history index
-    ///
-    /// ChangeDiff consists of:
-    ///     address->AccountChangeSet (It contains old and new account info,storage wipe flag, and
-    /// old/new storage)     bytecode_hash->bytecodes mapping
-    ///
-    /// BTreeMap is used to have sorted values
+    /// Commit change to the run-time database, and update the given [PostState] with the changes
+    /// made in the transaction, which can be persisted to the database.
     fn commit_changes(
         &mut self,
-        changes: hashbrown::HashMap<Address, RevmAccount>,
-    ) -> (BTreeMap<Address, AccountChangeSet>, BTreeMap<H256, Bytecode>) {
+        changes: hash_map::HashMap<Address, RevmAccount>,
+        has_state_clear_eip: bool,
+        post_state: &mut PostState,
+    ) {
         let db = self.db();
 
-        let mut change = BTreeMap::new();
-        let mut new_bytecodes = BTreeMap::new();
         // iterate over all changed accounts
         for (address, account) in changes {
             if account.is_destroyed {
@@ -96,16 +120,8 @@ where
                 };
                 // Insert into `change` a old account and None for new account
                 // and mark storage to be mapped
-                change.insert(
-                    address,
-                    AccountChangeSet {
-                        account: AccountInfoChangeSet::Destroyed {
-                            old: to_reth_acc(&db_account.info),
-                        },
-                        storage: BTreeMap::new(),
-                        wipe_storage: true,
-                    },
-                );
+                post_state.destroy_account(address, to_reth_acc(&db_account.info));
+
                 // clear cached DB and mark account as not existing
                 db_account.storage.clear();
                 db_account.account_state = AccountState::NotExisting;
@@ -117,83 +133,84 @@ where
                 // does it exist inside cached contracts if it doesn't it is new bytecode that
                 // we are inserting inside `change`
                 if let Some(ref code) = account.info.code {
-                    if !code.is_empty() {
-                        match db.contracts.entry(account.info.code_hash) {
-                            Entry::Vacant(entry) => {
-                                entry.insert(code.clone());
-                                new_bytecodes.insert(H256(account.info.code_hash.0), code.clone());
-                            }
-                            Entry::Occupied(mut entry) => {
-                                entry.insert(code.clone());
-                            }
-                        }
+                    if !code.is_empty() && !db.contracts.contains_key(&account.info.code_hash) {
+                        db.contracts.insert(account.info.code_hash, code.clone());
+                        post_state.add_bytecode(account.info.code_hash, Bytecode(code.clone()));
                     }
                 }
 
                 // get old account that is going to be overwritten or none if it does not exist
                 // and get new account that was just inserted. new account mut ref is used for
                 // inserting storage
-                let (account_info_changeset, new_account) = match db.accounts.entry(address) {
+                let cached_account = match db.accounts.entry(address) {
                     Entry::Vacant(entry) => {
                         let entry = entry.insert(Default::default());
                         entry.info = account.info.clone();
-                        // account was not existing, so this means new account is created
-                        (AccountInfoChangeSet::Created { new: to_reth_acc(&entry.info) }, entry)
+
+                        let account = to_reth_acc(&entry.info);
+                        if !(has_state_clear_eip && account.is_empty()) {
+                            post_state.create_account(address, account);
+                        }
+                        entry
                     }
                     Entry::Occupied(entry) => {
                         let entry = entry.into_mut();
 
-                        // account is present inside cache but is marked as NotExisting.
-                        let account_changeset =
-                            if matches!(entry.account_state, AccountState::NotExisting) {
-                                AccountInfoChangeSet::Created { new: to_reth_acc(&account.info) }
-                            } else if entry.info != account.info {
-                                AccountInfoChangeSet::Changed {
-                                    old: to_reth_acc(&entry.info),
-                                    new: to_reth_acc(&account.info),
-                                }
-                            } else {
-                                AccountInfoChangeSet::NoChange
-                            };
+                        if matches!(entry.account_state, AccountState::NotExisting) {
+                            let account = to_reth_acc(&account.info);
+                            if !(has_state_clear_eip && account.is_empty()) {
+                                post_state.create_account(address, account);
+                            }
+                        } else if entry.info != account.info {
+                            post_state.change_account(
+                                address,
+                                to_reth_acc(&entry.info),
+                                to_reth_acc(&account.info),
+                            );
+                        } else if has_state_clear_eip && account.is_empty() {
+                            // The account was touched, but it is empty, so it should be deleted.
+                            post_state.destroy_account(address, to_reth_acc(&account.info));
+                        }
+
                         entry.info = account.info.clone();
-                        (account_changeset, entry)
+                        entry
                     }
                 };
 
-                new_account.account_state = if account.storage_cleared {
-                    new_account.storage.clear();
+                cached_account.account_state = if account.storage_cleared {
+                    cached_account.storage.clear();
+                    AccountState::StorageCleared
+                } else if cached_account.account_state.is_storage_cleared() {
+                    // the account already exists and its storage was cleared, preserve its previous
+                    // state
                     AccountState::StorageCleared
                 } else {
                     AccountState::Touched
                 };
 
                 // Insert storage.
-                let mut storage = BTreeMap::new();
+                let mut storage_changeset = BTreeMap::new();
 
                 // insert storage into new db account.
-                new_account.storage.extend(account.storage.into_iter().map(|(key, value)| {
-                    storage.insert(key, (value.original_value(), value.present_value()));
+                cached_account.storage.extend(account.storage.into_iter().map(|(key, value)| {
+                    storage_changeset.insert(key, (value.original_value(), value.present_value()));
                     (key, value.present_value())
                 }));
 
                 // Insert into change.
-                change.insert(
-                    address,
-                    AccountChangeSet {
-                        account: account_info_changeset,
-                        storage,
-                        wipe_storage: false,
-                    },
-                );
+                if !storage_changeset.is_empty() {
+                    post_state.change_storage(address, storage_changeset);
+                }
             }
         }
-        (change, new_bytecodes)
     }
 
-    /// Collect all balance changes at the end of the block. Balance changes might include block
-    /// reward, uncle rewards, withdrawals or irregular state changes (DAO fork).
+    /// Collect all balance changes at the end of the block.
+    ///
+    /// Balance changes might include the block reward, uncle rewards, withdrawals, or irregular
+    /// state changes (DAO fork).
     fn post_block_balance_increments(
-        &mut self,
+        &self,
         block: &Block,
         td: U256,
     ) -> Result<HashMap<Address, U256>, Error> {
@@ -255,48 +272,36 @@ where
     }
 
     /// Irregular state change at Ethereum DAO hardfork
-    fn dao_fork_changeset(&mut self) -> Result<BTreeMap<Address, AccountInfoChangeSet>, Error> {
+    fn apply_dao_fork_changes(&mut self, post_state: &mut PostState) -> Result<(), Error> {
         let db = self.db();
 
         let mut drained_balance = U256::ZERO;
 
         // drain all accounts ether
-        let mut changesets = crate::eth_dao_fork::DAO_HARDKFORK_ACCOUNTS
-            .iter()
-            .map(|&address| {
-                let db_account = db.load_account(address).map_err(|_| Error::ProviderError)?;
-                let old = to_reth_acc(&db_account.info);
-                // drain balance
-                drained_balance += core::mem::take(&mut db_account.info.balance);
-                let new = to_reth_acc(&db_account.info);
-                // assume it is changeset as it is irregular state change
-                Ok((address, AccountInfoChangeSet::Changed { new, old }))
-            })
-            .collect::<Result<BTreeMap<Address, AccountInfoChangeSet>, _>>()?;
+        for address in crate::eth_dao_fork::DAO_HARDKFORK_ACCOUNTS {
+            let db_account = db.load_account(address).map_err(|_| Error::ProviderError)?;
+            let old = to_reth_acc(&db_account.info);
+            // drain balance
+            drained_balance += core::mem::take(&mut db_account.info.balance);
+            let new = to_reth_acc(&db_account.info);
+            // assume it is changeset as it is irregular state change
+            post_state.change_account(address, old, new);
+        }
 
         // add drained ether to beneficiary.
         let beneficiary = crate::eth_dao_fork::DAO_HARDFORK_BENEFICIARY;
+        self.increment_account_balance(beneficiary, drained_balance, post_state)?;
 
-        let beneficiary_db_account =
-            db.load_account(beneficiary).map_err(|_| Error::ProviderError)?;
-        let old = to_reth_acc(&beneficiary_db_account.info);
-        beneficiary_db_account.info.balance += drained_balance;
-        let new = to_reth_acc(&beneficiary_db_account.info);
-
-        let beneficiary_changeset = AccountInfoChangeSet::Changed { new, old };
-
-        // insert changeset
-        changesets.insert(beneficiary, beneficiary_changeset);
-
-        Ok(changesets)
+        Ok(())
     }
 
-    /// Generate balance increment account changeset and mutate account database entry in place.
-    fn account_balance_increment_changeset(
+    /// Increment the balance for the given account in the [PostState].
+    fn increment_account_balance(
         &mut self,
         address: Address,
         increment: U256,
-    ) -> Result<AccountInfoChangeSet, Error> {
+        post_state: &mut PostState,
+    ) -> Result<(), Error> {
         let db = self.db();
         let beneficiary = db.load_account(address).map_err(|_| Error::ProviderError)?;
         let old = to_reth_acc(&beneficiary.info);
@@ -310,9 +315,10 @@ where
                 beneficiary.account_state = AccountState::StorageCleared;
 
                 // if account was not present append `Created` changeset
-                Ok(AccountInfoChangeSet::Created {
-                    new: Account { nonce: 0, balance: new.balance, bytecode_hash: None },
-                })
+                post_state.create_account(
+                    address,
+                    Account { nonce: 0, balance: new.balance, bytecode_hash: None },
+                )
             }
 
             AccountState::StorageCleared | AccountState::Touched | AccountState::None => {
@@ -323,30 +329,64 @@ where
                     beneficiary.account_state = AccountState::Touched;
                 }
                 // if account was present, append changed changeset.
-                Ok(AccountInfoChangeSet::Changed { new, old })
+                post_state.change_account(address, old, new);
             }
         }
+
+        Ok(())
     }
-}
 
-impl<'a, DB> BlockExecutor<ExecutionResult> for Executor<'a, DB>
-where
-    DB: StateProvider,
-{
-    fn execute(
+    /// Runs a single transaction in the configured environment and proceeds
+    /// to return the result and state diff (without applying it).
+    ///
+    /// Assumes the rest of the block environment has been filled via `init_block_env`.
+    pub fn transact(
+        &mut self,
+        transaction: &TransactionSigned,
+        sender: Address,
+    ) -> Result<ResultAndState, Error> {
+        // Fill revm structure.
+        fill_tx_env(&mut self.evm.env.tx, transaction, sender);
+
+        let hash = transaction.hash();
+        let out = if self.stack.should_inspect(&self.evm.env, hash) {
+            // execution with inspector.
+            let output = self.evm.inspect(&mut self.stack);
+            tracing::trace!(
+                target: "evm",
+                ?hash, ?output, ?transaction, env = ?self.evm.env,
+                "Executed transaction"
+            );
+            output
+        } else {
+            // main execution.
+            self.evm.transact()
+        };
+        out.map_err(|e| Error::EVM { hash, message: format!("{e:?}") })
+    }
+
+    /// Runs the provided transactions and commits their state to the run-time database.
+    ///
+    /// The returned [PostState] can be used to persist the changes to disk, and contains the
+    /// changes made by each transaction.
+    ///
+    /// The changes in [PostState] have a transition ID associated with them: there is one
+    /// transition ID for each transaction (with the first executed tx having transition ID 0, and
+    /// so on).
+    ///
+    /// The second returned value represents the total gas used by this block of transactions.
+    pub fn execute_transactions(
         &mut self,
         block: &Block,
         total_difficulty: U256,
         senders: Option<Vec<Address>>,
-    ) -> Result<ExecutionResult, Error> {
+    ) -> Result<(PostState, u64), Error> {
         let senders = self.recover_senders(&block.body, senders)?;
 
         self.init_env(&block.header, total_difficulty);
 
         let mut cumulative_gas_used = 0;
-        // output of execution
-        let mut tx_changesets = Vec::with_capacity(block.body.len());
-
+        let mut post_state = PostState::with_tx_capacity(block.body.len());
         for (transaction, sender) in block.body.iter().zip(senders.into_iter()) {
             // The sum of the transaction’s gas limit, Tg, and the gas utilised in this block prior,
             // must be no greater than the block’s gasLimit.
@@ -357,30 +397,15 @@ where
                     block_available_gas,
                 })
             }
-
-            // Fill revm structure.
-            fill_tx_env(&mut self.evm.env.tx, transaction, sender);
-
             // Execute transaction.
-            let out = if self.use_printer_tracer {
-                // execution with inspector.
-                let output = self.evm.inspect(revm::inspectors::CustomPrintTracer::default());
-                tracing::trace!(
-                    target: "evm",
-                    hash = ?transaction.hash(), ?output, ?transaction, env = ?self.evm.env,
-                    "Executed transaction"
-                );
-                output
-            } else {
-                // main execution.
-                self.evm.transact()
-            };
-
-            // cast the error and extract returnables.
-            let ResultAndState { result, state } = out.map_err(|e| Error::EVM(format!("{e:?}")))?;
+            let ResultAndState { result, state } = self.transact(transaction, sender)?;
 
             // commit changes
-            let (changeset, new_bytecodes) = self.commit_changes(state);
+            self.commit_changes(
+                state,
+                self.chain_spec.fork(Hardfork::SpuriousDragon).active_at_block(block.number),
+                &mut post_state,
+            );
 
             // append gas used
             cumulative_gas_used += result.gas_used();
@@ -389,66 +414,81 @@ where
             let logs: Vec<Log> = result.logs().into_iter().map(into_reth_log).collect();
 
             // Push transaction changeset and calculate header bloom filter for receipt.
-            tx_changesets.push(TransactionChangeSet {
-                receipt: Receipt {
-                    tx_type: transaction.tx_type(),
-                    // Success flag was added in `EIP-658: Embedding transaction status code in
-                    // receipts`.
-                    success: result.is_success(),
-                    cumulative_gas_used,
-                    bloom: logs_bloom(logs.iter()),
-                    logs,
-                },
-                changeset,
-                new_bytecodes,
+            post_state.add_receipt(Receipt {
+                tx_type: transaction.tx_type(),
+                // Success flag was added in `EIP-658: Embedding transaction status code in
+                // receipts`.
+                success: result.is_success(),
+                cumulative_gas_used,
+                bloom: logs_bloom(logs.iter()),
+                logs,
             });
+            post_state.finish_transition();
         }
 
+        Ok((post_state, cumulative_gas_used))
+    }
+}
+
+impl<DB> BlockExecutor<DB> for Executor<DB>
+where
+    DB: StateProvider,
+{
+    fn execute(
+        &mut self,
+        block: &Block,
+        total_difficulty: U256,
+        senders: Option<Vec<Address>>,
+    ) -> Result<PostState, Error> {
+        let (mut post_state, cumulative_gas_used) =
+            self.execute_transactions(block, total_difficulty, senders)?;
+
         // Check if gas used matches the value set in header.
         if block.gas_used != cumulative_gas_used {
             return Err(Error::BlockGasUsed { got: cumulative_gas_used, expected: block.gas_used })
         }
 
-        let mut block_changesets = BTreeMap::default();
         let balance_increments = self.post_block_balance_increments(block, total_difficulty)?;
-        for (address, increment) in balance_increments {
-            let changeset = self.account_balance_increment_changeset(address, increment)?;
-            block_changesets.insert(address, changeset);
+        let mut includes_block_transition = !balance_increments.is_empty();
+        for (address, increment) in balance_increments.into_iter() {
+            self.increment_account_balance(address, increment, &mut post_state)?;
         }
 
         if self.chain_spec.fork(Hardfork::Dao).transitions_at_block(block.number) {
-            for (address, changeset) in self.dao_fork_changeset()? {
-                // No account collision between rewarded accounts and DAO fork related accounts.
-                block_changesets.insert(address, changeset);
-            }
+            includes_block_transition = true;
+            self.apply_dao_fork_changes(&mut post_state)?;
+        }
+
+        if includes_block_transition {
+            post_state.finish_transition();
         }
 
-        Ok(ExecutionResult { tx_changesets, block_changesets })
+        Ok(post_state)
     }
-}
 
-/// Execute and verify block
-pub fn execute_and_verify_receipt<DB: StateProvider>(
-    block: &Block,
-    total_difficulty: U256,
-    senders: Option<Vec<Address>>,
-    chain_spec: &ChainSpec,
-    db: &mut SubState<DB>,
-) -> Result<ExecutionResult, Error> {
-    let execution_result = execute(block, total_difficulty, senders, chain_spec, db)?;
+    fn execute_and_verify_receipt(
+        &mut self,
+        block: &Block,
+        total_difficulty: U256,
+        senders: Option<Vec<Address>>,
+    ) -> Result<PostState, Error> {
+        let post_state = self.execute(block, total_difficulty, senders)?;
+
+        if self.chain_spec.fork(Hardfork::Byzantium).active_at_block(block.header.number) {
+            verify_receipt(
+                block.header.receipts_root,
+                block.header.logs_bloom,
+                post_state.receipts().iter(),
+            )?;
+        }
 
-    let receipts_iter = execution_result.tx_changesets.iter().map(|changeset| &changeset.receipt);
+        // TODO Before Byzantium, receipts contained state root that would mean that expensive
+        // operation as hashing that is needed for state root got calculated in every
+        // transaction This was replaced with is_success flag.
+        // See more about EIP here: https://eips.ethereum.org/EIPS/eip-658
 
-    if chain_spec.fork(Hardfork::Byzantium).active_at_block(block.header.number) {
-        verify_receipt(block.header.receipts_root, block.header.logs_bloom, receipts_iter)?;
+        Ok(post_state)
     }
-
-    // TODO Before Byzantium, receipts contained state root that would mean that expensive operation
-    // as hashing that is needed for state root got calculated in every transaction
-    // This was replaced with is_success flag.
-    // See more about EIP here: https://eips.ethereum.org/EIPS/eip-658
-
-    Ok(execution_result)
 }
 
 /// Verify receipts
@@ -474,29 +514,17 @@ pub fn verify_receipt<'a>(
     Ok(())
 }
 
-/// Verify block. Execute all transaction and compare results.
-/// Returns ChangeSet on transaction granularity.
-/// NOTE: If block reward is still active (Before Paris/Merge) we would return
-/// additional TransactionStatechangeset for account that receives the reward.
-pub fn execute<DB: StateProvider>(
-    block: &Block,
-    total_difficulty: U256,
-    senders: Option<Vec<Address>>,
-    chain_spec: &ChainSpec,
-    db: &mut SubState<DB>,
-) -> Result<ExecutionResult, Error> {
-    let mut executor = Executor::new(chain_spec, db);
-    executor.execute(block, total_difficulty, senders)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use reth_primitives::{
-        hex_literal::hex, keccak256, Account, Address, Bytes, ChainSpecBuilder, ForkCondition,
-        StorageKey, H256, MAINNET, U256,
+        hex_literal::hex, keccak256, Account, Address, BlockNumber, Bytecode, Bytes,
+        ChainSpecBuilder, ForkCondition, StorageKey, H256, MAINNET, U256,
+    };
+    use reth_provider::{
+        post_state::{Change, Storage},
+        AccountProvider, BlockHashProvider, StateProvider,
     };
-    use reth_provider::{AccountProvider, BlockHashProvider, StateProvider};
     use reth_revm::database::State;
     use reth_rlp::Decodable;
     use std::{collections::HashMap, str::FromStr};
@@ -504,8 +532,8 @@ mod tests {
     #[derive(Debug, Default, Clone, Eq, PartialEq)]
     struct StateProviderTest {
         accounts: HashMap<Address, (HashMap<StorageKey, U256>, Account)>,
-        contracts: HashMap<H256, Bytes>,
-        block_hash: HashMap<U256, H256>,
+        contracts: HashMap<H256, Bytecode>,
+        block_hash: HashMap<u64, H256>,
     }
 
     impl StateProviderTest {
@@ -520,7 +548,7 @@ mod tests {
             if let Some(bytecode) = bytecode {
                 let hash = keccak256(&bytecode);
                 account.bytecode_hash = Some(hash);
-                self.contracts.insert(hash, bytecode);
+                self.contracts.insert(hash, Bytecode::new_raw(bytecode.into()));
             }
             self.accounts.insert(address, (storage, account));
         }
@@ -534,9 +562,22 @@ mod tests {
     }
 
     impl BlockHashProvider for StateProviderTest {
-        fn block_hash(&self, number: U256) -> reth_interfaces::Result<Option<H256>> {
+        fn block_hash(&self, number: u64) -> reth_interfaces::Result<Option<H256>> {
             Ok(self.block_hash.get(&number).cloned())
         }
+
+        fn canonical_hashes_range(
+            &self,
+            start: BlockNumber,
+            end: BlockNumber,
+        ) -> reth_interfaces::Result<Vec<H256>> {
+            let range = start..end;
+            Ok(self
+                .block_hash
+                .iter()
+                .filter_map(|(block, hash)| range.contains(block).then_some(*hash))
+                .collect())
+        }
     }
 
     impl StateProvider for StateProviderTest {
@@ -551,9 +592,17 @@ mod tests {
                 .and_then(|(storage, _)| storage.get(&storage_key).cloned()))
         }
 
-        fn bytecode_by_hash(&self, code_hash: H256) -> reth_interfaces::Result<Option<Bytes>> {
+        fn bytecode_by_hash(&self, code_hash: H256) -> reth_interfaces::Result<Option<Bytecode>> {
             Ok(self.contracts.get(&code_hash).cloned())
         }
+
+        fn proof(
+            &self,
+            _address: Address,
+            _keys: &[H256],
+        ) -> reth_interfaces::Result<(Vec<Bytes>, H256, Vec<Vec<Bytes>>)> {
+            todo!()
+        }
     }
 
     #[test]
@@ -602,23 +651,31 @@ mod tests {
         );
 
         // spec at berlin fork
-        let chain_spec = ChainSpecBuilder::mainnet().berlin_activated().build();
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().berlin_activated().build());
 
-        let mut db = SubState::new(State::new(db));
+        let db = SubState::new(State::new(db));
 
         // execute chain and verify receipts
-        let out =
-            execute_and_verify_receipt(&block, U256::ZERO, None, &chain_spec, &mut db).unwrap();
+        let mut executor = Executor::new(chain_spec, db);
+        let post_state = executor.execute_and_verify_receipt(&block, U256::ZERO, None).unwrap();
 
-        assert_eq!(out.tx_changesets.len(), 1, "Should executed one transaction");
+        assert_eq!(
+            post_state.transitions_count(),
+            2,
+            "Should executed two transitions (1 tx and 1 block reward)"
+        );
 
-        let changesets = out.tx_changesets[0].clone();
-        assert_eq!(changesets.new_bytecodes.len(), 0, "Should have zero new bytecodes");
+        let block_reward = U256::from(WEI_2ETH + (WEI_2ETH >> 5));
 
         let account1_info = Account { balance: U256::ZERO, nonce: 0x00, bytecode_hash: None };
         let account2_info = Account {
-            balance: U256::from(0x1bc16d674ece94bau128 - 0x1bc16d674ec80000u128), /* decrease for
-                                                                                   * block reward */
+            // Block reward decrease
+            balance: U256::from(0x1bc16d674ece94bau128 - 0x1bc16d674ec80000u128),
+            nonce: 0x00,
+            bytecode_hash: None,
+        };
+        let account2_info_with_block_reward = Account {
+            balance: account2_info.balance + block_reward,
             nonce: 0x00,
             bytecode_hash: None,
         };
@@ -627,11 +684,12 @@ mod tests {
             nonce: 0x01,
             bytecode_hash: None,
         };
-
-        let block_reward = U256::from(WEI_2ETH + (WEI_2ETH >> 5));
+        let ommer_beneficiary_info =
+            Account { nonce: 0, balance: U256::from((8 * WEI_2ETH) >> 3), bytecode_hash: None };
 
         // Check if cache is set
         // account1
+        let db = executor.db();
         let cached_acc1 = db.accounts.get(&account1).unwrap();
         assert_eq!(cached_acc1.info.balance, account1_info.balance);
         assert_eq!(cached_acc1.info.nonce, account1_info.nonce);
@@ -653,60 +711,88 @@ mod tests {
         assert_eq!(cached_acc3.account_state, AccountState::Touched);
         assert_eq!(cached_acc3.storage.len(), 0);
 
-        assert_eq!(
-            changesets.changeset.get(&account1).unwrap().account,
-            AccountInfoChangeSet::NoChange,
-            "No change to account"
+        assert!(
+            post_state.accounts().get(&account1).is_none(),
+            "Account should not be present in post-state since it was not changed"
         );
+
+        // Check changes
+        const TX_TRANSITION_ID: u64 = 0;
+        const BLOCK_TRANSITION_ID: u64 = 1;
+
+        // Clone and sort to make the test deterministic
+        let mut changes = post_state.changes().to_vec();
+        changes.sort_by_key(|change| (change.transition_id(), change.address()));
         assert_eq!(
-            changesets.changeset.get(&account2).unwrap().account,
-            AccountInfoChangeSet::Created { new: account2_info },
-            "New account"
+            changes,
+            &[
+                // Storage changes on account 1
+                Change::StorageChanged {
+                    id: TX_TRANSITION_ID,
+                    address: account1,
+                    changeset: [(U256::from(1), (U256::ZERO, U256::from(2)))].into()
+                },
+                // New account
+                Change::AccountCreated {
+                    id: TX_TRANSITION_ID,
+                    address: account2,
+                    account: account2_info
+                },
+                // Changed account
+                Change::AccountChanged {
+                    id: TX_TRANSITION_ID,
+                    address: account3,
+                    old: account3_old_info,
+                    new: account3_info
+                },
+                // Block reward
+                Change::AccountChanged {
+                    id: BLOCK_TRANSITION_ID,
+                    address: account2,
+                    old: account2_info,
+                    new: account2_info_with_block_reward
+                },
+                // Ommer reward
+                Change::AccountCreated {
+                    id: BLOCK_TRANSITION_ID,
+                    address: ommer_beneficiary,
+                    account: ommer_beneficiary_info
+                },
+            ],
+            "Changeset did not match"
         );
+
+        // Check final post-state
         assert_eq!(
-            changesets.changeset.get(&account3).unwrap().account,
-            AccountInfoChangeSet::Changed { old: account3_old_info, new: account3_info },
-            "Change to account state"
+            post_state.storage(),
+            &BTreeMap::from([(
+                account1,
+                Storage { wiped: false, storage: BTreeMap::from([(U256::from(1), U256::from(2))]) }
+            )]),
+            "Should have changed 1 storage slot"
         );
+        assert_eq!(post_state.bytecodes().len(), 0, "Should have zero new bytecodes");
 
-        // check block rewards changeset.
-        let mut block_rewarded_acc_info = account2_info;
-        // add Blocks 2 eth reward and 2>>5 for one ommer
-        block_rewarded_acc_info.balance += block_reward;
-
-        // check block reward changeset
+        let accounts = post_state.accounts();
         assert_eq!(
-            out.block_changesets,
-            BTreeMap::from([
-                (
-                    account2,
-                    AccountInfoChangeSet::Changed {
-                        new: block_rewarded_acc_info,
-                        old: account2_info
-                    }
-                ),
-                (
-                    ommer_beneficiary,
-                    AccountInfoChangeSet::Created {
-                        new: Account {
-                            nonce: 0,
-                            balance: U256::from((8 * WEI_2ETH) >> 3),
-                            bytecode_hash: None
-                        }
-                    }
-                )
-            ])
+            accounts.len(),
+            3,
+            "Should have 4 accounts (account 2, 3 and the ommer beneficiary)"
+        );
+        assert_eq!(
+            accounts.get(&account2).unwrap(),
+            &Some(account2_info_with_block_reward),
+            "Account 2 state is wrong"
         );
-
-        assert_eq!(changesets.new_bytecodes.len(), 0, "No new bytecodes");
-
-        // check storage
-        let storage = &changesets.changeset.get(&account1).unwrap().storage;
-        assert_eq!(storage.len(), 1, "Only one storage change");
         assert_eq!(
-            storage.get(&U256::from(1)),
-            Some(&(U256::ZERO, U256::from(2))),
-            "Storage change from 0 to 2 on slot 1"
+            accounts.get(&account3).unwrap(),
+            &Some(account3_info),
+            "Account 3 state is wrong"
+        );
+        assert_eq!(
+            accounts.get(&ommer_beneficiary).unwrap(),
+            &Some(ommer_beneficiary_info),
+            "Ommer beneficiary state is wrong"
         );
     }
 
@@ -727,25 +813,32 @@ mod tests {
             beneficiary_balance += i;
         }
 
-        let chain_spec = ChainSpecBuilder::from(&*MAINNET)
-            .homestead_activated()
-            .with_fork(Hardfork::Dao, ForkCondition::Block(1))
-            .build();
+        let chain_spec = Arc::new(
+            ChainSpecBuilder::from(&*MAINNET)
+                .homestead_activated()
+                .with_fork(Hardfork::Dao, ForkCondition::Block(1))
+                .build(),
+        );
 
-        let mut db = SubState::new(State::new(db));
+        let db = SubState::new(State::new(db));
         // execute chain and verify receipts
-        let out = execute_and_verify_receipt(
-            &Block { header, body: vec![], ommers: vec![], withdrawals: None },
-            U256::ZERO,
-            None,
-            &chain_spec,
-            &mut db,
-        )
-        .unwrap();
-        assert_eq!(out.tx_changesets.len(), 0, "No tx");
+        let mut executor = Executor::new(chain_spec, db);
+        let out = executor
+            .execute_and_verify_receipt(
+                &Block { header, body: vec![], ommers: vec![], withdrawals: None },
+                U256::ZERO,
+                None,
+            )
+            .unwrap();
+        assert_eq!(
+            out.transitions_count(),
+            1,
+            "Should only have 1 transition (the block transition)"
+        );
 
         // Check if cache is set
         // beneficiary
+        let db = executor.db();
         let dao_beneficiary =
             db.accounts.get(&crate::eth_dao_fork::DAO_HARDFORK_BENEFICIARY).unwrap();
 
@@ -756,24 +849,15 @@ mod tests {
         }
 
         // check changesets
-        let change_set =
-            out.block_changesets.get(&crate::eth_dao_fork::DAO_HARDFORK_BENEFICIARY).unwrap();
+        let beneficiary_state =
+            out.accounts().get(&crate::eth_dao_fork::DAO_HARDFORK_BENEFICIARY).unwrap().unwrap();
         assert_eq!(
-            *change_set,
-            AccountInfoChangeSet::Changed {
-                new: Account { balance: U256::from(beneficiary_balance), ..Default::default() },
-                old: Account { balance: U256::ZERO, ..Default::default() }
-            }
+            beneficiary_state,
+            Account { balance: U256::from(beneficiary_balance), ..Default::default() },
         );
-        for (i, address) in crate::eth_dao_fork::DAO_HARDKFORK_ACCOUNTS.iter().enumerate() {
-            let change_set = out.block_changesets.get(address).unwrap();
-            assert_eq!(
-                *change_set,
-                AccountInfoChangeSet::Changed {
-                    new: Account { balance: U256::ZERO, ..Default::default() },
-                    old: Account { balance: U256::from(i), ..Default::default() }
-                }
-            );
+        for address in crate::eth_dao_fork::DAO_HARDKFORK_ACCOUNTS.iter() {
+            let updated_account = out.accounts().get(address).unwrap().unwrap();
+            assert_eq!(updated_account, Account { balance: U256::ZERO, ..Default::default() });
         }
     }
 
@@ -820,18 +904,20 @@ mod tests {
         );
 
         // spec at berlin fork
-        let chain_spec = ChainSpecBuilder::mainnet().berlin_activated().build();
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().berlin_activated().build());
 
-        let mut db = SubState::new(State::new(db));
+        let db = SubState::new(State::new(db));
 
         // execute chain and verify receipts
-        let out =
-            execute_and_verify_receipt(&block, U256::ZERO, None, &chain_spec, &mut db).unwrap();
-
-        assert_eq!(out.tx_changesets.len(), 1, "Should executed one transaction");
+        let mut executor = Executor::new(chain_spec, db);
+        let out = executor.execute_and_verify_receipt(&block, U256::ZERO, None).unwrap();
 
-        let changesets = out.tx_changesets[0].clone();
-        assert_eq!(changesets.new_bytecodes.len(), 0, "Should have zero new bytecodes");
+        assert_eq!(
+            out.transitions_count(),
+            2,
+            "Should only have two transitions (the transaction and the block)"
+        );
+        assert_eq!(out.bytecodes().len(), 0, "Should have zero new bytecodes");
 
         let post_account_caller = Account {
             balance: U256::from(0x0de0b6b3a761cf60u64),
@@ -840,21 +926,20 @@ mod tests {
         };
 
         assert_eq!(
-            changesets.changeset.get(&address_caller).unwrap().account,
-            AccountInfoChangeSet::Changed { new: post_account_caller, old: pre_account_caller },
+            out.accounts().get(&address_caller).unwrap().unwrap(),
+            post_account_caller,
             "Caller account has changed and fee is deduced"
         );
 
-        let selfdestroyer_changeset = changesets.changeset.get(&address_selfdestruct).unwrap();
-
-        // check account
         assert_eq!(
-            selfdestroyer_changeset.account,
-            AccountInfoChangeSet::Destroyed { old: pre_account_selfdestroyed },
-            "Selfdestroyed account"
+            out.accounts().get(&address_selfdestruct).unwrap(),
+            &None,
+            "Selfdestructed account should have been deleted"
+        );
+        assert!(
+            out.storage().get(&address_selfdestruct).unwrap().wiped,
+            "Selfdestructed account should have its storage wiped"
         );
-
-        assert!(selfdestroyer_changeset.wipe_storage);
     }
 
     // Test vector from https://github.com/ethereum/tests/blob/3156db5389921125bb9e04142d18e0e7b0cf8d64/BlockchainTests/EIPTests/bc4895-withdrawals/twoIdenticalIndexDifferentValidator.json
@@ -869,45 +954,99 @@ mod tests {
             Address::from_str("c94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap();
 
         // spec at shanghai fork
-        let chain_spec = ChainSpecBuilder::mainnet().shanghai_activated().build();
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().shanghai_activated().build());
 
-        let mut db = SubState::new(State::new(StateProviderTest::default()));
+        let db = SubState::new(State::new(StateProviderTest::default()));
 
         // execute chain and verify receipts
-        let out =
-            execute_and_verify_receipt(&block, U256::ZERO, None, &chain_spec, &mut db).unwrap();
-        assert_eq!(out.tx_changesets.len(), 0, "No tx");
+        let mut executor = Executor::new(chain_spec, db);
+        let out = executor.execute_and_verify_receipt(&block, U256::ZERO, None).unwrap();
+        assert_eq!(out.transitions_count(), 1, "Only one transition (the block transition)");
 
         let withdrawal_sum = withdrawals.iter().fold(U256::ZERO, |sum, w| sum + w.amount_wei());
-        let beneficiary_account = db.accounts.get(&withdrawal_beneficiary).unwrap();
+        let beneficiary_account = executor.db().accounts.get(&withdrawal_beneficiary).unwrap();
         assert_eq!(beneficiary_account.info.balance, withdrawal_sum);
         assert_eq!(beneficiary_account.info.nonce, 0);
         assert_eq!(beneficiary_account.account_state, AccountState::StorageCleared);
 
-        assert_eq!(out.block_changesets.len(), 1);
         assert_eq!(
-            out.block_changesets.get(&withdrawal_beneficiary),
-            Some(&AccountInfoChangeSet::Created {
-                new: Account { nonce: 0, balance: withdrawal_sum, bytecode_hash: None },
-            })
+            out.accounts().get(&withdrawal_beneficiary).unwrap(),
+            &Some(Account { nonce: 0, balance: withdrawal_sum, bytecode_hash: None }),
+            "Withdrawal account should have gotten its balance set"
         );
 
         // Execute same block again
-        let out =
-            execute_and_verify_receipt(&block, U256::ZERO, None, &chain_spec, &mut db).unwrap();
-        assert_eq!(out.tx_changesets.len(), 0, "No tx");
+        let out = executor.execute_and_verify_receipt(&block, U256::ZERO, None).unwrap();
+        assert_eq!(
+            out.transitions_count(),
+            1,
+            "Should only have one transition (the block transition)"
+        );
 
-        assert_eq!(out.block_changesets.len(), 1);
         assert_eq!(
-            out.block_changesets.get(&withdrawal_beneficiary),
-            Some(&AccountInfoChangeSet::Changed {
-                old: Account { nonce: 0, balance: withdrawal_sum, bytecode_hash: None },
-                new: Account {
-                    nonce: 0,
-                    balance: withdrawal_sum + withdrawal_sum,
-                    bytecode_hash: None
-                },
-            })
+            out.accounts().get(&withdrawal_beneficiary).unwrap(),
+            &Some(Account {
+                nonce: 0,
+                balance: withdrawal_sum + withdrawal_sum,
+                bytecode_hash: None
+            }),
+            "Withdrawal account should have gotten its balance set"
+        );
+    }
+
+    #[test]
+    fn test_account_state_preserved() {
+        let account = Address::from_str("c94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap();
+
+        let mut db = StateProviderTest::default();
+        db.insert_account(account, Account::default(), None, HashMap::default());
+
+        let chain_spec = Arc::new(ChainSpecBuilder::mainnet().istanbul_activated().build());
+        let db = SubState::new(State::new(db));
+
+        let default_acc = RevmAccount {
+            info: AccountInfo::default(),
+            storage: hash_map::HashMap::default(),
+            is_destroyed: false,
+            is_touched: false,
+            storage_cleared: false,
+            is_not_existing: false,
+        };
+        let mut executor = Executor::new(chain_spec, db);
+        // touch account
+        executor.commit_changes(
+            hash_map::HashMap::from([(account, RevmAccount { ..default_acc.clone() })]),
+            true,
+            &mut PostState::default(),
+        );
+        // destroy account
+        executor.commit_changes(
+            hash_map::HashMap::from([(
+                account,
+                RevmAccount { is_destroyed: true, is_touched: true, ..default_acc.clone() },
+            )]),
+            true,
+            &mut PostState::default(),
         );
+        // re-create account
+        executor.commit_changes(
+            hash_map::HashMap::from([(
+                account,
+                RevmAccount { is_touched: true, storage_cleared: true, ..default_acc.clone() },
+            )]),
+            true,
+            &mut PostState::default(),
+        );
+        // touch account
+        executor.commit_changes(
+            hash_map::HashMap::from([(account, RevmAccount { ..default_acc })]),
+            true,
+            &mut PostState::default(),
+        );
+
+        let db = executor.db();
+
+        let account = db.load_account(account).unwrap();
+        assert_eq!(account.account_state, AccountState::StorageCleared);
     }
 }
diff --git a/crates/executor/src/factory.rs b/crates/executor/src/factory.rs
new file mode 100644
index 00000000000..5bd59d0297d
--- /dev/null
+++ b/crates/executor/src/factory.rs
@@ -0,0 +1,34 @@
+use reth_primitives::ChainSpec;
+use reth_provider::{ExecutorFactory, StateProvider};
+use reth_revm::database::{State, SubState};
+
+use crate::executor::Executor;
+use std::sync::Arc;
+
+/// Factory that spawn Executor.
+#[derive(Clone, Debug)]
+pub struct Factory {
+    chain_spec: Arc<ChainSpec>,
+}
+
+impl Factory {
+    /// Create new factory
+    pub fn new(chain_spec: Arc<ChainSpec>) -> Self {
+        Self { chain_spec }
+    }
+}
+
+impl ExecutorFactory for Factory {
+    type Executor<SP: StateProvider> = Executor<SP>;
+
+    /// Executor with [`StateProvider`]
+    fn with_sp<SP: StateProvider>(&self, sp: SP) -> Self::Executor<SP> {
+        let substate = SubState::new(State::new(sp));
+        Executor::new(self.chain_spec.clone(), substate)
+    }
+
+    /// Return internal chainspec
+    fn chain_spec(&self) -> &ChainSpec {
+        self.chain_spec.as_ref()
+    }
+}
diff --git a/crates/executor/src/lib.rs b/crates/executor/src/lib.rs
index 523fc7a0f0d..fbdb1cc1736 100644
--- a/crates/executor/src/lib.rs
+++ b/crates/executor/src/lib.rs
@@ -8,8 +8,20 @@
 //! Reth executor executes transaction in block of data.
 
 pub mod eth_dao_fork;
+pub mod substate;
+
+/// Execution result types.
+pub use reth_provider::post_state;
+
+pub mod blockchain_tree;
 
-/// Execution result types
-pub mod execution_result;
 /// Executor
 pub mod executor;
+
+/// ExecutorFactory impl
+pub mod factory;
+pub use factory::Factory;
+
+#[cfg(any(test, feature = "test-utils"))]
+/// Common test helpers for mocking out executor and executor factory
+pub mod test_utils;
diff --git a/crates/executor/src/substate.rs b/crates/executor/src/substate.rs
new file mode 100644
index 00000000000..082ce140b6b
--- /dev/null
+++ b/crates/executor/src/substate.rs
@@ -0,0 +1,101 @@
+//! Substate for blockchain trees
+
+use reth_interfaces::{provider::ProviderError, Result};
+use reth_primitives::{Account, Address, BlockHash, BlockNumber, Bytecode, Bytes, H256, U256};
+use reth_provider::{post_state::PostState, AccountProvider, BlockHashProvider, StateProvider};
+use std::collections::BTreeMap;
+
+/// A state provider that either resolves to data in a wrapped [`PostState`], or an underlying state
+/// provider.
+pub struct PostStateProvider<'a, SP: StateProvider> {
+    /// The wrapped state after execution of one or more transactions and/or blocks.
+    state: &'a PostState,
+    /// The inner state provider.
+    provider: SP,
+    /// The blocks in the sidechain.
+    sidechain_block_hashes: &'a BTreeMap<BlockNumber, BlockHash>,
+    /// The blocks in the canonical chain.
+    canonical_block_hashes: &'a BTreeMap<BlockNumber, BlockHash>,
+}
+
+impl<'a, SP: StateProvider> PostStateProvider<'a, SP> {
+    /// Create new post-state provider
+    pub fn new(
+        state: &'a PostState,
+        provider: SP,
+        sidechain_block_hashes: &'a BTreeMap<BlockNumber, BlockHash>,
+        canonical_block_hashes: &'a BTreeMap<BlockNumber, BlockHash>,
+    ) -> Self {
+        Self { state, provider, sidechain_block_hashes, canonical_block_hashes }
+    }
+}
+
+/* Implement StateProvider traits */
+
+impl<'a, SP: StateProvider> BlockHashProvider for PostStateProvider<'a, SP> {
+    fn block_hash(&self, block_number: BlockNumber) -> Result<Option<H256>> {
+        if let Some(sidechain_block_hash) = self.sidechain_block_hashes.get(&block_number).cloned()
+        {
+            return Ok(Some(sidechain_block_hash))
+        }
+
+        Ok(Some(
+            self.canonical_block_hashes
+                .get(&block_number)
+                .cloned()
+                .ok_or(ProviderError::BlockchainTreeBlockHash { block_number })?,
+        ))
+    }
+
+    fn canonical_hashes_range(&self, _start: BlockNumber, _end: BlockNumber) -> Result<Vec<H256>> {
+        unimplemented!()
+    }
+}
+
+impl<'a, SP: StateProvider> AccountProvider for PostStateProvider<'a, SP> {
+    fn basic_account(&self, address: Address) -> Result<Option<Account>> {
+        if let Some(account) = self.state.account(&address) {
+            Ok(*account)
+        } else {
+            self.provider.basic_account(address)
+        }
+    }
+}
+
+impl<'a, SP: StateProvider> StateProvider for PostStateProvider<'a, SP> {
+    fn storage(
+        &self,
+        account: Address,
+        storage_key: reth_primitives::StorageKey,
+    ) -> Result<Option<reth_primitives::StorageValue>> {
+        if let Some(storage) = self.state.account_storage(&account) {
+            if storage.wiped {
+                return Ok(Some(U256::ZERO))
+            }
+
+            if let Some(value) =
+                storage.storage.get(&U256::from_be_bytes(storage_key.to_fixed_bytes()))
+            {
+                return Ok(Some(*value))
+            }
+        }
+
+        self.provider.storage(account, storage_key)
+    }
+
+    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytecode>> {
+        if let Some(bytecode) = self.state.bytecode(&code_hash).cloned() {
+            return Ok(Some(bytecode))
+        }
+
+        self.provider.bytecode_by_hash(code_hash)
+    }
+
+    fn proof(
+        &self,
+        _address: Address,
+        _keys: &[H256],
+    ) -> Result<(Vec<Bytes>, H256, Vec<Vec<Bytes>>)> {
+        Err(ProviderError::HistoryStateRoot.into())
+    }
+}
diff --git a/crates/executor/src/test_utils/executor.rs b/crates/executor/src/test_utils/executor.rs
new file mode 100644
index 00000000000..d09338fd5eb
--- /dev/null
+++ b/crates/executor/src/test_utils/executor.rs
@@ -0,0 +1,26 @@
+use reth_interfaces::executor::Error as ExecutionError;
+use reth_primitives::{Address, Block, U256};
+use reth_provider::{post_state::PostState, BlockExecutor, StateProvider};
+
+/// Test executor with mocked result.
+pub struct TestExecutor(pub Option<PostState>);
+
+impl<SP: StateProvider> BlockExecutor<SP> for TestExecutor {
+    fn execute(
+        &mut self,
+        _block: &Block,
+        _total_difficulty: U256,
+        _senders: Option<Vec<Address>>,
+    ) -> Result<PostState, ExecutionError> {
+        self.0.clone().ok_or(ExecutionError::VerificationFailed)
+    }
+
+    fn execute_and_verify_receipt(
+        &mut self,
+        _block: &Block,
+        _total_difficulty: U256,
+        _senders: Option<Vec<Address>>,
+    ) -> Result<PostState, ExecutionError> {
+        self.0.clone().ok_or(ExecutionError::VerificationFailed)
+    }
+}
diff --git a/crates/executor/src/test_utils/factory.rs b/crates/executor/src/test_utils/factory.rs
new file mode 100644
index 00000000000..50e4360ad17
--- /dev/null
+++ b/crates/executor/src/test_utils/factory.rs
@@ -0,0 +1,37 @@
+use super::TestExecutor;
+use parking_lot::Mutex;
+use reth_primitives::ChainSpec;
+use reth_provider::{post_state::PostState, ExecutorFactory, StateProvider};
+use std::sync::Arc;
+
+/// Executor factory with pre-set execution results.
+#[derive(Clone, Debug)]
+pub struct TestExecutorFactory {
+    exec_results: Arc<Mutex<Vec<PostState>>>,
+    chain_spec: Arc<ChainSpec>,
+}
+
+impl TestExecutorFactory {
+    /// Create new instance of test factory.
+    pub fn new(chain_spec: Arc<ChainSpec>) -> Self {
+        Self { exec_results: Arc::new(Mutex::new(Vec::new())), chain_spec }
+    }
+
+    /// Extend the mocked execution results
+    pub fn extend(&self, results: Vec<PostState>) {
+        self.exec_results.lock().extend(results.into_iter());
+    }
+}
+
+impl ExecutorFactory for TestExecutorFactory {
+    type Executor<T: StateProvider> = TestExecutor;
+
+    fn with_sp<SP: StateProvider>(&self, _sp: SP) -> Self::Executor<SP> {
+        let exec_res = self.exec_results.lock().pop();
+        TestExecutor(exec_res)
+    }
+
+    fn chain_spec(&self) -> &ChainSpec {
+        self.chain_spec.as_ref()
+    }
+}
diff --git a/crates/executor/src/test_utils/mod.rs b/crates/executor/src/test_utils/mod.rs
new file mode 100644
index 00000000000..86ef2f53aea
--- /dev/null
+++ b/crates/executor/src/test_utils/mod.rs
@@ -0,0 +1,5 @@
+mod executor;
+pub use executor::*;
+
+mod factory;
+pub use factory::*;
diff --git a/crates/interfaces/Cargo.toml b/crates/interfaces/Cargo.toml
index aeb1b909c5f..d8a81d11542 100644
--- a/crates/interfaces/Cargo.toml
+++ b/crates/interfaces/Cargo.toml
@@ -10,7 +10,7 @@ readme = "README.md"
 reth-codecs = { path = "../storage/codecs" }
 reth-primitives = { path = "../primitives" }
 reth-rpc-types = { path = "../rpc/rpc-types" }
-reth-network-api = { path = "../net/network-api"}
+reth-network-api = { path = "../net/network-api" }
 revm-primitives = "1.0"
 async-trait = "0.1.57"
 thiserror = "1.0.37"
@@ -22,20 +22,28 @@ reth-eth-wire = { path = "../net/eth-wire" }
 
 # codecs
 parity-scale-codec = { version = "3.2.1", features = ["bytes"] }
-futures = "0.3.25"
+futures = "0.3"
 tokio-stream = "0.1.11"
 rand = "0.8.5"
 arbitrary = { version = "1.1.7", features = ["derive"], optional = true }
-secp256k1 = { version = "0.24.2", default-features = false, features = ["alloc", "recovery", "rand"], optional = true }
+secp256k1 = { version = "0.26.0", default-features = false, features = [
+    "alloc",
+    "recovery",
+    "rand",
+], optional = true }
 modular-bitfield = "0.11.2"
 
 [dev-dependencies]
 reth-db = { path = "../storage/db", features = ["test-utils"] }
 tokio = { version = "1.21.2", features = ["full"] }
 tokio-stream = { version = "0.1.11", features = ["sync"] }
-arbitrary = { version = "1.1.7", features = ["derive"]}
+arbitrary = { version = "1.1.7", features = ["derive"] }
 hex-literal = "0.3"
-secp256k1 = { version = "0.24.2", default-features = false, features = ["alloc", "recovery", "rand"] }
+secp256k1 = { version = "0.26.0", default-features = false, features = [
+    "alloc",
+    "recovery",
+    "rand",
+] }
 
 [features]
 bench = []
diff --git a/crates/interfaces/src/consensus.rs b/crates/interfaces/src/consensus.rs
index c940733b64b..5f232b67f30 100644
--- a/crates/interfaces/src/consensus.rs
+++ b/crates/interfaces/src/consensus.rs
@@ -1,7 +1,8 @@
 use async_trait::async_trait;
-use reth_primitives::{BlockHash, BlockNumber, SealedBlock, SealedHeader, H256, U256};
+use reth_primitives::{
+    BlockHash, BlockNumber, InvalidTransactionError, SealedBlock, SealedHeader, H256, U256,
+};
 use std::fmt::Debug;
-use tokio::sync::watch::Receiver;
 
 /// Re-export fork choice state
 pub use reth_rpc_types::engine::ForkchoiceState;
@@ -10,9 +11,6 @@ pub use reth_rpc_types::engine::ForkchoiceState;
 #[async_trait]
 #[auto_impl::auto_impl(&, Arc)]
 pub trait Consensus: Debug + Send + Sync {
-    /// Get a receiver for the fork choice state
-    fn fork_choice_state(&self) -> Receiver<ForkchoiceState>;
-
     /// Validate if the header is correct and follows consensus specification.
     ///
     /// This is called before properties that are not in the header itself (like total difficulty)
@@ -23,13 +21,17 @@ pub trait Consensus: Debug + Send + Sync {
         &self,
         header: &SealedHeader,
         parent: &SealedHeader,
-    ) -> Result<(), Error>;
+    ) -> Result<(), ConsensusError>;
 
     /// Validate if the header is correct and follows the consensus specification, including
     /// computed properties (like total difficulty).
     ///
     /// Some consensus engines may want to do additional checks here.
-    fn validate_header(&self, header: &SealedHeader, total_difficulty: U256) -> Result<(), Error>;
+    fn validate_header(
+        &self,
+        header: &SealedHeader,
+        total_difficulty: U256,
+    ) -> Result<(), ConsensusError>;
 
     /// Validate a block disregarding world state, i.e. things that can be checked before sender
     /// recovery and execution.
@@ -38,7 +40,7 @@ pub trait Consensus: Debug + Send + Sync {
     /// 11.1 "Ommer Validation".
     ///
     /// **This should not be called for the genesis block**.
-    fn pre_validate_block(&self, block: &SealedBlock) -> Result<(), Error>;
+    fn pre_validate_block(&self, block: &SealedBlock) -> Result<(), ConsensusError>;
 
     /// After the Merge (aka Paris) block rewards became obsolete.
     ///
@@ -51,7 +53,7 @@ pub trait Consensus: Debug + Send + Sync {
 /// Consensus Errors
 #[allow(missing_docs)]
 #[derive(thiserror::Error, Debug, PartialEq, Eq, Clone)]
-pub enum Error {
+pub enum ConsensusError {
     #[error("Block used gas ({gas_used:?}) is greater than gas limit ({gas_limit:?}).")]
     HeaderGasUsedExceedsGasLimit { gas_used: u64, gas_limit: u64 },
     #[error("Block ommer hash ({got:?}) is different from expected: ({expected:?})")]
@@ -71,7 +73,7 @@ pub enum Error {
     #[error("Block number {block_number:?} is mismatch with parent block number {parent_block_number:?}")]
     ParentBlockNumberMismatch { parent_block_number: BlockNumber, block_number: BlockNumber },
     #[error(
-        "Block timestamp {timestamp:?} is in past in comparison with parent timestamp {parent_timestamp:?}."
+    "Block timestamp {timestamp:?} is in past in comparison with parent timestamp {parent_timestamp:?}."
     )]
     TimestampIsInPast { parent_timestamp: u64, timestamp: u64 },
     #[error("Block timestamp {timestamp:?} is in future in comparison of our clock time {present_timestamp:?}.")]
@@ -84,26 +86,6 @@ pub enum Error {
     BaseFeeMissing,
     #[error("Block base fee ({got:?}) is different then expected: ({expected:?}).")]
     BaseFeeDiff { expected: u64, got: u64 },
-    #[error("Transaction eip1559 priority fee is more then max fee.")]
-    TransactionPriorityFeeMoreThenMaxFee,
-    #[error("Transaction chain_id does not match.")]
-    TransactionChainId,
-    #[error("Transaction max fee is less them block base fee.")]
-    TransactionMaxFeeLessThenBaseFee,
-    #[error("Transaction signer does not have account.")]
-    SignerAccountNotExisting,
-    #[error("Transaction signer has bytecode set.")]
-    SignerAccountHasBytecode,
-    #[error("Transaction nonce is not consistent.")]
-    TransactionNonceNotConsistent,
-    #[error("Account does not have enough funds ({available_funds:?}) to cover transaction max fee: {max_fee:?}.")]
-    InsufficientFunds { max_fee: u128, available_funds: u128 },
-    #[error("Eip2930 transaction is enabled after berlin hardfork.")]
-    TransactionEip2930Disabled,
-    #[error("Old legacy transaction before Spurious Dragon should not have chain_id.")]
-    TransactionOldLegacyChainId,
-    #[error("Eip2930 transaction is enabled after london hardfork.")]
-    TransactionEip1559Disabled,
     #[error("Transaction signer recovery error.")]
     TransactionSignerRecoveryError,
     #[error(
@@ -130,4 +112,7 @@ pub enum Error {
     WithdrawalIndexInvalid { got: u64, expected: u64 },
     #[error("Missing withdrawals")]
     BodyWithdrawalsMissing,
+    /// Error for a transaction that violates consensus.
+    #[error(transparent)]
+    InvalidTransaction(#[from] InvalidTransactionError),
 }
diff --git a/crates/interfaces/src/error.rs b/crates/interfaces/src/error.rs
index 6b27e906bba..746dffcb559 100644
--- a/crates/interfaces/src/error.rs
+++ b/crates/interfaces/src/error.rs
@@ -9,7 +9,7 @@ pub enum Error {
     Execution(#[from] crate::executor::Error),
 
     #[error(transparent)]
-    Consensus(#[from] crate::consensus::Error),
+    Consensus(#[from] crate::consensus::ConsensusError),
 
     #[error(transparent)]
     Database(#[from] crate::db::Error),
diff --git a/crates/interfaces/src/executor.rs b/crates/interfaces/src/executor.rs
index 489c00810e8..a40f60a0e25 100644
--- a/crates/interfaces/src/executor.rs
+++ b/crates/interfaces/src/executor.rs
@@ -1,32 +1,12 @@
-use async_trait::async_trait;
-use reth_primitives::{Address, Block, Bloom, H256, U256};
+use reth_primitives::{BlockHash, BlockNumber, Bloom, H256};
 use thiserror::Error;
 
-/// An executor capable of executing a block.
-#[async_trait]
-pub trait BlockExecutor<T> {
-    /// Execute a block.
-    ///
-    /// The number of `senders` should be equal to the number of transactions in the block.
-    ///
-    /// If no senders are specified, the `execute` function MUST recover the senders for the
-    /// provided block's transactions internally. We use this to allow for calculating senders in
-    /// parallel in e.g. staged sync, so that execution can happen without paying for sender
-    /// recovery costs.
-    fn execute(
-        &mut self,
-        block: &Block,
-        total_difficulty: U256,
-        senders: Option<Vec<Address>>,
-    ) -> Result<T, Error>;
-}
-
 /// BlockExecutor Errors
 #[allow(missing_docs)]
 #[derive(Error, Debug, Clone, PartialEq, Eq)]
 pub enum Error {
-    #[error("EVM reported invalid transaction:{0}")]
-    EVM(String),
+    #[error("EVM reported invalid transaction ({hash:?}): {message}")]
+    EVM { hash: H256, message: String },
     #[error("Example of error.")]
     VerificationFailed,
     #[error("Fatal internal error")]
@@ -54,4 +34,34 @@ pub enum Error {
     BlockGasUsed { got: u64, expected: u64 },
     #[error("Provider error")]
     ProviderError,
+    #[error("BlockChainId can't be found in BlockchainTree with internal index {chain_id}")]
+    BlockChainIdConsistency { chain_id: u64 },
+    #[error(
+        "Appending chain on fork (other_chain_fork:?) is not possible as the tip is {chain_tip:?}"
+    )]
+    AppendChainDoesntConnect { chain_tip: (u64, H256), other_chain_fork: (u64, H256) },
+    #[error("Canonical chain header #{block_hash} can't be found ")]
+    CanonicalChain { block_hash: BlockHash },
+    #[error("Can't insert #{block_number} {block_hash} as last finalized block number is {last_finalized}")]
+    PendingBlockIsFinalized {
+        block_hash: BlockHash,
+        block_number: BlockNumber,
+        last_finalized: BlockNumber,
+    },
+    #[error("Can't insert block  #{block_number} {block_hash} to far in future, as last finalized block number is {last_finalized}")]
+    PendingBlockIsInFuture {
+        block_hash: BlockHash,
+        block_number: BlockNumber,
+        last_finalized: BlockNumber,
+    },
+    #[error("Block number #{block_number} not found in blockchain tree chain")]
+    BlockNumberNotFoundInChain { block_number: BlockNumber },
+    #[error("Block hash {block_hash} not found in blockchain tree chain")]
+    BlockHashNotFoundInChain { block_hash: BlockHash },
+    #[error("Transaction error on revert: {inner:?}")]
+    CanonicalRevert { inner: String },
+    #[error("Transaction error on commit: {inner:?}")]
+    CanonicalCommit { inner: String },
+    #[error("Transaction error on pipeline status update: {inner:?}")]
+    PipelineStatusUpdate { inner: String },
 }
diff --git a/crates/interfaces/src/p2p/error.rs b/crates/interfaces/src/p2p/error.rs
index 92922e40b00..70e22f6cd01 100644
--- a/crates/interfaces/src/p2p/error.rs
+++ b/crates/interfaces/src/p2p/error.rs
@@ -125,7 +125,7 @@ pub enum DownloadError {
         hash: H256,
         /// The details of validation failure
         #[source]
-        error: consensus::Error,
+        error: consensus::ConsensusError,
     },
     /// Error when checking that the current [`Header`] has the parent's hash as the parent_hash
     /// field, and that they have sequential block numbers.
@@ -148,6 +148,14 @@ pub enum DownloadError {
         /// The hash of the expected tip
         expected: H256,
     },
+    /// Received a tip with an invalid tip number
+    #[error("Received invalid tip number: {received:?}. Expected {expected:?}.")]
+    InvalidTipNumber {
+        /// The block number of the received tip
+        received: u64,
+        /// The block number of the expected tip
+        expected: u64,
+    },
     /// Received a response to a request with unexpected start block
     #[error("Headers response starts at unexpected block: {received:?}. Expected {expected:?}.")]
     HeadersResponseStartBlockMismatch {
@@ -172,7 +180,7 @@ pub enum DownloadError {
         hash: H256,
         /// The details of validation failure
         #[source]
-        error: consensus::Error,
+        error: consensus::ConsensusError,
     },
     /// Received more bodies than requested.
     #[error("Received more bodies than requested. Expected: {expected}. Received: {received}")]
diff --git a/crates/interfaces/src/p2p/headers/downloader.rs b/crates/interfaces/src/p2p/headers/downloader.rs
index 7b129e29d80..ac10d2be79e 100644
--- a/crates/interfaces/src/p2p/headers/downloader.rs
+++ b/crates/interfaces/src/p2p/headers/downloader.rs
@@ -3,7 +3,7 @@ use crate::{
     p2p::error::{DownloadError, DownloadResult},
 };
 use futures::Stream;
-use reth_primitives::{SealedHeader, H256};
+use reth_primitives::{BlockHashOrNumber, SealedHeader, H256};
 
 /// A downloader capable of fetching and yielding block headers.
 ///
@@ -48,6 +48,8 @@ pub enum SyncTarget {
     /// The benefit of this variant is, that this already provides the block number of the highest
     /// missing block.
     Gap(SealedHeader),
+    /// This represents a tip by block number
+    TipNum(u64),
 }
 
 // === impl SyncTarget ===
@@ -57,10 +59,11 @@ impl SyncTarget {
     ///
     /// This returns the hash if the target is [SyncTarget::Tip] or the `parent_hash` of the given
     /// header in [SyncTarget::Gap]
-    pub fn tip(&self) -> H256 {
+    pub fn tip(&self) -> BlockHashOrNumber {
         match self {
-            SyncTarget::Tip(tip) => *tip,
-            SyncTarget::Gap(gap) => gap.parent_hash,
+            SyncTarget::Tip(tip) => (*tip).into(),
+            SyncTarget::Gap(gap) => gap.parent_hash.into(),
+            SyncTarget::TipNum(num) => (*num).into(),
         }
     }
 }
diff --git a/crates/interfaces/src/provider.rs b/crates/interfaces/src/provider.rs
index be00f651271..33ace26d1ea 100644
--- a/crates/interfaces/src/provider.rs
+++ b/crates/interfaces/src/provider.rs
@@ -68,7 +68,24 @@ pub enum ProviderError {
     /// Reached the end of the transaction sender table.
     #[error("Got to the end of the transaction sender table")]
     EndOfTransactionSenderTable,
+    /// Missing block hash in BlockchainTree
+    #[error("Missing block hash for block #{block_number:?} in blockchain tree")]
+    BlockchainTreeBlockHash { block_number: BlockNumber },
+    /// Some error occurred while interacting with the state tree.
+    #[error("Unknown error occurred while interacting with the state trie.")]
+    StateTrie,
+    #[error("History state root, can't be calculated")]
+    HistoryStateRoot,
     /// Thrown when required header related data was not found but was required.
     #[error("requested data not found")]
     HeaderNotFound,
+    /// Mismatch of sender and transaction
+    #[error("Mismatch of sender and transaction id {tx_id}")]
+    MismatchOfTransactionAndSenderId { tx_id: TxNumber },
+    /// Block body wrong transaction count
+    #[error("Stored block indices does not match transaction count")]
+    BlockBodyTransactionCount,
+    /// Thrown when the cache service task dropped
+    #[error("cache service task stopped")]
+    CacheServiceUnavailable,
 }
diff --git a/crates/interfaces/src/test_utils/generators.rs b/crates/interfaces/src/test_utils/generators.rs
index 4d0b7fa07f4..8d8e3bd4802 100644
--- a/crates/interfaces/src/test_utils/generators.rs
+++ b/crates/interfaces/src/test_utils/generators.rs
@@ -1,9 +1,10 @@
-use rand::{distributions::uniform::SampleRange, thread_rng, Rng};
+use rand::{distributions::uniform::SampleRange, seq::SliceRandom, thread_rng, Rng};
 use reth_primitives::{
-    proofs, Account, Address, Bytes, Header, SealedBlock, SealedHeader, Signature, Transaction,
-    TransactionKind, TransactionSigned, TxLegacy, H160, H256, U256,
+    proofs, sign_message, Account, Address, Bytes, Header, SealedBlock, SealedHeader, Signature,
+    StorageEntry, Transaction, TransactionKind, TransactionSigned, TxLegacy, H160, H256, U256,
 };
-use secp256k1::{KeyPair, Message as SecpMessage, Secp256k1, SecretKey};
+use secp256k1::{KeyPair, Message as SecpMessage, Secp256k1, SecretKey, SECP256K1};
+use std::{collections::BTreeMap, ops::Sub};
 
 // TODO(onbjerg): Maybe we should split this off to its own crate, or move the helpers to the
 // relevant crates?
@@ -71,21 +72,6 @@ pub fn random_signed_tx() -> TransactionSigned {
     TransactionSigned::from_transaction_and_signature(tx, signature)
 }
 
-/// Signs message with the given secret key.
-/// Returns the corresponding signature.
-pub fn sign_message(secret: H256, message: H256) -> Result<Signature, secp256k1::Error> {
-    let secp = Secp256k1::new();
-    let sec = SecretKey::from_slice(secret.as_ref())?;
-    let s = secp.sign_ecdsa_recoverable(&SecpMessage::from_slice(&message[..])?, &sec);
-    let (rec_id, data) = s.serialize_compact();
-
-    Ok(Signature {
-        r: U256::try_from_be_slice(&data[..32]).unwrap(),
-        s: U256::try_from_be_slice(&data[32..64]).unwrap(),
-        odd_y_parity: rec_id.to_i32() != 0,
-    })
-}
-
 /// Generate a random block filled with signed transactions (generated using
 /// [random_signed_tx]). If no transaction count is provided, the number of transactions
 /// will be random, otherwise the provided count will be used.
@@ -165,6 +151,115 @@ pub fn random_block_range(
     blocks
 }
 
+type Transition = Vec<(Address, Account, Vec<StorageEntry>)>;
+type AccountState = (Account, Vec<StorageEntry>);
+
+/// Generate a range of transitions for given blocks and accounts.
+/// Assumes all accounts start with an empty storage.
+///
+/// Returns a Vec of account and storage changes for each transition,
+/// along with the final state of all accounts and storages.
+pub fn random_transition_range<'a, IBlk, IAcc>(
+    blocks: IBlk,
+    accounts: IAcc,
+    n_changes: std::ops::Range<u64>,
+    key_range: std::ops::Range<u64>,
+) -> (Vec<Transition>, BTreeMap<Address, AccountState>)
+where
+    IBlk: IntoIterator<Item = &'a SealedBlock>,
+    IAcc: IntoIterator<Item = (Address, (Account, Vec<StorageEntry>))>,
+{
+    let mut rng = rand::thread_rng();
+    let mut state: BTreeMap<_, _> = accounts
+        .into_iter()
+        .map(|(addr, (acc, st))| (addr, (acc, st.into_iter().map(|e| (e.key, e.value)).collect())))
+        .collect();
+
+    let valid_addresses = state.keys().copied().collect();
+
+    let num_transitions: usize = blocks.into_iter().map(|block| block.body.len()).sum();
+    let mut transitions = Vec::with_capacity(num_transitions);
+
+    (0..num_transitions).for_each(|i| {
+        let mut transition = Vec::new();
+        let (from, to, mut transfer, new_entries) =
+            random_account_change(&valid_addresses, n_changes.clone(), key_range.clone());
+
+        // extract from sending account
+        let (prev_from, _) = state.get_mut(&from).unwrap();
+        transition.push((from, *prev_from, Vec::new()));
+
+        transfer = transfer.min(prev_from.balance).max(U256::from(1));
+        prev_from.balance = prev_from.balance.wrapping_sub(transfer);
+
+        // deposit in receiving account and update storage
+        let (prev_to, storage): &mut (Account, BTreeMap<H256, U256>) = state.get_mut(&to).unwrap();
+
+        let old_entries = new_entries
+            .into_iter()
+            .filter_map(|entry| {
+                let old = if entry.value != U256::ZERO {
+                    storage.insert(entry.key, entry.value)
+                } else {
+                    let old = storage.remove(&entry.key);
+                    if matches!(old, Some(U256::ZERO)) {
+                        return None
+                    }
+                    old
+                };
+                Some(StorageEntry { value: old.unwrap_or(U256::from(0)), ..entry })
+            })
+            .collect();
+
+        transition.push((to, *prev_to, old_entries));
+
+        prev_to.balance = prev_to.balance.wrapping_add(transfer);
+
+        transitions.push(transition);
+    });
+
+    let final_state = state
+        .into_iter()
+        .map(|(addr, (acc, storage))| {
+            (addr, (acc, storage.into_iter().map(|v| v.into()).collect()))
+        })
+        .collect();
+    (transitions, final_state)
+}
+
+/// Generate a random account change.
+///
+/// Returns two addresses, a balance_change, and a Vec of new storage entries.
+pub fn random_account_change(
+    valid_addresses: &Vec<Address>,
+    n_changes: std::ops::Range<u64>,
+    key_range: std::ops::Range<u64>,
+) -> (Address, Address, U256, Vec<StorageEntry>) {
+    let mut rng = rand::thread_rng();
+    let mut addresses = valid_addresses.choose_multiple(&mut rng, 2).cloned();
+
+    let addr_from = addresses.next().unwrap_or_else(Address::random);
+    let addr_to = addresses.next().unwrap_or_else(Address::random);
+
+    let balance_change = U256::from(rng.gen::<u64>());
+
+    let storage_changes = (0..n_changes.sample_single(&mut rng))
+        .map(|_| random_storage_entry(key_range.clone()))
+        .collect();
+
+    (addr_from, addr_to, balance_change, storage_changes)
+}
+
+/// Generate a random storage change.
+pub fn random_storage_entry(key_range: std::ops::Range<u64>) -> StorageEntry {
+    let mut rng = rand::thread_rng();
+
+    let key = H256::from_low_u64_be(key_range.sample_single(&mut rng));
+    let value = U256::from(rng.gen::<u64>());
+
+    StorageEntry { key, value }
+}
+
 /// Generate random Externaly Owned Account (EOA account without contract).
 pub fn random_eoa_account() -> (Address, Account) {
     let nonce: u64 = rand::random();
diff --git a/crates/interfaces/src/test_utils/headers.rs b/crates/interfaces/src/test_utils/headers.rs
index eaa8f804de3..ccb8bcd59b7 100644
--- a/crates/interfaces/src/test_utils/headers.rs
+++ b/crates/interfaces/src/test_utils/headers.rs
@@ -1,6 +1,6 @@
 //! Testing support for headers related interfaces.
 use crate::{
-    consensus::{self, Consensus, Error},
+    consensus::{self, Consensus, ConsensusError},
     p2p::{
         download::DownloadClient,
         error::{DownloadError, DownloadResult, PeerRequestResult, RequestError},
@@ -259,22 +259,13 @@ impl HeadersClient for TestHeadersClient {
 /// Consensus engine implementation for testing
 #[derive(Debug)]
 pub struct TestConsensus {
-    /// Watcher over the forkchoice state
-    channel: (watch::Sender<ForkchoiceState>, watch::Receiver<ForkchoiceState>),
     /// Flag whether the header validation should purposefully fail
     fail_validation: AtomicBool,
 }
 
 impl Default for TestConsensus {
     fn default() -> Self {
-        Self {
-            channel: watch::channel(ForkchoiceState {
-                head_block_hash: H256::zero(),
-                finalized_block_hash: H256::zero(),
-                safe_block_hash: H256::zero(),
-            }),
-            fail_validation: AtomicBool::new(false),
-        }
+        Self { fail_validation: AtomicBool::new(false) }
     }
 }
 
@@ -288,14 +279,6 @@ impl TestConsensus {
     pub fn set_fail_validation(&self, val: bool) {
         self.fail_validation.store(val, Ordering::SeqCst)
     }
-
-    /// Update the forkchoice state.
-    pub fn notify_fork_choice_state(
-        &self,
-        state: ForkchoiceState,
-    ) -> Result<(), SendError<ForkchoiceState>> {
-        self.channel.0.send(state)
-    }
 }
 
 /// Status updater for testing.
@@ -323,33 +306,33 @@ impl StatusUpdater for TestStatusUpdater {
 
 #[async_trait::async_trait]
 impl Consensus for TestConsensus {
-    fn fork_choice_state(&self) -> watch::Receiver<ForkchoiceState> {
-        self.channel.1.clone()
-    }
-
     fn pre_validate_header(
         &self,
         header: &SealedHeader,
         parent: &SealedHeader,
-    ) -> Result<(), Error> {
+    ) -> Result<(), ConsensusError> {
         if self.fail_validation() {
-            Err(consensus::Error::BaseFeeMissing)
+            Err(consensus::ConsensusError::BaseFeeMissing)
         } else {
             Ok(())
         }
     }
 
-    fn validate_header(&self, header: &SealedHeader, total_difficulty: U256) -> Result<(), Error> {
+    fn validate_header(
+        &self,
+        header: &SealedHeader,
+        total_difficulty: U256,
+    ) -> Result<(), ConsensusError> {
         if self.fail_validation() {
-            Err(consensus::Error::BaseFeeMissing)
+            Err(consensus::ConsensusError::BaseFeeMissing)
         } else {
             Ok(())
         }
     }
 
-    fn pre_validate_block(&self, _block: &SealedBlock) -> Result<(), consensus::Error> {
+    fn pre_validate_block(&self, _block: &SealedBlock) -> Result<(), consensus::ConsensusError> {
         if self.fail_validation() {
-            Err(consensus::Error::BaseFeeMissing)
+            Err(consensus::ConsensusError::BaseFeeMissing)
         } else {
             Ok(())
         }
diff --git a/crates/metrics/metrics-derive/tests/metrics.rs b/crates/metrics/metrics-derive/tests/metrics.rs
index 8f260761301..cca5ef83ca5 100644
--- a/crates/metrics/metrics-derive/tests/metrics.rs
+++ b/crates/metrics/metrics-derive/tests/metrics.rs
@@ -303,21 +303,21 @@ impl Recorder for TestRecorder {
 
     fn register_counter(&self, key: &Key) -> Counter {
         let labels_vec: Vec<Label> = key.labels().cloned().collect();
-        let labels = if labels_vec.is_empty() { None } else { Some(labels_vec) };
+        let labels = (!labels_vec.is_empty()).then_some(labels_vec);
         self.record_metric(key.name(), TestMetricTy::Counter, None, labels);
         Counter::noop()
     }
 
     fn register_gauge(&self, key: &Key) -> Gauge {
         let labels_vec: Vec<Label> = key.labels().cloned().collect();
-        let labels = if labels_vec.is_empty() { None } else { Some(labels_vec) };
+        let labels = (!labels_vec.is_empty()).then_some(labels_vec);
         self.record_metric(key.name(), TestMetricTy::Gauge, None, labels);
         Gauge::noop()
     }
 
     fn register_histogram(&self, key: &Key) -> Histogram {
         let labels_vec: Vec<Label> = key.labels().cloned().collect();
-        let labels = if labels_vec.is_empty() { None } else { Some(labels_vec) };
+        let labels = (!labels_vec.is_empty()).then_some(labels_vec);
         self.record_metric(key.name(), TestMetricTy::Histogram, None, labels);
         Histogram::noop()
     }
diff --git a/crates/net/discv4/Cargo.toml b/crates/net/discv4/Cargo.toml
index a2b9f30c8a4..93fcb95cbea 100644
--- a/crates/net/discv4/Cargo.toml
+++ b/crates/net/discv4/Cargo.toml
@@ -12,19 +12,20 @@ Ethereum network discovery
 [dependencies]
 # reth
 reth-primitives = { path = "../../primitives" }
-reth-rlp = { path = "../../rlp", features = ["enr"] }
+reth-rlp = { path = "../../rlp" }
 reth-rlp-derive = { path = "../../rlp/rlp-derive" }
 reth-net-common = { path = "../common" }
 reth-net-nat = { path = "../nat" }
 
 # ethereum
 discv5 = { git = "https://github.com/sigp/discv5" }
-secp256k1 = { version = "0.24", features = [
+secp256k1 = { version = "0.26.0", features = [
     "global-context",
     "rand-std",
     "recovery",
+    "serde"
 ] }
-enr = { version = "0.7.0", default-features = false, features = [
+enr = { version = "0.8.0", default-features = false, features = [
     "rust-secp256k1",
 ] }
 
diff --git a/crates/net/discv4/src/bootnodes.rs b/crates/net/discv4/src/bootnodes.rs
deleted file mode 100644
index 01c02017a92..00000000000
--- a/crates/net/discv4/src/bootnodes.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//! Various known bootstrap nodes for networks
-
-// <https://github.com/ledgerwatch/erigon/blob/610e648dc43ec8cd6563313e28f06f534a9091b3/params/bootnodes.go>
-
-use reth_primitives::NodeRecord;
-
-/// Ethereum Foundation Go Bootnodes
-pub static MAINNET_BOOTNODES : [&str; 8] = [
-    "enode://d860a01f9722d78051619d1e2351aba3f43f943f6f00718d1b9baa4101932a1f5011f16bb2b1bb35db20d6fe28fa0bf09636d26a87d31de9ec6203eeedb1f666@18.138.108.67:30303",   // bootnode-aws-ap-southeast-1-001
-    "enode://22a8232c3abc76a16ae9d6c3b164f98775fe226f0917b0ca871128a74a8e9630b458460865bab457221f1d448dd9791d24c4e5d88786180ac185df813a68d4de@3.209.45.79:30303",     // bootnode-aws-us-east-1-001
-    "enode://8499da03c47d637b20eee24eec3c356c9a2e6148d6fe25ca195c7949ab8ec2c03e3556126b0d7ed644675e78c4318b08691b7b57de10e5f0d40d05b09238fa0a@52.187.207.27:30303",   // bootnode-azure-australiaeast-001
-    "enode://103858bdb88756c71f15e9b5e09b56dc1be52f0a5021d46301dbbfb7e130029cc9d0d6f73f693bc29b665770fff7da4d34f3c6379fe12721b5d7a0bcb5ca1fc1@191.234.162.198:30303", // bootnode-azure-brazilsouth-001
-    "enode://715171f50508aba88aecd1250af392a45a330af91d7b90701c436b618c86aaa1589c9184561907bebbb56439b8f8787bc01f49a7c77276c58c1b09822d75e8e8@52.231.165.108:30303",  // bootnode-azure-koreasouth-001
-    "enode://5d6d7cd20d6da4bb83a1d28cadb5d409b64edf314c0335df658c1a54e32c7c4a7ab7823d57c39b6a757556e68ff1df17c748b698544a55cb488b52479a92b60f@104.42.217.25:30303",   // bootnode-azure-westus-001
-    "enode://2b252ab6a1d0f971d9722cb839a42cb81db019ba44c08754628ab4a823487071b5695317c8ccd085219c3a03af063495b2f1da8d18218da2d6a82981b45e6ffc@65.108.70.101:30303",   // bootnode-hetzner-hel
-    "enode://4aeb4ab6c14b23e2c4cfdce879c04b0748a20d8e9b59e25ded2a08143e265c6c25936e74cbc8e641e3312ca288673d91f2f93f8e277de3cfa444ecdaaf982052@157.90.35.166:30303",   // bootnode-hetzner-fsn
-];
-
-/// SEPOLIA BOOTNODES
-pub static SEPOLIA_BOOTNODES : [&str; 2] = [
-    // geth
-    "enode://9246d00bc8fd1742e5ad2428b80fc4dc45d786283e05ef6edbd9002cbc335d40998444732fbe921cb88e1d2c73d1b1de53bae6a2237996e9bfe14f871baf7066@18.168.182.86:30303",
-    // besu
-    "enode://ec66ddcf1a974950bd4c782789a7e04f8aa7110a72569b6e65fcd51e937e74eed303b1ea734e4d19cfaec9fbff9b6ee65bf31dcb50ba79acce9dd63a6aca61c7@52.14.151.177:30303",
-];
-
-/// GOERLI bootnodes
-pub static GOERLI_BOOTNODES : [&str; 7] = [
-    // Upstream bootnodes
-    "enode://011f758e6552d105183b1761c5e2dea0111bc20fd5f6422bc7f91e0fabbec9a6595caf6239b37feb773dddd3f87240d99d859431891e4a642cf2a0a9e6cbb98a@51.141.78.53:30303",
-    "enode://176b9417f511d05b6b2cf3e34b756cf0a7096b3094572a8f6ef4cdcb9d1f9d00683bf0f83347eebdf3b81c3521c2332086d9592802230bf528eaf606a1d9677b@13.93.54.137:30303",
-    "enode://46add44b9f13965f7b9875ac6b85f016f341012d84f975377573800a863526f4da19ae2c620ec73d11591fa9510e992ecc03ad0751f53cc02f7c7ed6d55c7291@94.237.54.114:30313",
-    "enode://b5948a2d3e9d486c4d75bf32713221c2bd6cf86463302339299bd227dc2e276cd5a1c7ca4f43a0e9122fe9af884efed563bd2a1fd28661f3b5f5ad7bf1de5949@18.218.250.66:30303",
-
-    // Ethereum Foundation bootnode
-    "enode://a61215641fb8714a373c80edbfa0ea8878243193f57c96eeb44d0bc019ef295abd4e044fd619bfc4c59731a73fb79afe84e9ab6da0c743ceb479cbb6d263fa91@3.11.147.67:30303",
-
-    // Goerli Initiative bootnodes
-    "enode://d4f764a48ec2a8ecf883735776fdefe0a3949eb0ca476bd7bc8d0954a9defe8fea15ae5da7d40b5d2d59ce9524a99daedadf6da6283fca492cc80b53689fb3b3@46.4.99.122:32109",
-    "enode://d2b720352e8216c9efc470091aa91ddafc53e222b32780f505c817ceef69e01d5b0b0797b69db254c586f493872352f5a022b4d8479a00fc92ec55f9ad46a27e@88.99.70.182:30303",
-];
-
-/// Returns parsed mainnet nodes
-pub fn mainnet_nodes() -> Vec<NodeRecord> {
-    parse_nodes(&MAINNET_BOOTNODES[..])
-}
-
-/// Returns parsed goerli nodes
-pub fn goerli_nodes() -> Vec<NodeRecord> {
-    parse_nodes(&GOERLI_BOOTNODES[..])
-}
-
-/// Returns parsed sepolia nodes
-pub fn sepolia_nodes() -> Vec<NodeRecord> {
-    parse_nodes(&SEPOLIA_BOOTNODES[..])
-}
-
-/// Parses all the nodes
-pub fn parse_nodes(nodes: impl IntoIterator<Item = impl AsRef<str>>) -> Vec<NodeRecord> {
-    nodes.into_iter().map(|s| s.as_ref().parse().unwrap()).collect()
-}
diff --git a/crates/net/discv4/src/lib.rs b/crates/net/discv4/src/lib.rs
index eb1424ba47e..4e05ec4ddb5 100644
--- a/crates/net/discv4/src/lib.rs
+++ b/crates/net/discv4/src/lib.rs
@@ -24,13 +24,13 @@ use crate::{
 use discv5::{
     kbucket,
     kbucket::{
-        BucketInsertResult, Distance, Entry as BucketEntry, KBucketsTable, NodeStatus,
-        MAX_NODES_PER_BUCKET,
+        BucketInsertResult, Distance, Entry as BucketEntry, InsertResult, KBucketsTable,
+        NodeStatus, MAX_NODES_PER_BUCKET,
     },
     ConnectionDirection, ConnectionState,
 };
 use enr::{Enr, EnrBuilder};
-use proto::{EnrRequest, EnrResponse};
+use proto::{EnrRequest, EnrResponse, EnrWrapper};
 use reth_primitives::{
     bytes::{Bytes, BytesMut},
     ForkId, PeerId, H256,
@@ -56,7 +56,6 @@ use tokio::{
 use tokio_stream::{wrappers::ReceiverStream, Stream, StreamExt};
 use tracing::{debug, info, trace, warn};
 
-pub mod bootnodes;
 pub mod error;
 mod proto;
 
@@ -406,10 +405,10 @@ impl Discv4Service {
         let mut tasks = JoinSet::<()>::new();
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { receive_loop(udp, ingress_tx, local_node_record.id).await });
+        tasks.spawn(receive_loop(udp, ingress_tx, local_node_record.id));
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { send_loop(udp, egress_rx).await });
+        tasks.spawn(send_loop(udp, egress_rx));
 
         let kbuckets = KBucketsTable::new(
             NodeKey::from(&local_node_record).into(),
@@ -486,11 +485,7 @@ impl Discv4Service {
 
     /// Returns the current enr sequence
     fn enr_seq(&self) -> Option<u64> {
-        if self.config.enable_eip868 {
-            Some(self.local_eip_868_enr.seq())
-        } else {
-            None
-        }
+        (self.config.enable_eip868).then(|| self.local_eip_868_enr.seq())
     }
 
     /// Sets the [Interval] used for periodically looking up targets over the network
@@ -553,20 +548,24 @@ impl Discv4Service {
     /// **Note:** This is a noop if there are no bootnodes.
     pub fn bootstrap(&mut self) {
         for record in self.config.bootstrap_nodes.clone() {
-            debug!(target : "discv4",  ?record, "Adding bootstrap node");
+            debug!(target : "discv4",  ?record, "pinging boot node");
             let key = kad_key(record.id);
             let entry = NodeEntry::new(record);
 
             // insert the boot node in the table
-            let _ = self.kbuckets.insert_or_update(
+            match self.kbuckets.insert_or_update(
                 &key,
                 entry,
                 NodeStatus {
                     state: ConnectionState::Connected,
                     direction: ConnectionDirection::Outgoing,
                 },
-            );
-            self.try_ping(record, PingReason::Initial);
+            ) {
+                InsertResult::Failed(_) => {}
+                _ => {
+                    self.try_ping(record, PingReason::Initial);
+                }
+            }
         }
     }
 
@@ -625,13 +624,23 @@ impl Discv4Service {
             target_key.clone(),
             self.kbuckets
                 .closest_values(&target_key)
+                .filter(|node| !self.pending_find_nodes.contains_key(&node.key.preimage().0))
                 .take(MAX_NODES_PER_BUCKET)
                 .map(|n| (target_key.distance(&n.key), n.value.record)),
             tx,
         );
 
         // From those 16, pick the 3 closest to start the concurrent lookup.
-        let closest = ctx.closest(ALPHA, |node| !self.pending_find_nodes.contains_key(&node.id));
+        let closest = ctx.closest(ALPHA);
+
+        if closest.is_empty() && self.pending_find_nodes.is_empty() {
+            // no closest nodes, and no lookup in progress: table is empty.
+            // This could happen if all records were deleted from the table due to missed pongs
+            // (e.g. connectivity problems over a long period of time, or issues during initial
+            // bootstrapping) so we attempt to bootstrap again
+            self.bootstrap();
+            return
+        }
 
         trace!(target : "net::discv4", ?target, num = closest.len(), "Start lookup closest nodes");
 
@@ -1111,7 +1120,7 @@ impl Discv4Service {
             self.send_packet(
                 Message::EnrResponse(EnrResponse {
                     request_hash,
-                    enr: self.local_eip_868_enr.clone(),
+                    enr: EnrWrapper::new(self.local_eip_868_enr.clone()),
                 }),
                 remote_addr,
             );
@@ -1172,7 +1181,8 @@ impl Discv4Service {
         }
 
         // get the next closest nodes, not yet queried nodes and start over.
-        let closest = ctx.closest(ALPHA, |node| !self.pending_find_nodes.contains_key(&node.id));
+        let closest =
+            ctx.filter_closest(ALPHA, |node| !self.pending_find_nodes.contains_key(&node.id));
 
         for closest in closest {
             let key = kad_key(closest.id);
@@ -1704,8 +1714,19 @@ impl LookupContext {
         self.inner.target.preimage().0
     }
 
+    fn closest(&self, num: usize) -> Vec<NodeRecord> {
+        self.inner
+            .closest_nodes
+            .borrow()
+            .iter()
+            .filter(|(_, node)| !node.queried)
+            .map(|(_, n)| n.record)
+            .take(num)
+            .collect()
+    }
+
     /// Returns the closest nodes that have not been queried yet.
-    fn closest<P>(&self, num: usize, filter: P) -> Vec<NodeRecord>
+    fn filter_closest<P>(&self, num: usize, filter: P) -> Vec<NodeRecord>
     where
         P: FnMut(&NodeRecord) -> bool,
     {
@@ -1916,12 +1937,9 @@ pub enum DiscoveryUpdate {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        bootnodes::mainnet_nodes,
-        test_utils::{create_discv4, create_discv4_with_config, rng_endpoint, rng_record},
-    };
+    use crate::test_utils::{create_discv4, create_discv4_with_config, rng_endpoint, rng_record};
     use rand::{thread_rng, Rng};
-    use reth_primitives::{hex_literal::hex, ForkHash};
+    use reth_primitives::{hex_literal::hex, mainnet_nodes, ForkHash};
     use std::{future::poll_fn, net::Ipv4Addr};
 
     #[test]
diff --git a/crates/net/discv4/src/proto.rs b/crates/net/discv4/src/proto.rs
index e4e8f28594a..ad52267ca6d 100644
--- a/crates/net/discv4/src/proto.rs
+++ b/crates/net/discv4/src/proto.rs
@@ -1,12 +1,14 @@
 #![allow(missing_docs)]
 
 use crate::{error::DecodePacketError, PeerId, MAX_PACKET_SIZE, MIN_PACKET_SIZE};
-use enr::Enr;
+use enr::{Enr, EnrKey};
 use reth_primitives::{
     bytes::{Buf, BufMut, Bytes, BytesMut},
-    keccak256, ForkId, NodeRecord, H256,
+    keccak256,
+    rpc_utils::rlp,
+    ForkId, NodeRecord, H256,
 };
-use reth_rlp::{Decodable, DecodeError, Encodable, Header};
+use reth_rlp::{length_of_length, Decodable, DecodeError, Encodable, Header};
 use reth_rlp_derive::{RlpDecodable, RlpEncodable};
 use secp256k1::{
     ecdsa::{RecoverableSignature, RecoveryId},
@@ -209,6 +211,80 @@ pub struct Neighbours {
     pub expire: u64,
 }
 
+/// Passthrough newtype to [`Enr`].
+///
+/// We need to wrap the ENR type because of Rust's orphan rules not allowing
+/// implementing a foreign trait on a foreign type.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EnrWrapper<K: EnrKey>(Enr<K>);
+
+impl<K: EnrKey> EnrWrapper<K> {
+    pub fn new(enr: Enr<K>) -> Self {
+        EnrWrapper(enr)
+    }
+}
+
+impl<K> Encodable for EnrWrapper<K>
+where
+    K: EnrKey,
+{
+    fn encode(&self, out: &mut dyn BufMut) {
+        let payload_length = self.0.signature().length() +
+            self.0.seq().length() +
+            self.0.iter().fold(0, |acc, (k, v)| acc + k.as_slice().length() + v.len());
+
+        let header = Header { list: true, payload_length };
+        header.encode(out);
+
+        self.0.signature().encode(out);
+        self.0.seq().encode(out);
+
+        for (k, v) in self.0.iter() {
+            // Keys are byte data
+            k.as_slice().encode(out);
+            // Values are raw RLP encoded data
+            out.put_slice(v);
+        }
+    }
+
+    fn length(&self) -> usize {
+        let payload_length = self.0.signature().length() +
+            self.0.seq().length() +
+            self.0.iter().fold(0, |acc, (k, v)| acc + k.as_slice().length() + v.len());
+        payload_length + length_of_length(payload_length)
+    }
+}
+
+impl<K: EnrKey> Decodable for EnrWrapper<K> {
+    fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
+        let enr = <Enr<K> as rlp::Decodable>::decode(&rlp::Rlp::new(buf))
+            .map_err(|e| match e {
+                rlp::DecoderError::RlpIsTooShort => DecodeError::InputTooShort,
+                rlp::DecoderError::RlpInvalidLength => DecodeError::Overflow,
+                rlp::DecoderError::RlpExpectedToBeList => DecodeError::UnexpectedString,
+                rlp::DecoderError::RlpExpectedToBeData => DecodeError::UnexpectedList,
+                rlp::DecoderError::RlpDataLenWithZeroPrefix |
+                rlp::DecoderError::RlpListLenWithZeroPrefix => DecodeError::LeadingZero,
+                rlp::DecoderError::RlpInvalidIndirection => DecodeError::NonCanonicalSize,
+                rlp::DecoderError::RlpIncorrectListLen => {
+                    DecodeError::Custom("incorrect list length when decoding rlp")
+                }
+                rlp::DecoderError::RlpIsTooBig => DecodeError::Custom("rlp is too big"),
+                rlp::DecoderError::RlpInconsistentLengthAndData => {
+                    DecodeError::Custom("inconsistent length and data when decoding rlp")
+                }
+                rlp::DecoderError::Custom(s) => DecodeError::Custom(s),
+            })
+            .map(EnrWrapper::new);
+        if enr.is_ok() {
+            // Decode was successful, advance buffer
+            let header = Header::decode(buf)?;
+            buf.advance(header.payload_length);
+        }
+        enr
+    }
+}
+
 /// A [ENRRequest packet](https://github.com/ethereum/devp2p/blob/master/discv4.md#enrrequest-packet-0x05).
 #[derive(Clone, Copy, Debug, Eq, PartialEq, RlpEncodable, RlpDecodable)]
 pub struct EnrRequest {
@@ -219,7 +295,7 @@ pub struct EnrRequest {
 #[derive(Clone, Debug, Eq, PartialEq, RlpEncodable)]
 pub struct EnrResponse {
     pub request_hash: H256,
-    pub enr: Enr<SecretKey>,
+    pub enr: EnrWrapper<SecretKey>,
 }
 
 // === impl EnrResponse ===
@@ -229,7 +305,7 @@ impl EnrResponse {
     ///
     /// See also <https://github.com/ethereum/go-ethereum/blob/9244d5cd61f3ea5a7645fdf2a1a96d53421e412f/eth/protocols/eth/discovery.go#L36>
     pub fn eth_fork_id(&self) -> Option<ForkId> {
-        let mut maybe_fork_id = self.enr.get(b"eth")?;
+        let mut maybe_fork_id = self.enr.0.get(b"eth")?;
         ForkId::decode(&mut maybe_fork_id).ok()
     }
 }
@@ -244,7 +320,7 @@ impl Decodable for EnrResponse {
         // let started_len = b.len();
         let this = Self {
             request_hash: reth_rlp::Decodable::decode(b)?,
-            enr: reth_rlp::Decodable::decode(b)?,
+            enr: EnrWrapper::<SecretKey>::decode(b)?,
         };
         // TODO: `Decodable` can be derived once we have native reth_rlp decoding for ENR: <https://github.com/paradigmxyz/reth/issues/482>
         // Skipping the size check here is fine since the `buf` is the UDP datagram
@@ -422,7 +498,9 @@ mod tests {
         test_utils::{rng_endpoint, rng_ipv4_record, rng_ipv6_record, rng_message},
         SAFE_MAX_DATAGRAM_NEIGHBOUR_RECORDS,
     };
+    use enr::{EnrBuilder, EnrPublicKey};
     use rand::{thread_rng, Rng, RngCore};
+    use reth_primitives::hex_literal::hex;
 
     #[test]
     fn test_endpoint_ipv_v4() {
@@ -635,4 +713,104 @@ mod tests {
         let data = hex::decode(packet).unwrap();
         Message::decode(&data).unwrap();
     }
+
+    // test vector from the enr library rlp encoding tests
+    // <https://github.com/sigp/enr/blob/e59dcb45ea07e423a7091d2a6ede4ad6d8ef2840/src/lib.rs#L1019>
+
+    #[test]
+    fn encode_known_rlp_enr() {
+        use self::EnrWrapper;
+        use enr::{secp256k1::SecretKey, EnrPublicKey};
+        use reth_rlp::Decodable;
+        use std::net::Ipv4Addr;
+
+        let valid_record =
+    hex!("f884b8407098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c01826964827634826970847f00000189736563703235366b31a103ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31388375647082765f"
+    );
+        let signature =
+    hex!("7098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c"
+    );
+        let expected_pubkey =
+            hex!("03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138");
+
+        let enr = EnrWrapper::<SecretKey>::decode(&mut &valid_record[..]).unwrap();
+        let pubkey = enr.0.public_key().encode();
+
+        assert_eq!(enr.0.ip4(), Some(Ipv4Addr::new(127, 0, 0, 1)));
+        assert_eq!(enr.0.id(), Some(String::from("v4")));
+        assert_eq!(enr.0.udp4(), Some(30303));
+        assert_eq!(enr.0.tcp4(), None);
+        assert_eq!(enr.0.signature(), &signature[..]);
+        assert_eq!(pubkey.to_vec(), expected_pubkey);
+        assert!(enr.0.verify());
+
+        let mut encoded = BytesMut::new();
+        enr.encode(&mut encoded);
+        assert_eq!(&encoded[..], &valid_record[..]);
+
+        // ensure the length is equal
+        assert_eq!(enr.length(), valid_record.len());
+    }
+
+    // test vector from the enr library rlp encoding tests
+    // <https://github.com/sigp/enr/blob/e59dcb45ea07e423a7091d2a6ede4ad6d8ef2840/src/lib.rs#L1019>
+    #[test]
+    fn decode_enr_rlp() {
+        use enr::secp256k1::SecretKey;
+        use std::net::Ipv4Addr;
+
+        let valid_record = hex!("f884b8407098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c01826964827634826970847f00000189736563703235366b31a103ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31388375647082765f");
+        let signature = hex!("7098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c");
+        let expected_pubkey =
+            hex!("03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138");
+
+        let mut valid_record_buf = valid_record.as_slice();
+        let enr = EnrWrapper::<SecretKey>::decode(&mut valid_record_buf).unwrap();
+        let pubkey = enr.0.public_key().encode();
+
+        // Byte array must be consumed after enr has finished decoding
+        assert!(valid_record_buf.is_empty());
+
+        assert_eq!(enr.0.ip4(), Some(Ipv4Addr::new(127, 0, 0, 1)));
+        assert_eq!(enr.0.id(), Some(String::from("v4")));
+        assert_eq!(enr.0.udp4(), Some(30303));
+        assert_eq!(enr.0.tcp4(), None);
+        assert_eq!(enr.0.signature(), &signature[..]);
+        assert_eq!(pubkey.to_vec(), expected_pubkey);
+        assert!(enr.0.verify());
+    }
+
+    // test vector from the enr library rlp encoding tests
+    // <https://github.com/sigp/enr/blob/e59dcb45ea07e423a7091d2a6ede4ad6d8ef2840/src/lib.rs#LL1206C35-L1206C35>
+    #[test]
+    fn encode_decode_enr_rlp() {
+        use enr::{secp256k1::SecretKey, EnrPublicKey};
+        use std::net::Ipv4Addr;
+
+        let key = SecretKey::new(&mut rand::rngs::OsRng);
+        let ip = Ipv4Addr::new(127, 0, 0, 1);
+        let tcp = 3000;
+
+        let enr = {
+            let mut builder = EnrBuilder::new("v4");
+            builder.ip(ip.into());
+            builder.tcp4(tcp);
+            EnrWrapper::new(builder.build(&key).unwrap())
+        };
+
+        let mut encoded = BytesMut::new();
+        enr.encode(&mut encoded);
+        let mut encoded_bytes = &encoded[..];
+        let decoded_enr = EnrWrapper::<SecretKey>::decode(&mut encoded_bytes).unwrap();
+
+        // Byte array must be consumed after enr has finished decoding
+        assert!(encoded_bytes.is_empty());
+
+        assert_eq!(decoded_enr, enr);
+        assert_eq!(decoded_enr.0.id(), Some("v4".into()));
+        assert_eq!(decoded_enr.0.ip4(), Some(ip));
+        assert_eq!(decoded_enr.0.tcp4(), Some(tcp));
+        assert_eq!(decoded_enr.0.public_key().encode(), key.public().encode());
+        assert!(decoded_enr.0.verify());
+    }
 }
diff --git a/crates/net/discv4/src/test_utils.rs b/crates/net/discv4/src/test_utils.rs
index 0657ec98ab6..6ade4a892ac 100644
--- a/crates/net/discv4/src/test_utils.rs
+++ b/crates/net/discv4/src/test_utils.rs
@@ -65,10 +65,10 @@ impl MockDiscovery {
         let mut tasks = JoinSet::<()>::new();
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { receive_loop(udp, ingress_tx, local_enr.id).await });
+        tasks.spawn(receive_loop(udp, ingress_tx, local_enr.id));
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { send_loop(udp, egress_rx).await });
+        tasks.spawn(send_loop(udp, egress_rx));
 
         let (tx, command_rx) = mpsc::channel(128);
         let this = Self {
@@ -130,17 +130,14 @@ impl Stream for MockDiscovery {
         let this = self.get_mut();
         // process all incoming commands
         while let Poll::Ready(maybe_cmd) = this.command_rx.poll_recv(cx) {
-            if let Some(cmd) = maybe_cmd {
-                match cmd {
-                    MockCommand::MockPong { node_id } => {
-                        this.queue_pong(node_id);
-                    }
-                    MockCommand::MockNeighbours { target, nodes } => {
-                        this.queue_neighbours(target, nodes);
-                    }
+            let Some(cmd) = maybe_cmd else { return Poll::Ready(None) };
+            match cmd {
+                MockCommand::MockPong { node_id } => {
+                    this.queue_pong(node_id);
+                }
+                MockCommand::MockNeighbours { target, nodes } => {
+                    this.queue_neighbours(target, nodes);
                 }
-            } else {
-                return Poll::Ready(None)
             }
         }
 
diff --git a/crates/net/dns/Cargo.toml b/crates/net/dns/Cargo.toml
index 80bea744cb5..29c4a1c5620 100644
--- a/crates/net/dns/Cargo.toml
+++ b/crates/net/dns/Cargo.toml
@@ -14,12 +14,13 @@ reth-net-common = { path = "../common" }
 reth-rlp = { path = "../../rlp" }
 
 # ethereum
-secp256k1 = { version = "0.24", features = [
+secp256k1 = { version = "0.26.0", features = [
     "global-context",
     "rand-std",
     "recovery",
+    "serde"
 ] }
-enr = { version = "0.7.0",  default-features = false, features = ["rust-secp256k1"] }
+enr = { version = "0.8.0", default-features = false, features = ["rust-secp256k1"] }
 
 # async/futures
 tokio = { version = "1", features = ["io-util", "net", "time"] }
@@ -32,7 +33,7 @@ trust-dns-resolver = "0.22"
 data-encoding = "2"
 async-trait = "0.1"
 linked_hash_set = "0.1"
-lru = "0.9"
+schnellru = "0.2"
 thiserror = "1.0"
 tracing = "0.1"
 parking_lot = "0.12"
diff --git a/crates/net/dns/src/config.rs b/crates/net/dns/src/config.rs
index 092ddbfce54..6a31c36ad40 100644
--- a/crates/net/dns/src/config.rs
+++ b/crates/net/dns/src/config.rs
@@ -1,5 +1,9 @@
 use crate::tree::LinkEntry;
-use std::{collections::HashSet, num::NonZeroUsize, time::Duration};
+use std::{
+    collections::HashSet,
+    num::{NonZeroU32, NonZeroUsize},
+    time::Duration,
+};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -21,7 +25,7 @@ pub struct DnsDiscoveryConfig {
     /// Default: 30min
     pub recheck_interval: Duration,
     /// Maximum number of cached DNS records.
-    pub dns_record_cache_limit: NonZeroUsize,
+    pub dns_record_cache_limit: NonZeroU32,
     /// Links to the DNS networks to bootstrap.
     pub bootstrap_dns_networks: Option<HashSet<LinkEntry>>,
 }
@@ -32,7 +36,7 @@ impl Default for DnsDiscoveryConfig {
             lookup_timeout: Duration::from_secs(5),
             max_requests_per_sec: NonZeroUsize::new(3).unwrap(),
             recheck_interval: Duration::from_secs(60 * 30),
-            dns_record_cache_limit: NonZeroUsize::new(1_000).unwrap(),
+            dns_record_cache_limit: NonZeroU32::new(1_000).unwrap(),
             bootstrap_dns_networks: Some(Default::default()),
         }
     }
diff --git a/crates/net/dns/src/lib.rs b/crates/net/dns/src/lib.rs
index 77ea3e8762d..d32dd00691e 100644
--- a/crates/net/dns/src/lib.rs
+++ b/crates/net/dns/src/lib.rs
@@ -1,4 +1,4 @@
-#![warn(missing_docs, unreachable_pub)]
+#![warn(missing_docs, unreachable_pub, unused_crate_dependencies)]
 #![deny(unused_must_use, rust_2018_idioms)]
 #![doc(test(
     no_crate_inject,
@@ -16,8 +16,8 @@ use crate::{
 pub use config::DnsDiscoveryConfig;
 use enr::Enr;
 use error::ParseDnsEntryError;
-use lru::LruCache;
 use reth_primitives::{ForkId, NodeRecord, PeerId};
+use schnellru::{ByLength, LruMap};
 use secp256k1::SecretKey;
 use std::{
     collections::{hash_map::Entry, HashMap, HashSet, VecDeque},
@@ -95,7 +95,7 @@ pub struct DnsDiscoveryService<R: Resolver = DnsResolver> {
     /// All queries currently in progress
     queries: QueryPool<R, SecretKey>,
     /// Cached dns records
-    dns_record_cache: LruCache<String, DnsEntry<SecretKey>>,
+    dns_record_cache: LruMap<String, DnsEntry<SecretKey>>,
     /// all buffered events
     queued_events: VecDeque<DnsDiscoveryEvent>,
     /// The rate at which trees should be updated.
@@ -133,7 +133,7 @@ impl<R: Resolver> DnsDiscoveryService<R> {
             node_record_listeners: Default::default(),
             trees: Default::default(),
             queries,
-            dns_record_cache: LruCache::new(dns_record_cache_limit),
+            dns_record_cache: LruMap::new(ByLength::new(dns_record_cache_limit.get())),
             queued_events: Default::default(),
             recheck_interval,
             bootstrap_dns_networks: bootstrap_dns_networks.unwrap_or_default(),
@@ -250,7 +250,7 @@ impl<R: Resolver> DnsDiscoveryService<R> {
             }
             Some(Ok(entry)) => {
                 // cache entry
-                self.dns_record_cache.push(hash.clone(), entry.clone());
+                self.dns_record_cache.insert(hash.clone(), entry.clone());
 
                 match entry {
                     DnsEntry::Root(root) => {
diff --git a/crates/net/dns/src/query.rs b/crates/net/dns/src/query.rs
index 34b5deccc6d..10e1fbf2149 100644
--- a/crates/net/dns/src/query.rs
+++ b/crates/net/dns/src/query.rs
@@ -59,18 +59,15 @@ impl<R: Resolver, K: EnrKeyUnambiguous> QueryPool<R, K> {
     pub(crate) fn resolve_root(&mut self, link: LinkEntry<K>) {
         let resolver = Arc::clone(&self.resolver);
         let timeout = self.lookup_timeout;
-        self.queued_queries.push_back(Query::Root(Box::pin(async move {
-            resolve_root(resolver, link, timeout).await
-        })))
+        self.queued_queries.push_back(Query::Root(Box::pin(resolve_root(resolver, link, timeout))))
     }
 
     /// Resolves the [DnsEntry] for `<hash.domain>`
     pub(crate) fn resolve_entry(&mut self, link: LinkEntry<K>, hash: String, kind: ResolveKind) {
         let resolver = Arc::clone(&self.resolver);
         let timeout = self.lookup_timeout;
-        self.queued_queries.push_back(Query::Entry(Box::pin(async move {
-            resolve_entry(resolver, link, hash, kind, timeout).await
-        })))
+        self.queued_queries
+            .push_back(Query::Entry(Box::pin(resolve_entry(resolver, link, hash, kind, timeout))))
     }
 
     /// Advances the state of the queries
@@ -208,10 +205,9 @@ async fn lookup_with_timeout<R: Resolver>(
     query: &str,
     timeout: Duration,
 ) -> LookupResult<Option<String>> {
-    match tokio::time::timeout(timeout, r.lookup_txt(query)).await {
-        Ok(res) => Ok(res),
-        Err(_) => Err(LookupError::RequestTimedOut),
-    }
+    tokio::time::timeout(timeout, r.lookup_txt(query))
+        .await
+        .map_err(|_| LookupError::RequestTimedOut)
 }
 
 #[cfg(test)]
diff --git a/crates/net/dns/src/tree.rs b/crates/net/dns/src/tree.rs
index 6f42af14679..d9e0408995f 100644
--- a/crates/net/dns/src/tree.rs
+++ b/crates/net/dns/src/tree.rs
@@ -27,7 +27,11 @@ use data_encoding::{BASE32_NOPAD, BASE64URL_NOPAD};
 use enr::{Enr, EnrError, EnrKey, EnrKeyUnambiguous, EnrPublicKey};
 use reth_primitives::{bytes::Bytes, hex};
 use secp256k1::SecretKey;
-use std::{fmt, str::FromStr};
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+    str::FromStr,
+};
 
 #[cfg(feature = "serde")]
 use serde_with::{DeserializeFromStr, SerializeDisplay};
@@ -222,7 +226,7 @@ impl fmt::Display for BranchEntry {
 }
 
 /// A link entry
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(SerializeDisplay, DeserializeFromStr))]
 pub struct LinkEntry<K: EnrKeyUnambiguous = SecretKey> {
     pub domain: String,
@@ -248,6 +252,33 @@ impl<K: EnrKeyUnambiguous> LinkEntry<K> {
     }
 }
 
+impl<K> PartialEq for LinkEntry<K>
+where
+    K: EnrKeyUnambiguous,
+    K::PublicKey: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.domain == other.domain && self.pubkey == other.pubkey
+    }
+}
+
+impl<K> Eq for LinkEntry<K>
+where
+    K: EnrKeyUnambiguous,
+    K::PublicKey: Eq + PartialEq,
+{
+}
+impl<K> Hash for LinkEntry<K>
+where
+    K: EnrKeyUnambiguous,
+    K::PublicKey: Hash,
+{
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.domain.hash(state);
+        self.pubkey.hash(state);
+    }
+}
+
 impl<K: EnrKeyUnambiguous> FromStr for LinkEntry<K> {
     type Err = ParseDnsEntryError;
 
diff --git a/crates/net/downloaders/src/bodies/request.rs b/crates/net/downloaders/src/bodies/request.rs
index 577f1fd169b..262664a1a0d 100644
--- a/crates/net/downloaders/src/bodies/request.rs
+++ b/crates/net/downloaders/src/bodies/request.rs
@@ -94,11 +94,7 @@ where
     /// Retrieve header hashes for the next request.
     fn next_request(&self) -> Option<Vec<H256>> {
         let mut hashes = self.headers.iter().filter(|h| !h.is_empty()).map(|h| h.hash()).peekable();
-        if hashes.peek().is_some() {
-            Some(hashes.collect())
-        } else {
-            None
-        }
+        hashes.peek().is_some().then(|| hashes.collect())
     }
 
     /// Submit the request.
diff --git a/crates/net/downloaders/src/bodies/task.rs b/crates/net/downloaders/src/bodies/task.rs
index a59c7d9e406..bf7ced932ab 100644
--- a/crates/net/downloaders/src/bodies/task.rs
+++ b/crates/net/downloaders/src/bodies/task.rs
@@ -76,7 +76,7 @@ impl TaskDownloader {
             downloader,
         };
 
-        spawner.spawn(async move { downloader.await }.boxed());
+        spawner.spawn(downloader.boxed());
 
         Self { from_downloader: UnboundedReceiverStream::new(bodies_rx), to_downloader }
     }
diff --git a/crates/net/downloaders/src/bodies/test_utils.rs b/crates/net/downloaders/src/bodies/test_utils.rs
index 13103f9cbda..c69d26d47cd 100644
--- a/crates/net/downloaders/src/bodies/test_utils.rs
+++ b/crates/net/downloaders/src/bodies/test_utils.rs
@@ -41,7 +41,7 @@ pub(crate) fn create_raw_bodies<'a>(
         .into_iter()
         .map(|header| {
             let body = bodies.remove(&header.hash()).expect("body exists");
-            body.create_block(header)
+            body.create_block(header.as_ref().clone())
         })
         .collect()
 }
diff --git a/crates/net/downloaders/src/headers/reverse_headers.rs b/crates/net/downloaders/src/headers/reverse_headers.rs
index 4d00ce0edfa..241bf3ded5a 100644
--- a/crates/net/downloaders/src/headers/reverse_headers.rs
+++ b/crates/net/downloaders/src/headers/reverse_headers.rs
@@ -16,7 +16,9 @@ use reth_interfaces::{
         priority::Priority,
     },
 };
-use reth_primitives::{BlockNumber, Header, HeadersDirection, PeerId, SealedHeader, H256};
+use reth_primitives::{
+    BlockHashOrNumber, BlockNumber, Header, HeadersDirection, PeerId, SealedHeader, H256,
+};
 use reth_tasks::{TaskSpawner, TokioTaskExecutor};
 use std::{
     cmp::{Ordering, Reverse},
@@ -116,14 +118,14 @@ where
         self.local_head.as_ref().expect("is initialized").number
     }
 
-    /// Returns the existing sync target hash.
+    /// Returns the existing sync target.
     ///
     /// # Panics
     ///
     /// If the sync target has never been set.
     #[inline]
-    fn existing_sync_target_hash(&self) -> H256 {
-        self.sync_target.as_ref().expect("is initialized").hash
+    fn existing_sync_target(&self) -> SyncTargetBlock {
+        self.sync_target.as_ref().expect("is initialized").clone()
     }
 
     /// Max requests to handle at the same time
@@ -198,7 +200,7 @@ where
         headers: Vec<Header>,
         peer_id: PeerId,
     ) -> Result<(), HeadersResponseError> {
-        let sync_target_hash = self.existing_sync_target_hash();
+        let sync_target = self.existing_sync_target();
         let mut validated = Vec::with_capacity(headers.len());
 
         let sealed_headers = headers.into_par_iter().map(|h| h.seal_slow()).collect::<Vec<_>>();
@@ -211,15 +213,45 @@ where
                     trace!(target: "downloaders::headers", ?error ,"Failed to validate header");
                     return Err(HeadersResponseError { request, peer_id: Some(peer_id), error })
                 }
-            } else if parent.hash() != sync_target_hash {
-                return Err(HeadersResponseError {
-                    request,
-                    peer_id: Some(peer_id),
-                    error: DownloadError::InvalidTip {
-                        received: parent.hash(),
-                        expected: sync_target_hash,
-                    },
-                })
+            } else {
+                match sync_target {
+                    SyncTargetBlock::Hash(hash) => {
+                        if parent.hash() != hash {
+                            return Err(HeadersResponseError {
+                                request,
+                                peer_id: Some(peer_id),
+                                error: DownloadError::InvalidTip {
+                                    received: parent.hash(),
+                                    expected: hash,
+                                },
+                            })
+                        }
+                    }
+                    SyncTargetBlock::Number(number) => {
+                        if parent.number != number {
+                            return Err(HeadersResponseError {
+                                request,
+                                peer_id: Some(peer_id),
+                                error: DownloadError::InvalidTipNumber {
+                                    received: parent.number,
+                                    expected: number,
+                                },
+                            })
+                        }
+                    }
+                    SyncTargetBlock::HashAndNumber { hash, .. } => {
+                        if parent.hash() != hash {
+                            return Err(HeadersResponseError {
+                                request,
+                                peer_id: Some(peer_id),
+                                error: DownloadError::InvalidTip {
+                                    received: parent.hash(),
+                                    expected: hash,
+                                },
+                            })
+                        }
+                    }
+                }
             }
 
             validated.push(parent);
@@ -246,7 +278,7 @@ where
     fn on_block_number_update(&mut self, target_block_number: u64, next_block: u64) {
         // Update the trackers
         if let Some(old_target) =
-            self.sync_target.as_mut().and_then(|t| t.number.replace(target_block_number))
+            self.sync_target.as_mut().and_then(|t| t.replace_number(target_block_number))
         {
             if target_block_number > old_target {
                 // the new target is higher than the old target we need to update the
@@ -277,7 +309,7 @@ where
         &mut self,
         response: HeadersRequestOutcome,
     ) -> Result<(), HeadersResponseError> {
-        let sync_target_hash = self.existing_sync_target_hash();
+        let sync_target = self.existing_sync_target();
         let HeadersRequestOutcome { request, outcome } = response;
         match outcome {
             Ok(res) => {
@@ -299,15 +331,43 @@ where
 
                 let target = headers.remove(0).seal_slow();
 
-                if target.hash() != sync_target_hash {
-                    return Err(HeadersResponseError {
-                        request,
-                        peer_id: Some(peer_id),
-                        error: DownloadError::InvalidTip {
-                            received: target.hash(),
-                            expected: sync_target_hash,
-                        },
-                    })
+                match sync_target {
+                    SyncTargetBlock::Hash(hash) => {
+                        if target.hash() != hash {
+                            return Err(HeadersResponseError {
+                                request,
+                                peer_id: Some(peer_id),
+                                error: DownloadError::InvalidTip {
+                                    received: target.hash(),
+                                    expected: hash,
+                                },
+                            })
+                        }
+                    }
+                    SyncTargetBlock::Number(number) => {
+                        if target.number != number {
+                            return Err(HeadersResponseError {
+                                request,
+                                peer_id: Some(peer_id),
+                                error: DownloadError::InvalidTipNumber {
+                                    received: target.number,
+                                    expected: number,
+                                },
+                            })
+                        }
+                    }
+                    SyncTargetBlock::HashAndNumber { hash, .. } => {
+                        if target.hash() != hash {
+                            return Err(HeadersResponseError {
+                                request,
+                                peer_id: Some(peer_id),
+                                error: DownloadError::InvalidTip {
+                                    received: target.hash(),
+                                    expected: hash,
+                                },
+                            })
+                        }
+                    }
                 }
 
                 trace!(target: "downloaders::headers", head=?self.local_block_number(), hash=?target.hash(), number=%target.number, "Received sync target");
@@ -463,8 +523,8 @@ where
     }
 
     /// Returns the request for the `sync_target` header.
-    fn get_sync_target_request(&self, start: H256) -> HeadersRequest {
-        HeadersRequest { start: start.into(), limit: 1, direction: HeadersDirection::Falling }
+    fn get_sync_target_request(&self, start: BlockHashOrNumber) -> HeadersRequest {
+        HeadersRequest { start, limit: 1, direction: HeadersDirection::Falling }
     }
 
     /// Starts a request future
@@ -552,7 +612,7 @@ where
 
     /// If the given target is different from the current target, we need to update the sync target
     fn update_sync_target(&mut self, target: SyncTarget) {
-        let current_tip = self.sync_target.as_ref().map(|t| t.hash);
+        let current_tip = self.sync_target.as_ref().and_then(|t| t.hash());
         match target {
             SyncTarget::Tip(tip) => {
                 if Some(tip) != current_tip {
@@ -574,8 +634,9 @@ where
                     trace!(target: "downloaders::headers", new=?target, "Request new sync target");
                     self.metrics.out_of_order_requests.increment(1);
                     self.sync_target = Some(new_sync_target);
-                    self.sync_target_request =
-                        Some(self.request_fut(self.get_sync_target_request(tip), Priority::High));
+                    self.sync_target_request = Some(
+                        self.request_fut(self.get_sync_target_request(tip.into()), Priority::High),
+                    );
                 }
             }
             SyncTarget::Gap(existing) => {
@@ -591,15 +652,23 @@ where
 
                     // Update the sync target hash
                     self.sync_target = match self.sync_target.take() {
-                        Some(mut sync_target) => {
-                            sync_target.hash = target;
-                            Some(sync_target)
-                        }
+                        Some(sync_target) => Some(sync_target.with_hash(target)),
                         None => Some(SyncTargetBlock::from_hash(target)),
                     };
                     self.on_block_number_update(parent_block_number, parent_block_number);
                 }
             }
+            SyncTarget::TipNum(num) => {
+                let current_tip_num = self.sync_target.as_ref().and_then(|t| t.number());
+                if Some(num) != current_tip_num {
+                    trace!(target: "downloaders::headers", %num, "Updating sync target based on num");
+                    // just update the sync target
+                    self.sync_target = Some(SyncTargetBlock::from_number(num));
+                    self.sync_target_request = Some(
+                        self.request_fut(self.get_sync_target_request(num.into()), Priority::High),
+                    );
+                }
+            }
         }
     }
 
@@ -823,24 +892,90 @@ impl HeadersResponseError {
 }
 
 /// The block to which we want to close the gap: (local head...sync target]
-#[derive(Debug, Default)]
-struct SyncTargetBlock {
+/// This tracks the sync target block, so this could be either a block number or hash.
+#[derive(Clone, Debug)]
+pub enum SyncTargetBlock {
     /// Block hash of the targeted block
-    hash: H256,
-    /// This is an `Option` because we don't know the block number at first
-    number: Option<u64>,
+    Hash(H256),
+    /// Block number of the targeted block
+    Number(u64),
+    /// Both the block hash and number of the targeted block
+    HashAndNumber {
+        /// Block hash of the targeted block
+        hash: H256,
+        /// Block number of the targeted block
+        number: u64,
+    },
 }
 
 impl SyncTargetBlock {
     /// Create new instance from hash.
     fn from_hash(hash: H256) -> Self {
-        Self { hash, number: None }
+        Self::Hash(hash)
+    }
+
+    /// Create new instance from number.
+    fn from_number(num: u64) -> Self {
+        Self::Number(num)
+    }
+
+    /// Set the hash for the sync target.
+    fn with_hash(self, hash: H256) -> Self {
+        match self {
+            Self::Hash(_) => Self::Hash(hash),
+            Self::Number(number) => Self::HashAndNumber { hash, number },
+            Self::HashAndNumber { number, .. } => Self::HashAndNumber { hash, number },
+        }
     }
 
     /// Set a number on the instance.
-    fn with_number(mut self, number: u64) -> Self {
-        self.number = Some(number);
-        self
+    fn with_number(self, number: u64) -> Self {
+        match self {
+            Self::Hash(hash) => Self::HashAndNumber { hash, number },
+            Self::Number(_) => Self::Number(number),
+            Self::HashAndNumber { hash, .. } => Self::HashAndNumber { hash, number },
+        }
+    }
+
+    /// Replace the target block number, and return the old block number, if it was set.
+    ///
+    /// If the target block is a hash, this be converted into a `HashAndNumber`, but return `None`.
+    /// The semantics should be equivalent to that of `Option::replace`.
+    fn replace_number(&mut self, number: u64) -> Option<u64> {
+        match self {
+            Self::Hash(hash) => {
+                *self = Self::HashAndNumber { hash: *hash, number };
+                None
+            }
+            Self::Number(old_number) => {
+                let res = Some(*old_number);
+                *self = Self::Number(number);
+                res
+            }
+            Self::HashAndNumber { number: old_number, hash } => {
+                let res = Some(*old_number);
+                *self = Self::HashAndNumber { hash: *hash, number };
+                res
+            }
+        }
+    }
+
+    /// Return the hash of the target block, if it is set.
+    fn hash(&self) -> Option<H256> {
+        match self {
+            Self::Hash(hash) => Some(*hash),
+            Self::Number(_) => None,
+            Self::HashAndNumber { hash, .. } => Some(*hash),
+        }
+    }
+
+    /// Return the block number of the sync target, if it is set.
+    fn number(&self) -> Option<u64> {
+        match self {
+            Self::Hash(_) => None,
+            Self::Number(number) => Some(*number),
+            Self::HashAndNumber { number, .. } => Some(*number),
+        }
     }
 }
 
@@ -989,6 +1124,65 @@ mod tests {
     use reth_interfaces::test_utils::{TestConsensus, TestHeadersClient};
     use reth_primitives::SealedHeader;
 
+    /// Tests that `replace_number` works the same way as Option::replace
+    #[test]
+    fn test_replace_number_semantics() {
+        struct Fixture {
+            // input fields (both SyncTargetBlock and Option<u64>)
+            sync_target_block: SyncTargetBlock,
+            sync_target_option: Option<u64>,
+
+            // option to replace
+            replace_number: u64,
+
+            // expected method result
+            expected_result: Option<u64>,
+
+            // output state
+            new_number: u64,
+        }
+
+        let fixtures = vec![
+            Fixture {
+                sync_target_block: SyncTargetBlock::Hash(H256::random()),
+                // Hash maps to None here, all other variants map to Some
+                sync_target_option: None,
+                replace_number: 1,
+                expected_result: None,
+                new_number: 1,
+            },
+            Fixture {
+                sync_target_block: SyncTargetBlock::Number(1),
+                sync_target_option: Some(1),
+                replace_number: 2,
+                expected_result: Some(1),
+                new_number: 2,
+            },
+            Fixture {
+                sync_target_block: SyncTargetBlock::HashAndNumber {
+                    hash: H256::random(),
+                    number: 1,
+                },
+                sync_target_option: Some(1),
+                replace_number: 2,
+                expected_result: Some(1),
+                new_number: 2,
+            },
+        ];
+
+        for fixture in fixtures {
+            let mut sync_target_block = fixture.sync_target_block;
+            let result = sync_target_block.replace_number(fixture.replace_number);
+            assert_eq!(result, fixture.expected_result);
+            assert_eq!(sync_target_block.number(), Some(fixture.new_number));
+
+            let mut sync_target_option = fixture.sync_target_option;
+            let option_result = sync_target_option.replace(fixture.replace_number);
+            assert_eq!(option_result, fixture.expected_result);
+            assert_eq!(sync_target_option, Some(fixture.new_number));
+        }
+    }
+
     /// Tests that request calc works
     #[test]
     fn test_sync_target_update() {
@@ -1013,7 +1207,7 @@ mod tests {
         assert!(downloader.sync_target_request.is_none());
         assert_matches!(
             downloader.sync_target,
-            Some(target) => target.number.is_some()
+            Some(target) => target.number().is_some()
         );
     }
 
diff --git a/crates/net/downloaders/src/headers/task.rs b/crates/net/downloaders/src/headers/task.rs
index 1d8a4ab1af4..bce7a8d0f87 100644
--- a/crates/net/downloaders/src/headers/task.rs
+++ b/crates/net/downloaders/src/headers/task.rs
@@ -68,7 +68,7 @@ impl TaskDownloader {
             updates: UnboundedReceiverStream::new(updates_rx),
             downloader,
         };
-        spawner.spawn(async move { downloader.await }.boxed());
+        spawner.spawn(downloader.boxed());
 
         Self { from_downloader: UnboundedReceiverStream::new(headers_rx), to_downloader }
     }
diff --git a/crates/net/ecies/Cargo.toml b/crates/net/ecies/Cargo.toml
index 9c61f8eef36..f5c76d68dda 100644
--- a/crates/net/ecies/Cargo.toml
+++ b/crates/net/ecies/Cargo.toml
@@ -30,7 +30,7 @@ byteorder = "1.4.3"
 rand = "0.8.5"
 ctr = "0.9.2"
 digest = "0.10.5"
-secp256k1 = { version = "0.24.2", features = ["global-context", "rand-std", "recovery"] }
+secp256k1 = { version = "0.26.0", features = ["global-context", "rand-std", "recovery"] }
 sha2 = "0.10.6"
 sha3 = "0.10.5"
 aes = "0.8.1"
diff --git a/crates/net/eth-wire/Cargo.toml b/crates/net/eth-wire/Cargo.toml
index fb76a352b66..831298a449b 100644
--- a/crates/net/eth-wire/Cargo.toml
+++ b/crates/net/eth-wire/Cargo.toml
@@ -45,8 +45,9 @@ ethers-core = { git = "https://github.com/gakonst/ethers-rs", default-features =
 test-fuzz = "3.0.4"
 tokio-util = { version = "0.7.4", features = ["io", "codec"] }
 hex-literal = "0.3"
+hex = "0.4"
 rand = "0.8"
-secp256k1 = { version = "0.24.2", features = ["global-context", "rand-std", "recovery"] }
+secp256k1 = { version = "0.26.0", features = ["global-context", "rand-std", "recovery"] }
 
 arbitrary = { version = "1.1.7", features = ["derive"] }
 proptest = { version = "1.0" }
diff --git a/crates/net/eth-wire/src/ethstream.rs b/crates/net/eth-wire/src/ethstream.rs
index 605b8e6a675..ae5d60edf3e 100644
--- a/crates/net/eth-wire/src/ethstream.rs
+++ b/crates/net/eth-wire/src/ethstream.rs
@@ -66,7 +66,6 @@ where
         let our_status_bytes = our_status_bytes.freeze();
         self.inner.send(our_status_bytes).await?;
 
-        tracing::trace!("waiting for eth status from peer");
         let their_msg_res = self.inner.next().await;
 
         let their_msg = match their_msg_res {
diff --git a/crates/net/eth-wire/src/p2pstream.rs b/crates/net/eth-wire/src/p2pstream.rs
index 25be3ae0d2b..2026754f88d 100644
--- a/crates/net/eth-wire/src/p2pstream.rs
+++ b/crates/net/eth-wire/src/p2pstream.rs
@@ -90,8 +90,6 @@ where
         P2PMessage::Hello(hello.clone()).encode(&mut raw_hello_bytes);
         self.inner.send(raw_hello_bytes.into()).await?;
 
-        tracing::trace!("waiting for p2p hello from peer");
-
         let first_message_bytes = tokio::time::timeout(HANDSHAKE_TIMEOUT, self.inner.next())
             .await
             .or(Err(P2PStreamError::HandshakeError(P2PHandshakeError::Timeout)))?
@@ -250,7 +248,15 @@ impl<S> P2PStream<S> {
         let pong = P2PMessage::Pong;
         let mut pong_bytes = BytesMut::with_capacity(pong.length());
         pong.encode(&mut pong_bytes);
-        self.outgoing_messages.push_back(pong_bytes.into());
+        self.outgoing_messages.push_back(pong_bytes.freeze());
+    }
+
+    /// Queues in a _snappy_ encoded [`P2PMessage::Ping`] message.
+    fn send_ping(&mut self) {
+        let ping = P2PMessage::Ping;
+        let mut ping_bytes = BytesMut::with_capacity(ping.length());
+        ping.encode(&mut ping_bytes);
+        self.outgoing_messages.push_back(ping_bytes.freeze());
     }
 
     /// Starts to gracefully disconnect the connection by sending a Disconnect message and stop
@@ -439,17 +445,7 @@ where
         match this.pinger.poll_ping(cx) {
             Poll::Pending => {}
             Poll::Ready(Ok(PingerEvent::Ping)) => {
-                // encode the ping message
-                let mut ping_bytes = BytesMut::new();
-                P2PMessage::Ping.encode(&mut ping_bytes);
-
-                // check if the buffer is full
-                if this.outgoing_messages.len() >= MAX_P2P_CAPACITY {
-                    return Poll::Ready(Err(P2PStreamError::SendBufferFull))
-                }
-
-                // if the sink is not ready, buffer the message
-                this.outgoing_messages.push_back(ping_bytes.into());
+                this.send_ping();
             }
             _ => {
                 // encode the disconnect message
@@ -518,12 +514,9 @@ where
             match ready!(this.inner.as_mut().poll_flush(cx)) {
                 Err(err) => return Poll::Ready(Err(err.into())),
                 Ok(()) => {
-                    if let Some(message) = this.outgoing_messages.pop_front() {
-                        if let Err(err) = this.inner.as_mut().start_send(message) {
-                            return Poll::Ready(Err(err.into()))
-                        }
-                    } else {
-                        return Poll::Ready(Ok(()))
+                    let Some(message) = this.outgoing_messages.pop_front() else { return Poll::Ready(Ok(())) };
+                    if let Err(err) = this.inner.as_mut().start_send(message) {
+                        return Poll::Ready(Err(err.into()))
                     }
                 }
             }
@@ -700,8 +693,22 @@ impl Encodable for P2PMessage {
 /// The [`Decodable`](reth_rlp::Decodable) implementation for [`P2PMessage`] assumes that each of
 /// the message variants are snappy compressed, except for the [`P2PMessage::Hello`] variant since
 /// the hello message is never compressed in the `p2p` subprotocol.
+/// The [`Decodable`] implementation for [`P2PMessage::Ping`] and
+/// [`P2PMessage::Pong`] expects a snappy encoded payload, see [`Encodable`] implementation.
 impl Decodable for P2PMessage {
     fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
+        /// Removes the snappy prefix from the Ping/Pong buffer
+        fn advance_snappy_ping_pong_payload(buf: &mut &[u8]) -> Result<(), DecodeError> {
+            if buf.len() < 3 {
+                return Err(DecodeError::InputTooShort)
+            }
+            if buf[..3] != [0x01, 0x00, EMPTY_LIST_CODE] {
+                return Err(DecodeError::Custom("expected snappy payload"))
+            }
+            buf.advance(3);
+            Ok(())
+        }
+
         let message_id = u8::decode(&mut &buf[..])?;
         let id = P2PMessageID::try_from(message_id)
             .or(Err(DecodeError::Custom("unknown p2p message id")))?;
@@ -710,11 +717,11 @@ impl Decodable for P2PMessage {
             P2PMessageID::Hello => Ok(P2PMessage::Hello(HelloMessage::decode(buf)?)),
             P2PMessageID::Disconnect => Ok(P2PMessage::Disconnect(DisconnectReason::decode(buf)?)),
             P2PMessageID::Ping => {
-                buf.advance(1);
+                advance_snappy_ping_pong_payload(buf)?;
                 Ok(P2PMessage::Ping)
             }
             P2PMessageID::Pong => {
-                buf.advance(1);
+                advance_snappy_ping_pong_payload(buf)?;
                 Ok(P2PMessage::Pong)
             }
         }
diff --git a/crates/net/eth-wire/src/types/blocks.rs b/crates/net/eth-wire/src/types/blocks.rs
index 2f93b2dc419..1890b355d66 100644
--- a/crates/net/eth-wire/src/types/blocks.rs
+++ b/crates/net/eth-wire/src/types/blocks.rs
@@ -87,9 +87,9 @@ pub struct BlockBody {
 
 impl BlockBody {
     /// Create a [`Block`](reth_primitives::Block) from the body and its header.
-    pub fn create_block(&self, header: &Header) -> Block {
+    pub fn create_block(&self, header: Header) -> Block {
         Block {
-            header: header.clone(),
+            header,
             body: self.transactions.clone(),
             ommers: self.ommers.clone(),
             withdrawals: self.withdrawals.clone(),
diff --git a/crates/net/eth-wire/src/types/broadcast.rs b/crates/net/eth-wire/src/types/broadcast.rs
index c6fef5457fc..c31ce72445f 100644
--- a/crates/net/eth-wire/src/types/broadcast.rs
+++ b/crates/net/eth-wire/src/types/broadcast.rs
@@ -1,8 +1,11 @@
 //! Types for broadcasting new data.
 use crate::{EthMessage, EthVersion};
+use bytes::Bytes;
 use reth_codecs::derive_arbitrary;
 use reth_primitives::{Block, TransactionSigned, H256, U128};
-use reth_rlp::{RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper};
+use reth_rlp::{
+    Decodable, Encodable, RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper,
+};
 use std::sync::Arc;
 
 #[cfg(feature = "serde")]
@@ -149,6 +152,35 @@ impl NewPooledTransactionHashes {
             NewPooledTransactionHashes::Eth68(msg) => msg.hashes.into_iter(),
         }
     }
+
+    /// Shortens the number of hashes in the message, keeping the first `len` hashes and dropping
+    /// the rest. If `len` is greater than the number of hashes, this has no effect.
+    pub fn truncate(&mut self, len: usize) {
+        match self {
+            NewPooledTransactionHashes::Eth66(msg) => msg.0.truncate(len),
+            NewPooledTransactionHashes::Eth68(msg) => {
+                msg.types.truncate(len);
+                msg.sizes.truncate(len);
+                msg.hashes.truncate(len);
+            }
+        }
+    }
+
+    /// Returns true if the message is empty
+    pub fn is_empty(&self) -> bool {
+        match self {
+            NewPooledTransactionHashes::Eth66(msg) => msg.0.is_empty(),
+            NewPooledTransactionHashes::Eth68(msg) => msg.hashes.is_empty(),
+        }
+    }
+
+    /// Returns the number of hashes in the message
+    pub fn len(&self) -> usize {
+        match self {
+            NewPooledTransactionHashes::Eth66(msg) => msg.0.len(),
+            NewPooledTransactionHashes::Eth68(msg) => msg.hashes.len(),
+        }
+    }
 }
 
 impl From<NewPooledTransactionHashes> for EthMessage {
@@ -193,10 +225,32 @@ impl From<Vec<H256>> for NewPooledTransactionHashes66 {
 /// Same as [`NewPooledTransactionHashes66`] but extends that that beside the transaction hashes,
 /// the node sends the transaction types and their sizes (as defined in EIP-2718) as well.
 #[derive_arbitrary(rlp)]
-#[derive(Clone, Debug, PartialEq, Eq, RlpEncodable, RlpDecodable, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct NewPooledTransactionHashes68 {
     /// Transaction types for new transactions that have appeared on the network.
+    ///
+    /// ## Note on RLP encoding and decoding
+    ///
+    /// In the [eth/68 spec](https://eips.ethereum.org/EIPS/eip-5793#specification) this is defined
+    /// the following way:
+    ///  * `[type_0: B_1, type_1: B_1, ...]`
+    ///
+    /// This would make it seem like the [`Encodable`](reth_rlp::Encodable) and
+    /// [`Decodable`](reth_rlp::Decodable) implementations should directly use a `Vec<u8>` for
+    /// encoding and decoding, because it looks like this field should be encoded as a _list_ of
+    /// bytes.
+    ///
+    /// However, [this is implemented in geth as a `[]byte`
+    /// type](https://github.com/ethereum/go-ethereum/blob/82d934b1dd80cdd8190803ea9f73ed2c345e2576/eth/protocols/eth/protocol.go#L308-L313),
+    /// which [ends up being encoded as a RLP
+    /// string](https://github.com/ethereum/go-ethereum/blob/82d934b1dd80cdd8190803ea9f73ed2c345e2576/rlp/encode_test.go#L171-L176),
+    /// **not** a RLP list.
+    ///
+    /// Because of this, we do not directly use the `Vec<u8>` when encoding and decoding, and
+    /// instead use the [`Encodable`](reth_rlp::Encodable) and [`Decodable`](reth_rlp::Decodable)
+    /// implementations for `&[u8]` instead, which encodes into a RLP string, and expects an RLP
+    /// string when decoding.
     pub types: Vec<u8>,
     /// Transaction sizes for new transactions that have appeared on the network.
     pub sizes: Vec<usize>,
@@ -204,10 +258,80 @@ pub struct NewPooledTransactionHashes68 {
     pub hashes: Vec<H256>,
 }
 
+impl Encodable for NewPooledTransactionHashes68 {
+    fn encode(&self, out: &mut dyn bytes::BufMut) {
+        #[derive(RlpEncodable)]
+        struct EncodableNewPooledTransactionHashes68<'a> {
+            types: &'a [u8],
+            sizes: &'a Vec<usize>,
+            hashes: &'a Vec<H256>,
+        }
+
+        let encodable = EncodableNewPooledTransactionHashes68 {
+            types: &self.types[..],
+            sizes: &self.sizes,
+            hashes: &self.hashes,
+        };
+
+        encodable.encode(out);
+    }
+    fn length(&self) -> usize {
+        #[derive(RlpEncodable)]
+        struct EncodableNewPooledTransactionHashes68<'a> {
+            types: &'a [u8],
+            sizes: &'a Vec<usize>,
+            hashes: &'a Vec<H256>,
+        }
+
+        let encodable = EncodableNewPooledTransactionHashes68 {
+            types: &self.types[..],
+            sizes: &self.sizes,
+            hashes: &self.hashes,
+        };
+
+        encodable.length()
+    }
+}
+
+impl Decodable for NewPooledTransactionHashes68 {
+    fn decode(buf: &mut &[u8]) -> Result<Self, reth_rlp::DecodeError> {
+        #[derive(RlpDecodable)]
+        struct EncodableNewPooledTransactionHashes68 {
+            types: Bytes,
+            sizes: Vec<usize>,
+            hashes: Vec<H256>,
+        }
+
+        let encodable = EncodableNewPooledTransactionHashes68::decode(buf)?;
+        Ok(Self { types: encodable.types.into(), sizes: encodable.sizes, hashes: encodable.hashes })
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use std::str::FromStr;
+
+    use bytes::BytesMut;
+    use hex_literal::hex;
+    use reth_rlp::{Decodable, Encodable};
+
     use super::*;
 
+    /// Takes as input a struct / encoded hex message pair, ensuring that we encode to the exact hex
+    /// message, and decode to the exact struct.
+    fn test_encoding_vector<T: Encodable + Decodable + PartialEq + std::fmt::Debug>(
+        input: (T, &[u8]),
+    ) {
+        let (expected_decoded, expected_encoded) = input;
+        let mut encoded = BytesMut::new();
+        expected_decoded.encode(&mut encoded);
+
+        assert_eq!(hex::encode(&encoded), hex::encode(expected_encoded));
+
+        let decoded = T::decode(&mut encoded.as_ref()).unwrap();
+        assert_eq!(expected_decoded, decoded);
+    }
+
     #[test]
     fn can_return_latest_block() {
         let mut blocks = NewBlockHashes(vec![BlockHashNumber { hash: H256::random(), number: 0 }]);
@@ -219,4 +343,125 @@ mod tests {
         let latest = blocks.latest().unwrap();
         assert_eq!(latest.number, 100);
     }
+
+    #[test]
+    fn eth_68_tx_hash_roundtrip() {
+        let vectors = vec![
+            (
+            NewPooledTransactionHashes68 { types: vec![], sizes: vec![], hashes: vec![] },
+            &hex!("c380c0c0")[..],
+            ),
+            (
+            NewPooledTransactionHashes68 {
+                types: vec![0x00],
+                sizes: vec![0x00],
+                hashes: vec![H256::from_str(
+                    "0x0000000000000000000000000000000000000000000000000000000000000000",
+                )
+                .unwrap()],
+            },
+            &hex!("e500c180e1a00000000000000000000000000000000000000000000000000000000000000000")[..],
+            ),
+            (
+            NewPooledTransactionHashes68 {
+                types: vec![0x00, 0x00],
+                sizes: vec![0x00, 0x00],
+                hashes: vec![
+                    H256::from_str(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    )
+                    .unwrap(),
+                    H256::from_str(
+                        "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    )
+                    .unwrap(),
+                ],
+            },
+            &hex!("f84a820000c28080f842a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000")[..],
+            ),
+            (
+            NewPooledTransactionHashes68 {
+                types: vec![0x02],
+                sizes: vec![0xb6],
+                hashes: vec![H256::from_str(
+                    "0xfecbed04c7b88d8e7221a0a3f5dc33f220212347fc167459ea5cc9c3eb4c1124",
+                )
+                .unwrap()],
+            },
+            &hex!("e602c281b6e1a0fecbed04c7b88d8e7221a0a3f5dc33f220212347fc167459ea5cc9c3eb4c1124")[..],
+            ),
+            (
+            NewPooledTransactionHashes68 {
+                types: vec![0xff, 0xff],
+                sizes: vec![0xffffffff, 0xffffffff],
+                hashes: vec![
+                    H256::from_str(
+                        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+                    )
+                    .unwrap(),
+                    H256::from_str(
+                        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+                    )
+                    .unwrap(),
+                ],
+            },
+            &hex!("f85282ffffca84ffffffff84fffffffff842a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[..],
+            ),
+            (
+            NewPooledTransactionHashes68 {
+                types: vec![0xff, 0xff],
+                sizes: vec![0xffffffff, 0xffffffff],
+                hashes: vec![
+                    H256::from_str(
+                        "0xbeefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafe",
+                    )
+                    .unwrap(),
+                    H256::from_str(
+                        "0xbeefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafe",
+                    )
+                    .unwrap(),
+                ],
+            },
+            &hex!("f85282ffffca84ffffffff84fffffffff842a0beefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafea0beefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafebeefcafe")[..],
+            ),
+            (
+            NewPooledTransactionHashes68 {
+                types: vec![0x10, 0x10],
+                sizes: vec![0xdeadc0de, 0xdeadc0de],
+                hashes: vec![
+                    H256::from_str(
+                        "0x3b9aca00f0671c9a2a1b817a0a78d3fe0c0f776cccb2a8c3c1b412a4f4e4d4e2",
+                    )
+                    .unwrap(),
+                    H256::from_str(
+                        "0x3b9aca00f0671c9a2a1b817a0a78d3fe0c0f776cccb2a8c3c1b412a4f4e4d4e2",
+                    )
+                    .unwrap(),
+                ],
+            },
+            &hex!("f852821010ca84deadc0de84deadc0def842a03b9aca00f0671c9a2a1b817a0a78d3fe0c0f776cccb2a8c3c1b412a4f4e4d4e2a03b9aca00f0671c9a2a1b817a0a78d3fe0c0f776cccb2a8c3c1b412a4f4e4d4e2")[..],
+            ),
+            (
+            NewPooledTransactionHashes68 {
+                types: vec![0x6f, 0x6f],
+                sizes: vec![0x7fffffff, 0x7fffffff],
+                hashes: vec![
+                    H256::from_str(
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                    )
+                    .unwrap(),
+                    H256::from_str(
+                        "0x0000000000000000000000000000000000000000000000000000000000000002",
+                    )
+                    .unwrap(),
+                ],
+            },
+            &hex!("f852826f6fca847fffffff847ffffffff842a00000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000002")[..],
+            ),
+        ];
+
+        for vector in vectors {
+            test_encoding_vector(vector);
+        }
+    }
 }
diff --git a/crates/net/nat/src/lib.rs b/crates/net/nat/src/lib.rs
index 69a72cded14..3cb65d060c5 100644
--- a/crates/net/nat/src/lib.rs
+++ b/crates/net/nat/src/lib.rs
@@ -82,13 +82,10 @@ impl FromStr for NatResolver {
             "none" => NatResolver::None,
             "publicip" | "public-ip" => NatResolver::PublicIp,
             s => {
-                if let Some(ip) = s.strip_prefix("extip:") {
-                    NatResolver::ExternalIp(ip.parse::<IpAddr>()?)
-                } else {
-                    return Err(ParseNatResolverError::UnknonwVariant(format!(
+                let Some(ip) = s.strip_prefix("extip:") else { return Err(ParseNatResolverError::UnknonwVariant(format!(
                         "Unknown Nat Resolver: {s}"
-                    )))
-                }
+                    ))) };
+                NatResolver::ExternalIp(ip.parse::<IpAddr>()?)
             }
         };
         Ok(r)
diff --git a/crates/net/network/Cargo.toml b/crates/net/network/Cargo.toml
index 9c27701b12b..a7c3a68fcc8 100644
--- a/crates/net/network/Cargo.toml
+++ b/crates/net/network/Cargo.toml
@@ -50,7 +50,7 @@ reth-metrics-derive = { path = "../../metrics/metrics-derive" }
 
 # misc
 auto_impl = "1"
-aquamarine = "0.2.1" # docs
+aquamarine = "0.3.0"
 tracing = "0.1"
 fnv = "1.0"
 thiserror = "1.0"
@@ -59,13 +59,13 @@ async-trait = "0.1"
 linked_hash_set = "0.1"
 linked-hash-map = "0.5.6"
 rand = "0.8"
-secp256k1 = { version = "0.24", features = [
+secp256k1 = { version = "0.26.0", features = [
     "global-context",
     "rand-std",
     "recovery",
 ] }
 
-enr = { version = "0.7.0", features = ["rust-secp256k1"], optional = true }
+enr = { version = "0.8.0", features = ["rust-secp256k1"], optional = true }
 ethers-core = { git = "https://github.com/gakonst/ethers-rs", default-features = false, optional = true }
 tempfile = { version = "3.3", optional = true }
 
@@ -87,7 +87,7 @@ ethers-providers = { git = "https://github.com/gakonst/ethers-rs", default-featu
 ethers-signers = { git = "https://github.com/gakonst/ethers-rs", default-features = false }
 ethers-middleware = { git = "https://github.com/gakonst/ethers-rs", default-features = false }
 
-enr = { version = "0.7.0", features = ["serde", "rust-secp256k1"] }
+enr = { version = "0.8.0", features = ["serde", "rust-secp256k1"] }
 
 # misc
 hex = "0.4"
diff --git a/crates/net/network/src/config.rs b/crates/net/network/src/config.rs
index add23de286f..4513879ae9d 100644
--- a/crates/net/network/src/config.rs
+++ b/crates/net/network/src/config.rs
@@ -15,12 +15,12 @@ use secp256k1::{SecretKey, SECP256K1};
 use std::{
     collections::HashSet,
     net::{Ipv4Addr, SocketAddr, SocketAddrV4},
+    sync::Arc,
 };
 
 /// reexports for convenience
 #[doc(hidden)]
 mod __reexport {
-    pub use reth_discv4::bootnodes::*;
     pub use secp256k1::SecretKey;
 }
 pub use __reexport::*;
@@ -54,7 +54,7 @@ pub struct NetworkConfig<C> {
     /// How to configure the [SessionManager](crate::session::SessionManager).
     pub sessions_config: SessionsConfig,
     /// The chain spec
-    pub chain_spec: ChainSpec,
+    pub chain_spec: Arc<ChainSpec>,
     /// The [`ForkFilter`] to use at launch for authenticating sessions.
     ///
     /// See also <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2124.md#stale-software-examples>
@@ -139,7 +139,7 @@ pub struct NetworkConfigBuilder {
     /// How to configure the sessions manager
     sessions_config: Option<SessionsConfig>,
     /// The network's chain spec
-    chain_spec: ChainSpec,
+    chain_spec: Arc<ChainSpec>,
     /// The default mode of the network.
     network_mode: NetworkMode,
     /// The executor to use for spawning tasks.
@@ -165,7 +165,7 @@ impl NetworkConfigBuilder {
             listener_addr: None,
             peers_config: None,
             sessions_config: None,
-            chain_spec: MAINNET.clone(),
+            chain_spec: Arc::new(MAINNET.clone()),
             network_mode: Default::default(),
             executor: None,
             hello_message: None,
@@ -179,7 +179,7 @@ impl NetworkConfigBuilder {
     }
 
     /// Sets the chain spec.
-    pub fn chain_spec(mut self, chain_spec: ChainSpec) -> Self {
+    pub fn chain_spec(mut self, chain_spec: Arc<ChainSpec>) -> Self {
         self.chain_spec = chain_spec;
         self
     }
@@ -417,6 +417,7 @@ mod tests {
 
         // remove any `next` fields we would have by removing all hardforks
         chain_spec.hardforks = BTreeMap::new();
+        let chain_spec = Arc::new(chain_spec);
 
         // check that the forkid is initialized with the genesis and no other forks
         let genesis_fork_hash = ForkHash::from(chain_spec.genesis_hash());
diff --git a/crates/net/network/src/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index 324419be45d..80d36cee7cb 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -7,7 +7,7 @@ use reth_eth_wire::{
     GetReceipts, NodeData, Receipts,
 };
 use reth_interfaces::p2p::error::RequestResult;
-use reth_primitives::{BlockHashOrNumber, Header, HeadersDirection, PeerId, U256};
+use reth_primitives::{BlockHashOrNumber, Header, HeadersDirection, PeerId};
 use reth_provider::{BlockProvider, HeaderProvider};
 use std::{
     borrow::Borrow,
@@ -82,11 +82,8 @@ where
         let mut block: BlockHashOrNumber = match start_block {
             BlockHashOrNumber::Hash(start) => start.into(),
             BlockHashOrNumber::Number(num) => {
-                if let Some(hash) = self.client.block_hash(U256::from(num)).unwrap_or_default() {
-                    hash.into()
-                } else {
-                    return headers
-                }
+                let Some(hash) = self.client.block_hash(num).unwrap_or_default() else { return headers };
+                hash.into()
             }
         };
 
diff --git a/crates/net/network/src/fetch/mod.rs b/crates/net/network/src/fetch/mod.rs
index b1db5a85c78..8672fa6a7db 100644
--- a/crates/net/network/src/fetch/mod.rs
+++ b/crates/net/network/src/fetch/mod.rs
@@ -135,11 +135,7 @@ impl StateFetcher {
             return PollAction::NoRequests
         }
 
-        let peer_id = if let Some(peer_id) = self.next_peer() {
-            peer_id
-        } else {
-            return PollAction::NoPeersAvailable
-        };
+        let Some(peer_id) = self.next_peer() else { return PollAction::NoPeersAvailable };
 
         let request = self.queued_requests.pop_front().expect("not empty; qed");
         let request = self.prepare_block_request(peer_id, request);
diff --git a/crates/net/network/src/import.rs b/crates/net/network/src/import.rs
index 87f7e30ded1..2146772c2ae 100644
--- a/crates/net/network/src/import.rs
+++ b/crates/net/network/src/import.rs
@@ -47,7 +47,7 @@ pub enum BlockValidation {
 pub enum BlockImportError {
     /// Consensus error
     #[error(transparent)]
-    Consensus(#[from] reth_interfaces::consensus::Error),
+    Consensus(#[from] reth_interfaces::consensus::ConsensusError),
 }
 
 /// An implementation of `BlockImport` used in Proof-of-Stake consensus that does nothing.
diff --git a/crates/net/network/src/lib.rs b/crates/net/network/src/lib.rs
index 1bc7ff986a0..5db64c797cd 100644
--- a/crates/net/network/src/lib.rs
+++ b/crates/net/network/src/lib.rs
@@ -55,9 +55,10 @@
 //!
 //! ```
 //! # async fn launch() {
-//! use reth_network::config::{rng_secret_key, mainnet_nodes};
+//! use reth_network::config::rng_secret_key;
 //! use reth_network::{NetworkConfig, NetworkManager};
 //! use reth_provider::test_utils::NoopProvider;
+//! use reth_primitives::mainnet_nodes;
 //!
 //! // This block provider implementation is used for testing purposes.
 //! let client = NoopProvider::default();
@@ -84,7 +85,7 @@
 //! ```
 //! use reth_provider::test_utils::NoopProvider;
 //! use reth_transaction_pool::TransactionPool;
-//! use reth_discv4::bootnodes::mainnet_nodes;
+//! use reth_primitives::mainnet_nodes;
 //! use reth_network::config::rng_secret_key;
 //! use reth_network::{NetworkConfig, NetworkManager};
 //! async fn launch<Pool: TransactionPool>(pool: Pool) {
diff --git a/crates/net/network/src/manager.rs b/crates/net/network/src/manager.rs
index 0b55604f915..502cd1f32ca 100644
--- a/crates/net/network/src/manager.rs
+++ b/crates/net/network/src/manager.rs
@@ -240,7 +240,7 @@ where
     /// ```
     /// use reth_provider::test_utils::NoopProvider;
     /// use reth_transaction_pool::TransactionPool;
-    /// use reth_discv4::bootnodes::mainnet_nodes;
+    /// use reth_primitives::mainnet_nodes;
     /// use reth_network::config::rng_secret_key;
     /// use reth_network::{NetworkConfig, NetworkManager};
     /// async fn launch<Pool: TransactionPool>(pool: Pool) {
diff --git a/crates/net/network/src/session/mod.rs b/crates/net/network/src/session/mod.rs
index f617c9516a1..03d67f915f5 100644
--- a/crates/net/network/src/session/mod.rs
+++ b/crates/net/network/src/session/mod.rs
@@ -169,7 +169,7 @@ impl SessionManager {
     where
         F: Future<Output = ()> + Send + 'static,
     {
-        self.executor.spawn(async move { f.await }.boxed());
+        self.executor.spawn(f.boxed());
     }
 
     /// Invoked on a received status update.
@@ -209,20 +209,17 @@ impl SessionManager {
         let hello_message = self.hello_message.clone();
         let status = self.status;
         let fork_filter = self.fork_filter.clone();
-        self.spawn(async move {
-            start_pending_incoming_session(
-                disconnect_rx,
-                session_id,
-                metered_stream,
-                pending_events,
-                remote_addr,
-                secret_key,
-                hello_message,
-                status,
-                fork_filter,
-            )
-            .await
-        });
+        self.spawn(start_pending_incoming_session(
+            disconnect_rx,
+            session_id,
+            metered_stream,
+            pending_events,
+            remote_addr,
+            secret_key,
+            hello_message,
+            status,
+            fork_filter,
+        ));
 
         let handle = PendingSessionHandle {
             disconnect_tx: Some(disconnect_tx),
@@ -243,21 +240,18 @@ impl SessionManager {
         let fork_filter = self.fork_filter.clone();
         let status = self.status;
         let band_with_meter = self.bandwidth_meter.clone();
-        self.spawn(async move {
-            start_pending_outbound_session(
-                disconnect_rx,
-                pending_events,
-                session_id,
-                remote_addr,
-                remote_peer_id,
-                secret_key,
-                hello_message,
-                status,
-                fork_filter,
-                band_with_meter,
-            )
-            .await
-        });
+        self.spawn(start_pending_outbound_session(
+            disconnect_rx,
+            pending_events,
+            session_id,
+            remote_addr,
+            remote_peer_id,
+            secret_key,
+            hello_message,
+            status,
+            fork_filter,
+            band_with_meter,
+        ));
 
         let handle = PendingSessionHandle {
             disconnect_tx: Some(disconnect_tx),
diff --git a/crates/net/network/src/test_utils/testnet.rs b/crates/net/network/src/test_utils/testnet.rs
index b31e4bb32e1..bfd2645a47a 100644
--- a/crates/net/network/src/test_utils/testnet.rs
+++ b/crates/net/network/src/test_utils/testnet.rs
@@ -77,7 +77,7 @@ where
         &mut self,
         configs: impl IntoIterator<Item = PeerConfig<C>>,
     ) -> Result<(), NetworkError> {
-        let peers = configs.into_iter().map(|c| async { c.launch().await }).collect::<Vec<_>>();
+        let peers = configs.into_iter().map(|c| c.launch()).collect::<Vec<_>>();
         let peers = futures::future::join_all(peers).await;
         for peer in peers {
             self.peers.push(peer?);
diff --git a/crates/net/network/src/transactions.rs b/crates/net/network/src/transactions.rs
index 3b470781365..109aec0e1a5 100644
--- a/crates/net/network/src/transactions.rs
+++ b/crates/net/network/src/transactions.rs
@@ -19,7 +19,8 @@ use reth_primitives::{
 };
 use reth_rlp::Encodable;
 use reth_transaction_pool::{
-    error::PoolResult, PropagateKind, PropagatedTransactions, TransactionPool,
+    error::PoolResult, PoolTransaction, PropagateKind, PropagatedTransactions, TransactionPool,
+    ValidPoolTransaction,
 };
 use std::{
     collections::{hash_map::Entry, HashMap},
@@ -36,6 +37,9 @@ use tracing::trace;
 /// Cache limit of transactions to keep track of for a single peer.
 const PEER_TRANSACTION_CACHE_LIMIT: usize = 1024 * 10;
 
+/// Soft limit for NewPooledTransactions
+const NEW_POOLED_TRANSACTION_HASHES_SOFT_LIMIT: usize = 4096;
+
 /// The future for inserting a function into the pool
 pub type PoolImportFuture = Pin<Box<dyn Future<Output = PoolResult<TxHash>> + Send + 'static>>;
 
@@ -223,7 +227,7 @@ where
         let max_num_full = (self.peers.len() as f64).sqrt() as usize + 1;
 
         // Note: Assuming ~random~ order due to random state of the peers map hasher
-        for (idx, (peer_id, peer)) in self.peers.iter_mut().enumerate() {
+        for (peer_idx, (peer_id, peer)) in self.peers.iter_mut().enumerate() {
             // filter all transactions unknown to the peer
             let mut hashes = PooledTransactionsHashesBuilder::new(peer.version);
             let mut full_transactions = Vec::new();
@@ -233,20 +237,27 @@ where
                     full_transactions.push(Arc::clone(&tx.transaction));
                 }
             }
-            let hashes = hashes.build();
+            let mut new_pooled_hashes = hashes.build();
 
             if !full_transactions.is_empty() {
-                if idx > max_num_full {
-                    for hash in hashes.iter_hashes().copied() {
+                // determine whether to send full tx objects or hashes.
+                if peer_idx > max_num_full {
+                    // enforce tx soft limit per message for the (unlikely) event the number of
+                    // hashes exceeds it
+                    new_pooled_hashes.truncate(NEW_POOLED_TRANSACTION_HASHES_SOFT_LIMIT);
+
+                    for hash in new_pooled_hashes.iter_hashes().copied() {
                         propagated.0.entry(hash).or_default().push(PropagateKind::Hash(*peer_id));
                     }
                     // send hashes of transactions
-                    self.network.send_transactions_hashes(*peer_id, hashes);
+                    self.network.send_transactions_hashes(*peer_id, new_pooled_hashes);
                 } else {
+                    // TODO ensure max message size
+
                     // send full transactions
                     self.network.send_transactions(*peer_id, full_transactions);
 
-                    for hash in hashes.into_iter_hashes() {
+                    for hash in new_pooled_hashes.into_iter_hashes() {
                         propagated.0.entry(hash).or_default().push(PropagateKind::Full(*peer_id));
                     }
                 }
@@ -337,7 +348,7 @@ where
                 self.peers.remove(&peer_id);
             }
             NetworkEvent::SessionEstablished { peer_id, messages, version, .. } => {
-                // insert a new peer
+                // insert a new peer into the peerset
                 self.peers.insert(
                     peer_id,
                     Peer {
@@ -349,15 +360,26 @@ where
                     },
                 );
 
-                // Send a `NewPooledTransactionHashes` to the peer with _all_ transactions in the
+                // Send a `NewPooledTransactionHashes` to the peer with up to
+                // `NEW_POOLED_TRANSACTION_HASHES_SOFT_LIMIT` transactions in the
                 // pool
                 if !self.network.is_syncing() {
-                    todo!("get access to full tx");
-                    // let msg = NewPooledTransactionHashes66(self.pool.pooled_transactions());
-                    // self.network.send_message(NetworkHandleMessage::SendPooledTransactionHashes {
-                    //     peer_id,
-                    //     msg,
-                    // })
+                    let peer = self.peers.get_mut(&peer_id).expect("is present; qed");
+
+                    let mut msg_builder = PooledTransactionsHashesBuilder::new(version);
+
+                    for pooled_tx in self
+                        .pool
+                        .pooled_transactions()
+                        .into_iter()
+                        .take(NEW_POOLED_TRANSACTION_HASHES_SOFT_LIMIT)
+                    {
+                        peer.transactions.insert(*pooled_tx.hash());
+                        msg_builder.push_pooled(pooled_tx);
+                    }
+
+                    let msg = msg_builder.build();
+                    self.network.send_transactions_hashes(peer_id, msg);
                 }
             }
             // TODO Add remaining events
@@ -409,6 +431,8 @@ where
                         let pool_transaction = <Pool::Transaction as FromRecoveredTransaction>::from_recovered_transaction(tx);
 
                         let pool = self.pool.clone();
+
+                        #[allow(clippy::redundant_async_block)]
                         let import = Box::pin(async move {
                             pool.add_external_transaction(pool_transaction).await
                         });
@@ -517,7 +541,7 @@ where
     }
 }
 
-/// A transaction that's about to be propagated
+/// A transaction that's about to be propagated to multiple peers.
 struct PropagateTransaction {
     tx_type: u8,
     length: usize,
@@ -546,6 +570,18 @@ enum PooledTransactionsHashesBuilder {
 // === impl PooledTransactionsHashesBuilder ===
 
 impl PooledTransactionsHashesBuilder {
+    /// Push a transaction from the pool to the list.
+    fn push_pooled<T: PoolTransaction>(&mut self, pooled_tx: Arc<ValidPoolTransaction<T>>) {
+        match self {
+            PooledTransactionsHashesBuilder::Eth66(msg) => msg.0.push(*pooled_tx.hash()),
+            PooledTransactionsHashesBuilder::Eth68(msg) => {
+                msg.hashes.push(*pooled_tx.hash());
+                msg.sizes.push(pooled_tx.encoded_length);
+                msg.types.push(pooled_tx.transaction.tx_type());
+            }
+        }
+    }
+
     fn push(&mut self, tx: &PropagateTransaction) {
         match self {
             PooledTransactionsHashesBuilder::Eth66(msg) => msg.0.push(tx.hash()),
diff --git a/crates/net/network/tests/it/connect.rs b/crates/net/network/tests/it/connect.rs
index a631908ec28..491fe23c55d 100644
--- a/crates/net/network/tests/it/connect.rs
+++ b/crates/net/network/tests/it/connect.rs
@@ -3,7 +3,7 @@
 use ethers_core::utils::Geth;
 use ethers_providers::{Http, Middleware, Provider};
 use futures::StreamExt;
-use reth_discv4::{bootnodes::mainnet_nodes, Discv4Config};
+use reth_discv4::Discv4Config;
 use reth_eth_wire::DisconnectReason;
 use reth_interfaces::{
     p2p::headers::client::{HeadersClient, HeadersRequest},
@@ -17,7 +17,7 @@ use reth_network::{
     NetworkConfigBuilder, NetworkEvent, NetworkManager, PeersConfig,
 };
 use reth_network_api::{NetworkInfo, Peers, PeersInfo};
-use reth_primitives::{HeadersDirection, NodeRecord, PeerId};
+use reth_primitives::{mainnet_nodes, HeadersDirection, NodeRecord, PeerId};
 use reth_provider::test_utils::NoopProvider;
 use reth_transaction_pool::test_utils::testing_pool;
 use secp256k1::SecretKey;
diff --git a/crates/primitives/Cargo.toml b/crates/primitives/Cargo.toml
index bb5c2f47c80..0ee112dd1d1 100644
--- a/crates/primitives/Cargo.toml
+++ b/crates/primitives/Cargo.toml
@@ -9,19 +9,14 @@ description = "Commonly used types in reth."
 
 [dependencies]
 # reth
-reth-rlp = { path = "../rlp", features = [
-    "std",
-    "derive",
-    "ethereum-types",
-] }
+reth-rlp = { path = "../rlp", features = ["std", "derive", "ethereum-types"] }
 reth-rlp-derive = { path = "../rlp/rlp-derive" }
 reth-codecs = { version = "0.1.0", path = "../storage/codecs" }
 
-revm-primitives = { version="1.0.0", features = ["serde"] }
+revm-primitives = { version = "1.0", features = ["serde"] }
 
 # ethereum
 ethers-core = { git = "https://github.com/gakonst/ethers-rs", default-features = false }
-parity-scale-codec = { version = "3.2.1", features = ["derive", "bytes"] }
 tiny-keccak = { version = "2.0", features = ["keccak"] }
 crunchy = { version = "0.2.2", default-features = false, features = ["limit_256"] }
 
@@ -31,7 +26,7 @@ fixed-hash = { version = "0.8", default-features = false, features = [
 ] }
 
 # crypto
-secp256k1 = { version = "0.24.2", default-features = false, features = [
+secp256k1 = { version = "0.26.0", default-features = false, features = [
     "global-context",
     "alloc",
     "recovery",
@@ -72,16 +67,20 @@ serde_json = "1.0"
 hex-literal = "0.3"
 test-fuzz = "3.0.4"
 rand = "0.8"
-revm-primitives = "1.0.0"
+revm-primitives = { version = "1.0", features = ["arbitrary"] }
 arbitrary = { version = "1.1.7", features = ["derive"] }
 proptest = { version = "1.0" }
 proptest-derive = "0.3"
 
 # necessary so we don't hit a "undeclared 'std'": 
 # https://github.com/paradigmxyz/reth/pull/177#discussion_r1021172198 
-secp256k1 = "0.24.2"
+secp256k1 = "0.26.0"
 criterion = "0.4.0"
-pprof = { version = "0.11", features = ["flamegraph", "frame-pointer", "criterion"] }
+pprof = { version = "0.11", features = [
+    "flamegraph",
+    "frame-pointer",
+    "criterion",
+] }
 
 [features]
 default = []
@@ -92,6 +91,7 @@ arbitrary = [
     "dep:proptest",
     "dep:proptest-derive",
 ]
+test-utils = []
 
 [[bench]]
 name = "recover_ecdsa_crit"
diff --git a/crates/primitives/res/genesis/goerli_op.json b/crates/primitives/res/genesis/goerli_op.json
new file mode 100644
index 00000000000..0ea4638d942
--- /dev/null
+++ b/crates/primitives/res/genesis/goerli_op.json
@@ -0,0 +1,92 @@
+{
+  "nonce": "0x00",
+  "timestamp": "0x00",
+  "extraData": "0x000000000000000000000000000000000000000000000000000000000000000027770a9694e4B4b1E130Ab91Bc327C36855f612E0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+  "difficulty": "0x01",
+  "gasLimit": "15000000",
+  "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "coinbase": "0x0000000000000000000000000000000000000000",
+  "gasUsed": "0x00",
+  "number": "0x00",
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "stateRoot": "0x9e6b478a1cd331a979c39e4bddf42c676bcf5a63382f898dc441fe3fe5eb0837",
+  "alloc": {
+    "0x4200000000000000000000000000000000000000": {
+      "balance": "00",
+      "storage": {},
+      "code": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806382e3702d1461003b578063cafa81dc14610072575b600080fd5b61005e610049366004610112565b60006020819052908152604090205460ff1681565b604051901515815260200160405180910390f35b61008561008036600461015a565b610087565b005b6001600080833360405160200161009f929190610229565b604080518083037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe001815291815281516020928301208352908201929092520160002080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001691151591909117905550565b60006020828403121561012457600080fd5b5035919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006020828403121561016c57600080fd5b813567ffffffffffffffff8082111561018457600080fd5b818401915084601f83011261019857600080fd5b8135818111156101aa576101aa61012b565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f011681019083821181831017156101f0576101f061012b565b8160405282815287602084870101111561020957600080fd5b826020860160208301376000928101602001929092525095945050505050565b6000835160005b8181101561024a5760208187018101518583015201610230565b81811115610259576000828501525b5060609390931b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000016919092019081526014019291505056fea26469706673582212209ffc0b44ce8a27c46cae74a3b3b620a72f10aaea97ed37c15b5d36792abd2aa464736f6c63430008090033"
+    },
+    "0x4200000000000000000000000000000000000002": {
+      "balance": "00",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000000000000000000000000000000000000000000000"
+      },
+      "code": "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"
+    },
+    "0x4200000000000000000000000000000000000007": {
+      "balance": "00",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000004": "0x000000000000000000000000000000000000000000000000000000000000dead",
+        "0x0000000000000000000000000000000000000000000000000000000000000005": "0x0000000000000000000000005086d1eef304eb5284a0f6720f79403b4e9be294",
+        "0x0000000000000000000000000000000000000000000000000000000000000003": "0x00000000000000000000000000000000000000000000000000000000000186a0"
+      },
+      "code": "0x608060405234801561001057600080fd5b50600436106100885760003560e01c8063a71198691161005b578063a71198691461012a578063b1b1b2091461014a578063cbd4ece91461016d578063ecc704281461018057600080fd5b806321d800ec1461008d5780633dbb202b146100c55780636e296e45146100da57806382e3702d14610107575b600080fd5b6100b061009b366004610826565b60006020819052908152604090205460ff1681565b60405190151581526020015b60405180910390f35b6100d86100d3366004610942565b610197565b005b6100e26102e2565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016100bc565b6100b0610115366004610826565b60026020526000908152604090205460ff1681565b6005546100e29073ffffffffffffffffffffffffffffffffffffffff1681565b6100b0610158366004610826565b60016020526000908152604090205460ff1681565b6100d861017b3660046109ad565b61038b565b61018960035481565b6040519081526020016100bc565b60006101a784338560035461078d565b80516020808301919091206000908152600290915260409081902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055517fcafa81dc0000000000000000000000000000000000000000000000000000000081529091507342000000000000000000000000000000000000009063cafa81dc9061023c908490600401610a89565b600060405180830381600087803b15801561025657600080fd5b505af115801561026a573d6000803e3d6000fd5b505050508373ffffffffffffffffffffffffffffffffffffffff167fcb0f7ffd78f9aee47a248fae8db181db6eee833039123e026dcbff529522e52a3385600354866040516102bc9493929190610aa3565b60405180910390a26001600360008282546102d79190610aef565b909155505050505050565b60045460009073ffffffffffffffffffffffffffffffffffffffff1661dead141561036e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f78446f6d61696e4d65737361676553656e646572206973206e6f74207365740060448201526064015b60405180910390fd5b5060045473ffffffffffffffffffffffffffffffffffffffff1690565b60055473ffffffffffffffffffffffffffffffffffffffff167fffffffffffffffffffffffffeeeeffffffffffffffffffffffffffffffffeeef330173ffffffffffffffffffffffffffffffffffffffff161461046a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602760248201527f50726f7669646564206d65737361676520636f756c64206e6f7420626520766560448201527f7269666965642e000000000000000000000000000000000000000000000000006064820152608401610365565b60006104788585858561078d565b8051602080830191909120600081815260019092526040909120549192509060ff1615610527576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f50726f7669646564206d6573736167652068617320616c72656164792062656560448201527f6e2072656365697665642e0000000000000000000000000000000000000000006064820152608401610365565b73ffffffffffffffffffffffffffffffffffffffff8616734200000000000000000000000000000000000000141561059957600090815260016020819052604090912080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016909117905550610787565b600480547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff878116919091179091556040516000918816906105f2908790610b2e565b6000604051808303816000865af19150503d806000811461062f576040519150601f19603f3d011682016040523d82523d6000602084013e610634565b606091505b5050600480547fffffffffffffffffffffffff00000000000000000000000000000000000000001661dead1790559050801515600114156106d557600082815260016020819052604080832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00169092179091555183917f4641df4a962071e12719d8c8c8e5ac7fc4d97b927346a3d7a335b1f7517e133c91a2610701565b60405182907f99d0e048484baa1b1540b1367cb128acd7ab2946d1ed91ec10e3c85e4bf51b8f90600090a25b600083334360405160200161071893929190610b4a565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529181528151602092830120600090815291829052902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055505050505b50505050565b6060848484846040516024016107a69493929190610b9c565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fcbd4ece9000000000000000000000000000000000000000000000000000000001790529050949350505050565b60006020828403121561083857600080fd5b5035919050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461086357600080fd5b919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600082601f8301126108a857600080fd5b813567ffffffffffffffff808211156108c3576108c3610868565b604051601f83017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190828211818310171561090957610909610868565b8160405283815286602085880101111561092257600080fd5b836020870160208301376000602085830101528094505050505092915050565b60008060006060848603121561095757600080fd5b6109608461083f565b9250602084013567ffffffffffffffff81111561097c57600080fd5b61098886828701610897565b925050604084013563ffffffff811681146109a257600080fd5b809150509250925092565b600080600080608085870312156109c357600080fd5b6109cc8561083f565b93506109da6020860161083f565b9250604085013567ffffffffffffffff8111156109f657600080fd5b610a0287828801610897565b949793965093946060013593505050565b60005b83811015610a2e578181015183820152602001610a16565b838111156107875750506000910152565b60008151808452610a57816020860160208601610a13565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b602081526000610a9c6020830184610a3f565b9392505050565b73ffffffffffffffffffffffffffffffffffffffff85168152608060208201526000610ad26080830186610a3f565b905083604083015263ffffffff8316606083015295945050505050565b60008219821115610b29577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b500190565b60008251610b40818460208701610a13565b9190910192915050565b60008451610b5c818460208901610a13565b60609490941b7fffffffffffffffffffffffffffffffffffffffff0000000000000000000000001691909301908152601481019190915260340192915050565b600073ffffffffffffffffffffffffffffffffffffffff808716835280861660208401525060806040830152610bd56080830185610a3f565b90508260608301529594505050505056fea26469706673582212200afb9537c52292543adecf37773b8e4d795c984adf4e80970731e434679b4ec264736f6c63430008090033"
+    },
+    "0x420000000000000000000000000000000000000F": {
+      "balance": "00",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000a693b8f8207ff043f6bbc2e2120bbe4c2251efe9",
+        "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001",
+        "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000001",
+        "0x0000000000000000000000000000000000000000000000000000000000000003": "0x0000000000000000000000000000000000000000000000000000000000000abe",
+        "0x0000000000000000000000000000000000000000000000000000000000000004": "0x000000000000000000000000000000000000000000000000000000000016e360",
+        "0x0000000000000000000000000000000000000000000000000000000000000005": "0x0000000000000000000000000000000000000000000000000000000000000006"
+      },
+      "code": "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"
+    },
+    "0x4200000000000000000000000000000000000010": {
+      "balance": "00",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000001": "0x000000000000000000000000636af16bf2f682dd3109e60102b8e1a089fedaa8",
+        "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000004200000000000000000000000000000000000007"
+      },
+      "code": "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"
+    },
+    "0x4200000000000000000000000000000000000011": {
+      "balance": "00",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000fd1d2e729ae8eee2e146c033bf4400fe75284301"
+      },
+      "code": "0x6080604052600436106100385760003560e01c80633ccfd60b14610044578063d3e5792b1461005b578063d4ff92181461008a57600080fd5b3661003f57005b600080fd5b34801561005057600080fd5b506100596100dc565b005b34801561006757600080fd5b5061007767d02ab486cedc000081565b6040519081526020015b60405180910390f35b34801561009657600080fd5b506000546100b79073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610081565b67d02ab486cedc000047101561019e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152605760248201527f4f564d5f53657175656e6365724665655661756c743a2077697468647261776160448201527f6c20616d6f756e74206d7573742062652067726561746572207468616e206d6960648201527f6e696d756d207769746864726177616c20616d6f756e74000000000000000000608482015260a40160405180910390fd5b600080546040805160208101825283815290517fa3a795480000000000000000000000000000000000000000000000000000000081527342000000000000000000000000000000000000109363a3a79548936102309373deaddeaddeaddeaddeaddeaddeaddeaddead00009373ffffffffffffffffffffffffffffffffffffffff909216924792909190600401610264565b600060405180830381600087803b15801561024a57600080fd5b505af115801561025e573d6000803e3d6000fd5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff808816835260208188168185015286604085015263ffffffff8616606085015260a06080850152845191508160a085015260005b828110156102cb5785810182015185820160c0015281016102af565b828111156102dd57600060c084870101525b5050601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160c001969550505050505056fea2646970667358221220387a6116dde263ea48767352a397053c8cffa776aecb43cded2f25a4a9cfbdc264736f6c63430008090033"
+    },
+    "0x4200000000000000000000000000000000000012": {
+      "balance": "00",
+      "storage": {},
+      "code": "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"
+    },
+    "0x4200000000000000000000000000000000000013": {
+      "balance": "00",
+      "storage": {},
+      "code": "0x4B60005260206000F3"
+    },
+    "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000": {
+      "balance": "00",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000006": "0x0000000000000000000000004200000000000000000000000000000000000010",
+        "0x0000000000000000000000000000000000000000000000000000000000000005": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000000000000000000000000003": "0x457468657200000000000000000000000000000000000000000000000000000a",
+        "0x0000000000000000000000000000000000000000000000000000000000000004": "0x4554480000000000000000000000000000000000000000000000000000000006"
+      },
+      "code": "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"
+    },
+    "0x4200000000000000000000000000000000000006": {
+      "balance": "00",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000000": "0x577261707065642045746865720000000000000000000000000000000000001a",
+        "0x0000000000000000000000000000000000000000000000000000000000000001": "0x5745544800000000000000000000000000000000000000000000000000000008",
+        "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000012"
+      },
+      "code": "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"
+    }
+  }
+}
diff --git a/crates/primitives/src/account.rs b/crates/primitives/src/account.rs
index eb77388a3f0..b91796129c2 100644
--- a/crates/primitives/src/account.rs
+++ b/crates/primitives/src/account.rs
@@ -1,5 +1,10 @@
 use crate::{H256, KECCAK_EMPTY, U256};
+use bytes::{Buf, BufMut, Bytes};
+use fixed_hash::byteorder::{BigEndian, ReadBytesExt};
 use reth_codecs::{main_codec, Compact};
+use revm_primitives::{Bytecode as RevmBytecode, BytecodeState, JumpMap};
+use serde::{Deserialize, Serialize};
+use std::ops::Deref;
 
 /// An Ethereum account.
 #[main_codec]
@@ -29,12 +34,108 @@ impl Account {
 
         self.nonce == 0 && self.balance == U256::ZERO && is_bytecode_empty
     }
+
+    /// Returns an account bytecode's hash.
+    /// In case of no bytecode, returns [`KECCAK_EMPTY`].
+    pub fn get_bytecode_hash(&self) -> H256 {
+        match self.bytecode_hash {
+            Some(hash) => hash,
+            None => KECCAK_EMPTY,
+        }
+    }
+}
+
+/// Bytecode for an account.
+///
+/// A wrapper around [`revm::primitives::Bytecode`][RevmBytecode] with encoding/decoding support.
+///
+/// Note: Upon decoding bytecode from the database, you *should* set the code hash using
+/// [`Self::with_code_hash`].
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Bytecode(pub RevmBytecode);
+
+impl Bytecode {
+    /// Create new bytecode from raw bytes.
+    ///
+    /// No analysis will be performed.
+    pub fn new_raw(bytes: Bytes) -> Self {
+        Self(RevmBytecode::new_raw(bytes))
+    }
+
+    /// Set the hash of the inner bytecode.
+    pub fn with_code_hash(mut self, code_hash: H256) -> Self {
+        self.0.hash = code_hash;
+        self
+    }
+}
+
+impl Deref for Bytecode {
+    type Target = RevmBytecode;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Compact for Bytecode {
+    fn to_compact(self, buf: &mut impl BufMut) -> usize {
+        buf.put_u32(self.0.bytecode.len() as u32);
+        buf.put_slice(self.0.bytecode.as_ref());
+        let len = match self.0.state() {
+            BytecodeState::Raw => {
+                buf.put_u8(0);
+                1
+            }
+            BytecodeState::Checked { len } => {
+                buf.put_u8(1);
+                buf.put_u64(*len as u64);
+                9
+            }
+            BytecodeState::Analysed { len, jump_map } => {
+                buf.put_u8(2);
+                buf.put_u64(*len as u64);
+                let map = jump_map.as_slice();
+                buf.put_slice(map);
+                9 + map.len()
+            }
+        };
+        len + self.0.bytecode.len() + 4
+    }
+
+    fn from_compact(mut buf: &[u8], _: usize) -> (Self, &[u8])
+    where
+        Self: Sized,
+    {
+        let len = buf.read_u32::<BigEndian>().expect("could not read bytecode length");
+        let bytes = buf.copy_to_bytes(len as usize);
+        let variant = buf.read_u8().expect("could not read bytecode variant");
+        let decoded = match variant {
+            0 => Bytecode(RevmBytecode::new_raw(bytes)),
+            1 => Bytecode(unsafe {
+                RevmBytecode::new_checked(
+                    bytes,
+                    buf.read_u64::<BigEndian>().unwrap() as usize,
+                    None,
+                )
+            }),
+            2 => Bytecode(RevmBytecode {
+                bytecode: bytes,
+                hash: KECCAK_EMPTY,
+                state: BytecodeState::Analysed {
+                    len: buf.read_u64::<BigEndian>().unwrap() as usize,
+                    jump_map: JumpMap::from_slice(buf),
+                },
+            }),
+            _ => unreachable!(),
+        };
+        (decoded, &[])
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{Account, U256};
-    use reth_codecs::Compact;
+    use super::*;
+    use hex_literal::hex;
 
     #[test]
     fn test_account() {
@@ -51,4 +152,26 @@ mod tests {
         let len = acc.to_compact(&mut buf);
         assert_eq!(len, 4);
     }
+
+    #[test]
+    fn test_bytecode() {
+        let mut buf = vec![];
+        let mut bytecode = Bytecode(RevmBytecode::new_raw(Bytes::default()));
+        let len = bytecode.clone().to_compact(&mut buf);
+        assert_eq!(len, 5);
+
+        let mut buf = vec![];
+        bytecode.0.bytecode = Bytes::from(hex!("ffff").as_ref());
+        let len = bytecode.clone().to_compact(&mut buf);
+        assert_eq!(len, 7);
+
+        let mut buf = vec![];
+        bytecode.0.state = BytecodeState::Analysed { len: 2, jump_map: JumpMap::from_slice(&[0]) };
+        let len = bytecode.clone().to_compact(&mut buf);
+        assert_eq!(len, 16);
+
+        let (decoded, remainder) = Bytecode::from_compact(&buf, len);
+        assert_eq!(decoded, bytecode);
+        assert!(remainder.is_empty());
+    }
 }
diff --git a/crates/primitives/src/block.rs b/crates/primitives/src/block.rs
index 13b8b9d548a..2d9b73f6d37 100644
--- a/crates/primitives/src/block.rs
+++ b/crates/primitives/src/block.rs
@@ -1,4 +1,4 @@
-use crate::{Header, SealedHeader, TransactionSigned, Withdrawal, H256};
+use crate::{Address, Header, SealedHeader, TransactionSigned, Withdrawal, H256};
 use ethers_core::types::BlockNumber;
 use reth_codecs::derive_arbitrary;
 use reth_rlp::{Decodable, DecodeError, Encodable, RlpDecodable, RlpEncodable};
@@ -12,10 +12,10 @@ use std::{fmt, fmt::Formatter, ops::Deref, str::FromStr};
 /// Ethereum full block.
 ///
 /// Withdrawals can be optionally included at the end of the RLP encoded message.
-#[derive_arbitrary(rlp, 25)]
 #[derive(
     Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, RlpEncodable, RlpDecodable,
 )]
+#[derive_arbitrary(rlp, 25)]
 #[rlp(trailing)]
 pub struct Block {
     /// Block header.
@@ -28,6 +28,18 @@ pub struct Block {
     pub withdrawals: Option<Vec<Withdrawal>>,
 }
 
+impl Block {
+    /// Create SealedBLock that will create all header hashes.
+    pub fn seal_slow(self) -> SealedBlock {
+        SealedBlock {
+            header: self.header.seal_slow(),
+            body: self.body,
+            ommers: self.ommers.into_iter().map(|o| o.seal_slow()).collect(),
+            withdrawals: self.withdrawals,
+        }
+    }
+}
+
 impl Deref for Block {
     type Target = Header;
     fn deref(&self) -> &Self::Target {
@@ -65,6 +77,17 @@ impl SealedBlock {
         (self.header, self.body, self.ommers)
     }
 
+    /// Expensive operation that recovers transaction signer. See [SealedBlockWithSenders].
+    pub fn senders(&self) -> Option<Vec<Address>> {
+        self.body.iter().map(|tx| tx.recover_signer()).collect::<Option<Vec<Address>>>()
+    }
+
+    /// Seal sealed block with recovered transaction senders.
+    pub fn seal_with_senders(self) -> Option<SealedBlockWithSenders> {
+        let senders = self.senders()?;
+        Some(SealedBlockWithSenders { block: self, senders })
+    }
+
     /// Unseal the block
     pub fn unseal(self) -> Block {
         Block {
@@ -83,6 +106,48 @@ impl Deref for SealedBlock {
     }
 }
 
+#[cfg(any(test, feature = "test-utils"))]
+impl std::ops::DerefMut for SealedBlock {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.header
+    }
+}
+
+/// Sealed block with senders recovered from transactions.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct SealedBlockWithSenders {
+    /// Sealed block
+    pub block: SealedBlock,
+    /// List of senders that match trasanctions from block.
+    pub senders: Vec<Address>,
+}
+
+impl SealedBlockWithSenders {
+    /// New sealed block with sender. Return none if len of tx and senders does not match
+    pub fn new(block: SealedBlock, senders: Vec<Address>) -> Option<Self> {
+        (!block.body.len() != senders.len()).then_some(Self { block, senders })
+    }
+
+    /// Split Structure to its components
+    pub fn into_components(self) -> (SealedBlock, Vec<Address>) {
+        (self.block, self.senders)
+    }
+}
+
+impl Deref for SealedBlockWithSenders {
+    type Target = SealedBlock;
+    fn deref(&self) -> &Self::Target {
+        &self.block
+    }
+}
+
+#[cfg(any(test, feature = "test-utils"))]
+impl std::ops::DerefMut for SealedBlockWithSenders {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.block
+    }
+}
+
 /// Either a block hash _or_ a block number
 #[derive_arbitrary(rlp)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -176,6 +241,16 @@ impl BlockId {
             BlockId::Number(_) => None,
         }
     }
+
+    /// Returns true if this is [BlockNumberOrTag::Latest]
+    pub fn is_latest(&self) -> bool {
+        matches!(self, BlockId::Number(BlockNumberOrTag::Latest))
+    }
+
+    /// Returns true if this is [BlockNumberOrTag::Pending]
+    pub fn is_pending(&self) -> bool {
+        matches!(self, BlockId::Number(BlockNumberOrTag::Pending))
+    }
 }
 
 impl From<u64> for BlockId {
diff --git a/crates/primitives/src/chain/mod.rs b/crates/primitives/src/chain/mod.rs
index d03aff38aa1..abce83794c9 100644
--- a/crates/primitives/src/chain/mod.rs
+++ b/crates/primitives/src/chain/mod.rs
@@ -1,4 +1,7 @@
-use crate::U256;
+use crate::{
+    net::{goerli_nodes, mainnet_nodes, sepolia_nodes},
+    NodeRecord, U256,
+};
 use ethers_core::types::U64;
 use reth_codecs::add_arbitrary_tests;
 use reth_rlp::{Decodable, Encodable};
@@ -11,6 +14,9 @@ pub use spec::{
     AllGenesisFormats, ChainSpec, ChainSpecBuilder, ForkCondition, GOERLI, MAINNET, SEPOLIA,
 };
 
+#[cfg(feature = "optimism")]
+pub use spec::OP_GOERLI;
+
 // The chain info module.
 mod info;
 pub use info::ChainInfo;
@@ -41,6 +47,18 @@ impl Chain {
         Chain::Named(ethers_core::types::Chain::Sepolia)
     }
 
+    /// Returns the optimism goerli chain.
+    #[cfg(feature = "optimism")]
+    pub const fn optimism_goerli() -> Self {
+        Chain::Named(ethers_core::types::Chain::OptimismGoerli)
+    }
+
+    /// Returns the optimism mainnet chain.
+    #[cfg(feature = "optimism")]
+    pub const fn optimism_mainnet() -> Self {
+        Chain::Named(ethers_core::types::Chain::Optimism)
+    }
+
     /// The id of the chain
     pub fn id(&self) -> u64 {
         match self {
@@ -72,6 +90,17 @@ impl Chain {
         }
         None
     }
+
+    /// Returns bootnodes for the given chain.
+    pub fn bootnodes(self) -> Option<Vec<NodeRecord>> {
+        use ethers_core::types::Chain::*;
+        match self.try_into().ok()? {
+            Mainnet => Some(mainnet_nodes()),
+            Goerli => Some(goerli_nodes()),
+            Sepolia => Some(sepolia_nodes()),
+            _ => None,
+        }
+    }
 }
 
 impl fmt::Display for Chain {
@@ -154,18 +183,18 @@ impl FromStr for Chain {
 }
 
 impl Encodable for Chain {
-    fn length(&self) -> usize {
-        match self {
-            Self::Named(chain) => u64::from(*chain).length(),
-            Self::Id(id) => id.length(),
-        }
-    }
     fn encode(&self, out: &mut dyn reth_rlp::BufMut) {
         match self {
             Self::Named(chain) => u64::from(*chain).encode(out),
             Self::Id(id) => id.encode(out),
         }
     }
+    fn length(&self) -> usize {
+        match self {
+            Self::Named(chain) => u64::from(*chain).length(),
+            Self::Id(id) => id.length(),
+        }
+    }
 }
 
 impl Decodable for Chain {
diff --git a/crates/primitives/src/chain/spec.rs b/crates/primitives/src/chain/spec.rs
index e9798f78f06..0d250b6ef86 100644
--- a/crates/primitives/src/chain/spec.rs
+++ b/crates/primitives/src/chain/spec.rs
@@ -1,7 +1,10 @@
 use crate::{
-    constants::EIP1559_INITIAL_BASE_FEE, forkid::ForkFilterKey, header::Head,
-    proofs::genesis_state_root, BlockNumber, Chain, ForkFilter, ForkHash, ForkId, Genesis,
-    GenesisAccount, Hardfork, Header, H160, H256, U256,
+    constants::{EIP1559_INITIAL_BASE_FEE, EMPTY_WITHDRAWALS},
+    forkid::ForkFilterKey,
+    header::Head,
+    proofs::genesis_state_root,
+    BlockNumber, Chain, ForkFilter, ForkHash, ForkId, Genesis, GenesisAccount, Hardfork, Header,
+    H160, H256, U256,
 };
 use ethers_core::utils::Genesis as EthersGenesis;
 use hex_literal::hex;
@@ -39,6 +42,7 @@ pub static MAINNET: Lazy<ChainSpec> = Lazy::new(|| ChainSpec {
                 total_difficulty: U256::from(58_750_000_000_000_000_000_000_u128),
             },
         ),
+        (Hardfork::Shanghai, ForkCondition::Timestamp(1681338455)),
     ]),
     #[cfg(feature = "optimism")]
     optimism: None,
@@ -100,6 +104,30 @@ pub static SEPOLIA: Lazy<ChainSpec> = Lazy::new(|| ChainSpec {
     optimism: None,
 });
 
+/// The Optimism Goerli spec
+#[cfg(feature = "optimism")]
+pub static OP_GOERLI: Lazy<ChainSpec> = Lazy::new(|| ChainSpec {
+    chain: Chain::optimism_goerli(),
+    genesis: serde_json::from_str(include_str!("../../res/genesis/goerli_op.json"))
+        .expect("Can't deserialize Optimism Goerli genesis json"),
+    genesis_hash: Some(H256(hex!(
+        "c1fc15cd51159b1f1e5cbc4b82e85c1447ddfa33c52cf1d98d14fba0d6354be1"
+    ))),
+    hardforks: BTreeMap::from([
+        (Hardfork::Byzantium, ForkCondition::Block(0)),
+        (Hardfork::Constantinople, ForkCondition::Block(0)),
+        (Hardfork::Petersburg, ForkCondition::Block(0)),
+        (Hardfork::Istanbul, ForkCondition::Block(0)),
+        (Hardfork::MuirGlacier, ForkCondition::Block(0)),
+        (Hardfork::Berlin, ForkCondition::Block(0)),
+        (Hardfork::London, ForkCondition::Block(4061224)),
+        (Hardfork::ArrowGlacier, ForkCondition::Block(4061224)),
+        (Hardfork::GrayGlacier, ForkCondition::Block(4061224)),
+        (Hardfork::Bedrock, ForkCondition::Block(4061224)),
+    ]),
+    optimism: Some(OptimismConfig { eip_1559_elasticity: 10, eip_1559_denominator: 50 }),
+});
+
 /// An Ethereum chain specification.
 ///
 /// A chain specification describes:
@@ -156,11 +184,14 @@ impl ChainSpec {
     /// Get the header for the genesis block.
     pub fn genesis_header(&self) -> Header {
         // If London is activated at genesis, we set the initial base fee as per EIP-1559.
-        let base_fee_per_gas = if self.fork(Hardfork::London).active_at_block(0) {
-            Some(EIP1559_INITIAL_BASE_FEE)
-        } else {
-            None
-        };
+        let base_fee_per_gas =
+            (self.fork(Hardfork::London).active_at_block(0)).then_some(EIP1559_INITIAL_BASE_FEE);
+
+        // If shanghai is activated, initialize the header with an empty withdrawals hash, and
+        // empty withdrawals list.
+        let withdrawals_root =
+            (self.fork(Hardfork::Shanghai).active_at_timestamp(self.genesis.timestamp))
+                .then_some(EMPTY_WITHDRAWALS);
 
         Header {
             gas_limit: self.genesis.gas_limit,
@@ -172,6 +203,7 @@ impl ChainSpec {
             mix_hash: self.genesis.mix_hash,
             beneficiary: self.genesis.coinbase,
             base_fee_per_gas,
+            withdrawals_root,
             ..Default::default()
         }
     }
@@ -320,7 +352,7 @@ impl From<EthersGenesis> for ChainSpec {
 }
 
 /// A helper type for compatibility with geth's config
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum AllGenesisFormats {
     /// The geth genesis format
@@ -627,13 +659,18 @@ impl ForkCondition {
 
 #[cfg(test)]
 mod tests {
-    use revm_primitives::U256;
+    use bytes::BytesMut;
+    use ethers_core::types as EtherType;
+    use reth_rlp::Encodable;
 
     use crate::{
-        Chain, ChainSpec, ChainSpecBuilder, ForkCondition, ForkHash, ForkId, Genesis, Hardfork,
-        Head, GOERLI, MAINNET, SEPOLIA,
+        AllGenesisFormats, Chain, ChainSpec, ChainSpecBuilder, ForkCondition, ForkHash, ForkId,
+        Genesis, Hardfork, Head, GOERLI, H256, MAINNET, SEPOLIA, U256,
     };
 
+    #[cfg(feature = "optimism")]
+    use crate::OP_GOERLI;
+
     fn test_fork_ids(spec: &ChainSpec, cases: &[(Head, ForkId)]) {
         for (block, expected_id) in cases {
             let computed_id = spec.fork_id(block);
@@ -753,7 +790,17 @@ mod tests {
                 ),
                 (
                     Head { number: 15050000, ..Default::default() },
-                    ForkId { hash: ForkHash([0xf0, 0xaf, 0xd0, 0xe3]), next: 0 },
+                    ForkId { hash: ForkHash([0xf0, 0xaf, 0xd0, 0xe3]), next: 1681338455 },
+                ),
+                // First Shanghai block
+                (
+                    Head { number: 20000000, timestamp: 1681338455, ..Default::default() },
+                    ForkId { hash: ForkHash([0xdc, 0xe9, 0x6c, 0x2d]), next: 0 },
+                ),
+                // Future Shanghai block
+                (
+                    Head { number: 20000000, timestamp: 2000000000, ..Default::default() },
+                    ForkId { hash: ForkHash([0xdc, 0xe9, 0x6c, 0x2d]), next: 0 },
                 ),
             ],
         );
@@ -809,6 +856,25 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "optimism")]
+    #[test]
+    fn optimism_goerli_forkids() {
+        // TODO
+        test_fork_ids(
+            &OP_GOERLI,
+            &[
+                (
+                    Head { number: 0, ..Default::default() },
+                    ForkId { hash: ForkHash([0x00, 0x00, 0x00, 0x00]), next: 4061224 },
+                ),
+                (
+                    Head { number: 4061224, ..Default::default() },
+                    ForkId { hash: ForkHash([0x00, 0x00, 0x00, 0x00]), next: 0 },
+                ),
+            ],
+        );
+    }
+
     /// Checks that time-based forks work
     ///
     /// This is based off of the test vectors here: https://github.com/ethereum/go-ethereum/blob/5c8cc10d1e05c23ff1108022f4150749e73c0ca1/core/forkid/forkid_test.go#L155-L188
@@ -1071,5 +1137,119 @@ mod tests {
             chainspec.hardforks.get(&Hardfork::Shanghai).unwrap(),
             &ForkCondition::Timestamp(0)
         );
+
+        // alloc key -> expected rlp mapping
+        let key_rlp = vec![
+            (hex_literal::hex!("658bdf435d810c91414ec09147daa6db62406379"), "f84d8089487a9a304539440000a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a0c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"),
+            (hex_literal::hex!("aa00000000000000000000000000000000000000"), "f8440101a08afc95b7d18a226944b9c2070b6bda1c3a36afcc3730429d47579c94b9fe5850a0ce92c756baff35fa740c3557c1a971fd24d2d35b7c8e067880d50cd86bb0bc99"),
+            (hex_literal::hex!("bb00000000000000000000000000000000000000"), "f8440102a08afc95b7d18a226944b9c2070b6bda1c3a36afcc3730429d47579c94b9fe5850a0e25a53cbb501cec2976b393719c63d832423dd70a458731a0b64e4847bbca7d2"),
+        ];
+
+        for (key, expected_rlp) in key_rlp {
+            let account = chainspec.genesis.alloc.get(&key.into()).expect("account should exist");
+            let mut account_rlp = BytesMut::new();
+            account.encode(&mut account_rlp);
+            assert_eq!(hex::encode(account_rlp), expected_rlp)
+        }
+
+        assert_eq!(chainspec.genesis_hash, None);
+        let expected_state_root: H256 =
+            hex_literal::hex!("078dc6061b1d8eaa8493384b59c9c65ceb917201221d08b80c4de6770b6ec7e7")
+                .into();
+        assert_eq!(chainspec.genesis_header().state_root, expected_state_root);
+
+        let expected_withdrawals_hash: H256 =
+            hex_literal::hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
+                .into();
+        assert_eq!(chainspec.genesis_header().withdrawals_root, Some(expected_withdrawals_hash));
+
+        let expected_hash: H256 =
+            hex_literal::hex!("1fc027d65f820d3eef441ebeec139ebe09e471cf98516dce7b5643ccb27f418c")
+                .into();
+        let hash = chainspec.genesis_hash();
+        assert_eq!(hash, expected_hash);
+    }
+
+    #[test]
+    fn hive_geth_json() {
+        let hive_json = r#"
+        {
+            "nonce": "0x0000000000000042",
+            "difficulty": "0x2123456",
+            "mixHash": "0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234",
+            "coinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            "timestamp": "0x123456",
+            "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "extraData": "0xfafbfcfd",
+            "gasLimit": "0x2fefd8",
+            "alloc": {
+                "dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6": {
+                    "balance": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                },
+                "e6716f9544a56c530d868e4bfbacb172315bdead": {
+                    "balance": "0x11",
+                    "code": "0x12"
+                },
+                "b9c015918bdaba24b4ff057a92a3873d6eb201be": {
+                    "balance": "0x21",
+                    "storage": {
+                        "0x0000000000000000000000000000000000000000000000000000000000000001": "0x22"
+                    }
+                },
+                "1a26338f0d905e295fccb71fa9ea849ffa12aaf4": {
+                    "balance": "0x31",
+                    "nonce": "0x32"
+                },
+                "0000000000000000000000000000000000000001": {
+                    "balance": "0x41"
+                },
+                "0000000000000000000000000000000000000002": {
+                    "balance": "0x51"
+                },
+                "0000000000000000000000000000000000000003": {
+                    "balance": "0x61"
+                },
+                "0000000000000000000000000000000000000004": {
+                    "balance": "0x71"
+                }
+            },
+            "config": {
+                "ethash": {},
+                "chainId": 10,
+                "homesteadBlock": 0,
+                "eip150Block": 0,
+                "eip155Block": 0,
+                "eip158Block": 0,
+                "byzantiumBlock": 0,
+                "constantinopleBlock": 0,
+                "petersburgBlock": 0,
+                "istanbulBlock": 0
+            }
+        }
+        "#;
+        let genesis = serde_json::from_str::<AllGenesisFormats>(hive_json).unwrap();
+        let chainspec: ChainSpec = genesis.into();
+        assert_eq!(chainspec.genesis_hash, None);
+        assert_eq!(Chain::Named(EtherType::Chain::Optimism), chainspec.chain);
+        let expected_state_root: H256 =
+            hex_literal::hex!("9a6049ac535e3dc7436c189eaa81c73f35abd7f282ab67c32944ff0301d63360")
+                .into();
+        assert_eq!(chainspec.genesis_header().state_root, expected_state_root);
+        let hard_forks = vec![
+            Hardfork::Byzantium,
+            Hardfork::Homestead,
+            Hardfork::Istanbul,
+            Hardfork::Petersburg,
+            Hardfork::Constantinople,
+        ];
+        for ref fork in hard_forks {
+            assert_eq!(chainspec.hardforks.get(fork).unwrap(), &ForkCondition::Block(0));
+        }
+
+        let expected_hash: H256 =
+            hex_literal::hex!("5ae31c6522bd5856129f66be3d582b842e4e9faaa87f21cce547128339a9db3c")
+                .into();
+        let hash = chainspec.genesis_header().hash_slow();
+        assert_eq!(hash, expected_hash);
     }
 }
diff --git a/crates/primitives/src/checkpoints.rs b/crates/primitives/src/checkpoints.rs
new file mode 100644
index 00000000000..62a90bfa0a0
--- /dev/null
+++ b/crates/primitives/src/checkpoints.rs
@@ -0,0 +1,42 @@
+use crate::{Address, H256};
+use reth_codecs::{main_codec, Compact};
+
+/// Saves the progress of MerkleStage
+#[main_codec]
+#[derive(Default, Debug, Copy, Clone, PartialEq)]
+pub struct ProofCheckpoint {
+    /// The next hashed account to insert into the trie.
+    pub hashed_address: Option<H256>,
+    /// The next storage entry to insert into the trie.
+    pub storage_key: Option<H256>,
+    /// Current intermediate root for `AccountsTrie`.
+    pub account_root: Option<H256>,
+    /// Current intermediate storage root from an account.
+    pub storage_root: Option<H256>,
+}
+
+/// Saves the progress of AccountHashing
+#[main_codec]
+#[derive(Default, Debug, Copy, Clone, PartialEq)]
+pub struct AccountHashingCheckpoint {
+    /// The next account to start hashing from
+    pub address: Option<Address>,
+    /// Start transition id
+    pub from: u64,
+    /// Last transition id
+    pub to: u64,
+}
+
+/// Saves the progress of StorageHashing
+#[main_codec]
+#[derive(Default, Debug, Copy, Clone, PartialEq)]
+pub struct StorageHashingCheckpoint {
+    /// The next account to start hashing from
+    pub address: Option<Address>,
+    /// The next storage slot to start hashing from
+    pub storage: Option<H256>,
+    /// Start transition id
+    pub from: u64,
+    /// Last transition id
+    pub to: u64,
+}
diff --git a/crates/primitives/src/constants.rs b/crates/primitives/src/constants.rs
index 4739074f827..adad8ccc3bb 100644
--- a/crates/primitives/src/constants.rs
+++ b/crates/primitives/src/constants.rs
@@ -3,6 +3,9 @@
 use crate::H256;
 use hex_literal::hex;
 
+/// The first four bytes of the call data for a function call specifies the function to be called.
+pub const SELECTOR_LEN: usize = 4;
+
 /// Initial base fee as defined in [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)
 pub const EIP1559_INITIAL_BASE_FEE: u64 = 1_000_000_000;
 
@@ -27,6 +30,11 @@ pub const GOERLI_GENESIS: H256 =
 pub const SEPOLIA_GENESIS: H256 =
     H256(hex!("25a5cc106eea7138acab33231d7160d69cb777ee0c2c553fcddf5138993e6dd9"));
 
+/// Optimism goerli genesis hash.
+#[cfg(feature = "optimism")]
+pub const GOERLI_OP_GENESIS: H256 =
+    H256(hex!("c1fc15cd51159b1f1e5cbc4b82e85c1447ddfa33c52cf1d98d14fba0d6354be1"));
+
 /// Keccak256 over empty array.
 pub const KECCAK_EMPTY: H256 =
     H256(hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"));
@@ -34,3 +42,7 @@ pub const KECCAK_EMPTY: H256 =
 /// Ommer root of empty list.
 pub const EMPTY_OMMER_ROOT: H256 =
     H256(hex!("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"));
+
+/// Withdrawals root of empty withdrawals set.
+pub const EMPTY_WITHDRAWALS: H256 =
+    H256(hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"));
diff --git a/crates/primitives/src/contract.rs b/crates/primitives/src/contract.rs
new file mode 100644
index 00000000000..43ce75b53f2
--- /dev/null
+++ b/crates/primitives/src/contract.rs
@@ -0,0 +1,104 @@
+//! Helpers for deriving contract addresses
+
+// re-export from revm
+use crate::{keccak256, Address, U256};
+pub use revm_primitives::utilities::{create2_address, create_address};
+
+/// Returns the CREATE2 address of a smart contract as specified in
+/// [EIP1014](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1014.md)
+///
+/// keccak256( 0xff ++ senderAddress ++ salt ++ keccak256(init_code))[12..]
+///
+/// where `salt` is always 32 bytes (a stack item).
+pub fn create2_address_from_code(
+    from: Address,
+    init_code: impl AsRef<[u8]>,
+    salt: U256,
+) -> Address {
+    let init_code_hash = keccak256(init_code);
+    create2_address(from, init_code_hash, salt)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn contract_address() {
+        // http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed
+        let from = "6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0".parse::<Address>().unwrap();
+        for (nonce, expected) in [
+            "cd234a471b72ba2f1ccf0a70fcaba648a5eecd8d",
+            "343c43a37d37dff08ae8c4a11544c718abb4fcf8",
+            "f778b86fa74e846c4f0a1fbd1335fe81c00a0c91",
+            "fffd933a0bc612844eaf0c6fe3e5b8e9b6c1d19c",
+        ]
+        .iter()
+        .enumerate()
+        {
+            let address = create_address(from, nonce as u64);
+            assert_eq!(address, expected.parse::<Address>().unwrap());
+        }
+    }
+
+    #[test]
+    // Test vectors from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1014.md#examples
+    fn test_create2_address() {
+        for (from, salt, init_code, expected) in &[
+            (
+                "0000000000000000000000000000000000000000",
+                "0000000000000000000000000000000000000000000000000000000000000000",
+                "00",
+                "4D1A2e2bB4F88F0250f26Ffff098B0b30B26BF38",
+            ),
+            (
+                "deadbeef00000000000000000000000000000000",
+                "0000000000000000000000000000000000000000000000000000000000000000",
+                "00",
+                "B928f69Bb1D91Cd65274e3c79d8986362984fDA3",
+            ),
+            (
+                "deadbeef00000000000000000000000000000000",
+                "000000000000000000000000feed000000000000000000000000000000000000",
+                "00",
+                "D04116cDd17beBE565EB2422F2497E06cC1C9833",
+            ),
+            (
+                "0000000000000000000000000000000000000000",
+                "0000000000000000000000000000000000000000000000000000000000000000",
+                "deadbeef",
+                "70f2b2914A2a4b783FaEFb75f459A580616Fcb5e",
+            ),
+            (
+                "00000000000000000000000000000000deadbeef",
+                "00000000000000000000000000000000000000000000000000000000cafebabe",
+                "deadbeef",
+                "60f3f640a8508fC6a86d45DF051962668E1e8AC7",
+            ),
+            (
+                "00000000000000000000000000000000deadbeef",
+                "00000000000000000000000000000000000000000000000000000000cafebabe",
+                "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+                "1d8bfDC5D46DC4f61D6b6115972536eBE6A8854C",
+            ),
+            (
+                "0000000000000000000000000000000000000000",
+                "0000000000000000000000000000000000000000000000000000000000000000",
+                "",
+                "E33C0C7F7df4809055C3ebA6c09CFe4BaF1BD9e0",
+            ),
+        ] {
+            // create2_address()
+            let from = from.parse::<Address>().unwrap();
+            let salt = hex::decode(salt).unwrap();
+            let salt = U256::try_from_be_slice(&salt).unwrap();
+            let init_code = hex::decode(init_code).unwrap();
+            let expected = expected.parse::<Address>().unwrap();
+            assert_eq!(expected, create2_address_from_code(from, init_code.clone(),salt ));
+
+            // get_create2_address_from_hash()
+            let init_code_hash = keccak256(init_code);
+            assert_eq!(expected, create2_address(from, init_code_hash,  salt))
+        }
+    }
+}
diff --git a/crates/primitives/src/genesis.rs b/crates/primitives/src/genesis.rs
index 56d6e1dddc4..c9a3f9abc41 100644
--- a/crates/primitives/src/genesis.rs
+++ b/crates/primitives/src/genesis.rs
@@ -6,14 +6,13 @@ use crate::{
     utils::serde_helpers::deserialize_stringified_u64,
     Address, Bytes, H256, KECCAK_EMPTY, U256,
 };
-use bytes::BytesMut;
 use ethers_core::utils::GenesisAccount as EthersGenesisAccount;
-use reth_rlp::{length_of_length, Encodable, Header as RlpHeader};
+use reth_rlp::{encode_fixed_size, length_of_length, Encodable, Header as RlpHeader};
 use serde::{Deserialize, Serialize};
 use triehash::sec_trie_root;
 
 /// The genesis block specification.
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase", default)]
 pub struct Genesis {
     /// The genesis header nonce.
@@ -37,6 +36,60 @@ pub struct Genesis {
     pub alloc: HashMap<Address, GenesisAccount>,
 }
 
+impl Genesis {
+    /// Set the nonce.
+    pub fn with_nonce(mut self, nonce: u64) -> Self {
+        self.nonce = nonce;
+        self
+    }
+
+    /// Set the timestamp.
+    pub fn with_timestamp(mut self, timestamp: u64) -> Self {
+        self.timestamp = timestamp;
+        self
+    }
+
+    /// Set the extra data.
+    pub fn with_extra_data(mut self, extra_data: Bytes) -> Self {
+        self.extra_data = extra_data;
+        self
+    }
+
+    /// Set the gas limit.
+    pub fn with_gas_limit(mut self, gas_limit: u64) -> Self {
+        self.gas_limit = gas_limit;
+        self
+    }
+
+    /// Set the difficulty.
+    pub fn with_difficulty(mut self, difficulty: U256) -> Self {
+        self.difficulty = difficulty;
+        self
+    }
+
+    /// Set the mix hash of the header.
+    pub fn with_mix_hash(mut self, mix_hash: H256) -> Self {
+        self.mix_hash = mix_hash;
+        self
+    }
+
+    /// Set the coinbase address.
+    pub fn with_coinbase(mut self, address: Address) -> Self {
+        self.coinbase = address;
+        self
+    }
+
+    /// Add accounts to the genesis block. If the address is already present,
+    /// the account is updated.
+    pub fn extend_accounts(
+        mut self,
+        accounts: impl IntoIterator<Item = (Address, GenesisAccount)>,
+    ) -> Self {
+        self.alloc.extend(accounts);
+        self
+    }
+}
+
 /// An account in the state of the genesis block.
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct GenesisAccount {
@@ -62,18 +115,37 @@ impl GenesisAccount {
         // rather than rlp-encoding the storage, we just return the length of a single hash
         // hashes are a fixed size, so it is safe to use the empty root for this
         len += EMPTY_ROOT.length();
-        len += self.code.as_ref().map_or(KECCAK_EMPTY, keccak256).length();
+        // we are encoding a hash, so let's just use the length of the empty hash for the code hash
+        len += KECCAK_EMPTY.length();
         len
     }
-}
 
-impl Encodable for GenesisAccount {
-    fn length(&self) -> usize {
-        let len = self.payload_len();
-        // RLP header length + payload length
-        len + length_of_length(len)
+    /// Set the nonce.
+    pub fn with_nonce(mut self, nonce: Option<u64>) -> Self {
+        self.nonce = nonce;
+        self
+    }
+
+    /// Set the balance.
+    pub fn with_balance(mut self, balance: U256) -> Self {
+        self.balance = balance;
+        self
+    }
+
+    /// Set the code.
+    pub fn with_code(mut self, code: Option<Bytes>) -> Self {
+        self.code = code;
+        self
     }
 
+    /// Set the storage.
+    pub fn with_storage(mut self, storage: Option<HashMap<H256, H256>>) -> Self {
+        self.storage = storage;
+        self
+    }
+}
+
+impl Encodable for GenesisAccount {
     fn encode(&self, out: &mut dyn bytes::BufMut) {
         let header = RlpHeader { list: true, payload_length: self.payload_len() };
         header.encode(out);
@@ -83,18 +155,25 @@ impl Encodable for GenesisAccount {
         self.storage
             .as_ref()
             .map_or(EMPTY_ROOT, |storage| {
+                if storage.is_empty() {
+                    return EMPTY_ROOT
+                }
                 let storage_values =
-                    storage.iter().filter(|(_k, &v)| v != KECCAK_EMPTY).map(|(&k, v)| {
-                        let mut value_rlp = BytesMut::new();
-                        v.encode(&mut value_rlp);
-                        (k, value_rlp.freeze())
+                    storage.iter().filter(|(_k, &v)| v != H256::zero()).map(|(&k, v)| {
+                        let value = U256::from_be_bytes(**v);
+                        (k, encode_fixed_size(&value))
                     });
-
                 sec_trie_root::<KeccakHasher, _, _, _>(storage_values)
             })
             .encode(out);
         self.code.as_ref().map_or(KECCAK_EMPTY, keccak256).encode(out);
     }
+
+    fn length(&self) -> usize {
+        let len = self.payload_len();
+        // RLP header length + payload length
+        len + length_of_length(len)
+    }
 }
 
 impl From<EthersGenesisAccount> for GenesisAccount {
@@ -109,3 +188,104 @@ impl From<EthersGenesisAccount> for GenesisAccount {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use hex_literal::hex;
+
+    #[test]
+    fn test_genesis() {
+        let default_genesis = Genesis::default();
+
+        let nonce = 999;
+        let timestamp = 12345;
+        let extra_data = Bytes::from(b"extra-data");
+        let gas_limit = 333333;
+        let difficulty = U256::from(9000);
+        let mix_hash =
+            hex!("74385b512f1e0e47100907efe2b00ac78df26acba6dd16b0772923068a5801a8").into();
+        let coinbase = hex!("265873b6faf3258b3ab0827805386a2a20ed040e").into();
+        // create dummy account
+        let first_address: Address = hex!("7618a8c597b89e01c66a1f662078992c52a30c9a").into();
+        let mut account = HashMap::default();
+        account.insert(first_address, GenesisAccount::default());
+
+        // check values updated
+        let custom_genesis = Genesis::default()
+            .with_nonce(nonce)
+            .with_timestamp(timestamp)
+            .with_extra_data(extra_data.clone())
+            .with_gas_limit(gas_limit)
+            .with_difficulty(difficulty)
+            .with_mix_hash(mix_hash)
+            .with_coinbase(coinbase)
+            .extend_accounts(account.clone());
+
+        assert_ne!(custom_genesis, default_genesis);
+        // check every field
+        assert_eq!(custom_genesis.nonce, nonce);
+        assert_eq!(custom_genesis.timestamp, timestamp);
+        assert_eq!(custom_genesis.extra_data, extra_data);
+        assert_eq!(custom_genesis.gas_limit, gas_limit);
+        assert_eq!(custom_genesis.difficulty, difficulty);
+        assert_eq!(custom_genesis.mix_hash, mix_hash);
+        assert_eq!(custom_genesis.coinbase, coinbase);
+        assert_eq!(custom_genesis.alloc, account.clone());
+
+        // update existing account
+        assert_eq!(custom_genesis.alloc.len(), 1);
+        let same_address = first_address;
+        let new_alloc_account = GenesisAccount {
+            nonce: Some(1),
+            balance: U256::from(1),
+            code: Some(Bytes::from(b"code")),
+            storage: Some(HashMap::default()),
+        };
+        let mut updated_account = HashMap::default();
+        updated_account.insert(same_address, new_alloc_account);
+        let custom_genesis = custom_genesis.extend_accounts(updated_account.clone());
+        assert_ne!(account, updated_account);
+        assert_eq!(custom_genesis.alloc.len(), 1);
+
+        // add second account
+        let different_address = hex!("94e0681e3073dd71cec54b53afe988f39078fd1a").into();
+        let more_accounts = HashMap::from([(different_address, GenesisAccount::default())]);
+        let custom_genesis = custom_genesis.extend_accounts(more_accounts);
+        assert_eq!(custom_genesis.alloc.len(), 2);
+
+        // ensure accounts are different
+        let first_account = custom_genesis.alloc.get(&first_address);
+        let second_account = custom_genesis.alloc.get(&different_address);
+        assert!(first_account.is_some());
+        assert!(second_account.is_some());
+        assert_ne!(first_account, second_account);
+    }
+
+    #[test]
+    fn test_genesis_account() {
+        let default_account = GenesisAccount::default();
+
+        let nonce = Some(1);
+        let balance = U256::from(33);
+        let code = Some(Bytes::from(b"code"));
+        let root = hex!("9474ddfcea39c5a690d2744103e39d1ff1b03d18db10fc147d970ad24699395a").into();
+        let value = hex!("58eb8294d9bb16832a9dabfcb270fff99ab8ee1d8764e4f3d9fdf59ec1dee469").into();
+        let mut map = HashMap::default();
+        map.insert(root, value);
+        let storage = Some(map);
+
+        let genesis_account = GenesisAccount::default()
+            .with_nonce(nonce)
+            .with_balance(balance)
+            .with_code(code.clone())
+            .with_storage(storage.clone());
+
+        assert_ne!(default_account, genesis_account);
+        // check every field
+        assert_eq!(genesis_account.nonce, nonce);
+        assert_eq!(genesis_account.balance, balance);
+        assert_eq!(genesis_account.code, code);
+        assert_eq!(genesis_account.storage, storage);
+    }
+}
diff --git a/crates/primitives/src/header.rs b/crates/primitives/src/header.rs
index 951d1f46ded..012a5ca4a46 100644
--- a/crates/primitives/src/header.rs
+++ b/crates/primitives/src/header.rs
@@ -8,7 +8,7 @@ use ethers_core::types::{Block, H256 as EthersH256, H64};
 use reth_codecs::{add_arbitrary_tests, derive_arbitrary, main_codec, Compact};
 use reth_rlp::{length_of_length, Decodable, Encodable, EMPTY_STRING_CODE};
 use serde::{Deserialize, Serialize};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 /// Describes the current head block.
 ///
@@ -284,9 +284,9 @@ impl Decodable for Header {
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct SealedHeader {
     /// Locked Header fields.
-    header: Header,
+    pub header: Header,
     /// Locked Header hash.
-    hash: BlockHash,
+    pub hash: BlockHash,
 }
 
 impl SealedHeader {
@@ -404,6 +404,12 @@ impl Deref for SealedHeader {
     }
 }
 
+impl DerefMut for SealedHeader {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.header
+    }
+}
+
 /// Represents the direction for a headers request depending on the `reverse` field of the request.
 /// > The response must contain a number of block headers, of rising number when reverse is 0,
 /// > falling when 1
diff --git a/crates/primitives/src/hex_bytes.rs b/crates/primitives/src/hex_bytes.rs
index b7447afa72f..33b58285312 100644
--- a/crates/primitives/src/hex_bytes.rs
+++ b/crates/primitives/src/hex_bytes.rs
@@ -98,6 +98,12 @@ impl From<bytes::Bytes> for Bytes {
     }
 }
 
+impl From<Bytes> for bytes::Bytes {
+    fn from(src: Bytes) -> Self {
+        src.0
+    }
+}
+
 impl From<Vec<u8>> for Bytes {
     fn from(src: Vec<u8>) -> Self {
         Self(src.into())
@@ -147,12 +153,12 @@ impl PartialEq<bytes::Bytes> for Bytes {
 }
 
 impl Encodable for Bytes {
-    fn length(&self) -> usize {
-        self.0.length()
-    }
     fn encode(&self, out: &mut dyn bytes::BufMut) {
         self.0.encode(out)
     }
+    fn length(&self) -> usize {
+        self.0.length()
+    }
 }
 
 impl Decodable for Bytes {
diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs
index 3007a20847d..904201a58be 100644
--- a/crates/primitives/src/lib.rs
+++ b/crates/primitives/src/lib.rs
@@ -14,7 +14,9 @@ mod bits;
 mod block;
 pub mod bloom;
 mod chain;
+mod checkpoints;
 pub mod constants;
+pub mod contract;
 mod error;
 pub mod filter;
 mod forkid;
@@ -23,7 +25,6 @@ mod hardfork;
 mod header;
 mod hex_bytes;
 mod integer_list;
-mod jsonu256;
 mod log;
 mod net;
 mod peer;
@@ -35,14 +36,19 @@ mod withdrawal;
 /// Helper function for calculating Merkle proofs and hashes
 pub mod proofs;
 
-pub use account::Account;
+pub use account::{Account, Bytecode};
 pub use bits::H512;
-pub use block::{Block, BlockHashOrNumber, BlockId, BlockNumberOrTag, SealedBlock};
+pub use block::{
+    Block, BlockHashOrNumber, BlockId, BlockNumberOrTag, SealedBlock, SealedBlockWithSenders,
+};
 pub use bloom::Bloom;
+#[cfg(feature = "optimism")]
+pub use chain::OP_GOERLI;
 pub use chain::{
     AllGenesisFormats, Chain, ChainInfo, ChainSpec, ChainSpecBuilder, ForkCondition, GOERLI,
     MAINNET, SEPOLIA,
 };
+pub use checkpoints::{AccountHashingCheckpoint, ProofCheckpoint, StorageHashingCheckpoint};
 pub use constants::{
     EMPTY_OMMER_ROOT, GOERLI_GENESIS, KECCAK_EMPTY, MAINNET_GENESIS, SEPOLIA_GENESIS,
 };
@@ -52,16 +58,21 @@ pub use hardfork::Hardfork;
 pub use header::{Head, Header, HeadersDirection, SealedHeader};
 pub use hex_bytes::Bytes;
 pub use integer_list::IntegerList;
-pub use jsonu256::JsonU256;
 pub use log::Log;
-pub use net::NodeRecord;
+pub use net::{
+    goerli_nodes, mainnet_nodes, sepolia_nodes, NodeRecord, GOERLI_BOOTNODES, MAINNET_BOOTNODES,
+    SEPOLIA_BOOTNODES,
+};
 pub use peer::{PeerId, WithPeerId};
 pub use receipt::Receipt;
+pub use revm_primitives::JumpMap;
+pub use serde_helper::JsonU256;
 pub use storage::{StorageEntry, StorageTrieEntry};
 pub use transaction::{
-    AccessList, AccessListItem, FromRecoveredTransaction, IntoRecoveredTransaction, Signature,
+    util::secp256k1::sign_message, AccessList, AccessListItem, AccessListWithGasUsed,
+    FromRecoveredTransaction, IntoRecoveredTransaction, InvalidTransactionError, Signature,
     Transaction, TransactionKind, TransactionSigned, TransactionSignedEcRecovered, TxEip1559,
-    TxEip2930, TxLegacy, TxType,
+    TxEip2930, TxLegacy, TxType, EIP1559_TX_TYPE_ID, EIP2930_TX_TYPE_ID, LEGACY_TX_TYPE_ID,
 };
 #[cfg(feature = "optimism")]
 pub use transaction::{TxDeposit, DEPOSIT_TX_TYPE, DEPOSIT_VERSION};
@@ -110,9 +121,7 @@ pub mod utils {
 }
 
 /// Helpers for working with serde
-pub mod serde_helper {
-    pub use crate::jsonu256::deserialize_json_u256;
-}
+pub mod serde_helper;
 
 /// Returns the keccak256 hash for the given data.
 #[inline]
@@ -125,3 +134,6 @@ pub fn keccak256(data: impl AsRef<[u8]>) -> H256 {
     hasher.finalize(&mut buf);
     buf.into()
 }
+
+#[cfg(any(test, feature = "arbitrary"))]
+pub use arbitrary;
diff --git a/crates/primitives/src/net.rs b/crates/primitives/src/net.rs
index bfb990f9d4e..08ddbe68aea 100644
--- a/crates/primitives/src/net.rs
+++ b/crates/primitives/src/net.rs
@@ -115,6 +115,60 @@ impl fmt::Display for NodeRecord {
     }
 }
 
+// <https://github.com/ledgerwatch/erigon/blob/610e648dc43ec8cd6563313e28f06f534a9091b3/params/bootnodes.go>
+
+/// Ethereum Foundation Go Bootnodes
+pub static MAINNET_BOOTNODES : [&str; 4] = [
+    "enode://d860a01f9722d78051619d1e2351aba3f43f943f6f00718d1b9baa4101932a1f5011f16bb2b1bb35db20d6fe28fa0bf09636d26a87d31de9ec6203eeedb1f666@18.138.108.67:30303",   // bootnode-aws-ap-southeast-1-001
+    "enode://22a8232c3abc76a16ae9d6c3b164f98775fe226f0917b0ca871128a74a8e9630b458460865bab457221f1d448dd9791d24c4e5d88786180ac185df813a68d4de@3.209.45.79:30303",     // bootnode-aws-us-east-1-001
+    "enode://2b252ab6a1d0f971d9722cb839a42cb81db019ba44c08754628ab4a823487071b5695317c8ccd085219c3a03af063495b2f1da8d18218da2d6a82981b45e6ffc@65.108.70.101:30303",   // bootnode-hetzner-hel
+    "enode://4aeb4ab6c14b23e2c4cfdce879c04b0748a20d8e9b59e25ded2a08143e265c6c25936e74cbc8e641e3312ca288673d91f2f93f8e277de3cfa444ecdaaf982052@157.90.35.166:30303",   // bootnode-hetzner-fsn
+];
+
+/// SEPOLIA BOOTNODES
+pub static SEPOLIA_BOOTNODES : [&str; 2] = [
+    // geth
+    "enode://9246d00bc8fd1742e5ad2428b80fc4dc45d786283e05ef6edbd9002cbc335d40998444732fbe921cb88e1d2c73d1b1de53bae6a2237996e9bfe14f871baf7066@18.168.182.86:30303",
+    // besu
+    "enode://ec66ddcf1a974950bd4c782789a7e04f8aa7110a72569b6e65fcd51e937e74eed303b1ea734e4d19cfaec9fbff9b6ee65bf31dcb50ba79acce9dd63a6aca61c7@52.14.151.177:30303",
+];
+
+/// GOERLI bootnodes
+pub static GOERLI_BOOTNODES : [&str; 7] = [
+    // Upstream bootnodes
+    "enode://011f758e6552d105183b1761c5e2dea0111bc20fd5f6422bc7f91e0fabbec9a6595caf6239b37feb773dddd3f87240d99d859431891e4a642cf2a0a9e6cbb98a@51.141.78.53:30303",
+    "enode://176b9417f511d05b6b2cf3e34b756cf0a7096b3094572a8f6ef4cdcb9d1f9d00683bf0f83347eebdf3b81c3521c2332086d9592802230bf528eaf606a1d9677b@13.93.54.137:30303",
+    "enode://46add44b9f13965f7b9875ac6b85f016f341012d84f975377573800a863526f4da19ae2c620ec73d11591fa9510e992ecc03ad0751f53cc02f7c7ed6d55c7291@94.237.54.114:30313",
+    "enode://b5948a2d3e9d486c4d75bf32713221c2bd6cf86463302339299bd227dc2e276cd5a1c7ca4f43a0e9122fe9af884efed563bd2a1fd28661f3b5f5ad7bf1de5949@18.218.250.66:30303",
+
+    // Ethereum Foundation bootnode
+    "enode://a61215641fb8714a373c80edbfa0ea8878243193f57c96eeb44d0bc019ef295abd4e044fd619bfc4c59731a73fb79afe84e9ab6da0c743ceb479cbb6d263fa91@3.11.147.67:30303",
+
+    // Goerli Initiative bootnodes
+    "enode://d4f764a48ec2a8ecf883735776fdefe0a3949eb0ca476bd7bc8d0954a9defe8fea15ae5da7d40b5d2d59ce9524a99daedadf6da6283fca492cc80b53689fb3b3@46.4.99.122:32109",
+    "enode://d2b720352e8216c9efc470091aa91ddafc53e222b32780f505c817ceef69e01d5b0b0797b69db254c586f493872352f5a022b4d8479a00fc92ec55f9ad46a27e@88.99.70.182:30303",
+];
+
+/// Returns parsed mainnet nodes
+pub fn mainnet_nodes() -> Vec<NodeRecord> {
+    parse_nodes(&MAINNET_BOOTNODES[..])
+}
+
+/// Returns parsed goerli nodes
+pub fn goerli_nodes() -> Vec<NodeRecord> {
+    parse_nodes(&GOERLI_BOOTNODES[..])
+}
+
+/// Returns parsed sepolia nodes
+pub fn sepolia_nodes() -> Vec<NodeRecord> {
+    parse_nodes(&SEPOLIA_BOOTNODES[..])
+}
+
+/// Parses all the nodes
+fn parse_nodes(nodes: impl IntoIterator<Item = impl AsRef<str>>) -> Vec<NodeRecord> {
+    nodes.into_iter().map(|s| s.as_ref().parse().unwrap()).collect()
+}
+
 /// Possible error types when parsing a `NodeRecord`
 #[derive(Debug, thiserror::Error)]
 pub enum NodeRecordParseError {
@@ -145,14 +199,10 @@ impl FromStr for NodeRecord {
             .port()
             .ok_or_else(|| NodeRecordParseError::InvalidUrl("no port specified".to_string()))?;
 
-        let udp_port = if let Some(discovery_port) =
-            url.query_pairs().find_map(|(maybe_disc, port)| {
-                if maybe_disc.as_ref() == "discport" {
-                    Some(port)
-                } else {
-                    None
-                }
-            }) {
+        let udp_port = if let Some(discovery_port) = url
+            .query_pairs()
+            .find_map(|(maybe_disc, port)| (maybe_disc.as_ref() == "discport").then_some(port))
+        {
             discovery_port.parse::<u16>().map_err(NodeRecordParseError::Discport)?
         } else {
             port
diff --git a/crates/primitives/src/proofs.rs b/crates/primitives/src/proofs.rs
index bfba3e50507..28f7f6e8b2e 100644
--- a/crates/primitives/src/proofs.rs
+++ b/crates/primitives/src/proofs.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::{
     keccak256, Address, Bytes, GenesisAccount, Header, Log, Receipt, TransactionSigned, Withdrawal,
     H256,
@@ -9,6 +7,7 @@ use hash_db::Hasher;
 use hex_literal::hex;
 use plain_hasher::PlainHasher;
 use reth_rlp::Encodable;
+use std::collections::HashMap;
 use triehash::{ordered_trie_root, sec_trie_root};
 
 /// Keccak-256 hash of the RLP of an empty list, KEC("\xc0").
@@ -36,7 +35,6 @@ impl Hasher for KeccakHasher {
 
 /// Calculate a transaction root.
 ///
-/// Iterates over the given transactions and the merkle merkle trie root of
 /// `(rlp(index), encoded(tx))` pairs.
 pub fn calculate_transaction_root<'a>(
     transactions: impl IntoIterator<Item = &'a TransactionSigned>,
diff --git a/crates/primitives/src/receipt.rs b/crates/primitives/src/receipt.rs
index 80761da980b..ae4303856f9 100644
--- a/crates/primitives/src/receipt.rs
+++ b/crates/primitives/src/receipt.rs
@@ -106,6 +106,9 @@ impl Receipt {
 }
 
 impl Encodable for Receipt {
+    fn encode(&self, out: &mut dyn BufMut) {
+        self.encode_inner(out, true)
+    }
     fn length(&self) -> usize {
         let mut payload_len = self.receipt_length();
         // account for eip-2718 type prefix and set the list
@@ -117,9 +120,6 @@ impl Encodable for Receipt {
 
         payload_len
     }
-    fn encode(&self, out: &mut dyn BufMut) {
-        self.encode_inner(out, true)
-    }
 }
 
 impl Decodable for Receipt {
diff --git a/crates/primitives/src/jsonu256.rs b/crates/primitives/src/serde_helper/jsonu256.rs
similarity index 96%
rename from crates/primitives/src/jsonu256.rs
rename to crates/primitives/src/serde_helper/jsonu256.rs
index 58c71580615..3cf187f1f37 100644
--- a/crates/primitives/src/jsonu256.rs
+++ b/crates/primitives/src/serde_helper/jsonu256.rs
@@ -15,6 +15,12 @@ impl From<JsonU256> for U256 {
     }
 }
 
+impl From<U256> for JsonU256 {
+    fn from(value: U256) -> Self {
+        JsonU256(value)
+    }
+}
+
 impl Serialize for JsonU256 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
diff --git a/crates/primitives/src/serde_helper/mod.rs b/crates/primitives/src/serde_helper/mod.rs
new file mode 100644
index 00000000000..b2d44797875
--- /dev/null
+++ b/crates/primitives/src/serde_helper/mod.rs
@@ -0,0 +1,47 @@
+//! Various serde utilities
+
+mod jsonu256;
+pub use jsonu256::*;
+
+pub mod num;
+
+/// serde functions for handling primitive `u64` as [U64](crate::U64)
+pub mod u64_hex {
+    use crate::U64;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    /// Deserializes an `u64` from [U64] accepting a hex quantity string with optional 0x prefix
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<u64, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        U64::deserialize(deserializer).map(|val| val.as_u64())
+    }
+
+    /// Serializes u64 as hex string
+    pub fn serialize<S: Serializer>(value: &u64, s: S) -> Result<S::Ok, S::Error> {
+        U64::from(*value).serialize(s)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[test]
+    fn test_hex_u64() {
+        #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
+        struct Value {
+            #[serde(with = "u64_hex")]
+            inner: u64,
+        }
+
+        let val = Value { inner: 1000 };
+        let s = serde_json::to_string(&val).unwrap();
+        assert_eq!(s, "{\"inner\":\"0x3e8\"}");
+
+        let deserialized: Value = serde_json::from_str(&s).unwrap();
+        assert_eq!(val, deserialized);
+    }
+}
diff --git a/crates/primitives/src/serde_helper/num.rs b/crates/primitives/src/serde_helper/num.rs
new file mode 100644
index 00000000000..beab749ab3b
--- /dev/null
+++ b/crates/primitives/src/serde_helper/num.rs
@@ -0,0 +1,88 @@
+//! Numeric helpers
+
+use crate::U256;
+use serde::{de, Deserialize, Deserializer};
+use std::str::FromStr;
+
+/// Deserializes the input into an `Option<U256>`, using [`from_int_or_hex`] to deserialize the
+/// inner value.
+pub fn from_int_or_hex_opt<'de, D>(deserializer: D) -> Result<Option<U256>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    match Option::<NumberOrHexU256>::deserialize(deserializer)? {
+        Some(val) => val.try_into_u256().map(Some),
+        None => Ok(None),
+    }
+}
+
+/// Deserializes the input into a U256, accepting both 0x-prefixed hex and decimal strings with
+/// arbitrary precision, defined by serde_json's [`Number`](serde_json::Number).
+pub fn from_int_or_hex<'de, D>(deserializer: D) -> Result<U256, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    NumberOrHexU256::deserialize(deserializer)?.try_into_u256()
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum NumberOrHexU256 {
+    Int(serde_json::Number),
+    Hex(U256),
+}
+
+impl NumberOrHexU256 {
+    fn try_into_u256<E: de::Error>(self) -> Result<U256, E> {
+        match self {
+            NumberOrHexU256::Int(num) => {
+                U256::from_str(num.to_string().as_str()).map_err(E::custom)
+            }
+            NumberOrHexU256::Hex(val) => Ok(val),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_u256_int_or_hex() {
+        #[derive(Debug, Deserialize, PartialEq, Eq)]
+        struct V(#[serde(deserialize_with = "from_int_or_hex")] U256);
+
+        proptest::proptest!(|(value: u64)| {
+            let u256_val = U256::from(value);
+
+            let num_obj = serde_json::to_string(&value).unwrap();
+            let hex_obj = serde_json::to_string(&u256_val).unwrap();
+
+            let int_val:V = serde_json::from_str(&num_obj).unwrap();
+            let hex_val =  serde_json::from_str(&hex_obj).unwrap();
+            assert_eq!(int_val, hex_val);
+        });
+    }
+
+    #[test]
+    fn test_u256_int_or_hex_opt() {
+        #[derive(Debug, Deserialize, PartialEq, Eq)]
+        struct V(#[serde(deserialize_with = "from_int_or_hex_opt")] Option<U256>);
+
+        let null = serde_json::to_string(&None::<U256>).unwrap();
+        let val: V = serde_json::from_str(&null).unwrap();
+        assert!(val.0.is_none());
+
+        proptest::proptest!(|(value: u64)| {
+            let u256_val = U256::from(value);
+
+            let num_obj = serde_json::to_string(&value).unwrap();
+            let hex_obj = serde_json::to_string(&u256_val).unwrap();
+
+            let int_val:V = serde_json::from_str(&num_obj).unwrap();
+            let hex_val =  serde_json::from_str(&hex_obj).unwrap();
+            assert_eq!(int_val, hex_val);
+            assert_eq!(int_val.0, Some(u256_val));
+        });
+    }
+}
diff --git a/crates/primitives/src/storage.rs b/crates/primitives/src/storage.rs
index f64554c88c4..67e027c34dc 100644
--- a/crates/primitives/src/storage.rs
+++ b/crates/primitives/src/storage.rs
@@ -12,6 +12,12 @@ pub struct StorageEntry {
     pub value: U256,
 }
 
+impl From<(H256, U256)> for StorageEntry {
+    fn from((key, value): (H256, U256)) -> Self {
+        StorageEntry { key, value }
+    }
+}
+
 // NOTE: Removing main_codec and manually encode subkey
 // and compress second part of the value. If we have compression
 // over whole value (Even SubKey) that would mess up fetching of values with seek_by_key_subkey
diff --git a/crates/primitives/src/transaction/access_list.rs b/crates/primitives/src/transaction/access_list.rs
index 823a98bbc45..d7295f5dccb 100644
--- a/crates/primitives/src/transaction/access_list.rs
+++ b/crates/primitives/src/transaction/access_list.rs
@@ -3,6 +3,7 @@ use revm_primitives::U256;
 
 use reth_codecs::{main_codec, Compact};
 use reth_rlp::{RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper};
+use serde::{Deserialize, Serialize};
 
 /// A list of addresses and storage keys that the transaction plans to access.
 /// Accesses outside the list are possible, but become more expensive.
@@ -34,3 +35,13 @@ impl AccessList {
             .collect()
     }
 }
+
+/// Access list with gas used appended.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct AccessListWithGasUsed {
+    /// List with accounts accessed during transaction.
+    pub access_list: AccessList,
+    /// Estimated gas used with access list.
+    pub gas_used: U256,
+}
diff --git a/crates/primitives/src/transaction/error.rs b/crates/primitives/src/transaction/error.rs
new file mode 100644
index 00000000000..649ecbe36b4
--- /dev/null
+++ b/crates/primitives/src/transaction/error.rs
@@ -0,0 +1,47 @@
+use crate::U256;
+
+/// Represents error variants that can happen when trying to validate a
+/// [Transaction](crate::Transaction)
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Eq, PartialEq, thiserror::Error)]
+pub enum InvalidTransactionError {
+    #[error("Transaction eip1559 priority fee is more then max fee.")]
+    PriorityFeeMoreThenMaxFee,
+    #[error("Account does not have enough funds ({available_funds:?}) to cover transaction max fee: {max_fee:?}.")]
+    InsufficientFunds { max_fee: u128, available_funds: U256 },
+    #[error("Transaction nonce is not consistent.")]
+    NonceNotConsistent,
+    #[error("Old legacy transaction before Spurious Dragon should not have chain_id.")]
+    OldLegacyChainId,
+    #[error("Transaction chain_id does not match.")]
+    ChainIdMismatch,
+    #[error("Transaction max fee is less them block base fee.")]
+    MaxFeeLessThenBaseFee,
+    #[error("Eip2930 transaction is enabled after berlin hardfork.")]
+    Eip2930Disabled,
+    #[error("Eip2930 transaction is enabled after london hardfork.")]
+    Eip1559Disabled,
+    /// Thrown when calculating gas usage
+    #[error("gas uint64 overflow")]
+    GasUintOverflow,
+    /// returned if the transaction is specified to use less gas than required to start the
+    /// invocation.
+    #[error("intrinsic gas too low")]
+    GasTooLow,
+    /// returned if the transaction gas exceeds the limit
+    #[error("intrinsic gas too high")]
+    GasTooHigh,
+    /// thrown if a transaction is not supported in the current network configuration.
+    #[error("transaction type not supported")]
+    TxTypeNotSupported,
+    /// Thrown to ensure no one is able to specify a transaction with a tip higher than the total
+    /// fee cap.
+    #[error("max priority fee per gas higher than max fee per gas")]
+    TipAboveFeeCap,
+    /// Thrown post London if the transaction's fee is less than the base fee of the block
+    #[error("max fee per gas less than block base fee")]
+    FeeCapTooLow,
+    /// Thrown if the sender of a transaction is a contract.
+    #[error("Transaction signer has bytecode set.")]
+    SignerAccountHasBytecode,
+}
diff --git a/crates/primitives/src/transaction/mod.rs b/crates/primitives/src/transaction/mod.rs
index 7725675fc46..33ad192b123 100644
--- a/crates/primitives/src/transaction/mod.rs
+++ b/crates/primitives/src/transaction/mod.rs
@@ -1,7 +1,8 @@
 use crate::{keccak256, Address, Bytes, ChainId, TxHash, H256};
-pub use access_list::{AccessList, AccessListItem};
+pub use access_list::{AccessList, AccessListItem, AccessListWithGasUsed};
 use bytes::{Buf, BytesMut};
 use derive_more::{AsRef, Deref};
+pub use error::InvalidTransactionError;
 use reth_codecs::{add_arbitrary_tests, main_codec, Compact};
 use reth_rlp::{
     length_of_length, Decodable, DecodeError, Encodable, Header, EMPTY_LIST_CODE, EMPTY_STRING_CODE,
@@ -9,12 +10,13 @@ use reth_rlp::{
 #[cfg(feature = "optimism")]
 use revm_primitives::U256;
 pub use signature::Signature;
-pub use tx_type::TxType;
+pub use tx_type::{TxType, EIP1559_TX_TYPE_ID, EIP2930_TX_TYPE_ID, LEGACY_TX_TYPE_ID};
 
 mod access_list;
+mod error;
 mod signature;
 mod tx_type;
-mod util;
+pub(crate) mod util;
 
 #[cfg(feature = "optimism")]
 mod optimism;
@@ -179,11 +181,13 @@ pub enum Transaction {
     Eip2930(TxEip2930),
     /// A transaction with a priority fee ([EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)).
     Eip1559(TxEip1559),
-    /// Deposit transaction.
+    /// Optimism deposit transaction.
     #[cfg(feature = "optimism")]
     Deposit(TxDeposit),
 }
 
+// === impl Transaction ===
+
 impl Transaction {
     /// Heavy operation that return signature hash over rlp encoded transaction.
     /// It is only for signature signing or signer recovery.
@@ -629,7 +633,7 @@ impl TransactionSigned {
 
     /// Recover signer from signature and hash.
     ///
-    /// Returns `None` if the transaction's signature is invalid.
+    /// Returns `None` if the transaction's signature is invalid, see also [Self::recover_signer].
     pub fn recover_signer(&self) -> Option<Address> {
         #[cfg(feature = "optimism")]
         if let Transaction::Deposit(TxDeposit { from, .. }) = self.transaction {
@@ -641,7 +645,7 @@ impl TransactionSigned {
 
     /// Devour Self, recover signer and return [`TransactionSignedEcRecovered`]
     ///
-    /// Returns `None` if the transaction's signature is invalid.
+    /// Returns `None` if the transaction's signature is invalid, see also [Self::recover_signer].
     pub fn into_ecrecovered(self) -> Option<TransactionSignedEcRecovered> {
         let signer = self.recover_signer()?;
         Some(TransactionSignedEcRecovered { signed_transaction: self, signer })
@@ -1003,6 +1007,8 @@ pub struct TransactionSignedEcRecovered {
     signed_transaction: TransactionSigned,
 }
 
+// === impl TransactionSignedEcRecovered ===
+
 impl TransactionSignedEcRecovered {
     /// Signer of transaction recovered from signature
     pub fn signer(&self) -> Address {
@@ -1014,6 +1020,11 @@ impl TransactionSignedEcRecovered {
         self.signed_transaction
     }
 
+    /// Desolve Self to its component
+    pub fn to_components(self) -> (TransactionSigned, Address) {
+        (self.signed_transaction, self.signer)
+    }
+
     /// Create [`TransactionSignedEcRecovered`] from [`TransactionSigned`] and [`Address`] of the
     /// signer.
     pub fn from_signed_transaction(signed_transaction: TransactionSigned, signer: Address) -> Self {
@@ -1021,6 +1032,26 @@ impl TransactionSignedEcRecovered {
     }
 }
 
+impl Encodable for TransactionSignedEcRecovered {
+    fn encode(&self, out: &mut dyn bytes::BufMut) {
+        self.signed_transaction.encode(out)
+    }
+
+    fn length(&self) -> usize {
+        self.signed_transaction.length()
+    }
+}
+
+impl Decodable for TransactionSignedEcRecovered {
+    fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
+        let signed_transaction = TransactionSigned::decode(buf)?;
+        let signer = signed_transaction
+            .recover_signer()
+            .ok_or(DecodeError::Custom("Unable to recover decoded transaction signer."))?;
+        Ok(TransactionSignedEcRecovered { signer, signed_transaction })
+    }
+}
+
 /// A transaction type that can be created from a [`TransactionSignedEcRecovered`] transaction.
 ///
 /// This is a conversion trait that'll ensure transactions received via P2P can be converted to the
@@ -1038,16 +1069,6 @@ impl FromRecoveredTransaction for TransactionSignedEcRecovered {
     }
 }
 
-impl Encodable for TransactionSignedEcRecovered {
-    fn encode(&self, out: &mut dyn bytes::BufMut) {
-        self.signed_transaction.encode(out)
-    }
-
-    fn length(&self) -> usize {
-        self.signed_transaction.length()
-    }
-}
-
 /// The inverse of [`FromRecoveredTransaction`] that ensure the transaction can be sent over the
 /// network
 pub trait IntoRecoveredTransaction {
@@ -1068,7 +1089,8 @@ impl IntoRecoveredTransaction for TransactionSignedEcRecovered {
 mod tests {
     use crate::{
         transaction::{signature::Signature, TransactionKind, TxEip1559, TxEip2930, TxLegacy},
-        AccessList, Address, Bytes, Transaction, TransactionSigned, H256, U256,
+        AccessList, Address, Bytes, Transaction, TransactionSigned, TransactionSignedEcRecovered,
+        H256, U256,
     };
     use bytes::BytesMut;
     use ethers_core::utils::hex;
@@ -1393,4 +1415,18 @@ mod tests {
         let encoded = decoded.envelope_encoded();
         assert_eq!(encoded, input);
     }
+
+    #[test]
+    fn test_decode_signed_ec_recovered_transaction() {
+        // random tx: <https://etherscan.io/getRawTx?tx=0x9448608d36e721ef403c53b00546068a6474d6cbab6816c3926de449898e7bce>
+        let input = hex::decode("02f871018302a90f808504890aef60826b6c94ddf4c5025d1a5742cf12f74eec246d4432c295e487e09c3bbcc12b2b80c080a0f21a4eacd0bf8fea9c5105c543be5a1d8c796516875710fafafdf16d16d8ee23a001280915021bb446d1973501a67f93d2b38894a514b976e7b46dc2fe54598d76").unwrap();
+        let tx = TransactionSigned::decode(&mut &input[..]).unwrap();
+        let recovered = tx.into_ecrecovered().unwrap();
+
+        let mut encoded = BytesMut::new();
+        recovered.encode(&mut encoded);
+
+        let decoded = TransactionSignedEcRecovered::decode(&mut &encoded[..]).unwrap();
+        assert_eq!(recovered, decoded)
+    }
 }
diff --git a/crates/primitives/src/transaction/signature.rs b/crates/primitives/src/transaction/signature.rs
index b20c4f79b2e..2d87bf04fd5 100644
--- a/crates/primitives/src/transaction/signature.rs
+++ b/crates/primitives/src/transaction/signature.rs
@@ -6,7 +6,7 @@ use reth_rlp::{Decodable, DecodeError, Encodable};
 /// transaction and used to determine the sender of
 /// the transaction; formally Tr and Ts. This is expanded in Appendix F of yellow paper.
 #[main_codec]
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
 pub struct Signature {
     /// The R field of the signature; the point on the curve.
     pub r: U256,
@@ -38,6 +38,11 @@ impl Signature {
     /// Output the `v` of the signature depends on chain_id
     #[inline]
     pub fn v(&self, chain_id: Option<u64>) -> u64 {
+        #[cfg(feature = "optimism")]
+        if self.r == U256::ZERO && self.s == U256::ZERO {
+            return 0
+        }
+
         if let Some(chain_id) = chain_id {
             // EIP-155: v = {0, 1} + CHAIN_ID * 2 + 35
             self.odd_y_parity as u64 + chain_id * 2 + 35
@@ -99,6 +104,17 @@ impl Signature {
         // errors and we care only if recovery is passing or not.
         secp256k1::recover(&sig, hash.as_fixed_bytes()).ok()
     }
+
+    /// Turn this signature into its byte
+    /// (hex) representation.
+    pub fn to_bytes(&self) -> [u8; 65] {
+        let mut sig = [0u8; 65];
+        sig[..32].copy_from_slice(&self.r.to_be_bytes::<32>());
+        sig[32..64].copy_from_slice(&self.s.to_be_bytes::<32>());
+        let v = u8::from(self.odd_y_parity) + 27;
+        sig[64] = v;
+        sig
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/primitives/src/transaction/tx_type.rs b/crates/primitives/src/transaction/tx_type.rs
index 0115f7ea6ff..91b2f9b58d3 100644
--- a/crates/primitives/src/transaction/tx_type.rs
+++ b/crates/primitives/src/transaction/tx_type.rs
@@ -1,6 +1,20 @@
 use reth_codecs::{derive_arbitrary, Compact};
 use serde::{Deserialize, Serialize};
 
+/// Identifier for legacy transaction, however [TxLegacy](crate::TxLegacy) this is technically not
+/// typed.
+pub const LEGACY_TX_TYPE_ID: u8 = 0;
+
+/// Identifier for [TxEip2930](crate::TxEip2930) transaction.
+pub const EIP2930_TX_TYPE_ID: u8 = 1;
+
+/// Identifier for [TxEip1559](crate::TxEip1559) transaction.
+pub const EIP1559_TX_TYPE_ID: u8 = 2;
+
+/// Identifier for [TxDeposit](crate::TxDeposit) transaction.
+#[cfg(feature = "optimism")]
+pub(crate) const DEPOSIT_TX_TYPE_ID: u8 = 126;
+
 /// Transaction Type
 #[derive_arbitrary(compact)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Serialize, Deserialize)]
@@ -20,11 +34,11 @@ pub enum TxType {
 impl From<TxType> for u8 {
     fn from(value: TxType) -> Self {
         match value {
-            TxType::Legacy => 0,
-            TxType::EIP2930 => 1,
-            TxType::EIP1559 => 2,
+            TxType::Legacy => LEGACY_TX_TYPE_ID,
+            TxType::EIP2930 => EIP2930_TX_TYPE_ID,
+            TxType::EIP1559 => EIP1559_TX_TYPE_ID,
             #[cfg(feature = "optimism")]
-            TxType::DEPOSIT => 126,
+            TxType::DEPOSIT => DEPOSIT_TX_TYPE_ID,
         }
     }
 }
@@ -32,11 +46,11 @@ impl From<TxType> for u8 {
 impl Compact for TxType {
     fn to_compact(self, _: &mut impl bytes::BufMut) -> usize {
         match self {
-            TxType::Legacy => 0,
-            TxType::EIP2930 => 1,
-            TxType::EIP1559 => 2,
+            TxType::Legacy => LEGACY_TX_TYPE_ID as usize,
+            TxType::EIP2930 => EIP2930_TX_TYPE_ID as usize,
+            TxType::EIP1559 => EIP1559_TX_TYPE_ID as usize,
             #[cfg(feature = "optimism")]
-            TxType::DEPOSIT => 126,
+            TxType::DEPOSIT => DEPOSIT_TX_TYPE_ID as usize,
         }
     }
 
diff --git a/crates/primitives/src/transaction/util.rs b/crates/primitives/src/transaction/util.rs
index 5bb11d41c52..f2d471c3045 100644
--- a/crates/primitives/src/transaction/util.rs
+++ b/crates/primitives/src/transaction/util.rs
@@ -1,11 +1,16 @@
 use crate::{keccak256, Address};
 
 pub(crate) mod secp256k1 {
+    use crate::Signature;
+
     use super::*;
     use ::secp256k1::{
         ecdsa::{RecoverableSignature, RecoveryId},
-        Error, Message, SECP256K1,
+        Message, SecretKey, SECP256K1,
     };
+    use revm_primitives::{B256, U256};
+
+    pub(crate) use ::secp256k1::Error;
 
     /// secp256k1 signer recovery
     pub(crate) fn recover(sig: &[u8; 65], msg: &[u8; 32]) -> Result<Address, Error> {
@@ -16,6 +21,21 @@ pub(crate) mod secp256k1 {
         let hash = keccak256(&public.serialize_uncompressed()[1..]);
         Ok(Address::from_slice(&hash[12..]))
     }
+
+    /// Signs message with the given secret key.
+    /// Returns the corresponding signature.
+    pub fn sign_message(secret: B256, message: B256) -> Result<Signature, secp256k1::Error> {
+        let sec = SecretKey::from_slice(secret.as_ref())?;
+        let s = SECP256K1.sign_ecdsa_recoverable(&Message::from_slice(&message[..])?, &sec);
+        let (rec_id, data) = s.serialize_compact();
+
+        let signature = Signature {
+            r: U256::try_from_be_slice(&data[..32]).expect("The slice has at most 32 bytes"),
+            s: U256::try_from_be_slice(&data[32..64]).expect("The slice has at most 32 bytes"),
+            odd_y_parity: rec_id.to_i32() != 0,
+        };
+        Ok(signature)
+    }
 }
 #[cfg(test)]
 mod tests {
diff --git a/crates/primitives/src/withdrawal.rs b/crates/primitives/src/withdrawal.rs
index ae49d3a38d8..f94175f8f0d 100644
--- a/crates/primitives/src/withdrawal.rs
+++ b/crates/primitives/src/withdrawal.rs
@@ -1,4 +1,4 @@
-use crate::{constants::GWEI_TO_WEI, Address, U256};
+use crate::{constants::GWEI_TO_WEI, serde_helper::u64_hex, Address, U256};
 use reth_codecs::{main_codec, Compact};
 use reth_rlp::{RlpDecodable, RlpEncodable};
 
@@ -7,12 +7,15 @@ use reth_rlp::{RlpDecodable, RlpEncodable};
 #[derive(Debug, Clone, PartialEq, Eq, Default, RlpEncodable, RlpDecodable)]
 pub struct Withdrawal {
     /// Monotonically increasing identifier issued by consensus layer.
+    #[serde(with = "u64_hex")]
     pub index: u64,
     /// Index of validator associated with withdrawal.
+    #[serde(with = "u64_hex", rename = "validatorIndex")]
     pub validator_index: u64,
     /// Target address for withdrawn ether.
     pub address: Address,
     /// Value of the withdrawal in gwei.
+    #[serde(with = "u64_hex")]
     pub amount: u64,
 }
 
@@ -22,3 +25,18 @@ impl Withdrawal {
         U256::from(self.amount) * U256::from(GWEI_TO_WEI)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // <https://github.com/paradigmxyz/reth/issues/1614>
+    #[test]
+    fn test_withdrawal_serde_roundtrip() {
+        let input = r#"[{"index":"0x0","validatorIndex":"0x0","address":"0x0000000000000000000000000000000000001000","amount":"0x1"},{"index":"0x1","validatorIndex":"0x1","address":"0x0000000000000000000000000000000000001001","amount":"0x1"},{"index":"0x2","validatorIndex":"0x2","address":"0x0000000000000000000000000000000000001002","amount":"0x1"},{"index":"0x3","validatorIndex":"0x3","address":"0x0000000000000000000000000000000000001003","amount":"0x1"},{"index":"0x4","validatorIndex":"0x4","address":"0x0000000000000000000000000000000000001004","amount":"0x1"},{"index":"0x5","validatorIndex":"0x5","address":"0x0000000000000000000000000000000000001005","amount":"0x1"},{"index":"0x6","validatorIndex":"0x6","address":"0x0000000000000000000000000000000000001006","amount":"0x1"},{"index":"0x7","validatorIndex":"0x7","address":"0x0000000000000000000000000000000000001007","amount":"0x1"},{"index":"0x8","validatorIndex":"0x8","address":"0x0000000000000000000000000000000000001008","amount":"0x1"},{"index":"0x9","validatorIndex":"0x9","address":"0x0000000000000000000000000000000000001009","amount":"0x1"},{"index":"0xa","validatorIndex":"0xa","address":"0x000000000000000000000000000000000000100a","amount":"0x1"},{"index":"0xb","validatorIndex":"0xb","address":"0x000000000000000000000000000000000000100b","amount":"0x1"},{"index":"0xc","validatorIndex":"0xc","address":"0x000000000000000000000000000000000000100c","amount":"0x1"},{"index":"0xd","validatorIndex":"0xd","address":"0x000000000000000000000000000000000000100d","amount":"0x1"},{"index":"0xe","validatorIndex":"0xe","address":"0x000000000000000000000000000000000000100e","amount":"0x1"},{"index":"0xf","validatorIndex":"0xf","address":"0x000000000000000000000000000000000000100f","amount":"0x1"}]"#;
+
+        let withdrawals: Vec<Withdrawal> = serde_json::from_str(input).unwrap();
+        let s = serde_json::to_string(&withdrawals).unwrap();
+        assert_eq!(input, s);
+    }
+}
diff --git a/crates/revm/Cargo.toml b/crates/revm/Cargo.toml
index de419c346d1..4b293a91f8e 100644
--- a/crates/revm/Cargo.toml
+++ b/crates/revm/Cargo.toml
@@ -12,5 +12,9 @@ reth-primitives = { path = "../primitives" }
 reth-interfaces = { path = "../interfaces" }
 reth-provider = { path = "../storage/provider" }
 reth-revm-primitives = { path = "./revm-primitives" }
+reth-revm-inspectors = { path = "./revm-inspectors" }
 
-revm = { version = "3.0.0"}
\ No newline at end of file
+revm = { version = "3.0.0" }
+
+[features]
+optimism = ["reth-primitives/optimism", "reth-revm-primitives/optimism"]
diff --git a/crates/revm/revm-inspectors/Cargo.toml b/crates/revm/revm-inspectors/Cargo.toml
index 5f21a007b20..19e5c34f70a 100644
--- a/crates/revm/revm-inspectors/Cargo.toml
+++ b/crates/revm/revm-inspectors/Cargo.toml
@@ -9,7 +9,10 @@ description = "revm inspector implementations used by reth"
 [dependencies]
 # reth 
 reth-primitives = { path = "../../primitives" }
+reth-rpc-types = { path = "../../rpc/rpc-types" }
 
 revm = { version = "3.0.0" }
 # remove from reth and reexport from revm
-hashbrown = "0.13"
\ No newline at end of file
+hashbrown = "0.13"
+
+serde = { version = "1.0", features = ["derive"] }
diff --git a/crates/revm/revm-inspectors/src/lib.rs b/crates/revm/revm-inspectors/src/lib.rs
index cec3a9d0912..a447c70951a 100644
--- a/crates/revm/revm-inspectors/src/lib.rs
+++ b/crates/revm/revm-inspectors/src/lib.rs
@@ -9,3 +9,11 @@
 
 /// An inspector implementation for an EIP2930 Accesslist
 pub mod access_list;
+
+/// An inspector stack abstracting the implementation details of
+/// each inspector and allowing to hook on block/transaciton execution,
+/// used in the main RETH executor.
+pub mod stack;
+
+/// An inspector for recording traces
+pub mod tracing;
diff --git a/crates/revm/revm-inspectors/src/stack/maybe_owned.rs b/crates/revm/revm-inspectors/src/stack/maybe_owned.rs
new file mode 100644
index 00000000000..897546f1672
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/stack/maybe_owned.rs
@@ -0,0 +1,209 @@
+use revm::{
+    interpreter::{CallInputs, CreateInputs, Gas, InstructionResult, Interpreter},
+    primitives::{db::Database, Bytes, B160, B256},
+    EVMData, Inspector,
+};
+use std::{
+    cell::{Ref, RefCell},
+    rc::Rc,
+};
+
+/// An [Inspector] that is either owned by an individual [Inspector] or is shared as part of a
+/// series of inspectors in a [InspectorStack](crate::stack::InspectorStack).
+///
+/// Caution: if the [Inspector] is _stacked_ then it _must_ be called first.
+#[derive(Debug)]
+pub enum MaybeOwnedInspector<INSP> {
+    /// Inspector is owned.
+    Owned(Rc<RefCell<INSP>>),
+    /// Inspector is shared and part of a stack
+    Stacked(Rc<RefCell<INSP>>),
+}
+
+impl<INSP> MaybeOwnedInspector<INSP> {
+    /// Create a new _owned_ instance
+    pub fn new_owned(inspector: INSP) -> Self {
+        MaybeOwnedInspector::Owned(Rc::new(RefCell::new(inspector)))
+    }
+
+    /// Creates a [MaybeOwnedInspector::Stacked] clone of this type.
+    pub fn clone_stacked(&self) -> Self {
+        match self {
+            MaybeOwnedInspector::Owned(gas) | MaybeOwnedInspector::Stacked(gas) => {
+                MaybeOwnedInspector::Stacked(Rc::clone(gas))
+            }
+        }
+    }
+
+    /// Returns a reference to the inspector.
+    pub fn as_ref(&self) -> Ref<'_, INSP> {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => insp.borrow(),
+            MaybeOwnedInspector::Stacked(insp) => insp.borrow(),
+        }
+    }
+}
+
+impl<INSP: Default> MaybeOwnedInspector<INSP> {
+    /// Create a new _owned_ instance
+    pub fn owned() -> Self {
+        Self::new_owned(Default::default())
+    }
+}
+
+impl<INSP: Default> Default for MaybeOwnedInspector<INSP> {
+    fn default() -> Self {
+        Self::owned()
+    }
+}
+
+impl<INSP> Clone for MaybeOwnedInspector<INSP> {
+    fn clone(&self) -> Self {
+        self.clone_stacked()
+    }
+}
+
+impl<INSP, DB> Inspector<DB> for MaybeOwnedInspector<INSP>
+where
+    DB: Database,
+    INSP: Inspector<DB>,
+{
+    fn initialize_interp(
+        &mut self,
+        interp: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+    ) -> InstructionResult {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().initialize_interp(interp, data, is_static)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+
+        InstructionResult::Continue
+    }
+
+    fn step(
+        &mut self,
+        interp: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+    ) -> InstructionResult {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().step(interp, data, is_static)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+
+        InstructionResult::Continue
+    }
+
+    fn log(
+        &mut self,
+        evm_data: &mut EVMData<'_, DB>,
+        address: &B160,
+        topics: &[B256],
+        data: &Bytes,
+    ) {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().log(evm_data, address, topics, data)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+    }
+
+    fn step_end(
+        &mut self,
+        interp: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+        eval: InstructionResult,
+    ) -> InstructionResult {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().step_end(interp, data, is_static, eval)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+
+        InstructionResult::Continue
+    }
+
+    fn call(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &mut CallInputs,
+        is_static: bool,
+    ) -> (InstructionResult, Gas, Bytes) {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().call(data, inputs, is_static)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+
+        (InstructionResult::Continue, Gas::new(0), Bytes::new())
+    }
+
+    fn call_end(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &CallInputs,
+        remaining_gas: Gas,
+        ret: InstructionResult,
+        out: Bytes,
+        is_static: bool,
+    ) -> (InstructionResult, Gas, Bytes) {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().call_end(data, inputs, remaining_gas, ret, out, is_static)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+        (ret, remaining_gas, out)
+    }
+
+    fn create(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &mut CreateInputs,
+    ) -> (InstructionResult, Option<B160>, Gas, Bytes) {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => return insp.borrow_mut().create(data, inputs),
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+
+        (InstructionResult::Continue, None, Gas::new(0), Bytes::default())
+    }
+
+    fn create_end(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &CreateInputs,
+        ret: InstructionResult,
+        address: Option<B160>,
+        remaining_gas: Gas,
+        out: Bytes,
+    ) -> (InstructionResult, Option<B160>, Gas, Bytes) {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().create_end(data, inputs, ret, address, remaining_gas, out)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+
+        (ret, address, remaining_gas, out)
+    }
+
+    fn selfdestruct(&mut self, contract: B160, target: B160) {
+        match self {
+            MaybeOwnedInspector::Owned(insp) => {
+                return insp.borrow_mut().selfdestruct(contract, target)
+            }
+            MaybeOwnedInspector::Stacked(_) => {}
+        }
+    }
+}
diff --git a/crates/revm/revm-inspectors/src/stack/mod.rs b/crates/revm/revm-inspectors/src/stack/mod.rs
new file mode 100644
index 00000000000..5a37169e2f9
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/stack/mod.rs
@@ -0,0 +1,244 @@
+use reth_primitives::{bytes::Bytes, Address, TxHash, H256};
+use revm::{
+    inspectors::CustomPrintTracer,
+    interpreter::{CallInputs, CreateInputs, Gas, InstructionResult, Interpreter},
+    primitives::Env,
+    Database, EVMData, Inspector,
+};
+
+/// A wrapped [Inspector](revm::Inspector) that can be reused in the stack
+mod maybe_owned;
+pub use maybe_owned::MaybeOwnedInspector;
+
+/// One can hook on inspector execution in 3 ways:
+/// - Block: Hook on block execution
+/// - BlockWithIndex: Hook on block execution transaction index
+/// - Transaction: Hook on a specific transaction hash
+#[derive(Default, Clone)]
+pub enum Hook {
+    #[default]
+    /// No hook.
+    None,
+    /// Hook on a specific block.
+    Block(u64),
+    /// Hook on a specific transaction hash.
+    Transaction(TxHash),
+    /// Hooks on every transaction in a block.
+    All,
+}
+
+#[derive(Default, Clone)]
+/// An inspector that calls multiple inspectors in sequence.
+///
+/// If a call to an inspector returns a value other than [InstructionResult::Continue] (or
+/// equivalent) the remaining inspectors are not called.
+pub struct InspectorStack {
+    /// An inspector that prints the opcode traces to the console.
+    pub custom_print_tracer: Option<CustomPrintTracer>,
+    /// The provided hook
+    pub hook: Hook,
+}
+
+impl InspectorStack {
+    /// Create a new inspector stack.
+    pub fn new(config: InspectorStackConfig) -> Self {
+        let mut stack = InspectorStack { hook: config.hook, ..Default::default() };
+
+        if config.use_printer_tracer {
+            stack.custom_print_tracer = Some(CustomPrintTracer::default());
+        }
+
+        stack
+    }
+
+    /// Check if the inspector should be used.
+    pub fn should_inspect(&self, env: &Env, tx_hash: TxHash) -> bool {
+        match self.hook {
+            Hook::None => false,
+            Hook::Block(block) => env.block.number.to::<u64>() == block,
+            Hook::Transaction(hash) => hash == tx_hash,
+            Hook::All => true,
+        }
+    }
+}
+
+#[derive(Default)]
+/// Configuration for the inspectors.
+pub struct InspectorStackConfig {
+    /// Enable revm inspector printer.
+    /// In execution this will print opcode level traces directly to console.
+    pub use_printer_tracer: bool,
+
+    /// Hook on a specific block or transaction.
+    pub hook: Hook,
+}
+
+/// Helper macro to call the same method on multiple inspectors without resorting to dynamic
+/// dispatch
+#[macro_export]
+macro_rules! call_inspectors {
+    ($id:ident, [ $($inspector:expr),+ ], $call:block) => {
+        $({
+            if let Some($id) = $inspector {
+                $call;
+            }
+        })+
+    }
+}
+
+impl<DB> Inspector<DB> for InspectorStack
+where
+    DB: Database,
+{
+    fn initialize_interp(
+        &mut self,
+        interpreter: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+    ) -> InstructionResult {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            let status = inspector.initialize_interp(interpreter, data, is_static);
+
+            // Allow inspectors to exit early
+            if status != InstructionResult::Continue {
+                return status
+            }
+        });
+
+        InstructionResult::Continue
+    }
+
+    fn step(
+        &mut self,
+        interpreter: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+    ) -> InstructionResult {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            let status = inspector.step(interpreter, data, is_static);
+
+            // Allow inspectors to exit early
+            if status != InstructionResult::Continue {
+                return status
+            }
+        });
+
+        InstructionResult::Continue
+    }
+
+    fn log(
+        &mut self,
+        evm_data: &mut EVMData<'_, DB>,
+        address: &Address,
+        topics: &[H256],
+        data: &Bytes,
+    ) {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            inspector.log(evm_data, address, topics, data);
+        });
+    }
+
+    fn step_end(
+        &mut self,
+        interpreter: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+        eval: InstructionResult,
+    ) -> InstructionResult {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            let status = inspector.step_end(interpreter, data, is_static, eval);
+
+            // Allow inspectors to exit early
+            if status != InstructionResult::Continue {
+                return status
+            }
+        });
+
+        InstructionResult::Continue
+    }
+
+    fn call(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &mut CallInputs,
+        is_static: bool,
+    ) -> (InstructionResult, Gas, Bytes) {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            let (status, gas, retdata) = inspector.call(data, inputs, is_static);
+
+            // Allow inspectors to exit early
+            if status != InstructionResult::Continue {
+                return (status, gas, retdata)
+            }
+        });
+
+        (InstructionResult::Continue, Gas::new(inputs.gas_limit), Bytes::new())
+    }
+
+    fn call_end(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &CallInputs,
+        remaining_gas: Gas,
+        ret: InstructionResult,
+        out: Bytes,
+        is_static: bool,
+    ) -> (InstructionResult, Gas, Bytes) {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            let (new_ret, new_gas, new_out) =
+                inspector.call_end(data, inputs, remaining_gas, ret, out.clone(), is_static);
+
+            // If the inspector returns a different ret or a revert with a non-empty message,
+            // we assume it wants to tell us something
+            if new_ret != ret || (new_ret == InstructionResult::Revert && new_out != out) {
+                return (new_ret, new_gas, new_out)
+            }
+        });
+
+        (ret, remaining_gas, out)
+    }
+
+    fn create(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &mut CreateInputs,
+    ) -> (InstructionResult, Option<Address>, Gas, Bytes) {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            let (status, addr, gas, retdata) = inspector.create(data, inputs);
+
+            // Allow inspectors to exit early
+            if status != InstructionResult::Continue {
+                return (status, addr, gas, retdata)
+            }
+        });
+
+        (InstructionResult::Continue, None, Gas::new(inputs.gas_limit), Bytes::new())
+    }
+
+    fn create_end(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &CreateInputs,
+        ret: InstructionResult,
+        address: Option<Address>,
+        remaining_gas: Gas,
+        out: Bytes,
+    ) -> (InstructionResult, Option<Address>, Gas, Bytes) {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            let (new_ret, new_address, new_gas, new_retdata) =
+                inspector.create_end(data, inputs, ret, address, remaining_gas, out.clone());
+
+            if new_ret != ret {
+                return (new_ret, new_address, new_gas, new_retdata)
+            }
+        });
+
+        (ret, address, remaining_gas, out)
+    }
+
+    fn selfdestruct(&mut self, contract: Address, target: Address) {
+        call_inspectors!(inspector, [&mut self.custom_print_tracer], {
+            Inspector::<DB>::selfdestruct(inspector, contract, target);
+        });
+    }
+}
diff --git a/crates/revm/revm-inspectors/src/tracing/arena.rs b/crates/revm/revm-inspectors/src/tracing/arena.rs
new file mode 100644
index 00000000000..e8e14075d44
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/arena.rs
@@ -0,0 +1,45 @@
+use crate::tracing::types::{CallTrace, CallTraceNode, LogCallOrder};
+
+/// An arena of recorded traces.
+///
+/// This type will be populated via the [TracingInspector](crate::tracing::TracingInspector).
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct CallTraceArena {
+    /// The arena of recorded trace nodes
+    pub(crate) arena: Vec<CallTraceNode>,
+}
+
+impl CallTraceArena {
+    /// Pushes a new trace into the arena, returning the trace ID
+    pub(crate) fn push_trace(&mut self, entry: usize, new_trace: CallTrace) -> usize {
+        match new_trace.depth {
+            // The entry node, just update it
+            0 => {
+                self.arena[0].trace = new_trace;
+                0
+            }
+            // We found the parent node, add the new trace as a child
+            _ if self.arena[entry].trace.depth == new_trace.depth - 1 => {
+                let id = self.arena.len();
+
+                let trace_location = self.arena[entry].children.len();
+                self.arena[entry].ordering.push(LogCallOrder::Call(trace_location));
+                let node = CallTraceNode {
+                    parent: Some(entry),
+                    trace: new_trace,
+                    idx: id,
+                    ..Default::default()
+                };
+                self.arena.push(node);
+                self.arena[entry].children.push(id);
+
+                id
+            }
+            // We haven't found the parent node, go deeper
+            _ => self.push_trace(
+                *self.arena[entry].children.last().expect("Disconnected trace"),
+                new_trace,
+            ),
+        }
+    }
+}
diff --git a/crates/revm/revm-inspectors/src/tracing/builder/geth.rs b/crates/revm/revm-inspectors/src/tracing/builder/geth.rs
new file mode 100644
index 00000000000..db402a53b99
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/builder/geth.rs
@@ -0,0 +1,109 @@
+//! Geth trace builder
+
+use crate::tracing::{types::CallTraceNode, TracingInspectorConfig};
+use reth_primitives::{Address, JsonU256, H256, U256};
+use reth_rpc_types::trace::geth::*;
+use revm::interpreter::opcode;
+use std::collections::{BTreeMap, HashMap};
+
+/// A type for creating geth style traces
+#[derive(Clone, Debug)]
+pub struct GethTraceBuilder {
+    /// Recorded trace nodes.
+    nodes: Vec<CallTraceNode>,
+    /// How the traces were recorded
+    _config: TracingInspectorConfig,
+}
+
+impl GethTraceBuilder {
+    /// Returns a new instance of the builder
+    pub(crate) fn new(nodes: Vec<CallTraceNode>, _config: TracingInspectorConfig) -> Self {
+        Self { nodes, _config }
+    }
+
+    /// Recursively fill in the geth trace by going through the traces
+    ///
+    /// TODO rewrite this iteratively
+    fn add_to_geth_trace(
+        &self,
+        storage: &mut HashMap<Address, BTreeMap<H256, H256>>,
+        trace_node: &CallTraceNode,
+        struct_logs: &mut Vec<StructLog>,
+        opts: &GethDefaultTracingOptions,
+    ) {
+        let mut child_id = 0;
+        // Iterate over the steps inside the given trace
+        for step in trace_node.trace.steps.iter() {
+            let mut log: StructLog = step.into();
+
+            // Fill in memory and storage depending on the options
+            if !opts.disable_storage.unwrap_or_default() {
+                let contract_storage = storage.entry(step.contract).or_default();
+                if let Some((key, value)) = step.state_diff {
+                    contract_storage.insert(key.into(), value.into());
+                    log.storage = Some(contract_storage.clone());
+                }
+            }
+            if opts.disable_stack.unwrap_or_default() {
+                log.stack = None;
+            }
+
+            if !opts.enable_memory.unwrap_or_default() {
+                log.memory = None;
+            }
+
+            if opts.enable_return_data.unwrap_or_default() {
+                log.return_data = trace_node.trace.last_call_return_value.clone().map(Into::into);
+            }
+
+            // Add step to geth trace
+            struct_logs.push(log);
+
+            // If the opcode is a call, the descend into child trace
+            match step.op.u8() {
+                opcode::CREATE |
+                opcode::CREATE2 |
+                opcode::DELEGATECALL |
+                opcode::CALL |
+                opcode::STATICCALL |
+                opcode::CALLCODE => {
+                    self.add_to_geth_trace(
+                        storage,
+                        &self.nodes[trace_node.children[child_id]],
+                        struct_logs,
+                        opts,
+                    );
+                    child_id += 1;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    /// Generate a geth-style trace e.g. for `debug_traceTransaction`
+    pub fn geth_traces(
+        &self,
+        // TODO(mattsse): This should be the total gas used, or gas used by last CallTrace?
+        receipt_gas_used: U256,
+        opts: GethDefaultTracingOptions,
+    ) -> DefaultFrame {
+        if self.nodes.is_empty() {
+            return Default::default()
+        }
+        // Fetch top-level trace
+        let main_trace_node = &self.nodes[0];
+        let main_trace = &main_trace_node.trace;
+
+        let mut struct_logs = Vec::new();
+        let mut storage = HashMap::new();
+        self.add_to_geth_trace(&mut storage, main_trace_node, &mut struct_logs, &opts);
+
+        DefaultFrame {
+            // If the top-level trace succeeded, then it was a success
+            failed: !main_trace.success,
+            gas: JsonU256(receipt_gas_used),
+            return_value: main_trace.output.clone().into(),
+            struct_logs,
+        }
+    }
+}
diff --git a/crates/revm/revm-inspectors/src/tracing/builder/mod.rs b/crates/revm/revm-inspectors/src/tracing/builder/mod.rs
new file mode 100644
index 00000000000..a39a31913ee
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/builder/mod.rs
@@ -0,0 +1,4 @@
+//! Builder types for building traces
+
+pub(crate) mod geth;
+pub(crate) mod parity;
diff --git a/crates/revm/revm-inspectors/src/tracing/builder/parity.rs b/crates/revm/revm-inspectors/src/tracing/builder/parity.rs
new file mode 100644
index 00000000000..fc62ef5b172
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/builder/parity.rs
@@ -0,0 +1,104 @@
+use crate::tracing::{types::CallTraceNode, TracingInspectorConfig};
+use reth_rpc_types::{trace::parity::*, TransactionInfo};
+
+/// A type for creating parity style traces
+#[derive(Clone, Debug)]
+pub struct ParityTraceBuilder {
+    /// Recorded trace nodes
+    nodes: Vec<CallTraceNode>,
+    /// How the traces were recorded
+    _config: TracingInspectorConfig,
+}
+
+impl ParityTraceBuilder {
+    /// Returns a new instance of the builder
+    pub(crate) fn new(nodes: Vec<CallTraceNode>, _config: TracingInspectorConfig) -> Self {
+        Self { nodes, _config }
+    }
+
+    /// Returns the trace addresses of all transactions in the set
+    fn trace_addresses(&self) -> Vec<Vec<usize>> {
+        let mut all_addresses = Vec::with_capacity(self.nodes.len());
+        for idx in 0..self.nodes.len() {
+            all_addresses.push(self.trace_address(idx));
+        }
+        all_addresses
+    }
+
+    /// Returns the `traceAddress` of the node in the arena
+    ///
+    /// The `traceAddress` field of all returned traces, gives the exact location in the call trace
+    /// [index in root, index in first CALL, index in second CALL, …].
+    ///
+    /// # Panics
+    ///
+    /// if the `idx` does not belong to a node
+    fn trace_address(&self, idx: usize) -> Vec<usize> {
+        if idx == 0 {
+            // root call has empty traceAddress
+            return vec![]
+        }
+        let mut graph = vec![];
+        let mut node = &self.nodes[idx];
+        while let Some(parent) = node.parent {
+            // the index of the child call in the arena
+            let child_idx = node.idx;
+            node = &self.nodes[parent];
+            // find the index of the child call in the parent node
+            let call_idx = node
+                .children
+                .iter()
+                .position(|child| *child == child_idx)
+                .expect("child exists in parent");
+            graph.push(call_idx);
+        }
+        graph.reverse();
+        graph
+    }
+
+    /// Returns an iterator over all recorded traces  for `trace_transaction`
+    pub fn into_localized_transaction_traces_iter(
+        self,
+        info: TransactionInfo,
+    ) -> impl Iterator<Item = LocalizedTransactionTrace> {
+        self.into_transaction_traces_iter().map(move |trace| {
+            let TransactionInfo { hash, index, block_hash, block_number } = info;
+            LocalizedTransactionTrace {
+                trace,
+                transaction_position: index,
+                transaction_hash: hash,
+                block_number,
+                block_hash,
+            }
+        })
+    }
+
+    /// Returns an iterator over all recorded traces  for `trace_transaction`
+    pub fn into_localized_transaction_traces(
+        self,
+        info: TransactionInfo,
+    ) -> Vec<LocalizedTransactionTrace> {
+        self.into_localized_transaction_traces_iter(info).collect()
+    }
+
+    /// Returns an iterator over all recorded traces  for `trace_transaction`
+    pub fn into_transaction_traces_iter(self) -> impl Iterator<Item = TransactionTrace> {
+        let trace_addresses = self.trace_addresses();
+
+        self.nodes.into_iter().zip(trace_addresses).map(|(node, trace_address)| {
+            let action = node.parity_action();
+            let output = TraceResult::parity_success(node.parity_trace_output());
+            TransactionTrace {
+                action,
+                result: Some(output),
+                trace_address,
+                subtraces: node.children.len(),
+            }
+        })
+    }
+
+    /// Returns the raw traces of the transaction
+    pub fn into_transaction_traces(self) -> Vec<TransactionTrace> {
+        self.into_transaction_traces_iter().collect()
+    }
+}
diff --git a/crates/revm/revm-inspectors/src/tracing/config.rs b/crates/revm/revm-inspectors/src/tracing/config.rs
new file mode 100644
index 00000000000..c731eb85dc8
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/config.rs
@@ -0,0 +1,75 @@
+/// Gives guidance to the [TracingInspector](crate::tracing::TracingInspector).
+///
+/// Use [TracingInspectorConfig::default_parity] or [TracingInspectorConfig::default_geth] to get
+/// the default configs for specific styles of traces.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct TracingInspectorConfig {
+    /// Whether to record every individual opcode level step.
+    pub record_steps: bool,
+    /// Whether to record individual memory snapshots.
+    pub record_memory_snapshots: bool,
+    /// Whether to record individual stack snapshots.
+    pub record_stack_snapshots: bool,
+    /// Whether to record state diffs.
+    pub record_state_diff: bool,
+}
+
+impl TracingInspectorConfig {
+    /// Returns a config with everything enabled.
+    pub const fn all() -> Self {
+        Self {
+            record_steps: true,
+            record_memory_snapshots: true,
+            record_stack_snapshots: true,
+            record_state_diff: false,
+        }
+    }
+
+    /// Returns a config for parity style traces.
+    ///
+    /// This config does _not_ record opcode level traces and is suited for `trace_transaction`
+    pub const fn default_parity() -> Self {
+        Self {
+            record_steps: false,
+            record_memory_snapshots: false,
+            record_stack_snapshots: false,
+            record_state_diff: false,
+        }
+    }
+
+    /// Returns a config for geth style traces.
+    ///
+    /// This config does _not_ record opcode level traces and is suited for `debug_traceTransaction`
+    pub const fn default_geth() -> Self {
+        Self {
+            record_steps: true,
+            record_memory_snapshots: true,
+            record_stack_snapshots: true,
+            record_state_diff: true,
+        }
+    }
+
+    /// Configure whether individual opcode level steps should be recorded
+    pub fn set_steps(mut self, record_steps: bool) -> Self {
+        self.record_steps = record_steps;
+        self
+    }
+
+    /// Configure whether the tracer should record memory snapshots
+    pub fn set_memory_snapshots(mut self, record_memory_snapshots: bool) -> Self {
+        self.record_memory_snapshots = record_memory_snapshots;
+        self
+    }
+
+    /// Configure whether the tracer should record stack snapshots
+    pub fn set_stack_snapshots(mut self, record_stack_snapshots: bool) -> Self {
+        self.record_stack_snapshots = record_stack_snapshots;
+        self
+    }
+
+    /// Configure whether the tracer should record state diffs
+    pub fn set_state_diffs(mut self, record_state_diff: bool) -> Self {
+        self.record_state_diff = record_state_diff;
+        self
+    }
+}
diff --git a/crates/revm/revm-inspectors/src/tracing/mod.rs b/crates/revm/revm-inspectors/src/tracing/mod.rs
new file mode 100644
index 00000000000..f78215fc615
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/mod.rs
@@ -0,0 +1,437 @@
+use crate::{
+    stack::MaybeOwnedInspector,
+    tracing::{
+        types::{CallKind, LogCallOrder, RawLog},
+        utils::{gas_used, get_create_address},
+    },
+};
+pub use arena::CallTraceArena;
+use reth_primitives::{bytes::Bytes, Address, H256, U256};
+use revm::{
+    inspectors::GasInspector,
+    interpreter::{
+        opcode, return_ok, CallInputs, CallScheme, CreateInputs, Gas, InstructionResult,
+        Interpreter, OpCode,
+    },
+    Database, EVMData, Inspector, JournalEntry,
+};
+use types::{CallTrace, CallTraceStep};
+
+mod arena;
+mod builder;
+mod config;
+mod types;
+mod utils;
+pub use builder::{geth::GethTraceBuilder, parity::ParityTraceBuilder};
+pub use config::TracingInspectorConfig;
+
+/// An inspector that collects call traces.
+///
+/// This [Inspector] can be hooked into the [EVM](revm::EVM) which then calls the inspector
+/// functions, such as [Inspector::call] or [Inspector::call_end].
+///
+/// The [TracingInspector] keeps track of everything by:
+///   1. start tracking steps/calls on [Inspector::step] and [Inspector::call]
+///   2. complete steps/calls on [Inspector::step_end] and [Inspector::call_end]
+#[derive(Debug, Clone)]
+pub struct TracingInspector {
+    /// Configures what and how the inspector records traces.
+    config: TracingInspectorConfig,
+    /// Records all call traces
+    traces: CallTraceArena,
+    /// Tracks active calls
+    trace_stack: Vec<usize>,
+    /// Tracks active steps
+    step_stack: Vec<StackStep>,
+    /// Tracks the return value of the last call
+    last_call_return_data: Option<Bytes>,
+    /// The gas inspector used to track remaining gas.
+    ///
+    /// This is either owned by this inspector directly or part of a stack of inspectors, in which
+    /// case all delegated functions are no-ops.
+    gas_inspector: MaybeOwnedInspector<GasInspector>,
+}
+
+// === impl TracingInspector ===
+
+impl TracingInspector {
+    /// Returns a new instance for the given config
+    pub fn new(config: TracingInspectorConfig) -> Self {
+        Self {
+            config,
+            traces: Default::default(),
+            trace_stack: vec![],
+            step_stack: vec![],
+            last_call_return_data: None,
+            gas_inspector: Default::default(),
+        }
+    }
+
+    /// Consumes the Inspector and returns a [ParityTraceBuilder].
+    pub fn into_parity_builder(self) -> ParityTraceBuilder {
+        ParityTraceBuilder::new(self.traces.arena, self.config)
+    }
+
+    /// Consumes the Inspector and returns a [GethTraceBuilder].
+    pub fn into_geth_builder(self) -> GethTraceBuilder {
+        GethTraceBuilder::new(self.traces.arena, self.config)
+    }
+
+    /// Configures a [GasInspector]
+    ///
+    /// If this [TracingInspector] is part of a stack [InspectorStack](crate::stack::InspectorStack)
+    /// which already uses a [GasInspector], it can be reused as [MaybeOwnedInspector::Stacked] in
+    /// which case the `gas_inspector`'s usage will be a no-op within the context of this
+    /// [TracingInspector].
+    pub fn with_stacked_gas_inspector(
+        mut self,
+        gas_inspector: MaybeOwnedInspector<GasInspector>,
+    ) -> Self {
+        self.gas_inspector = gas_inspector;
+        self
+    }
+
+    /// Returns the last trace [CallTrace] index from the stack.
+    ///
+    /// # Panics
+    ///
+    /// If no [CallTrace] was pushed
+    #[track_caller]
+    #[inline]
+    fn last_trace_idx(&self) -> usize {
+        self.trace_stack.last().copied().expect("can't start step without starting a trace first")
+    }
+
+    /// _Removes_ the last trace [CallTrace] index from the stack.
+    ///
+    /// # Panics
+    ///
+    /// If no [CallTrace] was pushed
+    #[track_caller]
+    #[inline]
+    fn pop_trace_idx(&mut self) -> usize {
+        self.trace_stack.pop().expect("more traces were filled than started")
+    }
+
+    /// Starts tracking a new trace.
+    ///
+    /// Invoked on [Inspector::call].
+    fn start_trace_on_call(
+        &mut self,
+        depth: usize,
+        address: Address,
+        data: Bytes,
+        value: U256,
+        kind: CallKind,
+        caller: Address,
+    ) {
+        self.trace_stack.push(self.traces.push_trace(
+            0,
+            CallTrace {
+                depth,
+                address,
+                kind,
+                data,
+                value,
+                status: InstructionResult::Continue,
+                caller,
+                last_call_return_value: self.last_call_return_data.clone(),
+                ..Default::default()
+            },
+        ));
+    }
+
+    /// Fills the current trace with the outcome of a call.
+    ///
+    /// Invoked on [Inspector::call_end].
+    ///
+    /// # Panics
+    ///
+    /// This expects an existing trace [Self::start_trace_on_call]
+    fn fill_trace_on_call_end(
+        &mut self,
+        status: InstructionResult,
+        gas_used: u64,
+        output: Bytes,
+        created_address: Option<Address>,
+    ) {
+        let trace_idx = self.pop_trace_idx();
+        let trace = &mut self.traces.arena[trace_idx].trace;
+
+        let success = matches!(status, return_ok!());
+        trace.status = status;
+        trace.success = success;
+        trace.gas_used = gas_used;
+        trace.output = output.clone();
+        self.last_call_return_data = Some(output);
+
+        if let Some(address) = created_address {
+            // A new contract was created via CREATE
+            trace.address = address;
+        }
+    }
+
+    /// Starts tracking a step
+    ///
+    /// Invoked on [Inspector::step]
+    ///
+    /// # Panics
+    ///
+    /// This expects an existing [CallTrace], in other words, this panics if not within the context
+    /// of a call.
+    fn start_step<DB: Database>(&mut self, interp: &mut Interpreter, data: &mut EVMData<'_, DB>) {
+        let trace_idx = self.last_trace_idx();
+        let trace = &mut self.traces.arena[trace_idx];
+
+        self.step_stack.push(StackStep { trace_idx, step_idx: trace.trace.steps.len() });
+
+        let pc = interp.program_counter();
+
+        let memory =
+            self.config.record_memory_snapshots.then(|| interp.memory.clone()).unwrap_or_default();
+        let stack =
+            self.config.record_stack_snapshots.then(|| interp.stack.clone()).unwrap_or_default();
+
+        trace.trace.steps.push(CallTraceStep {
+            depth: data.journaled_state.depth(),
+            pc,
+            op: OpCode::try_from_u8(interp.contract.bytecode.bytecode()[pc])
+                .expect("is valid opcode;"),
+            contract: interp.contract.address,
+            stack,
+            memory,
+            memory_size: interp.memory.len(),
+            gas: self.gas_inspector.as_ref().gas_remaining(),
+            gas_refund_counter: interp.gas.refunded() as u64,
+
+            // fields will be populated end of call
+            gas_cost: 0,
+            state_diff: None,
+            status: InstructionResult::Continue,
+        });
+    }
+
+    /// Fills the current trace with the output of a step.
+    ///
+    /// Invoked on [Inspector::step_end].
+    fn fill_step_on_step_end<DB: Database>(
+        &mut self,
+        interp: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        status: InstructionResult,
+    ) {
+        let StackStep { trace_idx, step_idx } =
+            self.step_stack.pop().expect("can't fill step without starting a step first");
+        let step = &mut self.traces.arena[trace_idx].trace.steps[step_idx];
+
+        if let Some(pc) = interp.program_counter().checked_sub(1) {
+            if self.config.record_state_diff {
+                let op = interp.contract.bytecode.bytecode()[pc];
+
+                let journal_entry = data
+                    .journaled_state
+                    .journal
+                    .last()
+                    // This should always work because revm initializes it as `vec![vec![]]`
+                    // See [JournaledState::new](revm::JournaledState)
+                    .expect("exists; initialized with vec")
+                    .last();
+
+                step.state_diff = match (op, journal_entry) {
+                    (
+                        opcode::SLOAD | opcode::SSTORE,
+                        Some(JournalEntry::StorageChange { address, key, .. }),
+                    ) => {
+                        // SAFETY: (Address,key) exists if part if StorageChange
+                        let value =
+                            data.journaled_state.state[address].storage[key].present_value();
+                        Some((*key, value))
+                    }
+                    _ => None,
+                };
+            }
+
+            step.gas_cost = step.gas - self.gas_inspector.as_ref().gas_remaining();
+        }
+
+        // set the status
+        step.status = status;
+    }
+}
+
+impl<DB> Inspector<DB> for TracingInspector
+where
+    DB: Database,
+{
+    fn initialize_interp(
+        &mut self,
+        interp: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+    ) -> InstructionResult {
+        self.gas_inspector.initialize_interp(interp, data, is_static)
+    }
+
+    fn step(
+        &mut self,
+        interp: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+    ) -> InstructionResult {
+        if self.config.record_steps {
+            self.gas_inspector.step(interp, data, is_static);
+            self.start_step(interp, data);
+        }
+
+        InstructionResult::Continue
+    }
+
+    fn log(
+        &mut self,
+        evm_data: &mut EVMData<'_, DB>,
+        address: &Address,
+        topics: &[H256],
+        data: &Bytes,
+    ) {
+        self.gas_inspector.log(evm_data, address, topics, data);
+
+        let trace_idx = self.last_trace_idx();
+        let trace = &mut self.traces.arena[trace_idx];
+        trace.ordering.push(LogCallOrder::Log(trace.logs.len()));
+        trace.logs.push(RawLog { topics: topics.to_vec(), data: data.clone() });
+    }
+
+    fn step_end(
+        &mut self,
+        interp: &mut Interpreter,
+        data: &mut EVMData<'_, DB>,
+        is_static: bool,
+        eval: InstructionResult,
+    ) -> InstructionResult {
+        if self.config.record_steps {
+            self.gas_inspector.step_end(interp, data, is_static, eval);
+            self.fill_step_on_step_end(interp, data, eval);
+            return eval
+        }
+        InstructionResult::Continue
+    }
+
+    fn call(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &mut CallInputs,
+        is_static: bool,
+    ) -> (InstructionResult, Gas, Bytes) {
+        self.gas_inspector.call(data, inputs, is_static);
+
+        // determine correct `from` and `to`  based on the call scheme
+        let (from, to) = match inputs.context.scheme {
+            CallScheme::DelegateCall | CallScheme::CallCode => {
+                (inputs.context.address, inputs.context.code_address)
+            }
+            _ => (inputs.context.caller, inputs.context.address),
+        };
+
+        self.start_trace_on_call(
+            data.journaled_state.depth() as usize,
+            to,
+            inputs.input.clone(),
+            inputs.transfer.value,
+            inputs.context.scheme.into(),
+            from,
+        );
+
+        (InstructionResult::Continue, Gas::new(0), Bytes::new())
+    }
+
+    fn call_end(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &CallInputs,
+        gas: Gas,
+        ret: InstructionResult,
+        out: Bytes,
+        is_static: bool,
+    ) -> (InstructionResult, Gas, Bytes) {
+        self.gas_inspector.call_end(data, inputs, gas, ret, out.clone(), is_static);
+
+        self.fill_trace_on_call_end(
+            ret,
+            gas_used(data.env.cfg.spec_id, gas.spend(), gas.refunded() as u64),
+            out.clone(),
+            None,
+        );
+
+        (ret, gas, out)
+    }
+
+    fn create(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &mut CreateInputs,
+    ) -> (InstructionResult, Option<Address>, Gas, Bytes) {
+        self.gas_inspector.create(data, inputs);
+
+        let _ = data.journaled_state.load_account(inputs.caller, data.db);
+        let nonce = data.journaled_state.account(inputs.caller).info.nonce;
+        self.start_trace_on_call(
+            data.journaled_state.depth() as usize,
+            get_create_address(inputs, nonce),
+            inputs.init_code.clone(),
+            inputs.value,
+            inputs.scheme.into(),
+            inputs.caller,
+        );
+
+        (InstructionResult::Continue, None, Gas::new(inputs.gas_limit), Bytes::default())
+    }
+
+    /// Called when a contract has been created.
+    ///
+    /// InstructionResulting anything other than the values passed to this function (`(ret,
+    /// remaining_gas, address, out)`) will alter the result of the create.
+    fn create_end(
+        &mut self,
+        data: &mut EVMData<'_, DB>,
+        inputs: &CreateInputs,
+        status: InstructionResult,
+        address: Option<Address>,
+        gas: Gas,
+        retdata: Bytes,
+    ) -> (InstructionResult, Option<Address>, Gas, Bytes) {
+        self.gas_inspector.create_end(data, inputs, status, address, gas, retdata.clone());
+
+        // get the code of the created contract
+        let code = address
+            .and_then(|address| {
+                data.journaled_state
+                    .account(address)
+                    .info
+                    .code
+                    .as_ref()
+                    .map(|code| code.bytes()[..code.len()].to_vec())
+            })
+            .unwrap_or_default();
+
+        self.fill_trace_on_call_end(
+            status,
+            gas_used(data.env.cfg.spec_id, gas.spend(), gas.refunded() as u64),
+            code.into(),
+            address,
+        );
+
+        (status, address, gas, retdata)
+    }
+
+    fn selfdestruct(&mut self, _contract: Address, target: Address) {
+        let trace_idx = self.last_trace_idx();
+        let trace = &mut self.traces.arena[trace_idx].trace;
+        trace.selfdestruct_refund_target = Some(target)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct StackStep {
+    trace_idx: usize,
+    step_idx: usize,
+}
diff --git a/crates/revm/revm-inspectors/src/tracing/types.rs b/crates/revm/revm-inspectors/src/tracing/types.rs
new file mode 100644
index 00000000000..723e065f63b
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/types.rs
@@ -0,0 +1,292 @@
+//! Types for representing call trace items.
+
+use crate::tracing::utils::convert_memory;
+use reth_primitives::{bytes::Bytes, Address, H256, U256};
+use reth_rpc_types::trace::{
+    geth::StructLog,
+    parity::{
+        Action, ActionType, CallAction, CallOutput, CallType, CreateAction, CreateOutput,
+        SelfdestructAction, TraceOutput,
+    },
+};
+use revm::interpreter::{
+    CallContext, CallScheme, CreateScheme, InstructionResult, Memory, OpCode, Stack,
+};
+use serde::{Deserialize, Serialize};
+
+/// A unified representation of a call
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "UPPERCASE")]
+#[allow(missing_docs)]
+pub enum CallKind {
+    #[default]
+    Call,
+    StaticCall,
+    CallCode,
+    DelegateCall,
+    Create,
+    Create2,
+}
+
+impl From<CallScheme> for CallKind {
+    fn from(scheme: CallScheme) -> Self {
+        match scheme {
+            CallScheme::Call => CallKind::Call,
+            CallScheme::StaticCall => CallKind::StaticCall,
+            CallScheme::CallCode => CallKind::CallCode,
+            CallScheme::DelegateCall => CallKind::DelegateCall,
+        }
+    }
+}
+
+impl From<CreateScheme> for CallKind {
+    fn from(create: CreateScheme) -> Self {
+        match create {
+            CreateScheme::Create => CallKind::Create,
+            CreateScheme::Create2 { .. } => CallKind::Create2,
+        }
+    }
+}
+
+impl From<CallKind> for ActionType {
+    fn from(kind: CallKind) -> Self {
+        match kind {
+            CallKind::Call | CallKind::StaticCall | CallKind::DelegateCall | CallKind::CallCode => {
+                ActionType::Call
+            }
+            CallKind::Create => ActionType::Create,
+            CallKind::Create2 => ActionType::Create,
+        }
+    }
+}
+
+impl From<CallKind> for CallType {
+    fn from(ty: CallKind) -> Self {
+        match ty {
+            CallKind::Call => CallType::Call,
+            CallKind::StaticCall => CallType::StaticCall,
+            CallKind::CallCode => CallType::CallCode,
+            CallKind::DelegateCall => CallType::DelegateCall,
+            CallKind::Create => CallType::None,
+            CallKind::Create2 => CallType::None,
+        }
+    }
+}
+
+/// A trace of a call.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct CallTrace {
+    /// The depth of the call
+    pub(crate) depth: usize,
+    /// Whether the call was successful
+    pub(crate) success: bool,
+    /// caller of this call
+    pub(crate) caller: Address,
+    /// The destination address of the call or the address from the created contract.
+    ///
+    /// In other words, this is the callee if the [CallKind::Call] or the address of the created
+    /// contract if [CallKind::Create].
+    pub(crate) address: Address,
+    /// Holds the target for the selfdestruct refund target if `status` is
+    /// [InstructionResult::SelfDestruct]
+    pub(crate) selfdestruct_refund_target: Option<Address>,
+    /// The kind of call this is
+    pub(crate) kind: CallKind,
+    /// The value transferred in the call
+    pub(crate) value: U256,
+    /// The calldata for the call, or the init code for contract creations
+    pub(crate) data: Bytes,
+    /// The return data of the call if this was not a contract creation, otherwise it is the
+    /// runtime bytecode of the created contract
+    pub(crate) output: Bytes,
+    /// The return data of the last call, if any
+    pub(crate) last_call_return_value: Option<Bytes>,
+    /// The gas cost of the call
+    pub(crate) gas_used: u64,
+    /// The status of the trace's call
+    pub(crate) status: InstructionResult,
+    /// call context of the runtime
+    pub(crate) call_context: Option<CallContext>,
+    /// Opcode-level execution steps
+    pub(crate) steps: Vec<CallTraceStep>,
+}
+
+impl Default for CallTrace {
+    fn default() -> Self {
+        Self {
+            depth: Default::default(),
+            success: Default::default(),
+            caller: Default::default(),
+            address: Default::default(),
+            selfdestruct_refund_target: None,
+            kind: Default::default(),
+            value: Default::default(),
+            data: Default::default(),
+            output: Default::default(),
+            last_call_return_value: None,
+            gas_used: Default::default(),
+            status: InstructionResult::Continue,
+            call_context: Default::default(),
+            steps: Default::default(),
+        }
+    }
+}
+
+/// A node in the arena
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CallTraceNode {
+    /// Parent node index in the arena
+    pub(crate) parent: Option<usize>,
+    /// Children node indexes in the arena
+    pub(crate) children: Vec<usize>,
+    /// This node's index in the arena
+    pub(crate) idx: usize,
+    /// The call trace
+    pub(crate) trace: CallTrace,
+    /// Logs
+    pub(crate) logs: Vec<RawLog>,
+    /// Ordering of child calls and logs
+    pub(crate) ordering: Vec<LogCallOrder>,
+}
+
+impl CallTraceNode {
+    /// Returns the kind of call the trace belongs to
+    pub(crate) fn kind(&self) -> CallKind {
+        self.trace.kind
+    }
+
+    /// Returns the status of the call
+    pub(crate) fn status(&self) -> InstructionResult {
+        self.trace.status
+    }
+
+    /// Returns the `Output` for a parity trace
+    pub(crate) fn parity_trace_output(&self) -> TraceOutput {
+        match self.kind() {
+            CallKind::Call | CallKind::StaticCall | CallKind::CallCode | CallKind::DelegateCall => {
+                TraceOutput::Call(CallOutput {
+                    gas_used: self.trace.gas_used.into(),
+                    output: self.trace.output.clone().into(),
+                })
+            }
+            CallKind::Create | CallKind::Create2 => TraceOutput::Create(CreateOutput {
+                gas_used: self.trace.gas_used.into(),
+                code: self.trace.output.clone().into(),
+                address: self.trace.address,
+            }),
+        }
+    }
+
+    /// Returns the `Action` for a parity trace
+    pub(crate) fn parity_action(&self) -> Action {
+        if self.status() == InstructionResult::SelfDestruct {
+            return Action::Selfdestruct(SelfdestructAction {
+                address: self.trace.address,
+                refund_address: self.trace.selfdestruct_refund_target.unwrap_or_default(),
+                balance: self.trace.value,
+            })
+        }
+        match self.kind() {
+            CallKind::Call | CallKind::StaticCall | CallKind::CallCode | CallKind::DelegateCall => {
+                Action::Call(CallAction {
+                    from: self.trace.caller,
+                    to: self.trace.address,
+                    value: self.trace.value,
+                    gas: self.trace.gas_used.into(),
+                    input: self.trace.data.clone().into(),
+                    call_type: self.kind().into(),
+                })
+            }
+            CallKind::Create | CallKind::Create2 => Action::Create(CreateAction {
+                from: self.trace.caller,
+                value: self.trace.value,
+                gas: self.trace.gas_used.into(),
+                init: self.trace.data.clone().into(),
+            }),
+        }
+    }
+}
+
+/// Ordering enum for calls and logs
+///
+/// i.e. if Call 0 occurs before Log 0, it will be pushed into the `CallTraceNode`'s ordering before
+/// the log.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum LogCallOrder {
+    Log(usize),
+    Call(usize),
+}
+
+/// Ethereum log.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RawLog {
+    /// Indexed event params are represented as log topics.
+    pub(crate) topics: Vec<H256>,
+    /// Others are just plain data.
+    pub(crate) data: Bytes,
+}
+
+/// Represents a tracked call step during execution
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CallTraceStep {
+    // Fields filled in `step`
+    /// Call depth
+    pub depth: u64,
+    /// Program counter before step execution
+    pub pc: usize,
+    /// Opcode to be executed
+    pub op: OpCode,
+    /// Current contract address
+    pub contract: Address,
+    /// Stack before step execution
+    pub stack: Stack,
+    /// Memory before step execution
+    pub memory: Memory,
+    /// Size of memory
+    pub memory_size: usize,
+    /// Remaining gas before step execution
+    pub gas: u64,
+    /// Gas refund counter before step execution
+    pub gas_refund_counter: u64,
+    // Fields filled in `step_end`
+    /// Gas cost of step execution
+    pub gas_cost: u64,
+    /// Change of the contract state after step execution (effect of the SLOAD/SSTORE instructions)
+    pub state_diff: Option<(U256, U256)>,
+    /// Final status of the call
+    pub status: InstructionResult,
+}
+
+// === impl CallTraceStep ===
+
+impl CallTraceStep {
+    // Returns true if the status code is an error or revert, See [InstructionResult::Revert]
+    pub fn is_error(&self) -> bool {
+        self.status as u8 >= InstructionResult::Revert as u8
+    }
+
+    /// Returns the error message if it is an erroneous result.
+    pub fn as_error(&self) -> Option<String> {
+        self.is_error().then(|| format!("{:?}", self.status))
+    }
+}
+
+impl From<&CallTraceStep> for StructLog {
+    fn from(step: &CallTraceStep) -> Self {
+        StructLog {
+            depth: step.depth,
+            error: step.as_error(),
+            gas: step.gas,
+            gas_cost: step.gas_cost,
+            memory: Some(convert_memory(step.memory.data())),
+            op: step.op.to_string(),
+            pc: step.pc as u64,
+            refund_counter: (step.gas_refund_counter > 0).then_some(step.gas_refund_counter),
+            stack: Some(step.stack.data().clone()),
+            // Filled in `CallTraceArena::geth_trace` as a result of compounding all slot changes
+            return_data: None,
+            storage: None,
+            memory_size: step.memory_size as u64,
+        }
+    }
+}
diff --git a/crates/revm/revm-inspectors/src/tracing/utils.rs b/crates/revm/revm-inspectors/src/tracing/utils.rs
new file mode 100644
index 00000000000..64468f82502
--- /dev/null
+++ b/crates/revm/revm-inspectors/src/tracing/utils.rs
@@ -0,0 +1,40 @@
+//! Util functions for revm related ops
+
+use reth_primitives::{
+    contract::{create2_address_from_code, create_address},
+    hex, Address,
+};
+use revm::{
+    interpreter::CreateInputs,
+    primitives::{CreateScheme, SpecId},
+};
+
+/// creates the memory data in 32byte chunks
+/// see <https://github.com/ethereum/go-ethereum/blob/366d2169fbc0e0f803b68c042b77b6b480836dbc/eth/tracers/logger/logger.go#L450-L452>
+#[inline]
+pub(crate) fn convert_memory(data: &[u8]) -> Vec<String> {
+    let mut memory = Vec::with_capacity((data.len() + 31) / 32);
+    for idx in (0..data.len()).step_by(32) {
+        let len = std::cmp::min(idx + 32, data.len());
+        memory.push(hex::encode(&data[idx..len]));
+    }
+    memory
+}
+
+/// Get the gas used, accounting for refunds
+#[inline]
+pub(crate) fn gas_used(spec: SpecId, spent: u64, refunded: u64) -> u64 {
+    let refund_quotient = if SpecId::enabled(spec, SpecId::LONDON) { 5 } else { 2 };
+    spent - (refunded).min(spent / refund_quotient)
+}
+
+/// Get the address of a contract creation
+#[inline]
+pub(crate) fn get_create_address(call: &CreateInputs, nonce: u64) -> Address {
+    match call.scheme {
+        CreateScheme::Create => create_address(call.caller, nonce),
+        CreateScheme::Create2 { salt } => {
+            create2_address_from_code(call.caller, call.init_code.clone(), salt)
+        }
+    }
+}
diff --git a/crates/revm/revm-primitives/Cargo.toml b/crates/revm/revm-primitives/Cargo.toml
index 87ba3ea0bfe..87bb93c1341 100644
--- a/crates/revm/revm-primitives/Cargo.toml
+++ b/crates/revm/revm-primitives/Cargo.toml
@@ -11,4 +11,4 @@ reth-primitives = { path = "../../primitives" }
 revm = { version = "3.0.0" }
 
 [features]
-optimism = []
+optimism = ["reth-primitives/optimism"]
diff --git a/crates/revm/revm-primitives/src/compat.rs b/crates/revm/revm-primitives/src/compat.rs
index b581b871668..35aaa4eb5a4 100644
--- a/crates/revm/revm-primitives/src/compat.rs
+++ b/crates/revm/revm-primitives/src/compat.rs
@@ -29,6 +29,6 @@ pub fn to_reth_acc(revm_acc: &AccountInfo) -> Account {
     Account {
         balance: revm_acc.balance,
         nonce: revm_acc.nonce,
-        bytecode_hash: if code_hash == KECCAK_EMPTY { None } else { Some(code_hash) },
+        bytecode_hash: (code_hash != KECCAK_EMPTY).then_some(code_hash),
     }
 }
diff --git a/crates/revm/revm-primitives/src/env.rs b/crates/revm/revm-primitives/src/env.rs
index 74445f70481..712fe7cf75d 100644
--- a/crates/revm/revm-primitives/src/env.rs
+++ b/crates/revm/revm-primitives/src/env.rs
@@ -1,23 +1,24 @@
 use crate::config::revm_spec;
 use reth_primitives::{
-    Address, ChainSpec, Head, Header, Transaction, TransactionKind, TransactionSigned, TxEip1559,
-    TxEip2930, TxLegacy, U256,
+    Address, ChainSpec, Head, Header, Transaction, TransactionKind, TransactionSignedEcRecovered,
+    TxEip1559, TxEip2930, TxLegacy, U256,
 };
-use revm::primitives::{AnalysisKind, BlockEnv, CfgEnv, Env, SpecId, TransactTo, TxEnv};
+use revm::primitives::{AnalysisKind, BlockEnv, CfgEnv, SpecId, TransactTo, TxEnv};
 
 #[cfg(feature = "optimism")]
 use reth_primitives::TxDeposit;
 
 /// Convenience function to call both [fill_cfg_env] and [fill_block_env]
 pub fn fill_cfg_and_block_env(
-    env: &mut Env,
+    cfg: &mut CfgEnv,
+    block_env: &mut BlockEnv,
     chain_spec: &ChainSpec,
     header: &Header,
     total_difficulty: U256,
 ) {
-    fill_cfg_env(&mut env.cfg, chain_spec, header, total_difficulty);
-    let after_merge = env.cfg.spec_id >= SpecId::MERGE;
-    fill_block_env(&mut env.block, header, after_merge);
+    fill_cfg_env(cfg, chain_spec, header, total_difficulty);
+    let after_merge = cfg.spec_id >= SpecId::MERGE;
+    fill_block_env(block_env, header, after_merge);
 }
 
 /// Fill [CfgEnv] fields according to the chain spec and given header
@@ -41,7 +42,7 @@ pub fn fill_cfg_env(
     cfg_env.chain_id = U256::from(chain_spec.chain().id());
     cfg_env.spec_id = spec_id;
     cfg_env.perf_all_precompiles_have_balance = false;
-    cfg_env.perf_analyse_created_bytecodes = AnalysisKind::Raw;
+    cfg_env.perf_analyse_created_bytecodes = AnalysisKind::Analyse;
 }
 /// Fill block environment from Block.
 pub fn fill_block_env(block_env: &mut BlockEnv, header: &Header, after_merge: bool) {
@@ -59,28 +60,25 @@ pub fn fill_block_env(block_env: &mut BlockEnv, header: &Header, after_merge: bo
     block_env.gas_limit = U256::from(header.gas_limit);
 }
 
-/// Fill transaction environment from Transaction.
-pub fn fill_tx_env(tx_env: &mut TxEnv, transaction: &TransactionSigned, sender: Address) {
+/// Returns a new [TxEnv] filled with the transaction's data.
+pub fn tx_env_with_recovered(transaction: &TransactionSignedEcRecovered) -> TxEnv {
+    let mut tx_env = TxEnv::default();
+    fill_tx_env(&mut tx_env, transaction.as_ref(), transaction.signer());
+    tx_env
+}
+
+/// Fill transaction environment from [TransactionSignedEcRecovered].
+pub fn fill_tx_env_with_recovered(tx_env: &mut TxEnv, transaction: &TransactionSignedEcRecovered) {
+    fill_tx_env(tx_env, transaction.as_ref(), transaction.signer())
+}
+
+/// Fill transaction environment from a [Transaction] and the given sender address.
+pub fn fill_tx_env<T>(tx_env: &mut TxEnv, transaction: T, sender: Address)
+where
+    T: AsRef<Transaction>,
+{
     tx_env.caller = sender;
     match transaction.as_ref() {
-        #[cfg(feature = "optimism")]
-        Transaction::Deposit(TxDeposit { to, mint, value, gas_limit, input, .. }) => {
-            tx_env.gas_limit = *gas_limit;
-            if let Some(m) = mint {
-                tx_env.gas_price = U256::from(*m);
-            } else {
-                tx_env.gas_price = U256::ZERO;
-            }
-            tx_env.gas_priority_fee = None;
-            match to {
-                TransactionKind::Call(to) => tx_env.transact_to = TransactTo::Call(*to),
-                TransactionKind::Create => tx_env.transact_to = TransactTo::create(),
-            }
-            tx_env.value = U256::from(*value);
-            tx_env.data = input.0.clone();
-            tx_env.chain_id = None;
-            tx_env.nonce = None;
-        }
         Transaction::Legacy(TxLegacy {
             nonce,
             chain_id,
@@ -101,6 +99,7 @@ pub fn fill_tx_env(tx_env: &mut TxEnv, transaction: &TransactionSigned, sender:
             tx_env.data = input.0.clone();
             tx_env.chain_id = *chain_id;
             tx_env.nonce = Some(*nonce);
+            tx_env.access_list.clear();
         }
         Transaction::Eip2930(TxEip2930 {
             nonce,
@@ -173,5 +172,23 @@ pub fn fill_tx_env(tx_env: &mut TxEnv, transaction: &TransactionSigned, sender:
                 })
                 .collect();
         }
+        #[cfg(feature = "optimism")]
+        Transaction::Deposit(TxDeposit { to, mint, value, gas_limit, input, .. }) => {
+            tx_env.gas_limit = *gas_limit;
+            if let Some(m) = mint {
+                tx_env.gas_price = U256::from(*m);
+            } else {
+                tx_env.gas_price = U256::ZERO;
+            }
+            tx_env.gas_priority_fee = None;
+            match to {
+                TransactionKind::Call(to) => tx_env.transact_to = TransactTo::Call(*to),
+                TransactionKind::Create => tx_env.transact_to = TransactTo::create(),
+            }
+            tx_env.value = U256::from(*value);
+            tx_env.data = input.0.clone();
+            tx_env.chain_id = None;
+            tx_env.nonce = None;
+        }
     }
 }
diff --git a/crates/revm/revm-primitives/src/lib.rs b/crates/revm/revm-primitives/src/lib.rs
index a989c0b65e3..80537049460 100644
--- a/crates/revm/revm-primitives/src/lib.rs
+++ b/crates/revm/revm-primitives/src/lib.rs
@@ -6,7 +6,6 @@
 ))]
 
 //! revm utils and implementations specific to reth.
-
 pub mod config;
 
 /// Helpers for configuring revm [Env](revm::primitives::Env)
diff --git a/crates/revm/src/database.rs b/crates/revm/src/database.rs
index c90a7b111b0..1698b5500d6 100644
--- a/crates/revm/src/database.rs
+++ b/crates/revm/src/database.rs
@@ -49,19 +49,9 @@ impl<DB: StateProvider> DatabaseRef for State<DB> {
     fn code_by_hash(&self, code_hash: H256) -> Result<Bytecode, Self::Error> {
         let bytecode = self.0.bytecode_by_hash(code_hash)?;
 
-        // SAFETY: We are requesting the code by its hash, so it is almost tautological why this
-        // would be safe. If the bytecode is not found, we return an empty bytecode with the
-        // appropriate hash.
-        //
-        // In an ideal world we would return analysed bytecode here, but analysed bytecode in revm
-        // depends on the current active hard fork, since it calculates gas blocks...
         if let Some(bytecode) = bytecode {
-            Ok(unsafe { Bytecode::new_raw_with_hash(bytecode.0, code_hash) })
+            Ok(bytecode.with_code_hash(code_hash).0)
         } else {
-            // NOTE(onbjerg): This corresponds to an empty analysed bytecode with a hash of
-            // `KECCAK_EMPTY`. In the case where the bytecode is not found, we would
-            // return empty bytes anyway: this simply skips the hashing and analysis steps, which
-            // would otherwise be present if we simply did an `.unwrap_or_default()` above.
             Ok(Bytecode::new())
         }
     }
@@ -73,6 +63,7 @@ impl<DB: StateProvider> DatabaseRef for State<DB> {
     }
 
     fn block_hash(&self, number: U256) -> Result<H256, Self::Error> {
-        Ok(self.0.block_hash(number)?.unwrap_or_default())
+        // Note: this unwrap is potentially unsafe
+        Ok(self.0.block_hash(number.try_into().unwrap())?.unwrap_or_default())
     }
 }
diff --git a/crates/revm/src/lib.rs b/crates/revm/src/lib.rs
index 21cc3790af8..c4541a2ee88 100644
--- a/crates/revm/src/lib.rs
+++ b/crates/revm/src/lib.rs
@@ -10,5 +10,10 @@
 /// Contains glue code for integrating reth database into revm's [Database](revm::Database).
 pub mod database;
 
+/// reexport for convenience
+pub use reth_revm_inspectors::*;
 /// reexport for convenience
 pub use reth_revm_primitives::*;
+
+/// Re-export everything
+pub use revm;
diff --git a/crates/rlp/Cargo.toml b/crates/rlp/Cargo.toml
index c3554660590..606d74b0333 100644
--- a/crates/rlp/Cargo.toml
+++ b/crates/rlp/Cargo.toml
@@ -12,10 +12,8 @@ auto_impl = "1"
 bytes = { version = "1", default-features = false }
 ethnum = { version = "1", default-features = false, optional = true }
 smol_str = { version = "0.1", default-features = false, optional = true }
-enr = { version = "0.7", default-features = false, optional = true }
-rlp = { version = "0.5.2", default-features = false, optional = true }
 ethereum-types = { version = "0.14", features = ["codec"], optional = true }
-revm-primitives = {version = "1.0.0", features = ["serde"] }
+revm-primitives = { version = "1.0.0", features = ["serde"] }
 reth-rlp-derive = { version = "0.1", path = "./rlp-derive", optional = true }
 
 [dev-dependencies]
@@ -24,22 +22,16 @@ reth-rlp = { path = ".", package = "reth-rlp", features = [
     "std",
     "ethnum",
     "ethereum-types",
-    "enr",
     "smol_str"
 ] }
 criterion = "0.4.0"
 hex-literal = "0.3"
-rand = "0.8"
-secp256k1 = { version = "0.24", features = [
-    "rand-std",
-] }
 pprof = { version = "0.11", features = ["flamegraph", "frame-pointer", "criterion"] }
 
 [features]
 alloc = []
 derive = ["reth-rlp-derive"]
 std = ["alloc"]
-enr = ["dep:enr", "dep:rlp", "enr/rust-secp256k1", "derive"]
 
 [[bench]]
 name = "bench"
diff --git a/crates/rlp/rlp-derive/src/lib.rs b/crates/rlp/rlp-derive/src/lib.rs
index 24737a8ae7c..a23fe79c1d9 100644
--- a/crates/rlp/rlp-derive/src/lib.rs
+++ b/crates/rlp/rlp-derive/src/lib.rs
@@ -1,5 +1,5 @@
 #![warn(missing_docs, unreachable_pub)]
-#![deny(unused_must_use)]
+#![deny(unused_must_use, unused_crate_dependencies)]
 #![doc(test(
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
diff --git a/crates/rlp/src/decode.rs b/crates/rlp/src/decode.rs
index d152d87087e..94d466612bf 100644
--- a/crates/rlp/src/decode.rs
+++ b/crates/rlp/src/decode.rs
@@ -448,39 +448,6 @@ impl Decodable for smol_str::SmolStr {
     }
 }
 
-#[cfg(feature = "enr")]
-impl<K> Decodable for enr::Enr<K>
-where
-    K: enr::EnrKey,
-{
-    fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
-        // currently the only way to build an enr is to decode it using the rlp::Decodable trait
-        let enr = <Self as rlp::Decodable>::decode(&rlp::Rlp::new(buf)).map_err(|e| match e {
-            rlp::DecoderError::RlpIsTooShort => DecodeError::InputTooShort,
-            rlp::DecoderError::RlpInvalidLength => DecodeError::Overflow,
-            rlp::DecoderError::RlpExpectedToBeList => DecodeError::UnexpectedString,
-            rlp::DecoderError::RlpExpectedToBeData => DecodeError::UnexpectedList,
-            rlp::DecoderError::RlpDataLenWithZeroPrefix |
-            rlp::DecoderError::RlpListLenWithZeroPrefix => DecodeError::LeadingZero,
-            rlp::DecoderError::RlpInvalidIndirection => DecodeError::NonCanonicalSize,
-            rlp::DecoderError::RlpIncorrectListLen => {
-                DecodeError::Custom("incorrect list length when decoding rlp")
-            }
-            rlp::DecoderError::RlpIsTooBig => DecodeError::Custom("rlp is too big"),
-            rlp::DecoderError::RlpInconsistentLengthAndData => {
-                DecodeError::Custom("inconsistent length and data when decoding rlp")
-            }
-            rlp::DecoderError::Custom(s) => DecodeError::Custom(s),
-        });
-        if enr.is_ok() {
-            // Decode was successful, advance buffer
-            let header = Header::decode(buf)?;
-            buf.advance(header.payload_length);
-        }
-        enr
-    }
-}
-
 #[cfg(test)]
 mod tests {
     extern crate alloc;
@@ -699,68 +666,4 @@ mod tests {
             (Err(DecodeError::UnexpectedList), &hex!("C0")[..]),
         ])
     }
-
-    // test vector from the enr library rlp encoding tests
-    // <https://github.com/sigp/enr/blob/e59dcb45ea07e423a7091d2a6ede4ad6d8ef2840/src/lib.rs#L1019>
-    #[cfg(feature = "enr")]
-    #[test]
-    fn decode_enr_rlp() {
-        use enr::{secp256k1::SecretKey, Enr, EnrPublicKey};
-        use std::net::Ipv4Addr;
-
-        let valid_record = hex!("f884b8407098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c01826964827634826970847f00000189736563703235366b31a103ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31388375647082765f");
-        let signature = hex!("7098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c");
-        let expected_pubkey =
-            hex!("03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138");
-
-        let mut valid_record_buf = valid_record.as_slice();
-        let enr = Enr::<SecretKey>::decode(&mut valid_record_buf).unwrap();
-        let pubkey = enr.public_key().encode();
-
-        // Byte array must be consumed after enr has finished decoding
-        assert!(valid_record_buf.is_empty());
-
-        assert_eq!(enr.ip4(), Some(Ipv4Addr::new(127, 0, 0, 1)));
-        assert_eq!(enr.id(), Some(String::from("v4")));
-        assert_eq!(enr.udp4(), Some(30303));
-        assert_eq!(enr.tcp4(), None);
-        assert_eq!(enr.signature(), &signature[..]);
-        assert_eq!(pubkey.to_vec(), expected_pubkey);
-        assert!(enr.verify());
-    }
-
-    // test vector from the enr library rlp encoding tests
-    // <https://github.com/sigp/enr/blob/e59dcb45ea07e423a7091d2a6ede4ad6d8ef2840/src/lib.rs#LL1206C35-L1206C35>
-    #[cfg(feature = "enr")]
-    #[test]
-    fn encode_decode_enr_rlp() {
-        use enr::{secp256k1::SecretKey, Enr, EnrBuilder, EnrKey, EnrPublicKey};
-        use std::net::Ipv4Addr;
-
-        let key = SecretKey::new(&mut rand::rngs::OsRng);
-        let ip = Ipv4Addr::new(127, 0, 0, 1);
-        let tcp = 3000;
-
-        let enr = {
-            let mut builder = EnrBuilder::new("v4");
-            builder.ip(ip.into());
-            builder.tcp4(tcp);
-            builder.build(&key).unwrap()
-        };
-
-        let mut encoded = BytesMut::new();
-        enr.encode(&mut encoded);
-        let mut encoded_bytes = &encoded[..];
-        let decoded_enr = Enr::<SecretKey>::decode(&mut encoded_bytes).unwrap();
-
-        // Byte array must be consumed after enr has finished decoding
-        assert!(encoded_bytes.is_empty());
-
-        assert_eq!(decoded_enr, enr);
-        assert_eq!(decoded_enr.id(), Some("v4".into()));
-        assert_eq!(decoded_enr.ip4(), Some(ip));
-        assert_eq!(decoded_enr.tcp4(), Some(tcp));
-        assert_eq!(decoded_enr.public_key().encode(), key.public().encode());
-        assert!(decoded_enr.verify());
-    }
 }
diff --git a/crates/rlp/src/encode.rs b/crates/rlp/src/encode.rs
index 98c00d61e8b..73f62c01afa 100644
--- a/crates/rlp/src/encode.rs
+++ b/crates/rlp/src/encode.rs
@@ -70,7 +70,12 @@ macro_rules! impl_max_encoded_len {
 #[auto_impl(&)]
 #[cfg_attr(feature = "alloc", auto_impl(Box, Arc))]
 pub trait Encodable {
+    /// Appends the rlp encoded object to the specified output buffer.
     fn encode(&self, out: &mut dyn BufMut);
+
+    /// Returns the length of the encoded object.
+    ///
+    /// NOTE: This includes the length of the rlp [Header].
     fn length(&self) -> usize {
         let mut out = BytesMut::new();
         self.encode(&mut out);
@@ -79,6 +84,13 @@ pub trait Encodable {
 }
 
 impl<'a> Encodable for &'a [u8] {
+    fn encode(&self, out: &mut dyn BufMut) {
+        if self.len() != 1 || self[0] >= EMPTY_STRING_CODE {
+            Header { list: false, payload_length: self.len() }.encode(out);
+        }
+        out.put_slice(self);
+    }
+
     fn length(&self) -> usize {
         let mut len = self.len();
         if self.len() != 1 || self[0] >= EMPTY_STRING_CODE {
@@ -86,23 +98,16 @@ impl<'a> Encodable for &'a [u8] {
         }
         len
     }
+}
 
+impl<const LEN: usize> Encodable for [u8; LEN] {
     fn encode(&self, out: &mut dyn BufMut) {
-        if self.len() != 1 || self[0] >= EMPTY_STRING_CODE {
-            Header { list: false, payload_length: self.len() }.encode(out);
-        }
-        out.put_slice(self);
+        (self as &[u8]).encode(out)
     }
-}
 
-impl<const LEN: usize> Encodable for [u8; LEN] {
     fn length(&self) -> usize {
         (self as &[u8]).length()
     }
-
-    fn encode(&self, out: &mut dyn BufMut) {
-        (self as &[u8]).encode(out)
-    }
 }
 
 unsafe impl<const LEN: usize> MaxEncodedLenAssoc for [u8; LEN] {
@@ -164,13 +169,13 @@ encodable_uint!(u128);
 max_encoded_len_uint!(u128);
 
 impl Encodable for bool {
-    fn length(&self) -> usize {
-        (*self as u8).length()
-    }
-
     fn encode(&self, out: &mut dyn BufMut) {
         (*self as u8).encode(out)
     }
+
+    fn length(&self) -> usize {
+        (*self as u8).length()
+    }
 }
 
 impl_max_encoded_len!(bool, { <u8 as MaxEncodedLenAssoc>::LEN });
@@ -185,38 +190,6 @@ impl Encodable for smol_str::SmolStr {
     }
 }
 
-#[cfg(feature = "enr")]
-impl<K> Encodable for enr::Enr<K>
-where
-    K: enr::EnrKey,
-{
-    fn encode(&self, out: &mut dyn BufMut) {
-        let payload_length = self.signature().length() +
-            self.seq().length() +
-            self.iter().fold(0, |acc, (k, v)| acc + k.as_slice().length() + v.len());
-
-        let header = Header { list: true, payload_length };
-        header.encode(out);
-
-        self.signature().encode(out);
-        self.seq().encode(out);
-
-        for (k, v) in self.iter() {
-            // Keys are byte data
-            k.as_slice().encode(out);
-            // Values are raw RLP encoded data
-            out.put_slice(v);
-        }
-    }
-
-    fn length(&self) -> usize {
-        let payload_length = self.signature().length() +
-            self.seq().length() +
-            self.iter().fold(0, |acc, (k, v)| acc + k.as_slice().length() + v.len());
-        payload_length + length_of_length(payload_length)
-    }
-}
-
 #[cfg(feature = "std")]
 impl Encodable for std::net::IpAddr {
     fn encode(&self, out: &mut dyn BufMut) {
@@ -340,13 +313,13 @@ mod alloc_support {
     where
         T: Encodable,
     {
-        fn length(&self) -> usize {
-            list_length(self)
-        }
-
         fn encode(&self, out: &mut dyn BufMut) {
             encode_list(self, out)
         }
+
+        fn length(&self) -> usize {
+            list_length(self)
+        }
     }
 
     impl Encodable for ::alloc::string::String {
@@ -583,7 +556,7 @@ mod tests {
                 "0100020003000400050006000700080009000A0B4B000C000D000E010100020003000400050006000700080009000A0B4B000C000D000E01",
                 16,
             )
-            .unwrap(),
+                .unwrap(),
             &hex!("b8380100020003000400050006000700080009000A0B4B000C000D000E010100020003000400050006000700080009000A0B4B000C000D000E01")[..],
         )])
     }
@@ -644,37 +617,4 @@ mod tests {
         "abcdefgh".to_string().encode(&mut b);
         assert_eq!(&encoded(SmolStr::new("abcdefgh"))[..], b.as_ref());
     }
-
-    // test vector from the enr library rlp encoding tests
-    // <https://github.com/sigp/enr/blob/e59dcb45ea07e423a7091d2a6ede4ad6d8ef2840/src/lib.rs#L1019>
-    #[cfg(feature = "enr")]
-    #[test]
-    fn encode_known_rlp_enr() {
-        use crate::Decodable;
-        use enr::{secp256k1::SecretKey, Enr, EnrPublicKey};
-        use std::net::Ipv4Addr;
-
-        let valid_record = hex!("f884b8407098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c01826964827634826970847f00000189736563703235366b31a103ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31388375647082765f");
-        let signature = hex!("7098ad865b00a582051940cb9cf36836572411a47278783077011599ed5cd16b76f2635f4e234738f30813a89eb9137e3e3df5266e3a1f11df72ecf1145ccb9c");
-        let expected_pubkey =
-            hex!("03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138");
-
-        let enr = Enr::<SecretKey>::decode(&mut &valid_record[..]).unwrap();
-        let pubkey = enr.public_key().encode();
-
-        assert_eq!(enr.ip4(), Some(Ipv4Addr::new(127, 0, 0, 1)));
-        assert_eq!(enr.id(), Some(String::from("v4")));
-        assert_eq!(enr.udp4(), Some(30303));
-        assert_eq!(enr.tcp4(), None);
-        assert_eq!(enr.signature(), &signature[..]);
-        assert_eq!(pubkey.to_vec(), expected_pubkey);
-        assert!(enr.verify());
-
-        let mut encoded = BytesMut::new();
-        enr.encode(&mut encoded);
-        assert_eq!(&encoded[..], &valid_record[..]);
-
-        // ensure the length is equal
-        assert_eq!(enr.length(), valid_record.len());
-    }
 }
diff --git a/crates/rlp/src/lib.rs b/crates/rlp/src/lib.rs
index 9055fc6e464..c4671f55bff 100644
--- a/crates/rlp/src/lib.rs
+++ b/crates/rlp/src/lib.rs
@@ -1,3 +1,9 @@
+#![warn(unreachable_pub)]
+#![deny(unused_must_use)]
+#![doc(test(
+    no_crate_inject,
+    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
+))]
 #![cfg_attr(not(feature = "std"), no_std)]
 
 #[cfg(feature = "alloc")]
diff --git a/crates/rpc/ipc/src/server/mod.rs b/crates/rpc/ipc/src/server/mod.rs
index e6f46fe1c52..f4718fd5cc3 100644
--- a/crates/rpc/ipc/src/server/mod.rs
+++ b/crates/rpc/ipc/src/server/mod.rs
@@ -379,6 +379,7 @@ pub struct Builder<B = Identity, L = ()> {
     settings: Settings,
     resources: Resources,
     logger: L,
+    /// Subscription ID provider.
     id_provider: Arc<dyn IdProvider>,
     service_builder: tower::ServiceBuilder<B>,
 }
diff --git a/crates/rpc/rpc-api/src/debug.rs b/crates/rpc/rpc-api/src/debug.rs
index 4a78a635a62..dc594e0275f 100644
--- a/crates/rpc/rpc-api/src/debug.rs
+++ b/crates/rpc/rpc-api/src/debug.rs
@@ -1,6 +1,9 @@
 use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc};
-use reth_primitives::{BlockId, Bytes, H256};
-use reth_rpc_types::RichBlock;
+use reth_primitives::{BlockId, BlockNumberOrTag, Bytes, H256};
+use reth_rpc_types::{
+    trace::geth::{BlockTraceResult, GethDebugTracingOptions, GethTraceFrame, TraceResult},
+    CallRequest, RichBlock,
+};
 
 /// Debug rpc interface.
 #[cfg_attr(not(feature = "client"), rpc(server))]
@@ -25,4 +28,75 @@ pub trait DebugApi {
     /// Returns an array of recent bad blocks that the client has seen on the network.
     #[method(name = "debug_getBadBlocks")]
     async fn bad_blocks(&self) -> Result<Vec<RichBlock>>;
+
+    /// Returns the structured logs created during the execution of EVM between two blocks
+    /// (excluding start) as a JSON object.
+    #[method(name = "debug_traceChain")]
+    async fn debug_trace_chain(
+        &self,
+        start_exclusive: BlockNumberOrTag,
+        end_inclusive: BlockNumberOrTag,
+    ) -> Result<Vec<BlockTraceResult>>;
+
+    /// The `debug_traceBlock` method will return a full stack trace of all invoked opcodes of all
+    /// transaction that were included in this block.
+    ///
+    /// This expects an rlp encoded block
+    ///
+    /// Note, the parent of this block must be present, or it will fail. For the second parameter
+    /// see [GethDebugTracingOptions] reference.
+    #[method(name = "debug_traceBlock")]
+    async fn debug_trace_block(
+        &self,
+        rlp_block: Bytes,
+        opts: GethDebugTracingOptions,
+    ) -> Result<Vec<TraceResult>>;
+
+    /// Similar to `debug_traceBlock`, `debug_traceBlockByHash` accepts a block hash and will replay
+    /// the block that is already present in the database. For the second parameter see
+    /// [GethDebugTracingOptions].
+    #[method(name = "debug_traceBlockByHash")]
+    async fn debug_trace_block_by_hash(
+        &self,
+        block: H256,
+        opts: GethDebugTracingOptions,
+    ) -> Result<Vec<TraceResult>>;
+
+    /// Similar to `debug_traceBlockByNumber`, `debug_traceBlockByHash` accepts a block number
+    /// [BlockNumberOrTag] and will replay the block that is already present in the database.
+    /// For the second parameter see [GethDebugTracingOptions].
+    #[method(name = "debug_traceBlockByNumber")]
+    async fn debug_trace_block_by_number(
+        &self,
+        block: BlockNumberOrTag,
+        opts: GethDebugTracingOptions,
+    ) -> Result<Vec<TraceResult>>;
+
+    /// The `debug_traceTransaction` debugging method will attempt to run the transaction in the
+    /// exact same manner as it was executed on the network. It will replay any transaction that
+    /// may have been executed prior to this one before it will finally attempt to execute the
+    /// transaction that corresponds to the given hash.
+    #[method(name = "debug_traceTransaction")]
+    async fn debug_trace_transaction(
+        &self,
+        tx_hash: H256,
+        opts: GethDebugTracingOptions,
+    ) -> Result<GethTraceFrame>;
+
+    /// The debug_traceCall method lets you run an `eth_call` within the context of the given block
+    /// execution using the final state of parent block as the base.
+    ///
+    /// The first argument (just as in`eth_call`) is a transaction request.
+    /// The block can be specified either by hash or by number as
+    /// the second argument.
+    /// The trace can be configured similar to `debug_traceTransaction`,
+    /// see [GethDebugTracingOptions]. The method returns the same output as
+    /// `debug_traceTransaction`.
+    #[method(name = "debug_traceCall")]
+    async fn debug_trace_call(
+        &self,
+        request: CallRequest,
+        block_number: Option<BlockId>,
+        opts: GethDebugTracingOptions,
+    ) -> Result<GethTraceFrame>;
 }
diff --git a/crates/rpc/rpc-api/src/eth.rs b/crates/rpc/rpc-api/src/eth.rs
index 5b6553e7318..dc715088f62 100644
--- a/crates/rpc/rpc-api/src/eth.rs
+++ b/crates/rpc/rpc-api/src/eth.rs
@@ -1,11 +1,10 @@
 use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc};
 use reth_primitives::{
-    rpc::transaction::eip2930::AccessListWithGasUsed, Address, BlockId, BlockNumberOrTag, Bytes,
-    H256, H64, U256, U64,
+    AccessListWithGasUsed, Address, BlockId, BlockNumberOrTag, Bytes, H256, H64, U256, U64,
 };
 use reth_rpc_types::{
-    CallRequest, EIP1186AccountProofResponse, FeeHistory, Index, RichBlock, SyncStatus,
-    Transaction, TransactionReceipt, TransactionRequest, Work,
+    state::StateOverride, CallRequest, EIP1186AccountProofResponse, FeeHistory, Index, RichBlock,
+    SyncStatus, Transaction, TransactionReceipt, TransactionRequest, Work,
 };
 
 /// Eth rpc interface: <https://ethereum.github.io/execution-apis/api-documentation/>
@@ -135,7 +134,12 @@ pub trait EthApi {
 
     /// Executes a new message call immediately without creating a transaction on the block chain.
     #[method(name = "eth_call")]
-    async fn call(&self, request: CallRequest, block_number: Option<BlockId>) -> Result<Bytes>;
+    async fn call(
+        &self,
+        request: CallRequest,
+        block_number: Option<BlockId>,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<Bytes>;
 
     /// Generates an access list for a transaction.
     ///
diff --git a/crates/rpc/rpc-api/src/trace.rs b/crates/rpc/rpc-api/src/trace.rs
index 7ff742f237c..f5670283fdf 100644
--- a/crates/rpc/rpc-api/src/trace.rs
+++ b/crates/rpc/rpc-api/src/trace.rs
@@ -12,7 +12,7 @@ use std::collections::HashSet;
 pub trait TraceApi {
     /// Executes the given call and returns a number of possible traces for it.
     #[method(name = "trace_call")]
-    async fn call(
+    async fn trace_call(
         &self,
         call: CallRequest,
         trace_types: HashSet<TraceType>,
@@ -23,7 +23,7 @@ pub trait TraceApi {
     /// on top of a pending block with all n-1 transactions applied (traced) first. Allows to trace
     /// dependent transactions.
     #[method(name = "trace_callMany")]
-    async fn call_many(
+    async fn trace_call_many(
         &self,
         calls: Vec<(CallRequest, HashSet<TraceType>)>,
         block_id: Option<BlockId>,
@@ -33,7 +33,7 @@ pub trait TraceApi {
     ///
     /// Expects a raw transaction data
     #[method(name = "trace_rawTransaction")]
-    async fn raw_transaction(
+    async fn trace_raw_transaction(
         &self,
         data: Bytes,
         trace_types: HashSet<TraceType>,
@@ -58,17 +58,25 @@ pub trait TraceApi {
 
     /// Returns traces created at given block.
     #[method(name = "trace_block")]
-    async fn block(&self, block_id: BlockId) -> Result<Option<Vec<LocalizedTransactionTrace>>>;
+    async fn trace_block(
+        &self,
+        block_id: BlockId,
+    ) -> Result<Option<Vec<LocalizedTransactionTrace>>>;
 
     /// Returns traces matching given filter
     #[method(name = "trace_filter")]
-    async fn filter(&self, filter: TraceFilter) -> Result<Vec<LocalizedTransactionTrace>>;
+    async fn trace_filter(&self, filter: TraceFilter) -> Result<Vec<LocalizedTransactionTrace>>;
 
     /// Returns transaction trace at given index.
     #[method(name = "trace_get")]
-    fn trace(&self, hash: H256, indices: Vec<Index>) -> Result<Option<LocalizedTransactionTrace>>;
+    async fn trace_get(
+        &self,
+        hash: H256,
+        indices: Vec<Index>,
+    ) -> Result<Option<LocalizedTransactionTrace>>;
 
     /// Returns all traces of given transaction.
     #[method(name = "trace_transaction")]
-    fn transaction_traces(&self, hash: H256) -> Result<Option<Vec<LocalizedTransactionTrace>>>;
+    async fn trace_transaction(&self, hash: H256)
+        -> Result<Option<Vec<LocalizedTransactionTrace>>>;
 }
diff --git a/crates/rpc/rpc-builder/Cargo.toml b/crates/rpc/rpc-builder/Cargo.toml
index 67e32a50adc..6f9e41a588a 100644
--- a/crates/rpc/rpc-builder/Cargo.toml
+++ b/crates/rpc/rpc-builder/Cargo.toml
@@ -15,6 +15,7 @@ reth-rpc = { path = "../rpc" }
 reth-rpc-api = { path = "../rpc-api" }
 reth-rpc-engine-api = { path = "../rpc-engine-api" }
 reth-rpc-types = { path = "../rpc-types" }
+reth-tasks = { path = "../../tasks" }
 reth-transaction-pool = { path = "../../transaction-pool" }
 
 jsonrpsee = { version = "0.16", features = ["server"] }
diff --git a/crates/rpc/rpc-builder/src/auth.rs b/crates/rpc/rpc-builder/src/auth.rs
index 4bccd977a1f..42c5d413093 100644
--- a/crates/rpc/rpc-builder/src/auth.rs
+++ b/crates/rpc/rpc-builder/src/auth.rs
@@ -1,52 +1,42 @@
-use crate::{constants::DEFAULT_AUTH_PORT, RpcServerConfig};
-use hyper::{http::HeaderValue, Method};
 pub use jsonrpsee::server::ServerBuilder;
-use jsonrpsee::{
-    core::{
-        server::{host_filtering::AllowHosts, rpc_module::Methods},
-        Error as RpcError,
-    },
-    server::{middleware, Server, ServerHandle},
-    RpcModule,
-};
-use reth_ipc::server::IpcServer;
-pub use reth_ipc::server::{Builder as IpcServerBuilder, Endpoint};
+use jsonrpsee::{core::Error as RpcError, server::ServerHandle, RpcModule};
 use reth_network_api::{NetworkInfo, Peers};
 use reth_provider::{BlockProvider, EvmEnvProvider, HeaderProvider, StateProviderFactory};
 use reth_rpc::{
-    AdminApi, AuthLayer, DebugApi, EngineApi, EthApi, JwtAuthValidator, JwtSecret, NetApi,
-    TraceApi, Web3Api,
+    eth::cache::EthStateCache, AuthLayer, EngineApi, EthApi, JwtAuthValidator, JwtSecret,
 };
 use reth_rpc_api::servers::*;
 use reth_rpc_engine_api::EngineApiHandle;
+use reth_tasks::TaskSpawner;
 use reth_transaction_pool::TransactionPool;
-use serde::{Deserialize, Serialize, Serializer};
-use std::{
-    collections::{hash_map::Entry, HashMap},
-    fmt,
-    net::{Ipv4Addr, SocketAddr, SocketAddrV4},
-    str::FromStr,
-};
-use strum::{AsRefStr, EnumString, EnumVariantNames, ParseError, VariantNames};
-use tower::layer::util::{Identity, Stack};
-use tower_http::cors::{AllowOrigin, Any, CorsLayer};
+use std::net::SocketAddr;
 
-/// Configure and launch an auth server with `engine` and `eth` namespaces.
-pub async fn launch<Client, Pool, Network>(
+/// Configure and launch an auth server with `engine` and a _new_ `eth` namespace.
+pub async fn launch<Client, Pool, Network, Tasks>(
     client: Client,
     pool: Pool,
     network: Network,
+    executor: Tasks,
     handle: EngineApiHandle,
     socket_addr: SocketAddr,
     secret: JwtSecret,
 ) -> Result<ServerHandle, RpcError>
 where
-    Client:
-        BlockProvider + HeaderProvider + StateProviderFactory + EvmEnvProvider + Clone + 'static,
+    Client: BlockProvider
+        + HeaderProvider
+        + StateProviderFactory
+        + EvmEnvProvider
+        + Clone
+        + Unpin
+        + 'static,
     Pool: TransactionPool + Clone + 'static,
     Network: NetworkInfo + Peers + Clone + 'static,
+    Tasks: TaskSpawner + Clone + 'static,
 {
-    launch_with_eth_api(EthApi::new(client, pool, network), handle, socket_addr, secret).await
+    // spawn a new cache task
+    let eth_cache = EthStateCache::spawn_with(client.clone(), Default::default(), executor);
+    launch_with_eth_api(EthApi::new(client, pool, network, eth_cache), handle, socket_addr, secret)
+        .await
 }
 
 /// Configure and launch an auth server with existing EthApi implementation.
@@ -57,21 +47,26 @@ pub async fn launch_with_eth_api<Client, Pool, Network>(
     secret: JwtSecret,
 ) -> Result<ServerHandle, RpcError>
 where
-    Client:
-        BlockProvider + HeaderProvider + StateProviderFactory + EvmEnvProvider + Clone + 'static,
+    Client: BlockProvider
+        + HeaderProvider
+        + StateProviderFactory
+        + EvmEnvProvider
+        + Clone
+        + Unpin
+        + 'static,
     Pool: TransactionPool + Clone + 'static,
     Network: NetworkInfo + Peers + Clone + 'static,
 {
     // Configure the module and start the server.
     let mut module = RpcModule::new(());
-    module.merge(EngineApi::new(handle).into_rpc());
-    module.merge(eth_api.into_rpc());
+    module.merge(EngineApi::new(handle).into_rpc()).expect("No conflicting methods");
+    module.merge(eth_api.into_rpc()).expect("No conflicting methods");
 
     // Create auth middleware.
     let middleware =
         tower::ServiceBuilder::new().layer(AuthLayer::new(JwtAuthValidator::new(secret)));
 
-    // By default both http and ws are enabled.
+    // By default, both http and ws are enabled.
     let server = ServerBuilder::new().set_middleware(middleware).build(socket_addr).await?;
 
     server.start(module)
diff --git a/crates/rpc/rpc-builder/src/eth.rs b/crates/rpc/rpc-builder/src/eth.rs
new file mode 100644
index 00000000000..eec235cdd8c
--- /dev/null
+++ b/crates/rpc/rpc-builder/src/eth.rs
@@ -0,0 +1,25 @@
+use reth_rpc::{
+    eth::cache::{EthStateCache, EthStateCacheConfig},
+    EthApi, EthFilter, EthPubSub,
+};
+use serde::{Deserialize, Serialize};
+
+/// All handlers for the `eth` namespace
+#[derive(Debug, Clone)]
+pub struct EthHandlers<Client, Pool, Network, Events> {
+    /// Main `eth_` request handler
+    pub api: EthApi<Client, Pool, Network>,
+    /// The async caching layer used by the eth handlers
+    pub eth_cache: EthStateCache,
+    /// Polling based filter handler available on all transports
+    pub filter: EthFilter<Client, Pool>,
+    /// Handler for subscriptions only available for transports that support it (ws, ipc)
+    pub pubsub: Option<EthPubSub<Client, Pool, Events, Network>>,
+}
+
+/// Additional config values for the eth namespace
+#[derive(Debug, Clone, Eq, PartialEq, Default, Serialize, Deserialize)]
+pub struct EthConfig {
+    /// Settings for the caching layer
+    pub cache: EthStateCacheConfig,
+}
diff --git a/crates/rpc/rpc-builder/src/lib.rs b/crates/rpc/rpc-builder/src/lib.rs
index 1a87511228a..8b883f4218c 100644
--- a/crates/rpc/rpc-builder/src/lib.rs
+++ b/crates/rpc/rpc-builder/src/lib.rs
@@ -4,7 +4,6 @@
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
 ))]
-#![allow(unused)]
 
 //! Configure reth RPC
 //!
@@ -26,12 +25,13 @@
 //!
 //! ```
 //! use reth_network_api::{NetworkInfo, Peers};
-//! use reth_provider::{BlockProvider, HeaderProvider, StateProviderFactory, EvmEnvProvider};
+//! use reth_provider::{BlockProvider, StateProviderFactory, EvmEnvProvider};
 //! use reth_rpc_builder::{RethRpcModule, RpcModuleBuilder, RpcServerConfig, ServerBuilder, TransportRpcModuleConfig};
+//! use reth_tasks::TokioTaskExecutor;
 //! use reth_transaction_pool::TransactionPool;
 //! pub async fn launch<Client, Pool, Network>(client: Client, pool: Pool, network: Network)
 //! where
-//!     Client: BlockProvider + HeaderProvider + StateProviderFactory + EvmEnvProvider + Clone + 'static,
+//!     Client: BlockProvider + StateProviderFactory + EvmEnvProvider + Clone + Unpin + 'static,
 //!     Pool: TransactionPool + Clone + 'static,
 //!     Network: NetworkInfo + Peers + Clone + 'static,
 //! {
@@ -42,7 +42,7 @@
 //!         RethRpcModule::Eth,
 //!         RethRpcModule::Web3,
 //!     ]);
-//!     let transport_modules = RpcModuleBuilder::new(client, pool, network).build(transports);
+//!     let transport_modules = RpcModuleBuilder::new(client, pool, network, TokioTaskExecutor::default()).build(transports);
 //!     let handle = RpcServerConfig::default()
 //!         .with_http(ServerBuilder::default())
 //!         .start(transport_modules)
@@ -51,24 +51,22 @@
 //! }
 //! ```
 
-use hyper::{http::HeaderValue, Method};
 use jsonrpsee::{
-    core::{
-        server::{host_filtering::AllowHosts, rpc_module::Methods},
-        Error as RpcError,
-    },
-    server::{Server, ServerHandle},
+    core::{server::rpc_module::Methods, Error as RpcError},
+    server::{IdProvider, Server, ServerHandle},
     RpcModule,
 };
 use reth_ipc::server::IpcServer;
 use reth_network_api::{NetworkInfo, Peers};
-use reth_provider::{BlockProvider, EvmEnvProvider, HeaderProvider, StateProviderFactory};
-use reth_rpc::{AdminApi, DebugApi, EthApi, NetApi, TraceApi, Web3Api};
+use reth_provider::{BlockProvider, EvmEnvProvider, StateProviderFactory};
+use reth_rpc::{
+    AdminApi, DebugApi, EthApi, EthFilter, EthSubscriptionIdProvider, NetApi, TraceApi, Web3Api,
+};
 use reth_rpc_api::servers::*;
 use reth_transaction_pool::TransactionPool;
 use serde::{Deserialize, Serialize, Serializer};
 use std::{
-    collections::{hash_map::Entry, HashMap},
+    collections::HashMap,
     fmt,
     net::{Ipv4Addr, SocketAddr, SocketAddrV4},
     str::FromStr,
@@ -83,30 +81,37 @@ pub use reth_ipc::server::{Builder as IpcServerBuilder, Endpoint};
 /// Auth server utilities.
 pub mod auth;
 
+/// Eth utils
+mod eth;
+
 /// Common RPC constants.
 pub mod constants;
+pub use crate::eth::{EthConfig, EthHandlers};
 use constants::*;
+use reth_rpc::eth::cache::EthStateCache;
+use reth_tasks::TaskSpawner;
 
 /// Cors utilities.
 mod cors;
 
 /// Convenience function for starting a server in one step.
-pub async fn launch<Client, Pool, Network>(
+pub async fn launch<Client, Pool, Network, Tasks>(
     client: Client,
     pool: Pool,
     network: Network,
     module_config: impl Into<TransportRpcModuleConfig>,
     server_config: impl Into<RpcServerConfig>,
+    executor: Tasks,
 ) -> Result<RpcServerHandle, RpcError>
 where
-    Client:
-        BlockProvider + HeaderProvider + StateProviderFactory + EvmEnvProvider + Clone + 'static,
+    Client: BlockProvider + StateProviderFactory + EvmEnvProvider + Clone + Unpin + 'static,
     Pool: TransactionPool + Clone + 'static,
     Network: NetworkInfo + Peers + Clone + 'static,
+    Tasks: TaskSpawner + Clone + 'static,
 {
     let module_config = module_config.into();
     let server_config = server_config.into();
-    RpcModuleBuilder::new(client, pool, network)
+    RpcModuleBuilder::new(client, pool, network, executor)
         .build(module_config)
         .start_server(server_config)
         .await
@@ -116,57 +121,68 @@ where
 ///
 /// This is the main entrypoint for up RPC servers.
 #[derive(Debug)]
-pub struct RpcModuleBuilder<Client, Pool, Network> {
+pub struct RpcModuleBuilder<Client, Pool, Network, Tasks> {
     /// The Client type to when creating all rpc handlers
     client: Client,
     /// The Pool type to when creating all rpc handlers
     pool: Pool,
     /// The Network type to when creating all rpc handlers
     network: Network,
+    /// How additional tasks are spawned, for example in the eth pubsub namespace
+    executor: Tasks,
 }
 
 // === impl RpcBuilder ===
 
-impl<Client, Pool, Network> RpcModuleBuilder<Client, Pool, Network> {
+impl<Client, Pool, Network, Tasks> RpcModuleBuilder<Client, Pool, Network, Tasks> {
     /// Create a new instance of the builder
-    pub fn new(client: Client, pool: Pool, network: Network) -> Self {
-        Self { client, pool, network }
+    pub fn new(client: Client, pool: Pool, network: Network, executor: Tasks) -> Self {
+        Self { client, pool, network, executor }
     }
 
     /// Configure the client instance.
-    pub fn with_client<C>(self, client: C) -> RpcModuleBuilder<C, Pool, Network>
+    pub fn with_client<C>(self, client: C) -> RpcModuleBuilder<C, Pool, Network, Tasks>
     where
         C: BlockProvider + StateProviderFactory + EvmEnvProvider + 'static,
     {
-        let Self { pool, network, .. } = self;
-        RpcModuleBuilder { client, network, pool }
+        let Self { pool, network, executor, .. } = self;
+        RpcModuleBuilder { client, network, pool, executor }
     }
 
     /// Configure the transaction pool instance.
-    pub fn with_pool<P>(self, pool: P) -> RpcModuleBuilder<Client, P, Network>
+    pub fn with_pool<P>(self, pool: P) -> RpcModuleBuilder<Client, P, Network, Tasks>
     where
         P: TransactionPool + 'static,
     {
-        let Self { client, network, .. } = self;
-        RpcModuleBuilder { client, network, pool }
+        let Self { client, network, executor, .. } = self;
+        RpcModuleBuilder { client, network, pool, executor }
     }
 
     /// Configure the network instance.
-    pub fn with_network<N>(self, network: N) -> RpcModuleBuilder<Client, Pool, N>
+    pub fn with_network<N>(self, network: N) -> RpcModuleBuilder<Client, Pool, N, Tasks>
     where
         N: NetworkInfo + Peers + 'static,
     {
-        let Self { client, pool, .. } = self;
-        RpcModuleBuilder { client, network, pool }
+        let Self { client, pool, executor, .. } = self;
+        RpcModuleBuilder { client, network, pool, executor }
+    }
+
+    /// Configure the task executor to use for additional tasks.
+    pub fn with_executor<T>(self, executor: T) -> RpcModuleBuilder<Client, Pool, Network, T>
+    where
+        T: TaskSpawner + 'static,
+    {
+        let Self { pool, network, client, .. } = self;
+        RpcModuleBuilder { client, network, pool, executor }
     }
 }
 
-impl<Client, Pool, Network> RpcModuleBuilder<Client, Pool, Network>
+impl<Client, Pool, Network, Tasks> RpcModuleBuilder<Client, Pool, Network, Tasks>
 where
-    Client:
-        BlockProvider + HeaderProvider + StateProviderFactory + EvmEnvProvider + Clone + 'static,
+    Client: BlockProvider + StateProviderFactory + EvmEnvProvider + Clone + Unpin + 'static,
     Pool: TransactionPool + Clone + 'static,
     Network: NetworkInfo + Peers + Clone + 'static,
+    Tasks: TaskSpawner + Clone + 'static,
 {
     /// Configures all [RpcModule]s specific to the given [TransportRpcModuleConfig] which can be
     /// used to start the transport server(s).
@@ -175,12 +191,19 @@ where
     pub fn build(self, module_config: TransportRpcModuleConfig) -> TransportRpcModules<()> {
         let mut modules = TransportRpcModules::default();
 
-        let Self { client, pool, network } = self;
-
-        let mut registry = RethModuleRegistry::new(client, pool, network);
+        let Self { client, pool, network, executor } = self;
 
         if !module_config.is_empty() {
-            let TransportRpcModuleConfig { http, ws, ipc } = module_config;
+            let TransportRpcModuleConfig { http, ws, ipc, config } = module_config;
+
+            let mut registry = RethModuleRegistry::new(
+                client,
+                pool,
+                network,
+                executor,
+                config.unwrap_or_default(),
+            );
+
             modules.http = registry.maybe_module(http.as_ref());
             modules.ws = registry.maybe_module(ws.as_ref());
             modules.ipc = registry.maybe_module(ipc.as_ref());
@@ -190,9 +213,47 @@ where
     }
 }
 
-impl Default for RpcModuleBuilder<(), (), ()> {
+impl Default for RpcModuleBuilder<(), (), (), ()> {
     fn default() -> Self {
-        RpcModuleBuilder::new((), (), ())
+        RpcModuleBuilder::new((), (), (), ())
+    }
+}
+
+/// Bundles settings for modules
+#[derive(Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
+pub struct RpcModuleConfig {
+    /// `eth` namespace settings
+    eth: EthConfig,
+}
+
+// === impl RpcModuleConfig ===
+
+impl RpcModuleConfig {
+    /// Convenience method to create a new [RpcModuleConfigBuilder]
+    pub fn builder() -> RpcModuleConfigBuilder {
+        RpcModuleConfigBuilder::default()
+    }
+}
+
+/// Configures [RpcModuleConfig]
+#[derive(Default)]
+pub struct RpcModuleConfigBuilder {
+    eth: Option<EthConfig>,
+}
+
+// === impl RpcModuleConfigBuilder ===
+
+impl RpcModuleConfigBuilder {
+    /// Configures a custom eth namespace config
+    pub fn eth(mut self, eth: EthConfig) -> Self {
+        self.eth = Some(eth);
+        self
+    }
+
+    /// Consumes the type and creates the [RpcModuleConfig]
+    pub fn build(self) -> RpcModuleConfig {
+        let RpcModuleConfigBuilder { eth } = self;
+        RpcModuleConfig { eth: eth.unwrap_or_default() }
     }
 }
 
@@ -217,7 +278,7 @@ pub enum RpcModuleSelection {
     Selection(Vec<RethRpcModule>),
 }
 
-// === impl RpcModuleConfig ===
+// === impl RpcModuleSelection ===
 
 impl RpcModuleSelection {
     /// The standard modules to instantiate by default `eth`, `net`, `web3`
@@ -258,23 +319,21 @@ impl RpcModuleSelection {
     /// Note: This will always create new instance of the module handlers and is therefor only
     /// recommended for launching standalone transports. If multiple transports need to be
     /// configured it's recommended to use the [RpcModuleBuilder].
-    pub fn standalone_module<Client, Pool, Network>(
+    pub fn standalone_module<Client, Pool, Network, Tasks>(
         &self,
         client: Client,
         pool: Pool,
         network: Network,
+        executor: Tasks,
+        config: RpcModuleConfig,
     ) -> RpcModule<()>
     where
-        Client: BlockProvider
-            + HeaderProvider
-            + StateProviderFactory
-            + EvmEnvProvider
-            + Clone
-            + 'static,
+        Client: BlockProvider + StateProviderFactory + EvmEnvProvider + Clone + Unpin + 'static,
         Pool: TransactionPool + Clone + 'static,
         Network: NetworkInfo + Peers + Clone + 'static,
+        Tasks: TaskSpawner + Clone + 'static,
     {
-        let mut registry = RethModuleRegistry::new(client, pool, network);
+        let mut registry = RethModuleRegistry::new(client, pool, network, executor, config);
         registry.module_for(self)
     }
 
@@ -354,23 +413,31 @@ impl Serialize for RethRpcModule {
 }
 
 /// A Helper type the holds instances of the configured modules.
-pub struct RethModuleRegistry<Client, Pool, Network> {
+pub struct RethModuleRegistry<Client, Pool, Network, Tasks> {
     client: Client,
     pool: Pool,
     network: Network,
-    /// Holds a clone of the actual [EthApi] namespace impl since this can be required by other
-    /// namespaces
-    eth_api: Option<EthApi<Client, Pool, Network>>,
+    executor: Tasks,
+    /// Additional settings for handlers.
+    config: RpcModuleConfig,
+    /// Holds a clone of all the eth namespace handlers
+    eth: Option<EthHandlers<Client, Pool, Network, ()>>,
     /// Contains the [Methods] of a module
     modules: HashMap<RethRpcModule, Methods>,
 }
 
 // === impl RethModuleRegistry ===
 
-impl<Client, Pool, Network> RethModuleRegistry<Client, Pool, Network> {
+impl<Client, Pool, Network, Tasks> RethModuleRegistry<Client, Pool, Network, Tasks> {
     /// Creates a new, empty instance.
-    pub fn new(client: Client, pool: Pool, network: Network) -> Self {
-        Self { client, pool, network, eth_api: None, modules: Default::default() }
+    pub fn new(
+        client: Client,
+        pool: Pool,
+        network: Network,
+        executor: Tasks,
+        config: RpcModuleConfig,
+    ) -> Self {
+        Self { client, pool, network, eth: None, executor, modules: Default::default(), config }
     }
 
     /// Returns all installed methods
@@ -388,7 +455,7 @@ impl<Client, Pool, Network> RethModuleRegistry<Client, Pool, Network> {
     }
 }
 
-impl<Client, Pool, Network> RethModuleRegistry<Client, Pool, Network>
+impl<Client, Pool, Network, Tasks> RethModuleRegistry<Client, Pool, Network, Tasks>
 where
     Network: NetworkInfo + Peers + Clone + 'static,
 {
@@ -407,12 +474,12 @@ where
     }
 }
 
-impl<Client, Pool, Network> RethModuleRegistry<Client, Pool, Network>
+impl<Client, Pool, Network, Tasks> RethModuleRegistry<Client, Pool, Network, Tasks>
 where
-    Client:
-        BlockProvider + HeaderProvider + StateProviderFactory + EvmEnvProvider + Clone + 'static,
+    Client: BlockProvider + StateProviderFactory + EvmEnvProvider + Clone + Unpin + 'static,
     Pool: TransactionPool + Clone + 'static,
     Network: NetworkInfo + Peers + Clone + 'static,
+    Tasks: TaskSpawner + Clone + 'static,
 {
     /// Register Eth Namespace
     pub fn register_eth(&mut self) -> &mut Self {
@@ -465,6 +532,7 @@ where
         namespaces: impl Iterator<Item = RethRpcModule>,
     ) -> Vec<Methods> {
         let eth_api = self.eth_api();
+        let eth_cache = self.eth_cache();
         namespaces
             .map(|namespace| {
                 self.modules
@@ -478,7 +546,11 @@ where
                         RethRpcModule::Net => {
                             NetApi::new(self.network.clone(), eth_api.clone()).into_rpc().into()
                         }
-                        RethRpcModule::Trace => TraceApi::new().into_rpc().into(),
+                        RethRpcModule::Trace => {
+                            TraceApi::new(self.client.clone(), eth_api.clone(), eth_cache.clone())
+                                .into_rpc()
+                                .into()
+                        }
                         RethRpcModule::Web3 => Web3Api::new(self.network.clone()).into_rpc().into(),
                     })
                     .clone()
@@ -486,13 +558,44 @@ where
             .collect::<Vec<_>>()
     }
 
+    /// Returns the [EthStateCache] frontend
+    ///
+    /// This will spawn exactly one [EthStateCache] service if this is the first time the cache is
+    /// requested.
+    pub fn eth_cache(&mut self) -> EthStateCache {
+        self.with_eth(|handlers| handlers.eth_cache.clone())
+    }
+
+    /// Creates the [EthHandlers] type the first time this is called.
+    fn with_eth<F, R>(&mut self, f: F) -> R
+    where
+        F: FnOnce(&EthHandlers<Client, Pool, Network, ()>) -> R,
+    {
+        if self.eth.is_none() {
+            let eth_cache = EthStateCache::spawn_with(
+                self.client.clone(),
+                self.config.eth.cache.clone(),
+                self.executor.clone(),
+            );
+            let api = EthApi::new(
+                self.client.clone(),
+                self.pool.clone(),
+                self.network.clone(),
+                eth_cache.clone(),
+            );
+            let filter = EthFilter::new(self.client.clone(), self.pool.clone());
+
+            // TODO: install pubsub
+
+            let eth = EthHandlers { api, eth_cache, filter, pubsub: None };
+            self.eth = Some(eth);
+        }
+        f(self.eth.as_ref().expect("exists; qed"))
+    }
+
     /// Returns the configured [EthApi] or creates it if it does not exist yet
     fn eth_api(&mut self) -> EthApi<Client, Pool, Network> {
-        self.eth_api
-            .get_or_insert_with(|| {
-                EthApi::new(self.client.clone(), self.pool.clone(), self.network.clone())
-            })
-            .clone()
+        self.with_eth(|handlers| handlers.api.clone())
     }
 }
 
@@ -542,11 +645,17 @@ impl RpcServerConfig {
     pub fn ipc(config: IpcServerBuilder) -> Self {
         Self::default().with_ipc(config)
     }
+
     /// Configures the http server
+    ///
+    /// Note: this always configures an [EthSubscriptionIdProvider] [IdProvider] for convenience.
+    /// To set a custom [IdProvider], please use [Self::with_id_provider].
     pub fn with_http(mut self, config: ServerBuilder) -> Self {
-        self.http_server_config = Some(config.http_only());
+        self.http_server_config =
+            Some(config.http_only().set_id_provider(EthSubscriptionIdProvider::default()));
         self
     }
+
     /// Configure the corsdomains
     pub fn with_cors(mut self, cors_domain: String) -> Self {
         self.http_cors_domains = Some(cors_domain);
@@ -554,8 +663,12 @@ impl RpcServerConfig {
     }
 
     /// Configures the ws server
+    ///
+    /// Note: this always configures an [EthSubscriptionIdProvider] [IdProvider] for convenience.
+    /// To set a custom [IdProvider], please use [Self::with_id_provider].
     pub fn with_ws(mut self, config: ServerBuilder) -> Self {
-        self.ws_server_config = Some(config.ws_only());
+        self.ws_server_config =
+            Some(config.ws_only().set_id_provider(EthSubscriptionIdProvider::default()));
         self
     }
 
@@ -576,8 +689,31 @@ impl RpcServerConfig {
     }
 
     /// Configures the ipc server
-    pub fn with_ipc(mut self, mut config: IpcServerBuilder) -> Self {
-        self.ipc_server_config = Some(config);
+    ///
+    /// Note: this always configures an [EthSubscriptionIdProvider] [IdProvider] for convenience.
+    /// To set a custom [IdProvider], please use [Self::with_id_provider].
+    pub fn with_ipc(mut self, config: IpcServerBuilder) -> Self {
+        self.ipc_server_config = Some(config.set_id_provider(EthSubscriptionIdProvider::default()));
+        self
+    }
+
+    /// Sets a custom [IdProvider] for all configured transports.
+    ///
+    /// By default all transports use [EthSubscriptionIdProvider]
+    pub fn with_id_provider<I>(mut self, id_provider: I) -> Self
+    where
+        I: IdProvider + Clone + 'static,
+    {
+        if let Some(http) = self.http_server_config {
+            self.http_server_config = Some(http.set_id_provider(id_provider.clone()));
+        }
+        if let Some(ws) = self.ws_server_config {
+            self.ws_server_config = Some(ws.set_id_provider(id_provider.clone()));
+        }
+        if let Some(ipc) = self.ipc_server_config {
+            self.ipc_server_config = Some(ipc.set_id_provider(id_provider));
+        }
+
         self
     }
 
@@ -667,7 +803,7 @@ impl RpcServerConfig {
 ///
 /// # Example
 ///
-/// Configure an http transport only
+/// Configure a http transport only
 ///
 /// ```
 /// use reth_rpc_builder::{RethRpcModule, TransportRpcModuleConfig};
@@ -682,6 +818,8 @@ pub struct TransportRpcModuleConfig {
     ws: Option<RpcModuleSelection>,
     /// ipc module configuration
     ipc: Option<RpcModuleSelection>,
+    /// Config for the modules
+    config: Option<RpcModuleConfig>,
 }
 
 // === impl TransportRpcModuleConfig ===
@@ -720,6 +858,12 @@ impl TransportRpcModuleConfig {
         self
     }
 
+    /// Sets a custom [RpcModuleConfig] for the configured modules.
+    pub fn with_config(mut self, config: RpcModuleConfig) -> Self {
+        self.config = Some(config);
+        self
+    }
+
     /// Returns true if no transports are configured
     pub fn is_empty(&self) -> bool {
         self.http.is_none() && self.ws.is_none() && self.ipc.is_none()
@@ -790,12 +934,12 @@ impl RpcServer {
     }
 
     /// Returns the [`SocketAddr`] of the http server if started.
-    fn http_local_addr(&self) -> Option<SocketAddr> {
+    pub fn http_local_addr(&self) -> Option<SocketAddr> {
         self.http_local_addr
     }
 
     /// Returns the [`SocketAddr`] of the ws server if started.
-    fn ws_local_addr(&self) -> Option<SocketAddr> {
+    pub fn ws_local_addr(&self) -> Option<SocketAddr> {
         self.ws_local_addr
     }
 
@@ -873,12 +1017,12 @@ pub struct RpcServerHandle {
 
 impl RpcServerHandle {
     /// Returns the [`SocketAddr`] of the http server if started.
-    fn http_local_addr(&self) -> Option<SocketAddr> {
+    pub fn http_local_addr(&self) -> Option<SocketAddr> {
         self.http_local_addr
     }
 
     /// Returns the [`SocketAddr`] of the ws server if started.
-    fn ws_local_addr(&self) -> Option<SocketAddr> {
+    pub fn ws_local_addr(&self) -> Option<SocketAddr> {
         self.ws_local_addr
     }
 
@@ -994,6 +1138,7 @@ mod tests {
                 ])),
                 ws: None,
                 ipc: None,
+                config: None,
             }
         )
     }
diff --git a/crates/rpc/rpc-builder/tests/it/http.rs b/crates/rpc/rpc-builder/tests/it/http.rs
index f6eec08ba3c..1516a97679e 100644
--- a/crates/rpc/rpc-builder/tests/it/http.rs
+++ b/crates/rpc/rpc-builder/tests/it/http.rs
@@ -9,7 +9,8 @@ use jsonrpsee::{
     types::error::{CallError, ErrorCode},
 };
 use reth_primitives::{
-    hex_literal::hex, Address, BlockId, BlockNumberOrTag, Bytes, NodeRecord, H256, H64, U256,
+    hex_literal::hex, Address, BlockId, BlockNumberOrTag, Bytes, NodeRecord, TxHash, H256, H64,
+    U256,
 };
 use reth_rpc_api::{
     clients::{AdminApiClient, EthApiClient},
@@ -50,6 +51,7 @@ where
     let address = Address::default();
     let index = Index::default();
     let hash = H256::default();
+    let tx_hash = TxHash::default();
     let block_number = BlockNumberOrTag::default();
     let call_request = CallRequest::default();
     let transaction_request = TransactionRequest::default();
@@ -71,41 +73,32 @@ where
     EthApiClient::block_by_number(client, block_number, false).await.unwrap();
     EthApiClient::block_transaction_count_by_number(client, block_number).await.unwrap();
     EthApiClient::block_transaction_count_by_hash(client, hash).await.unwrap();
+    EthApiClient::get_proof(client, address, vec![], None).await.unwrap();
     EthApiClient::block_uncles_count_by_hash(client, hash).await.unwrap();
     EthApiClient::block_uncles_count_by_number(client, block_number).await.unwrap();
+    EthApiClient::uncle_by_block_hash_and_index(client, hash, index).await.unwrap();
+    EthApiClient::uncle_by_block_number_and_index(client, block_number, index).await.unwrap();
+    EthApiClient::sign(client, address, bytes.clone()).await.unwrap_err();
+    EthApiClient::sign_typed_data(client, address, jsonrpsee::core::JsonValue::Null)
+        .await
+        .unwrap_err();
+    EthApiClient::transaction_by_hash(client, tx_hash).await.unwrap();
+    EthApiClient::transaction_by_block_hash_and_index(client, hash, index).await.unwrap();
+    EthApiClient::transaction_by_block_number_and_index(client, block_number, index).await.unwrap();
+    EthApiClient::create_access_list(client, call_request.clone(), Some(block_number.into()))
+        .await
+        .unwrap();
+    EthApiClient::estimate_gas(client, call_request.clone(), Some(block_number.into()))
+        .await
+        .unwrap();
+    EthApiClient::call(client, call_request.clone(), Some(block_number.into()), None)
+        .await
+        .unwrap();
 
     // Unimplemented
     assert!(is_unimplemented(EthApiClient::syncing(client).await.err().unwrap()));
     assert!(is_unimplemented(EthApiClient::author(client).await.err().unwrap()));
-    assert!(is_unimplemented(
-        EthApiClient::uncle_by_block_hash_and_index(client, hash, index).await.err().unwrap()
-    ));
-    assert!(is_unimplemented(
-        EthApiClient::uncle_by_block_number_and_index(client, block_number, index)
-            .await
-            .err()
-            .unwrap()
-    ));
-    assert!(is_unimplemented(EthApiClient::transaction_by_hash(client, hash).await.err().unwrap()));
-    assert!(is_unimplemented(
-        EthApiClient::transaction_by_block_hash_and_index(client, hash, index).await.err().unwrap()
-    ));
-    assert!(is_unimplemented(
-        EthApiClient::transaction_by_block_number_and_index(client, block_number, index)
-            .await
-            .err()
-            .unwrap()
-    ));
     assert!(is_unimplemented(EthApiClient::transaction_receipt(client, hash).await.err().unwrap()));
-    assert!(is_unimplemented(
-        EthApiClient::call(client, call_request.clone(), None).await.err().unwrap()
-    ));
-    assert!(is_unimplemented(
-        EthApiClient::create_access_list(client, call_request.clone(), None).await.err().unwrap()
-    ));
-    assert!(is_unimplemented(
-        EthApiClient::estimate_gas(client, call_request.clone(), None).await.err().unwrap()
-    ));
     assert!(is_unimplemented(EthApiClient::gas_price(client).await.err().unwrap()));
     assert!(is_unimplemented(EthApiClient::max_priority_fee_per_gas(client).await.err().unwrap()));
     assert!(is_unimplemented(EthApiClient::is_mining(client).await.err().unwrap()));
@@ -126,21 +119,9 @@ where
     assert!(is_unimplemented(
         EthApiClient::send_transaction(client, transaction_request).await.err().unwrap()
     ));
-    assert!(is_unimplemented(
-        EthApiClient::sign(client, address, bytes.clone()).await.err().unwrap()
-    ));
     assert!(is_unimplemented(
         EthApiClient::sign_transaction(client, call_request.clone()).await.err().unwrap()
     ));
-    assert!(is_unimplemented(
-        EthApiClient::sign_typed_data(client, address, jsonrpsee::core::JsonValue::Null)
-            .await
-            .err()
-            .unwrap()
-    ));
-    assert!(is_unimplemented(
-        EthApiClient::get_proof(client, address, vec![], None).await.err().unwrap()
-    ));
 }
 
 async fn test_basic_debug_calls<C>(client: &C)
@@ -182,14 +163,16 @@ where
     };
 
     assert!(is_unimplemented(
-        TraceApiClient::call(client, CallRequest::default(), HashSet::default(), None)
+        TraceApiClient::trace_call(client, CallRequest::default(), HashSet::default(), None)
             .await
             .err()
             .unwrap()
     ));
-    assert!(is_unimplemented(TraceApiClient::call_many(client, vec![], None).await.err().unwrap()));
     assert!(is_unimplemented(
-        TraceApiClient::raw_transaction(client, Bytes::default(), HashSet::default(), None)
+        TraceApiClient::trace_call_many(client, vec![], None).await.err().unwrap()
+    ));
+    assert!(is_unimplemented(
+        TraceApiClient::trace_raw_transaction(client, Bytes::default(), HashSet::default(), None)
             .await
             .err()
             .unwrap()
@@ -206,13 +189,9 @@ where
             .err()
             .unwrap()
     ));
-    assert!(is_unimplemented(TraceApiClient::block(client, block_id).await.err().unwrap()));
-    assert!(is_unimplemented(TraceApiClient::filter(client, trace_filter).await.err().unwrap()));
-    assert!(is_unimplemented(
-        TraceApiClient::trace(client, H256::default(), vec![]).await.err().unwrap()
-    ));
+    assert!(is_unimplemented(TraceApiClient::trace_block(client, block_id).await.err().unwrap()));
     assert!(is_unimplemented(
-        TraceApiClient::transaction_traces(client, H256::default()).await.err().unwrap()
+        TraceApiClient::trace_filter(client, trace_filter).await.err().unwrap()
     ));
 }
 
diff --git a/crates/rpc/rpc-builder/tests/it/utils.rs b/crates/rpc/rpc-builder/tests/it/utils.rs
index bc9f696591d..5e8e8527b0e 100644
--- a/crates/rpc/rpc-builder/tests/it/utils.rs
+++ b/crates/rpc/rpc-builder/tests/it/utils.rs
@@ -4,6 +4,7 @@ use reth_rpc_builder::{
     RpcModuleBuilder, RpcModuleSelection, RpcServerConfig, RpcServerHandle,
     TransportRpcModuleConfig,
 };
+use reth_tasks::TokioTaskExecutor;
 use reth_transaction_pool::test_utils::{testing_pool, TestPool};
 use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
 
@@ -50,9 +51,11 @@ pub async fn launch_http_ws(modules: impl Into<RpcModuleSelection>) -> RpcServer
 }
 
 /// Returns an [RpcModuleBuilder] with testing components.
-pub fn test_rpc_builder() -> RpcModuleBuilder<NoopProvider, TestPool, NoopNetwork> {
+pub fn test_rpc_builder() -> RpcModuleBuilder<NoopProvider, TestPool, NoopNetwork, TokioTaskExecutor>
+{
     RpcModuleBuilder::default()
         .with_client(NoopProvider::default())
         .with_pool(testing_pool())
         .with_network(NoopNetwork::default())
+        .with_executor(TokioTaskExecutor::default())
 }
diff --git a/crates/rpc/rpc-engine-api/Cargo.toml b/crates/rpc/rpc-engine-api/Cargo.toml
index 3be1201f493..b2d68f31d8d 100644
--- a/crates/rpc/rpc-engine-api/Cargo.toml
+++ b/crates/rpc/rpc-engine-api/Cargo.toml
@@ -31,3 +31,6 @@ thiserror = "1.0.37"
 reth-interfaces = { path = "../../interfaces", features = ["test-utils"] }
 reth-provider = { path = "../../storage/provider", features = ["test-utils"] }
 assert_matches = "1.5.0"
+
+[features]
+optimism = ["reth-primitives/optimism", "reth-rpc-types/optimism"]
diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index c5e8df1d3f2..e0881d2e2af 100644
--- a/crates/rpc/rpc-engine-api/src/engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/engine_api.rs
@@ -1,14 +1,15 @@
 use crate::{message::EngineApiMessageVersion, EngineApiError, EngineApiMessage, EngineApiResult};
 use futures::StreamExt;
-use reth_executor::executor;
 use reth_interfaces::consensus::ForkchoiceState;
 use reth_primitives::{
     proofs::{self, EMPTY_LIST_HASH},
     BlockHash, BlockId, BlockNumber, ChainSpec, Hardfork, Header, SealedBlock, TransactionSigned,
-    H64, U256,
+    H256, H64, U256,
+};
+use reth_provider::{
+    BlockExecutor, BlockProvider, EvmEnvProvider, ExecutorFactory, HeaderProvider,
+    StateProviderFactory,
 };
-use reth_provider::{BlockProvider, EvmEnvProvider, HeaderProvider, StateProviderFactory};
-use reth_revm::database::{State, SubState};
 use reth_rlp::Decodable;
 use reth_rpc_types::engine::{
     ExecutionPayload, ExecutionPayloadBodies, ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
@@ -17,6 +18,7 @@ use reth_rpc_types::engine::{
 use std::{
     future::Future,
     pin::Pin,
+    sync::Arc,
     task::{ready, Context, Poll},
 };
 use tokio::sync::{mpsc, oneshot, watch};
@@ -37,7 +39,7 @@ const MAX_PAYLOAD_BODIES_LIMIT: u64 = 1024;
 pub struct EngineApi<Client> {
     client: Client,
     /// Consensus configuration
-    chain_spec: ChainSpec,
+    chain_spec: Arc<ChainSpec>,
     message_rx: UnboundedReceiverStream<EngineApiMessage>,
     forkchoice_state_tx: watch::Sender<ForkchoiceState>,
     // TODO: Placeholder for storing future blocks. Make cache bounded. Use lru
@@ -51,7 +53,7 @@ impl<Client: HeaderProvider + BlockProvider + StateProviderFactory + EvmEnvProvi
     /// Create new instance of [EngineApi].
     pub fn new(
         client: Client,
-        chain_spec: ChainSpec,
+        chain_spec: Arc<ChainSpec>,
         message_rx: mpsc::UnboundedReceiver<EngineApiMessage>,
         forkchoice_state_tx: watch::Sender<ForkchoiceState>,
     ) -> Self {
@@ -255,6 +257,9 @@ impl<Client: HeaderProvider + BlockProvider + StateProviderFactory + EvmEnvProvi
     /// state in the block header, then passes validation data back to Consensus layer, that
     /// adds the block to the head of its own blockchain and attests to it. The block is then
     /// broadcasted over the consensus p2p network in the form of a "Beacon block".
+    ///
+    /// These responses should adhere to the [Engine API Spec for
+    /// `engine_newPayload`](https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#specification).
     pub fn new_payload(&mut self, payload: ExecutionPayload) -> EngineApiResult<PayloadStatus> {
         let block = match self.try_construct_block(payload) {
             Ok(b) => b,
@@ -277,19 +282,28 @@ impl<Client: HeaderProvider + BlockProvider + StateProviderFactory + EvmEnvProvi
              return Ok(PayloadStatus::from_status(PayloadStatusEnum::Syncing))
         };
 
-        let parent_td = if let Some(parent_td) = self.client.header_td(&block.parent_hash)? {
-            parent_td
-        } else {
-            return Ok(PayloadStatus::from_status(PayloadStatusEnum::Invalid {
+        let Some(parent_td) = self.client.header_td(&block.parent_hash)? else { return Ok(PayloadStatus::from_status(PayloadStatusEnum::Invalid {
                 validation_error: EngineApiError::PayloadPreMerge.to_string(),
-            }))
-        };
+            })) };
 
         // Short circuit the check by passing parent total difficulty.
         if !self.chain_spec.fork(Hardfork::Paris).active_at_ttd(parent_td, U256::ZERO) {
+            // This case returns a `latestValidHash` of zero because it is required by the engine
+            // api spec:
+            //
+            // Client software MUST respond to this method call in the following way:
+            // {
+            //     status: INVALID,
+            //     latestValidHash:
+            // 0x0000000000000000000000000000000000000000000000000000000000000000,
+            //     validationError: errorMessage | null
+            // }
+            //
+            // if terminal block conditions are not satisfied
             return Ok(PayloadStatus::from_status(PayloadStatusEnum::Invalid {
                 validation_error: EngineApiError::PayloadPreMerge.to_string(),
-            }))
+            })
+            .with_latest_valid_hash(H256::zero()))
         }
 
         if block.timestamp <= parent.timestamp {
@@ -304,13 +318,10 @@ impl<Client: HeaderProvider + BlockProvider + StateProviderFactory + EvmEnvProvi
 
         let state_provider = self.client.latest()?;
         let total_difficulty = parent_td + block.header.difficulty;
-        match executor::execute_and_verify_receipt(
-            &block.unseal(),
-            total_difficulty,
-            None,
-            &self.chain_spec,
-            &mut SubState::new(State::new(&state_provider)),
-        ) {
+
+        let factory = reth_executor::Factory::new(self.chain_spec.clone());
+        let mut executor = factory.with_sp(&state_provider);
+        match executor.execute_and_verify_receipt(&block.unseal(), total_difficulty, None) {
             Ok(_) => Ok(PayloadStatus::new(PayloadStatusEnum::Valid, block_hash)),
             Err(err) => Ok(PayloadStatus::new(
                 PayloadStatusEnum::Invalid { validation_error: err.to_string() },
@@ -321,6 +332,9 @@ impl<Client: HeaderProvider + BlockProvider + StateProviderFactory + EvmEnvProvi
 
     /// Called to resolve chain forks and ensure that the Execution layer is working with the latest
     /// valid chain.
+    ///
+    /// These responses should adhere to the [Engine API Spec for
+    /// `engine_forkchoiceUpdated`](https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#specification-1).
     pub fn fork_choice_updated(
         &self,
         fork_choice_state: ForkchoiceState,
@@ -334,21 +348,74 @@ impl<Client: HeaderProvider + BlockProvider + StateProviderFactory + EvmEnvProvi
             }))
         }
 
-        // Block is not known, nothing to do.
-        if !self.client.is_known(&head_block_hash)? {
+        let Some(head) = self.client.header(&head_block_hash)? else {
+            // Block is not known, nothing to do
             return Ok(ForkchoiceUpdated::from_status(PayloadStatusEnum::Syncing))
-        }
+        };
 
         // The finalized block hash is not known, we are still syncing
         if !finalized_block_hash.is_zero() && !self.client.is_known(&finalized_block_hash)? {
             return Ok(ForkchoiceUpdated::from_status(PayloadStatusEnum::Syncing))
         }
 
+        let Some(head_td) = self.client.header_td(&head_block_hash)? else {
+            // internal error - we have the head block but not the total difficulty
+            return Ok(ForkchoiceUpdated::from_status(PayloadStatusEnum::Invalid {
+                validation_error: EngineApiError::Internal(
+                    reth_interfaces::provider::ProviderError::TotalDifficulty {
+                        number: head.number,
+                    }
+                    .into(),
+                )
+                .to_string(),
+            }))
+        };
+
+        // From the Engine API spec:
+        //
+        // If forkchoiceState.headBlockHash references a PoW block, client software MUST validate
+        // this block with respect to terminal block conditions according to EIP-3675. This check
+        // maps to the transition block validity section of the EIP. Additionally, if this
+        // validation fails, client software MUST NOT update the forkchoice state and MUST NOT
+        // begin a payload build process.
+        //
+        // We use ZERO here because as long as the total difficulty is above the ttd, we are sure
+        // that the block is EITHER:
+        //  * The terminal PoW block, or
+        //  * A child of the terminal PoW block
+        //
+        // Using the head.difficulty instead of U256::ZERO here would be incorrect because it would
+        // not return true on the terminal PoW block. For the terminal PoW block, head_td -
+        // head.difficulty would be less than the TTD, causing active_at_ttd to return false.
+        if !self.chain_spec.fork(Hardfork::Paris).active_at_ttd(head_td, U256::ZERO) {
+            // This case returns a `latestValidHash` of zero because it is required by the engine
+            // api spec:
+            //
+            // Client software MUST respond to this method call in the following way:
+            // {
+            //     status: INVALID,
+            //     latestValidHash:
+            // 0x0000000000000000000000000000000000000000000000000000000000000000,
+            //     validationError: errorMessage | null
+            // }
+            // obtained either from the Payload validation process or as a result of validating a
+            // terminal PoW block referenced by forkchoiceState.headBlockHash
+            return Ok(ForkchoiceUpdated::from_status(PayloadStatusEnum::Invalid {
+                validation_error: EngineApiError::PayloadPreMerge.to_string(),
+            })
+            .with_latest_valid_hash(H256::zero()))
+        }
+
         if let Err(error) = self.forkchoice_state_tx.send(fork_choice_state) {
             tracing::error!(target: "rpc::engine_api", ?error, "Failed to update forkchoice state");
         }
 
         if let Some(_attr) = payload_attributes {
+            #[cfg(feature = "optimism")]
+            if self.chain_spec.optimism.is_some() && _attr.gas_limit.is_none() {
+                return Err(EngineApiError::MissingGasLimitInPayloadAttributes)
+            }
+
             // TODO: optionally build the block
         }
 
@@ -392,7 +459,7 @@ impl<Client: HeaderProvider + BlockProvider + StateProviderFactory + EvmEnvProvi
         }
 
         // Attempt to look up terminal block hash
-        let local_hash = self.client.block_hash(U256::from(terminal_block_number.as_u64()))?;
+        let local_hash = self.client.block_hash(terminal_block_number.as_u64())?;
 
         // Transition configuration exchange is successful if block hashes match
         match local_hash {
@@ -443,7 +510,7 @@ mod tests {
     };
 
     fn setup_engine_api() -> (EngineApiTestHandle, EngineApi<Arc<MockEthProvider>>) {
-        let chain_spec = MAINNET.clone();
+        let chain_spec = Arc::new(MAINNET.clone());
         let client = Arc::new(MockEthProvider::default());
         let (msg_tx, msg_rx) = unbounded_channel();
         let (forkchoice_state_tx, forkchoice_state_rx) = watch::channel(ForkchoiceState::default());
@@ -458,7 +525,7 @@ mod tests {
     }
 
     struct EngineApiTestHandle {
-        chain_spec: ChainSpec,
+        chain_spec: Arc<ChainSpec>,
         client: Arc<MockEthProvider>,
         msg_tx: UnboundedSender<EngineApiMessage>,
         forkchoice_state_rx: WatchReceiver<ForkchoiceState>,
@@ -647,7 +714,8 @@ mod tests {
 
             let expected_result = PayloadStatus::from_status(PayloadStatusEnum::Invalid {
                 validation_error: EngineApiError::PayloadPreMerge.to_string(),
-            });
+            })
+            .with_latest_valid_hash(H256::zero());
             assert_matches!(result_rx.await, Ok(Ok(result)) => assert_eq!(result, expected_result));
         }
 
@@ -905,8 +973,13 @@ mod tests {
             let (handle, api) = setup_engine_api();
             tokio::spawn(api);
 
+            let ttd = handle.chain_spec.fork(Hardfork::Paris).ttd().unwrap();
             let finalized = random_header(90, None);
-            let head = random_header(100, None);
+            let mut head = random_header(100, None).unseal();
+
+            // set the difficulty so we know it is post-merge
+            head.difficulty = ttd;
+            let head = head.seal_slow();
             handle.client.extend_headers([
                 (head.hash(), head.clone().unseal()),
                 (finalized.hash(), finalized.clone().unseal()),
@@ -938,6 +1011,58 @@ mod tests {
             assert!(handle.forkchoice_state_has_changed());
             assert_eq!(handle.forkchoice_state(), state);
         }
+
+        #[tokio::test]
+        async fn forkchoice_updated_invalid_pow() {
+            let (handle, api) = setup_engine_api();
+            tokio::spawn(api);
+
+            let finalized = random_header(90, None);
+            let mut head = random_header(100, None).unseal();
+
+            // ensure we don't mess up when subtracting just in case
+            let ttd = handle.chain_spec.fork(Hardfork::Paris).ttd().unwrap();
+            assert!(ttd > finalized.difficulty);
+
+            // set the difficulty so we know it is post-merge
+            head.difficulty = ttd - U256::from(1) - finalized.difficulty;
+            let head = head.seal_slow();
+            handle.client.extend_headers([
+                (head.hash(), head.clone().unseal()),
+                (finalized.hash(), finalized.clone().unseal()),
+            ]);
+
+            let state = ForkchoiceState {
+                head_block_hash: head.hash(),
+                finalized_block_hash: finalized.hash(),
+                ..Default::default()
+            };
+
+            let (result_tx, result_rx) = oneshot::channel();
+            handle.send_message(EngineApiMessage::ForkchoiceUpdated(
+                EngineApiMessageVersion::V1,
+                state.clone(),
+                None,
+                result_tx,
+            ));
+
+            let expected_result = ForkchoiceUpdated {
+                payload_id: None,
+                payload_status: PayloadStatus {
+                    status: PayloadStatusEnum::Invalid {
+                        validation_error: EngineApiError::PayloadPreMerge.to_string(),
+                    },
+                    latest_valid_hash: Some(H256::zero()),
+                },
+            };
+            assert_matches!(result_rx.await, Ok(Ok(result)) => assert_eq!(result, expected_result));
+
+            // From the engine API spec:
+            //
+            // Additionally, if this validation fails, client software MUST NOT update the
+            // forkchoice state and MUST NOT begin a payload build process.
+            assert!(!handle.forkchoice_state_has_changed());
+        }
     }
 
     // https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#specification-3
diff --git a/crates/rpc/rpc-engine-api/src/error.rs b/crates/rpc/rpc-engine-api/src/error.rs
index 49c7c1afce1..f439f4bda50 100644
--- a/crates/rpc/rpc-engine-api/src/error.rs
+++ b/crates/rpc/rpc-engine-api/src/error.rs
@@ -87,4 +87,9 @@ pub enum EngineApiError {
     /// API encountered an internal error.
     #[error(transparent)]
     Internal(#[from] reth_interfaces::Error),
+    /// If the optimism feature flag is enabled, the payload attributes must have a present
+    /// gas limit for the forkchoice updated method.
+    #[cfg(feature = "optimism")]
+    #[error("Missing gas limit in payload attributes")]
+    MissingGasLimitInPayloadAttributes,
 }
diff --git a/crates/rpc/rpc-types/Cargo.toml b/crates/rpc/rpc-types/Cargo.toml
index 684cb06fd10..b2d1a6c2de7 100644
--- a/crates/rpc/rpc-types/Cargo.toml
+++ b/crates/rpc/rpc-types/Cargo.toml
@@ -27,6 +27,7 @@ jsonrpsee-types = { version = "0.16" }
 lru = "0.9"
 
 [dev-dependencies]
+rand = "0.8"
 reth-interfaces = { path = "../../interfaces", features = ["test-utils"] }
 
 [features]
diff --git a/crates/rpc/rpc-types/src/eth/block.rs b/crates/rpc/rpc-types/src/eth/block.rs
index a5dde53f097..aa74d1a63ef 100644
--- a/crates/rpc/rpc-types/src/eth/block.rs
+++ b/crates/rpc/rpc-types/src/eth/block.rs
@@ -8,7 +8,8 @@ use reth_rlp::Encodable;
 use serde::{ser::Error, Deserialize, Serialize, Serializer};
 use std::{collections::BTreeMap, ops::Deref};
 
-/// Block Transactions depending on the boolean attribute of `eth_getBlockBy*`
+/// Block Transactions depending on the boolean attribute of `eth_getBlockBy*`,
+/// or if used by `eth_getUncle*`
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum BlockTransactions {
@@ -16,8 +17,16 @@ pub enum BlockTransactions {
     Hashes(Vec<H256>),
     /// Full transactions
     Full(Vec<Transaction>),
+    /// Special case for uncle response.
+    Uncle,
+}
+impl BlockTransactions {
+    /// Check if the enum variant is
+    /// used for an uncle response.
+    pub fn is_uncle(&self) -> bool {
+        matches!(self, Self::Uncle)
+    }
 }
-
 /// Determines how the `transactions` field of [Block] should be filled.
 ///
 /// This essentially represents the `full:bool` argument in RPC calls that determine whether the
@@ -55,11 +64,14 @@ pub struct Block {
     /// Header of the block
     #[serde(flatten)]
     pub header: Header,
-    /// Total difficulty
-    pub total_difficulty: U256,
+    /// Total difficulty, this field is None only if representing
+    /// an Uncle block.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub total_difficulty: Option<U256>,
     /// Uncles' hashes
     pub uncles: Vec<H256>,
     /// Transactions
+    #[serde(skip_serializing_if = "BlockTransactions::is_uncle")]
     pub transactions: BlockTransactions,
     /// Integer the size of this block in bytes.
     pub size: Option<U256>,
@@ -67,6 +79,7 @@ pub struct Block {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub base_fee_per_gas: Option<U256>,
     /// Withdrawals
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub withdrawals: Option<Vec<Withdrawal>>,
 }
 
@@ -160,11 +173,29 @@ impl Block {
             uncles,
             transactions,
             base_fee_per_gas: base_fee_per_gas.map(U256::from),
-            total_difficulty,
+            total_difficulty: Some(total_difficulty),
             size: Some(U256::from(block_length)),
             withdrawals: block.withdrawals,
         }
     }
+
+    /// Build an RPC block response representing
+    /// an Uncle from its header.
+    pub fn uncle_block_from_header(header: PrimitiveHeader) -> Self {
+        let hash = header.hash_slow();
+        let rpc_header = Header::from_primitive_with_hash(header.clone(), hash);
+        let uncle_block = PrimitiveBlock { header, ..Default::default() };
+        let size = Some(U256::from(uncle_block.length()));
+        Self {
+            uncles: vec![],
+            header: rpc_header,
+            transactions: BlockTransactions::Uncle,
+            base_fee_per_gas: None,
+            withdrawals: None,
+            size,
+            total_difficulty: None,
+        }
+    }
 }
 
 /// Block header representation.
@@ -189,6 +220,7 @@ pub struct Header {
     /// Transactions receipts root hash
     pub receipts_root: H256,
     /// Withdrawals root hash
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub withdrawals_root: Option<H256>,
     /// Block number
     pub number: Option<U256>,
@@ -330,4 +362,43 @@ mod tests {
         let full = false;
         assert_eq!(BlockTransactionsKind::Hashes, full.into());
     }
+
+    #[test]
+    fn serde_block() {
+        let block = Block {
+            header: Header {
+                hash: Some(H256::from_low_u64_be(1)),
+                parent_hash: H256::from_low_u64_be(2),
+                uncles_hash: H256::from_low_u64_be(3),
+                author: Address::from_low_u64_be(4),
+                miner: Address::from_low_u64_be(4),
+                state_root: H256::from_low_u64_be(5),
+                transactions_root: H256::from_low_u64_be(6),
+                receipts_root: H256::from_low_u64_be(7),
+                withdrawals_root: Some(H256::from_low_u64_be(8)),
+                number: Some(U256::from(9)),
+                gas_used: U256::from(10),
+                gas_limit: U256::from(11),
+                extra_data: Bytes::from(vec![1, 2, 3]),
+                logs_bloom: Bloom::default(),
+                timestamp: U256::from(12),
+                difficulty: U256::from(13),
+                mix_hash: H256::from_low_u64_be(14),
+                nonce: Some(H64::from_low_u64_be(15)),
+            },
+            total_difficulty: Some(U256::from(100000)),
+            uncles: vec![H256::from_low_u64_be(17)],
+            transactions: BlockTransactions::Hashes(vec![H256::from_low_u64_be(18)]),
+            size: Some(U256::from(19)),
+            base_fee_per_gas: Some(U256::from(20)),
+            withdrawals: None,
+        };
+        let serialized = serde_json::to_string(&block).unwrap();
+        assert_eq!(
+            serialized,
+            r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000001","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000002","sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000003","author":"0x0000000000000000000000000000000000000004","miner":"0x0000000000000000000000000000000000000004","stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000005","transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000006","receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000007","withdrawalsRoot":"0x0000000000000000000000000000000000000000000000000000000000000008","number":"0x9","gasUsed":"0xa","gasLimit":"0xb","extraData":"0x010203","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","timestamp":"0xc","difficulty":"0xd","mixHash":"0x000000000000000000000000000000000000000000000000000000000000000e","nonce":"0x000000000000000f","totalDifficulty":"0x186a0","uncles":["0x0000000000000000000000000000000000000000000000000000000000000011"],"transactions":["0x0000000000000000000000000000000000000000000000000000000000000012"],"size":"0x13","baseFeePerGas":"0x14"}"#
+        );
+        let deserialized: Block = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(block, deserialized);
+    }
 }
diff --git a/crates/rpc/rpc-types/src/eth/call.rs b/crates/rpc/rpc-types/src/eth/call.rs
index dd69d809346..6076d073340 100644
--- a/crates/rpc/rpc-types/src/eth/call.rs
+++ b/crates/rpc/rpc-types/src/eth/call.rs
@@ -1,4 +1,4 @@
-use reth_primitives::{AccessList, Address, Bytes, U128, U256, U64};
+use reth_primitives::{AccessList, Address, Bytes, U256, U64};
 use serde::{Deserialize, Serialize};
 
 /// Call request
@@ -10,11 +10,11 @@ pub struct CallRequest {
     /// To
     pub to: Option<Address>,
     /// Gas Price
-    pub gas_price: Option<U128>,
+    pub gas_price: Option<U256>,
     /// EIP-1559 Max base fee the caller is willing to pay
-    pub max_fee_per_gas: Option<U128>,
+    pub max_fee_per_gas: Option<U256>,
     /// EIP-1559 Priority fee the caller is paying to the block author
-    pub max_priority_fee_per_gas: Option<U128>,
+    pub max_priority_fee_per_gas: Option<U256>,
     /// Gas
     pub gas: Option<U256>,
     /// Value
diff --git a/crates/rpc/rpc-types/src/eth/engine.rs b/crates/rpc/rpc-types/src/eth/engine.rs
index 548ed16645b..ea78817c9ee 100644
--- a/crates/rpc/rpc-types/src/eth/engine.rs
+++ b/crates/rpc/rpc-types/src/eth/engine.rs
@@ -161,6 +161,11 @@ impl PayloadStatus {
     pub fn from_status(status: PayloadStatusEnum) -> Self {
         Self { status, latest_valid_hash: None }
     }
+
+    pub fn with_latest_valid_hash(mut self, latest_valid_hash: H256) -> Self {
+        self.latest_valid_hash = Some(latest_valid_hash);
+        self
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
diff --git a/crates/rpc/rpc-types/src/eth/error.rs b/crates/rpc/rpc-types/src/eth/error.rs
new file mode 100644
index 00000000000..43a70feefb2
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/error.rs
@@ -0,0 +1,23 @@
+//! Commonly used errors for the `eth_` namespace.
+
+/// List of JSON-RPC error codes
+#[derive(Debug, Copy, PartialEq, Eq, Clone)]
+pub enum EthRpcErrorCode {
+    /// Failed to send transaction, See also <https://github.com/MetaMask/eth-rpc-errors/blob/main/src/error-constants.ts>
+    TransactionRejected,
+    /// Custom geth error code, <https://github.com/vapory-legacy/wiki/blob/master/JSON-RPC-Error-Codes-Improvement-Proposal.md>
+    ExecutionError,
+    /// <https://eips.ethereum.org/EIPS/eip-1898>
+    InvalidInput,
+}
+
+impl EthRpcErrorCode {
+    /// Returns the error code as `i32`
+    pub const fn code(&self) -> i32 {
+        match *self {
+            EthRpcErrorCode::TransactionRejected => -32003,
+            EthRpcErrorCode::ExecutionError => 3,
+            EthRpcErrorCode::InvalidInput => -32000,
+        }
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/index.rs b/crates/rpc/rpc-types/src/eth/index.rs
index 217a928e3ed..4ef83b6ceab 100644
--- a/crates/rpc/rpc-types/src/eth/index.rs
+++ b/crates/rpc/rpc-types/src/eth/index.rs
@@ -1,10 +1,12 @@
+use reth_primitives::U256;
 use serde::{
     de::{Error, Visitor},
     Deserialize, Deserializer, Serialize, Serializer,
 };
 use std::fmt;
 
-/// A hex encoded or decimal index
+/// A hex encoded or decimal index that's intended to be used as a rust index, hence it's
+/// deserialized into a `usize`.
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Default)]
 pub struct Index(usize);
 
@@ -14,12 +16,18 @@ impl From<Index> for usize {
     }
 }
 
+impl From<Index> for U256 {
+    fn from(idx: Index) -> Self {
+        U256::from(idx.0)
+    }
+}
+
 impl Serialize for Index {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        serializer.serialize_str(&format!("{:x}", self.0))
+        serializer.serialize_str(&format!("0x{:x}", self.0))
     }
 }
 
@@ -71,3 +79,20 @@ impl<'a> Deserialize<'a> for Index {
         deserializer.deserialize_any(IndexVisitor)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::{thread_rng, Rng};
+
+    #[test]
+    fn test_serde_index_rand() {
+        let mut rng = thread_rng();
+        for _ in 0..100 {
+            let index = Index(rng.gen());
+            let val = serde_json::to_string(&index).unwrap();
+            let de: Index = serde_json::from_str(&val).unwrap();
+            assert_eq!(index, de);
+        }
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/log.rs b/crates/rpc/rpc-types/src/eth/log.rs
index f17eda38d40..06becfe555c 100644
--- a/crates/rpc/rpc-types/src/eth/log.rs
+++ b/crates/rpc/rpc-types/src/eth/log.rs
@@ -27,3 +27,32 @@ pub struct Log {
     #[serde(default)]
     pub removed: bool,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn serde_log() {
+        let log = Log {
+            address: Address::from_low_u64_be(0x1234),
+            topics: vec![H256::from_low_u64_be(0x1234)],
+            data: Bytes::from(vec![0x12, 0x34]),
+            block_hash: Some(H256::from_low_u64_be(0x1234)),
+            block_number: Some(U256::from(0x1234)),
+            transaction_hash: Some(H256::from_low_u64_be(0x1234)),
+            transaction_index: Some(U256::from(0x1234)),
+            log_index: Some(U256::from(0x1234)),
+            transaction_log_index: Some(U256::from(0x1234)),
+            removed: false,
+        };
+        let serialized = serde_json::to_string(&log).unwrap();
+        assert_eq!(
+            serialized,
+            r#"{"address":"0x0000000000000000000000000000000000001234","topics":["0x0000000000000000000000000000000000000000000000000000000000001234"],"data":"0x1234","blockHash":"0x0000000000000000000000000000000000000000000000000000000000001234","blockNumber":"0x1234","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000001234","transactionIndex":"0x1234","logIndex":"0x1234","transactionLogIndex":"0x1234","removed":false}"#
+        );
+
+        let deserialized: Log = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(log, deserialized);
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/mod.rs b/crates/rpc/rpc-types/src/eth/mod.rs
index 60d40e999ce..3efa9750a79 100644
--- a/crates/rpc/rpc-types/src/eth/mod.rs
+++ b/crates/rpc/rpc-types/src/eth/mod.rs
@@ -4,6 +4,7 @@ mod account;
 mod block;
 mod call;
 pub mod engine;
+pub mod error;
 mod fee;
 mod filter;
 mod index;
diff --git a/crates/rpc/rpc-types/src/eth/pubsub.rs b/crates/rpc/rpc-types/src/eth/pubsub.rs
index 7fbd1e46bd6..5166e64368a 100644
--- a/crates/rpc/rpc-types/src/eth/pubsub.rs
+++ b/crates/rpc/rpc-types/src/eth/pubsub.rs
@@ -1,7 +1,7 @@
 //! Ethereum types for pub-sub
 
 use crate::{Log, RichHeader};
-use reth_primitives::{rpc::Filter, H256};
+use reth_primitives::{filter::Filter, H256};
 use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
 
 /// Subscription result.
diff --git a/crates/rpc/rpc-types/src/eth/state.rs b/crates/rpc/rpc-types/src/eth/state.rs
index c2d1edadce7..9fbc0d8a138 100644
--- a/crates/rpc/rpc-types/src/eth/state.rs
+++ b/crates/rpc/rpc-types/src/eth/state.rs
@@ -9,7 +9,7 @@ pub type StateOverride = HashMap<Address, AccountOverride>;
 
 /// Custom account override used in call
 #[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]
 #[allow(missing_docs)]
 pub struct AccountOverride {
     pub nonce: Option<u64>,
diff --git a/crates/rpc/rpc-types/src/eth/trace/common.rs b/crates/rpc/rpc-types/src/eth/trace/common.rs
new file mode 100644
index 00000000000..78ee088ce28
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/trace/common.rs
@@ -0,0 +1,14 @@
+//! Types used by tracing backends
+
+use serde::{Deserialize, Serialize};
+
+/// The result of a single transaction trace.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+#[allow(missing_docs)]
+pub enum TraceResult<Ok, Err> {
+    /// Untagged success variant
+    Success { result: Ok },
+    /// Untagged error variant
+    Error { error: Err },
+}
diff --git a/crates/rpc/rpc-types/src/eth/trace/geth/call.rs b/crates/rpc/rpc-types/src/eth/trace/geth/call.rs
new file mode 100644
index 00000000000..3723929a59a
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/trace/geth/call.rs
@@ -0,0 +1,87 @@
+use reth_primitives::{serde_helper::num::from_int_or_hex, Address, Bytes, H256, U256};
+use serde::{Deserialize, Serialize};
+
+/// <https://github.com/ethereum/go-ethereum/blob/91cb6f863a965481e51d5d9c0e5ccd54796fd967/eth/tracers/native/call.go#L44>
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CallFrame {
+    #[serde(rename = "type")]
+    pub typ: String,
+    pub from: Address,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub to: Option<Address>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<U256>,
+    #[serde(default, deserialize_with = "from_int_or_hex")]
+    pub gas: U256,
+    #[serde(default, deserialize_with = "from_int_or_hex", rename = "gasUsed")]
+    pub gas_used: U256,
+    pub input: Bytes,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<Bytes>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub calls: Option<Vec<CallFrame>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub logs: Option<Vec<CallLogFrame>>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CallLogFrame {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    address: Option<Address>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    topics: Option<Vec<H256>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    data: Option<Bytes>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CallConfig {
+    /// When set to true, this will only trace the primary (top-level) call and not any sub-calls.
+    /// It eliminates the additional processing for each call frame
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub only_top_call: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub with_log: Option<bool>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::trace::geth::*;
+
+    // See <https://github.com/ethereum/go-ethereum/tree/master/eth/tracers/internal/tracetest/testdata>
+    const DEFAULT: &str = include_str!("../../../../test_data/call_tracer/default.json");
+    const LEGACY: &str = include_str!("../../../../test_data/call_tracer/legacy.json");
+    const ONLY_TOP_CALL: &str =
+        include_str!("../../../../test_data/call_tracer/only_top_call.json");
+    const WITH_LOG: &str = include_str!("../../../../test_data/call_tracer/with_log.json");
+
+    #[test]
+    fn test_serialize_call_trace() {
+        let mut opts = GethDebugTracingCallOptions::default();
+        opts.tracing_options.config.disable_storage = Some(false);
+        opts.tracing_options.tracer =
+            Some(GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::CallTracer));
+        opts.tracing_options.tracer_config =
+            Some(GethDebugTracerConfig::BuiltInTracer(GethDebugBuiltInTracerConfig::CallTracer(
+                CallConfig { only_top_call: Some(true), with_log: Some(true) },
+            )));
+
+        assert_eq!(
+            serde_json::to_string(&opts).unwrap(),
+            r#"{"disableStorage":false,"tracer":"callTracer","tracerConfig":{"onlyTopCall":true,"withLog":true}}"#
+        );
+    }
+
+    #[test]
+    fn test_deserialize_call_trace() {
+        let _trace: CallFrame = serde_json::from_str(DEFAULT).unwrap();
+        let _trace: CallFrame = serde_json::from_str(LEGACY).unwrap();
+        let _trace: CallFrame = serde_json::from_str(ONLY_TOP_CALL).unwrap();
+        let trace: CallFrame = serde_json::from_str(WITH_LOG).unwrap();
+        let _logs = trace.logs.unwrap();
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/trace/geth/four_byte.rs b/crates/rpc/rpc-types/src/eth/trace/geth/four_byte.rs
new file mode 100644
index 00000000000..927df7b76cb
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/trace/geth/four_byte.rs
@@ -0,0 +1,34 @@
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+/// <https://github.com/ethereum/go-ethereum/blob/91cb6f863a965481e51d5d9c0e5ccd54796fd967/eth/tracers/native/4byte.go#L48>
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct FourByteFrame(pub BTreeMap<String, u64>);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::trace::geth::*;
+
+    const DEFAULT: &str = r#"{
+        "0x27dc297e-128": 1,
+        "0x38cc4831-0": 2,
+        "0x524f3889-96": 1,
+        "0xadf59f99-288": 1,
+        "0xc281d19e-0": 1
+    }"#;
+
+    #[test]
+    fn test_serialize_four_byte_trace() {
+        let mut opts = GethDebugTracingCallOptions::default();
+        opts.tracing_options.tracer =
+            Some(GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::FourByteTracer));
+
+        assert_eq!(serde_json::to_string(&opts).unwrap(), r#"{"tracer":"4byteTracer"}"#);
+    }
+
+    #[test]
+    fn test_deserialize_four_byte_trace() {
+        let _trace: FourByteFrame = serde_json::from_str(DEFAULT).unwrap();
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/trace/geth/mod.rs b/crates/rpc/rpc-types/src/eth/trace/geth/mod.rs
new file mode 100644
index 00000000000..e2d0776c063
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/trace/geth/mod.rs
@@ -0,0 +1,325 @@
+#![allow(missing_docs)]
+
+/// Geth tracing types
+use reth_primitives::{Bytes, JsonU256, H256, U256};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+// re-exports
+pub use self::{
+    call::{CallConfig, CallFrame},
+    four_byte::FourByteFrame,
+    noop::NoopFrame,
+    pre_state::{PreStateConfig, PreStateFrame},
+};
+
+mod call;
+mod four_byte;
+mod noop;
+mod pre_state;
+
+/// Result type for geth style transaction trace
+pub type TraceResult = crate::trace::common::TraceResult<serde_json::Value, String>;
+
+/// blockTraceResult represents the results of tracing a single block when an entire chain is being
+/// traced. ref <https://github.com/ethereum/go-ethereum/blob/ee530c0d5aa70d2c00ab5691a89ab431b73f8165/eth/tracers/api.go#L218-L222>
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BlockTraceResult {
+    /// Block number corresponding to the trace task
+    pub block: U256,
+    /// Block hash corresponding to the trace task
+    pub hash: H256,
+    /// Trace results produced by the trace task
+    pub traces: Vec<TraceResult>,
+}
+
+/// Geth Default trace frame
+///
+/// <https://github.com/ethereum/go-ethereum/blob/a9ef135e2dd53682d106c6a2aede9187026cc1de/eth/tracers/logger/logger.go#L406-L411>
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DefaultFrame {
+    pub failed: bool,
+    pub gas: JsonU256,
+    pub return_value: Bytes,
+    pub struct_logs: Vec<StructLog>,
+}
+
+/// Represents a struct log entry in a trace
+///
+/// <https://github.com/ethereum/go-ethereum/blob/366d2169fbc0e0f803b68c042b77b6b480836dbc/eth/tracers/logger/logger.go#L413-L426>
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct StructLog {
+    /// program counter
+    pub pc: u64,
+    /// opcode to be executed
+    pub op: String,
+    /// remaining gas
+    pub gas: u64,
+    /// cost for executing op
+    #[serde(rename = "gasCost")]
+    pub gas_cost: u64,
+    /// ref <https://github.com/ethereum/go-ethereum/blob/366d2169fbc0e0f803b68c042b77b6b480836dbc/eth/tracers/logger/logger.go#L450-L452>
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub memory: Option<Vec<String>>,
+    /// Size of memory.
+    #[serde(rename = "memSize")]
+    pub memory_size: u64,
+    /// EVM stack
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub stack: Option<Vec<U256>>,
+    /// Last call's return data. Enabled via enableReturnData
+    #[serde(default, rename = "refund", skip_serializing_if = "Option::is_none")]
+    pub return_data: Option<Bytes>,
+    /// Storage slots of current contract read from and written to. Only emitted for SLOAD and
+    /// SSTORE. Disabled via disableStorage
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub storage: Option<BTreeMap<H256, H256>>,
+    /// Current call depth
+    pub depth: u64,
+    /// Refund counter
+    #[serde(default, rename = "refund", skip_serializing_if = "Option::is_none")]
+    pub refund_counter: Option<u64>,
+    /// Error message if any
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+
+/// Tracing response
+#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum GethTraceFrame {
+    Default(DefaultFrame),
+    NoopTracer(NoopFrame),
+    FourByteTracer(FourByteFrame),
+    CallTracer(CallFrame),
+    PreStateTracer(PreStateFrame),
+}
+
+impl From<DefaultFrame> for GethTraceFrame {
+    fn from(value: DefaultFrame) -> Self {
+        GethTraceFrame::Default(value)
+    }
+}
+
+impl From<FourByteFrame> for GethTraceFrame {
+    fn from(value: FourByteFrame) -> Self {
+        GethTraceFrame::FourByteTracer(value)
+    }
+}
+
+impl From<CallFrame> for GethTraceFrame {
+    fn from(value: CallFrame) -> Self {
+        GethTraceFrame::CallTracer(value)
+    }
+}
+
+impl From<PreStateFrame> for GethTraceFrame {
+    fn from(value: PreStateFrame) -> Self {
+        GethTraceFrame::PreStateTracer(value)
+    }
+}
+
+impl From<NoopFrame> for GethTraceFrame {
+    fn from(value: NoopFrame) -> Self {
+        GethTraceFrame::NoopTracer(value)
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum GethTrace {
+    Known(GethTraceFrame),
+    Unknown(serde_json::Value),
+}
+
+impl From<GethTraceFrame> for GethTrace {
+    fn from(value: GethTraceFrame) -> Self {
+        GethTrace::Known(value)
+    }
+}
+
+impl From<serde_json::Value> for GethTrace {
+    fn from(value: serde_json::Value) -> Self {
+        GethTrace::Unknown(value)
+    }
+}
+
+/// Available built-in tracers
+///
+/// See <https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers>
+#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
+pub enum GethDebugBuiltInTracerType {
+    /// The 4byteTracer collects the function selectors of every function executed in the lifetime
+    /// of a transaction, along with the size of the supplied call data. The result is a
+    /// [FourByteFrame] where the keys are SELECTOR-CALLDATASIZE and the values are number of
+    /// occurrences of this key.
+    #[serde(rename = "4byteTracer")]
+    FourByteTracer,
+    /// The callTracer tracks all the call frames executed during a transaction, including depth 0.
+    /// The result will be a nested list of call frames, resembling how EVM works. They form a tree
+    /// with the top-level call at root and sub-calls as children of the higher levels.
+    #[serde(rename = "callTracer")]
+    CallTracer,
+    /// The prestate tracer has two modes: prestate and diff. The prestate mode returns the
+    /// accounts necessary to execute a given transaction. diff mode returns the differences
+    /// between the transaction's pre and post-state (i.e. what changed because the transaction
+    /// happened). The prestateTracer defaults to prestate mode. It reexecutes the given
+    /// transaction and tracks every part of state that is touched. This is similar to the concept
+    /// of a stateless witness, the difference being this tracer doesn't return any cryptographic
+    /// proof, rather only the trie leaves. The result is an object. The keys are addresses of
+    /// accounts.
+    #[serde(rename = "prestateTracer")]
+    PreStateTracer,
+    /// This tracer is noop. It returns an empty object and is only meant for testing the setup.
+    #[serde(rename = "noopTracer")]
+    NoopTracer,
+}
+
+/// Configuration for the builtin tracer
+#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum GethDebugBuiltInTracerConfig {
+    CallTracer(CallConfig),
+    PreStateTracer(PreStateConfig),
+}
+
+// === impl GethDebugBuiltInTracerConfig ===
+
+impl GethDebugBuiltInTracerConfig {
+    /// Returns true if the config matches the given tracer
+    pub fn matches_tracer(&self, tracer: &GethDebugBuiltInTracerType) -> bool {
+        matches!(
+            (self, tracer),
+            (GethDebugBuiltInTracerConfig::CallTracer(_), GethDebugBuiltInTracerType::CallTracer,) |
+                (
+                    GethDebugBuiltInTracerConfig::PreStateTracer(_),
+                    GethDebugBuiltInTracerType::PreStateTracer,
+                )
+        )
+    }
+}
+
+/// Available tracers
+///
+/// See <https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers> and <https://geth.ethereum.org/docs/developers/evm-tracing/custom-tracer>
+#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum GethDebugTracerType {
+    /// built-in tracer
+    BuiltInTracer(GethDebugBuiltInTracerType),
+    /// custom JS tracer
+    JsTracer(String),
+}
+
+/// Configuration of the tracer
+#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum GethDebugTracerConfig {
+    /// built-in tracer
+    BuiltInTracer(GethDebugBuiltInTracerConfig),
+    /// custom JS tracer
+    JsTracer(serde_json::Value),
+}
+
+// === impl GethDebugTracerConfig ===
+
+impl GethDebugTracerConfig {
+    /// Returns the [CallConfig] if it is a call config.
+    pub fn into_call_config(self) -> Option<CallConfig> {
+        match self {
+            GethDebugTracerConfig::BuiltInTracer(GethDebugBuiltInTracerConfig::CallTracer(cfg)) => {
+                Some(cfg)
+            }
+            _ => None,
+        }
+    }
+
+    /// Returns the [PreStateConfig] if it is a call config.
+    pub fn into_pre_state_config(self) -> Option<PreStateConfig> {
+        match self {
+            GethDebugTracerConfig::BuiltInTracer(GethDebugBuiltInTracerConfig::PreStateTracer(
+                cfg,
+            )) => Some(cfg),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the config matches the given tracer
+    pub fn matches_tracer(&self, tracer: &GethDebugTracerType) -> bool {
+        match (self, tracer) {
+            (_, GethDebugTracerType::BuiltInTracer(tracer)) => self.matches_builtin_tracer(tracer),
+            (GethDebugTracerConfig::JsTracer(_), GethDebugTracerType::JsTracer(_)) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the config matches the given tracer
+    pub fn matches_builtin_tracer(&self, tracer: &GethDebugBuiltInTracerType) -> bool {
+        match (self, tracer) {
+            (GethDebugTracerConfig::BuiltInTracer(config), tracer) => config.matches_tracer(tracer),
+            (GethDebugTracerConfig::JsTracer(_), _) => false,
+        }
+    }
+}
+
+/// Bindings for additional `debug_traceTransaction` options
+///
+/// See <https://geth.ethereum.org/docs/rpc/ns-debug#debug_tracetransaction>
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct GethDebugTracingOptions {
+    #[serde(default, flatten)]
+    pub config: GethDefaultTracingOptions,
+    /// The custom tracer to use.
+    ///
+    /// If `None` then the default structlog tracer is used.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tracer: Option<GethDebugTracerType>,
+    /// tracerConfig is slated for Geth v1.11.0
+    /// See <https://github.com/ethereum/go-ethereum/issues/26513>
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tracer_config: Option<GethDebugTracerConfig>,
+    /// A string of decimal integers that overrides the JavaScript-based tracing calls default
+    /// timeout of 5 seconds.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<String>,
+}
+
+/// Default tracing options for the struct looger
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct GethDefaultTracingOptions {
+    /// enable memory capture
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enable_memory: Option<bool>,
+    /// disable stack capture
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub disable_stack: Option<bool>,
+    /// disable storage capture
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub disable_storage: Option<bool>,
+    /// enable return data capture
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enable_return_data: Option<bool>,
+    /// print output during capture end
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub debug: Option<bool>,
+    /// maximum length of output, but zero means unlimited
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<u64>,
+    /// Chain overrides, can be used to execute a trace using future fork rules
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub overrides: Option<serde_json::Value>,
+}
+
+/// Bindings for additional `debug_traceCall` options
+///
+/// See <https://geth.ethereum.org/docs/rpc/ns-debug#debug_tracecall>
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct GethDebugTracingCallOptions {
+    #[serde(flatten)]
+    pub tracing_options: GethDebugTracingOptions,
+    // TODO: Add stateoverrides and blockoverrides options
+}
diff --git a/crates/rpc/rpc-types/src/eth/trace/geth/noop.rs b/crates/rpc/rpc-types/src/eth/trace/geth/noop.rs
new file mode 100644
index 00000000000..003b1dcc99c
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/trace/geth/noop.rs
@@ -0,0 +1,30 @@
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+/// <https://github.com/ethereum/go-ethereum/blob/91cb6f863a965481e51d5d9c0e5ccd54796fd967/eth/tracers/native/noop.go#L34>
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct NoopFrame(BTreeMap<Null, Null>);
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord)]
+struct Null;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::trace::geth::*;
+
+    const DEFAULT: &str = r#"{}"#;
+
+    #[test]
+    fn test_serialize_noop_trace() {
+        let mut opts = GethDebugTracingCallOptions::default();
+        opts.tracing_options.tracer =
+            Some(GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::NoopTracer));
+
+        assert_eq!(serde_json::to_string(&opts).unwrap(), r#"{"tracer":"noopTracer"}"#);
+    }
+
+    #[test]
+    fn test_deserialize_noop_trace() {
+        let _trace: NoopFrame = serde_json::from_str(DEFAULT).unwrap();
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/trace/geth/pre_state.rs b/crates/rpc/rpc-types/src/eth/trace/geth/pre_state.rs
new file mode 100644
index 00000000000..e8bde9fbd83
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/trace/geth/pre_state.rs
@@ -0,0 +1,89 @@
+use reth_primitives::{serde_helper::num::from_int_or_hex_opt, Address, H256, U256};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+/// <https://github.com/ethereum/go-ethereum/blob/91cb6f863a965481e51d5d9c0e5ccd54796fd967/eth/tracers/native/prestate.go#L38>
+#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum PreStateFrame {
+    Default(PreStateMode),
+    Diff(DiffMode),
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PreStateMode(pub BTreeMap<Address, AccountState>);
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DiffMode {
+    pub pre: BTreeMap<Address, AccountState>,
+    pub post: BTreeMap<Address, AccountState>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AccountState {
+    #[serde(
+        default,
+        deserialize_with = "from_int_or_hex_opt",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub balance: Option<U256>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(
+        default,
+        deserialize_with = "from_int_or_hex_opt",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub nonce: Option<U256>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub storage: Option<BTreeMap<H256, H256>>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PreStateConfig {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub diff_mode: Option<bool>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::trace::geth::*;
+
+    // See <https://github.com/ethereum/go-ethereum/tree/master/eth/tracers/internal/tracetest/testdata>
+    const DEFAULT: &str = include_str!("../../../../test_data/pre_state_tracer/default.json");
+    const LEGACY: &str = include_str!("../../../../test_data/pre_state_tracer/legacy.json");
+    const DIFF_MODE: &str = include_str!("../../../../test_data/pre_state_tracer/diff_mode.json");
+
+    #[test]
+    fn test_serialize_pre_state_trace() {
+        let mut opts = GethDebugTracingCallOptions::default();
+        opts.tracing_options.config.disable_storage = Some(false);
+        opts.tracing_options.tracer =
+            Some(GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::PreStateTracer));
+        opts.tracing_options.tracer_config = Some(GethDebugTracerConfig::BuiltInTracer(
+            GethDebugBuiltInTracerConfig::PreStateTracer(PreStateConfig { diff_mode: Some(true) }),
+        ));
+
+        assert_eq!(
+            serde_json::to_string(&opts).unwrap(),
+            r#"{"disableStorage":false,"tracer":"prestateTracer","tracerConfig":{"diffMode":true}}"#
+        );
+    }
+
+    #[test]
+    fn test_deserialize_pre_state_trace() {
+        let trace: PreStateFrame = serde_json::from_str(DEFAULT).unwrap();
+        match trace {
+            PreStateFrame::Default(PreStateMode(_)) => {}
+            _ => unreachable!(),
+        }
+        let _trace: PreStateFrame = serde_json::from_str(LEGACY).unwrap();
+        let trace: PreStateFrame = serde_json::from_str(DIFF_MODE).unwrap();
+        match trace {
+            PreStateFrame::Diff(DiffMode { pre: _pre, post: _post }) => {}
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/trace/mod.rs b/crates/rpc/rpc-types/src/eth/trace/mod.rs
index 9270dbe1e57..d4ec6960f0d 100644
--- a/crates/rpc/rpc-types/src/eth/trace/mod.rs
+++ b/crates/rpc/rpc-types/src/eth/trace/mod.rs
@@ -1,4 +1,6 @@
 //! Types for tracing
 
+pub mod common;
 pub mod filter;
+pub mod geth;
 pub mod parity;
diff --git a/crates/rpc/rpc-types/src/eth/trace/parity.rs b/crates/rpc/rpc-types/src/eth/trace/parity.rs
index 80c4359794c..a6f865a1728 100644
--- a/crates/rpc/rpc-types/src/eth/trace/parity.rs
+++ b/crates/rpc/rpc-types/src/eth/trace/parity.rs
@@ -7,6 +7,23 @@ use reth_primitives::{Address, Bytes, H256, U256, U64};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
+/// Result type for parity style transaction trace
+pub type TraceResult = crate::trace::common::TraceResult<TraceOutput, String>;
+
+// === impl TraceResult ===
+
+impl TraceResult {
+    /// Wraps the result type in a [TraceResult::Success] variant
+    pub fn parity_success(result: TraceOutput) -> Self {
+        TraceResult::Success { result }
+    }
+
+    /// Wraps the result type in a [TraceResult::Error] variant
+    pub fn parity_error(error: String) -> Self {
+        TraceResult::Error { error }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum TraceType {
@@ -75,11 +92,26 @@ pub enum Action {
     Reward(RewardAction),
 }
 
+/// An external action type.
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ActionType {
+    /// Contract call.
+    Call,
+    /// Contract creation.
+    Create,
+    /// Contract suicide/selfdestruct.
+    Selfdestruct,
+    /// A block reward.
+    Reward,
+}
+
 /// Call type.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum CallType {
     /// None
+    #[default]
     None,
     /// Call
     Call,
@@ -156,13 +188,6 @@ pub enum TraceOutput {
     Create(CreateOutput),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum TraceResult {
-    Success { result: TraceOutput },
-    Error { error: String },
-}
-
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionTrace {
@@ -179,10 +204,18 @@ pub struct TransactionTrace {
 pub struct LocalizedTransactionTrace {
     #[serde(flatten)]
     pub trace: TransactionTrace,
+    /// Transaction index within the block, None if pending.
     pub transaction_position: Option<usize>,
+    /// Hash of the transaction
     pub transaction_hash: Option<H256>,
-    pub block_number: U64,
-    pub block_hash: H256,
+    /// Block number the transaction is included in, None if pending.
+    ///
+    /// Note: this deviates from <https://openethereum.github.io/JSONRPC-trace-module#trace_transaction> which always returns a block number
+    pub block_number: Option<u64>,
+    /// Hash of the block, if not pending
+    ///
+    /// Note: this deviates from <https://openethereum.github.io/JSONRPC-trace-module#trace_transaction> which always returns a block number
+    pub block_hash: Option<H256>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
diff --git a/crates/rpc/rpc-types/src/eth/transaction/common.rs b/crates/rpc/rpc-types/src/eth/transaction/common.rs
new file mode 100644
index 00000000000..fd02a66bc11
--- /dev/null
+++ b/crates/rpc/rpc-types/src/eth/transaction/common.rs
@@ -0,0 +1,17 @@
+//! Commonly used additional types that are not part of the JSON RPC spec but are often required
+//! when working with RPC types, such as [Transaction](crate::Transaction)
+
+use reth_primitives::{TxHash, H256};
+
+/// Additional fields in the context of a block that contains this transaction.
+#[derive(Debug, Clone, Copy, Default, Eq, PartialEq)]
+pub struct TransactionInfo {
+    /// Hash of the transaction.
+    pub hash: Option<TxHash>,
+    /// Index of the transaction in the block
+    pub index: Option<usize>,
+    /// Hash of the block.
+    pub block_hash: Option<H256>,
+    /// Number of the block.
+    pub block_number: Option<u64>,
+}
diff --git a/crates/rpc/rpc-types/src/eth/transaction/mod.rs b/crates/rpc/rpc-types/src/eth/transaction/mod.rs
index 035f00890bb..5da51012b30 100644
--- a/crates/rpc/rpc-types/src/eth/transaction/mod.rs
+++ b/crates/rpc/rpc-types/src/eth/transaction/mod.rs
@@ -1,8 +1,10 @@
+mod common;
 mod receipt;
 mod request;
 mod signature;
 mod typed;
 
+pub use common::TransactionInfo;
 pub use receipt::TransactionReceipt;
 pub use request::TransactionRequest;
 pub use signature::Signature;
@@ -74,7 +76,7 @@ impl Transaction {
     ///
     /// The block hash, number, and tx index fields should be from the original block where the
     /// transaction was mined.
-    pub(crate) fn from_recovered_with_block_context(
+    pub fn from_recovered_with_block_context(
         tx: TransactionSignedEcRecovered,
         block_hash: H256,
         block_number: BlockNumber,
@@ -87,9 +89,9 @@ impl Transaction {
         tx
     }
 
-    /// Create a new rpc transaction result for a pending signed transaction, setting block
+    /// Create a new rpc transaction result for a _pending_ signed transaction, setting block
     /// environment related fields to `None`.
-    pub(crate) fn from_recovered(tx: TransactionSignedEcRecovered) -> Self {
+    pub fn from_recovered(tx: TransactionSignedEcRecovered) -> Self {
         let signer = tx.signer();
         let signed_tx = tx.into_signed();
 
@@ -146,7 +148,7 @@ impl Transaction {
             max_fee_per_gas,
             max_priority_fee_per_gas: signed_tx.max_priority_fee_per_gas().map(U128::from),
             signature: Some(Signature::from_primitive_signature(
-                signed_tx.signature().clone(),
+                *signed_tx.signature(),
                 signed_tx.chain_id(),
             )),
             gas: U256::from(signed_tx.gas_limit()),
@@ -157,3 +159,38 @@ impl Transaction {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn serde_transaction() {
+        let transaction = Transaction {
+            hash: H256::from_low_u64_be(1),
+            nonce: U256::from(2),
+            block_hash: Some(H256::from_low_u64_be(3)),
+            block_number: Some(U256::from(4)),
+            transaction_index: Some(U256::from(5)),
+            from: Address::from_low_u64_be(6),
+            to: Some(Address::from_low_u64_be(7)),
+            value: U256::from(8),
+            gas_price: Some(U128::from(9)),
+            gas: U256::from(10),
+            input: Bytes::from(vec![11, 12, 13]),
+            signature: Some(Signature { v: U256::from(14), r: U256::from(14), s: U256::from(14) }),
+            chain_id: Some(U64::from(17)),
+            access_list: None,
+            transaction_type: Some(U64::from(20)),
+            max_fee_per_gas: Some(U128::from(21)),
+            max_priority_fee_per_gas: Some(U128::from(22)),
+        };
+        let serialized = serde_json::to_string(&transaction).unwrap();
+        assert_eq!(
+            serialized,
+            r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000001","nonce":"0x2","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000003","blockNumber":"0x4","transactionIndex":"0x5","from":"0x0000000000000000000000000000000000000006","to":"0x0000000000000000000000000000000000000007","value":"0x8","gasPrice":"0x9","gas":"0xa","maxFeePerGas":"0x15","maxPriorityFeePerGas":"0x16","input":"0x0b0c0d","r":"0xe","s":"0xe","v":"0xe","chainId":"0x11","type":"0x14"}"#
+        );
+        let deserialized: Transaction = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(transaction, deserialized);
+    }
+}
diff --git a/crates/rpc/rpc-types/src/eth/transaction/typed.rs b/crates/rpc/rpc-types/src/eth/transaction/typed.rs
index bcca7a0b758..f91903c6966 100644
--- a/crates/rpc/rpc-types/src/eth/transaction/typed.rs
+++ b/crates/rpc/rpc-types/src/eth/transaction/typed.rs
@@ -83,18 +83,18 @@ impl TransactionKind {
 }
 
 impl Encodable for TransactionKind {
-    fn length(&self) -> usize {
-        match self {
-            TransactionKind::Call(to) => to.length(),
-            TransactionKind::Create => ([]).length(),
-        }
-    }
     fn encode(&self, out: &mut dyn BufMut) {
         match self {
             TransactionKind::Call(to) => to.encode(out),
             TransactionKind::Create => ([]).encode(out),
         }
     }
+    fn length(&self) -> usize {
+        match self {
+            TransactionKind::Call(to) => to.length(),
+            TransactionKind::Create => ([]).length(),
+        }
+    }
 }
 
 impl Decodable for TransactionKind {
diff --git a/crates/rpc/rpc-types/test_data/call_tracer/default.json b/crates/rpc/rpc-types/test_data/call_tracer/default.json
new file mode 100644
index 00000000000..553b2a39795
--- /dev/null
+++ b/crates/rpc/rpc-types/test_data/call_tracer/default.json
@@ -0,0 +1,21 @@
+{
+    "calls": [
+        {
+            "from": "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe",
+            "gas": "0x6d05",
+            "gasUsed": "0x0",
+            "input": "0x",
+            "to": "0x0024f658a46fbb89d8ac105e98d7ac7cbbaf27c5",
+            "type": "CALL",
+            "value": "0x6f05b59d3b20000"
+        }
+    ],
+    "from": "0xb436ba50d378d4bbc8660d312a13df6af6e89dfb",
+    "gas": "0x10738",
+    "gasUsed": "0x9751",
+    "input": "0x63e4bff40000000000000000000000000024f658a46fbb89d8ac105e98d7ac7cbbaf27c5",
+    "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+    "to": "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe",
+    "type": "CALL",
+    "value": "0x0"
+}
diff --git a/crates/rpc/rpc-types/test_data/call_tracer/legacy.json b/crates/rpc/rpc-types/test_data/call_tracer/legacy.json
new file mode 100644
index 00000000000..b89e7ae86c4
--- /dev/null
+++ b/crates/rpc/rpc-types/test_data/call_tracer/legacy.json
@@ -0,0 +1,19 @@
+{
+    "calls": [
+        {
+            "from": "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe",
+            "input": "0x",
+            "to": "0x0024f658a46fbb89d8ac105e98d7ac7cbbaf27c5",
+            "type": "CALL",
+            "value": "0x6f05b59d3b20000"
+        }
+    ],
+    "from": "0xb436ba50d378d4bbc8660d312a13df6af6e89dfb",
+    "gas": "0x10738",
+    "gasUsed": "0x9751",
+    "input": "0x63e4bff40000000000000000000000000024f658a46fbb89d8ac105e98d7ac7cbbaf27c5",
+    "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+    "to": "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe",
+    "type": "CALL",
+    "value": "0x0"
+}
diff --git a/crates/rpc/rpc-types/test_data/call_tracer/only_top_call.json b/crates/rpc/rpc-types/test_data/call_tracer/only_top_call.json
new file mode 100644
index 00000000000..327bb427874
--- /dev/null
+++ b/crates/rpc/rpc-types/test_data/call_tracer/only_top_call.json
@@ -0,0 +1,10 @@
+{
+    "from": "0x4f5777744b500616697cb655dcb02ee6cd51deb5",
+    "gas": "0x2dced",
+    "gasUsed": "0x1a9e5",
+    "to": "0x200edd17f30485a8735878661960cd7a9a95733f",
+    "input": "0xba51a6df0000000000000000000000000000000000000000000000000000000000000000",
+    "output": "0xba51a6df00000000000000000000000000000000000000000000000000000000",
+    "value": "0x8ac7230489e80000",
+    "type": "CALL"
+}
diff --git a/crates/rpc/rpc-types/test_data/call_tracer/with_log.json b/crates/rpc/rpc-types/test_data/call_tracer/with_log.json
new file mode 100644
index 00000000000..2528bbc0484
--- /dev/null
+++ b/crates/rpc/rpc-types/test_data/call_tracer/with_log.json
@@ -0,0 +1,20 @@
+{
+    "from": "0xd1220a0cf47c7b9be7a2e6ba89f429762e7b9adb",
+    "gas": "0x1f36d",
+    "gasUsed": "0xc6a5",
+    "to": "0xf4eced2f682ce333f96f2d8966c613ded8fc95dd",
+    "input": "0xa9059cbb000000000000000000000000dbf03b407c01e7cd3cbea99509d93f8dddc8c6fb0000000000000000000000000000000000000000000000000000000000989680",
+    "logs": [
+        {
+            "address": "0xf4eced2f682ce333f96f2d8966c613ded8fc95dd",
+            "topics": [
+            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+            "0x000000000000000000000000d1220a0cf47c7b9be7a2e6ba89f429762e7b9adb",
+            "0x000000000000000000000000dbf03b407c01e7cd3cbea99509d93f8dddc8c6fb"
+            ],
+            "data": "0x0000000000000000000000000000000000000000000000000000000000989680"
+        }
+    ],
+    "value": "0x0",
+    "type": "CALL"
+}
diff --git a/crates/rpc/rpc-types/test_data/pre_state_tracer/default.json b/crates/rpc/rpc-types/test_data/pre_state_tracer/default.json
new file mode 100644
index 00000000000..43e69b11bdb
--- /dev/null
+++ b/crates/rpc/rpc-types/test_data/pre_state_tracer/default.json
@@ -0,0 +1,20 @@
+{
+    "0x082d4cdf07f386ffa9258f52a5c49db4ac321ec6": {
+        "balance": "0xc820f93200f4000",
+        "nonce": 94
+    },
+    "0x332b656504f4eabb44c8617a42af37461a34e9dc": {
+        "balance": "0x11faea4f35e5af80000",
+        "storage": {
+            "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000000000000000000000000000000000000000000000"
+        }
+    },
+    "0x52bc44d5378309ee2abf1539bf71de1b7d7be3b5": {
+        "balance": "0xbf681825be002ac452",
+        "nonce": 28922
+    },
+    "0x82effbaaaf28614e55b2ba440fb198e0e5789b0f": {
+        "balance": "0xb3d0ac5cb94df6f6b0",
+        "nonce": 1
+    }
+}
diff --git a/crates/rpc/rpc-types/test_data/pre_state_tracer/diff_mode.json b/crates/rpc/rpc-types/test_data/pre_state_tracer/diff_mode.json
new file mode 100644
index 00000000000..0654d26f546
--- /dev/null
+++ b/crates/rpc/rpc-types/test_data/pre_state_tracer/diff_mode.json
@@ -0,0 +1,41 @@
+{
+    "pre": {
+        "0x0024f658a46fbb89d8ac105e98d7ac7cbbaf27c5": {
+            "balance": "0x0",
+            "nonce": 22
+        },
+        "0x1585936b53834b021f68cc13eeefdec2efc8e724": {
+            "balance": "0x0"
+        },
+        "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe": {
+            "balance": "0x4d87094125a369d9bd5",
+            "nonce": 1,
+            "code": "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",
+            "storage": {
+                "0x0000000000000000000000000000000000000000000000000000000000000003": "0x000000000000000000000000000000000000000000000000000000005a37b834"
+            }
+        },
+        "0xb436ba50d378d4bbc8660d312a13df6af6e89dfb": {
+            "balance": "0x1780d77678137ac1b775",
+            "nonce": 29072
+        }
+    },
+    "post": {
+        "0x0024f658a46fbb89d8ac105e98d7ac7cbbaf27c5": {
+            "balance": "0x6f05b59d3b20000"
+        },
+        "0x1585936b53834b021f68cc13eeefdec2efc8e724": {
+            "balance": "0x420eed1bd6c00"
+        },
+        "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe": {
+            "balance": "0x4d869a3b70062eb9bd5",
+            "storage": {
+                "0x0000000000000000000000000000000000000000000000000000000000000003": "0x000000000000000000000000000000000000000000000000000000005a37b95e"
+            }
+        },
+        "0xb436ba50d378d4bbc8660d312a13df6af6e89dfb": {
+            "balance": "0x1780d7725724a9044b75",
+            "nonce": 29073
+        }
+    }
+}
diff --git a/crates/rpc/rpc-types/test_data/pre_state_tracer/legacy.json b/crates/rpc/rpc-types/test_data/pre_state_tracer/legacy.json
new file mode 100644
index 00000000000..dbefb198c40
--- /dev/null
+++ b/crates/rpc/rpc-types/test_data/pre_state_tracer/legacy.json
@@ -0,0 +1,25 @@
+{
+    "0x0024f658a46fbb89d8ac105e98d7ac7cbbaf27c5": {
+        "balance": "0x0",
+        "code": "0x",
+        "nonce": 22,
+        "storage": {}
+    },
+    "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe": {
+        "balance": "0x4d87094125a369d9bd5",
+        "code": "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",
+        "nonce": 1,
+        "storage": {
+            "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000001b436ba50d378d4bbc8660d312a13df6af6e89dfb",
+            "0x0000000000000000000000000000000000000000000000000000000000000001": "0x00000000000000000000000000000000000000000000000006f05b59d3b20000",
+            "0x0000000000000000000000000000000000000000000000000000000000000002": "0x000000000000000000000000000000000000000000000000000000000000003c",
+            "0x0000000000000000000000000000000000000000000000000000000000000003": "0x000000000000000000000000000000000000000000000000000000005a37b834"
+        }
+    },
+    "0xb436ba50d378d4bbc8660d312a13df6af6e89dfb": {
+        "balance": "0x1780d77678137ac1b775",
+        "code": "0x",
+        "nonce": 29072,
+        "storage": {}
+    }
+}
diff --git a/crates/rpc/rpc/Cargo.toml b/crates/rpc/rpc/Cargo.toml
index f86cb8a25ee..0323eac5662 100644
--- a/crates/rpc/rpc/Cargo.toml
+++ b/crates/rpc/rpc/Cargo.toml
@@ -16,7 +16,9 @@ reth-rpc-api = { path = "../rpc-api" }
 reth-rlp = { path = "../../rlp" }
 reth-rpc-types = { path = "../rpc-types" }
 reth-provider = { path = "../../storage/provider", features = ["test-utils"] }
-reth-transaction-pool = { path = "../../transaction-pool", features = ["test-utils"]}
+reth-transaction-pool = { path = "../../transaction-pool", features = [
+    "test-utils",
+] }
 reth-network-api = { path = "../../net/network-api", features = ["test-utils"] }
 reth-rpc-engine-api = { path = "../rpc-engine-api" }
 reth-revm = { path = "../../revm" }
@@ -24,6 +26,7 @@ reth-tasks = { path = "../../tasks" }
 
 # eth
 revm = { version = "3.0.0", features = ["optional_block_gas_limit"] }
+ethers-core = { git = "https://github.com/gakonst/ethers-rs", features = ["eip712"] }
 
 # rpc
 jsonrpsee = { version = "0.16" }
@@ -39,10 +42,11 @@ tower = "0.4"
 tokio-stream = "0.1"
 pin-project = "1.0"
 
+bytes = "1.4"
 secp256k1 = { version = "0.26.0", features = [
     "global-context",
     "rand-std",
-    "recovery",
+    "recovery"
 ] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
@@ -50,7 +54,8 @@ thiserror = "1.0"
 hex = "0.4"
 rand = "0.8.5"
 tracing = "0.1"
+schnellru = "0.2"
+futures = "0.3.26"
 
 [dev-dependencies]
-jsonrpsee = { version = "0.16", features = ["client"]}
-
+jsonrpsee = { version = "0.16", features = ["client"] }
diff --git a/crates/rpc/rpc/src/admin.rs b/crates/rpc/rpc/src/admin.rs
index eb0bbe8dfa8..7921ecad8d7 100644
--- a/crates/rpc/rpc/src/admin.rs
+++ b/crates/rpc/rpc/src/admin.rs
@@ -26,26 +26,31 @@ impl<N> AdminApiServer for AdminApi<N>
 where
     N: NetworkInfo + Peers + 'static,
 {
+    /// Handler for `admin_addPeer`
     fn add_peer(&self, record: NodeRecord) -> RpcResult<bool> {
         self.network.add_peer(record.id, record.tcp_addr());
         Ok(true)
     }
 
+    /// Handler for `admin_removePeer`
     fn remove_peer(&self, record: NodeRecord) -> RpcResult<bool> {
         self.network.remove_peer(record.id, PeerKind::Basic);
         Ok(true)
     }
 
+    /// Handler for `admin_addTrustedPeer`
     fn add_trusted_peer(&self, record: NodeRecord) -> RpcResult<bool> {
         self.network.add_trusted_peer(record.id, record.tcp_addr());
         Ok(true)
     }
 
+    /// Handler for `admin_removeTrustedPeer`
     fn remove_trusted_peer(&self, record: NodeRecord) -> RpcResult<bool> {
         self.network.remove_peer(record.id, PeerKind::Trusted);
         Ok(true)
     }
 
+    /// Handler for `admin_peerEvents`
     fn subscribe_peer_events(
         &self,
         _subscription_sink: jsonrpsee::SubscriptionSink,
@@ -53,6 +58,7 @@ where
         todo!()
     }
 
+    /// Handler for `admin_nodeInfo`
     async fn node_info(&self) -> RpcResult<NodeInfo> {
         let enr = self.network.local_node_record();
         let status = self.network.network_status().await.to_rpc_result()?;
diff --git a/crates/rpc/rpc/src/debug.rs b/crates/rpc/rpc/src/debug.rs
index de3d11398c9..b4130513529 100644
--- a/crates/rpc/rpc/src/debug.rs
+++ b/crates/rpc/rpc/src/debug.rs
@@ -1,9 +1,29 @@
-use crate::{result::internal_rpc_err, EthApiSpec};
+use crate::{
+    eth::{
+        error::{EthApiError, EthResult},
+        revm_utils::inspect,
+        EthTransactions,
+    },
+    result::internal_rpc_err,
+    EthApiSpec,
+};
 use async_trait::async_trait;
-use jsonrpsee::core::RpcResult as Result;
-use reth_primitives::{BlockId, Bytes, H256};
+use jsonrpsee::core::RpcResult;
+use reth_primitives::{BlockId, BlockNumberOrTag, Bytes, H256, U256};
+use reth_revm::{
+    database::{State, SubState},
+    env::tx_env_with_recovered,
+    tracing::{TracingInspector, TracingInspectorConfig},
+};
 use reth_rpc_api::DebugApiServer;
-use reth_rpc_types::RichBlock;
+use reth_rpc_types::{
+    trace::geth::{
+        BlockTraceResult, GethDebugBuiltInTracerType, GethDebugTracerType, GethDebugTracingOptions,
+        GethTraceFrame, NoopFrame, TraceResult,
+    },
+    CallRequest, RichBlock,
+};
+use revm::primitives::Env;
 
 /// `debug` API implementation.
 ///
@@ -11,7 +31,7 @@ use reth_rpc_types::RichBlock;
 #[non_exhaustive]
 pub struct DebugApi<Eth> {
     /// The implementation of `eth` API
-    eth: Eth,
+    eth_api: Eth,
 }
 
 // === impl DebugApi ===
@@ -19,7 +39,81 @@ pub struct DebugApi<Eth> {
 impl<Eth> DebugApi<Eth> {
     /// Create a new instance of the [DebugApi]
     pub fn new(eth: Eth) -> Self {
-        Self { eth }
+        Self { eth_api: eth }
+    }
+}
+
+// === impl DebugApi ===
+
+impl<Eth> DebugApi<Eth>
+where
+    Eth: EthTransactions + 'static,
+{
+    /// Trace the transaction according to the provided options.
+    ///
+    /// Ref: <https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers>
+    pub async fn debug_trace_transaction(
+        &self,
+        tx_hash: H256,
+        opts: GethDebugTracingOptions,
+    ) -> EthResult<GethTraceFrame> {
+        let (transaction, at) = match self.eth_api.transaction_by_hash_at(tx_hash).await? {
+            None => return Err(EthApiError::TransactionNotFound),
+            Some(res) => res,
+        };
+
+        let (cfg, block, at) = self.eth_api.evm_env_at(at).await?;
+
+        let tx = transaction.into_recovered();
+
+        self.eth_api.with_state_at(at, |state| {
+            let tx = tx_env_with_recovered(&tx);
+            let env = Env { cfg, block, tx };
+            let db = SubState::new(State::new(state));
+
+            let GethDebugTracingOptions { config, tracer, tracer_config, .. } = opts;
+            if let Some(tracer) = tracer {
+                // valid matching config
+                if let Some(ref config) = tracer_config {
+                    if !config.matches_tracer(&tracer) {
+                        return Err(EthApiError::InvalidTracerConfig)
+                    }
+                }
+
+                return match tracer {
+                    GethDebugTracerType::BuiltInTracer(tracer) => match tracer {
+                        GethDebugBuiltInTracerType::FourByteTracer => {
+                            todo!()
+                        }
+                        GethDebugBuiltInTracerType::CallTracer => {
+                            todo!()
+                        }
+                        GethDebugBuiltInTracerType::PreStateTracer => {
+                            todo!()
+                        }
+                        GethDebugBuiltInTracerType::NoopTracer => Ok(NoopFrame::default().into()),
+                    },
+                    GethDebugTracerType::JsTracer(_) => {
+                        Err(EthApiError::Unsupported("javascript tracers are unsupported."))
+                    }
+                }
+            }
+
+            // default structlog tracer
+            let inspector_config = TracingInspectorConfig::default_geth()
+                .set_memory_snapshots(config.enable_memory.unwrap_or_default())
+                .set_stack_snapshots(!config.disable_stack.unwrap_or_default())
+                .set_state_diffs(!config.disable_storage.unwrap_or_default());
+
+            let mut inspector = TracingInspector::new(inspector_config);
+
+            let (res, _) = inspect(db, env, &mut inspector)?;
+            let gas_used = res.result.gas_used();
+
+            let frame = inspector.into_geth_builder().geth_traces(U256::from(gas_used), config);
+
+            Ok(frame.into())
+        })
     }
 }
 
@@ -28,24 +122,84 @@ impl<Eth> DebugApiServer for DebugApi<Eth>
 where
     Eth: EthApiSpec + 'static,
 {
-    async fn raw_header(&self, _block_id: BlockId) -> Result<Bytes> {
+    /// Handler for `debug_getRawHeader`
+    async fn raw_header(&self, _block_id: BlockId) -> RpcResult<Bytes> {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    async fn raw_block(&self, _block_id: BlockId) -> Result<Bytes> {
+    /// Handler for `debug_getRawBlock`
+    async fn raw_block(&self, _block_id: BlockId) -> RpcResult<Bytes> {
         Err(internal_rpc_err("unimplemented"))
     }
 
+    /// Handler for `debug_getRawTransaction`
     /// Returns the bytes of the transaction for the given hash.
-    async fn raw_transaction(&self, _hash: H256) -> Result<Bytes> {
+    async fn raw_transaction(&self, _hash: H256) -> RpcResult<Bytes> {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    async fn raw_receipts(&self, _block_id: BlockId) -> Result<Vec<Bytes>> {
+    /// Handler for `debug_getRawReceipts`
+    async fn raw_receipts(&self, _block_id: BlockId) -> RpcResult<Vec<Bytes>> {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    async fn bad_blocks(&self) -> Result<Vec<RichBlock>> {
+    /// Handler for `debug_getBadBlocks`
+    async fn bad_blocks(&self) -> RpcResult<Vec<RichBlock>> {
+        Err(internal_rpc_err("unimplemented"))
+    }
+
+    /// Handler for `debug_traceChain`
+    async fn debug_trace_chain(
+        &self,
+        _start_exclusive: BlockNumberOrTag,
+        _end_inclusive: BlockNumberOrTag,
+    ) -> RpcResult<Vec<BlockTraceResult>> {
+        Err(internal_rpc_err("unimplemented"))
+    }
+
+    /// Handler for `debug_traceBlock`
+    async fn debug_trace_block(
+        &self,
+        _rlp_block: Bytes,
+        _opts: GethDebugTracingOptions,
+    ) -> RpcResult<Vec<TraceResult>> {
+        Err(internal_rpc_err("unimplemented"))
+    }
+
+    /// Handler for `debug_traceBlockByHash`
+    async fn debug_trace_block_by_hash(
+        &self,
+        _block: H256,
+        _opts: GethDebugTracingOptions,
+    ) -> RpcResult<Vec<TraceResult>> {
+        Err(internal_rpc_err("unimplemented"))
+    }
+
+    /// Handler for `debug_traceBlockByNumber`
+    async fn debug_trace_block_by_number(
+        &self,
+        _block: BlockNumberOrTag,
+        _opts: GethDebugTracingOptions,
+    ) -> RpcResult<Vec<TraceResult>> {
+        Err(internal_rpc_err("unimplemented"))
+    }
+
+    /// Handler for `debug_traceTransaction`
+    async fn debug_trace_transaction(
+        &self,
+        tx_hash: H256,
+        opts: GethDebugTracingOptions,
+    ) -> RpcResult<GethTraceFrame> {
+        Ok(DebugApi::debug_trace_transaction(self, tx_hash, opts).await?)
+    }
+
+    /// Handler for `debug_traceCall`
+    async fn debug_trace_call(
+        &self,
+        _request: CallRequest,
+        _block_number: Option<BlockId>,
+        _opts: GethDebugTracingOptions,
+    ) -> RpcResult<GethTraceFrame> {
         Err(internal_rpc_err("unimplemented"))
     }
 }
diff --git a/crates/rpc/rpc/src/engine/mod.rs b/crates/rpc/rpc/src/engine/mod.rs
index 2b917d394bc..1b943fd07f7 100644
--- a/crates/rpc/rpc/src/engine/mod.rs
+++ b/crates/rpc/rpc/src/engine/mod.rs
@@ -58,6 +58,7 @@ impl EngineApi {
 
 #[async_trait]
 impl EngineApiServer for EngineApi {
+    /// Handler for `engine_getPayloadV1`
     /// See also <https://github.com/ethereum/execution-apis/blob/8db51dcd2f4bdfbd9ad6e4a7560aac97010ad063/src/engine/specification.md#engine_newpayloadv1>
     /// Caution: This should not accept the `withdrawals` field
     async fn new_payload_v1(&self, payload: ExecutionPayload) -> Result<PayloadStatus> {
@@ -69,6 +70,7 @@ impl EngineApiServer for EngineApi {
         .await
     }
 
+    /// Handler for `engine_getPayloadV2`
     /// See also <https://github.com/ethereum/execution-apis/blob/8db51dcd2f4bdfbd9ad6e4a7560aac97010ad063/src/engine/specification.md#engine_newpayloadv1>
     async fn new_payload_v2(&self, payload: ExecutionPayload) -> Result<PayloadStatus> {
         let (tx, rx) = oneshot::channel();
@@ -79,6 +81,7 @@ impl EngineApiServer for EngineApi {
         .await
     }
 
+    /// Handler for `engine_forkchoiceUpdatedV1`
     /// See also <https://github.com/ethereum/execution-apis/blob/8db51dcd2f4bdfbd9ad6e4a7560aac97010ad063/src/engine/specification.md#engine_forkchoiceUpdatedV1>
     ///
     /// Caution: This should not accept the `withdrawals` field
@@ -100,6 +103,7 @@ impl EngineApiServer for EngineApi {
         .await
     }
 
+    /// Handler for `engine_forkchoiceUpdatedV2`
     /// See also <https://github.com/ethereum/execution-apis/blob/main/src/engine/specification.md#engine_forkchoiceupdatedv2>
     async fn fork_choice_updated_v2(
         &self,
@@ -119,6 +123,7 @@ impl EngineApiServer for EngineApi {
         .await
     }
 
+    /// Handler for `engine_getPayloadV1`
     /// See also <https://github.com/ethereum/execution-apis/blob/8db51dcd2f4bdfbd9ad6e4a7560aac97010ad063/src/engine/specification.md#engine_getPayloadV1>
     ///
     /// Caution: This should not return the `withdrawals` field
@@ -127,12 +132,14 @@ impl EngineApiServer for EngineApi {
         self.delegate_request(EngineApiMessage::GetPayload(payload_id, tx), rx).await
     }
 
+    /// Handler for `engine_getPayloadV2`
     /// See also <https://github.com/ethereum/execution-apis/blob/main/src/engine/specification.md#engine_getpayloadv2>
     async fn get_payload_v2(&self, payload_id: H64) -> Result<ExecutionPayload> {
         let (tx, rx) = oneshot::channel();
         self.delegate_request(EngineApiMessage::GetPayload(payload_id, tx), rx).await
     }
 
+    /// Handler for `engine_getPayloadBodiesByHashV1`
     /// See also <https://github.com/ethereum/execution-apis/blob/6452a6b194d7db269bf1dbd087a267251d3cc7f8/src/engine/shanghai.md#engine_getpayloadbodiesbyhashv1>
     async fn get_payload_bodies_by_hash_v1(
         &self,
@@ -142,6 +149,7 @@ impl EngineApiServer for EngineApi {
         self.delegate_request(EngineApiMessage::GetPayloadBodiesByHash(block_hashes, tx), rx).await
     }
 
+    /// Handler for `engine_getPayloadBodiesByRangeV1`
     /// See also <https://github.com/ethereum/execution-apis/blob/6452a6b194d7db269bf1dbd087a267251d3cc7f8/src/engine/shanghai.md#engine_getpayloadbodiesbyrangev1>
     async fn get_payload_bodies_by_range_v1(
         &self,
@@ -152,6 +160,7 @@ impl EngineApiServer for EngineApi {
         self.delegate_request(EngineApiMessage::GetPayloadBodiesByRange(start, count, tx), rx).await
     }
 
+    /// Handler for `engine_exchangeTransitionConfigurationV1`
     /// See also <https://github.com/ethereum/execution-apis/blob/8db51dcd2f4bdfbd9ad6e4a7560aac97010ad063/src/engine/specification.md#engine_exchangeTransitionConfigurationV1>
     async fn exchange_transition_configuration(
         &self,
@@ -162,6 +171,7 @@ impl EngineApiServer for EngineApi {
             .await
     }
 
+    /// Handler for `engine_exchangeCapabilitiesV1`
     /// See also <https://github.com/ethereum/execution-apis/blob/6452a6b194d7db269bf1dbd087a267251d3cc7f8/src/engine/common.md#capabilities>
     async fn exchange_capabilities(&self, _capabilities: Vec<String>) -> Result<Vec<String>> {
         Ok(CAPABILITIES.into_iter().map(str::to_owned).collect())
diff --git a/crates/rpc/rpc/src/eth/api/block.rs b/crates/rpc/rpc/src/eth/api/block.rs
index 158ba31d568..30dd290f46a 100644
--- a/crates/rpc/rpc/src/eth/api/block.rs
+++ b/crates/rpc/rpc/src/eth/api/block.rs
@@ -6,7 +6,7 @@ use crate::{
 };
 use reth_primitives::BlockId;
 use reth_provider::{BlockProvider, EvmEnvProvider, StateProviderFactory};
-use reth_rpc_types::{Block, RichBlock};
+use reth_rpc_types::{Block, Index, RichBlock};
 
 impl<Client, Pool, Network> EthApi<Client, Pool, Network>
 where
@@ -23,6 +23,20 @@ where
         Ok(self.client().ommers(block_id)?)
     }
 
+    pub(crate) async fn ommer_by_block_and_index(
+        &self,
+        block_id: impl Into<BlockId>,
+        index: Index,
+    ) -> EthResult<Option<RichBlock>> {
+        let block_id = block_id.into();
+        let index = usize::from(index);
+        let uncles = self.client().ommers(block_id)?.unwrap_or_default();
+        let uncle = uncles
+            .into_iter()
+            .nth(index)
+            .map(|header| Block::uncle_block_from_header(header).into());
+        Ok(uncle)
+    }
     pub(crate) async fn block_transaction_count(
         &self,
         block_id: impl Into<BlockId>,
diff --git a/crates/rpc/rpc/src/eth/api/call.rs b/crates/rpc/rpc/src/eth/api/call.rs
index 60cb62bd66a..dabd21045ff 100644
--- a/crates/rpc/rpc/src/eth/api/call.rs
+++ b/crates/rpc/rpc/src/eth/api/call.rs
@@ -1,34 +1,53 @@
 //! Contains RPC handler implementations specific to endpoints that call/execute within evm.
 
-#![allow(unused)] // TODO rm later
-
 use crate::{
-    eth::error::{EthApiError, EthResult, InvalidTransactionError},
+    eth::{
+        error::{EthApiError, EthResult, InvalidTransactionError, RevertError},
+        revm_utils::{build_call_evm_env, get_precompiles, inspect, transact},
+        EthTransactions,
+    },
     EthApi,
 };
-use reth_primitives::{AccessList, Address, BlockId, Bytes, TransactionKind, U128, U256};
+use ethers_core::utils::get_contract_address;
+use reth_primitives::{AccessList, Address, BlockId, BlockNumberOrTag, U256};
 use reth_provider::{BlockProvider, EvmEnvProvider, StateProvider, StateProviderFactory};
-use reth_revm::database::{State, SubState};
-use reth_rpc_types::CallRequest;
+use reth_revm::{
+    access_list::AccessListInspector,
+    database::{State, SubState},
+};
+use reth_rpc_types::{
+    state::{AccountOverride, StateOverride},
+    CallRequest,
+};
+use reth_transaction_pool::TransactionPool;
 use revm::{
-    primitives::{ruint::Uint, BlockEnv, CfgEnv, Env, ResultAndState, TransactTo, TxEnv},
+    db::{CacheDB, DatabaseRef},
+    primitives::{
+        BlockEnv, Bytecode, CfgEnv, Env, ExecutionResult, Halt, ResultAndState, TransactTo,
+    },
     Database,
 };
 
 // Gas per transaction not creating a contract.
-pub(crate) const MIN_TRANSACTION_GAS: U256 = Uint::from_limbs([21_000, 0, 0, 0]);
+const MIN_TRANSACTION_GAS: u64 = 21_000u64;
+const MIN_CREATE_GAS: u64 = 53_000u64;
 
 impl<Client, Pool, Network> EthApi<Client, Pool, Network>
 where
+    Pool: TransactionPool + Clone + 'static,
     Client: BlockProvider + StateProviderFactory + EvmEnvProvider + 'static,
+    Network: Send + Sync + 'static,
 {
     /// Executes the call request at the given [BlockId]
-    pub(crate) fn call_at(
+    pub(crate) async fn execute_call_at(
         &self,
         request: CallRequest,
         at: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> EthResult<(ResultAndState, Env)> {
-        todo!()
+        let (cfg, block_env, at) = self.evm_env_at(at).await?;
+        let state = self.state_at(at)?;
+        self.call_with(cfg, block_env, request, state, state_overrides)
     }
 
     /// Executes the call request using the given environment against the state provider
@@ -38,8 +57,9 @@ where
         &self,
         mut cfg: CfgEnv,
         block: BlockEnv,
-        mut request: CallRequest,
+        request: CallRequest,
         state: S,
+        state_overrides: Option<StateOverride>,
     ) -> EthResult<(ResultAndState, Env)>
     where
         S: StateProvider,
@@ -48,175 +68,306 @@ where
         // impls and providers <https://github.com/foundry-rs/foundry/issues/4388>
         cfg.disable_block_gas_limit = true;
 
-        let mut env = build_call_evm_env(cfg, block, request)?;
+        let env = build_call_evm_env(cfg, block, request)?;
         let mut db = SubState::new(State::new(state));
+
+        // apply state overrides
+        if let Some(state_overrides) = state_overrides {
+            apply_state_overrides(state_overrides, &mut db)?;
+        }
+
         transact(&mut db, env)
     }
 
-    /// Estimate gas needed for execution of the `request` at the [BlockId] .
-    pub(crate) fn estimate_gas_at(&self, mut request: CallRequest, at: BlockId) -> EthResult<U256> {
-        // TODO get a StateProvider for the given blockId and BlockEnv
-        todo!()
+    /// Estimate gas needed for execution of the `request` at the [BlockId].
+    pub(crate) async fn estimate_gas_at(
+        &self,
+        request: CallRequest,
+        at: BlockId,
+    ) -> EthResult<U256> {
+        let (cfg, block_env, at) = self.evm_env_at(at).await?;
+        let state = self.state_at(at)?;
+        self.estimate_gas_with(cfg, block_env, request, state)
     }
 
     /// Estimates the gas usage of the `request` with the state.
+    ///
+    /// This will execute the [CallRequest] and find the best gas limit via binary search
     fn estimate_gas_with<S>(
         &self,
         cfg: CfgEnv,
         block: BlockEnv,
-        mut request: CallRequest,
+        request: CallRequest,
         state: S,
     ) -> EthResult<U256>
     where
         S: StateProvider,
     {
+        // keep a copy of gas related request values
+        let request_gas = request.gas;
+        let request_gas_price = request.gas_price;
+        let env_gas_limit = block.gas_limit;
+
         // get the highest possible gas limit, either the request's set value or the currently
         // configured gas limit
         let mut highest_gas_limit = request.gas.unwrap_or(block.gas_limit);
 
         // Configure the evm env
         let mut env = build_call_evm_env(cfg, block, request)?;
+        let mut db = SubState::new(State::new(state));
 
         // if the request is a simple transfer we can optimize
         if env.tx.data.is_empty() {
             if let TransactTo::Call(to) = env.tx.transact_to {
-                let no_code = state.account_code(to)?.map(|code| code.is_empty()).unwrap_or(true);
-                if no_code {
-                    return Ok(MIN_TRANSACTION_GAS)
+                if let Ok(code) = db.db.state().account_code(to) {
+                    let no_code_callee = code.map(|code| code.is_empty()).unwrap_or(true);
+                    if no_code_callee {
+                        // simple transfer, check if caller has sufficient funds
+                        let available_funds =
+                            db.basic(env.tx.caller)?.map(|acc| acc.balance).unwrap_or_default();
+                        if env.tx.value > available_funds {
+                            return Err(InvalidTransactionError::InsufficientFundsForTransfer.into())
+                        }
+                        return Ok(U256::from(MIN_TRANSACTION_GAS))
+                    }
+                }
+            }
+        }
+
+        // check funds of the sender
+        let gas_price = env.tx.gas_price;
+        if gas_price > U256::ZERO {
+            let mut available_funds =
+                db.basic(env.tx.caller)?.map(|acc| acc.balance).unwrap_or_default();
+            if env.tx.value > available_funds {
+                return Err(InvalidTransactionError::InsufficientFunds.into())
+            }
+            // subtract transferred value from available funds
+            // SAFETY: value < available_funds, checked above
+            available_funds -= env.tx.value;
+            // amount of gas the sender can afford with the `gas_price`
+            // SAFETY: gas_price not zero
+            let allowance = available_funds.checked_div(gas_price).unwrap_or_default();
+
+            if highest_gas_limit > allowance {
+                // cap the highest gas limit by max gas caller can afford with given gas price
+                highest_gas_limit = allowance;
+            }
+        }
+
+        // if the provided gas limit is less than computed cap, use that
+        let gas_limit = std::cmp::min(U256::from(env.tx.gas_limit), highest_gas_limit);
+        env.block.gas_limit = gas_limit;
+
+        // execute the call without writing to db
+        let (res, mut env) = transact(&mut db, env)?;
+        match res.result {
+            ExecutionResult::Success { .. } => {
+                // succeeded
+            }
+            ExecutionResult::Halt { reason, gas_used } => {
+                return Err(InvalidTransactionError::halt(reason, gas_used).into())
+            }
+            ExecutionResult::Revert { output, .. } => {
+                // if price or limit was included in the request then we can execute the request
+                // again with the block's gas limit to check if revert is gas related or not
+                return if request_gas.is_some() || request_gas_price.is_some() {
+                    let req_gas_limit = env.tx.gas_limit;
+                    env.tx.gas_limit = env_gas_limit.try_into().unwrap_or(u64::MAX);
+                    let (res, _) = transact(&mut db, env)?;
+                    match res.result {
+                        ExecutionResult::Success { .. } => {
+                            // transaction succeeded by manually increasing the gas limit to
+                            // highest, which means the caller lacks funds to pay for the tx
+                            Err(InvalidTransactionError::BasicOutOfGas(U256::from(req_gas_limit))
+                                .into())
+                        }
+                        ExecutionResult::Revert { .. } => {
+                            // reverted again after bumping the limit
+                            Err(InvalidTransactionError::Revert(RevertError::new(output)).into())
+                        }
+                        ExecutionResult::Halt { reason, .. } => {
+                            Err(InvalidTransactionError::EvmHalt(reason).into())
+                        }
+                    }
+                } else {
+                    // the transaction did revert
+                    Err(InvalidTransactionError::Revert(RevertError::new(output)).into())
+                }
+            }
+        }
+
+        // at this point we know the call succeeded but want to find the _best_ (lowest) gas the
+        // transaction succeeds with. we  find this by doing a binary search over the
+        // possible range NOTE: this is the gas the transaction used, which is less than the
+        // transaction requires to succeed
+        let gas_used = res.result.gas_used();
+        // the lowest value is capped by the gas it takes for a transfer
+        let mut lowest_gas_limit =
+            if env.tx.transact_to.is_create() { MIN_CREATE_GAS } else { MIN_TRANSACTION_GAS };
+        let mut highest_gas_limit: u64 = highest_gas_limit.try_into().unwrap_or(u64::MAX);
+        // pick a point that's close to the estimated gas
+        let mut mid_gas_limit = std::cmp::min(
+            gas_used * 3,
+            ((highest_gas_limit as u128 + lowest_gas_limit as u128) / 2) as u64,
+        );
+
+        let mut last_highest_gas_limit = highest_gas_limit;
+
+        // binary search
+        while (highest_gas_limit - lowest_gas_limit) > 1 {
+            let mut env = env.clone();
+            env.tx.gas_limit = mid_gas_limit;
+            let (res, _) = transact(&mut db, env)?;
+            match res.result {
+                ExecutionResult::Success { .. } => {
+                    // cap the highest gas limit with succeeding gas limit
+                    highest_gas_limit = mid_gas_limit;
+                    // if last two successful estimations only vary by 10%, we consider this to be
+                    // sufficiently accurate
+                    const ACCURACY: u128 = 10;
+                    if (last_highest_gas_limit - highest_gas_limit) as u128 * ACCURACY /
+                        (last_highest_gas_limit as u128) <
+                        1u128
+                    {
+                        return Ok(U256::from(highest_gas_limit))
+                    }
+                    last_highest_gas_limit = highest_gas_limit;
+                }
+                ExecutionResult::Revert { .. } => {
+                    // increase the lowest gas limit
+                    lowest_gas_limit = mid_gas_limit;
+                }
+                ExecutionResult::Halt { reason, .. } => {
+                    match reason {
+                        Halt::OutOfGas(_) => {
+                            // increase the lowest gas limit
+                            lowest_gas_limit = mid_gas_limit;
+                        }
+                        err => {
+                            // these should be unreachable because we know the transaction succeeds,
+                            // but we consider these cases an error
+                            return Err(InvalidTransactionError::EvmHalt(err).into())
+                        }
+                    }
                 }
             }
+            // new midpoint
+            mid_gas_limit = ((highest_gas_limit as u128 + lowest_gas_limit as u128) / 2) as u64;
         }
 
+        Ok(U256::from(highest_gas_limit))
+    }
+
+    pub(crate) async fn create_access_list_at(
+        &self,
+        request: CallRequest,
+        at: Option<BlockId>,
+    ) -> EthResult<AccessList> {
+        let block_id = at.unwrap_or(BlockId::Number(BlockNumberOrTag::Latest));
+        let (mut cfg, block, at) = self.evm_env_at(block_id).await?;
+        let state = self.state_at(at)?;
+
+        // we want to disable this in eth_call, since this is common practice used by other node
+        // impls and providers <https://github.com/foundry-rs/foundry/issues/4388>
+        cfg.disable_block_gas_limit = true;
+
+        let env = build_call_evm_env(cfg, block, request.clone())?;
         let mut db = SubState::new(State::new(state));
 
-        todo!()
+        let from = request.from.unwrap_or_default();
+        let to = if let Some(to) = request.to {
+            to
+        } else {
+            let nonce = db.basic(from)?.unwrap_or_default().nonce;
+            get_contract_address(from, nonce).into()
+        };
+
+        let initial = request.access_list.clone().unwrap_or_default();
+
+        let precompiles = get_precompiles(&env.cfg.spec_id);
+        let mut inspector = AccessListInspector::new(initial, from, to, precompiles);
+        let (result, _env) = inspect(&mut db, env, &mut inspector)?;
+
+        match result.result {
+            ExecutionResult::Halt { reason, .. } => Err(match reason {
+                Halt::NonceOverflow => InvalidTransactionError::NonceMaxValue,
+                halt => InvalidTransactionError::EvmHalt(halt),
+            }),
+            ExecutionResult::Revert { output, .. } => {
+                Err(InvalidTransactionError::Revert(RevertError::new(output)))
+            }
+            ExecutionResult::Success { .. } => Ok(()),
+        }?;
+        Ok(inspector.into_access_list())
     }
 }
 
-/// Executes the [Env] against the given [Database] without committing state changes.
-pub(crate) fn transact<S>(db: S, env: Env) -> EthResult<(ResultAndState, Env)>
+/// Applies the given state overrides (a set of [AccountOverride]) to the [CacheDB].
+fn apply_state_overrides<DB>(overrides: StateOverride, db: &mut CacheDB<DB>) -> EthResult<()>
 where
-    S: Database,
-    <S as Database>::Error: Into<EthApiError>,
+    DB: DatabaseRef,
+    EthApiError: From<<DB as DatabaseRef>::Error>,
 {
-    let mut evm = revm::EVM::with_env(env);
-    evm.database(db);
-    let res = evm.transact()?;
-    Ok((res, evm.env))
-}
-
-/// Creates a new [Env] to be used for executing the [CallRequest] in `eth_call`
-pub(crate) fn build_call_evm_env(
-    mut cfg: CfgEnv,
-    block: BlockEnv,
-    request: CallRequest,
-) -> EthResult<Env> {
-    let tx = create_txn_env(&block, request)?;
-    Ok(Env { cfg, block, tx })
+    for (account, account_overrides) in overrides {
+        apply_account_override(account, account_overrides, db)?;
+    }
+    Ok(())
 }
 
-/// Configures a new [TxEnv]  for the [CallRequest]
-fn create_txn_env(block_env: &BlockEnv, request: CallRequest) -> EthResult<TxEnv> {
-    let CallRequest {
-        from,
-        to,
-        gas_price,
-        max_fee_per_gas,
-        max_priority_fee_per_gas,
-        gas,
-        value,
-        data,
-        nonce,
-        access_list,
-        chain_id,
-    } = request;
-
-    let CallFees { max_priority_fee_per_gas, gas_price } =
-        CallFees::ensure_fees(gas_price, max_fee_per_gas, max_priority_fee_per_gas)?;
-
-    let gas_limit = gas.unwrap_or(block_env.gas_limit);
-
-    let env = TxEnv {
-        gas_limit: gas_limit.try_into().map_err(|_| InvalidTransactionError::GasUintOverflow)?,
-        nonce: nonce
-            .map(|n| n.try_into().map_err(|n| InvalidTransactionError::NonceTooHigh))
-            .transpose()?,
-        caller: from.unwrap_or_default(),
-        gas_price,
-        gas_priority_fee: max_priority_fee_per_gas,
-        transact_to: to.map(TransactTo::Call).unwrap_or_else(TransactTo::create),
-        value: value.unwrap_or_default(),
-        data: data.map(|data| data.0).unwrap_or_default(),
-        chain_id: chain_id.map(|c| c.as_u64()),
-        access_list: access_list.map(AccessList::flattened).unwrap_or_default(),
-    };
+/// Applies a single [AccountOverride] to the [CacheDB].
+fn apply_account_override<DB>(
+    account: Address,
+    account_override: AccountOverride,
+    db: &mut CacheDB<DB>,
+) -> EthResult<()>
+where
+    DB: DatabaseRef,
+    EthApiError: From<<DB as DatabaseRef>::Error>,
+{
+    let mut account_info = db.basic(account)?.unwrap_or_default();
 
-    Ok(env)
-}
+    if let Some(nonce) = account_override.nonce {
+        account_info.nonce = nonce;
+    }
+    if let Some(code) = account_override.code {
+        account_info.code = Some(Bytecode::new_raw(code.0));
+    }
+    if let Some(balance) = account_override.balance {
+        account_info.balance = balance;
+    }
 
-/// Helper type for representing the fees of a [CallRequest]
-struct CallFees {
-    /// EIP-1559 priority fee
-    max_priority_fee_per_gas: Option<U256>,
-    /// Unified gas price setting
-    ///
-    /// Will be `0` if unset in request
-    ///
-    /// `gasPrice` for legacy,
-    /// `maxFeePerGas` for EIP-1559
-    gas_price: U256,
-}
+    db.insert_account_info(account, account_info);
 
-// === impl CallFees ===
-
-impl CallFees {
-    /// Ensures the fields of a [CallRequest] are not conflicting
-    fn ensure_fees(
-        call_gas_price: Option<U128>,
-        call_max_fee: Option<U128>,
-        call_priority_fee: Option<U128>,
-    ) -> EthResult<CallFees> {
-        match (call_gas_price, call_max_fee, call_priority_fee) {
-            (gas_price, None, None) => {
-                // request for a legacy transaction
-                // set everything to zero
-                let gas_price = gas_price.unwrap_or_default();
-                Ok(CallFees { gas_price: U256::from(gas_price), max_priority_fee_per_gas: None })
-            }
-            (None, max_fee_per_gas, max_priority_fee_per_gas) => {
-                // request for eip-1559 transaction
-                let max_fee = max_fee_per_gas.unwrap_or_default();
-
-                if let Some(max_priority) = max_priority_fee_per_gas {
-                    if max_priority > max_fee {
-                        // Fail early
-                        return Err(
-                            // `max_priority_fee_per_gas` is greater than the `max_fee_per_gas`
-                            InvalidTransactionError::TipAboveFeeCap.into(),
-                        )
-                    }
-                }
-                Ok(CallFees {
-                    gas_price: U256::from(max_fee),
-                    max_priority_fee_per_gas: max_priority_fee_per_gas.map(U256::from),
-                })
-            }
-            (Some(gas_price), Some(max_fee_per_gas), Some(max_priority_fee_per_gas)) => {
-                Err(EthApiError::ConflictingRequestGasPriceAndTipSet {
-                    gas_price,
-                    max_fee_per_gas,
-                    max_priority_fee_per_gas,
-                })
-            }
-            (Some(gas_price), Some(max_fee_per_gas), None) => {
-                Err(EthApiError::ConflictingRequestGasPrice { gas_price, max_fee_per_gas })
-            }
-            (Some(gas_price), None, Some(max_priority_fee_per_gas)) => {
-                Err(EthApiError::RequestLegacyGasPriceAndTipSet {
-                    gas_price,
-                    max_priority_fee_per_gas,
-                })
+    // We ensure that not both state and state_diff are set.
+    // If state is set, we must mark the account as "NewlyCreated", so that the old storage
+    // isn't read from
+    match (account_override.state, account_override.state_diff) {
+        (Some(_), Some(_)) => return Err(EthApiError::BothStateAndStateDiffInOverride(account)),
+        (None, None) => {
+            // nothing to do
+        }
+        (Some(new_account_state), None) => {
+            db.replace_account_storage(
+                account,
+                new_account_state
+                    .into_iter()
+                    .map(|(slot, value)| {
+                        (U256::from_be_bytes(slot.0), U256::from_be_bytes(value.0))
+                    })
+                    .collect(),
+            )?;
+        }
+        (None, Some(account_state_diff)) => {
+            for (slot, value) in account_state_diff {
+                db.insert_account_storage(
+                    account,
+                    U256::from_be_bytes(slot.0),
+                    U256::from_be_bytes(value.0),
+                )?;
             }
         }
-    }
+    };
+
+    Ok(())
 }
diff --git a/crates/rpc/rpc/src/eth/api/mod.rs b/crates/rpc/rpc/src/eth/api/mod.rs
index 960c19d4b2f..274835e10ba 100644
--- a/crates/rpc/rpc/src/eth/api/mod.rs
+++ b/crates/rpc/rpc/src/eth/api/mod.rs
@@ -3,27 +3,24 @@
 //! The entire implementation of the namespace is quite large, hence it is divided across several
 //! files.
 
-use crate::eth::signer::EthSigner;
+use crate::eth::{cache::EthStateCache, signer::EthSigner};
 use async_trait::async_trait;
 use reth_interfaces::Result;
 use reth_network_api::NetworkInfo;
-use reth_primitives::{
-    Address, BlockId, BlockNumberOrTag, ChainInfo, TransactionSigned, H256, U64,
-};
-use reth_provider::{BlockProvider, EvmEnvProvider, StateProviderFactory};
-use std::num::NonZeroUsize;
-
-use crate::eth::error::EthResult;
-use reth_provider::providers::ChainState;
+use reth_primitives::{Address, BlockId, BlockNumberOrTag, ChainInfo, H256, U64};
+use reth_provider::{providers::ChainState, BlockProvider, EvmEnvProvider, StateProviderFactory};
 use reth_rpc_types::FeeHistoryCache;
 use reth_transaction_pool::TransactionPool;
-use std::sync::Arc;
+use std::{num::NonZeroUsize, sync::Arc};
 
 mod block;
 mod call;
 mod server;
+mod sign;
 mod state;
 mod transactions;
+use crate::eth::error::{EthApiError, EthResult};
+pub use transactions::{EthTransactions, TransactionSource};
 
 /// Cache limit of block-level fee history for `eth_feeHistory` RPC method.
 const FEE_HISTORY_CACHE_LIMIT: usize = 2048;
@@ -32,7 +29,7 @@ const FEE_HISTORY_CACHE_LIMIT: usize = 2048;
 ///
 /// Defines core functionality of the `eth` API implementation.
 #[async_trait]
-pub trait EthApiSpec: Send + Sync {
+pub trait EthApiSpec: EthTransactions + Send + Sync {
     /// Returns the current ethereum protocol version.
     async fn protocol_version(&self) -> Result<U64>;
 
@@ -44,9 +41,6 @@ pub trait EthApiSpec: Send + Sync {
 
     /// Returns a list of addresses owned by client.
     fn accounts(&self) -> Vec<Address>;
-
-    /// Returns the transaction by hash
-    async fn transaction_by_hash(&self, hash: H256) -> Result<Option<TransactionSigned>>;
 }
 
 /// `Eth` API implementation.
@@ -58,7 +52,6 @@ pub trait EthApiSpec: Send + Sync {
 /// the main impls. This way [`EthApi`] is not limited to [`jsonrpsee`] and can be used standalone
 /// or in other network handlers (for example ipc).
 #[derive(Clone)]
-#[allow(missing_debug_implementations)]
 pub struct EthApi<Client, Pool, Network> {
     /// All nested fields bundled together.
     inner: Arc<EthApiInner<Client, Pool, Network>>,
@@ -67,8 +60,8 @@ pub struct EthApi<Client, Pool, Network> {
 
 impl<Client, Pool, Network> EthApi<Client, Pool, Network> {
     /// Creates a new, shareable instance.
-    pub fn new(client: Client, pool: Pool, network: Network) -> Self {
-        let inner = EthApiInner { client, pool, network, signers: Default::default() };
+    pub fn new(client: Client, pool: Pool, network: Network, eth_cache: EthStateCache) -> Self {
+        let inner = EthApiInner { client, pool, network, signers: Default::default(), eth_cache };
         Self {
             inner: Arc::new(inner),
             fee_history_cache: FeeHistoryCache::new(
@@ -77,6 +70,11 @@ impl<Client, Pool, Network> EthApi<Client, Pool, Network> {
         }
     }
 
+    /// Returns the state cache frontend
+    pub(crate) fn cache(&self) -> &EthStateCache {
+        &self.inner.eth_cache
+    }
+
     /// Returns the inner `Client`
     pub(crate) fn client(&self) -> &Client {
         &self.inner.client
@@ -103,34 +101,25 @@ where
         self.client().convert_block_number(num)
     }
 
-    /// Helper function to execute a closure with the database at a specific block.
-    pub(crate) fn with_state_at<F, T>(&self, _at: BlockId, _f: F) -> EthResult<T>
-    where
-        F: FnOnce(ChainState<'_>) -> T,
-    {
-        unimplemented!()
+    /// Returns the state at the given [BlockId] enum.
+    pub(crate) fn state_at_block_id(&self, at: BlockId) -> EthResult<ChainState<'_>> {
+        match at {
+            BlockId::Hash(hash) => Ok(self.state_at_hash(hash.into()).map(ChainState::boxed)?),
+            BlockId::Number(num) => {
+                self.state_at_block_number(num)?.ok_or(EthApiError::UnknownBlockNumber)
+            }
+        }
     }
 
     /// Returns the state at the given [BlockId] enum or the latest.
     pub(crate) fn state_at_block_id_or_latest(
         &self,
         block_id: Option<BlockId>,
-    ) -> Result<Option<<Client as StateProviderFactory>::HistorySP<'_>>> {
+    ) -> EthResult<ChainState<'_>> {
         if let Some(block_id) = block_id {
             self.state_at_block_id(block_id)
         } else {
-            self.latest_state()
-        }
-    }
-
-    /// Returns the state at the given [BlockId] enum.
-    pub(crate) fn state_at_block_id(
-        &self,
-        block_id: BlockId,
-    ) -> Result<Option<<Client as StateProviderFactory>::HistorySP<'_>>> {
-        match block_id {
-            BlockId::Hash(hash) => self.state_at_hash(hash.into()).map(Some),
-            BlockId::Number(num) => self.state_at_block_number(num),
+            Ok(self.latest_state().map(ChainState::boxed)?)
         }
     }
 
@@ -140,7 +129,7 @@ where
     pub(crate) fn state_at_block_number(
         &self,
         num: BlockNumberOrTag,
-    ) -> Result<Option<<Client as StateProviderFactory>::HistorySP<'_>>> {
+    ) -> Result<Option<ChainState<'_>>> {
         if let Some(number) = self.convert_block_number(num)? {
             self.state_at_number(number).map(Some)
         } else {
@@ -157,18 +146,22 @@ where
     }
 
     /// Returns the state at the given block number
-    pub(crate) fn state_at_number(
-        &self,
-        block_number: u64,
-    ) -> Result<<Client as StateProviderFactory>::HistorySP<'_>> {
-        self.client().history_by_block_number(block_number)
+    pub(crate) fn state_at_number(&self, block_number: u64) -> Result<ChainState<'_>> {
+        match self.convert_block_number(BlockNumberOrTag::Latest)? {
+            Some(num) if num == block_number => self.latest_state().map(ChainState::boxed),
+            _ => self.client().history_by_block_number(block_number).map(ChainState::boxed),
+        }
     }
 
     /// Returns the _latest_ state
-    pub(crate) fn latest_state(
-        &self,
-    ) -> Result<Option<<Client as StateProviderFactory>::HistorySP<'_>>> {
-        self.state_at_block_number(BlockNumberOrTag::Latest)
+    pub(crate) fn latest_state(&self) -> Result<<Client as StateProviderFactory>::LatestSP<'_>> {
+        self.client().latest()
+    }
+}
+
+impl<Client, Pool, Events> std::fmt::Debug for EthApi<Client, Pool, Events> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EthApi").finish_non_exhaustive()
     }
 }
 
@@ -200,10 +193,6 @@ where
     fn accounts(&self) -> Vec<Address> {
         self.inner.signers.iter().flat_map(|s| s.accounts()).collect()
     }
-
-    async fn transaction_by_hash(&self, hash: H256) -> Result<Option<TransactionSigned>> {
-        self.client().transaction_by_hash(hash)
-    }
 }
 
 /// Container type `EthApi`
@@ -216,4 +205,6 @@ struct EthApiInner<Client, Pool, Network> {
     network: Network,
     /// All configured Signers
     signers: Vec<Box<dyn EthSigner>>,
+    /// The async cache frontend for eth related data
+    eth_cache: EthStateCache,
 }
diff --git a/crates/rpc/rpc/src/eth/api/server.rs b/crates/rpc/rpc/src/eth/api/server.rs
index 1e382017837..e39db79ef46 100644
--- a/crates/rpc/rpc/src/eth/api/server.rs
+++ b/crates/rpc/rpc/src/eth/api/server.rs
@@ -3,19 +3,22 @@
 
 use super::EthApiSpec;
 use crate::{
-    eth::{api::EthApi, error::EthApiError},
+    eth::{
+        api::{EthApi, EthTransactions},
+        error::{ensure_success, EthApiError},
+    },
     result::{internal_rpc_err, ToRpcResult},
 };
 use jsonrpsee::core::RpcResult as Result;
 use reth_primitives::{
-    rpc::transaction::eip2930::AccessListWithGasUsed, Address, BlockId, BlockNumberOrTag, Bytes,
-    Header, H256, H64, U256, U64,
+    AccessListWithGasUsed, Address, BlockId, BlockNumberOrTag, Bytes, Header, H256, H64, U256, U64,
 };
 use reth_provider::{BlockProvider, EvmEnvProvider, HeaderProvider, StateProviderFactory};
 use reth_rpc_api::EthApiServer;
 use reth_rpc_types::{
-    CallRequest, EIP1186AccountProofResponse, FeeHistory, FeeHistoryCacheItem, Index, RichBlock,
-    SyncStatus, TransactionReceipt, TransactionRequest, Work,
+    state::StateOverride, CallRequest, EIP1186AccountProofResponse, FeeHistory,
+    FeeHistoryCacheItem, Index, RichBlock, SyncStatus, TransactionReceipt, TransactionRequest,
+    Work,
 };
 use reth_transaction_pool::TransactionPool;
 use serde_json::Value;
@@ -24,10 +27,10 @@ use std::collections::BTreeMap;
 #[async_trait::async_trait]
 impl<Client, Pool, Network> EthApiServer for EthApi<Client, Pool, Network>
 where
-    Self: EthApiSpec,
+    Self: EthApiSpec + EthTransactions,
     Pool: TransactionPool + 'static,
     Client: BlockProvider + HeaderProvider + StateProviderFactory + EvmEnvProvider + 'static,
-    Network: 'static,
+    Network: Send + Sync + 'static,
 {
     /// Handler for: `eth_protocolVersion`
     async fn protocol_version(&self) -> Result<U64> {
@@ -101,45 +104,42 @@ where
     /// Handler for: `eth_getUncleByBlockHashAndIndex`
     async fn uncle_by_block_hash_and_index(
         &self,
-        _hash: H256,
-        _index: Index,
+        hash: H256,
+        index: Index,
     ) -> Result<Option<RichBlock>> {
-        Err(internal_rpc_err("unimplemented"))
+        Ok(EthApi::ommer_by_block_and_index(self, hash, index).await?)
     }
 
     /// Handler for: `eth_getUncleByBlockNumberAndIndex`
     async fn uncle_by_block_number_and_index(
         &self,
-        _number: BlockNumberOrTag,
-        _index: Index,
+        number: BlockNumberOrTag,
+        index: Index,
     ) -> Result<Option<RichBlock>> {
-        Err(internal_rpc_err("unimplemented"))
+        Ok(EthApi::ommer_by_block_and_index(self, number, index).await?)
     }
 
     /// Handler for: `eth_getTransactionByHash`
-    async fn transaction_by_hash(
-        &self,
-        _hash: H256,
-    ) -> Result<Option<reth_rpc_types::Transaction>> {
-        Err(internal_rpc_err("unimplemented"))
+    async fn transaction_by_hash(&self, hash: H256) -> Result<Option<reth_rpc_types::Transaction>> {
+        Ok(EthTransactions::transaction_by_hash(self, hash).await?.map(Into::into))
     }
 
     /// Handler for: `eth_getTransactionByBlockHashAndIndex`
     async fn transaction_by_block_hash_and_index(
         &self,
-        _hash: H256,
-        _index: Index,
+        hash: H256,
+        index: Index,
     ) -> Result<Option<reth_rpc_types::Transaction>> {
-        Err(internal_rpc_err("unimplemented"))
+        Ok(EthApi::transaction_by_block_and_tx_index(self, hash, index).await?)
     }
 
     /// Handler for: `eth_getTransactionByBlockNumberAndIndex`
     async fn transaction_by_block_number_and_index(
         &self,
-        _number: BlockNumberOrTag,
-        _index: Index,
+        number: BlockNumberOrTag,
+        index: Index,
     ) -> Result<Option<reth_rpc_types::Transaction>> {
-        Err(internal_rpc_err("unimplemented"))
+        Ok(EthApi::transaction_by_block_and_tx_index(self, number, index).await?)
     }
 
     /// Handler for: `eth_getTransactionReceipt`
@@ -177,26 +177,48 @@ where
     }
 
     /// Handler for: `eth_call`
-    async fn call(&self, _request: CallRequest, _block_number: Option<BlockId>) -> Result<Bytes> {
-        Err(internal_rpc_err("unimplemented"))
+    async fn call(
+        &self,
+        request: CallRequest,
+        block_number: Option<BlockId>,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<Bytes> {
+        let (res, _env) = self
+            .execute_call_at(
+                request,
+                block_number.unwrap_or(BlockId::Number(BlockNumberOrTag::Pending)),
+                state_overrides,
+            )
+            .await?;
+
+        Ok(ensure_success(res.result)?)
     }
 
     /// Handler for: `eth_createAccessList`
     async fn create_access_list(
         &self,
-        _request: CallRequest,
-        _block_number: Option<BlockId>,
+        mut request: CallRequest,
+        block_number: Option<BlockId>,
     ) -> Result<AccessListWithGasUsed> {
-        Err(internal_rpc_err("unimplemented"))
+        let block_id = block_number.unwrap_or(BlockId::Number(BlockNumberOrTag::Pending));
+        let access_list = self.create_access_list_at(request.clone(), block_number).await?;
+        request.access_list = Some(access_list.clone());
+        let gas_used = self.estimate_gas_at(request, block_id).await?;
+        Ok(AccessListWithGasUsed { access_list, gas_used })
     }
 
     /// Handler for: `eth_estimateGas`
     async fn estimate_gas(
         &self,
-        _request: CallRequest,
-        _block_number: Option<BlockId>,
+        request: CallRequest,
+        block_number: Option<BlockId>,
     ) -> Result<U256> {
-        Err(internal_rpc_err("unimplemented"))
+        Ok(EthApi::estimate_gas_at(
+            self,
+            request,
+            block_number.unwrap_or(BlockId::Number(BlockNumberOrTag::Pending)),
+        )
+        .await?)
     }
 
     /// Handler for: `eth_gasPrice`
@@ -288,8 +310,7 @@ where
             }
         }
 
-        let oldest_block_hash =
-            self.inner.client.block_hash(start_block.try_into().unwrap()).to_rpc_result()?.unwrap();
+        let oldest_block_hash = self.inner.client.block_hash(start_block).to_rpc_result()?.unwrap();
 
         fee_history_cache_items.get_mut(&start_block).unwrap().hash = Some(oldest_block_hash);
         fee_history_cache.get_mut(&start_block).unwrap().hash = Some(oldest_block_hash);
@@ -351,8 +372,8 @@ where
     }
 
     /// Handler for: `eth_sign`
-    async fn sign(&self, _address: Address, _message: Bytes) -> Result<Bytes> {
-        Err(internal_rpc_err("unimplemented"))
+    async fn sign(&self, address: Address, message: Bytes) -> Result<Bytes> {
+        Ok(EthApi::sign(self, address, message).await?)
     }
 
     /// Handler for: `eth_signTransaction`
@@ -361,23 +382,31 @@ where
     }
 
     /// Handler for: `eth_signTypedData`
-    async fn sign_typed_data(&self, _address: Address, _data: Value) -> Result<Bytes> {
-        Err(internal_rpc_err("unimplemented"))
+    async fn sign_typed_data(&self, address: Address, data: Value) -> Result<Bytes> {
+        Ok(EthApi::sign_typed_data(self, data, address).await?)
     }
 
     /// Handler for: `eth_getProof`
     async fn get_proof(
         &self,
-        _address: Address,
-        _keys: Vec<H256>,
-        _block_number: Option<BlockId>,
+        address: Address,
+        keys: Vec<H256>,
+        block_number: Option<BlockId>,
     ) -> Result<EIP1186AccountProofResponse> {
-        Err(internal_rpc_err("unimplemented"))
+        let res = EthApi::get_proof(self, address, keys, block_number);
+
+        Ok(res.map_err(|e| match e {
+            EthApiError::InvalidBlockRange => {
+                internal_rpc_err("eth_getProof is unimplemented for historical blocks")
+            }
+            _ => e.into(),
+        })?)
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::{eth::cache::EthStateCache, EthApi};
     use jsonrpsee::{
         core::{error::Error as RpcError, RpcResult},
         types::error::{CallError, INVALID_PARAMS_CODE},
@@ -389,12 +418,15 @@ mod tests {
     use reth_rpc_api::EthApiServer;
     use reth_transaction_pool::test_utils::testing_pool;
 
-    use crate::EthApi;
-
     #[tokio::test]
     /// Handler for: `eth_test_fee_history`
     async fn test_fee_history() {
-        let eth_api = EthApi::new(NoopProvider::default(), testing_pool(), NoopNetwork::default());
+        let eth_api = EthApi::new(
+            NoopProvider::default(),
+            testing_pool(),
+            NoopNetwork::default(),
+            EthStateCache::spawn(NoopProvider::default(), Default::default()),
+        );
 
         let response = eth_api.fee_history(1.into(), BlockNumberOrTag::Latest.into(), None).await;
         assert!(matches!(response, RpcResult::Err(RpcError::Call(CallError::Custom(_)))));
@@ -414,8 +446,7 @@ mod tests {
             let hash = H256::random();
             let gas_limit: u64 = random();
             let gas_used: u64 = random();
-            let base_fee_per_gas: Option<u64> =
-                if random::<bool>() { Some(random()) } else { None };
+            let base_fee_per_gas: Option<u64> = random::<bool>().then(random);
 
             let header = Header {
                 number: newest_block - i,
@@ -434,7 +465,12 @@ mod tests {
                 .push(base_fee_per_gas.map(|fee| U256::try_from(fee).unwrap()).unwrap_or_default());
         }
 
-        let eth_api = EthApi::new(mock_provider, testing_pool(), NoopNetwork::default());
+        let eth_api = EthApi::new(
+            mock_provider,
+            testing_pool(),
+            NoopNetwork::default(),
+            EthStateCache::spawn(NoopProvider::default(), Default::default()),
+        );
 
         let response =
             eth_api.fee_history((newest_block + 1).into(), newest_block.into(), None).await;
diff --git a/crates/rpc/rpc/src/eth/api/sign.rs b/crates/rpc/rpc/src/eth/api/sign.rs
new file mode 100644
index 00000000000..edd03e4655a
--- /dev/null
+++ b/crates/rpc/rpc/src/eth/api/sign.rs
@@ -0,0 +1,41 @@
+//! Contains RPC handler implementations specific to sign endpoints
+use crate::{
+    eth::{
+        error::{EthResult, SignError},
+        signer::EthSigner,
+    },
+    EthApi,
+};
+use ethers_core::types::transaction::eip712::TypedData;
+use reth_primitives::{Address, Bytes};
+use serde_json::Value;
+use std::ops::Deref;
+
+impl<Client, Pool, Network> EthApi<Client, Pool, Network> {
+    pub(crate) async fn sign(&self, account: Address, message: Bytes) -> EthResult<Bytes> {
+        let signer = self.find_signer(&account)?;
+        let signature = signer.sign(account, &message).await?;
+        let bytes = hex::encode(signature.to_bytes()).as_bytes().into();
+        Ok(bytes)
+    }
+
+    pub(crate) async fn sign_typed_data(&self, data: Value, account: Address) -> EthResult<Bytes> {
+        let signer = self.find_signer(&account)?;
+        let data = serde_json::from_value::<TypedData>(data).map_err(|_| SignError::TypedData)?;
+        let signature = signer.sign_typed_data(account, &data)?;
+        let bytes = hex::encode(signature.to_bytes()).as_bytes().into();
+        Ok(bytes)
+    }
+
+    pub(crate) fn find_signer(
+        &self,
+        account: &Address,
+    ) -> Result<&(dyn EthSigner + 'static), SignError> {
+        self.inner
+            .signers
+            .iter()
+            .find(|signer| signer.is_signer_for(account))
+            .map(|signer| signer.deref())
+            .ok_or(SignError::NoAccount)
+    }
+}
diff --git a/crates/rpc/rpc/src/eth/api/state.rs b/crates/rpc/rpc/src/eth/api/state.rs
index 935615ea4d2..4227983499a 100644
--- a/crates/rpc/rpc/src/eth/api/state.rs
+++ b/crates/rpc/rpc/src/eth/api/state.rs
@@ -4,23 +4,24 @@ use crate::{
     eth::error::{EthApiError, EthResult},
     EthApi,
 };
-use reth_primitives::{Address, BlockId, Bytes, H256, U256};
-use reth_provider::{BlockProvider, EvmEnvProvider, StateProvider, StateProviderFactory};
+use reth_primitives::{Address, BlockId, BlockNumberOrTag, Bytes, H256, KECCAK_EMPTY, U256};
+use reth_provider::{
+    AccountProvider, BlockProvider, EvmEnvProvider, StateProvider, StateProviderFactory,
+};
+use reth_rpc_types::{EIP1186AccountProofResponse, StorageProof};
 
 impl<Client, Pool, Network> EthApi<Client, Pool, Network>
 where
     Client: BlockProvider + StateProviderFactory + EvmEnvProvider + 'static,
 {
     pub(crate) fn get_code(&self, address: Address, block_id: Option<BlockId>) -> EthResult<Bytes> {
-        let state =
-            self.state_at_block_id_or_latest(block_id)?.ok_or(EthApiError::UnknownBlockNumber)?;
+        let state = self.state_at_block_id_or_latest(block_id)?;
         let code = state.account_code(address)?.unwrap_or_default();
-        Ok(code)
+        Ok(code.original_bytes().into())
     }
 
     pub(crate) fn balance(&self, address: Address, block_id: Option<BlockId>) -> EthResult<U256> {
-        let state =
-            self.state_at_block_id_or_latest(block_id)?.ok_or(EthApiError::UnknownBlockNumber)?;
+        let state = self.state_at_block_id_or_latest(block_id)?;
         let balance = state.account_balance(address)?.unwrap_or_default();
         Ok(balance)
     }
@@ -30,8 +31,7 @@ where
         address: Address,
         block_id: Option<BlockId>,
     ) -> EthResult<U256> {
-        let state =
-            self.state_at_block_id_or_latest(block_id)?.ok_or(EthApiError::UnknownBlockNumber)?;
+        let state = self.state_at_block_id_or_latest(block_id)?;
         let nonce = U256::from(state.account_nonce(address)?.unwrap_or_default());
         Ok(nonce)
     }
@@ -42,10 +42,56 @@ where
         index: U256,
         block_id: Option<BlockId>,
     ) -> EthResult<H256> {
-        let state =
-            self.state_at_block_id_or_latest(block_id)?.ok_or(EthApiError::UnknownBlockNumber)?;
+        let state = self.state_at_block_id_or_latest(block_id)?;
         let storage_key = H256(index.to_be_bytes());
         let value = state.storage(address, storage_key)?.unwrap_or_default();
         Ok(H256(value.to_be_bytes()))
     }
+
+    pub(crate) fn get_proof(
+        &self,
+        address: Address,
+        keys: Vec<H256>,
+        block_id: Option<BlockId>,
+    ) -> EthResult<EIP1186AccountProofResponse> {
+        let block_id = block_id.unwrap_or(BlockId::Number(BlockNumberOrTag::Latest));
+
+        // TODO: remove when HistoricalStateProviderRef::proof is implemented
+        if !block_id.is_latest() {
+            return Err(EthApiError::InvalidBlockRange)
+        }
+
+        let state = self.state_at_block_id(block_id)?;
+
+        let (account_proof, storage_hash, stg_proofs) = state.proof(address, &keys)?;
+
+        let storage_proof = keys
+            .into_iter()
+            .zip(stg_proofs)
+            .map(|(key, proof)| {
+                state.storage(address, key).map(|op| StorageProof {
+                    key: U256::from_be_bytes(*key.as_fixed_bytes()),
+                    value: op.unwrap_or_default(),
+                    proof,
+                })
+            })
+            .collect::<Result<_, _>>()?;
+
+        let mut proof = EIP1186AccountProofResponse {
+            address,
+            code_hash: KECCAK_EMPTY,
+            account_proof,
+            storage_hash,
+            storage_proof,
+            ..Default::default()
+        };
+
+        if let Some(account) = state.basic_account(address)? {
+            proof.balance = account.balance;
+            proof.nonce = account.nonce.into();
+            proof.code_hash = account.get_bytecode_hash();
+        }
+
+        Ok(proof)
+    }
 }
diff --git a/crates/rpc/rpc/src/eth/api/transactions.rs b/crates/rpc/rpc/src/eth/api/transactions.rs
index e33e6459745..cc8ffeeb822 100644
--- a/crates/rpc/rpc/src/eth/api/transactions.rs
+++ b/crates/rpc/rpc/src/eth/api/transactions.rs
@@ -1,14 +1,147 @@
 //! Contains RPC handler implementations specific to transactions
-
 use crate::{
     eth::error::{EthApiError, EthResult},
     EthApi,
 };
-use reth_primitives::{Bytes, FromRecoveredTransaction, TransactionSigned, H256};
-use reth_provider::{BlockProvider, EvmEnvProvider, StateProviderFactory};
+use async_trait::async_trait;
+use reth_primitives::{
+    BlockId, BlockNumberOrTag, Bytes, FromRecoveredTransaction, IntoRecoveredTransaction,
+    TransactionSigned, TransactionSignedEcRecovered, H256, U256,
+};
+use reth_provider::{providers::ChainState, BlockProvider, EvmEnvProvider, StateProviderFactory};
 use reth_rlp::Decodable;
-use reth_rpc_types::TransactionRequest;
+use reth_rpc_types::{Index, Transaction, TransactionInfo, TransactionRequest};
 use reth_transaction_pool::{TransactionOrigin, TransactionPool};
+use revm::primitives::{BlockEnv, CfgEnv};
+
+/// Commonly used transaction related functions for the [EthApi] type in the `eth_` namespace
+#[async_trait::async_trait]
+pub trait EthTransactions: Send + Sync {
+    /// Returns the state at the given [BlockId]
+    fn state_at(&self, at: BlockId) -> EthResult<ChainState<'_>>;
+
+    /// Executes the closure with the state that corresponds to the given [BlockId].
+    fn with_state_at<F, T>(&self, _at: BlockId, _f: F) -> EthResult<T>
+    where
+        F: FnOnce(ChainState<'_>) -> EthResult<T>;
+
+    /// Returns the revm evm env for the requested [BlockId]
+    ///
+    /// If the [BlockId] this will return the [BlockId::Hash] of the block the env was configured
+    /// for.
+    async fn evm_env_at(&self, at: BlockId) -> EthResult<(CfgEnv, BlockEnv, BlockId)>;
+
+    /// Returns the transaction by hash.
+    ///
+    /// Checks the pool and state.
+    ///
+    /// Returns `Ok(None)` if no matching transaction was found.
+    async fn transaction_by_hash(&self, hash: H256) -> EthResult<Option<TransactionSource>>;
+
+    /// Returns the transaction by including its corresponding [BlockId]
+    async fn transaction_by_hash_at(
+        &self,
+        hash: H256,
+    ) -> EthResult<Option<(TransactionSource, BlockId)>>;
+}
+
+#[async_trait]
+impl<Client, Pool, Network> EthTransactions for EthApi<Client, Pool, Network>
+where
+    Pool: TransactionPool + Clone + 'static,
+    Client: BlockProvider + StateProviderFactory + EvmEnvProvider + 'static,
+    Network: Send + Sync + 'static,
+{
+    fn state_at(&self, at: BlockId) -> EthResult<ChainState<'_>> {
+        self.state_at_block_id(at)
+    }
+
+    fn with_state_at<F, T>(&self, at: BlockId, f: F) -> EthResult<T>
+    where
+        F: FnOnce(ChainState<'_>) -> EthResult<T>,
+    {
+        let state = self.state_at(at)?;
+        f(state)
+    }
+
+    async fn evm_env_at(&self, at: BlockId) -> EthResult<(CfgEnv, BlockEnv, BlockId)> {
+        // TODO handle Pending state's env
+        match at {
+            BlockId::Number(BlockNumberOrTag::Pending) => {
+                // This should perhaps use the latest env settings and update block specific
+                // settings like basefee/number
+                unimplemented!("support pending state env")
+            }
+            hash_or_num => {
+                let block_hash = self
+                    .client()
+                    .block_hash_for_id(hash_or_num)?
+                    .ok_or_else(|| EthApiError::UnknownBlockNumber)?;
+                let (cfg, env) = self.cache().get_evm_env(block_hash).await?;
+                Ok((cfg, env, block_hash.into()))
+            }
+        }
+    }
+
+    async fn transaction_by_hash(&self, hash: H256) -> EthResult<Option<TransactionSource>> {
+        if let Some(tx) = self.pool().get(&hash).map(|tx| tx.transaction.to_recovered_transaction())
+        {
+            return Ok(Some(TransactionSource::Pool(tx)))
+        }
+
+        match self.client().transaction_by_hash(hash)? {
+            None => Ok(None),
+            Some(tx) => {
+                let transaction =
+                    tx.into_ecrecovered().ok_or(EthApiError::InvalidTransactionSignature)?;
+
+                let tx = TransactionSource::Database {
+                    transaction,
+                    // TODO: this is just stubbed out for now still need to fully implement tx =>
+                    // block
+                    index: 0,
+                    block_hash: Default::default(),
+                    block_number: 0,
+                };
+                Ok(Some(tx))
+            }
+        }
+    }
+
+    async fn transaction_by_hash_at(
+        &self,
+        hash: H256,
+    ) -> EthResult<Option<(TransactionSource, BlockId)>> {
+        match self.transaction_by_hash(hash).await? {
+            None => return Ok(None),
+            Some(tx) => {
+                let res = match tx {
+                    tx @ TransactionSource::Pool(_) => {
+                        (tx, BlockId::Number(BlockNumberOrTag::Pending))
+                    }
+                    TransactionSource::Database {
+                        transaction,
+                        index,
+                        block_hash,
+                        block_number,
+                    } => {
+                        let at = BlockId::Hash(block_hash.into());
+                        let tx = TransactionSource::Database {
+                            transaction,
+                            index,
+                            block_hash,
+                            block_number,
+                        };
+                        (tx, at)
+                    }
+                };
+                Ok(Some(res))
+            }
+        }
+    }
+}
+
+// === impl EthApi ===
 
 impl<Client, Pool, Network> EthApi<Client, Pool, Network>
 where
@@ -20,6 +153,35 @@ where
         unimplemented!()
     }
 
+    /// Get Transaction by [BlockId] and the index of the transaction within that Block.
+    ///
+    /// Returns `Ok(None)` if the block does not exist, or the block as fewer transactions
+    pub(crate) async fn transaction_by_block_and_tx_index(
+        &self,
+        block_id: impl Into<BlockId>,
+        index: Index,
+    ) -> EthResult<Option<Transaction>> {
+        let block_id = block_id.into();
+        if let Some(block) = self.client().block(block_id)? {
+            let block_hash = self
+                .client()
+                .block_hash_for_id(block_id)?
+                .ok_or(EthApiError::UnknownBlockNumber)?;
+            if let Some(tx_signed) = block.body.into_iter().nth(index.into()) {
+                let tx =
+                    tx_signed.into_ecrecovered().ok_or(EthApiError::InvalidTransactionSignature)?;
+                return Ok(Some(Transaction::from_recovered_with_block_context(
+                    tx,
+                    block_hash,
+                    block.header.number,
+                    index.into(),
+                )))
+            }
+        }
+
+        Ok(None)
+    }
+
     /// Decodes and recovers the transaction and submits it to the pool.
     ///
     /// Returns the hash of the transaction.
@@ -44,8 +206,91 @@ where
     }
 }
 
+/// Represents from where a transaction was fetched.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum TransactionSource {
+    /// Transaction exists in the pool (Pending)
+    Pool(TransactionSignedEcRecovered),
+    /// Transaction already executed
+    Database {
+        /// Transaction fetched via provider
+        transaction: TransactionSignedEcRecovered,
+        /// Index of the transaction in the block
+        index: usize,
+        /// Hash of the block.
+        block_hash: H256,
+        /// Number of the block.
+        block_number: u64,
+    },
+}
+
+// === impl TransactionSource ===
+
+impl TransactionSource {
+    /// Consumes the type and returns the wrapped transaction.
+    pub fn into_recovered(self) -> TransactionSignedEcRecovered {
+        self.into()
+    }
+
+    /// Returns the transaction and block related info, if not pending
+    pub fn split(self) -> (TransactionSignedEcRecovered, TransactionInfo) {
+        match self {
+            TransactionSource::Pool(tx) => {
+                let hash = tx.hash();
+                (
+                    tx,
+                    TransactionInfo {
+                        hash: Some(hash),
+                        index: None,
+                        block_hash: None,
+                        block_number: None,
+                    },
+                )
+            }
+            TransactionSource::Database { transaction, index, block_hash, block_number } => {
+                let hash = transaction.hash();
+                (
+                    transaction,
+                    TransactionInfo {
+                        hash: Some(hash),
+                        index: Some(index),
+                        block_hash: Some(block_hash),
+                        block_number: Some(block_number),
+                    },
+                )
+            }
+        }
+    }
+}
+
+impl From<TransactionSource> for TransactionSignedEcRecovered {
+    fn from(value: TransactionSource) -> Self {
+        match value {
+            TransactionSource::Pool(tx) => tx,
+            TransactionSource::Database { transaction, .. } => transaction,
+        }
+    }
+}
+
+impl From<TransactionSource> for Transaction {
+    fn from(value: TransactionSource) -> Self {
+        match value {
+            TransactionSource::Pool(tx) => Transaction::from_recovered(tx),
+            TransactionSource::Database { transaction, index, block_hash, block_number } => {
+                Transaction::from_recovered_with_block_context(
+                    transaction,
+                    block_hash,
+                    block_number,
+                    U256::from(index),
+                )
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use crate::eth::cache::EthStateCache;
     use reth_primitives::{hex_literal::hex, Bytes};
     use reth_provider::test_utils::NoopProvider;
     use reth_transaction_pool::{test_utils::testing_pool, TransactionPool};
@@ -58,7 +303,12 @@ mod tests {
 
         let pool = testing_pool();
 
-        let eth_api = EthApi::new(noop_provider, pool.clone(), ());
+        let eth_api = EthApi::new(
+            noop_provider,
+            pool.clone(),
+            (),
+            EthStateCache::spawn(NoopProvider::default(), Default::default()),
+        );
 
         // https://etherscan.io/tx/0xa694b71e6c128a2ed8e2e0f6770bddbe52e3bb8f10e8472f9a79ab81497a8b5d
         let tx_1 = Bytes::from(hex!("02f871018303579880850555633d1b82520894eee27662c2b8eba3cd936a23f039f3189633e4c887ad591c62bdaeb180c080a07ea72c68abfb8fca1bd964f0f99132ed9280261bdca3e549546c0205e800f7d0a05b4ef3039e9c9b9babc179a1878fb825b5aaf5aed2fa8744854150157b08d6f3"));
diff --git a/crates/rpc/rpc/src/eth/cache.rs b/crates/rpc/rpc/src/eth/cache.rs
new file mode 100644
index 00000000000..71706dc7cc4
--- /dev/null
+++ b/crates/rpc/rpc/src/eth/cache.rs
@@ -0,0 +1,321 @@
+//! Async caching support for eth RPC
+
+use futures::StreamExt;
+use reth_interfaces::{provider::ProviderError, Result};
+use reth_primitives::{Block, H256};
+use reth_provider::{BlockProvider, EvmEnvProvider, StateProviderFactory};
+use reth_tasks::{TaskSpawner, TokioTaskExecutor};
+use revm::primitives::{BlockEnv, CfgEnv};
+use schnellru::{ByMemoryUsage, Limiter, LruMap};
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    future::Future,
+    hash::Hash,
+    pin::Pin,
+    task::{ready, Context, Poll},
+};
+use tokio::sync::{
+    mpsc::{unbounded_channel, UnboundedSender},
+    oneshot,
+};
+use tokio_stream::wrappers::UnboundedReceiverStream;
+
+/// The type that can send the response to a requested [Block]
+type BlockResponseSender = oneshot::Sender<Result<Option<Block>>>;
+
+/// The type that can send the response to a requested env
+type EnvResponseSender = oneshot::Sender<Result<(CfgEnv, BlockEnv)>>;
+
+type BlockLruCache<L> = MultiConsumerLruCache<H256, Block, L, BlockResponseSender>;
+
+type EnvLruCache<L> = MultiConsumerLruCache<H256, (CfgEnv, BlockEnv), L, EnvResponseSender>;
+
+/// Settings for the [EthStateCache]
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EthStateCacheConfig {
+    /// Max number of bytes for cached block data.
+    ///
+    /// Default is 50MB
+    pub max_block_bytes: usize,
+    /// Max number of bytes for cached env data.
+    ///
+    /// Default is 500kb (env configs are very small)
+    pub max_env_bytes: usize,
+}
+
+impl Default for EthStateCacheConfig {
+    fn default() -> Self {
+        Self { max_block_bytes: 50 * 1024 * 1024, max_env_bytes: 500 * 1024 }
+    }
+}
+
+/// Provides async access to cached eth data
+///
+/// This is the frontend for the async caching service which manages cached data on a different
+/// task.
+#[derive(Debug, Clone)]
+pub struct EthStateCache {
+    to_service: UnboundedSender<CacheAction>,
+}
+
+impl EthStateCache {
+    /// Creates and returns both [EthStateCache] frontend and the memory bound service.
+    fn create<Client, Tasks>(
+        client: Client,
+        action_task_spawner: Tasks,
+        max_block_bytes: usize,
+        max_env_bytes: usize,
+    ) -> (Self, EthStateCacheService<Client, Tasks>) {
+        let (to_service, rx) = unbounded_channel();
+        let service = EthStateCacheService {
+            client,
+            full_block_cache: BlockLruCache::with_memory_budget(max_block_bytes),
+            evm_env_cache: EnvLruCache::with_memory_budget(max_env_bytes),
+            action_tx: to_service.clone(),
+            action_rx: UnboundedReceiverStream::new(rx),
+            action_task_spawner,
+        };
+        let cache = EthStateCache { to_service };
+        (cache, service)
+    }
+
+    /// Creates a new async LRU backed cache service task and spawns it to a new task via
+    /// [tokio::spawn].
+    ///
+    /// See also [Self::spawn_with]
+    pub fn spawn<Client>(client: Client, config: EthStateCacheConfig) -> Self
+    where
+        Client: StateProviderFactory + BlockProvider + EvmEnvProvider + Clone + Unpin + 'static,
+    {
+        Self::spawn_with(client, config, TokioTaskExecutor::default())
+    }
+
+    /// Creates a new async LRU backed cache service task and spawns it to a new task via the given
+    /// spawner.
+    ///
+    /// The cache is memory limited by the given max bytes values.
+    pub fn spawn_with<Client, Tasks>(
+        client: Client,
+        config: EthStateCacheConfig,
+        executor: Tasks,
+    ) -> Self
+    where
+        Client: StateProviderFactory + BlockProvider + EvmEnvProvider + Clone + Unpin + 'static,
+        Tasks: TaskSpawner + Clone + 'static,
+    {
+        let EthStateCacheConfig { max_block_bytes, max_env_bytes } = config;
+        let (this, service) =
+            Self::create(client, executor.clone(), max_block_bytes, max_env_bytes);
+        executor.spawn_critical("eth state cache", Box::pin(service));
+        this
+    }
+
+    /// Requests the [Block] for the block hash
+    ///
+    /// Returns `None` if the block does not exist.
+    pub(crate) async fn get_block(&self, block_hash: H256) -> Result<Option<Block>> {
+        let (response_tx, rx) = oneshot::channel();
+        let _ = self.to_service.send(CacheAction::GetBlock { block_hash, response_tx });
+        rx.await.map_err(|_| ProviderError::CacheServiceUnavailable)?
+    }
+
+    /// Requests the evm env config for the block hash.
+    ///
+    /// Returns an error if the corresponding header (required for populating the envs) was not
+    /// found.
+    pub(crate) async fn get_evm_env(&self, block_hash: H256) -> Result<(CfgEnv, BlockEnv)> {
+        let (response_tx, rx) = oneshot::channel();
+        let _ = self.to_service.send(CacheAction::GetEnv { block_hash, response_tx });
+        rx.await.map_err(|_| ProviderError::CacheServiceUnavailable)?
+    }
+}
+
+/// A task than manages caches for data required by the `eth` rpc implementation.
+///
+/// It provides a caching layer on top of the given [StateProvider](reth_provider::StateProvider)
+/// and keeps data fetched via the provider in memory in an LRU cache. If the requested data is
+/// missing in the cache it is fetched and inserted into the cache afterwards. While fetching data
+/// from disk is sync, this service is async since requests and data is shared via channels.
+///
+/// This type is an endless future that listens for incoming messages from the user facing
+/// [EthStateCache] via a channel. If the requested data is not cached then it spawns a new task
+/// that does the IO and sends the result back to it. This way the caching service only
+/// handles messages and does LRU lookups and never blocking IO.
+///
+/// Caution: The channel for the data is _unbounded_ it is assumed that this is mainly used by the
+/// [EthApi](crate::EthApi) which is typically invoked by the RPC server, which already uses permits
+/// to limit concurrent requests.
+#[must_use = "Type does nothing unless spawned"]
+pub(crate) struct EthStateCacheService<
+    Client,
+    Tasks,
+    LimitBlocks = ByMemoryUsage,
+    LimitEnvs = ByMemoryUsage,
+> where
+    LimitBlocks: Limiter<H256, Block>,
+    LimitEnvs: Limiter<H256, (CfgEnv, BlockEnv)>,
+{
+    /// The type used to lookup data from disk
+    client: Client,
+    /// The LRU cache for full blocks grouped by their hash.
+    full_block_cache: BlockLruCache<LimitBlocks>,
+    /// The LRU cache for revm environments
+    evm_env_cache: EnvLruCache<LimitEnvs>,
+    /// Sender half of the action channel.
+    action_tx: UnboundedSender<CacheAction>,
+    /// Receiver half of the action channel.
+    action_rx: UnboundedReceiverStream<CacheAction>,
+    /// The type that's used to spawn tasks that do the actual work
+    action_task_spawner: Tasks,
+}
+
+impl<Client, Tasks> Future for EthStateCacheService<Client, Tasks>
+where
+    Client: StateProviderFactory + BlockProvider + EvmEnvProvider + Clone + Unpin + 'static,
+    Tasks: TaskSpawner + Clone + 'static,
+{
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        loop {
+            match ready!(this.action_rx.poll_next_unpin(cx)) {
+                None => {
+                    unreachable!("can't close")
+                }
+                Some(action) => {
+                    match action {
+                        CacheAction::GetBlock { block_hash, response_tx } => {
+                            // check if block is cached
+                            if let Some(block) =
+                                this.full_block_cache.cache.get(&block_hash).cloned()
+                            {
+                                let _ = response_tx.send(Ok(Some(block)));
+                                continue
+                            }
+
+                            // block is not in the cache, request it if this is the first consumer
+                            if this.full_block_cache.queue(block_hash, response_tx) {
+                                let client = this.client.clone();
+                                let action_tx = this.action_tx.clone();
+                                this.action_task_spawner.spawn(Box::pin(async move {
+                                    let res = client.block_by_hash(block_hash);
+                                    let _ = action_tx
+                                        .send(CacheAction::BlockResult { block_hash, res });
+                                }));
+                            }
+                        }
+                        CacheAction::GetEnv { block_hash, response_tx } => {
+                            // check if env data is cached
+                            if let Some(env) = this.evm_env_cache.cache.get(&block_hash).cloned() {
+                                let _ = response_tx.send(Ok(env));
+                                continue
+                            }
+
+                            // env data is not in the cache, request it if this is the first
+                            // consumer
+                            if this.evm_env_cache.queue(block_hash, response_tx) {
+                                let client = this.client.clone();
+                                let action_tx = this.action_tx.clone();
+                                this.action_task_spawner.spawn(Box::pin(async move {
+                                    let mut cfg = CfgEnv::default();
+                                    let mut block_env = BlockEnv::default();
+                                    let res = client
+                                        .fill_env_at(&mut cfg, &mut block_env, block_hash.into())
+                                        .map(|_| (cfg, block_env));
+                                    let _ = action_tx.send(CacheAction::EnvResult {
+                                        block_hash,
+                                        res: Box::new(res),
+                                    });
+                                }));
+                            }
+                        }
+                        CacheAction::BlockResult { block_hash, res } => {
+                            if let Some(queued) = this.full_block_cache.queued.remove(&block_hash) {
+                                // send the response to queued senders
+                                for tx in queued {
+                                    let _ = tx.send(res.clone());
+                                }
+                            }
+
+                            // cache good block
+                            if let Ok(Some(block)) = res {
+                                this.full_block_cache.cache.insert(block_hash, block);
+                            }
+                        }
+                        CacheAction::EnvResult { block_hash, res } => {
+                            let res = *res;
+                            if let Some(queued) = this.evm_env_cache.queued.remove(&block_hash) {
+                                // send the response to queued senders
+                                for tx in queued {
+                                    let _ = tx.send(res.clone());
+                                }
+                            }
+
+                            // cache good env data
+                            if let Ok(data) = res {
+                                this.evm_env_cache.cache.insert(block_hash, data);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+struct MultiConsumerLruCache<K, V, L, S>
+where
+    K: Hash + Eq,
+    L: Limiter<K, V>,
+{
+    /// The LRU cache for the
+    cache: LruMap<K, V, L>,
+    /// All queued consumers
+    queued: HashMap<K, Vec<S>>,
+}
+
+impl<K, V, L, S> MultiConsumerLruCache<K, V, L, S>
+where
+    K: Hash + Eq,
+    L: Limiter<K, V>,
+{
+    /// Adds the sender to the queue for the given key.
+    ///
+    /// Returns true if this is the first queued sender for the key
+    fn queue(&mut self, key: K, sender: S) -> bool {
+        match self.queued.entry(key) {
+            Entry::Occupied(mut entry) => {
+                entry.get_mut().push(sender);
+                false
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(vec![sender]);
+                true
+            }
+        }
+    }
+}
+
+impl<K, V, S> MultiConsumerLruCache<K, V, ByMemoryUsage, S>
+where
+    K: Hash + Eq,
+{
+    /// Creates a new empty map with a given `memory_budget`.
+    ///
+    /// See also [LruMap::with_memory_budget]
+    fn with_memory_budget(memory_budget: usize) -> Self {
+        Self { cache: LruMap::with_memory_budget(memory_budget), queued: Default::default() }
+    }
+}
+
+/// All message variants sent through the channel
+enum CacheAction {
+    GetBlock { block_hash: H256, response_tx: BlockResponseSender },
+    GetEnv { block_hash: H256, response_tx: EnvResponseSender },
+    BlockResult { block_hash: H256, res: Result<Option<Block>> },
+    EnvResult { block_hash: H256, res: Box<Result<(CfgEnv, BlockEnv)>> },
+}
diff --git a/crates/rpc/rpc/src/eth/error.rs b/crates/rpc/rpc/src/eth/error.rs
index e211b29c468..51f43061f77 100644
--- a/crates/rpc/rpc/src/eth/error.rs
+++ b/crates/rpc/rpc/src/eth/error.rs
@@ -1,41 +1,19 @@
-//! Error variants for the `eth_` namespace.
+//! Implementation specific Errors for the `eth_` namespace.
 
-use crate::result::{internal_rpc_err, rpc_err};
-use jsonrpsee::{core::Error as RpcError, types::error::INVALID_PARAMS_CODE};
-use reth_primitives::U128;
-use reth_rpc_types::BlockError;
-use reth_transaction_pool::error::PoolError;
-use revm::primitives::EVMError;
+use crate::result::{internal_rpc_err, invalid_params_rpc_err, rpc_err};
+use jsonrpsee::core::Error as RpcError;
+use reth_primitives::{constants::SELECTOR_LEN, Address, Bytes, U256};
+use reth_rpc_types::{error::EthRpcErrorCode, BlockError};
+use reth_transaction_pool::error::{InvalidPoolTransactionError, PoolError};
+use revm::primitives::{EVMError, ExecutionResult, Halt, OutOfGasError};
 
 /// Result alias
-pub(crate) type EthResult<T> = Result<T, EthApiError>;
-
-/// List of JSON-RPC error codes
-#[derive(Debug, Copy, PartialEq, Eq, Clone)]
-pub(crate) enum EthRpcErrorCode {
-    /// Failed to send transaction, See also <https://github.com/MetaMask/eth-rpc-errors/blob/main/src/error-constants.ts>
-    TransactionRejected,
-    /// Custom geth error code, <https://github.com/vapory-legacy/wiki/blob/master/JSON-RPC-Error-Codes-Improvement-Proposal.md>
-    ExecutionError,
-    /// <https://eips.ethereum.org/EIPS/eip-1898>
-    InvalidInput,
-}
-
-impl EthRpcErrorCode {
-    /// Returns the error code as `i32`
-    pub(crate) const fn code(&self) -> i32 {
-        match *self {
-            EthRpcErrorCode::TransactionRejected => -32003,
-            EthRpcErrorCode::ExecutionError => 3,
-            EthRpcErrorCode::InvalidInput => -32000,
-        }
-    }
-}
+pub type EthResult<T> = Result<T, EthApiError>;
 
 /// Errors that can occur when interacting with the `eth_` namespace
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
-pub(crate) enum EthApiError {
+pub enum EthApiError {
     /// When a raw transaction is empty
     #[error("Empty transaction data")]
     EmptyRawTransactionData,
@@ -44,7 +22,7 @@ pub(crate) enum EthApiError {
     #[error("Invalid transaction signature")]
     InvalidTransactionSignature,
     #[error(transparent)]
-    PoolError(GethTxPoolError),
+    PoolError(RpcPoolError),
     #[error("Unknown block number")]
     UnknownBlockNumber,
     #[error("Invalid block range")]
@@ -53,35 +31,62 @@ pub(crate) enum EthApiError {
     #[error("Prevrandao not in th EVM's environment after merge")]
     PrevrandaoNotSet,
     #[error("Conflicting fee values in request. Both legacy gasPrice {gas_price} and maxFeePerGas {max_fee_per_gas} set")]
-    ConflictingRequestGasPrice { gas_price: U128, max_fee_per_gas: U128 },
+    ConflictingRequestGasPrice { gas_price: U256, max_fee_per_gas: U256 },
     #[error("Conflicting fee values in request. Both legacy gasPrice {gas_price} maxFeePerGas {max_fee_per_gas} and maxPriorityFeePerGas {max_priority_fee_per_gas} set")]
     ConflictingRequestGasPriceAndTipSet {
-        gas_price: U128,
-        max_fee_per_gas: U128,
-        max_priority_fee_per_gas: U128,
+        gas_price: U256,
+        max_fee_per_gas: U256,
+        max_priority_fee_per_gas: U256,
     },
     #[error("Conflicting fee values in request. Legacy gasPrice {gas_price} and maxPriorityFeePerGas {max_priority_fee_per_gas} set")]
-    RequestLegacyGasPriceAndTipSet { gas_price: U128, max_priority_fee_per_gas: U128 },
+    RequestLegacyGasPriceAndTipSet { gas_price: U256, max_priority_fee_per_gas: U256 },
     #[error(transparent)]
     InvalidTransaction(#[from] InvalidTransactionError),
     /// Thrown when constructing an RPC block from a primitive block data failed.
     #[error(transparent)]
     InvalidBlockData(#[from] BlockError),
+    /// Thrown when a [AccountOverride](reth_rpc_types::state::AccountOverride) contains
+    /// conflicting `state` and `stateDiff` fields
+    #[error("account {0:?} has both 'state' and 'stateDiff'")]
+    BothStateAndStateDiffInOverride(Address),
     /// Other internal error
     #[error(transparent)]
     Internal(#[from] reth_interfaces::Error),
+    /// Error related to signing
+    #[error(transparent)]
+    Signing(#[from] SignError),
+    /// Thrown when a transaction was requested but not matching transaction exists
+    #[error("transaction not found")]
+    TransactionNotFound,
+    /// Some feature is unsupported
+    #[error("unsupported")]
+    Unsupported(&'static str),
+    /// When tracer config does not match the tracer
+    #[error("invalid tracer config")]
+    InvalidTracerConfig,
 }
 
 impl From<EthApiError> for RpcError {
-    fn from(value: EthApiError) -> Self {
-        match value {
+    fn from(error: EthApiError) -> Self {
+        match error {
             EthApiError::FailedToDecodeSignedTransaction |
             EthApiError::InvalidTransactionSignature |
             EthApiError::EmptyRawTransactionData |
             EthApiError::UnknownBlockNumber |
-            EthApiError::InvalidBlockRange => rpc_err(INVALID_PARAMS_CODE, value.to_string(), None),
+            EthApiError::InvalidBlockRange |
+            EthApiError::ConflictingRequestGasPrice { .. } |
+            EthApiError::ConflictingRequestGasPriceAndTipSet { .. } |
+            EthApiError::RequestLegacyGasPriceAndTipSet { .. } |
+            EthApiError::Signing(_) |
+            EthApiError::BothStateAndStateDiffInOverride(_) |
+            EthApiError::InvalidTracerConfig => invalid_params_rpc_err(error.to_string()),
             EthApiError::InvalidTransaction(err) => err.into(),
-            err => internal_rpc_err(err.to_string()),
+            EthApiError::PoolError(_) |
+            EthApiError::PrevrandaoNotSet |
+            EthApiError::InvalidBlockData(_) |
+            EthApiError::Internal(_) |
+            EthApiError::TransactionNotFound => internal_rpc_err(error.to_string()),
+            EthApiError::Unsupported(msg) => internal_rpc_err(msg),
         }
     }
 }
@@ -161,23 +166,80 @@ pub enum InvalidTransactionError {
     /// Thrown if the sender of a transaction is a contract.
     #[error("sender not an eoa")]
     SenderNoEOA,
+    /// Thrown during estimate if caller has insufficient funds to cover the tx.
+    #[error("Out of gas: gas required exceeds allowance: {0:?}")]
+    BasicOutOfGas(U256),
+    /// As BasicOutOfGas but thrown when gas exhausts during memory expansion.
+    #[error("Out of gas: gas exhausts during memory expansion: {0:?}")]
+    MemoryOutOfGas(U256),
+    /// As BasicOutOfGas but thrown when gas exhausts during precompiled contract execution.
+    #[error("Out of gas: gas exhausts during precompiled contract execution: {0:?}")]
+    PrecompileOutOfGas(U256),
+    /// revm's Type cast error, U256 casts down to a u64 with overflow
+    #[error("Out of gas: revm's Type cast error, U256 casts down to a u64 with overflow {0:?}")]
+    InvalidOperandOutOfGas(U256),
+    /// Thrown if executing a transaction failed during estimate/call
+    #[error("{0}")]
+    Revert(RevertError),
+    /// Unspecific evm halt error
+    #[error("EVM error {0:?}")]
+    EvmHalt(Halt),
+    /// Invalid chain id set for the transaction.
+    #[error("Invalid chain id")]
+    InvalidChainId,
 }
 
 impl InvalidTransactionError {
     /// Returns the rpc error code for this error.
     fn error_code(&self) -> i32 {
         match self {
-            InvalidTransactionError::GasTooLow | InvalidTransactionError::GasTooHigh => {
-                EthRpcErrorCode::InvalidInput.code()
-            }
+            InvalidTransactionError::InvalidChainId |
+            InvalidTransactionError::GasTooLow |
+            InvalidTransactionError::GasTooHigh => EthRpcErrorCode::InvalidInput.code(),
+            InvalidTransactionError::Revert(_) => EthRpcErrorCode::ExecutionError.code(),
             _ => EthRpcErrorCode::TransactionRejected.code(),
         }
     }
+
+    /// Converts the halt error
+    ///
+    /// Takes the configured gas limit of the transaction which is attached to the error
+    pub(crate) fn halt(reason: Halt, gas_limit: u64) -> Self {
+        match reason {
+            Halt::OutOfGas(err) => InvalidTransactionError::out_of_gas(err, gas_limit),
+            Halt::NonceOverflow => InvalidTransactionError::NonceMaxValue,
+            err => InvalidTransactionError::EvmHalt(err),
+        }
+    }
+
+    /// Converts the out of gas error
+    pub(crate) fn out_of_gas(reason: OutOfGasError, gas_limit: u64) -> Self {
+        let gas_limit = U256::from(gas_limit);
+        match reason {
+            OutOfGasError::BasicOutOfGas => InvalidTransactionError::BasicOutOfGas(gas_limit),
+            OutOfGasError::Memory => InvalidTransactionError::MemoryOutOfGas(gas_limit),
+            OutOfGasError::Precompile => InvalidTransactionError::PrecompileOutOfGas(gas_limit),
+            OutOfGasError::InvalidOperand => {
+                InvalidTransactionError::InvalidOperandOutOfGas(gas_limit)
+            }
+            OutOfGasError::MemoryLimit => InvalidTransactionError::MemoryOutOfGas(gas_limit),
+        }
+    }
 }
 
 impl From<InvalidTransactionError> for RpcError {
     fn from(err: InvalidTransactionError) -> Self {
-        rpc_err(err.error_code(), err.to_string(), None)
+        match err {
+            InvalidTransactionError::Revert(revert) => {
+                // include out data if some
+                rpc_err(
+                    revert.error_code(),
+                    revert.to_string(),
+                    revert.output.as_ref().map(|out| out.as_ref()),
+                )
+            }
+            err => rpc_err(err.error_code(), err.to_string(), None),
+        }
     }
 }
 
@@ -185,6 +247,7 @@ impl From<revm::primitives::InvalidTransaction> for InvalidTransactionError {
     fn from(err: revm::primitives::InvalidTransaction) -> Self {
         use revm::primitives::InvalidTransaction;
         match err {
+            InvalidTransaction::InvalidChainId => InvalidTransactionError::InvalidChainId,
             InvalidTransaction::GasMaxFeeGreaterThanPriorityFee => {
                 InvalidTransactionError::TipAboveFeeCap
             }
@@ -210,9 +273,52 @@ impl From<revm::primitives::InvalidTransaction> for InvalidTransactionError {
     }
 }
 
-/// A helper error type that mirrors `geth` Txpool's error messages
+/// Represents a reverted transaction and its output data.
+///
+/// Displays "execution reverted(: reason)?" if the reason is a string.
+#[derive(Debug, Clone)]
+pub struct RevertError {
+    /// The transaction output data
+    ///
+    /// Note: this is `None` if output was empty
+    output: Option<bytes::Bytes>,
+}
+
+// === impl RevertError ==
+
+impl RevertError {
+    /// Wraps the output bytes
+    ///
+    /// Note: this is intended to wrap an revm output
+    pub fn new(output: bytes::Bytes) -> Self {
+        if output.is_empty() {
+            Self { output: None }
+        } else {
+            Self { output: Some(output) }
+        }
+    }
+
+    fn error_code(&self) -> i32 {
+        EthRpcErrorCode::ExecutionError.code()
+    }
+}
+
+impl std::fmt::Display for RevertError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("execution reverted")?;
+        if let Some(reason) = self.output.as_ref().and_then(decode_revert_reason) {
+            write!(f, ": {reason}")?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for RevertError {}
+
+/// A helper error type that's mainly used to mirror `geth` Txpool's error messages
 #[derive(Debug, thiserror::Error)]
-pub(crate) enum GethTxPoolError {
+#[allow(missing_docs)]
+pub enum RpcPoolError {
     #[error("already known")]
     AlreadyKnown,
     #[error("invalid sender")]
@@ -229,23 +335,67 @@ pub(crate) enum GethTxPoolError {
     NegativeValue,
     #[error("oversized data")]
     OversizedData,
+    #[error(transparent)]
+    Invalid(#[from] InvalidPoolTransactionError),
+    #[error(transparent)]
+    Other(Box<dyn std::error::Error + Send + Sync>),
 }
 
-impl From<PoolError> for GethTxPoolError {
-    fn from(err: PoolError) -> GethTxPoolError {
+impl From<PoolError> for RpcPoolError {
+    fn from(err: PoolError) -> RpcPoolError {
         match err {
-            PoolError::ReplacementUnderpriced(_) => GethTxPoolError::ReplaceUnderpriced,
-            PoolError::ProtocolFeeCapTooLow(_, _) => GethTxPoolError::Underpriced,
-            PoolError::SpammerExceededCapacity(_, _) => GethTxPoolError::TxPoolOverflow,
-            PoolError::DiscardedOnInsert(_) => GethTxPoolError::TxPoolOverflow,
-            PoolError::TxExceedsGasLimit(_, _, _) => GethTxPoolError::GasLimit,
-            PoolError::TxExceedsMaxInitCodeSize(_, _, _) => GethTxPoolError::OversizedData,
+            PoolError::ReplacementUnderpriced(_) => RpcPoolError::ReplaceUnderpriced,
+            PoolError::ProtocolFeeCapTooLow(_, _) => RpcPoolError::Underpriced,
+            PoolError::SpammerExceededCapacity(_, _) => RpcPoolError::TxPoolOverflow,
+            PoolError::DiscardedOnInsert(_) => RpcPoolError::TxPoolOverflow,
+            PoolError::InvalidTransaction(_, err) => err.into(),
+            PoolError::Other(_, err) => RpcPoolError::Other(err),
         }
     }
 }
 
 impl From<PoolError> for EthApiError {
     fn from(err: PoolError) -> Self {
-        EthApiError::PoolError(GethTxPoolError::from(err))
+        EthApiError::PoolError(RpcPoolError::from(err))
+    }
+}
+
+/// Errors returned from a sign request.
+#[derive(Debug, thiserror::Error)]
+pub enum SignError {
+    /// Error occured while trying to sign data.
+    #[error("Could not sign")]
+    CouldNotSign,
+    /// Signer for requested account not found.
+    #[error("Unknown account")]
+    NoAccount,
+    /// TypedData has invalid format.
+    #[error("Given typed data is not valid")]
+    TypedData,
+}
+
+/// Converts the evm [ExecutionResult] into a result where `Ok` variant is the output bytes if it is
+/// [ExecutionResult::Success].
+pub(crate) fn ensure_success(result: ExecutionResult) -> EthResult<Bytes> {
+    match result {
+        ExecutionResult::Success { output, .. } => Ok(output.into_data().into()),
+        ExecutionResult::Revert { output, .. } => {
+            Err(InvalidTransactionError::Revert(RevertError::new(output)).into())
+        }
+        ExecutionResult::Halt { reason, gas_used } => {
+            Err(InvalidTransactionError::halt(reason, gas_used).into())
+        }
+    }
+}
+
+/// Returns the revert reason from the `revm::TransactOut` data, if it's an abi encoded String.
+///
+/// **Note:** it's assumed the `out` buffer starts with the call's signature
+pub(crate) fn decode_revert_reason(out: impl AsRef<[u8]>) -> Option<String> {
+    use ethers_core::abi::AbiDecode;
+    let out = out.as_ref();
+    if out.len() < SELECTOR_LEN {
+        return None
     }
+    String::decode(&out[SELECTOR_LEN..]).ok()
 }
diff --git a/crates/rpc/rpc/src/eth/filter.rs b/crates/rpc/rpc/src/eth/filter.rs
index edaf73c97d5..350017f7d20 100644
--- a/crates/rpc/rpc/src/eth/filter.rs
+++ b/crates/rpc/rpc/src/eth/filter.rs
@@ -1,16 +1,11 @@
 use crate::{
-    eth::error::EthApiError,
+    eth::{error::EthApiError, logs_utils},
     result::{internal_rpc_err, rpc_error_with_code, ToRpcResult},
+    EthSubscriptionIdProvider,
 };
 use async_trait::async_trait;
-use jsonrpsee::{
-    core::RpcResult,
-    server::{IdProvider, RandomIntegerIdProvider},
-};
-use reth_primitives::{
-    filter::{Filter, FilterBlockOption, FilteredParams},
-    Block, U256,
-};
+use jsonrpsee::{core::RpcResult, server::IdProvider};
+use reth_primitives::filter::{Filter, FilterBlockOption, FilteredParams};
 use reth_provider::{BlockProvider, EvmEnvProvider};
 use reth_rpc_api::EthFilterApiServer;
 use reth_rpc_types::{FilterChanges, FilterId, Log};
@@ -36,7 +31,7 @@ impl<Client, Pool> EthFilter<Client, Pool> {
             client,
             active_filters: Default::default(),
             pool,
-            id_provider: Arc::new(RandomIntegerIdProvider),
+            id_provider: Arc::new(EthSubscriptionIdProvider::default()),
             max_logs_in_response: DEFAULT_MAX_LOGS_IN_RESPONSE,
         };
         Self { inner: Arc::new(inner) }
@@ -54,18 +49,22 @@ where
     Client: BlockProvider + EvmEnvProvider + 'static,
     Pool: TransactionPool + 'static,
 {
+    /// Handler for `eth_newFilter`
     async fn new_filter(&self, filter: Filter) -> RpcResult<FilterId> {
         self.inner.install_filter(FilterKind::Log(Box::new(filter))).await
     }
 
+    /// Handler for `eth_newBlockFilter`
     async fn new_block_filter(&self) -> RpcResult<FilterId> {
         self.inner.install_filter(FilterKind::Block).await
     }
 
+    /// Handler for `eth_newPendingTransactionFilter`
     async fn new_pending_transaction_filter(&self) -> RpcResult<FilterId> {
         self.inner.install_filter(FilterKind::PendingTransaction).await
     }
 
+    /// Handler for `eth_getFilterChanges`
     async fn filter_changes(&self, id: FilterId) -> RpcResult<FilterChanges> {
         let info = self.inner.client.chain_info().to_rpc_result()?;
         let best_number = info.best_number;
@@ -94,7 +93,7 @@ where
                     let block_hash = self
                         .inner
                         .client
-                        .block_hash(U256::from(block_num))
+                        .block_hash(block_num)
                         .to_rpc_result()?
                         .ok_or(EthApiError::UnknownBlockNumber)?;
                     block_hashes.push(block_hash);
@@ -136,20 +135,23 @@ where
         }
     }
 
+    /// Handler for `eth_getFilterLogs`
     async fn filter_logs(&self, _id: FilterId) -> RpcResult<Vec<Log>> {
         todo!()
     }
 
+    /// Handler for `eth_uninstallFilter`
     async fn uninstall_filter(&self, id: FilterId) -> RpcResult<bool> {
         let mut filters = self.inner.active_filters.inner.lock().await;
         if filters.remove(&id).is_some() {
             trace!(target: "rpc::eth::filter", ?id, "uninstalled filter");
             Ok(true)
         } else {
-            Err(internal_rpc_err(format!("Filter id {id:?} does not exist.")))
+            Ok(false)
         }
     }
 
+    /// Handler for `eth_getLogs`
     async fn logs(&self, _filter: Filter) -> RpcResult<Vec<Log>> {
         todo!()
     }
@@ -196,50 +198,51 @@ where
     /// Returns an error if:
     ///  - underlying database error
     ///  - amount of matches exceeds configured limit
-    #[allow(dead_code)]
     fn filter_logs(&self, filter: &Filter, from_block: u64, to_block: u64) -> RpcResult<Vec<Log>> {
-        let mut logs = Vec::new();
+        let mut all_logs = Vec::new();
         let filter_params = FilteredParams::new(Some(filter.clone()));
 
-        let topics =
-            if filter.has_topics() { Some(filter_params.flat_topics.clone()) } else { None };
+        let topics = filter.has_topics().then(|| filter_params.flat_topics.clone());
 
         // derive bloom filters from filter input
         let address_filter = FilteredParams::address_filter(&filter.address);
         let topics_filter = FilteredParams::topics_filter(&topics);
 
+        // loop over the range of new blocks and check logs if the filter matches the log's bloom
+        // filter
         for block_number in from_block..=to_block {
             if let Some(block) = self.client.block_by_number(block_number).to_rpc_result()? {
                 // only if filter matches
                 if FilteredParams::matches_address(block.header.logs_bloom, &address_filter) &&
                     FilteredParams::matches_topics(block.header.logs_bloom, &topics_filter)
                 {
-                    self.append_matching_block_logs(&mut logs, &filter_params, block);
-
-                    // TODO size check
+                    // get receipts for the block
+                    if let Some(receipts) =
+                        self.client.receipts_by_block(block.number.into()).to_rpc_result()?
+                    {
+                        let block_hash = block.hash_slow();
+
+                        logs_utils::append_matching_block_logs(
+                            &mut all_logs,
+                            &filter_params,
+                            block_hash,
+                            block_number,
+                            block.body.into_iter().map(|tx| tx.hash).zip(receipts),
+                        );
+
+                        // size check
+                        if all_logs.len() > self.max_logs_in_response {
+                            return Err(FilterError::QueryExceedsMaxResults(
+                                self.max_logs_in_response,
+                            )
+                            .into())
+                        }
+                    }
                 }
             }
         }
 
-        Ok(logs)
-    }
-
-    /// Appends all logs emitted in the `block` that match the `filter` to the `logs` vector.
-    #[allow(clippy::ptr_arg)]
-    fn append_matching_block_logs(
-        &self,
-        _logs: &mut Vec<Log>,
-        _filter: &FilteredParams,
-        block: Block,
-    ) {
-        let _block_log_index: u32 = 0;
-        let _block_hash = block.hash_slow();
-
-        // loop over all transactions in the block
-        for tx in block.body {
-            let _transaction_log_index: u32 = 0;
-            let _transaction_hash = tx.hash;
-        }
+        Ok(all_logs)
     }
 }
 
@@ -261,7 +264,6 @@ struct ActiveFilter {
 }
 
 #[derive(Clone, Debug)]
-#[allow(clippy::large_enum_variant)]
 enum FilterKind {
     Log(Box<Filter>),
     Block,
@@ -273,6 +275,8 @@ enum FilterKind {
 pub enum FilterError {
     #[error("filter not found")]
     FilterNotFound(FilterId),
+    #[error("Query exceeds max results {0}")]
+    QueryExceedsMaxResults(usize),
 }
 
 // convert the error
@@ -280,9 +284,12 @@ impl From<FilterError> for jsonrpsee::core::Error {
     fn from(err: FilterError) -> Self {
         match err {
             FilterError::FilterNotFound(_) => rpc_error_with_code(
-                jsonrpsee::types::error::CALL_EXECUTION_FAILED_CODE,
+                jsonrpsee::types::error::INVALID_PARAMS_CODE,
                 "filter not found",
             ),
+            err @ FilterError::QueryExceedsMaxResults(_) => {
+                rpc_error_with_code(jsonrpsee::types::error::INVALID_PARAMS_CODE, err.to_string())
+            }
         }
     }
 }
diff --git a/crates/rpc/rpc/src/eth/id_provider.rs b/crates/rpc/rpc/src/eth/id_provider.rs
new file mode 100644
index 00000000000..0355d714d72
--- /dev/null
+++ b/crates/rpc/rpc/src/eth/id_provider.rs
@@ -0,0 +1,67 @@
+use jsonrpsee::types::SubscriptionId;
+use std::fmt::Write;
+
+/// An [IdProvider](jsonrpsee::core::traits::IdProvider) for ethereum subscription ids.
+///
+/// Returns new hex-string [QUANTITY](https://ethereum.org/en/developers/docs/apis/json-rpc/#quantities-encoding) ids
+#[derive(Debug, Clone, Copy, Default)]
+#[non_exhaustive]
+pub struct EthSubscriptionIdProvider;
+
+impl jsonrpsee::core::traits::IdProvider for EthSubscriptionIdProvider {
+    fn next_id(&self) -> SubscriptionId<'static> {
+        to_quantity(rand::random::<u128>())
+    }
+}
+
+/// Returns a hex quantity string for the given value
+///
+/// Strips all leading zeros, `0` is returned as `0x0`
+#[inline(always)]
+fn to_quantity(val: u128) -> SubscriptionId<'static> {
+    let bytes = val.to_be_bytes();
+    let b = bytes.as_slice();
+    let non_zero = b.iter().take_while(|b| **b == 0).count();
+    let b = &b[non_zero..];
+    if b.is_empty() {
+        return SubscriptionId::Str("0x0".into())
+    }
+
+    let mut id = String::with_capacity(2 * b.len() + 2);
+    id.push_str("0x");
+    let first_byte = b[0];
+    write!(id, "{first_byte:x}").unwrap();
+
+    for byte in &b[1..] {
+        write!(id, "{byte:02x}").unwrap();
+    }
+    id.into()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reth_primitives::U128;
+
+    #[test]
+    fn test_id_provider_quantity() {
+        let id = to_quantity(0);
+        assert_eq!(id, SubscriptionId::Str("0x0".into()));
+        let id = to_quantity(1);
+        assert_eq!(id, SubscriptionId::Str("0x1".into()));
+
+        for _ in 0..1000 {
+            let val = rand::random::<u128>();
+            let id = to_quantity(val);
+            match id {
+                SubscriptionId::Str(id) => {
+                    let from_hex: U128 = id.parse().unwrap();
+                    assert_eq!(from_hex, U128::from(val));
+                }
+                SubscriptionId::Num(_) => {
+                    unreachable!()
+                }
+            }
+        }
+    }
+}
diff --git a/crates/rpc/rpc/src/eth/logs_utils.rs b/crates/rpc/rpc/src/eth/logs_utils.rs
new file mode 100644
index 00000000000..41f3cdf87e4
--- /dev/null
+++ b/crates/rpc/rpc/src/eth/logs_utils.rs
@@ -0,0 +1,72 @@
+use reth_primitives::{filter::FilteredParams, Receipt, TxHash, U256};
+use reth_rpc_types::Log;
+use revm::primitives::B256 as H256;
+
+/// Returns all matching logs of a block's receipts grouped with the hash of their transaction.
+pub(crate) fn matching_block_logs<I>(
+    filter: &FilteredParams,
+    block_hash: H256,
+    block_number: u64,
+    tx_and_receipts: I,
+) -> Vec<Log>
+where
+    I: IntoIterator<Item = (TxHash, Receipt)>,
+{
+    let mut all_logs = Vec::new();
+    append_matching_block_logs(&mut all_logs, filter, block_hash, block_number, tx_and_receipts);
+    all_logs
+}
+
+/// Appends all matching logs of a block's receipts grouped with the hash of their transaction
+pub(crate) fn append_matching_block_logs<I>(
+    all_logs: &mut Vec<Log>,
+    filter: &FilteredParams,
+    block_hash: H256,
+    block_number: u64,
+    tx_and_receipts: I,
+) where
+    I: IntoIterator<Item = (TxHash, Receipt)>,
+{
+    let block_number_u256 = U256::from(block_number);
+    // tracks the index of a log in the entire block
+    let mut log_index: u32 = 0;
+    for (transaction_idx, (transaction_hash, receipt)) in tx_and_receipts.into_iter().enumerate() {
+        let logs = receipt.logs;
+        for (transaction_log_idx, log) in logs.into_iter().enumerate() {
+            if log_matches_filter(block_hash, block_number, &log, filter) {
+                let log = Log {
+                    address: log.address,
+                    topics: log.topics,
+                    data: log.data,
+                    block_hash: Some(block_hash),
+                    block_number: Some(block_number_u256),
+                    transaction_hash: Some(transaction_hash),
+                    transaction_index: Some(U256::from(transaction_idx)),
+                    log_index: Some(U256::from(log_index)),
+                    transaction_log_index: Some(U256::from(transaction_log_idx)),
+                    removed: false,
+                };
+                all_logs.push(log);
+            }
+            log_index += 1;
+        }
+    }
+}
+
+/// Returns true if the log matches the filter and should be included
+pub(crate) fn log_matches_filter(
+    block_hash: H256,
+    block_number: u64,
+    log: &reth_primitives::Log,
+    params: &FilteredParams,
+) -> bool {
+    if params.filter.is_some() &&
+        (!params.filter_block_range(block_number) ||
+            !params.filter_block_hash(block_hash) ||
+            !params.filter_address(log) ||
+            !params.filter_topics(log))
+    {
+        return false
+    }
+    true
+}
diff --git a/crates/rpc/rpc/src/eth/mod.rs b/crates/rpc/rpc/src/eth/mod.rs
index 598e3721a36..6958b1238d5 100644
--- a/crates/rpc/rpc/src/eth/mod.rs
+++ b/crates/rpc/rpc/src/eth/mod.rs
@@ -1,11 +1,16 @@
 //! `eth` namespace handler implementation.
 
 mod api;
-pub(crate) mod error;
+pub mod cache;
+pub mod error;
 mod filter;
+mod id_provider;
+mod logs_utils;
 mod pubsub;
+pub(crate) mod revm_utils;
 mod signer;
 
-pub use api::{EthApi, EthApiSpec};
+pub use api::{EthApi, EthApiSpec, EthTransactions, TransactionSource};
 pub use filter::EthFilter;
+pub use id_provider::EthSubscriptionIdProvider;
 pub use pubsub::EthPubSub;
diff --git a/crates/rpc/rpc/src/eth/pubsub.rs b/crates/rpc/rpc/src/eth/pubsub.rs
index e4a9a5f145c..ff35b78ba93 100644
--- a/crates/rpc/rpc/src/eth/pubsub.rs
+++ b/crates/rpc/rpc/src/eth/pubsub.rs
@@ -1,39 +1,45 @@
 //! `eth_` PubSub RPC handler implementation
 
+use crate::eth::logs_utils;
+use futures::StreamExt;
 use jsonrpsee::{types::SubscriptionResult, SubscriptionSink};
-use reth_interfaces::events::ChainEventSubscriptions;
-use reth_primitives::{rpc::FilteredParams, TxHash};
+use reth_interfaces::{events::ChainEventSubscriptions, sync::SyncStateProvider};
+use reth_primitives::{filter::FilteredParams, BlockId, TxHash};
 use reth_provider::{BlockProvider, EvmEnvProvider};
 use reth_rpc_api::EthPubSubApiServer;
 use reth_rpc_types::{
-    pubsub::{Params, SubscriptionKind, SubscriptionResult as EthSubscriptionResult},
-    Header,
+    pubsub::{
+        Params, PubSubSyncStatus, SubscriptionKind, SubscriptionResult as EthSubscriptionResult,
+        SyncStatusMetadata,
+    },
+    Header, Log,
 };
 use reth_tasks::{TaskSpawner, TokioTaskExecutor};
 use reth_transaction_pool::TransactionPool;
 use tokio_stream::{
     wrappers::{ReceiverStream, UnboundedReceiverStream},
-    Stream, StreamExt,
+    Stream,
 };
 
 /// `Eth` pubsub RPC implementation.
 ///
-/// This handles
-pub struct EthPubSub<Client, Pool, Events> {
+/// This handles `eth_subscribe` RPC calls.
+#[derive(Clone)]
+pub struct EthPubSub<Client, Pool, Events, Network> {
     /// All nested fields bundled together.
-    inner: EthPubSubInner<Client, Pool, Events>,
+    inner: EthPubSubInner<Client, Pool, Events, Network>,
     /// The type that's used to spawn subscription tasks.
     subscription_task_spawner: Box<dyn TaskSpawner>,
 }
 
 // === impl EthPubSub ===
 
-impl<Client, Pool, Events> EthPubSub<Client, Pool, Events> {
+impl<Client, Pool, Events, Network> EthPubSub<Client, Pool, Events, Network> {
     /// Creates a new, shareable instance.
     ///
     /// Subscription tasks are spawned via [tokio::task::spawn]
-    pub fn new(client: Client, pool: Pool, chain_events: Events) -> Self {
-        Self::with_spawner(client, pool, chain_events, Box::<TokioTaskExecutor>::default())
+    pub fn new(client: Client, pool: Pool, chain_events: Events, network: Network) -> Self {
+        Self::with_spawner(client, pool, chain_events, network, Box::<TokioTaskExecutor>::default())
     }
 
     /// Creates a new, shareable instance.
@@ -41,19 +47,22 @@ impl<Client, Pool, Events> EthPubSub<Client, Pool, Events> {
         client: Client,
         pool: Pool,
         chain_events: Events,
+        network: Network,
         subscription_task_spawner: Box<dyn TaskSpawner>,
     ) -> Self {
-        let inner = EthPubSubInner { client, pool, chain_events };
+        let inner = EthPubSubInner { client, pool, chain_events, network };
         Self { inner, subscription_task_spawner }
     }
 }
 
-impl<Client, Pool, Events> EthPubSubApiServer for EthPubSub<Client, Pool, Events>
+impl<Client, Pool, Events, Network> EthPubSubApiServer for EthPubSub<Client, Pool, Events, Network>
 where
     Client: BlockProvider + EvmEnvProvider + Clone + 'static,
     Pool: TransactionPool + 'static,
     Events: ChainEventSubscriptions + Clone + 'static,
+    Network: SyncStateProvider + Clone + 'static,
 {
+    /// Handler for `eth_subscribe`
     fn subscribe(
         &self,
         mut sink: SubscriptionSink,
@@ -64,7 +73,7 @@ where
 
         let pubsub = self.inner.clone();
         self.subscription_task_spawner.spawn(Box::pin(async move {
-            handle_accepted(pubsub, sink, kind, params).await;
+            handle_accepted(pubsub, sink, kind, params, Box::<TokioTaskExecutor>::default()).await;
         }));
 
         Ok(())
@@ -72,22 +81,18 @@ where
 }
 
 /// The actual handler for and accepted [`EthPubSub::subscribe`] call.
-async fn handle_accepted<Client, Pool, Events>(
-    pubsub: EthPubSubInner<Client, Pool, Events>,
+async fn handle_accepted<Client, Pool, Events, Network>(
+    pubsub: EthPubSubInner<Client, Pool, Events, Network>,
     mut accepted_sink: SubscriptionSink,
     kind: SubscriptionKind,
     params: Option<Params>,
+    subscription_task_spawner: Box<dyn TaskSpawner>,
 ) where
-    Client: BlockProvider + EvmEnvProvider + 'static,
+    Client: BlockProvider + EvmEnvProvider + Clone + 'static,
     Pool: TransactionPool + 'static,
-    Events: ChainEventSubscriptions + 'static,
+    Events: ChainEventSubscriptions + Clone + 'static,
+    Network: SyncStateProvider + Clone + 'static,
 {
-    // if no params are provided, used default filter params
-    let _params = match params {
-        Some(Params::Logs(filter)) => FilteredParams::new(Some(*filter)),
-        _ => FilteredParams::default(),
-    };
-
     match kind {
         SubscriptionKind::NewHeads => {
             let stream = pubsub
@@ -96,7 +101,14 @@ async fn handle_accepted<Client, Pool, Events>(
             accepted_sink.pipe_from_stream(stream).await;
         }
         SubscriptionKind::Logs => {
-            // TODO subscribe new blocks -> fetch logs via bloom
+            // if no params are provided, used default filter params
+            let filter = match params {
+                Some(Params::Logs(filter)) => FilteredParams::new(Some(*filter)),
+                _ => FilteredParams::default(),
+            };
+            let stream =
+                pubsub.into_log_stream(filter).map(|log| EthSubscriptionResult::Log(Box::new(log)));
+            accepted_sink.pipe_from_stream(stream).await;
         }
         SubscriptionKind::NewPendingTransactions => {
             let stream = pubsub
@@ -105,12 +117,35 @@ async fn handle_accepted<Client, Pool, Events>(
             accepted_sink.pipe_from_stream(stream).await;
         }
         SubscriptionKind::Syncing => {
-            // TODO subscribe new blocks -> read is_syncing from network
+            subscription_task_spawner.spawn(Box::pin(async move {
+                // get new block subscription
+                let mut new_blocks =
+                    UnboundedReceiverStream::new(pubsub.chain_events.subscribe_new_blocks());
+                // get current sync status
+                let mut initial_sync_status = pubsub.network.is_syncing();
+                let current_sub_res = pubsub.sync_status(initial_sync_status).await;
+
+                // send the current status immediately
+                let _ = accepted_sink.send(&current_sub_res);
+
+                while (new_blocks.next().await).is_some() {
+                    let current_syncing = pubsub.network.is_syncing();
+                    // Only send a new response if the sync status has changed
+                    if current_syncing != initial_sync_status {
+                        // Update the sync status on each new block
+                        initial_sync_status = current_syncing;
+
+                        // send a new message now that the status changed
+                        let sync_status = pubsub.sync_status(current_syncing).await;
+                        let _ = accepted_sink.send(&sync_status);
+                    }
+                }
+            }));
         }
     }
 }
 
-impl<Client, Pool, Events> std::fmt::Debug for EthPubSub<Client, Pool, Events> {
+impl<Client, Pool, Events, Network> std::fmt::Debug for EthPubSub<Client, Pool, Events, Network> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("EthPubSub").finish_non_exhaustive()
     }
@@ -118,18 +153,41 @@ impl<Client, Pool, Events> std::fmt::Debug for EthPubSub<Client, Pool, Events> {
 
 /// Container type `EthPubSub`
 #[derive(Clone)]
-struct EthPubSubInner<Client, Pool, Events> {
+struct EthPubSubInner<Client, Pool, Events, Network> {
     /// The transaction pool.
     pool: Pool,
     /// The client that can interact with the chain.
     client: Client,
     /// A type that allows to create new event subscriptions,
     chain_events: Events,
+    /// The network.
+    network: Network,
 }
 
 // == impl EthPubSubInner ===
 
-impl<Client, Pool, Events> EthPubSubInner<Client, Pool, Events>
+impl<Client, Pool, Events, Network> EthPubSubInner<Client, Pool, Events, Network>
+where
+    Client: BlockProvider + 'static,
+{
+    /// Returns the current sync status for the `syncing` subscription
+    async fn sync_status(&self, is_syncing: bool) -> EthSubscriptionResult {
+        let current_block =
+            self.client.chain_info().map(|info| info.best_number).unwrap_or_default();
+        if is_syncing {
+            EthSubscriptionResult::SyncState(PubSubSyncStatus::Detailed(SyncStatusMetadata {
+                syncing: true,
+                starting_block: 0,
+                current_block,
+                highest_block: Some(current_block),
+            }))
+        } else {
+            EthSubscriptionResult::SyncState(PubSubSyncStatus::Simple(false))
+        }
+    }
+}
+
+impl<Client, Pool, Events, Network> EthPubSubInner<Client, Pool, Events, Network>
 where
     Pool: TransactionPool + 'static,
 {
@@ -139,10 +197,11 @@ where
     }
 }
 
-impl<Client, Pool, Events> EthPubSubInner<Client, Pool, Events>
+impl<Client, Pool, Events, Network> EthPubSubInner<Client, Pool, Events, Network>
 where
     Client: BlockProvider + EvmEnvProvider + 'static,
     Events: ChainEventSubscriptions + 'static,
+    Network: SyncStateProvider + 'static,
 {
     /// Returns a stream that yields all new RPC blocks.
     fn into_new_headers_stream(self) -> impl Stream<Item = Header> {
@@ -150,4 +209,31 @@ where
             Header::from_primitive_with_hash(new_block.header.as_ref().clone(), new_block.hash)
         })
     }
+
+    /// Returns a stream that yields all logs that match the given filter.
+    fn into_log_stream(self, filter: FilteredParams) -> impl Stream<Item = Log> {
+        UnboundedReceiverStream::new(self.chain_events.subscribe_new_blocks())
+            .filter_map(move |new_block| {
+                let block_id: BlockId = new_block.hash.into();
+                let txs = self.client.transactions_by_block(block_id).ok().flatten();
+                let receipts = self.client.receipts_by_block(block_id).ok().flatten();
+                match (txs, receipts) {
+                    (Some(txs), Some(receipts)) => {
+                        futures::future::ready(Some((new_block, txs, receipts)))
+                    }
+                    _ => futures::future::ready(None),
+                }
+            })
+            .flat_map(move |(new_block, transactions, receipts)| {
+                let block_hash = new_block.hash;
+                let block_number = new_block.header.number;
+                let all_logs = logs_utils::matching_block_logs(
+                    &filter,
+                    block_hash,
+                    block_number,
+                    transactions.into_iter().map(|tx| tx.hash).zip(receipts),
+                );
+                futures::stream::iter(all_logs)
+            })
+    }
 }
diff --git a/crates/rpc/rpc/src/eth/revm_utils.rs b/crates/rpc/rpc/src/eth/revm_utils.rs
new file mode 100644
index 00000000000..09fcb6c6da5
--- /dev/null
+++ b/crates/rpc/rpc/src/eth/revm_utils.rs
@@ -0,0 +1,179 @@
+//! utilities for working with revm
+
+use crate::eth::error::{EthApiError, EthResult, InvalidTransactionError};
+use reth_primitives::{AccessList, Address, U256};
+use reth_rpc_types::CallRequest;
+use revm::{
+    precompile::{Precompiles, SpecId as PrecompilesSpecId},
+    primitives::{BlockEnv, CfgEnv, Env, ResultAndState, SpecId, TransactTo, TxEnv},
+    Database, Inspector,
+};
+
+/// Returns the addresses of the precompiles corresponding to the SpecId.
+pub(crate) fn get_precompiles(spec_id: &SpecId) -> Vec<reth_primitives::H160> {
+    let spec = match spec_id {
+        SpecId::FRONTIER | SpecId::FRONTIER_THAWING => return vec![],
+        SpecId::HOMESTEAD | SpecId::DAO_FORK | SpecId::TANGERINE | SpecId::SPURIOUS_DRAGON => {
+            PrecompilesSpecId::HOMESTEAD
+        }
+        SpecId::BYZANTIUM | SpecId::CONSTANTINOPLE | SpecId::PETERSBURG => {
+            PrecompilesSpecId::BYZANTIUM
+        }
+        SpecId::ISTANBUL | SpecId::MUIR_GLACIER => PrecompilesSpecId::ISTANBUL,
+        SpecId::BERLIN |
+        SpecId::LONDON |
+        SpecId::ARROW_GLACIER |
+        SpecId::GRAY_GLACIER |
+        SpecId::MERGE |
+        SpecId::SHANGHAI |
+        SpecId::CANCUN => PrecompilesSpecId::BERLIN,
+        SpecId::LATEST => PrecompilesSpecId::LATEST,
+    };
+    Precompiles::new(spec).addresses().into_iter().map(Address::from).collect()
+}
+
+/// Executes the [Env] against the given [Database] without committing state changes.
+pub(crate) fn transact<S>(db: S, env: Env) -> EthResult<(ResultAndState, Env)>
+where
+    S: Database,
+    <S as Database>::Error: Into<EthApiError>,
+{
+    let mut evm = revm::EVM::with_env(env);
+    evm.database(db);
+    let res = evm.transact()?;
+    Ok((res, evm.env))
+}
+
+/// Executes the [Env] against the given [Database] without committing state changes.
+pub(crate) fn inspect<S, I>(db: S, env: Env, inspector: I) -> EthResult<(ResultAndState, Env)>
+where
+    S: Database,
+    <S as Database>::Error: Into<EthApiError>,
+    I: Inspector<S>,
+{
+    let mut evm = revm::EVM::with_env(env);
+    evm.database(db);
+    let res = evm.inspect(inspector)?;
+    Ok((res, evm.env))
+}
+
+/// Creates a new [Env] to be used for executing the [CallRequest] in `eth_call`
+pub(crate) fn build_call_evm_env(
+    cfg: CfgEnv,
+    block: BlockEnv,
+    request: CallRequest,
+) -> EthResult<Env> {
+    let tx = create_txn_env(&block, request)?;
+    Ok(Env { cfg, block, tx })
+}
+
+/// Configures a new [TxEnv]  for the [CallRequest]
+pub(crate) fn create_txn_env(block_env: &BlockEnv, request: CallRequest) -> EthResult<TxEnv> {
+    let CallRequest {
+        from,
+        to,
+        gas_price,
+        max_fee_per_gas,
+        max_priority_fee_per_gas,
+        gas,
+        value,
+        data,
+        nonce,
+        access_list,
+        chain_id,
+    } = request;
+
+    let CallFees { max_priority_fee_per_gas, gas_price } = CallFees::ensure_fees(
+        gas_price,
+        max_fee_per_gas,
+        max_priority_fee_per_gas,
+        block_env.basefee,
+    )?;
+
+    let gas_limit = gas.unwrap_or(block_env.gas_limit.min(U256::from(u64::MAX)));
+
+    let env = TxEnv {
+        gas_limit: gas_limit.try_into().map_err(|_| InvalidTransactionError::GasUintOverflow)?,
+        nonce: nonce
+            .map(|n| n.try_into().map_err(|_| InvalidTransactionError::NonceTooHigh))
+            .transpose()?,
+        caller: from.unwrap_or_default(),
+        gas_price,
+        gas_priority_fee: max_priority_fee_per_gas,
+        transact_to: to.map(TransactTo::Call).unwrap_or_else(TransactTo::create),
+        value: value.unwrap_or_default(),
+        data: data.map(|data| data.0).unwrap_or_default(),
+        chain_id: chain_id.map(|c| c.as_u64()),
+        access_list: access_list.map(AccessList::flattened).unwrap_or_default(),
+    };
+
+    Ok(env)
+}
+
+/// Helper type for representing the fees of a [CallRequest]
+pub(crate) struct CallFees {
+    /// EIP-1559 priority fee
+    max_priority_fee_per_gas: Option<U256>,
+    /// Unified gas price setting
+    ///
+    /// Will be the configured `basefee` if unset in the request
+    ///
+    /// `gasPrice` for legacy,
+    /// `maxFeePerGas` for EIP-1559
+    gas_price: U256,
+}
+
+// === impl CallFees ===
+
+impl CallFees {
+    /// Ensures the fields of a [CallRequest] are not conflicting.
+    ///
+    /// If no `gasPrice` or `maxFeePerGas` is set, then the `gas_price` in the response will
+    /// fallback to the given `basefee`.
+    fn ensure_fees(
+        call_gas_price: Option<U256>,
+        call_max_fee: Option<U256>,
+        call_priority_fee: Option<U256>,
+        base_fee: U256,
+    ) -> EthResult<CallFees> {
+        match (call_gas_price, call_max_fee, call_priority_fee) {
+            (gas_price, None, None) => {
+                // request for a legacy transaction
+                // set everything to zero
+                let gas_price = gas_price.unwrap_or(base_fee);
+                Ok(CallFees { gas_price, max_priority_fee_per_gas: None })
+            }
+            (None, max_fee_per_gas, max_priority_fee_per_gas) => {
+                // request for eip-1559 transaction
+                let max_fee = max_fee_per_gas.unwrap_or(base_fee);
+
+                if let Some(max_priority) = max_priority_fee_per_gas {
+                    if max_priority > max_fee {
+                        // Fail early
+                        return Err(
+                            // `max_priority_fee_per_gas` is greater than the `max_fee_per_gas`
+                            InvalidTransactionError::TipAboveFeeCap.into(),
+                        )
+                    }
+                }
+                Ok(CallFees { gas_price: max_fee, max_priority_fee_per_gas })
+            }
+            (Some(gas_price), Some(max_fee_per_gas), Some(max_priority_fee_per_gas)) => {
+                Err(EthApiError::ConflictingRequestGasPriceAndTipSet {
+                    gas_price,
+                    max_fee_per_gas,
+                    max_priority_fee_per_gas,
+                })
+            }
+            (Some(gas_price), Some(max_fee_per_gas), None) => {
+                Err(EthApiError::ConflictingRequestGasPrice { gas_price, max_fee_per_gas })
+            }
+            (Some(gas_price), None, Some(max_priority_fee_per_gas)) => {
+                Err(EthApiError::RequestLegacyGasPriceAndTipSet {
+                    gas_price,
+                    max_priority_fee_per_gas,
+                })
+            }
+        }
+    }
+}
diff --git a/crates/rpc/rpc/src/eth/signer.rs b/crates/rpc/rpc/src/eth/signer.rs
index 2c16e748660..90a2bb4deec 100644
--- a/crates/rpc/rpc/src/eth/signer.rs
+++ b/crates/rpc/rpc/src/eth/signer.rs
@@ -1,11 +1,17 @@
 //! An abstraction over ethereum signers.
 
-use jsonrpsee::core::RpcResult as Result;
-use reth_primitives::{Address, Signature, TransactionSigned};
+use crate::eth::error::SignError;
+use ethers_core::{
+    types::transaction::eip712::{Eip712, TypedData},
+    utils::hash_message,
+};
+use reth_primitives::{sign_message, Address, Signature, TransactionSigned, H256};
 use reth_rpc_types::TypedTransactionRequest;
 use secp256k1::SecretKey;
 use std::collections::HashMap;
 
+type Result<T> = std::result::Result<T, SignError>;
+
 /// An Ethereum Signer used via RPC.
 #[async_trait::async_trait]
 pub(crate) trait EthSigner: Send + Sync {
@@ -26,6 +32,9 @@ pub(crate) trait EthSigner: Send + Sync {
         request: TypedTransactionRequest,
         address: &Address,
     ) -> Result<TransactionSigned>;
+
+    /// Encodes and signs the typed data according EIP-712. Payload must implement Eip712 trait.
+    fn sign_typed_data(&self, address: Address, payload: &TypedData) -> Result<Signature>;
 }
 
 /// Holds developer keys
@@ -34,6 +43,16 @@ pub(crate) struct DevSigner {
     accounts: HashMap<Address, SecretKey>,
 }
 
+impl DevSigner {
+    fn get_key(&self, account: Address) -> Result<&SecretKey> {
+        self.accounts.get(&account).ok_or(SignError::NoAccount)
+    }
+    fn sign_hash(&self, hash: H256, account: Address) -> Result<Signature> {
+        let secret = self.get_key(account)?;
+        let signature = sign_message(H256::from_slice(secret.as_ref()), hash);
+        signature.map_err(|_| SignError::CouldNotSign)
+    }
+}
 #[async_trait::async_trait]
 impl EthSigner for DevSigner {
     fn accounts(&self) -> Vec<Address> {
@@ -44,8 +63,11 @@ impl EthSigner for DevSigner {
         self.accounts.contains_key(addr)
     }
 
-    async fn sign(&self, _address: Address, _message: &[u8]) -> Result<Signature> {
-        todo!()
+    async fn sign(&self, address: Address, message: &[u8]) -> Result<Signature> {
+        // Hash message according to EIP 191:
+        // https://ethereum.org/es/developers/docs/apis/json-rpc/#eth_sign
+        let hash = hash_message(message).into();
+        self.sign_hash(hash, address)
     }
 
     fn sign_transaction(
@@ -55,4 +77,131 @@ impl EthSigner for DevSigner {
     ) -> Result<TransactionSigned> {
         todo!()
     }
+
+    fn sign_typed_data(&self, address: Address, payload: &TypedData) -> Result<Signature> {
+        let encoded: H256 = payload.encode_eip712().map_err(|_| SignError::TypedData)?.into();
+        self.sign_hash(encoded, address)
+    }
+}
+#[cfg(test)]
+mod test {
+    use super::*;
+    use reth_primitives::U256;
+    use std::str::FromStr;
+    fn build_signer() -> DevSigner {
+        let addresses = vec![];
+        let secret =
+            SecretKey::from_str("4646464646464646464646464646464646464646464646464646464646464646")
+                .unwrap();
+        let accounts = HashMap::from([(Address::default(), secret)]);
+        DevSigner { addresses, accounts }
+    }
+
+    #[tokio::test]
+    async fn test_sign_type_data() {
+        let eip_712_example = serde_json::json!(
+            r#"{
+            "types": {
+            "EIP712Domain": [
+                {
+                    "name": "name",
+                    "type": "string"
+                },
+                {
+                    "name": "version",
+                    "type": "string"
+                },
+                {
+                    "name": "chainId",
+                    "type": "uint256"
+                },
+                {
+                    "name": "verifyingContract",
+                    "type": "address"
+                }
+            ],
+            "Person": [
+                {
+                    "name": "name",
+                    "type": "string"
+                },
+                {
+                    "name": "wallet",
+                    "type": "address"
+                }
+            ],
+            "Mail": [
+                {
+                    "name": "from",
+                    "type": "Person"
+                },
+                {
+                    "name": "to",
+                    "type": "Person"
+                },
+                {
+                    "name": "contents",
+                    "type": "string"
+                }
+            ]
+        },
+        "primaryType": "Mail",
+        "domain": {
+            "name": "Ether Mail",
+            "version": "1",
+            "chainId": 1,
+            "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
+        },
+        "message": {
+            "from": {
+                "name": "Cow",
+                "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
+            },
+            "to": {
+                "name": "Bob",
+                "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
+            },
+            "contents": "Hello, Bob!"
+        }
+        }"#
+        );
+        let data: TypedData = serde_json::from_value(eip_712_example).unwrap();
+        let signer = build_signer();
+        let sig = signer.sign_typed_data(Address::default(), &data).unwrap();
+        let expected = Signature {
+            r: U256::from_str_radix(
+                "5318aee9942b84885761bb20e768372b76e7ee454fc4d39b59ce07338d15a06c",
+                16,
+            )
+            .unwrap(),
+            s: U256::from_str_radix(
+                "5e585a2f4882ec3228a9303244798b47a9102e4be72f48159d890c73e4511d79",
+                16,
+            )
+            .unwrap(),
+            odd_y_parity: false,
+        };
+        assert_eq!(sig, expected)
+    }
+
+    #[tokio::test]
+    async fn test_signer() {
+        let message = b"Test message";
+        let signer = build_signer();
+        let sig = signer.sign(Address::default(), message).await.unwrap();
+        let expected = Signature {
+            r: U256::from_str_radix(
+                "54313da7432e4058b8d22491b2e7dbb19c7186c35c24155bec0820a8a2bfe0c1",
+                16,
+            )
+            .unwrap(),
+            s: U256::from_str_radix(
+                "687250f11a3d4435004c04a4cb60e846bc27997271d67f21c6c8170f17a25e10",
+                16,
+            )
+            .unwrap(),
+            odd_y_parity: true,
+        };
+        assert_eq!(sig, expected)
+    }
 }
diff --git a/crates/rpc/rpc/src/layers/auth_layer.rs b/crates/rpc/rpc/src/layers/auth_layer.rs
index c71c8f99ddb..537bdd33f5a 100644
--- a/crates/rpc/rpc/src/layers/auth_layer.rs
+++ b/crates/rpc/rpc/src/layers/auth_layer.rs
@@ -191,7 +191,7 @@ mod tests {
     }
 
     async fn valid_jwt() {
-        let claims = Claims { iat: to_u64(SystemTime::now()), exp: 10000000000 };
+        let claims = Claims { iat: to_u64(SystemTime::now()), exp: Some(10000000000) };
         let secret = JwtSecret::from_hex(SECRET).unwrap(); // Same secret as the server
         let jwt = secret.encode(&claims).unwrap();
         let (status, _) = send_request(Some(jwt)).await;
@@ -209,7 +209,7 @@ mod tests {
         // This secret is different from the server. This will generate a
         // different signature
         let secret = JwtSecret::random();
-        let claims = Claims { iat: to_u64(SystemTime::now()), exp: 10000000000 };
+        let claims = Claims { iat: to_u64(SystemTime::now()), exp: Some(10000000000) };
         let jwt = secret.encode(&claims).unwrap();
 
         let (status, body) = send_request(Some(jwt)).await;
@@ -222,7 +222,7 @@ mod tests {
         let secret = JwtSecret::from_hex(SECRET).unwrap(); // Same secret as the server
 
         let iat = to_u64(SystemTime::now()) + 1000;
-        let claims = Claims { iat, exp: 10000000000 };
+        let claims = Claims { iat, exp: Some(10000000000) };
         let jwt = secret.encode(&claims).unwrap();
 
         let (status, body) = send_request(Some(jwt)).await;
diff --git a/crates/rpc/rpc/src/layers/jwt_secret.rs b/crates/rpc/rpc/src/layers/jwt_secret.rs
index 9a349174831..bf757292c9b 100644
--- a/crates/rpc/rpc/src/layers/jwt_secret.rs
+++ b/crates/rpc/rpc/src/layers/jwt_secret.rs
@@ -58,8 +58,10 @@ impl JwtSecret {
     /// Returns an error if one of the following applies:
     /// - `hex` is not a valid hexadecimal string
     /// - `hex` argument length is less than `JWT_SECRET_LEN`
+    ///
+    /// This strips the leading `0x`, if any.
     pub fn from_hex<S: AsRef<str>>(hex: S) -> Result<Self, JwtError> {
-        let hex: &str = hex.as_ref().trim();
+        let hex: &str = hex.as_ref().trim().trim_start_matches("0x");
         if hex.len() != JWT_SECRET_LEN {
             Err(JwtError::InvalidLength(JWT_SECRET_LEN, hex.len()))
         } else {
@@ -109,7 +111,9 @@ impl JwtSecret {
     ///
     /// See also: [JWT Claims - Engine API specs](https://github.com/ethereum/execution-apis/blob/main/src/engine/authentication.md#jwt-claims)
     pub fn validate(&self, jwt: String) -> Result<(), JwtError> {
-        let validation = Validation::new(JWT_SIGNATURE_ALGO);
+        let mut validation = Validation::new(JWT_SIGNATURE_ALGO);
+        // ensure that the JWT has an `iat` claim
+        validation.set_required_spec_claims(&["iat"]);
         let bytes = &self.0;
 
         match decode::<Claims>(&jwt, &DecodingKey::from_secret(bytes), &validation) {
@@ -163,7 +167,7 @@ pub(crate) struct Claims {
     /// - [`RFC-7519 - Spec`](https://www.rfc-editor.org/rfc/rfc7519#section-4.1.6)
     /// - [`RFC-7519 - Notations`](https://www.rfc-editor.org/rfc/rfc7519#section-2)
     pub(crate) iat: u64,
-    pub(crate) exp: u64,
+    pub(crate) exp: Option<u64>,
 }
 
 impl Claims {
@@ -212,6 +216,14 @@ mod tests {
         assert_eq!(hex.len(), expected_len);
     }
 
+    #[test]
+    fn creation_ok_hex_string_with_0x() {
+        let hex: String =
+            "0x7365637265747365637265747365637265747365637265747365637265747365".into();
+        let result = JwtSecret::from_hex(hex);
+        assert!(matches!(result, Ok(_)));
+    }
+
     #[test]
     fn creation_error_wrong_len() {
         let hex = "f79ae8046";
@@ -229,7 +241,7 @@ mod tests {
     #[test]
     fn validation_ok() {
         let secret = JwtSecret::random();
-        let claims = Claims { iat: to_u64(SystemTime::now()), exp: 10000000000 };
+        let claims = Claims { iat: to_u64(SystemTime::now()), exp: Some(10000000000) };
         let jwt: String = secret.encode(&claims).unwrap();
 
         let result = secret.validate(jwt);
@@ -244,7 +256,7 @@ mod tests {
         // Check past 'iat' claim more than 60 secs
         let offset = Duration::from_secs(JWT_MAX_IAT_DIFF.as_secs() + 1);
         let out_of_window_time = SystemTime::now().checked_sub(offset).unwrap();
-        let claims = Claims { iat: to_u64(out_of_window_time), exp: 10000000000 };
+        let claims = Claims { iat: to_u64(out_of_window_time), exp: Some(10000000000) };
         let jwt: String = secret.encode(&claims).unwrap();
 
         let result = secret.validate(jwt);
@@ -254,7 +266,7 @@ mod tests {
         // Check future 'iat' claim more than 60 secs
         let offset = Duration::from_secs(JWT_MAX_IAT_DIFF.as_secs() + 1);
         let out_of_window_time = SystemTime::now().checked_add(offset).unwrap();
-        let claims = Claims { iat: to_u64(out_of_window_time), exp: 10000000000 };
+        let claims = Claims { iat: to_u64(out_of_window_time), exp: Some(10000000000) };
         let jwt: String = secret.encode(&claims).unwrap();
 
         let result = secret.validate(jwt);
@@ -265,7 +277,7 @@ mod tests {
     #[test]
     fn validation_error_wrong_signature() {
         let secret_1 = JwtSecret::random();
-        let claims = Claims { iat: to_u64(SystemTime::now()), exp: 10000000000 };
+        let claims = Claims { iat: to_u64(SystemTime::now()), exp: Some(10000000000) };
         let jwt: String = secret_1.encode(&claims).unwrap();
 
         // A different secret will generate a different signature.
@@ -282,13 +294,25 @@ mod tests {
         let key = EncodingKey::from_secret(bytes);
         let unsupported_algo = Header::new(Algorithm::HS384);
 
-        let claims = Claims { iat: to_u64(SystemTime::now()), exp: 10000000000 };
+        let claims = Claims { iat: to_u64(SystemTime::now()), exp: Some(10000000000) };
         let jwt: String = encode(&unsupported_algo, &claims, &key).unwrap();
         let result = secret.validate(jwt);
 
         assert!(matches!(result, Err(JwtError::UnsupportedSignatureAlgorithm)));
     }
 
+    #[test]
+    fn valid_without_exp_claim() {
+        let secret = JwtSecret::random();
+
+        let claims = Claims { iat: to_u64(SystemTime::now()), exp: None };
+        let jwt: String = secret.encode(&claims).unwrap();
+
+        let result = secret.validate(jwt);
+
+        assert!(matches!(result, Ok(())));
+    }
+
     #[test]
     fn ephemeral_secret_created() {
         let fpath: &Path = Path::new("secret0.hex");
diff --git a/crates/rpc/rpc/src/lib.rs b/crates/rpc/rpc/src/lib.rs
index 2281d828e69..53a37d4dfd2 100644
--- a/crates/rpc/rpc/src/lib.rs
+++ b/crates/rpc/rpc/src/lib.rs
@@ -14,7 +14,7 @@
 mod admin;
 mod debug;
 mod engine;
-mod eth;
+pub mod eth;
 mod layers;
 mod net;
 mod trace;
@@ -23,7 +23,7 @@ mod web3;
 pub use admin::AdminApi;
 pub use debug::DebugApi;
 pub use engine::EngineApi;
-pub use eth::{EthApi, EthApiSpec, EthFilter, EthPubSub};
+pub use eth::{EthApi, EthApiSpec, EthFilter, EthPubSub, EthSubscriptionIdProvider};
 pub use layers::{AuthLayer, AuthValidator, JwtAuthValidator, JwtError, JwtSecret};
 pub use net::NetApi;
 pub use trace::TraceApi;
diff --git a/crates/rpc/rpc/src/net.rs b/crates/rpc/rpc/src/net.rs
index c0e9e03861a..6f6ec7d38be 100644
--- a/crates/rpc/rpc/src/net.rs
+++ b/crates/rpc/rpc/src/net.rs
@@ -29,14 +29,17 @@ where
     Net: PeersInfo + 'static,
     Eth: EthApiSpec + 'static,
 {
+    /// Handler for `net_version`
     fn version(&self) -> Result<String> {
         Ok(self.eth.chain_id().to_string())
     }
 
+    /// Handler for `net_peerCount`
     fn peer_count(&self) -> Result<PeerCount> {
         Ok(PeerCount::Hex(self.network.num_connected_peers().into()))
     }
 
+    /// Handler for `net_listening`
     fn is_listening(&self) -> Result<bool> {
         Ok(true)
     }
diff --git a/crates/rpc/rpc/src/result.rs b/crates/rpc/rpc/src/result.rs
index 291e7762b53..7ca707ab074 100644
--- a/crates/rpc/rpc/src/result.rs
+++ b/crates/rpc/rpc/src/result.rs
@@ -69,10 +69,7 @@ macro_rules! impl_to_rpc_result {
                 F: FnOnce($err) -> M,
                 M: Into<String>,
             {
-                match self {
-                    Ok(t) => Ok(t),
-                    Err(err) => Err($crate::result::internal_rpc_err(op(err))),
-                }
+                self.map_err(|err| $crate::result::internal_rpc_err(op(err)))
             }
 
             #[inline]
@@ -122,15 +119,17 @@ impl ToRpcResultExt for RethResult<Option<Block>> {
 
     fn map_ok_or_rpc_err(self) -> RpcResult<<Self as ToRpcResultExt>::Ok> {
         match self {
-            Ok(block) => match block {
-                Some(value) => Ok(value),
-                None => Err(EthApiError::UnknownBlockNumber.into()),
-            },
+            Ok(block) => block.ok_or_else(|| EthApiError::UnknownBlockNumber.into()),
             Err(err) => Err(internal_rpc_err(err.to_string())),
         }
     }
 }
 
+/// Constructs an invalid params JSON-RPC error.
+pub(crate) fn invalid_params_rpc_err(msg: impl Into<String>) -> jsonrpsee::core::Error {
+    rpc_err(jsonrpsee::types::error::INVALID_PARAMS_CODE, msg, None)
+}
+
 /// Constructs an internal JSON-RPC error.
 pub(crate) fn internal_rpc_err(msg: impl Into<String>) -> jsonrpsee::core::Error {
     rpc_err(jsonrpsee::types::error::INTERNAL_ERROR_CODE, msg, None)
diff --git a/crates/rpc/rpc/src/trace.rs b/crates/rpc/rpc/src/trace.rs
index 962129fbd10..c1474d8c687 100644
--- a/crates/rpc/rpc/src/trace.rs
+++ b/crates/rpc/rpc/src/trace.rs
@@ -1,34 +1,106 @@
-use crate::result::internal_rpc_err;
+use crate::{
+    eth::{cache::EthStateCache, error::EthResult, revm_utils::inspect, EthTransactions},
+    result::internal_rpc_err,
+};
 use async_trait::async_trait;
 use jsonrpsee::core::RpcResult as Result;
 use reth_primitives::{BlockId, Bytes, H256};
+use reth_provider::{BlockProvider, EvmEnvProvider, StateProviderFactory};
+use reth_revm::{
+    database::{State, SubState},
+    env::tx_env_with_recovered,
+    tracing::{TracingInspector, TracingInspectorConfig},
+};
 use reth_rpc_api::TraceApiServer;
 use reth_rpc_types::{
     trace::{filter::TraceFilter, parity::*},
     CallRequest, Index,
 };
+use revm::primitives::Env;
 use std::collections::HashSet;
 
 /// `trace` API implementation.
 ///
 /// This type provides the functionality for handling `trace` related requests.
-#[non_exhaustive]
-pub struct TraceApi {}
+#[derive(Clone)]
+pub struct TraceApi<Client, Eth> {
+    /// The client that can interact with the chain.
+    client: Client,
+    /// Access to commonly used code of the `eth` namespace
+    eth_api: Eth,
+    /// The async cache frontend for eth related data
+    eth_cache: EthStateCache,
+}
 
 // === impl TraceApi ===
 
-impl TraceApi {
+impl<Client, Eth> TraceApi<Client, Eth> {
     /// Create a new instance of the [TraceApi]
-    #[allow(clippy::new_without_default)]
-    // TODO add necessary types
-    pub fn new() -> Self {
-        Self {}
+    pub fn new(client: Client, eth_api: Eth, eth_cache: EthStateCache) -> Self {
+        Self { client, eth_api, eth_cache }
+    }
+}
+
+// === impl TraceApi ===
+
+impl<Client, Eth> TraceApi<Client, Eth>
+where
+    Client: BlockProvider + StateProviderFactory + EvmEnvProvider + 'static,
+    Eth: EthTransactions + 'static,
+{
+    /// Returns transaction trace with the given address.
+    pub async fn trace_get(
+        &self,
+        hash: H256,
+        trace_address: Vec<usize>,
+    ) -> EthResult<Option<LocalizedTransactionTrace>> {
+        match self.trace_transaction(hash).await? {
+            None => Ok(None),
+            Some(traces) => {
+                let trace =
+                    traces.into_iter().find(|trace| trace.trace.trace_address == trace_address);
+                Ok(trace)
+            }
+        }
+    }
+
+    /// Returns all traces for the given transaction hash
+    pub async fn trace_transaction(
+        &self,
+        hash: H256,
+    ) -> EthResult<Option<Vec<LocalizedTransactionTrace>>> {
+        let (transaction, at) = match self.eth_api.transaction_by_hash_at(hash).await? {
+            None => return Ok(None),
+            Some(res) => res,
+        };
+
+        let (cfg, block, at) = self.eth_api.evm_env_at(at).await?;
+
+        let (tx, tx_info) = transaction.split();
+
+        self.eth_api.with_state_at(at, |state| {
+            let tx = tx_env_with_recovered(&tx);
+            let env = Env { cfg, block, tx };
+            let db = SubState::new(State::new(state));
+            let mut inspector = TracingInspector::new(TracingInspectorConfig::default_parity());
+
+            inspect(db, env, &mut inspector)?;
+
+            let traces = inspector.into_parity_builder().into_localized_transaction_traces(tx_info);
+
+            Ok(Some(traces))
+        })
     }
 }
 
 #[async_trait]
-impl TraceApiServer for TraceApi {
-    async fn call(
+impl<Client, Eth> TraceApiServer for TraceApi<Client, Eth>
+where
+    Client: BlockProvider + StateProviderFactory + EvmEnvProvider + 'static,
+    Eth: EthTransactions + 'static,
+{
+    /// Handler for `trace_call`
+    async fn trace_call(
         &self,
         _call: CallRequest,
         _trace_types: HashSet<TraceType>,
@@ -37,7 +109,8 @@ impl TraceApiServer for TraceApi {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    async fn call_many(
+    /// Handler for `trace_callMany`
+    async fn trace_call_many(
         &self,
         _calls: Vec<(CallRequest, HashSet<TraceType>)>,
         _block_id: Option<BlockId>,
@@ -45,7 +118,8 @@ impl TraceApiServer for TraceApi {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    async fn raw_transaction(
+    /// Handler for `trace_rawTransaction`
+    async fn trace_raw_transaction(
         &self,
         _data: Bytes,
         _trace_types: HashSet<TraceType>,
@@ -54,6 +128,7 @@ impl TraceApiServer for TraceApi {
         Err(internal_rpc_err("unimplemented"))
     }
 
+    /// Handler for `trace_replayBlockTransactions`
     async fn replay_block_transactions(
         &self,
         _block_id: BlockId,
@@ -62,6 +137,7 @@ impl TraceApiServer for TraceApi {
         Err(internal_rpc_err("unimplemented"))
     }
 
+    /// Handler for `trace_replayTransaction`
     async fn replay_transaction(
         &self,
         _transaction: H256,
@@ -70,28 +146,39 @@ impl TraceApiServer for TraceApi {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    async fn block(&self, _block_id: BlockId) -> Result<Option<Vec<LocalizedTransactionTrace>>> {
+    /// Handler for `trace_block`
+    async fn trace_block(
+        &self,
+        _block_id: BlockId,
+    ) -> Result<Option<Vec<LocalizedTransactionTrace>>> {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    async fn filter(&self, _filter: TraceFilter) -> Result<Vec<LocalizedTransactionTrace>> {
+    /// Handler for `trace_filter`
+    async fn trace_filter(&self, _filter: TraceFilter) -> Result<Vec<LocalizedTransactionTrace>> {
         Err(internal_rpc_err("unimplemented"))
     }
 
-    fn trace(
+    /// Returns transaction trace at given index.
+    /// Handler for `trace_get`
+    async fn trace_get(
         &self,
-        _hash: H256,
-        _indices: Vec<Index>,
+        hash: H256,
+        indices: Vec<Index>,
     ) -> Result<Option<LocalizedTransactionTrace>> {
-        Err(internal_rpc_err("unimplemented"))
+        Ok(TraceApi::trace_get(self, hash, indices.into_iter().map(Into::into).collect()).await?)
     }
 
-    fn transaction_traces(&self, _hash: H256) -> Result<Option<Vec<LocalizedTransactionTrace>>> {
-        Err(internal_rpc_err("unimplemented"))
+    /// Handler for `trace_transaction`
+    async fn trace_transaction(
+        &self,
+        hash: H256,
+    ) -> Result<Option<Vec<LocalizedTransactionTrace>>> {
+        Ok(TraceApi::trace_transaction(self, hash).await?)
     }
 }
 
-impl std::fmt::Debug for TraceApi {
+impl<Client, Eth> std::fmt::Debug for TraceApi<Client, Eth> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("TraceApi").finish_non_exhaustive()
     }
diff --git a/crates/rpc/rpc/src/web3.rs b/crates/rpc/rpc/src/web3.rs
index e5476f5bcd1..e3b600f945c 100644
--- a/crates/rpc/rpc/src/web3.rs
+++ b/crates/rpc/rpc/src/web3.rs
@@ -25,11 +25,13 @@ impl<N> Web3ApiServer for Web3Api<N>
 where
     N: NetworkInfo + 'static,
 {
+    /// Handler for `web3_clientVersion`
     async fn client_version(&self) -> RpcResult<String> {
         let status = self.network.network_status().await.to_rpc_result()?;
         Ok(status.client_version)
     }
 
+    /// Handler for `web3_sha3`
     fn sha3(&self, input: Bytes) -> RpcResult<H256> {
         Ok(keccak256(input))
     }
diff --git a/crates/staged-sync/Cargo.toml b/crates/staged-sync/Cargo.toml
index dc440eaa634..d81750ff669 100644
--- a/crates/staged-sync/Cargo.toml
+++ b/crates/staged-sync/Cargo.toml
@@ -7,12 +7,6 @@ repository = "https://github.com/paradigmxyz/reth"
 readme = "README.md"
 description = "Puts together all the Reth stages in a unified abstraction"
 
-[package.metadata.cargo-udeps.ignore]
-normal = [
-    # Used for config loading
-    "confy"
-]
-
 [dependencies]
 # reth
 reth-db = {path = "../../crates/storage/db", features = ["mdbx", "test-utils"] }
@@ -23,13 +17,10 @@ reth-downloaders = { path = "../../crates/net/downloaders" }
 reth-primitives = { path = "../../crates/primitives" }
 reth-provider = { path = "../../crates/storage/provider", features = ["test-utils"] }
 reth-net-nat = { path = "../../crates/net/nat" }
-reth-interfaces = { path = "../interfaces", optional = true }
-reth-tasks = { path = "../../crates/tasks" }
 
 # io
 serde = "1.0"
 serde_json = "1.0.91"
-confy = "0.5"
 
 # misc
 walkdir = "2.3.2"
@@ -41,10 +32,10 @@ tracing = "0.1.37"
 rand = { version = "0.8", optional = true }
 
 # errors
-thiserror = { version = "1", optional = true }
+thiserror = "1"
 
 # enr
-enr = { version = "0.7.0", features = ["serde", "rust-secp256k1"], optional = true }
+enr = { version = "0.8.0", features = ["serde", "rust-secp256k1"], optional = true }
 
 # ethers
 ethers-core = { git = "https://github.com/gakonst/ethers-rs", default-features = false, optional = true }
@@ -55,45 +46,40 @@ ethers-signers = { git = "https://github.com/gakonst/ethers-rs", default-feature
 # async / futures
 async-trait = { version = "0.1", optional = true }
 tokio = { version = "1", features = ["io-util", "net", "macros", "rt-multi-thread", "time"], optional = true }
-tokio-test = { version = "0.4", optional = true }
 
 # misc
-tempfile = { version = "3.3", optional = true }
 hex = { version = "0.4", optional = true }
 
 [dev-dependencies]
 # reth crates
 reth-tracing = { path = "../tracing" }
-reth-stages = { path = "../stages" }
 reth-downloaders = { path = "../net/downloaders" }
-reth-staged-sync = { path = ".", features = ["test-utils"] }
 
 # async/futures
 futures = "0.3"
 tokio = { version = "1", features = ["io-util", "net", "macros", "rt-multi-thread", "time"] }
-tokio-stream = "0.1"
 
 # crypto
-secp256k1 = { version = "0.24", features = [
+secp256k1 = { version = "0.26.0", features = [
     "global-context",
     "rand-std",
     "recovery",
 ] }
 
+confy = "0.5"
+
+tempfile = "3.4"
+
 [features]
 test-utils = [
     "reth-network/test-utils",
-    "reth-interfaces/test-utils",
     "reth-network/test-utils",
     "reth-provider/test-utils",
     "dep:enr",
     "dep:ethers-core",
-    "dep:tempfile",
-    "dep:thiserror",
     "dep:hex",
     "dep:rand",
     "dep:tokio",
-    "dep:tokio-test",
     "dep:ethers-signers",
     "dep:ethers-providers",
     "dep:ethers-middleware",
diff --git a/crates/staged-sync/src/lib.rs b/crates/staged-sync/src/lib.rs
index 781199fb5e6..a0ea405be98 100644
--- a/crates/staged-sync/src/lib.rs
+++ b/crates/staged-sync/src/lib.rs
@@ -1,3 +1,12 @@
+#![warn(missing_docs, unreachable_pub)]
+#![deny(unused_must_use, rust_2018_idioms)]
+#![doc(test(
+    no_crate_inject,
+    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
+))]
+
+//! Puts together all the Reth stages in a unified abstraction
+
 pub mod config;
 pub use config::Config;
 
diff --git a/crates/staged-sync/src/test_utils/clique.rs b/crates/staged-sync/src/test_utils/clique.rs
index 8a75e600982..c053d8ee03a 100644
--- a/crates/staged-sync/src/test_utils/clique.rs
+++ b/crates/staged-sync/src/test_utils/clique.rs
@@ -20,7 +20,7 @@ use std::{
 /// ```no_run
 /// # use ethers_core::utils::Geth;
 /// # use reth_staged_sync::test_utils::CliqueGethInstance;
-/// # tokio_test::block_on(async {
+/// # let clique = async {
 ///
 /// // this creates a funded geth
 /// let clique_geth = Geth::new()
@@ -32,7 +32,7 @@ use std::{
 ///
 /// // don't print logs, but drain the stderr
 /// clique.prevent_blocking().await;
-/// # });
+/// # };
 /// ```
 pub struct CliqueGethInstance {
     /// The spawned [`GethInstance`](ethers_core::utils::GethInstance).
diff --git a/crates/staged-sync/src/test_utils/mod.rs b/crates/staged-sync/src/test_utils/mod.rs
index 51dc7cd5798..ff1105afade 100644
--- a/crates/staged-sync/src/test_utils/mod.rs
+++ b/crates/staged-sync/src/test_utils/mod.rs
@@ -1,5 +1,3 @@
-#![warn(missing_docs, unreachable_pub)]
-
 //! Common helpers for staged sync integration testing.
 
 pub mod clique;
diff --git a/crates/staged-sync/src/utils/chainspec.rs b/crates/staged-sync/src/utils/chainspec.rs
index 27151bbbd9d..6d089741249 100644
--- a/crates/staged-sync/src/utils/chainspec.rs
+++ b/crates/staged-sync/src/utils/chainspec.rs
@@ -1,10 +1,10 @@
 use reth_primitives::{AllGenesisFormats, ChainSpec, GOERLI, MAINNET, SEPOLIA};
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 
 /// Clap value parser for [ChainSpec]s that takes either a built-in chainspec or the path
 /// to a custom one.
-pub fn chain_spec_value_parser(s: &str) -> Result<ChainSpec, eyre::Error> {
-    Ok(match s {
+pub fn chain_spec_value_parser(s: &str) -> Result<Arc<ChainSpec>, eyre::Error> {
+    Ok(Arc::new(match s {
         "mainnet" => MAINNET.clone(),
         "goerli" => GOERLI.clone(),
         "sepolia" => SEPOLIA.clone(),
@@ -12,13 +12,13 @@ pub fn chain_spec_value_parser(s: &str) -> Result<ChainSpec, eyre::Error> {
             let raw = std::fs::read_to_string(PathBuf::from(shellexpand::full(s)?.into_owned()))?;
             serde_json::from_str(&raw)?
         }
-    })
+    }))
 }
 
 /// Clap value parser for [ChainSpec]s that takes either a built-in genesis format or the path
 /// to a custom one.
-pub fn genesis_value_parser(s: &str) -> Result<ChainSpec, eyre::Error> {
-    Ok(match s {
+pub fn genesis_value_parser(s: &str) -> Result<Arc<ChainSpec>, eyre::Error> {
+    Ok(Arc::new(match s {
         "mainnet" => MAINNET.clone(),
         "goerli" => GOERLI.clone(),
         "sepolia" => SEPOLIA.clone(),
@@ -27,7 +27,7 @@ pub fn genesis_value_parser(s: &str) -> Result<ChainSpec, eyre::Error> {
             let genesis: AllGenesisFormats = serde_json::from_str(&raw)?;
             genesis.into()
         }
-    })
+    }))
 }
 
 #[cfg(test)]
diff --git a/crates/staged-sync/src/utils/init.rs b/crates/staged-sync/src/utils/init.rs
index 5551ee7d9dd..7ee1d76382c 100644
--- a/crates/staged-sync/src/utils/init.rs
+++ b/crates/staged-sync/src/utils/init.rs
@@ -12,23 +12,48 @@ use tracing::debug;
 /// Opens up an existing database or creates a new one at the specified path.
 pub fn init_db<P: AsRef<Path>>(path: P) -> eyre::Result<Env<WriteMap>> {
     std::fs::create_dir_all(path.as_ref())?;
-    let db = reth_db::mdbx::Env::<reth_db::mdbx::WriteMap>::open(
-        path.as_ref(),
-        reth_db::mdbx::EnvKind::RW,
-    )?;
+    let db = Env::<WriteMap>::open(path.as_ref(), reth_db::mdbx::EnvKind::RW)?;
     db.create_tables()?;
 
     Ok(db)
 }
 
+/// Database initialization error type.
+#[derive(Debug, thiserror::Error, PartialEq, Eq, Clone)]
+pub enum InitDatabaseError {
+    /// Attempted to reinitialize database with inconsistent genesis block
+    #[error("Genesis hash mismatch: expected {expected}, got {actual}")]
+    GenesisHashMismatch {
+        /// Expected genesis hash.
+        expected: H256,
+        /// Actual genesis hash.
+        actual: H256,
+    },
+
+    /// Low-level database error.
+    #[error(transparent)]
+    DBError(#[from] reth_db::Error),
+}
+
 /// Write the genesis block if it has not already been written
 #[allow(clippy::field_reassign_with_default)]
-pub fn init_genesis<DB: Database>(db: Arc<DB>, chain: ChainSpec) -> Result<H256, reth_db::Error> {
+pub fn init_genesis<DB: Database>(
+    db: Arc<DB>,
+    chain: Arc<ChainSpec>,
+) -> Result<H256, InitDatabaseError> {
     let genesis = chain.genesis();
+
+    let header = chain.genesis_header();
+    let hash = header.hash_slow();
+
     let tx = db.tx()?;
-    if let Some((_, hash)) = tx.cursor_read::<tables::CanonicalHeaders>()?.first()? {
-        debug!("Genesis already written, skipping.");
-        return Ok(hash)
+    if let Some((_, db_hash)) = tx.cursor_read::<tables::CanonicalHeaders>()?.first()? {
+        if db_hash == hash {
+            debug!("Genesis already written, skipping.");
+            return Ok(hash)
+        }
+
+        return Err(InitDatabaseError::GenesisHashMismatch { expected: hash, actual: db_hash })
     }
 
     drop(tx);
@@ -48,9 +73,6 @@ pub fn init_genesis<DB: Database>(db: Arc<DB>, chain: ChainSpec) -> Result<H256,
     }
 
     // Insert header
-    let header = chain.genesis_header();
-
-    let hash = header.hash_slow();
     tx.put::<tables::CanonicalHeaders>(0, hash)?;
     tx.put::<tables::HeaderNumbers>(hash, 0)?;
     tx.put::<tables::BlockBodies>(0, Default::default())?;
@@ -65,7 +87,9 @@ pub fn init_genesis<DB: Database>(db: Arc<DB>, chain: ChainSpec) -> Result<H256,
 #[cfg(test)]
 mod tests {
 
-    use super::init_genesis;
+    use std::sync::Arc;
+
+    use super::{init_genesis, InitDatabaseError};
     use reth_db::mdbx::test_utils::create_test_rw_db;
     use reth_primitives::{
         GOERLI, GOERLI_GENESIS, MAINNET, MAINNET_GENESIS, SEPOLIA, SEPOLIA_GENESIS,
@@ -74,7 +98,7 @@ mod tests {
     #[test]
     fn success_init_genesis_mainnet() {
         let db = create_test_rw_db();
-        let genesis_hash = init_genesis(db, MAINNET.clone()).unwrap();
+        let genesis_hash = init_genesis(db, Arc::new(MAINNET.clone())).unwrap();
 
         // actual, expected
         assert_eq!(genesis_hash, MAINNET_GENESIS);
@@ -83,7 +107,7 @@ mod tests {
     #[test]
     fn success_init_genesis_goerli() {
         let db = create_test_rw_db();
-        let genesis_hash = init_genesis(db, GOERLI.clone()).unwrap();
+        let genesis_hash = init_genesis(db, Arc::new(GOERLI.clone())).unwrap();
 
         // actual, expected
         assert_eq!(genesis_hash, GOERLI_GENESIS);
@@ -92,9 +116,26 @@ mod tests {
     #[test]
     fn success_init_genesis_sepolia() {
         let db = create_test_rw_db();
-        let genesis_hash = init_genesis(db, SEPOLIA.clone()).unwrap();
+        let genesis_hash = init_genesis(db, Arc::new(SEPOLIA.clone())).unwrap();
 
         // actual, expected
         assert_eq!(genesis_hash, SEPOLIA_GENESIS);
     }
+
+    #[test]
+    fn fail_init_inconsistent_db() {
+        let db = create_test_rw_db();
+        init_genesis(db.clone(), Arc::new(SEPOLIA.clone())).unwrap();
+
+        // Try to init db with a different genesis block
+        let genesis_hash = init_genesis(db, Arc::new(MAINNET.clone()));
+
+        assert_eq!(
+            genesis_hash.unwrap_err(),
+            InitDatabaseError::GenesisHashMismatch {
+                expected: MAINNET_GENESIS,
+                actual: SEPOLIA_GENESIS
+            }
+        )
+    }
 }
diff --git a/crates/staged-sync/tests/sync.rs b/crates/staged-sync/tests/sync.rs
index 4bb5d07f0fb..96170fab1a4 100644
--- a/crates/staged-sync/tests/sync.rs
+++ b/crates/staged-sync/tests/sync.rs
@@ -57,7 +57,7 @@ async fn can_peer_with_geth() {
     assert_eq!(geth_peer_id, peer_id);
 }
 
-async fn init_geth() -> (CliqueGethInstance, ChainSpec) {
+async fn init_geth() -> (CliqueGethInstance, Arc<ChainSpec>) {
     // first create a signer that we will fund so we can make transactions
     let chain_id = 13337u64;
     let data_dir = tempfile::tempdir().expect("should be able to create temp geth datadir");
@@ -123,5 +123,5 @@ async fn init_geth() -> (CliqueGethInstance, ChainSpec) {
     let block = clique.provider.get_block_number().await.unwrap();
     assert!(block > U64::zero());
 
-    (clique, chainspec)
+    (clique, Arc::new(chainspec))
 }
diff --git a/crates/stages/Cargo.toml b/crates/stages/Cargo.toml
index eb14a8e7c10..8eded1c5166 100644
--- a/crates/stages/Cargo.toml
+++ b/crates/stages/Cargo.toml
@@ -10,17 +10,15 @@ description = "Staged syncing primitives used in reth."
 [package.metadata.cargo-udeps.ignore]
 normal = [
     # Used for diagrams in docs
-    "aquamarine"
+    "aquamarine",
 ]
 
 [dependencies]
-# reth libs
+# reth
 reth-primitives = { path = "../primitives" }
 reth-interfaces = { path = "../interfaces" }
-reth-executor = { path = "../executor" }
-reth-revm = { path = "../revm" }
-reth-rlp = { path = "../rlp" }
 reth-db = { path = "../storage/db" }
+reth-codecs = { path = "../storage/codecs" }
 reth-provider = { path = "../storage/provider" }
 reth-metrics-derive = { path = "../metrics/metrics-derive" }
 
@@ -36,48 +34,37 @@ tracing = "0.1.36"
 metrics = "0.20.1"
 
 # misc
-serde = { version = "1.0", optional = true }
 thiserror = "1.0.37"
-aquamarine = "0.2.1"
+aquamarine = "0.3.0"
 itertools = "0.10.5"
 rayon = "1.6.0"
 num-traits = "0.2.15"
 
-# trie
-cita_trie = "4.0.0"
-hasher = "0.1.4"
-
-# arbitrary utils
-arbitrary = { version = "1.1.7", features = ["derive"], optional = true }
-proptest = { version = "1.0", optional = true }
-
 [dev-dependencies]
 # reth
-reth-primitives = { path = "../primitives", features = ["arbitrary"]}
+reth-primitives = { path = "../primitives", features = ["arbitrary"] }
 reth-db = { path = "../storage/db", features = ["test-utils", "mdbx"] }
 reth-interfaces = { path = "../interfaces", features = ["test-utils"] }
 reth-downloaders = { path = "../net/downloaders" }
 reth-eth-wire = { path = "../net/eth-wire" }                            # TODO(onbjerg): We only need this for [BlockBody]
+reth-executor = { path = "../executor" }
+reth-rlp = { path = "../rlp" }
+
+itertools = "0.10.5"
 tokio = { version = "*", features = ["rt", "sync", "macros"] }
-tempfile = "3.3.0"
 assert_matches = "1.5.0"
 rand = "0.8.5"
 paste = "1.0"
 
 # Stage benchmarks
-pprof = { version = "0.11", features = ["flamegraph", "frame-pointer", "criterion"] }
+pprof = { version = "0.11", features = [
+    "flamegraph",
+    "frame-pointer",
+    "criterion",
+] }
 criterion = { version = "0.4.0", features = ["async_futures"] }
-proptest = { version = "1.0" }
-arbitrary = { version = "1.1.7", features = ["derive"] }
-eyre = "0.6.8"
-
-# trie
-reth-staged-sync = { path = "../staged-sync" }
-triehash = "0.8"
 
 [features]
-default = ["serde"]
-serde = ["dep:serde"]
 test-utils = []
 
 
diff --git a/crates/stages/benches/criterion.rs b/crates/stages/benches/criterion.rs
index 3fa21ee6f1e..0385099fa1c 100644
--- a/crates/stages/benches/criterion.rs
+++ b/crates/stages/benches/criterion.rs
@@ -4,22 +4,26 @@ use criterion::{
 };
 use pprof::criterion::{Output, PProfProfiler};
 use reth_db::mdbx::{Env, WriteMap};
+use reth_interfaces::test_utils::TestConsensus;
 use reth_stages::{
-    stages::{SenderRecoveryStage, TotalDifficultyStage, TransactionLookupStage},
+    stages::{MerkleStage, SenderRecoveryStage, TotalDifficultyStage, TransactionLookupStage},
     test_utils::TestTransaction,
     ExecInput, Stage, StageId, UnwindInput,
 };
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 
 mod setup;
+use setup::StageRange;
 
 criterion_group! {
     name = benches;
-    config = Criterion::default().with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets = transaction_lookup, account_hashing, senders, total_difficulty
+    config = Criterion::default().with_profiler(PProfProfiler::new(1000, Output::Flamegraph(None)));
+    targets = transaction_lookup, account_hashing, senders, total_difficulty, merkle
 }
 criterion_main!(benches);
 
+const DEFAULT_NUM_BLOCKS: u64 = 10_000;
+
 fn account_hashing(c: &mut Criterion) {
     let mut group = c.benchmark_group("Stages");
 
@@ -29,32 +33,42 @@ fn account_hashing(c: &mut Criterion) {
     let num_blocks = 10_000;
     let (path, stage, execution_range) = setup::prepare_account_hashing(num_blocks);
 
-    measure_stage_with_path(&mut group, stage, path, "AccountHashing".to_string(), execution_range);
+    measure_stage_with_path(
+        path,
+        &mut group,
+        setup::stage_unwind,
+        stage,
+        execution_range,
+        "AccountHashing".to_string(),
+    );
 }
 
 fn senders(c: &mut Criterion) {
     let mut group = c.benchmark_group("Stages");
-
     // don't need to run each stage for that many times
     group.sample_size(10);
 
     for batch in [1000usize, 10_000, 100_000, 250_000] {
-        let num_blocks = 10_000;
-        let stage = SenderRecoveryStage { commit_threshold: num_blocks, ..Default::default() };
+        let stage = SenderRecoveryStage { commit_threshold: DEFAULT_NUM_BLOCKS };
         let label = format!("SendersRecovery-batch-{batch}");
-        measure_stage(&mut group, stage, num_blocks, label);
+
+        measure_stage(&mut group, setup::stage_unwind, stage, 0..DEFAULT_NUM_BLOCKS, label);
     }
 }
 
 fn transaction_lookup(c: &mut Criterion) {
     let mut group = c.benchmark_group("Stages");
-
     // don't need to run each stage for that many times
     group.sample_size(10);
+    let stage = TransactionLookupStage::new(DEFAULT_NUM_BLOCKS);
 
-    let num_blocks = 10_000;
-    let stage = TransactionLookupStage::new(num_blocks);
-    measure_stage(&mut group, stage, num_blocks, "TransactionLookup".to_string());
+    measure_stage(
+        &mut group,
+        setup::stage_unwind,
+        stage,
+        0..DEFAULT_NUM_BLOCKS,
+        "TransactionLookup".to_string(),
+    );
 }
 
 fn total_difficulty(c: &mut Criterion) {
@@ -63,44 +77,60 @@ fn total_difficulty(c: &mut Criterion) {
     group.warm_up_time(std::time::Duration::from_millis(2000));
     // don't need to run each stage for that many times
     group.sample_size(10);
+    let stage = TotalDifficultyStage::new(Arc::new(TestConsensus::default()));
 
-    let num_blocks = 10_000;
-    let stage = TotalDifficultyStage::default();
-    measure_stage(&mut group, stage, num_blocks, "TotalDifficulty".to_string());
+    measure_stage(
+        &mut group,
+        setup::stage_unwind,
+        stage,
+        0..DEFAULT_NUM_BLOCKS,
+        "TotalDifficulty".to_string(),
+    );
+}
+
+fn merkle(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Stages");
+    // don't need to run each stage for that many times
+    group.sample_size(10);
+
+    let stage = MerkleStage::Both { clean_threshold: u64::MAX };
+    measure_stage(
+        &mut group,
+        setup::unwind_hashes,
+        stage,
+        1..DEFAULT_NUM_BLOCKS + 1,
+        "Merkle-incremental".to_string(),
+    );
+
+    let stage = MerkleStage::Both { clean_threshold: 0 };
+    measure_stage(
+        &mut group,
+        setup::unwind_hashes,
+        stage,
+        1..DEFAULT_NUM_BLOCKS + 1,
+        "Merkle-fullhash".to_string(),
+    );
 }
 
-fn measure_stage_with_path<S: Clone + Default + Stage<Env<WriteMap>>>(
+fn measure_stage_with_path<F, S>(
+    path: PathBuf,
     group: &mut BenchmarkGroup<WallTime>,
+    setup: F,
     stage: S,
-    path: PathBuf,
+    stage_range: StageRange,
     label: String,
-    stage_range: (ExecInput, UnwindInput),
-) {
+) where
+    S: Clone + Stage<Env<WriteMap>>,
+    F: Fn(S, &TestTransaction, StageRange),
+{
     let tx = TestTransaction::new(&path);
-    let (input, unwind) = stage_range;
+    let (input, _) = stage_range;
 
     group.bench_function(label, move |b| {
         b.to_async(FuturesExecutor).iter_with_setup(
             || {
                 // criterion setup does not support async, so we have to use our own runtime
-                tokio::runtime::Runtime::new().unwrap().block_on(async {
-                    let mut stage = stage.clone();
-                    let mut db_tx = tx.inner();
-
-                    // Clear previous run
-                    stage
-                        .unwind(&mut db_tx, unwind)
-                        .await
-                        .map_err(|e| {
-                            eyre::eyre!(format!(
-                                "{e}\nMake sure your test database at `{}` isn't too old and incompatible with newer stage changes.",
-                                path.display()
-                            ))
-                        })
-                        .unwrap();
-
-                    db_tx.commit().unwrap();
-                });
+                setup(stage.clone(), &tx, stage_range)
             },
             |_| async {
                 let mut stage = stage.clone();
@@ -112,25 +142,34 @@ fn measure_stage_with_path<S: Clone + Default + Stage<Env<WriteMap>>>(
     });
 }
 
-fn measure_stage<S: Clone + Default + Stage<Env<WriteMap>>>(
+fn measure_stage<F, S>(
     group: &mut BenchmarkGroup<WallTime>,
+    setup: F,
     stage: S,
-    num_blocks: u64,
+    block_interval: std::ops::Range<u64>,
     label: String,
-) {
-    let path = setup::txs_testdata(num_blocks as usize);
+) where
+    S: Clone + Stage<Env<WriteMap>>,
+    F: Fn(S, &TestTransaction, StageRange),
+{
+    let path = setup::txs_testdata(block_interval.end);
 
     measure_stage_with_path(
+        path,
         group,
+        setup,
         stage,
-        path,
-        label,
         (
             ExecInput {
-                previous_stage: Some((StageId("Another"), num_blocks)),
-                ..Default::default()
+                previous_stage: Some((StageId("Another"), block_interval.end)),
+                stage_progress: Some(block_interval.start),
+            },
+            UnwindInput {
+                stage_progress: block_interval.end,
+                unwind_to: block_interval.start,
+                bad_block: None,
             },
-            UnwindInput::default(),
         ),
-    )
+        label,
+    );
 }
diff --git a/crates/stages/benches/setup/account_hashing.rs b/crates/stages/benches/setup/account_hashing.rs
index ec408c358ff..033b71da9fa 100644
--- a/crates/stages/benches/setup/account_hashing.rs
+++ b/crates/stages/benches/setup/account_hashing.rs
@@ -1,4 +1,4 @@
-use super::constants;
+use super::{constants, StageRange};
 use reth_db::{
     cursor::DbCursorRO, database::Database, tables, transaction::DbTx, Error as DbError,
 };
@@ -15,9 +15,7 @@ use std::path::{Path, PathBuf};
 /// generate its own random data.
 ///
 /// Returns the path to the database file, stage and range of stage execution if it exists.
-pub fn prepare_account_hashing(
-    num_blocks: u64,
-) -> (PathBuf, AccountHashingStage, (ExecInput, UnwindInput)) {
+pub fn prepare_account_hashing(num_blocks: u64) -> (PathBuf, AccountHashingStage, StageRange) {
     let (path, stage_range) = match std::env::var(constants::ACCOUNT_HASHING_DB) {
         Ok(db) => {
             let path = Path::new(&db).to_path_buf();
@@ -30,7 +28,7 @@ pub fn prepare_account_hashing(
     (path, AccountHashingStage::default(), stage_range)
 }
 
-fn find_stage_range(db: &Path) -> (ExecInput, UnwindInput) {
+fn find_stage_range(db: &Path) -> StageRange {
     let mut stage_range = None;
     TestTransaction::new(db)
         .tx
@@ -54,7 +52,7 @@ fn find_stage_range(db: &Path) -> (ExecInput, UnwindInput) {
     stage_range.expect("Could not find the stage range from the external DB.")
 }
 
-fn generate_testdata_db(num_blocks: u64) -> (PathBuf, (ExecInput, UnwindInput)) {
+fn generate_testdata_db(num_blocks: u64) -> (PathBuf, StageRange) {
     let opts = SeedOpts {
         blocks: 0..num_blocks + 1,
         accounts: 0..10_000,
diff --git a/crates/stages/benches/setup/mod.rs b/crates/stages/benches/setup/mod.rs
index 7f7932bfede..eb587f893d2 100644
--- a/crates/stages/benches/setup/mod.rs
+++ b/crates/stages/benches/setup/mod.rs
@@ -1,34 +1,169 @@
+use itertools::concat;
 use reth_db::{
     cursor::DbCursorRO,
+    mdbx::{Env, WriteMap},
     tables,
     transaction::{DbTx, DbTxMut},
 };
-use reth_interfaces::test_utils::generators::random_block_range;
-use reth_primitives::H256;
-use reth_stages::test_utils::TestTransaction;
-use std::path::{Path, PathBuf};
+use reth_interfaces::test_utils::generators::{
+    random_block_range, random_contract_account_range, random_eoa_account_range,
+    random_transition_range,
+};
+use reth_primitives::{Account, Address, SealedBlock, H256};
+use reth_provider::trie::DBTrieLoader;
+use reth_stages::{
+    stages::{AccountHashingStage, StorageHashingStage},
+    test_utils::TestTransaction,
+    ExecInput, Stage, UnwindInput,
+};
+use std::{
+    collections::BTreeMap,
+    ops::Deref,
+    path::{Path, PathBuf},
+};
 
 mod constants;
 
 mod account_hashing;
 pub use account_hashing::*;
 
-// Helper for generating testdata for the sender recovery stage and tx lookup stages (512MB).
-// Returns the path to the database file and the number of blocks written.
-pub fn txs_testdata(num_blocks: usize) -> PathBuf {
+pub(crate) type StageRange = (ExecInput, UnwindInput);
+
+pub(crate) fn stage_unwind<S: Clone + Stage<Env<WriteMap>>>(
+    stage: S,
+    tx: &TestTransaction,
+    range: StageRange,
+) {
+    let (_, unwind) = range;
+
+    tokio::runtime::Runtime::new().unwrap().block_on(async {
+        let mut stage = stage.clone();
+        let mut db_tx = tx.inner();
+
+        // Clear previous run
+        stage
+            .unwind(&mut db_tx, unwind)
+            .await
+            .map_err(|e| {
+                format!(
+                    "{e}\nMake sure your test database at `{}` isn't too old and incompatible with newer stage changes.",
+                    tx.path.as_ref().unwrap().display()
+                )
+            })
+            .unwrap();
+
+        db_tx.commit().unwrap();
+    });
+}
+
+pub(crate) fn unwind_hashes<S: Clone + Stage<Env<WriteMap>>>(
+    stage: S,
+    tx: &TestTransaction,
+    range: StageRange,
+) {
+    let (input, unwind) = range;
+
+    tokio::runtime::Runtime::new().unwrap().block_on(async {
+        let mut stage = stage.clone();
+        let mut db_tx = tx.inner();
+
+        StorageHashingStage::default().unwind(&mut db_tx, unwind).await.unwrap();
+        AccountHashingStage::default().unwind(&mut db_tx, unwind).await.unwrap();
+
+        let target_root = db_tx.get_header(unwind.unwind_to).unwrap().state_root;
+        let _ = db_tx.delete::<tables::AccountsTrie>(target_root, None);
+
+        // Clear previous run
+        stage.unwind(&mut db_tx, unwind).await.unwrap();
+
+        AccountHashingStage::default().execute(&mut db_tx, input).await.unwrap();
+        StorageHashingStage::default().execute(&mut db_tx, input).await.unwrap();
+
+        db_tx.commit().unwrap();
+    });
+}
+
+// Helper for generating testdata for the benchmarks.
+// Returns the path to the database file.
+pub(crate) fn txs_testdata(num_blocks: u64) -> PathBuf {
     let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata").join("txs-bench");
     let txs_range = 100..150;
 
+    // number of storage changes per transition
+    let n_changes = 0..3;
+
+    // range of possible values for a storage key
+    let key_range = 0..300;
+
+    // number of accounts
+    let n_eoa = 131;
+    let n_contract = 31;
+
     if !path.exists() {
         // create the dirs
         std::fs::create_dir_all(&path).unwrap();
         println!("Transactions testdata not found, generating to {:?}", path.display());
         let tx = TestTransaction::new(&path);
 
-        // This takes a while because it does sig recovery internally
-        let blocks = random_block_range(0..num_blocks as u64 + 1, H256::zero(), txs_range);
+        let accounts: BTreeMap<Address, Account> = concat([
+            random_eoa_account_range(0..n_eoa),
+            random_contract_account_range(&mut (0..n_contract)),
+        ])
+        .into_iter()
+        .collect();
+
+        let mut blocks = random_block_range(0..num_blocks + 1, H256::zero(), txs_range);
+
+        let (transitions, start_state) = random_transition_range(
+            blocks.iter().take(2),
+            accounts.into_iter().map(|(addr, acc)| (addr, (acc, Vec::new()))),
+            n_changes.clone(),
+            key_range.clone(),
+        );
+
+        tx.insert_accounts_and_storages(start_state.clone()).unwrap();
+
+        // make first block after genesis have valid state root
+        let root =
+            DBTrieLoader::new(tx.inner().deref()).calculate_root().and_then(|e| e.root()).unwrap();
+        let second_block = blocks.get_mut(1).unwrap();
+        let cloned_second = second_block.clone();
+        let mut updated_header = cloned_second.header.unseal();
+        updated_header.state_root = root;
+        *second_block = SealedBlock { header: updated_header.seal_slow(), ..cloned_second };
+
+        let offset = transitions.len() as u64;
+
+        tx.insert_transitions(transitions, None).unwrap();
+
+        let (transitions, final_state) =
+            random_transition_range(blocks.iter().skip(2), start_state, n_changes, key_range);
+
+        tx.insert_transitions(transitions, Some(offset)).unwrap();
+
+        tx.insert_accounts_and_storages(final_state).unwrap();
+
+        // make last block have valid state root
+        let root = {
+            let mut tx_mut = tx.inner();
+            let root =
+                DBTrieLoader::new(tx_mut.deref()).calculate_root().and_then(|e| e.root()).unwrap();
+            tx_mut.commit().unwrap();
+            root
+        };
+
+        tx.query(|tx| {
+            assert!(tx.get::<tables::AccountsTrie>(root)?.is_some());
+            Ok(())
+        })
+        .unwrap();
+
+        let last_block = blocks.last_mut().unwrap();
+        let cloned_last = last_block.clone();
+        let mut updated_header = cloned_last.header.unseal();
+        updated_header.state_root = root;
+        *last_block = SealedBlock { header: updated_header.seal_slow(), ..cloned_last };
 
-        // insert all blocks
         tx.insert_blocks(blocks.iter(), None).unwrap();
 
         // initialize TD
diff --git a/crates/stages/src/error.rs b/crates/stages/src/error.rs
index 0698bf092f4..bd1c91bc122 100644
--- a/crates/stages/src/error.rs
+++ b/crates/stages/src/error.rs
@@ -17,7 +17,7 @@ pub enum StageError {
         block: BlockNumber,
         /// The underlying consensus error.
         #[source]
-        error: consensus::Error,
+        error: consensus::ConsensusError,
     },
     /// The stage encountered a database error.
     #[error("An internal database error occurred: {0}")]
diff --git a/crates/stages/src/id.rs b/crates/stages/src/id.rs
index 8feb0222133..2d4bfc971dc 100644
--- a/crates/stages/src/id.rs
+++ b/crates/stages/src/id.rs
@@ -27,7 +27,7 @@ impl StageId {
 
     /// Get the last committed progress of this stage.
     pub fn get_progress<'db>(&self, tx: &impl DbTx<'db>) -> Result<Option<BlockNumber>, DbError> {
-        tx.get::<SyncStage>(self.0.as_bytes().to_vec())
+        tx.get::<SyncStage>(self.0.to_string())
     }
 
     /// Save the progress of this stage.
@@ -36,7 +36,7 @@ impl StageId {
         tx: &impl DbTxMut<'db>,
         block: BlockNumber,
     ) -> Result<(), DbError> {
-        tx.put::<SyncStage>(self.0.as_bytes().to_vec(), block)
+        tx.put::<SyncStage>(self.0.to_string(), block)
     }
 }
 
diff --git a/crates/stages/src/lib.rs b/crates/stages/src/lib.rs
index 139bc314d1c..dbc43f486a6 100644
--- a/crates/stages/src/lib.rs
+++ b/crates/stages/src/lib.rs
@@ -27,9 +27,12 @@
 //! # use reth_interfaces::consensus::Consensus;
 //! # use reth_interfaces::sync::NoopSyncStateUpdate;
 //! # use reth_interfaces::test_utils::{TestBodiesClient, TestConsensus, TestHeadersClient, TestStatusUpdater};
-//! # use reth_primitives::PeerId;
+//! # use reth_executor::Factory;
+//! # use reth_primitives::{PeerId, MAINNET, H256};
 //! # use reth_stages::Pipeline;
 //! # use reth_stages::sets::DefaultStages;
+//! # use reth_stages::stages::HeaderSyncMode;
+//! # use tokio::sync::watch;
 //! # let consensus: Arc<dyn Consensus> = Arc::new(TestConsensus::default());
 //! # let headers_downloader = ReverseHeadersDownloaderBuilder::default().build(
 //! #    Arc::new(TestHeadersClient::default()),
@@ -40,12 +43,15 @@
 //! #    consensus.clone(),
 //! #    create_test_rw_db()
 //! # );
+//! # let (tip_tx, tip_rx) = watch::channel(H256::default());
+//! # let factory = Factory::new(Arc::new(MAINNET.clone()));
 //! # let (status_updater, _) = TestStatusUpdater::new();
 //! // Create a pipeline that can fully sync
 //! # let pipeline: Pipeline<Env<WriteMap>, NoopSyncStateUpdate> =
 //! Pipeline::builder()
+//!     .with_tip_sender(tip_tx)
 //!     .add_stages(
-//!         DefaultStages::new(consensus, headers_downloader, bodies_downloader, status_updater)
+//!         DefaultStages::new(HeaderSyncMode::Tip(tip_rx), consensus, headers_downloader, bodies_downloader, status_updater, factory)
 //!     )
 //!     .build();
 //! ```
@@ -53,7 +59,6 @@ mod error;
 mod id;
 mod pipeline;
 mod stage;
-mod trie;
 mod util;
 
 #[allow(missing_docs)]
diff --git a/crates/stages/src/pipeline/builder.rs b/crates/stages/src/pipeline/builder.rs
index 4882dbdf0fa..37853708cd0 100644
--- a/crates/stages/src/pipeline/builder.rs
+++ b/crates/stages/src/pipeline/builder.rs
@@ -1,7 +1,8 @@
 use crate::{Pipeline, Stage, StageSet};
 use reth_db::database::Database;
 use reth_interfaces::sync::{NoopSyncStateUpdate, SyncStateUpdater};
-use reth_primitives::BlockNumber;
+use reth_primitives::{BlockNumber, H256};
+use tokio::sync::watch;
 
 /// Builds a [`Pipeline`].
 #[derive(Debug)]
@@ -56,6 +57,12 @@ where
         self
     }
 
+    /// Set the tip sender.
+    pub fn with_tip_sender(mut self, tip_tx: watch::Sender<H256>) -> Self {
+        self.pipeline.tip_tx = Some(tip_tx);
+        self
+    }
+
     /// Set a [SyncStateUpdater].
     pub fn with_sync_state_updater(mut self, updater: U) -> Self {
         self.pipeline.sync_state_updater = Some(updater);
diff --git a/crates/stages/src/pipeline/mod.rs b/crates/stages/src/pipeline/mod.rs
index 794503bc582..95347f982bf 100644
--- a/crates/stages/src/pipeline/mod.rs
+++ b/crates/stages/src/pipeline/mod.rs
@@ -1,28 +1,30 @@
-use crate::{error::*, util::opt, ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput};
-use metrics::Gauge;
+use crate::{error::*, ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput};
 use reth_db::database::Database;
 use reth_interfaces::sync::{SyncState, SyncStateUpdater};
-use reth_metrics_derive::Metrics;
-use reth_primitives::BlockNumber;
+use reth_primitives::{BlockNumber, H256};
 use reth_provider::Transaction;
 use std::{
-    collections::HashMap,
     fmt::{Debug, Formatter},
     ops::Deref,
     sync::Arc,
 };
+use tokio::sync::watch;
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use tracing::*;
 
 mod builder;
 mod ctrl;
 mod event;
+mod progress;
 mod set;
+mod sync_metrics;
 
 pub use builder::*;
 use ctrl::*;
 pub use event::*;
+use progress::*;
 pub use set::*;
+use sync_metrics::*;
 
 #[cfg_attr(doc, aquamarine::aquamarine)]
 /// A staged sync pipeline.
@@ -80,6 +82,7 @@ pub struct Pipeline<DB: Database, U: SyncStateUpdater> {
     listeners: PipelineEventListeners,
     sync_state_updater: Option<U>,
     progress: PipelineProgress,
+    tip_tx: Option<watch::Sender<H256>>,
     metrics: Metrics,
 }
 
@@ -91,6 +94,7 @@ impl<DB: Database, U: SyncStateUpdater> Default for Pipeline<DB, U> {
             listeners: PipelineEventListeners::default(),
             sync_state_updater: None,
             progress: PipelineProgress::default(),
+            tip_tx: None,
             metrics: Metrics::default(),
         }
     }
@@ -111,6 +115,11 @@ impl<DB: Database, U: SyncStateUpdater> Pipeline<DB, U> {
         PipelineBuilder::default()
     }
 
+    /// Set tip for reverse sync.
+    pub fn set_tip(&self, tip: H256) {
+        self.tip_tx.as_ref().expect("tip sender is set").send(tip).expect("tip channel closed");
+    }
+
     /// Listen for events on the pipeline.
     pub fn events(&mut self) -> UnboundedReceiverStream<PipelineEvent> {
         self.listeners.new_listener()
@@ -360,75 +369,17 @@ impl<DB: Database, U: SyncStateUpdater> Pipeline<DB, U> {
     }
 }
 
-#[derive(Metrics)]
-#[metrics(scope = "sync")]
-struct StageMetrics {
-    /// The block number of the last commit for a stage.
-    checkpoint: Gauge,
-}
-
-#[derive(Default)]
-struct Metrics {
-    checkpoints: HashMap<StageId, StageMetrics>,
-}
-
-impl Metrics {
-    fn stage_checkpoint(&mut self, stage_id: StageId, progress: u64) {
-        self.checkpoints
-            .entry(stage_id)
-            .or_insert_with(|| StageMetrics::new_with_labels(&[("stage", stage_id.to_string())]))
-            .checkpoint
-            .set(progress as f64);
-    }
-}
-
-#[derive(Debug, Default)]
-struct PipelineProgress {
-    /// The progress of the current stage
-    pub(crate) progress: Option<BlockNumber>,
-    /// The maximum progress achieved by any stage during the execution of the pipeline.
-    pub(crate) maximum_progress: Option<BlockNumber>,
-    /// The minimum progress achieved by any stage during the execution of the pipeline.
-    pub(crate) minimum_progress: Option<BlockNumber>,
-}
-
-impl PipelineProgress {
-    fn update(&mut self, progress: BlockNumber) {
-        self.progress = Some(progress);
-        self.minimum_progress = opt::min(self.minimum_progress, progress);
-        self.maximum_progress = opt::max(self.maximum_progress, progress);
-    }
-
-    /// Create a sync state from pipeline progress.
-    fn current_sync_state(&self, downloading: bool) -> SyncState {
-        match self.progress {
-            Some(progress) if downloading => SyncState::Downloading { target_block: progress },
-            Some(progress) => SyncState::Executing { target_block: progress },
-            None => SyncState::Idle,
-        }
-    }
-
-    /// Get next control flow step
-    fn next_ctrl(&self) -> ControlFlow {
-        match self.progress {
-            Some(progress) => ControlFlow::Continue { progress },
-            None => ControlFlow::NoProgress { stage_progress: None },
-        }
-    }
-}
-
 /// A container for a queued stage.
 pub(crate) type BoxedStage<DB> = Box<dyn Stage<DB>>;
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{StageId, UnwindOutput};
+    use crate::{test_utils::TestStage, StageId, UnwindOutput};
     use assert_matches::assert_matches;
     use reth_db::mdbx::{self, test_utils, EnvKind};
     use reth_interfaces::{consensus, provider::ProviderError, sync::NoopSyncStateUpdate};
     use tokio_stream::StreamExt;
-    use utils::TestStage;
 
     #[test]
     fn record_progress_calculates_outliers() {
@@ -490,7 +441,9 @@ mod tests {
         let events = pipeline.events();
 
         // Run pipeline
-        tokio::spawn(async move { pipeline.run(db).await });
+        tokio::spawn(async move {
+            pipeline.run(db).await.unwrap();
+        });
 
         // Check that the stages were run in order
         assert_eq!(
@@ -620,7 +573,7 @@ mod tests {
                 TestStage::new(StageId("B"))
                     .add_exec(Err(StageError::Validation {
                         block: 5,
-                        error: consensus::Error::BaseFeeMissing,
+                        error: consensus::ConsensusError::BaseFeeMissing,
                     }))
                     .add_unwind(Ok(UnwindOutput { stage_progress: 0 }))
                     .add_exec(Ok(ExecOutput { stage_progress: 10, done: true })),
@@ -698,59 +651,4 @@ mod tests {
             })))
         );
     }
-
-    mod utils {
-        use super::*;
-        use async_trait::async_trait;
-        use std::collections::VecDeque;
-
-        pub(crate) struct TestStage {
-            id: StageId,
-            exec_outputs: VecDeque<Result<ExecOutput, StageError>>,
-            unwind_outputs: VecDeque<Result<UnwindOutput, StageError>>,
-        }
-
-        impl TestStage {
-            pub(crate) fn new(id: StageId) -> Self {
-                Self { id, exec_outputs: VecDeque::new(), unwind_outputs: VecDeque::new() }
-            }
-
-            pub(crate) fn add_exec(mut self, output: Result<ExecOutput, StageError>) -> Self {
-                self.exec_outputs.push_back(output);
-                self
-            }
-
-            pub(crate) fn add_unwind(mut self, output: Result<UnwindOutput, StageError>) -> Self {
-                self.unwind_outputs.push_back(output);
-                self
-            }
-        }
-
-        #[async_trait]
-        impl<DB: Database> Stage<DB> for TestStage {
-            fn id(&self) -> StageId {
-                self.id
-            }
-
-            async fn execute(
-                &mut self,
-                _: &mut Transaction<'_, DB>,
-                _input: ExecInput,
-            ) -> Result<ExecOutput, StageError> {
-                self.exec_outputs
-                    .pop_front()
-                    .unwrap_or_else(|| panic!("Test stage {} executed too many times.", self.id))
-            }
-
-            async fn unwind(
-                &mut self,
-                _: &mut Transaction<'_, DB>,
-                _input: UnwindInput,
-            ) -> Result<UnwindOutput, StageError> {
-                self.unwind_outputs
-                    .pop_front()
-                    .unwrap_or_else(|| panic!("Test stage {} unwound too many times.", self.id))
-            }
-        }
-    }
 }
diff --git a/crates/stages/src/pipeline/progress.rs b/crates/stages/src/pipeline/progress.rs
new file mode 100644
index 00000000000..51711370b65
--- /dev/null
+++ b/crates/stages/src/pipeline/progress.rs
@@ -0,0 +1,39 @@
+use super::ctrl::ControlFlow;
+use crate::util::opt;
+use reth_interfaces::sync::SyncState;
+use reth_primitives::BlockNumber;
+
+#[derive(Debug, Default)]
+pub(crate) struct PipelineProgress {
+    /// The progress of the current stage
+    pub(crate) progress: Option<BlockNumber>,
+    /// The maximum progress achieved by any stage during the execution of the pipeline.
+    pub(crate) maximum_progress: Option<BlockNumber>,
+    /// The minimum progress achieved by any stage during the execution of the pipeline.
+    pub(crate) minimum_progress: Option<BlockNumber>,
+}
+
+impl PipelineProgress {
+    pub(crate) fn update(&mut self, progress: BlockNumber) {
+        self.progress = Some(progress);
+        self.minimum_progress = opt::min(self.minimum_progress, progress);
+        self.maximum_progress = opt::max(self.maximum_progress, progress);
+    }
+
+    /// Create a sync state from pipeline progress.
+    pub(crate) fn current_sync_state(&self, downloading: bool) -> SyncState {
+        match self.progress {
+            Some(progress) if downloading => SyncState::Downloading { target_block: progress },
+            Some(progress) => SyncState::Executing { target_block: progress },
+            None => SyncState::Idle,
+        }
+    }
+
+    /// Get next control flow step
+    pub(crate) fn next_ctrl(&self) -> ControlFlow {
+        match self.progress {
+            Some(progress) => ControlFlow::Continue { progress },
+            None => ControlFlow::NoProgress { stage_progress: None },
+        }
+    }
+}
diff --git a/crates/stages/src/pipeline/sync_metrics.rs b/crates/stages/src/pipeline/sync_metrics.rs
new file mode 100644
index 00000000000..ba44ebc726c
--- /dev/null
+++ b/crates/stages/src/pipeline/sync_metrics.rs
@@ -0,0 +1,26 @@
+use crate::StageId;
+use metrics::Gauge;
+use reth_metrics_derive::Metrics;
+use std::collections::HashMap;
+
+#[derive(Metrics)]
+#[metrics(scope = "sync")]
+pub(crate) struct StageMetrics {
+    /// The block number of the last commit for a stage.
+    checkpoint: Gauge,
+}
+
+#[derive(Default)]
+pub(crate) struct Metrics {
+    checkpoints: HashMap<StageId, StageMetrics>,
+}
+
+impl Metrics {
+    pub(crate) fn stage_checkpoint(&mut self, stage_id: StageId, progress: u64) {
+        self.checkpoints
+            .entry(stage_id)
+            .or_insert_with(|| StageMetrics::new_with_labels(&[("stage", stage_id.to_string())]))
+            .checkpoint
+            .set(progress as f64);
+    }
+}
diff --git a/crates/stages/src/sets.rs b/crates/stages/src/sets.rs
index 6b2d70031fe..248c34dd5dd 100644
--- a/crates/stages/src/sets.rs
+++ b/crates/stages/src/sets.rs
@@ -14,24 +14,33 @@
 //! # use reth_interfaces::sync::NoopSyncStateUpdate;
 //! # use reth_stages::Pipeline;
 //! # use reth_stages::sets::{OfflineStages};
+//! # use reth_executor::Factory;
+//! # use reth_primitives::MAINNET;
+//! # use std::sync::Arc;
+//!
+//! # let factory = Factory::new(Arc::new(MAINNET.clone()));
 //! // Build a pipeline with all offline stages.
 //! # let pipeline: Pipeline<Env<WriteMap>, NoopSyncStateUpdate> =
-//! Pipeline::builder().add_stages(OfflineStages::default()).build();
+//! Pipeline::builder().add_stages(OfflineStages::new(factory)).build();
 //! ```
 //!
 //! ```ignore
 //! # use reth_stages::Pipeline;
 //! # use reth_stages::{StageSet, sets::OfflineStages};
+//! # use reth_executor::Factory;
+//! # use reth_primitives::MAINNET;
+//! # use std::sync::Arc;
 //! // Build a pipeline with all offline stages and a custom stage at the end.
+//! # let factory = Factory::new(Arc::new(MAINNET.clone()));
 //! Pipeline::builder()
 //!     .add_stages(
-//!         OfflineStages::default().builder().add_stage(MyCustomStage)
+//!         OfflineStages::new(factory).builder().add_stage(MyCustomStage)
 //!     )
 //!     .build();
 //! ```
 use crate::{
     stages::{
-        AccountHashingStage, BodyStage, ExecutionStage, FinishStage, HeaderStage,
+        AccountHashingStage, BodyStage, ExecutionStage, FinishStage, HeaderStage, HeaderSyncMode,
         IndexAccountHistoryStage, IndexStorageHistoryStage, MerkleStage, SenderRecoveryStage,
         StorageHashingStage, TotalDifficultyStage, TransactionLookupStage,
     },
@@ -45,7 +54,7 @@ use reth_interfaces::{
         headers::{client::StatusUpdater, downloader::HeaderDownloader},
     },
 };
-use reth_primitives::ChainSpec;
+use reth_provider::ExecutorFactory;
 use std::sync::Arc;
 
 /// A set containing all stages to run a fully syncing instance of reth.
@@ -56,40 +65,63 @@ use std::sync::Arc;
 /// - [`OfflineStages`]
 /// - [`FinishStage`]
 #[derive(Debug)]
-pub struct DefaultStages<H, B, S> {
+pub struct DefaultStages<H, B, S, EF> {
     /// Configuration for the online stages
     online: OnlineStages<H, B>,
+    /// Executor factory needs for execution stage
+    executor_factory: EF,
     /// Configuration for the [`FinishStage`] stage.
     status_updater: S,
 }
 
-impl<H, B, S> DefaultStages<H, B, S> {
+impl<H, B, S, EF> DefaultStages<H, B, S, EF> {
     /// Create a new set of default stages with default values.
     pub fn new(
+        header_mode: HeaderSyncMode,
         consensus: Arc<dyn Consensus>,
         header_downloader: H,
         body_downloader: B,
         status_updater: S,
-    ) -> Self {
+        executor_factory: EF,
+    ) -> Self
+    where
+        EF: ExecutorFactory,
+    {
         Self {
-            online: OnlineStages::new(consensus, header_downloader, body_downloader),
+            online: OnlineStages::new(header_mode, consensus, header_downloader, body_downloader),
+            executor_factory,
             status_updater,
         }
     }
 }
 
-impl<DB, H, B, S> StageSet<DB> for DefaultStages<H, B, S>
+impl<H, B, S, EF> DefaultStages<H, B, S, EF>
+where
+    S: StatusUpdater + 'static,
+    EF: ExecutorFactory,
+{
+    /// Appends the default offline stages and default finish stage to the given builder.
+    pub fn add_offline_stages<DB: Database>(
+        default_offline: StageSetBuilder<DB>,
+        status_updater: S,
+        executor_factory: EF,
+    ) -> StageSetBuilder<DB> {
+        default_offline
+            .add_set(OfflineStages::new(executor_factory))
+            .add_stage(FinishStage::new(status_updater))
+    }
+}
+
+impl<DB, H, B, S, EF> StageSet<DB> for DefaultStages<H, B, S, EF>
 where
     DB: Database,
     H: HeaderDownloader + 'static,
     B: BodyDownloader + 'static,
     S: StatusUpdater + 'static,
+    EF: ExecutorFactory,
 {
     fn builder(self) -> StageSetBuilder<DB> {
-        self.online
-            .builder()
-            .add_set(OfflineStages)
-            .add_stage(FinishStage::new(self.status_updater))
+        Self::add_offline_stages(self.online.builder(), self.status_updater, self.executor_factory)
     }
 }
 
@@ -99,6 +131,8 @@ where
 /// themselves offline.
 #[derive(Debug)]
 pub struct OnlineStages<H, B> {
+    /// The sync mode for the headers stage.
+    header_mode: HeaderSyncMode,
     /// The consensus engine used to validate incoming data.
     consensus: Arc<dyn Consensus>,
     /// The block header downloader
@@ -109,8 +143,44 @@ pub struct OnlineStages<H, B> {
 
 impl<H, B> OnlineStages<H, B> {
     /// Create a new set of online stages with default values.
-    pub fn new(consensus: Arc<dyn Consensus>, header_downloader: H, body_downloader: B) -> Self {
-        Self { consensus, header_downloader, body_downloader }
+    pub fn new(
+        header_mode: HeaderSyncMode,
+        consensus: Arc<dyn Consensus>,
+        header_downloader: H,
+        body_downloader: B,
+    ) -> Self {
+        Self { header_mode, consensus, header_downloader, body_downloader }
+    }
+}
+
+impl<H, B> OnlineStages<H, B>
+where
+    H: HeaderDownloader + 'static,
+    B: BodyDownloader + 'static,
+{
+    /// Create a new builder using the given headers stage.
+    pub fn builder_with_headers<DB: Database>(
+        headers: HeaderStage<H>,
+        body_downloader: B,
+        consensus: Arc<dyn Consensus>,
+    ) -> StageSetBuilder<DB> {
+        StageSetBuilder::default()
+            .add_stage(headers)
+            .add_stage(TotalDifficultyStage::new(consensus.clone()))
+            .add_stage(BodyStage { downloader: body_downloader, consensus })
+    }
+
+    /// Create a new builder using the given bodies stage.
+    pub fn builder_with_bodies<DB: Database>(
+        bodies: BodyStage<B>,
+        mode: HeaderSyncMode,
+        header_downloader: H,
+        consensus: Arc<dyn Consensus>,
+    ) -> StageSetBuilder<DB> {
+        StageSetBuilder::default()
+            .add_stage(HeaderStage::new(header_downloader, mode))
+            .add_stage(TotalDifficultyStage::new(consensus.clone()))
+            .add_stage(bodies)
     }
 }
 
@@ -122,8 +192,8 @@ where
 {
     fn builder(self) -> StageSetBuilder<DB> {
         StageSetBuilder::default()
-            .add_stage(HeaderStage::new(self.header_downloader, self.consensus.clone()))
-            .add_stage(TotalDifficultyStage::default())
+            .add_stage(HeaderStage::new(self.header_downloader, self.header_mode))
+            .add_stage(TotalDifficultyStage::new(self.consensus.clone()))
             .add_stage(BodyStage { downloader: self.body_downloader, consensus: self.consensus })
     }
 }
@@ -137,40 +207,47 @@ where
 /// - [`HistoryIndexingStages`]
 #[derive(Debug, Default)]
 #[non_exhaustive]
-pub struct OfflineStages;
+pub struct OfflineStages<EF: ExecutorFactory> {
+    /// Executor factory needs for execution stage
+    pub executor_factory: EF,
+}
+
+impl<EF: ExecutorFactory> OfflineStages<EF> {
+    /// Create a new set of ofline stages with default values.
+    pub fn new(executor_factory: EF) -> Self {
+        Self { executor_factory }
+    }
+}
 
-impl<DB: Database> StageSet<DB> for OfflineStages {
+impl<EF: ExecutorFactory, DB: Database> StageSet<DB> for OfflineStages<EF> {
     fn builder(self) -> StageSetBuilder<DB> {
-        ExecutionStages::default().builder().add_set(HashingStages).add_set(HistoryIndexingStages)
+        ExecutionStages::new(self.executor_factory)
+            .builder()
+            .add_set(HashingStages)
+            .add_set(HistoryIndexingStages)
     }
 }
 
 /// A set containing all stages that are required to execute pre-existing block data.
 #[derive(Debug)]
 #[non_exhaustive]
-pub struct ExecutionStages {
-    /// The chain specification to use for execution.
-    chain_spec: ChainSpec,
-}
-
-impl Default for ExecutionStages {
-    fn default() -> Self {
-        Self { chain_spec: reth_primitives::MAINNET.clone() }
-    }
+pub struct ExecutionStages<EF: ExecutorFactory> {
+    /// Executor factory that will create executors.
+    executor_factory: EF,
 }
 
-impl ExecutionStages {
+impl<EF: ExecutorFactory + 'static> ExecutionStages<EF> {
     /// Create a new set of execution stages with default values.
-    pub fn new(chain_spec: ChainSpec) -> Self {
-        Self { chain_spec }
+    pub fn new(executor_factory: EF) -> Self {
+        Self { executor_factory }
     }
 }
 
-impl<DB: Database> StageSet<DB> for ExecutionStages {
+impl<EF: ExecutorFactory, DB: Database> StageSet<DB> for ExecutionStages<EF> {
     fn builder(self) -> StageSetBuilder<DB> {
         StageSetBuilder::default()
             .add_stage(SenderRecoveryStage::default())
-            .add_stage(ExecutionStage { chain_spec: self.chain_spec, ..Default::default() })
+            .add_stage(ExecutionStage::new(self.executor_factory, 10_000))
     }
 }
 
diff --git a/crates/stages/src/stages/execution.rs b/crates/stages/src/stages/execution.rs
index 62490016b15..d0d44d8967d 100644
--- a/crates/stages/src/stages/execution.rs
+++ b/crates/stages/src/stages/execution.rs
@@ -9,12 +9,11 @@ use reth_db::{
     tables,
     transaction::{DbTx, DbTxMut},
 };
-use reth_executor::execution_result::AccountChangeSet;
 use reth_interfaces::provider::ProviderError;
-use reth_primitives::{Address, Block, ChainSpec, Hardfork, StorageEntry, H256, MAINNET, U256};
-use reth_provider::{LatestStateProviderRef, Transaction};
-use reth_revm::database::{State, SubState};
-use std::fmt::Debug;
+use reth_primitives::{Address, Block, U256};
+use reth_provider::{
+    post_state::PostState, BlockExecutor, ExecutorFactory, LatestStateProviderRef, Transaction,
+};
 use tracing::*;
 
 /// The [`StageId`] of the execution stage.
@@ -48,21 +47,27 @@ pub const EXECUTION: StageId = StageId("Execution");
 /// - [tables::AccountHistory] to remove change set and apply old values to
 /// - [tables::PlainAccountState] [tables::StorageHistory] to remove change set and apply old values
 /// to [tables::PlainStorageState]
-#[derive(Debug)]
-pub struct ExecutionStage {
-    /// Executor configuration.
-    pub chain_spec: ChainSpec,
+// false positive, we cannot derive it if !DB: Debug.
+#[allow(missing_debug_implementations)]
+pub struct ExecutionStage<EF: ExecutorFactory> {
+    /// The stage's internal executor
+    pub executor_factory: EF,
     /// Commit threshold
     pub commit_threshold: u64,
 }
 
-impl Default for ExecutionStage {
-    fn default() -> Self {
-        Self { chain_spec: MAINNET.clone(), commit_threshold: 1_000 }
+impl<EF: ExecutorFactory> ExecutionStage<EF> {
+    /// Create new execution stage with specified config.
+    pub fn new(executor_factory: EF, commit_threshold: u64) -> Self {
+        Self { executor_factory, commit_threshold }
+    }
+
+    /// Create execution stage with executor factory and default commit threshold set to 10_000
+    /// blocks
+    pub fn new_default_threshold(executor_factory: EF) -> Self {
+        Self { executor_factory, commit_threshold: 10_000 }
     }
-}
 
-impl ExecutionStage {
     /// Execute the stage.
     pub fn execute_inner<DB: Database>(
         &self,
@@ -87,7 +92,6 @@ impl ExecutionStage {
         let mut tx_cursor = tx.cursor_read::<tables::Transactions>()?;
         // Skip sender recovery and load signer from database.
         let mut tx_sender = tx.cursor_read::<tables::TxSenders>()?;
-
         // Get block headers and bodies
         let block_batch = headers_cursor
             .walk_range(start_block..=end_block)?
@@ -106,10 +110,11 @@ impl ExecutionStage {
             .collect::<Result<Vec<_>, _>>()?;
 
         // Create state provider with cached state
-        let mut state_provider = SubState::new(State::new(LatestStateProviderRef::new(&**tx)));
+
+        let mut executor = self.executor_factory.with_sp(LatestStateProviderRef::new(&**tx));
 
         // Fetch transactions, execute them and generate results
-        let mut block_change_patches = Vec::with_capacity(block_batch.len());
+        let mut changesets = PostState::default();
         for (header, td, body, ommers, withdrawals) in block_batch.into_iter() {
             let block_number = header.number;
             tracing::trace!(target: "sync::stages::execution", ?block_number, "Execute block.");
@@ -143,122 +148,20 @@ impl ExecutionStage {
 
             trace!(target: "sync::stages::execution", number = block_number, txs = transactions.len(), "Executing block");
 
-            let changeset = reth_executor::executor::execute_and_verify_receipt(
-                &Block { header, body: transactions, ommers, withdrawals },
-                td,
-                Some(signers),
-                &self.chain_spec,
-                &mut state_provider,
-            )
-            .map_err(|error| StageError::ExecutionError { block: block_number, error })?;
-            block_change_patches.push((changeset, block_number));
+            // Configure the executor to use the current state.
+            let changeset = executor
+                .execute_and_verify_receipt(
+                    &Block { header, body: transactions, ommers, withdrawals },
+                    td,
+                    Some(signers),
+                )
+                .map_err(|error| StageError::ExecutionError { block: block_number, error })?;
+            changesets.extend(changeset);
         }
 
-        // Get last tx count so that we can know amount of transaction in the block.
-        let mut current_transition_id = tx.get_block_transition(last_block)?;
-        info!(target: "sync::stages::execution", current_transition_id, blocks = block_change_patches.len(), "Inserting execution results");
-
-        // apply changes to plain database.
-        for (results, block_number) in block_change_patches.into_iter() {
-            let spurious_dragon_active =
-                self.chain_spec.fork(Hardfork::SpuriousDragon).active_at_block(block_number);
-            // insert state change set
-            for result in results.tx_changesets.into_iter() {
-                for (address, account_change_set) in result.changeset.into_iter() {
-                    let AccountChangeSet { account, wipe_storage, storage } = account_change_set;
-                    // apply account change to db. Updates AccountChangeSet and PlainAccountState
-                    // tables.
-                    trace!(target: "sync::stages::execution", ?address, current_transition_id, ?account, wipe_storage, "Applying account changeset");
-                    account.apply_to_db(
-                        &**tx,
-                        address,
-                        current_transition_id,
-                        spurious_dragon_active,
-                    )?;
-
-                    let storage_id = TransitionIdAddress((current_transition_id, address));
-
-                    // cast key to H256 and trace the change
-                    let storage = storage
-                        .into_iter()
-                        .map(|(key, (old_value,new_value))| {
-                            let hkey = H256(key.to_be_bytes());
-                            trace!(target: "sync::stages::execution", ?address, current_transition_id, ?hkey, ?old_value, ?new_value, "Applying storage changeset");
-                            (hkey, old_value,new_value)
-                        })
-                        .collect::<Vec<_>>();
-
-                    let mut cursor_storage_changeset =
-                        tx.cursor_write::<tables::StorageChangeSet>()?;
-                    cursor_storage_changeset.seek_exact(storage_id)?;
-
-                    if wipe_storage {
-                        // iterate over storage and save them before entry is deleted.
-                        tx.cursor_read::<tables::PlainStorageState>()?
-                            .walk(Some(address))?
-                            .take_while(|res| {
-                                res.as_ref().map(|(k, _)| *k == address).unwrap_or_default()
-                            })
-                            .try_for_each(|entry| {
-                                let (_, old_value) = entry?;
-                                cursor_storage_changeset.append(storage_id, old_value)
-                            })?;
-
-                        // delete all entries
-                        tx.delete::<tables::PlainStorageState>(address, None)?;
-
-                        // insert storage changeset
-                        for (key, _, new_value) in storage {
-                            // old values are already cleared.
-                            if new_value != U256::ZERO {
-                                tx.put::<tables::PlainStorageState>(
-                                    address,
-                                    StorageEntry { key, value: new_value },
-                                )?;
-                            }
-                        }
-                    } else {
-                        // insert storage changeset
-                        for (key, old_value, new_value) in storage {
-                            let old_entry = StorageEntry { key, value: old_value };
-                            let new_entry = StorageEntry { key, value: new_value };
-                            // insert into StorageChangeSet
-                            cursor_storage_changeset.append(storage_id, old_entry)?;
-
-                            // Always delete old value as duplicate table, put will not override it
-                            tx.delete::<tables::PlainStorageState>(address, Some(old_entry))?;
-                            if new_value != U256::ZERO {
-                                tx.put::<tables::PlainStorageState>(address, new_entry)?;
-                            }
-                        }
-                    }
-                }
-                // insert bytecode
-                for (hash, bytecode) in result.new_bytecodes.into_iter() {
-                    // make different types of bytecode. Checked and maybe even analyzed (needs to
-                    // be packed). Currently save only raw bytes.
-                    let bytecode = bytecode.bytes();
-                    trace!(target: "sync::stages::execution", ?hash, ?bytecode, len = bytecode.len(), "Inserting bytecode");
-                    tx.put::<tables::Bytecodes>(hash, bytecode[..bytecode.len()].to_vec())?;
-
-                    // NOTE: bytecode bytes are not inserted in change set and can be found in
-                    // separate table
-                }
-                current_transition_id += 1;
-            }
-
-            // If there are any post block changes, we will add account changesets to db.
-            for (address, changeset) in results.block_changesets.into_iter() {
-                trace!(target: "sync::stages::execution", ?address, current_transition_id, "Applying block reward");
-                changeset.apply_to_db(
-                    &**tx,
-                    address,
-                    current_transition_id,
-                    spurious_dragon_active,
-                )?;
-            }
-            current_transition_id += 1;
-        }
+        // put execution results to database
+        let first_transition_id = tx.get_block_transition(last_block)?;
+        changesets.write_to_db(&**tx, first_transition_id)?;
 
         let done = !capped;
         info!(target: "sync::stages::execution", stage_progress = end_block, done, "Sync iteration finished");
@@ -266,15 +169,8 @@ impl ExecutionStage {
     }
 }
 
-impl ExecutionStage {
-    /// Create new execution stage with specified config.
-    pub fn new(chain_spec: ChainSpec, commit_threshold: u64) -> Self {
-        Self { chain_spec, commit_threshold }
-    }
-}
-
 #[async_trait::async_trait]
-impl<DB: Database> Stage<DB> for ExecutionStage {
+impl<EF: ExecutorFactory, DB: Database> Stage<DB> for ExecutionStage<EF> {
     /// Return the id of the stage
     fn id(&self) -> StageId {
         EXECUTION
@@ -392,20 +288,29 @@ impl<DB: Database> Stage<DB> for ExecutionStage {
 
 #[cfg(test)]
 mod tests {
-    use std::ops::{Deref, DerefMut};
-
-    use crate::test_utils::{TestTransaction, PREV_STAGE_ID};
-
     use super::*;
+    use crate::test_utils::{TestTransaction, PREV_STAGE_ID};
     use reth_db::{
         mdbx::{test_utils::create_test_db, EnvKind, WriteMap},
         models::AccountBeforeTx,
     };
+    use reth_executor::Factory;
     use reth_primitives::{
-        hex_literal::hex, keccak256, Account, ChainSpecBuilder, SealedBlock, H160, U256,
+        hex_literal::hex, keccak256, Account, Bytecode, ChainSpecBuilder, SealedBlock,
+        StorageEntry, H160, H256, U256,
     };
     use reth_provider::insert_canonical_block;
     use reth_rlp::Decodable;
+    use std::{
+        ops::{Deref, DerefMut},
+        sync::Arc,
+    };
+
+    fn stage() -> ExecutionStage<Factory> {
+        let factory =
+            Factory::new(Arc::new(ChainSpecBuilder::mainnet().berlin_activated().build()));
+        ExecutionStage::new(factory, 100)
+    }
 
     #[tokio::test]
     async fn sanity_execution_of_block() {
@@ -422,8 +327,8 @@ mod tests {
         let genesis = SealedBlock::decode(&mut genesis_rlp).unwrap();
         let mut block_rlp = hex!("f90262f901f9a075c371ba45999d87f4542326910a11af515897aebce5265d3f6acd1f1161f82fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa098f2dcd87c8ae4083e7017a05456c14eea4b1db2032126e27b3b1563d57d7cc0a08151d548273f6683169524b66ca9fe338b9ce42bc3540046c828fd939ae23bcba03f4e5c2ec5b2170b711d97ee755c160457bb58d8daa338e835ec02ae6860bbabb901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083020000018502540be40082a8798203e800a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f863f861800a8405f5e10094100000000000000000000000000000000000000080801ba07e09e26678ed4fac08a249ebe8ed680bf9051a5e14ad223e4b2b9d26e0208f37a05f6e3f188e3e6eab7d7d3b6568f5eac7d687b08d307d3154ccd8c87b4630509bc0").as_slice();
         let block = SealedBlock::decode(&mut block_rlp).unwrap();
-        insert_canonical_block(tx.deref_mut(), &genesis, true).unwrap();
-        insert_canonical_block(tx.deref_mut(), &block, true).unwrap();
+        insert_canonical_block(tx.deref_mut(), genesis, None, true).unwrap();
+        insert_canonical_block(tx.deref_mut(), block.clone(), None, true).unwrap();
         tx.commit().unwrap();
 
         // insert pre state
@@ -445,14 +350,10 @@ mod tests {
                 Account { nonce: 0, balance, bytecode_hash: None },
             )
             .unwrap();
-        db_tx.put::<tables::Bytecodes>(code_hash, code.to_vec()).unwrap();
+        db_tx.put::<tables::Bytecodes>(code_hash, Bytecode::new_raw(code.to_vec().into())).unwrap();
         tx.commit().unwrap();
 
-        // execute
-        let mut execution_stage = ExecutionStage {
-            chain_spec: ChainSpecBuilder::mainnet().berlin_activated().build(),
-            ..Default::default()
-        };
+        let mut execution_stage = stage();
         let output = execution_stage.execute(&mut tx, input).await.unwrap();
         tx.commit().unwrap();
         assert_eq!(output, ExecOutput { stage_progress: 1, done: true });
@@ -515,8 +416,8 @@ mod tests {
         let genesis = SealedBlock::decode(&mut genesis_rlp).unwrap();
         let mut block_rlp = hex!("f90262f901f9a075c371ba45999d87f4542326910a11af515897aebce5265d3f6acd1f1161f82fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa098f2dcd87c8ae4083e7017a05456c14eea4b1db2032126e27b3b1563d57d7cc0a08151d548273f6683169524b66ca9fe338b9ce42bc3540046c828fd939ae23bcba03f4e5c2ec5b2170b711d97ee755c160457bb58d8daa338e835ec02ae6860bbabb901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083020000018502540be40082a8798203e800a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f863f861800a8405f5e10094100000000000000000000000000000000000000080801ba07e09e26678ed4fac08a249ebe8ed680bf9051a5e14ad223e4b2b9d26e0208f37a05f6e3f188e3e6eab7d7d3b6568f5eac7d687b08d307d3154ccd8c87b4630509bc0").as_slice();
         let block = SealedBlock::decode(&mut block_rlp).unwrap();
-        insert_canonical_block(tx.deref_mut(), &genesis, true).unwrap();
-        insert_canonical_block(tx.deref_mut(), &block, true).unwrap();
+        insert_canonical_block(tx.deref_mut(), genesis, None, true).unwrap();
+        insert_canonical_block(tx.deref_mut(), block.clone(), None, true).unwrap();
         tx.commit().unwrap();
 
         // variables
@@ -532,18 +433,16 @@ mod tests {
 
         db_tx.put::<tables::PlainAccountState>(acc1, acc1_info).unwrap();
         db_tx.put::<tables::PlainAccountState>(acc2, acc2_info).unwrap();
-        db_tx.put::<tables::Bytecodes>(code_hash, code.to_vec()).unwrap();
+        db_tx.put::<tables::Bytecodes>(code_hash, Bytecode::new_raw(code.to_vec().into())).unwrap();
         tx.commit().unwrap();
 
         // execute
-        let mut execution_stage = ExecutionStage {
-            chain_spec: ChainSpecBuilder::mainnet().berlin_activated().build(),
-            ..Default::default()
-        };
+        let mut execution_stage = stage();
         let _ = execution_stage.execute(&mut tx, input).await.unwrap();
         tx.commit().unwrap();
 
-        let o = ExecutionStage::default()
+        let mut stage = stage();
+        let o = stage
             .unwind(&mut tx, UnwindInput { stage_progress: 1, unwind_to: 0, bad_block: None })
             .await
             .unwrap();
@@ -584,8 +483,8 @@ mod tests {
         let genesis = SealedBlock::decode(&mut genesis_rlp).unwrap();
         let mut block_rlp = hex!("f9025ff901f7a0c86e8cc0310ae7c531c758678ddbfd16fc51c8cef8cec650b032de9869e8b94fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa050554882fbbda2c2fd93fdc466db9946ea262a67f7a76cc169e714f105ab583da00967f09ef1dfed20c0eacfaa94d5cd4002eda3242ac47eae68972d07b106d192a0e3c8b47fbfc94667ef4cceb17e5cc21e3b1eebd442cebb27f07562b33836290db90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000001830f42408238108203e800a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f862f860800a83061a8094095e7baea6a6c7c4c2dfeb977efac326af552d8780801ba072ed817487b84ba367d15d2f039b5fc5f087d0a8882fbdf73e8cb49357e1ce30a0403d800545b8fc544f92ce8124e2255f8c3c6af93f28243a120585d4c4c6a2a3c0").as_slice();
         let block = SealedBlock::decode(&mut block_rlp).unwrap();
-        insert_canonical_block(tx.deref_mut(), &genesis, true).unwrap();
-        insert_canonical_block(tx.deref_mut(), &block, true).unwrap();
+        insert_canonical_block(tx.deref_mut(), genesis, None, true).unwrap();
+        insert_canonical_block(tx.deref_mut(), block.clone(), None, true).unwrap();
         tx.commit().unwrap();
 
         // variables
@@ -606,7 +505,7 @@ mod tests {
         // set account
         db_tx.put::<tables::PlainAccountState>(caller_address, caller_info).unwrap();
         db_tx.put::<tables::PlainAccountState>(destroyed_address, destroyed_info).unwrap();
-        db_tx.put::<tables::Bytecodes>(code_hash, code.to_vec()).unwrap();
+        db_tx.put::<tables::Bytecodes>(code_hash, Bytecode::new_raw(code.to_vec().into())).unwrap();
         // set storage to check when account gets destroyed.
         db_tx
             .put::<tables::PlainStorageState>(
@@ -624,10 +523,7 @@ mod tests {
         tx.commit().unwrap();
 
         // execute
-        let mut execution_stage = ExecutionStage {
-            chain_spec: ChainSpecBuilder::mainnet().berlin_activated().build(),
-            ..Default::default()
-        };
+        let mut execution_stage = stage();
         let _ = execution_stage.execute(&mut tx, input).await.unwrap();
         tx.commit().unwrap();
 
diff --git a/crates/stages/src/stages/hashing_account.rs b/crates/stages/src/stages/hashing_account.rs
index ffba350c873..a129a5bcbd9 100644
--- a/crates/stages/src/stages/hashing_account.rs
+++ b/crates/stages/src/stages/hashing_account.rs
@@ -1,17 +1,14 @@
 use crate::{ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput, UnwindOutput};
+use reth_codecs::Compact;
 use reth_db::{
     cursor::{DbCursorRO, DbCursorRW},
     database::Database,
     tables,
     transaction::{DbTx, DbTxMut},
 };
-use reth_primitives::{keccak256, Account, Address};
+use reth_primitives::{keccak256, AccountHashingCheckpoint};
 use reth_provider::Transaction;
-use std::{
-    collections::{BTreeMap, BTreeSet},
-    fmt::Debug,
-    ops::Range,
-};
+use std::{collections::BTreeMap, fmt::Debug, ops::Range};
 use tracing::*;
 
 /// The [`StageId`] of the account hashing stage.
@@ -34,6 +31,43 @@ impl Default for AccountHashingStage {
     }
 }
 
+impl AccountHashingStage {
+    /// Saves the hashing progress
+    pub fn save_checkpoint<DB: Database>(
+        &mut self,
+        tx: &Transaction<'_, DB>,
+        checkpoint: AccountHashingCheckpoint,
+    ) -> Result<(), StageError> {
+        debug!(target: "sync::stages::account_hashing::exec", checkpoint = ?checkpoint, "Saving inner account hashing checkpoint");
+
+        let mut buf = vec![];
+        checkpoint.to_compact(&mut buf);
+
+        Ok(tx.put::<tables::SyncStageProgress>(ACCOUNT_HASHING.0.into(), buf)?)
+    }
+
+    /// Gets the hashing progress
+    pub fn get_checkpoint<DB: Database>(
+        &self,
+        tx: &Transaction<'_, DB>,
+    ) -> Result<AccountHashingCheckpoint, StageError> {
+        let buf =
+            tx.get::<tables::SyncStageProgress>(ACCOUNT_HASHING.0.into())?.unwrap_or_default();
+
+        if buf.is_empty() {
+            return Ok(AccountHashingCheckpoint::default())
+        }
+
+        let (checkpoint, _) = AccountHashingCheckpoint::from_compact(&buf, buf.len());
+
+        if checkpoint.address.is_some() {
+            debug!(target: "sync::stages::account_hashing::exec", checkpoint = ?checkpoint, "Continuing inner account hashing checkpoint");
+        }
+
+        Ok(checkpoint)
+    }
+}
+
 #[derive(Clone, Debug)]
 /// `SeedOpts` provides configuration parameters for calling `AccountHashingStage::seed`
 /// in unit tests or benchmarks to generate an initial database state for running the
@@ -67,12 +101,12 @@ impl AccountHashingStage {
     pub fn seed<DB: Database>(
         tx: &mut Transaction<'_, DB>,
         opts: SeedOpts,
-    ) -> Result<Vec<(Address, Account)>, StageError> {
+    ) -> Result<Vec<(reth_primitives::Address, reth_primitives::Account)>, StageError> {
         use reth_db::models::AccountBeforeTx;
         use reth_interfaces::test_utils::generators::{
             random_block_range, random_eoa_account_range,
         };
-        use reth_primitives::{H256, U256};
+        use reth_primitives::{Account, H256, U256};
         use reth_provider::insert_canonical_block;
 
         let blocks = random_block_range(opts.blocks, H256::zero(), opts.txs);
@@ -80,7 +114,7 @@ impl AccountHashingStage {
         let transitions = std::cmp::min(opts.transitions, num_transitions);
 
         for block in blocks {
-            insert_canonical_block(&**tx, &block, true).unwrap();
+            insert_canonical_block(&**tx, block, None, true).unwrap();
         }
         let mut accounts = random_eoa_account_range(opts.accounts);
         {
@@ -141,77 +175,69 @@ impl<DB: Database> Stage<DB> for AccountHashingStage {
         // AccountHashing table. Also, if we start from genesis, we need to hash from scratch, as
         // genesis accounts are not in changeset.
         if to_transition - from_transition > self.clean_threshold || stage_progress == 0 {
-            // clear table, load all accounts and hash it
-            tx.clear::<tables::HashedAccount>()?;
-            tx.commit()?;
-
-            let mut first_key = None;
-            loop {
-                let next_key = {
-                    let mut accounts = tx.cursor_read::<tables::PlainAccountState>()?;
-
-                    let hashed_batch = accounts
-                        .walk(first_key)?
-                        .take(self.commit_threshold as usize)
-                        .map(|res| res.map(|(address, account)| (keccak256(address), account)))
-                        .collect::<Result<BTreeMap<_, _>, _>>()?;
-
-                    let mut hashed_account_cursor = tx.cursor_write::<tables::HashedAccount>()?;
-
-                    // iterate and put presorted hashed accounts
-                    if first_key.is_none() {
-                        hashed_batch
-                            .into_iter()
-                            .try_for_each(|(k, v)| hashed_account_cursor.append(k, v))?;
-                    } else {
-                        hashed_batch
-                            .into_iter()
-                            .try_for_each(|(k, v)| hashed_account_cursor.insert(k, v))?;
-                    }
+            let mut checkpoint = self.get_checkpoint(tx)?;
+
+            if checkpoint.address.is_none() ||
+                // Checkpoint is no longer valid if the range of transitions changed. 
+                // An already hashed account may have been changed with the new range, and therefore should be hashed again. 
+                checkpoint.to != to_transition ||
+                checkpoint.from != from_transition
+            {
+                // clear table, load all accounts and hash it
+                tx.clear::<tables::HashedAccount>()?;
+
+                checkpoint = AccountHashingCheckpoint::default();
+                self.save_checkpoint(tx, checkpoint)?;
+            }
 
-                    // next key of iterator
-                    accounts.next()?
-                };
-                tx.commit()?;
-                if let Some((next_key, _)) = next_key {
-                    first_key = Some(next_key);
-                    continue
+            let start_address = checkpoint.address.take();
+            let next_address = {
+                let mut accounts = tx.cursor_read::<tables::PlainAccountState>()?;
+
+                let hashed_batch = accounts
+                    .walk(start_address)?
+                    .take(self.commit_threshold as usize)
+                    .map(|res| res.map(|(address, account)| (keccak256(address), account)))
+                    .collect::<Result<BTreeMap<_, _>, _>>()?;
+
+                let mut hashed_account_cursor = tx.cursor_write::<tables::HashedAccount>()?;
+
+                // iterate and put presorted hashed accounts
+                if start_address.is_none() {
+                    hashed_batch
+                        .into_iter()
+                        .try_for_each(|(k, v)| hashed_account_cursor.append(k, v))?;
+                } else {
+                    hashed_batch
+                        .into_iter()
+                        .try_for_each(|(k, v)| hashed_account_cursor.insert(k, v))?;
                 }
-                break
+
+                // next key of iterator
+                accounts.next()?
+            };
+
+            if let Some((next_address, _)) = &next_address {
+                checkpoint.address = Some(*next_address);
+                checkpoint.from = from_transition;
+                checkpoint.to = to_transition;
             }
-        } else {
-            let mut plain_accounts = tx.cursor_read::<tables::PlainAccountState>()?;
-            let mut hashed_accounts = tx.cursor_write::<tables::HashedAccount>()?;
 
+            self.save_checkpoint(tx, checkpoint)?;
+
+            if next_address.is_some() {
+                return Ok(ExecOutput { stage_progress, done: false })
+            }
+        } else {
             // Aggregate all transition changesets and and make list of account that have been
             // changed.
-            tx.cursor_read::<tables::AccountChangeSet>()?
-                .walk_range(from_transition..to_transition)?
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter()
-                // fold all account to one set of changed accounts
-                .fold(BTreeSet::new(), |mut accounts: BTreeSet<Address>, (_, account_before)| {
-                    accounts.insert(account_before.address);
-                    accounts
-                })
-                .into_iter()
-                // iterate over plain state and get newest value.
-                // Assumption we are okay to make is that plainstate represent
-                // `previous_stage_progress` state.
-                .map(|address| {
-                    plain_accounts.seek_exact(address).map(|a| (address, a.map(|(_, v)| v)))
-                })
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter()
-                .try_for_each(|(address, account)| -> Result<(), StageError> {
-                    let hashed_address = keccak256(address);
-                    if let Some(account) = account {
-                        hashed_accounts.upsert(hashed_address, account)?
-                    } else if hashed_accounts.seek_exact(hashed_address)?.is_some() {
-                        hashed_accounts.delete_current()?;
-                    }
-                    Ok(())
-                })?;
+            let lists = tx.get_addresses_of_changed_accounts(from_transition, to_transition)?;
+            // iterate over plain state and get newest value.
+            // Assumption we are okay to make is that plainstate represent
+            // `previous_stage_progress` state.
+            let accounts = tx.get_plainstate_accounts(lists.into_iter())?;
+            // insert and hash accounts to hashing table
+            tx.insert_account_for_hashing(accounts.into_iter())?;
         }
 
         info!(target: "sync::stages::hashing_account", "Stage finished");
@@ -230,37 +256,8 @@ impl<DB: Database> Stage<DB> for AccountHashingStage {
         let from_transition_rev = tx.get_block_transition(input.unwind_to)?;
         let to_transition_rev = tx.get_block_transition(input.stage_progress)?;
 
-        let mut hashed_accounts = tx.cursor_write::<tables::HashedAccount>()?;
-
         // Aggregate all transition changesets and and make list of account that have been changed.
-        tx.cursor_read::<tables::AccountChangeSet>()?
-            .walk_range(from_transition_rev..to_transition_rev)?
-            .collect::<Result<Vec<_>, _>>()?
-            .into_iter()
-            .rev()
-            // fold all account to get the old balance/nonces and account that needs to be removed
-            .fold(
-                BTreeMap::new(),
-                |mut accounts: BTreeMap<Address, Option<Account>>, (_, account_before)| {
-                    accounts.insert(account_before.address, account_before.info);
-                    accounts
-                },
-            )
-            .into_iter()
-            // hash addresses and collect it inside sorted BTreeMap.
-            // We are doing keccak only once per address.
-            .map(|(address, account)| (keccak256(address), account))
-            .collect::<BTreeMap<_, _>>()
-            .into_iter()
-            // Apply values to HashedState (if Account is None remove it);
-            .try_for_each(|(hashed_address, account)| -> Result<(), StageError> {
-                if let Some(account) = account {
-                    hashed_accounts.upsert(hashed_address, account)?;
-                } else if hashed_accounts.seek_exact(hashed_address)?.is_some() {
-                    hashed_accounts.delete_current()?;
-                }
-                Ok(())
-            })?;
+        tx.unwind_account_hashing(from_transition_rev..to_transition_rev)?;
 
         Ok(UnwindOutput { stage_progress: input.unwind_to })
     }
@@ -310,6 +307,7 @@ mod tests {
             ExecInput, ExecOutput, UnwindInput,
         };
         use reth_db::{cursor::DbCursorRO, tables, transaction::DbTx};
+        use reth_primitives::Address;
 
         pub(crate) struct AccountHashingTestRunner {
             pub(crate) tx: TestTransaction,
diff --git a/crates/stages/src/stages/hashing_storage.rs b/crates/stages/src/stages/hashing_storage.rs
index 2427d90a50f..0480e693146 100644
--- a/crates/stages/src/stages/hashing_storage.rs
+++ b/crates/stages/src/stages/hashing_storage.rs
@@ -1,18 +1,16 @@
 use crate::{ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput, UnwindOutput};
 use num_traits::Zero;
+use reth_codecs::Compact;
 use reth_db::{
-    cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO},
+    cursor::DbDupCursorRO,
     database::Database,
     models::TransitionIdAddress,
     tables,
     transaction::{DbTx, DbTxMut},
 };
-use reth_primitives::{keccak256, Address, StorageEntry, H256, U256};
+use reth_primitives::{keccak256, Address, StorageEntry, StorageHashingCheckpoint};
 use reth_provider::Transaction;
-use std::{
-    collections::{BTreeMap, BTreeSet},
-    fmt::Debug,
-};
+use std::{collections::BTreeMap, fmt::Debug};
 use tracing::*;
 
 /// The [`StageId`] of the storage hashing stage.
@@ -35,6 +33,43 @@ impl Default for StorageHashingStage {
     }
 }
 
+impl StorageHashingStage {
+    /// Saves the hashing progress
+    pub fn save_checkpoint<DB: Database>(
+        &mut self,
+        tx: &Transaction<'_, DB>,
+        checkpoint: StorageHashingCheckpoint,
+    ) -> Result<(), StageError> {
+        debug!(target: "sync::stages::storage_hashing::exec", checkpoint = ?checkpoint, "Saving inner storage hashing checkpoint");
+
+        let mut buf = vec![];
+        checkpoint.to_compact(&mut buf);
+
+        Ok(tx.put::<tables::SyncStageProgress>(STORAGE_HASHING.0.into(), buf)?)
+    }
+
+    /// Gets the hashing progress
+    pub fn get_checkpoint<DB: Database>(
+        &self,
+        tx: &Transaction<'_, DB>,
+    ) -> Result<StorageHashingCheckpoint, StageError> {
+        let buf =
+            tx.get::<tables::SyncStageProgress>(STORAGE_HASHING.0.into())?.unwrap_or_default();
+
+        if buf.is_empty() {
+            return Ok(StorageHashingCheckpoint::default())
+        }
+
+        let (checkpoint, _) = StorageHashingCheckpoint::from_compact(&buf, buf.len());
+
+        if checkpoint.address.is_some() {
+            debug!(target: "sync::stages::storage_hashing::exec", checkpoint = ?checkpoint, "Continuing inner storage hashing checkpoint");
+        }
+
+        Ok(checkpoint)
+    }
+}
+
 #[async_trait::async_trait]
 impl<DB: Database> Stage<DB> for StorageHashingStage {
     /// Return the id of the stage
@@ -60,136 +95,103 @@ impl<DB: Database> Stage<DB> for StorageHashingStage {
         // AccountHashing table. Also, if we start from genesis, we need to hash from scratch, as
         // genesis accounts are not in changeset, along with their storages.
         if to_transition - from_transition > self.clean_threshold || stage_progress == 0 {
-            tx.clear::<tables::HashedStorage>()?;
-            tx.commit()?;
+            let mut checkpoint = self.get_checkpoint(tx)?;
+
+            if checkpoint.address.is_none() ||
+                // Checkpoint is no longer valid if the range of transitions changed. 
+                // An already hashed storage may have been changed with the new range, and therefore should be hashed again. 
+                checkpoint.to != to_transition ||
+                checkpoint.from != from_transition
+            {
+                tx.clear::<tables::HashedStorage>()?;
+
+                checkpoint = StorageHashingCheckpoint::default();
+                self.save_checkpoint(tx, checkpoint)?;
+            }
 
-            let mut current_key = None;
-            let mut current_subkey = None;
+            let mut current_key = checkpoint.address.take();
+            let mut current_subkey = checkpoint.storage.take();
             let mut keccak_address = None;
 
-            loop {
-                let mut hashed_batch = BTreeMap::new();
-                let mut remaining = self.commit_threshold as usize;
-                {
-                    let mut storage = tx.cursor_dup_read::<tables::PlainStorageState>()?;
-                    while !remaining.is_zero() {
-                        hashed_batch.extend(
-                            storage
-                                .walk_dup(current_key, current_subkey)?
-                                .take(remaining)
-                                .map(|res| {
-                                    res.map(|(address, slot)| {
-                                        // Address caching for the first iteration when current_key
-                                        // is None
-                                        let keccak_address =
-                                            if let Some(keccak_address) = keccak_address {
-                                                keccak_address
-                                            } else {
-                                                keccak256(address)
-                                            };
-
-                                        // TODO cache map keccak256(slot.key) ?
-                                        ((keccak_address, keccak256(slot.key)), slot.value)
-                                    })
+            let mut hashed_batch = BTreeMap::new();
+            let mut remaining = self.commit_threshold as usize;
+            {
+                let mut storage = tx.cursor_dup_read::<tables::PlainStorageState>()?;
+                while !remaining.is_zero() {
+                    hashed_batch.extend(
+                        storage
+                            .walk_dup(current_key, current_subkey)?
+                            .take(remaining)
+                            .map(|res| {
+                                res.map(|(address, slot)| {
+                                    // Address caching for the first iteration when current_key
+                                    // is None
+                                    let keccak_address =
+                                        if let Some(keccak_address) = keccak_address {
+                                            keccak_address
+                                        } else {
+                                            keccak256(address)
+                                        };
+
+                                    // TODO cache map keccak256(slot.key) ?
+                                    ((keccak_address, keccak256(slot.key)), slot.value)
                                 })
-                                .collect::<Result<BTreeMap<_, _>, _>>()?,
-                        );
-
-                        remaining = self.commit_threshold as usize - hashed_batch.len();
-
-                        if let Some((address, slot)) = storage.next_dup()? {
-                            // There's still some remaining elements on this key, so we need to save
-                            // the cursor position for the next
-                            // iteration
-
-                            current_key = Some(address);
-                            current_subkey = Some(slot.key);
+                            })
+                            .collect::<Result<BTreeMap<_, _>, _>>()?,
+                    );
+
+                    remaining = self.commit_threshold as usize - hashed_batch.len();
+
+                    if let Some((address, slot)) = storage.next_dup()? {
+                        // There's still some remaining elements on this key, so we need to save
+                        // the cursor position for the next
+                        // iteration
+
+                        current_key = Some(address);
+                        current_subkey = Some(slot.key);
+                    } else {
+                        // Go to the next key
+                        current_key = storage.next_no_dup()?.map(|(key, _)| key);
+                        current_subkey = None;
+
+                        // Cache keccak256(address) for the next key if it exists
+                        if let Some(address) = current_key {
+                            keccak_address = Some(keccak256(address));
                         } else {
-                            // Go to the next key
-                            current_key = storage.next_no_dup()?.map(|(key, _)| key);
-                            current_subkey = None;
-
-                            // Cache keccak256(address) for the next key if it exists
-                            if let Some(address) = current_key {
-                                keccak_address = Some(keccak256(address));
-                            } else {
-                                // We have reached the end of table
-                                break
-                            }
+                            // We have reached the end of table
+                            break
                         }
                     }
                 }
+            }
 
-                // iterate and put presorted hashed slots
-                hashed_batch.into_iter().try_for_each(|((addr, key), value)| {
-                    tx.put::<tables::HashedStorage>(addr, StorageEntry { key, value })
-                })?;
+            // iterate and put presorted hashed slots
+            hashed_batch.into_iter().try_for_each(|((addr, key), value)| {
+                tx.put::<tables::HashedStorage>(addr, StorageEntry { key, value })
+            })?;
 
-                tx.commit()?;
+            if let Some(address) = &current_key {
+                checkpoint.address = Some(*address);
+                checkpoint.storage = current_subkey;
+                checkpoint.from = from_transition;
+                checkpoint.to = to_transition;
+            }
 
-                // We have reached the end of table
-                if current_key.is_none() {
-                    break
-                }
+            self.save_checkpoint(tx, checkpoint)?;
+
+            if current_key.is_some() {
+                return Ok(ExecOutput { stage_progress, done: false })
             }
         } else {
-            let mut plain_storage = tx.cursor_dup_read::<tables::PlainStorageState>()?;
-            let mut hashed_storage = tx.cursor_dup_write::<tables::HashedStorage>()?;
-
             // Aggregate all transition changesets and and make list of storages that have been
             // changed.
-            tx.cursor_read::<tables::StorageChangeSet>()?
-                .walk_range(
-                    TransitionIdAddress((from_transition, Address::zero()))..
-                        TransitionIdAddress((to_transition, Address::zero())),
-                )?
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter()
-                // fold all storages and save its old state so we can remove it from HashedStorage
-                // it is needed as it is dup table.
-                .fold(
-                    BTreeMap::new(),
-                    |mut accounts: BTreeMap<Address, BTreeSet<H256>>,
-                     (TransitionIdAddress((_, address)), storage_entry)| {
-                        accounts.entry(address).or_default().insert(storage_entry.key);
-                        accounts
-                    },
-                )
-                .into_iter()
-                // iterate over plain state and get newest storage value.
-                // Assumption we are okay with is that plain state represent
-                // `previous_stage_progress` state.
-                .map(|(address, storage)| {
-                    storage
-                        .into_iter()
-                        .map(|key| {
-                            plain_storage
-                                .seek_by_key_subkey(address, key)
-                                .map(|ret| (keccak256(key), ret.map(|e| e.value)))
-                        })
-                        .collect::<Result<BTreeMap<_, _>, _>>()
-                        .map(|storage| (keccak256(address), storage))
-                })
-                .collect::<Result<BTreeMap<_, _>, _>>()?
-                .into_iter()
-                // Hash the address and key and apply them to HashedStorage (if Storage is None
-                // just remove it);
-                .try_for_each(|(address, storage)| {
-                    storage.into_iter().try_for_each(|(key, val)| -> Result<(), StageError> {
-                        if hashed_storage
-                            .seek_by_key_subkey(address, key)?
-                            .filter(|entry| entry.key == key)
-                            .is_some()
-                        {
-                            hashed_storage.delete_current()?;
-                        }
-
-                        if let Some(value) = val {
-                            hashed_storage.upsert(address, StorageEntry { key, value })?;
-                        }
-                        Ok(())
-                    })
-                })?;
+            let lists =
+                tx.get_addresses_and_keys_of_changed_storages(from_transition, to_transition)?;
+            // iterate over plain state and get newest storage value.
+            // Assumption we are okay with is that plain state represent
+            // `previous_stage_progress` state.
+            let storages = tx.get_plainstate_storages(lists.into_iter())?;
+            tx.insert_storage_for_hashing(storages.into_iter())?;
         }
 
         info!(target: "sync::stages::hashing_storage", "Stage finished");
@@ -205,47 +207,10 @@ impl<DB: Database> Stage<DB> for StorageHashingStage {
         let from_transition_rev = tx.get_block_transition(input.unwind_to)?;
         let to_transition_rev = tx.get_block_transition(input.stage_progress)?;
 
-        let mut hashed_storage = tx.cursor_dup_write::<tables::HashedStorage>()?;
-
-        // Aggregate all transition changesets and make list of accounts that have been changed.
-        tx.cursor_read::<tables::StorageChangeSet>()?
-            .walk_range(
-                TransitionIdAddress((from_transition_rev, Address::zero()))..
-                    TransitionIdAddress((to_transition_rev, Address::zero())),
-            )?
-            .collect::<Result<Vec<_>, _>>()?
-            .into_iter()
-            .rev()
-            // fold all account to get the old balance/nonces and account that needs to be removed
-            .fold(
-                BTreeMap::new(),
-                |mut accounts: BTreeMap<(Address, H256), U256>,
-                 (TransitionIdAddress((_, address)), storage_entry)| {
-                    accounts.insert((address, storage_entry.key), storage_entry.value);
-                    accounts
-                },
-            )
-            .into_iter()
-            // hash addresses and collect it inside sorted BTreeMap.
-            // We are doing keccak only once per address.
-            .map(|((address, key), value)| ((keccak256(address), keccak256(key)), value))
-            .collect::<BTreeMap<_, _>>()
-            .into_iter()
-            // Apply values to HashedStorage (if Value is zero just remove it);
-            .try_for_each(|((address, key), value)| -> Result<(), StageError> {
-                if hashed_storage
-                    .seek_by_key_subkey(address, key)?
-                    .filter(|entry| entry.key == key)
-                    .is_some()
-                {
-                    hashed_storage.delete_current()?;
-                }
-
-                if value != U256::ZERO {
-                    hashed_storage.upsert(address, StorageEntry { key, value })?;
-                }
-                Ok(())
-            })?;
+        tx.unwind_storage_hashing(
+            TransitionIdAddress((from_transition_rev, Address::zero()))..
+                TransitionIdAddress((to_transition_rev, Address::zero())),
+        )?;
 
         Ok(UnwindOutput { stage_progress: input.unwind_to })
     }
@@ -258,9 +223,8 @@ mod tests {
         stage_test_suite_ext, ExecuteStageTestRunner, StageTestRunner, TestRunnerError,
         TestTransaction, UnwindStageTestRunner, PREV_STAGE_ID,
     };
-    use assert_matches::assert_matches;
     use reth_db::{
-        cursor::DbCursorRW,
+        cursor::{DbCursorRO, DbCursorRW},
         mdbx::{tx::Tx, WriteMap, RW},
         models::{StoredBlockBody, TransitionIdAddress},
     };
@@ -293,18 +257,25 @@ mod tests {
 
         runner.seed_execution(input).expect("failed to seed execution");
 
-        let rx = runner.execute(input);
+        loop {
+            if let Ok(result) = runner.execute(input).await.unwrap() {
+                if !result.done {
+                    // Continue from checkpoint
+                    continue
+                } else {
+                    assert!(result.stage_progress == previous_stage);
 
-        // Assert the successful result
-        let result = rx.await.unwrap();
-        assert_matches!(
-            result,
-            Ok(ExecOutput { done, stage_progress })
-                if done && stage_progress == previous_stage
-        );
+                    // Validate the stage execution
+                    assert!(
+                        runner.validate_execution(input, Some(result)).is_ok(),
+                        "execution validation"
+                    );
 
-        // Validate the stage execution
-        assert!(runner.validate_execution(input, result.ok()).is_ok(), "execution validation");
+                    break
+                }
+            }
+            panic!("Failed execution");
+        }
     }
 
     struct StorageHashingTestRunner {
diff --git a/crates/stages/src/stages/headers.rs b/crates/stages/src/stages/headers.rs
index ef258ce2cf1..a628069f853 100644
--- a/crates/stages/src/stages/headers.rs
+++ b/crates/stages/src/stages/headers.rs
@@ -7,18 +7,28 @@ use reth_db::{
     transaction::{DbTx, DbTxMut},
 };
 use reth_interfaces::{
-    consensus::{Consensus, ForkchoiceState},
     p2p::headers::downloader::{HeaderDownloader, SyncTarget},
     provider::ProviderError,
 };
-use reth_primitives::{BlockNumber, SealedHeader};
+use reth_primitives::{BlockHashOrNumber, BlockNumber, SealedHeader, H256};
 use reth_provider::Transaction;
-use std::sync::Arc;
+use tokio::sync::watch;
 use tracing::*;
 
 /// The [`StageId`] of the headers downloader stage.
 pub const HEADERS: StageId = StageId("Headers");
 
+/// The header sync mode.
+#[derive(Debug)]
+pub enum HeaderSyncMode {
+    /// A sync mode in which the stage continuously requests the downloader for
+    /// next blocks.
+    Continuous,
+    /// A sync mode in which the stage polls the receiver for the next tip
+    /// to download from.
+    Tip(watch::Receiver<H256>),
+}
+
 /// The headers stage.
 ///
 /// The headers stage downloads all block headers from the highest block in the local database to
@@ -36,8 +46,8 @@ pub const HEADERS: StageId = StageId("Headers");
 pub struct HeaderStage<D: HeaderDownloader> {
     /// Strategy for downloading the headers
     downloader: D,
-    /// Consensus client implementation
-    consensus: Arc<dyn Consensus>,
+    /// The sync mode for the stage.
+    mode: HeaderSyncMode,
 }
 
 // === impl HeaderStage ===
@@ -47,8 +57,8 @@ where
     D: HeaderDownloader,
 {
     /// Create a new header stage
-    pub fn new(downloader: D, consensus: Arc<dyn Consensus>) -> Self {
-        Self { downloader, consensus }
+    pub fn new(downloader: D, mode: HeaderSyncMode) -> Self {
+        Self { downloader, mode }
     }
 
     fn is_stage_done<DB: Database>(
@@ -68,7 +78,7 @@ where
     ///
     /// See also [SyncTarget]
     async fn get_sync_gap<DB: Database>(
-        &self,
+        &mut self,
         tx: &Transaction<'_, DB>,
         stage_progress: u64,
     ) -> Result<SyncGap, StageError> {
@@ -104,21 +114,27 @@ where
         // reverse from there. Else, it should use whatever the forkchoice state reports.
         let target = match next_header {
             Some(header) if stage_progress + 1 != header.number => SyncTarget::Gap(header),
-            None => SyncTarget::Tip(self.next_fork_choice_state().await.head_block_hash),
+            None => self.next_sync_target(head_num).await,
             _ => return Err(StageError::StageProgress(stage_progress)),
         };
 
         Ok(SyncGap { local_head, target })
     }
 
-    /// Awaits the next [ForkchoiceState] message from [Consensus] with a non-zero block hash
-    async fn next_fork_choice_state(&self) -> ForkchoiceState {
-        let mut state_rcv = self.consensus.fork_choice_state();
-        loop {
-            let _ = state_rcv.changed().await;
-            let forkchoice = state_rcv.borrow();
-            if !forkchoice.head_block_hash.is_zero() {
-                return forkchoice.clone()
+    async fn next_sync_target(&mut self, head: BlockNumber) -> SyncTarget {
+        match self.mode {
+            HeaderSyncMode::Tip(ref mut rx) => {
+                loop {
+                    let _ = rx.changed().await; // TODO: remove this await?
+                    let tip = rx.borrow();
+                    if !tip.is_zero() {
+                        return SyncTarget::Tip(*tip)
+                    }
+                }
+            }
+            HeaderSyncMode::Continuous => {
+                tracing::trace!(target: "sync::stages::headers", head, "No next header found, using continuous sync strategy");
+                SyncTarget::TipNum(head + 1)
             }
         }
     }
@@ -236,9 +252,12 @@ where
 
 /// Represents a gap to sync: from `local_head` to `target`
 #[derive(Debug)]
-struct SyncGap {
-    local_head: SealedHeader,
-    target: SyncTarget,
+pub struct SyncGap {
+    /// The local head block. Represents lower bound of sync range.
+    pub local_head: SealedHeader,
+
+    /// The sync target. Represents upper bound of sync range.
+    pub target: SyncTarget,
 }
 
 // === impl SyncGap ===
@@ -246,8 +265,11 @@ struct SyncGap {
 impl SyncGap {
     /// Returns `true` if the gap from the head to the target was closed
     #[inline]
-    fn is_closed(&self) -> bool {
-        self.local_head.hash() == self.target.tip()
+    pub fn is_closed(&self) -> bool {
+        match self.target.tip() {
+            BlockHashOrNumber::Hash(hash) => self.local_head.hash() == hash,
+            BlockHashOrNumber::Number(num) => self.local_head.number == num,
+        }
     }
 }
 
@@ -264,35 +286,20 @@ mod tests {
     use test_runner::HeadersTestRunner;
 
     mod test_runner {
-        use crate::{
-            stages::headers::HeaderStage,
-            test_utils::{
-                ExecuteStageTestRunner, StageTestRunner, TestRunnerError, TestTransaction,
-                UnwindStageTestRunner,
-            },
-            ExecInput, ExecOutput, UnwindInput,
-        };
-        use reth_db::{
-            tables,
-            transaction::{DbTx, DbTxMut},
-        };
+        use super::*;
+        use crate::test_utils::{TestRunnerError, TestTransaction};
         use reth_downloaders::headers::reverse_headers::{
             ReverseHeadersDownloader, ReverseHeadersDownloaderBuilder,
         };
-        use reth_interfaces::{
-            consensus::ForkchoiceState,
-            p2p::headers::downloader::HeaderDownloader,
-            test_utils::{
-                generators::{random_header, random_header_range},
-                TestConsensus, TestHeaderDownloader, TestHeadersClient,
-            },
+        use reth_interfaces::test_utils::{
+            generators::random_header_range, TestConsensus, TestHeaderDownloader, TestHeadersClient,
         };
-        use reth_primitives::{BlockNumber, SealedHeader, U256};
+        use reth_primitives::U256;
         use std::sync::Arc;
 
         pub(crate) struct HeadersTestRunner<D: HeaderDownloader> {
-            pub(crate) consensus: Arc<TestConsensus>,
             pub(crate) client: Arc<TestHeadersClient>,
+            channel: (watch::Sender<H256>, watch::Receiver<H256>),
             downloader_factory: Box<dyn Fn() -> D + Send + Sync + 'static>,
             tx: TestTransaction,
         }
@@ -300,12 +307,16 @@ mod tests {
         impl Default for HeadersTestRunner<TestHeaderDownloader> {
             fn default() -> Self {
                 let client = Arc::new(TestHeadersClient::default());
-                let consensus = Arc::new(TestConsensus::default());
                 Self {
                     client: client.clone(),
-                    consensus: consensus.clone(),
+                    channel: watch::channel(H256::zero()),
                     downloader_factory: Box::new(move || {
-                        TestHeaderDownloader::new(client.clone(), consensus.clone(), 1000, 1000)
+                        TestHeaderDownloader::new(
+                            client.clone(),
+                            Arc::new(TestConsensus::default()),
+                            1000,
+                            1000,
+                        )
                     }),
                     tx: TestTransaction::default(),
                 }
@@ -321,7 +332,7 @@ mod tests {
 
             fn stage(&self) -> Self::S {
                 HeaderStage {
-                    consensus: self.consensus.clone(),
+                    mode: HeaderSyncMode::Tip(self.channel.1.clone()),
                     downloader: (*self.downloader_factory)(),
                 }
             }
@@ -392,12 +403,7 @@ mod tests {
                     self.tx.insert_headers(std::iter::once(&tip))?;
                     tip.hash()
                 };
-                self.consensus
-                    .notify_fork_choice_state(ForkchoiceState {
-                        head_block_hash: tip,
-                        ..Default::default()
-                    })
-                    .expect("Setting tip failed");
+                self.send_tip(tip);
                 Ok(())
             }
         }
@@ -411,14 +417,13 @@ mod tests {
         impl HeadersTestRunner<ReverseHeadersDownloader<TestHeadersClient>> {
             pub(crate) fn with_linear_downloader() -> Self {
                 let client = Arc::new(TestHeadersClient::default());
-                let consensus = Arc::new(TestConsensus::default());
                 Self {
                     client: client.clone(),
-                    consensus: consensus.clone(),
+                    channel: watch::channel(H256::zero()),
                     downloader_factory: Box::new(move || {
                         ReverseHeadersDownloaderBuilder::default()
                             .stream_batch_size(500)
-                            .build(client.clone(), consensus.clone())
+                            .build(client.clone(), Arc::new(TestConsensus::default()))
                     }),
                     tx: TestTransaction::default(),
                 }
@@ -436,6 +441,10 @@ mod tests {
                 self.tx.ensure_no_entry_above::<tables::Headers, _>(block, |key| key)?;
                 Ok(())
             }
+
+            pub(crate) fn send_tip(&self, tip: H256) {
+                self.channel.0.send(tip).expect("failed to send tip");
+            }
         }
     }
 
@@ -457,13 +466,7 @@ mod tests {
 
         // skip `after_execution` hook for linear downloader
         let tip = headers.last().unwrap();
-        runner
-            .consensus
-            .notify_fork_choice_state(ForkchoiceState {
-                head_block_hash: tip.hash(),
-                ..Default::default()
-            })
-            .expect("Setting tip failed");
+        runner.send_tip(tip.hash());
 
         let result = rx.await.unwrap();
         assert_matches!(result, Ok(ExecOutput { done: true, stage_progress }) if stage_progress == tip.number);
@@ -475,16 +478,10 @@ mod tests {
     async fn head_and_tip_lookup() {
         let runner = HeadersTestRunner::default();
         let tx = runner.tx().inner();
-        let stage = runner.stage();
+        let mut stage = runner.stage();
 
         let consensus_tip = H256::random();
-        runner
-            .consensus
-            .notify_fork_choice_state(ForkchoiceState {
-                head_block_hash: consensus_tip,
-                ..Default::default()
-            })
-            .expect("Setting tip failed");
+        runner.send_tip(consensus_tip);
 
         // Genesis
         let stage_progress = 0;
@@ -507,7 +504,7 @@ mod tests {
 
         let gap = stage.get_sync_gap(&tx, stage_progress).await.unwrap();
         assert_eq!(gap.local_head, head);
-        assert_eq!(gap.target.tip(), consensus_tip);
+        assert_eq!(gap.target.tip(), consensus_tip.into());
 
         // Checkpoint and gap
         tx.put::<tables::CanonicalHeaders>(gap_tip.number, gap_tip.hash())
@@ -517,7 +514,7 @@ mod tests {
 
         let gap = stage.get_sync_gap(&tx, stage_progress).await.unwrap();
         assert_eq!(gap.local_head, head);
-        assert_eq!(gap.target.tip(), gap_tip.parent_hash);
+        assert_eq!(gap.target.tip(), gap_tip.parent_hash.into());
 
         // Checkpoint and gap closed
         tx.put::<tables::CanonicalHeaders>(gap_fill.number, gap_fill.hash())
@@ -548,13 +545,7 @@ mod tests {
 
         // skip `after_execution` hook for linear downloader
         let tip = headers.last().unwrap();
-        runner
-            .consensus
-            .notify_fork_choice_state(ForkchoiceState {
-                head_block_hash: tip.hash(),
-                ..Default::default()
-            })
-            .expect("Setting tip failed");
+        runner.send_tip(tip.hash());
 
         let result = rx.await.unwrap();
         assert_matches!(result, Ok(ExecOutput { done: false, stage_progress: progress }) if progress == stage_progress);
diff --git a/crates/stages/src/stages/index_account_history.rs b/crates/stages/src/stages/index_account_history.rs
index 5ff888019a2..55ea9a3233d 100644
--- a/crates/stages/src/stages/index_account_history.rs
+++ b/crates/stages/src/stages/index_account_history.rs
@@ -1,17 +1,7 @@
 use crate::{ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput, UnwindOutput};
-use itertools::Itertools;
-use reth_db::{
-    cursor::{DbCursorRO, DbCursorRW},
-    database::{Database, DatabaseGAT},
-    models::{sharded_key::NUM_OF_INDICES_IN_SHARD, ShardedKey},
-    tables,
-    transaction::{DbTx, DbTxMut, DbTxMutGAT},
-    TransitionList,
-};
+use reth_db::database::Database;
 use reth_provider::Transaction;
-
-use reth_primitives::{Address, TransitionId};
-use std::{collections::BTreeMap, fmt::Debug};
+use std::fmt::Debug;
 use tracing::*;
 
 /// The [`StageId`] of the account history indexing stage.
@@ -19,7 +9,7 @@ pub const INDEX_ACCOUNT_HISTORY: StageId = StageId("IndexAccountHistory");
 
 /// Stage is indexing history the account changesets generated in
 /// [`ExecutionStage`][crate::stages::ExecutionStage]. For more information
-/// on index sharding take a look at [`tables::AccountHistory`]
+/// on index sharding take a look at [`reth_db::tables::AccountHistory`]
 #[derive(Debug)]
 pub struct IndexAccountHistoryStage {
     /// Number of blocks after which the control
@@ -57,52 +47,10 @@ impl<DB: Database> Stage<DB> for IndexAccountHistoryStage {
             std::cmp::min(stage_progress + self.commit_threshold, previous_stage_progress);
         let to_transition = tx.get_block_transition(to_block)?;
 
-        let account_changesets = tx
-            .cursor_read::<tables::AccountChangeSet>()?
-            .walk(Some(from_transition))?
-            .take_while(|res| res.as_ref().map(|(k, _)| *k < to_transition).unwrap_or_default())
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let account_changeset_lists = account_changesets
-            .into_iter()
-            // fold all account to one set of changed accounts
-            .fold(
-                BTreeMap::new(),
-                |mut accounts: BTreeMap<Address, Vec<u64>>, (index, account)| {
-                    accounts.entry(account.address).or_default().push(index);
-                    accounts
-                },
-            );
-        // insert indexes to AccontHistory.
-        for (address, mut indices) in account_changeset_lists {
-            let mut last_shard = take_last_account_shard(tx, address)?;
-            last_shard.append(&mut indices);
-            // chunk indices and insert them in shards of N size.
-            let mut chunks = last_shard
-                .iter()
-                .chunks(NUM_OF_INDICES_IN_SHARD)
-                .into_iter()
-                .map(|chunks| chunks.map(|i| *i as usize).collect::<Vec<usize>>())
-                .collect::<Vec<_>>();
-            let last_chunk = chunks.pop();
-
-            chunks.into_iter().try_for_each(|list| {
-                tx.put::<tables::AccountHistory>(
-                    ShardedKey::new(
-                        address,
-                        *list.last().expect("Chuck does not return empty list") as TransitionId,
-                    ),
-                    TransitionList::new(list).expect("Indices are presorted and not empty"),
-                )
-            })?;
-            // Insert last list with u64::MAX
-            if let Some(last_list) = last_chunk {
-                tx.put::<tables::AccountHistory>(
-                    ShardedKey::new(address, u64::MAX),
-                    TransitionList::new(last_list).expect("Indices are presorted and not empty"),
-                )?
-            }
-        }
+        let indices =
+            tx.get_account_transition_ids_from_changeset(from_transition, to_transition)?;
+        // Insert changeset to history index
+        tx.insert_account_history_index(indices)?;
 
         info!(target: "sync::stages::index_account_history", "Stage finished");
         Ok(ExecOutput { stage_progress: to_block, done: true })
@@ -118,101 +66,25 @@ impl<DB: Database> Stage<DB> for IndexAccountHistoryStage {
         let from_transition_rev = tx.get_block_transition(input.unwind_to)?;
         let to_transition_rev = tx.get_block_transition(input.stage_progress)?;
 
-        let mut cursor = tx.cursor_write::<tables::AccountHistory>()?;
+        tx.unwind_account_history_indices(from_transition_rev..to_transition_rev)?;
 
-        let account_changeset = tx
-            .cursor_read::<tables::AccountChangeSet>()?
-            .walk(Some(from_transition_rev))?
-            .take_while(|res| res.as_ref().map(|(k, _)| *k < to_transition_rev).unwrap_or_default())
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let last_indices = account_changeset
-            .into_iter()
-            // reverse so we can get lowest transition id where we need to unwind account.
-            .rev()
-            // fold all account and get last transition index
-            .fold(BTreeMap::new(), |mut accounts: BTreeMap<Address, u64>, (index, account)| {
-                // we just need address and lowest transition id.
-                accounts.insert(account.address, index);
-                accounts
-            });
-        // try to unwind the index
-        for (address, rem_index) in last_indices {
-            let shard_part = unwind_account_history_shards::<DB>(&mut cursor, address, rem_index)?;
-
-            // check last shard_part, if present, items needs to be reinserted.
-            if !shard_part.is_empty() {
-                // there are items in list
-                tx.put::<tables::AccountHistory>(
-                    ShardedKey::new(address, u64::MAX),
-                    TransitionList::new(shard_part)
-                        .expect("There is at least one element in list and it is sorted."),
-                )?;
-            }
-        }
         // from HistoryIndex higher than that number.
         Ok(UnwindOutput { stage_progress: input.unwind_to })
     }
 }
 
-/// Load last shard and check if it is full and remove if it is not. If list is empty, last shard
-/// was full or there is no shards at all.
-pub fn take_last_account_shard<DB: Database>(
-    tx: &Transaction<'_, DB>,
-    address: Address,
-) -> Result<Vec<u64>, StageError> {
-    let mut cursor = tx.cursor_read::<tables::AccountHistory>()?;
-    let last = cursor.seek_exact(ShardedKey::new(address, u64::MAX))?;
-    if let Some((shard_key, list)) = last {
-        // delete old shard so new one can be inserted.
-        tx.delete::<tables::AccountHistory>(shard_key, None)?;
-        let list = list.iter(0).map(|i| i as u64).collect::<Vec<_>>();
-        return Ok(list)
-    }
-    Ok(Vec::new())
-}
-
-/// Unwind all history shards. For boundary shard, remove it from database and
-/// return last part of shard with still valid items. If all full shard were removed, return list
-/// would be empty.
-pub fn unwind_account_history_shards<DB: Database>(
-    cursor: &mut <<DB as DatabaseGAT<'_>>::TXMut as DbTxMutGAT<'_>>::CursorMut<
-        tables::AccountHistory,
-    >,
-    address: Address,
-    transition_id: TransitionId,
-) -> Result<Vec<usize>, StageError> {
-    let mut item = cursor.seek_exact(ShardedKey::new(address, u64::MAX))?;
-
-    while let Some((sharded_key, list)) = item {
-        // there is no more shard for address
-        if sharded_key.key != address {
-            break
-        }
-        cursor.delete_current()?;
-        // check first item and if it is more and eq than `transition_id` delete current
-        // item.
-        let first = list.iter(0).next().expect("List can't empty");
-        if first >= transition_id as usize {
-            item = cursor.prev()?;
-            continue
-        } else if transition_id <= sharded_key.highest_transition_id {
-            // if first element is in scope whole list would be removed.
-            // so at least this first element is present.
-            return Ok(list.iter(0).take_while(|i| *i < transition_id as usize).collect::<Vec<_>>())
-        } else {
-            let new_list = list.iter(0).collect::<Vec<_>>();
-            return Ok(new_list)
-        }
-    }
-    Ok(Vec::new())
-}
-
 #[cfg(test)]
 mod tests {
+    use std::collections::BTreeMap;
+
     use super::*;
     use crate::test_utils::{TestTransaction, PREV_STAGE_ID};
-    use reth_db::models::AccountBeforeTx;
+    use reth_db::{
+        models::{sharded_key::NUM_OF_INDICES_IN_SHARD, AccountBeforeTx, ShardedKey},
+        tables,
+        transaction::DbTxMut,
+        TransitionList,
+    };
     use reth_primitives::{hex_literal::hex, H160};
 
     const ADDRESS: H160 = H160(hex!("0000000000000000000000000000000000000001"));
@@ -258,8 +130,8 @@ mod tests {
     }
 
     async fn run(tx: &TestTransaction, run_to: u64) {
-        let mut input = ExecInput::default();
-        input.previous_stage = Some((PREV_STAGE_ID, run_to));
+        let input =
+            ExecInput { previous_stage: Some((PREV_STAGE_ID, run_to)), ..Default::default() };
         let mut stage = IndexAccountHistoryStage::default();
         let mut tx = tx.inner();
         let out = stage.execute(&mut tx, input).await.unwrap();
@@ -268,9 +140,7 @@ mod tests {
     }
 
     async fn unwind(tx: &TestTransaction, unwind_from: u64, unwind_to: u64) {
-        let mut input = UnwindInput::default();
-        input.stage_progress = unwind_from;
-        input.unwind_to = unwind_to;
+        let input = UnwindInput { stage_progress: unwind_from, unwind_to, ..Default::default() };
         let mut stage = IndexAccountHistoryStage::default();
         let mut tx = tx.inner();
         let out = stage.unwind(&mut tx, input).await.unwrap();
diff --git a/crates/stages/src/stages/index_storage_history.rs b/crates/stages/src/stages/index_storage_history.rs
index 576ff0bd5c0..6431d12f58f 100644
--- a/crates/stages/src/stages/index_storage_history.rs
+++ b/crates/stages/src/stages/index_storage_history.rs
@@ -1,16 +1,8 @@
 use crate::{ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput, UnwindOutput};
-use itertools::Itertools;
-use reth_db::{
-    cursor::{DbCursorRO, DbCursorRW},
-    database::{Database, DatabaseGAT},
-    models::{sharded_key::NUM_OF_INDICES_IN_SHARD, storage_sharded_key::StorageShardedKey},
-    tables,
-    transaction::{DbTx, DbTxMut, DbTxMutGAT},
-    TransitionList,
-};
-use reth_primitives::{Address, TransitionId, H256};
+use reth_db::{database::Database, models::TransitionIdAddress};
+use reth_primitives::Address;
 use reth_provider::Transaction;
-use std::{collections::BTreeMap, fmt::Debug};
+use std::fmt::Debug;
 use tracing::*;
 
 /// The [`StageId`] of the storage history indexing stage.
@@ -18,7 +10,7 @@ pub const INDEX_STORAGE_HISTORY: StageId = StageId("IndexStorageHistory");
 
 /// Stage is indexing history the account changesets generated in
 /// [`ExecutionStage`][crate::stages::ExecutionStage]. For more information
-/// on index sharding take a look at [`tables::StorageHistory`].
+/// on index sharding take a look at [`reth_db::tables::StorageHistory`].
 #[derive(Debug)]
 pub struct IndexStorageHistoryStage {
     /// Number of blocks after which the control
@@ -57,58 +49,9 @@ impl<DB: Database> Stage<DB> for IndexStorageHistoryStage {
             std::cmp::min(stage_progress + self.commit_threshold, previous_stage_progress);
         let to_transition = tx.get_block_transition(to_block)?;
 
-        let storage_chageset = tx
-            .cursor_read::<tables::StorageChangeSet>()?
-            .walk(Some((from_transition, Address::zero()).into()))?
-            .take_while(|res| {
-                res.as_ref().map(|(k, _)| k.transition_id() < to_transition).unwrap_or_default()
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        // fold all storages to one set of changes
-        let storage_changeset_lists = storage_chageset.into_iter().fold(
-            BTreeMap::new(),
-            |mut storages: BTreeMap<(Address, H256), Vec<u64>>, (index, storage)| {
-                storages
-                    .entry((index.address(), storage.key))
-                    .or_default()
-                    .push(index.transition_id());
-                storages
-            },
-        );
-
-        for ((address, storage_key), mut indices) in storage_changeset_lists {
-            let mut last_shard = take_last_storage_shard(tx, address, storage_key)?;
-            last_shard.append(&mut indices);
-
-            // chunk indices and insert them in shards of N size.
-            let mut chunks = last_shard
-                .iter()
-                .chunks(NUM_OF_INDICES_IN_SHARD)
-                .into_iter()
-                .map(|chunks| chunks.map(|i| *i as usize).collect::<Vec<usize>>())
-                .collect::<Vec<_>>();
-            let last_chunk = chunks.pop();
-
-            // chunk indices and insert them in shards of N size.
-            chunks.into_iter().try_for_each(|list| {
-                tx.put::<tables::StorageHistory>(
-                    StorageShardedKey::new(
-                        address,
-                        storage_key,
-                        *list.last().expect("Chuck does not return empty list") as TransitionId,
-                    ),
-                    TransitionList::new(list).expect("Indices are presorted and not empty"),
-                )
-            })?;
-            // Insert last list with u64::MAX
-            if let Some(last_list) = last_chunk {
-                tx.put::<tables::StorageHistory>(
-                    StorageShardedKey::new(address, storage_key, u64::MAX),
-                    TransitionList::new(last_list).expect("Indices are presorted and not empty"),
-                )?;
-            }
-        }
+        let indices =
+            tx.get_storage_transition_ids_from_changeset(from_transition, to_transition)?;
+        tx.insert_storage_history_index(indices)?;
 
         info!(target: "sync::stages::index_storage_history", "Stage finished");
         Ok(ExecOutput { stage_progress: to_block, done: true })
@@ -124,110 +67,32 @@ impl<DB: Database> Stage<DB> for IndexStorageHistoryStage {
         let from_transition_rev = tx.get_block_transition(input.unwind_to)?;
         let to_transition_rev = tx.get_block_transition(input.stage_progress)?;
 
-        let mut cursor = tx.cursor_write::<tables::StorageHistory>()?;
+        tx.unwind_storage_history_indices(
+            TransitionIdAddress((from_transition_rev, Address::zero()))..
+                TransitionIdAddress((to_transition_rev, Address::zero())),
+        )?;
 
-        let storage_changesets = tx
-            .cursor_read::<tables::StorageChangeSet>()?
-            .walk(Some((from_transition_rev, Address::zero()).into()))?
-            .take_while(|res| {
-                res.as_ref().map(|(k, _)| k.transition_id() < to_transition_rev).unwrap_or_default()
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        let last_indices = storage_changesets
-            .into_iter()
-            // reverse so we can get lowest transition id where we need to unwind account.
-            .rev()
-            // fold all storages and get last transition index
-            .fold(
-                BTreeMap::new(),
-                |mut accounts: BTreeMap<(Address, H256), u64>, (index, storage)| {
-                    // we just need address and lowest transition id.
-                    accounts.insert((index.address(), storage.key), index.transition_id());
-                    accounts
-                },
-            );
-        for ((address, storage_key), rem_index) in last_indices {
-            let shard_part =
-                unwind_storage_history_shards::<DB>(&mut cursor, address, storage_key, rem_index)?;
-
-            // check last shard_part, if present, items needs to be reinserted.
-            if !shard_part.is_empty() {
-                // there are items in list
-                tx.put::<tables::StorageHistory>(
-                    StorageShardedKey::new(address, storage_key, u64::MAX),
-                    TransitionList::new(shard_part)
-                        .expect("There is at least one element in list and it is sorted."),
-                )?;
-            }
-        }
         Ok(UnwindOutput { stage_progress: input.unwind_to })
     }
 }
 
-/// Load last shard and check if it is full and remove if it is not. If list is empty, last shard
-/// was full or there is no shards at all.
-pub fn take_last_storage_shard<DB: Database>(
-    tx: &Transaction<'_, DB>,
-    address: Address,
-    storage_key: H256,
-) -> Result<Vec<u64>, StageError> {
-    let mut cursor = tx.cursor_read::<tables::StorageHistory>()?;
-    let last = cursor.seek_exact(StorageShardedKey::new(address, storage_key, u64::MAX))?;
-    if let Some((storage_shard_key, list)) = last {
-        // delete old shard so new one can be inserted.
-        tx.delete::<tables::StorageHistory>(storage_shard_key, None)?;
-        let list = list.iter(0).map(|i| i as u64).collect::<Vec<_>>();
-        return Ok(list)
-    }
-    Ok(Vec::new())
-}
-
-/// Unwind all history shards. For boundary shard, remove it from database and
-/// return last part of shard with still valid items. If all full shard were removed, return list
-/// would be empty but this does not mean that there is none shard left but that there is no
-/// splitted shards.
-pub fn unwind_storage_history_shards<DB: Database>(
-    cursor: &mut <<DB as DatabaseGAT<'_>>::TXMut as DbTxMutGAT<'_>>::CursorMut<
-        tables::StorageHistory,
-    >,
-    address: Address,
-    storage_key: H256,
-    transition_id: TransitionId,
-) -> Result<Vec<usize>, StageError> {
-    let mut item = cursor.seek_exact(StorageShardedKey::new(address, storage_key, u64::MAX))?;
-
-    while let Some((storage_sharded_key, list)) = item {
-        // there is no more shard for address
-        if storage_sharded_key.address != address ||
-            storage_sharded_key.sharded_key.key != storage_key
-        {
-            // there is no more shard for address and storage_key.
-            break
-        }
-        cursor.delete_current()?;
-        // check first item and if it is more and eq than `transition_id` delete current
-        // item.
-        let first = list.iter(0).next().expect("List can't empty");
-        if first >= transition_id as usize {
-            item = cursor.prev()?;
-            continue
-        } else if transition_id <= storage_sharded_key.sharded_key.highest_transition_id {
-            // if first element is in scope whole list would be removed.
-            // so at least this first element is present.
-            return Ok(list.iter(0).take_while(|i| *i < transition_id as usize).collect::<Vec<_>>())
-        } else {
-            return Ok(list.iter(0).collect::<Vec<_>>())
-        }
-    }
-    Ok(Vec::new())
-}
 #[cfg(test)]
 mod tests {
 
+    use std::collections::BTreeMap;
+
     use super::*;
     use crate::test_utils::{TestTransaction, PREV_STAGE_ID};
-    use reth_db::models::{ShardedKey, TransitionIdAddress};
-    use reth_primitives::{hex_literal::hex, StorageEntry, H160, U256};
+    use reth_db::{
+        models::{
+            storage_sharded_key::{StorageShardedKey, NUM_OF_INDICES_IN_SHARD},
+            ShardedKey, TransitionIdAddress,
+        },
+        tables,
+        transaction::DbTxMut,
+        TransitionList,
+    };
+    use reth_primitives::{hex_literal::hex, StorageEntry, H160, H256, U256};
 
     const ADDRESS: H160 = H160(hex!("0000000000000000000000000000000000000001"));
     const STORAGE_KEY: H256 =
@@ -282,8 +147,8 @@ mod tests {
     }
 
     async fn run(tx: &TestTransaction, run_to: u64) {
-        let mut input = ExecInput::default();
-        input.previous_stage = Some((PREV_STAGE_ID, run_to));
+        let input =
+            ExecInput { previous_stage: Some((PREV_STAGE_ID, run_to)), ..Default::default() };
         let mut stage = IndexStorageHistoryStage::default();
         let mut tx = tx.inner();
         let out = stage.execute(&mut tx, input).await.unwrap();
@@ -292,9 +157,7 @@ mod tests {
     }
 
     async fn unwind(tx: &TestTransaction, unwind_from: u64, unwind_to: u64) {
-        let mut input = UnwindInput::default();
-        input.stage_progress = unwind_from;
-        input.unwind_to = unwind_to;
+        let input = UnwindInput { stage_progress: unwind_from, unwind_to, ..Default::default() };
         let mut stage = IndexStorageHistoryStage::default();
         let mut tx = tx.inner();
         let out = stage.unwind(&mut tx, input).await.unwrap();
@@ -357,8 +220,7 @@ mod tests {
     async fn insert_index_to_full_shard() {
         // init
         let tx = TestTransaction::default();
-        let mut input = ExecInput::default();
-        input.previous_stage = Some((PREV_STAGE_ID, 5));
+        let _input = ExecInput { previous_stage: Some((PREV_STAGE_ID, 5)), ..Default::default() };
 
         // change does not matter only that account is present in changeset.
         let full_list = vec![3; NUM_OF_INDICES_IN_SHARD];
diff --git a/crates/stages/src/stages/merkle.rs b/crates/stages/src/stages/merkle.rs
index d86470bff89..d2b8df05b2d 100644
--- a/crates/stages/src/stages/merkle.rs
+++ b/crates/stages/src/stages/merkle.rs
@@ -1,11 +1,11 @@
-use crate::{
-    trie::DBTrieLoader, ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput,
-    UnwindOutput,
-};
+use crate::{ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput, UnwindOutput};
 use reth_db::{database::Database, tables, transaction::DbTx};
 use reth_interfaces::consensus;
-use reth_provider::Transaction;
-use std::fmt::Debug;
+use reth_provider::{
+    trie::{DBTrieLoader, TrieProgress},
+    Transaction,
+};
+use std::{fmt::Debug, ops::DerefMut};
 use tracing::*;
 
 /// The [`StageId`] of the merkle hashing execution stage.
@@ -14,6 +14,9 @@ pub const MERKLE_EXECUTION: StageId = StageId("MerkleExecute");
 /// The [`StageId`] of the merkle hashing unwind stage.
 pub const MERKLE_UNWIND: StageId = StageId("MerkleUnwind");
 
+/// The [`StageId`] of the merkle hashing unwind and execution stage.
+pub const MERKLE_BOTH: StageId = StageId("MerkleBoth");
+
 /// The merkle hashing stage uses input from
 /// [`AccountHashingStage`][crate::stages::AccountHashingStage] and
 /// [`StorageHashingStage`][crate::stages::AccountHashingStage] to calculate intermediate hashes
@@ -35,7 +38,7 @@ pub const MERKLE_UNWIND: StageId = StageId("MerkleUnwind");
 /// - [`AccountHashingStage`][crate::stages::AccountHashingStage]
 /// - [`StorageHashingStage`][crate::stages::StorageHashingStage]
 /// - [`MerkleStage::Execution`]
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum MerkleStage {
     /// The execution portion of the merkle stage.
     Execution {
@@ -46,7 +49,9 @@ pub enum MerkleStage {
     /// The unwind portion of the merkle stage.
     Unwind,
 
-    #[cfg(test)]
+    /// Able to execute and unwind. Used for tests
+    #[cfg(any(test, feature = "test-utils"))]
+    #[allow(missing_docs)]
     Both { clean_threshold: u64 },
 }
 
@@ -69,8 +74,8 @@ impl<DB: Database> Stage<DB> for MerkleStage {
         match self {
             MerkleStage::Execution { .. } => MERKLE_EXECUTION,
             MerkleStage::Unwind => MERKLE_UNWIND,
-            #[cfg(test)]
-            MerkleStage::Both { .. } => unreachable!(),
+            #[cfg(any(test, feature = "test-utils"))]
+            MerkleStage::Both { .. } => MERKLE_BOTH,
         }
     }
 
@@ -89,7 +94,7 @@ impl<DB: Database> Stage<DB> for MerkleStage {
                 })
             }
             MerkleStage::Execution { clean_threshold } => *clean_threshold,
-            #[cfg(test)]
+            #[cfg(any(test, feature = "test-utils"))]
             MerkleStage::Both { clean_threshold } => *clean_threshold,
         };
 
@@ -103,26 +108,38 @@ impl<DB: Database> Stage<DB> for MerkleStage {
 
         let trie_root = if from_transition == to_transition {
             block_root
-        } else if to_transition - from_transition > threshold || stage_progress == 0 {
-            debug!(target: "sync::stages::merkle::exec", current = ?stage_progress, target = ?previous_stage_progress, "Rebuilding trie");
-            // if there are more blocks than threshold it is faster to rebuild the trie
-            let loader = DBTrieLoader::default();
-            loader.calculate_root(tx).map_err(|e| StageError::Fatal(Box::new(e)))?
         } else {
-            debug!(target: "sync::stages::merkle::exec", current = ?stage_progress, target = ?previous_stage_progress, "Updating trie");
-            // Iterate over changeset (similar to Hashing stages) and take new values
-            let current_root = tx.get_header(stage_progress)?.state_root;
-            let loader = DBTrieLoader::default();
-            loader
-                .update_root(tx, current_root, from_transition..to_transition)
-                .map_err(|e| StageError::Fatal(Box::new(e)))?
+            let res = if to_transition - from_transition > threshold || stage_progress == 0 {
+                debug!(target: "sync::stages::merkle::exec", current = ?stage_progress, target = ?previous_stage_progress, "Rebuilding trie");
+                // if there are more blocks than threshold it is faster to rebuild the trie
+                let mut loader = DBTrieLoader::new(tx.deref_mut());
+                loader.calculate_root().map_err(|e| StageError::Fatal(Box::new(e)))?
+            } else {
+                debug!(target: "sync::stages::merkle::exec", current = ?stage_progress, target = ?previous_stage_progress, "Updating trie");
+                // Iterate over changeset (similar to Hashing stages) and take new values
+                let current_root = tx.get_header(stage_progress)?.state_root;
+                let mut loader = DBTrieLoader::new(tx.deref_mut());
+                loader
+                    .update_root(current_root, from_transition..to_transition)
+                    .map_err(|e| StageError::Fatal(Box::new(e)))?
+            };
+
+            match res {
+                TrieProgress::Complete(root) => root,
+                TrieProgress::InProgress(_) => {
+                    return Ok(ExecOutput { stage_progress, done: false })
+                }
+            }
         };
 
         if block_root != trie_root {
-            warn!(target: "sync::stages::merkle::exec", ?previous_stage_progress, got = ?block_root, expected = ?trie_root, "Block's root state failed verification");
+            warn!(target: "sync::stages::merkle::exec", ?previous_stage_progress, got = ?trie_root, expected = ?block_root, "Block's root state failed verification");
             return Err(StageError::Validation {
                 block: previous_stage_progress,
-                error: consensus::Error::BodyStateRootDiff { got: trie_root, expected: block_root },
+                error: consensus::ConsensusError::BodyStateRootDiff {
+                    got: trie_root,
+                    expected: block_root,
+                },
             })
         }
 
@@ -150,15 +167,41 @@ impl<DB: Database> Stage<DB> for MerkleStage {
             return Ok(UnwindOutput { stage_progress: input.unwind_to })
         }
 
-        let loader = DBTrieLoader::default();
         let current_root = tx.get_header(input.stage_progress)?.state_root;
-
         let from_transition = tx.get_block_transition(input.unwind_to)?;
         let to_transition = tx.get_block_transition(input.stage_progress)?;
 
-        loader
-            .update_root(tx, current_root, from_transition..to_transition)
-            .map_err(|e| StageError::Fatal(Box::new(e)))?;
+        let mut loader = DBTrieLoader::new(tx.deref_mut());
+        let block_root = loop {
+            match loader
+                .update_root(current_root, from_transition..to_transition)
+                .map_err(|e| StageError::Fatal(Box::new(e)))?
+            {
+                TrieProgress::Complete(root) => break root,
+                TrieProgress::InProgress(_) => {
+                    // Save the loader's progress & drop it to allow committing to the database,
+                    // otherwise we're hitting the borrow checker
+                    let progress = loader.current;
+                    let _ = loader;
+                    tx.commit()?;
+                    // Reinstantiate the loader from where it was left off.
+                    loader = DBTrieLoader::new(tx.deref_mut());
+                    loader.current = progress;
+                }
+            }
+        };
+
+        if block_root != target_root {
+            let unwind_to = input.unwind_to;
+            warn!(target: "sync::stages::merkle::unwind", ?unwind_to, got = ?block_root, expected = ?target_root, "Block's root state failed verification");
+            return Err(StageError::Validation {
+                block: unwind_to,
+                error: consensus::ConsensusError::BodyStateRootDiff {
+                    got: block_root,
+                    expected: target_root,
+                },
+            })
+        }
 
         info!(target: "sync::stages::merkle::unwind", "Stage finished");
         Ok(UnwindOutput { stage_progress: input.unwind_to })
@@ -175,15 +218,16 @@ mod tests {
     use assert_matches::assert_matches;
     use reth_db::{
         cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO, DbDupCursorRW},
-        models::{AccountBeforeTx, StoredBlockBody},
+        database::DatabaseGAT,
+        mdbx::{Env, WriteMap},
         tables,
         transaction::{DbTx, DbTxMut},
     };
     use reth_interfaces::test_utils::generators::{
-        random_block, random_block_range, random_contract_account_range,
+        random_block, random_block_range, random_contract_account_range, random_transition_range,
     };
     use reth_primitives::{keccak256, Account, Address, SealedBlock, StorageEntry, H256, U256};
-    use std::collections::BTreeMap;
+    use std::{collections::BTreeMap, ops::Deref};
 
     stage_test_suite_ext!(MerkleTestRunner, merkle);
 
@@ -244,6 +288,12 @@ mod tests {
         assert!(runner.validate_execution(input, result.ok()).is_ok(), "execution validation");
     }
 
+    fn create_trie_loader<'tx, 'db>(
+        tx: &'tx Transaction<'db, Env<WriteMap>>,
+    ) -> DBTrieLoader<'tx, <Env<WriteMap> as DatabaseGAT<'db>>::TXMut> {
+        DBTrieLoader::new(tx.deref())
+    }
+
     struct MerkleTestRunner {
         tx: TestTransaction,
         clean_threshold: u64,
@@ -276,12 +326,16 @@ mod tests {
             let end = input.previous_stage_progress() + 1;
 
             let n_accounts = 31;
-            let mut accounts = random_contract_account_range(&mut (0..n_accounts));
+            let accounts = random_contract_account_range(&mut (0..n_accounts))
+                .into_iter()
+                .collect::<BTreeMap<_, _>>();
 
             let SealedBlock { header, body, ommers, withdrawals } =
                 random_block(stage_progress, None, Some(0), None);
             let mut header = header.unseal();
-            header.state_root = self.generate_initial_trie(&accounts)?;
+
+            header.state_root =
+                self.generate_initial_trie(accounts.iter().map(|(k, v)| (*k, *v)))?;
             let sealed_head = SealedBlock { header: header.seal_slow(), body, ommers, withdrawals };
 
             let head_hash = sealed_head.hash();
@@ -289,64 +343,18 @@ mod tests {
 
             blocks.extend(random_block_range((stage_progress + 1)..end, head_hash, 0..3));
 
-            self.tx.insert_headers(blocks.iter().map(|block| &block.header))?;
-
-            let (mut transition_id, mut tx_id) = (0, 0);
-
-            let mut storages: BTreeMap<Address, BTreeMap<H256, U256>> = BTreeMap::new();
-
-            for progress in blocks.iter() {
-                // Insert last progress data
-                self.tx.commit(|tx| {
-                    let body = StoredBlockBody {
-                        start_tx_id: tx_id,
-                        tx_count: progress.body.len() as u64,
-                    };
-
-                    progress.body.iter().try_for_each(|transaction| {
-                        tx.put::<tables::TxHashNumber>(transaction.hash(), tx_id)?;
-                        tx.put::<tables::Transactions>(tx_id, transaction.clone())?;
-                        tx.put::<tables::TxTransitionIndex>(tx_id, transition_id)?;
-
-                        // seed account changeset
-                        let (addr, prev_acc) = accounts
-                            .get_mut(rand::random::<usize>() % n_accounts as usize)
-                            .unwrap();
-                        let acc_before_tx =
-                            AccountBeforeTx { address: *addr, info: Some(*prev_acc) };
-
-                        tx.put::<tables::AccountChangeSet>(transition_id, acc_before_tx)?;
+            self.tx.insert_blocks(blocks.iter(), None)?;
 
-                        prev_acc.nonce += 1;
-                        prev_acc.balance = prev_acc.balance.wrapping_add(U256::from(1));
+            let (transitions, final_state) = random_transition_range(
+                blocks.iter(),
+                accounts.into_iter().map(|(addr, acc)| (addr, (acc, Vec::new()))),
+                0..3,
+                0..256,
+            );
 
-                        let new_entry = StorageEntry {
-                            key: keccak256([rand::random::<u8>()]),
-                            value: U256::from(rand::random::<u8>() % 30 + 1),
-                        };
-                        let storage = storages.entry(*addr).or_default();
-                        let old_value = storage.entry(new_entry.key).or_default();
+            self.tx.insert_transitions(transitions, None)?;
 
-                        tx.put::<tables::StorageChangeSet>(
-                            (transition_id, *addr).into(),
-                            StorageEntry { key: new_entry.key, value: *old_value },
-                        )?;
-
-                        *old_value = new_entry.value;
-
-                        tx_id += 1;
-                        transition_id += 1;
-
-                        Ok(())
-                    })?;
-
-                    tx.put::<tables::BlockTransitionIndex>(progress.number, transition_id)?;
-                    tx.put::<tables::BlockBodies>(progress.number, body)
-                })?;
-            }
-
-            self.insert_accounts(&accounts)?;
-            self.insert_storages(&storages)?;
+            self.tx.insert_accounts_and_storages(final_state)?;
 
             let last_block_number = end - 1;
             let root = self.state_root()?;
@@ -466,81 +474,39 @@ mod tests {
 
     impl MerkleTestRunner {
         fn state_root(&self) -> Result<H256, TestRunnerError> {
-            Ok(DBTrieLoader::default().calculate_root(&self.tx.inner()).unwrap())
+            Ok(create_trie_loader(&self.tx.inner())
+                .calculate_root()
+                .and_then(|e| e.root())
+                .unwrap())
         }
 
         pub(crate) fn generate_initial_trie(
             &self,
-            accounts: &[(Address, Account)],
+            accounts: impl IntoIterator<Item = (Address, Account)>,
         ) -> Result<H256, TestRunnerError> {
-            self.insert_accounts(accounts)?;
-
-            let loader = DBTrieLoader::default();
+            self.tx.insert_accounts_and_storages(
+                accounts.into_iter().map(|(addr, acc)| (addr, (acc, std::iter::empty()))),
+            )?;
 
             let mut tx = self.tx.inner();
-            let root = loader.calculate_root(&tx).expect("couldn't create initial trie");
+            let root = create_trie_loader(&tx)
+                .calculate_root()
+                .and_then(|e| e.root())
+                .expect("couldn't create initial trie");
 
             tx.commit()?;
 
             Ok(root)
         }
 
-        pub(crate) fn insert_accounts(
-            &self,
-            accounts: &[(Address, Account)],
-        ) -> Result<(), TestRunnerError> {
-            for (addr, acc) in accounts.iter() {
-                self.tx.commit(|tx| {
-                    tx.put::<tables::PlainAccountState>(*addr, *acc)?;
-                    tx.put::<tables::HashedAccount>(keccak256(addr), *acc)?;
-                    Ok(())
-                })?;
-            }
-
-            Ok(())
-        }
-
-        fn insert_storages(
-            &self,
-            storages: &BTreeMap<Address, BTreeMap<H256, U256>>,
-        ) -> Result<(), TestRunnerError> {
-            self.tx
-                .commit(|tx| {
-                    storages.iter().try_for_each(|(&addr, storage)| {
-                        storage.iter().try_for_each(|(&key, &value)| {
-                            let entry = StorageEntry { key, value };
-                            tx.put::<tables::PlainStorageState>(addr, entry)
-                        })
-                    })?;
-                    storages
-                        .iter()
-                        .map(|(addr, storage)| {
-                            (
-                                keccak256(addr),
-                                storage
-                                    .iter()
-                                    .filter(|(_, &value)| value != U256::ZERO)
-                                    .map(|(key, value)| (keccak256(key), value)),
-                            )
-                        })
-                        .collect::<BTreeMap<_, _>>()
-                        .into_iter()
-                        .try_for_each(|(addr, storage)| {
-                            storage.into_iter().try_for_each(|(key, &value)| {
-                                let entry = StorageEntry { key, value };
-                                tx.put::<tables::HashedStorage>(addr, entry)
-                            })
-                        })?;
-                    Ok(())
-                })
-                .map_err(|e| e.into())
-        }
-
         fn check_root(&self, previous_stage_progress: u64) -> Result<(), TestRunnerError> {
             if previous_stage_progress != 0 {
                 let block_root =
                     self.tx.inner().get_header(previous_stage_progress).unwrap().state_root;
-                let root = DBTrieLoader::default().calculate_root(&self.tx.inner()).unwrap();
+                let root = create_trie_loader(&self.tx().inner())
+                    .calculate_root()
+                    .and_then(|e| e.root())
+                    .unwrap();
                 assert_eq!(block_root, root);
             }
             Ok(())
diff --git a/crates/stages/src/stages/sender_recovery.rs b/crates/stages/src/stages/sender_recovery.rs
index 5ea1beb5ca1..dc0e39aa97b 100644
--- a/crates/stages/src/stages/sender_recovery.rs
+++ b/crates/stages/src/stages/sender_recovery.rs
@@ -3,6 +3,7 @@ use crate::{
     StageError, StageId, UnwindInput, UnwindOutput,
 };
 use futures_util::StreamExt;
+use itertools::Itertools;
 use reth_db::{
     cursor::{DbCursorRO, DbCursorRW},
     database::Database,
@@ -55,6 +56,7 @@ impl<DB: Database> Stage<DB> for SenderRecoveryStage {
     ) -> Result<ExecOutput, StageError> {
         let ((start_block, end_block), capped) =
             exec_or_return!(input, self.commit_threshold, "sync::stages::sender_recovery");
+        let done = !capped;
 
         // Look up the start index for the transaction range
         let start_tx_index = tx.get_block_body(start_block)?.start_tx_id;
@@ -65,7 +67,7 @@ impl<DB: Database> Stage<DB> for SenderRecoveryStage {
         // No transactions to walk over
         if start_tx_index > end_tx_index {
             info!(target: "sync::stages::sender_recovery", start_tx_index, end_tx_index, "Target transaction already reached");
-            return Ok(ExecOutput { stage_progress: end_block, done: true })
+            return Ok(ExecOutput { stage_progress: end_block, done })
         }
 
         // Acquire the cursor for inserting elements
@@ -74,31 +76,49 @@ impl<DB: Database> Stage<DB> for SenderRecoveryStage {
         // Acquire the cursor over the transactions
         let mut tx_cursor = tx.cursor_read::<tables::Transactions>()?;
         // Walk the transactions from start to end index (inclusive)
-        let entries = tx_cursor.walk_range(start_tx_index..=end_tx_index)?;
+        let tx_walker = tx_cursor.walk_range(start_tx_index..=end_tx_index)?;
 
         // Iterate over transactions in chunks
         info!(target: "sync::stages::sender_recovery", start_tx_index, end_tx_index, "Recovering senders");
 
-        // a channel to receive results from a rayon job
+        // An _unordered_ channel to receive results from a rayon job
         let (tx, rx) = mpsc::unbounded_channel();
 
-        // spawn recovery jobs onto the default rayon threadpool and send the result through the
-        // channel
-        for entry in entries {
-            let (tx_id, transaction) = entry?;
+        // Spawn recovery jobs onto the default rayon threadpool and send the result through the
+        // channel.
+        //
+        // We try to evenly divide the transactions to recover across all threads in the threadpool.
+        // Chunks are submitted instead of individual transactions to reduce the overhead of work
+        // stealing in the threadpool workers.
+        for chunk in
+            &tx_walker.chunks(self.commit_threshold as usize / rayon::current_num_threads())
+        {
             let tx = tx.clone();
-            rayon::spawn_fifo(move || {
-                let res = if let Some(signer) = transaction.recover_signer() {
-                    Ok((tx_id, signer))
-                } else {
-                    Err(StageError::from(SenderRecoveryStageError::SenderRecovery { tx: tx_id }))
-                };
-                // send the result back
-                let _ = tx.send(res);
+            // Note: Unfortunate side-effect of how chunk is designed in itertools (it is not Send)
+            let mut chunk: Vec<_> = chunk.collect();
+
+            // Spawn the sender recovery task onto the global rayon pool
+            // This task will send the results through the channel after it recovered the senders.
+            rayon::spawn(move || {
+                chunk
+                    .drain(..)
+                    .map(|entry| {
+                        let (tx_id, transaction) = entry?;
+                        let sender = transaction.recover_signer().ok_or(StageError::from(
+                            SenderRecoveryStageError::SenderRecovery { tx: tx_id },
+                        ))?;
+
+                        Ok((tx_id, sender))
+                    })
+                    .for_each(|result: Result<_, StageError>| {
+                        let _ = tx.send(result);
+                    });
             });
         }
         drop(tx);
 
+        // We need sorted results, so we wrap the _unordered_ receiver stream into a sequential
+        // stream, which yields the results by ascending transaction ID.
         let mut recovered_senders =
             SequentialPairStream::new(start_tx_index, UnboundedReceiverStream::new(rx));
 
@@ -107,7 +127,6 @@ impl<DB: Database> Stage<DB> for SenderRecoveryStage {
             senders_cursor.append(id, sender)?;
         }
 
-        let done = !capped;
         info!(target: "sync::stages::sender_recovery", stage_progress = end_block, done, "Sync iteration finished");
         Ok(ExecOutput { stage_progress: end_block, done })
     }
diff --git a/crates/stages/src/stages/total_difficulty.rs b/crates/stages/src/stages/total_difficulty.rs
index 6556bf81df2..69f1ccad94e 100644
--- a/crates/stages/src/stages/total_difficulty.rs
+++ b/crates/stages/src/stages/total_difficulty.rs
@@ -8,9 +8,10 @@ use reth_db::{
     tables,
     transaction::{DbTx, DbTxMut},
 };
-use reth_interfaces::{consensus::Error, provider::ProviderError};
-use reth_primitives::{ChainSpec, Hardfork, EMPTY_OMMER_ROOT, MAINNET, U256};
+use reth_interfaces::{consensus::Consensus, provider::ProviderError};
+use reth_primitives::U256;
 use reth_provider::Transaction;
+use std::sync::Arc;
 use tracing::*;
 
 /// The [`StageId`] of the total difficulty stage.
@@ -23,15 +24,22 @@ pub const TOTAL_DIFFICULTY: StageId = StageId("TotalDifficulty");
 /// table.
 #[derive(Debug, Clone)]
 pub struct TotalDifficultyStage {
-    /// The chain specification.
-    pub chain_spec: ChainSpec,
+    /// Consensus client implementation
+    consensus: Arc<dyn Consensus>,
     /// The number of table entries to commit at once
-    pub commit_threshold: u64,
+    commit_threshold: u64,
 }
 
-impl Default for TotalDifficultyStage {
-    fn default() -> Self {
-        Self { chain_spec: MAINNET.clone(), commit_threshold: 100_000 }
+impl TotalDifficultyStage {
+    /// Create a new total difficulty stage
+    pub fn new(consensus: Arc<dyn Consensus>) -> Self {
+        Self { consensus, commit_threshold: 100_000 }
+    }
+
+    /// Set a commit threshold on total difficulty stage
+    pub fn with_commit_threshold(mut self, commit_threshold: u64) -> Self {
+        self.commit_threshold = commit_threshold;
+        self
     }
 }
 
@@ -55,6 +63,7 @@ impl<DB: Database> Stage<DB> for TotalDifficultyStage {
 
         // Acquire cursor over total difficulty and headers tables
         let mut cursor_td = tx.cursor_write::<tables::HeaderTD>()?;
+        let mut cursor_canonical = tx.cursor_read::<tables::CanonicalHeaders>()?;
         let mut cursor_headers = tx.cursor_read::<tables::Headers>()?;
 
         // Get latest total difficulty
@@ -66,38 +75,22 @@ impl<DB: Database> Stage<DB> for TotalDifficultyStage {
         let mut td: U256 = last_entry.1.into();
         debug!(target: "sync::stages::total_difficulty", ?td, block_number = last_header_number, "Last total difficulty entry");
 
-        let walker = cursor_headers
-            .walk(Some(start_block))?
-            .take_while(|e| e.as_ref().map(|(_, h)| h.number <= end_block).unwrap_or_default());
+        // Acquire canonical walker
+        let walker = cursor_canonical.walk_range(start_block..=end_block)?;
+
         // Walk over newly inserted headers, update & insert td
         for entry in walker {
-            let (key, header) = entry?;
+            let (number, hash) = entry?;
+            let (_, header) =
+                cursor_headers.seek_exact(number)?.ok_or(ProviderError::Header { number })?;
+            let header = header.seal(hash);
             td += header.difficulty;
 
-            if self.chain_spec.fork(Hardfork::Paris).active_at_ttd(td, header.difficulty) {
-                if header.difficulty != U256::ZERO {
-                    return Err(StageError::Validation {
-                        block: header.number,
-                        error: Error::TheMergeDifficultyIsNotZero,
-                    })
-                }
-
-                if header.nonce != 0 {
-                    return Err(StageError::Validation {
-                        block: header.number,
-                        error: Error::TheMergeNonceIsNotZero,
-                    })
-                }
+            self.consensus
+                .validate_header(&header, td)
+                .map_err(|error| StageError::Validation { block: header.number, error })?;
 
-                if header.ommers_hash != EMPTY_OMMER_ROOT {
-                    return Err(StageError::Validation {
-                        block: header.number,
-                        error: Error::TheMergeOmmerRootIsNotEmpty,
-                    })
-                }
-            }
-
-            cursor_td.append(key, td.into())?;
+            cursor_td.append(number, td.into())?;
         }
 
         let done = !capped;
@@ -120,8 +113,11 @@ impl<DB: Database> Stage<DB> for TotalDifficultyStage {
 #[cfg(test)]
 mod tests {
     use reth_db::transaction::DbTx;
-    use reth_interfaces::test_utils::generators::{random_header, random_header_range};
-    use reth_primitives::{BlockNumber, SealedHeader, MAINNET};
+    use reth_interfaces::test_utils::{
+        generators::{random_header, random_header_range},
+        TestConsensus,
+    };
+    use reth_primitives::{BlockNumber, SealedHeader};
 
     use super::*;
     use crate::test_utils::{
@@ -173,12 +169,17 @@ mod tests {
 
     struct TotalDifficultyTestRunner {
         tx: TestTransaction,
+        consensus: Arc<TestConsensus>,
         commit_threshold: u64,
     }
 
     impl Default for TotalDifficultyTestRunner {
         fn default() -> Self {
-            Self { tx: Default::default(), commit_threshold: 500 }
+            Self {
+                tx: Default::default(),
+                consensus: Arc::new(TestConsensus::default()),
+                commit_threshold: 500,
+            }
         }
     }
 
@@ -191,7 +192,7 @@ mod tests {
 
         fn stage(&self) -> Self::S {
             TotalDifficultyStage {
-                chain_spec: MAINNET.clone(),
+                consensus: self.consensus.clone(),
                 commit_threshold: self.commit_threshold,
             }
         }
diff --git a/crates/stages/src/stages/tx_lookup.rs b/crates/stages/src/stages/tx_lookup.rs
index 7921dbdedc6..54599ff6775 100644
--- a/crates/stages/src/stages/tx_lookup.rs
+++ b/crates/stages/src/stages/tx_lookup.rs
@@ -111,9 +111,9 @@ impl<DB: Database> Stage<DB> for TransactionLookupStage {
     ) -> Result<UnwindOutput, StageError> {
         info!(target: "sync::stages::transaction_lookup", to_block = input.unwind_to, "Unwinding");
         // Cursors to unwind tx hash to number
-        let mut body_cursor = tx.cursor_write::<tables::BlockBodies>()?;
+        let mut body_cursor = tx.cursor_read::<tables::BlockBodies>()?;
         let mut tx_hash_number_cursor = tx.cursor_write::<tables::TxHashNumber>()?;
-        let mut transaction_cursor = tx.cursor_write::<tables::Transactions>()?;
+        let mut transaction_cursor = tx.cursor_read::<tables::Transactions>()?;
         let mut rev_walker = body_cursor.walk_back(None)?;
         while let Some((number, body)) = rev_walker.next().transpose()? {
             if number <= input.unwind_to {
diff --git a/crates/stages/src/test_utils/mod.rs b/crates/stages/src/test_utils/mod.rs
index 7ec5b2e840f..3b499fc697a 100644
--- a/crates/stages/src/test_utils/mod.rs
+++ b/crates/stages/src/test_utils/mod.rs
@@ -2,14 +2,24 @@
 use crate::StageId;
 
 mod macros;
-mod runner;
-mod test_db;
-
 pub(crate) use macros::*;
+
+mod runner;
 pub(crate) use runner::{
     ExecuteStageTestRunner, StageTestRunner, TestRunnerError, UnwindStageTestRunner,
 };
+
+mod test_db;
 pub use test_db::TestTransaction;
 
+mod stage;
+pub use stage::TestStage;
+
+mod set;
+pub use set::TestStages;
+
+/// The test stage id
+pub const TEST_STAGE_ID: StageId = StageId("TestStage");
+
 /// The previous test stage id mock used for testing
 pub(crate) const PREV_STAGE_ID: StageId = StageId("PrevStage");
diff --git a/crates/stages/src/test_utils/set.rs b/crates/stages/src/test_utils/set.rs
new file mode 100644
index 00000000000..c5b14928456
--- /dev/null
+++ b/crates/stages/src/test_utils/set.rs
@@ -0,0 +1,29 @@
+use super::{TestStage, TEST_STAGE_ID};
+use crate::{ExecOutput, StageError, StageSet, StageSetBuilder, UnwindOutput};
+use reth_db::database::Database;
+use std::collections::VecDeque;
+
+#[derive(Default, Debug)]
+pub struct TestStages {
+    exec_outputs: VecDeque<Result<ExecOutput, StageError>>,
+    unwind_outputs: VecDeque<Result<UnwindOutput, StageError>>,
+}
+
+impl TestStages {
+    pub fn new(
+        exec_outputs: VecDeque<Result<ExecOutput, StageError>>,
+        unwind_outputs: VecDeque<Result<UnwindOutput, StageError>>,
+    ) -> Self {
+        Self { exec_outputs, unwind_outputs }
+    }
+}
+
+impl<DB: Database> StageSet<DB> for TestStages {
+    fn builder(self) -> StageSetBuilder<DB> {
+        StageSetBuilder::default().add_stage(
+            TestStage::new(TEST_STAGE_ID)
+                .with_exec(self.exec_outputs)
+                .with_unwind(self.unwind_outputs),
+        )
+    }
+}
diff --git a/crates/stages/src/test_utils/stage.rs b/crates/stages/src/test_utils/stage.rs
new file mode 100644
index 00000000000..bd9913f9b53
--- /dev/null
+++ b/crates/stages/src/test_utils/stage.rs
@@ -0,0 +1,67 @@
+use crate::{ExecInput, ExecOutput, Stage, StageError, StageId, UnwindInput, UnwindOutput};
+use reth_db::database::Database;
+use reth_provider::Transaction;
+use std::collections::VecDeque;
+
+#[derive(Debug)]
+pub struct TestStage {
+    id: StageId,
+    exec_outputs: VecDeque<Result<ExecOutput, StageError>>,
+    unwind_outputs: VecDeque<Result<UnwindOutput, StageError>>,
+}
+
+impl TestStage {
+    pub fn new(id: StageId) -> Self {
+        Self { id, exec_outputs: VecDeque::new(), unwind_outputs: VecDeque::new() }
+    }
+
+    pub fn with_exec(mut self, exec_outputs: VecDeque<Result<ExecOutput, StageError>>) -> Self {
+        self.exec_outputs = exec_outputs;
+        self
+    }
+
+    pub fn with_unwind(
+        mut self,
+        unwind_outputs: VecDeque<Result<UnwindOutput, StageError>>,
+    ) -> Self {
+        self.unwind_outputs = unwind_outputs;
+        self
+    }
+
+    pub fn add_exec(mut self, output: Result<ExecOutput, StageError>) -> Self {
+        self.exec_outputs.push_back(output);
+        self
+    }
+
+    pub fn add_unwind(mut self, output: Result<UnwindOutput, StageError>) -> Self {
+        self.unwind_outputs.push_back(output);
+        self
+    }
+}
+
+#[async_trait::async_trait]
+impl<DB: Database> Stage<DB> for TestStage {
+    fn id(&self) -> StageId {
+        self.id
+    }
+
+    async fn execute(
+        &mut self,
+        _: &mut Transaction<'_, DB>,
+        _input: ExecInput,
+    ) -> Result<ExecOutput, StageError> {
+        self.exec_outputs
+            .pop_front()
+            .unwrap_or_else(|| panic!("Test stage {} executed too many times.", self.id))
+    }
+
+    async fn unwind(
+        &mut self,
+        _: &mut Transaction<'_, DB>,
+        _input: UnwindInput,
+    ) -> Result<UnwindOutput, StageError> {
+        self.unwind_outputs
+            .pop_front()
+            .unwrap_or_else(|| panic!("Test stage {} unwound too many times.", self.id))
+    }
+}
diff --git a/crates/stages/src/test_utils/test_db.rs b/crates/stages/src/test_utils/test_db.rs
index a040c651386..3d0f299f89e 100644
--- a/crates/stages/src/test_utils/test_db.rs
+++ b/crates/stages/src/test_utils/test_db.rs
@@ -1,19 +1,27 @@
 use reth_db::{
-    cursor::{DbCursorRO, DbCursorRW},
+    common::KeyValue,
+    cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO},
     mdbx::{
         test_utils::{create_test_db, create_test_db_with_path},
         tx::Tx,
         Env, EnvKind, WriteMap, RW,
     },
-    models::StoredBlockBody,
+    models::{AccountBeforeTx, BlockNumHash, StoredBlockBody},
     table::Table,
     tables,
     transaction::{DbTx, DbTxMut},
     Error as DbError,
 };
-use reth_primitives::{BlockNumber, SealedBlock, SealedHeader, U256};
+use reth_primitives::{
+    keccak256, Account, Address, BlockNumber, SealedBlock, SealedHeader, StorageEntry, H256, U256,
+};
 use reth_provider::Transaction;
-use std::{borrow::Borrow, path::Path, sync::Arc};
+use std::{
+    borrow::Borrow,
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 /// The [TestTransaction] is used as an internal
 /// database for testing stage implementation.
@@ -26,18 +34,22 @@ use std::{borrow::Borrow, path::Path, sync::Arc};
 pub struct TestTransaction {
     /// WriteMap DB
     pub tx: Arc<Env<WriteMap>>,
+    pub path: Option<PathBuf>,
 }
 
 impl Default for TestTransaction {
     /// Create a new instance of [TestTransaction]
     fn default() -> Self {
-        Self { tx: create_test_db::<WriteMap>(EnvKind::RW) }
+        Self { tx: create_test_db::<WriteMap>(EnvKind::RW), path: None }
     }
 }
 
 impl TestTransaction {
     pub fn new(path: &Path) -> Self {
-        Self { tx: Arc::new(create_test_db_with_path::<WriteMap>(EnvKind::RW, path)) }
+        Self {
+            tx: Arc::new(create_test_db_with_path::<WriteMap>(EnvKind::RW, path)),
+            path: Some(path.to_path_buf()),
+        }
     }
 
     /// Return a database wrapped in [Transaction].
@@ -77,9 +89,8 @@ impl TestTransaction {
         })
     }
 
-    #[allow(clippy::type_complexity)]
     /// Return full table as Vec
-    pub fn table<T: Table>(&self) -> Result<Vec<(T::Key, T::Value)>, DbError>
+    pub fn table<T: Table>(&self) -> Result<Vec<KeyValue<T>>, DbError>
     where
         T::Key: Default + Ord,
     {
@@ -177,23 +188,20 @@ impl TestTransaction {
         })
     }
 
+    /// Inserts a single [SealedHeader] into the corresponding tables of the headers stage.
+    fn insert_header(tx: &mut Tx<'_, RW, WriteMap>, header: &SealedHeader) -> Result<(), DbError> {
+        tx.put::<tables::CanonicalHeaders>(header.number, header.hash())?;
+        tx.put::<tables::HeaderNumbers>(header.hash(), header.number)?;
+        tx.put::<tables::Headers>(header.number, header.clone().unseal())
+    }
+
     /// Insert ordered collection of [SealedHeader] into the corresponding tables
     /// that are supposed to be populated by the headers stage.
     pub fn insert_headers<'a, I>(&self, headers: I) -> Result<(), DbError>
     where
         I: Iterator<Item = &'a SealedHeader>,
     {
-        self.commit(|tx| {
-            let headers = headers.collect::<Vec<_>>();
-
-            for header in headers {
-                tx.put::<tables::CanonicalHeaders>(header.number, header.hash())?;
-                tx.put::<tables::HeaderNumbers>(header.hash(), header.number)?;
-                tx.put::<tables::Headers>(header.number, header.clone().unseal())?;
-            }
-
-            Ok(())
-        })
+        self.commit(|tx| headers.into_iter().try_for_each(|header| Self::insert_header(tx, header)))
     }
 
     /// Inserts total difficulty of headers into the corresponding tables.
@@ -204,23 +212,19 @@ impl TestTransaction {
         I: Iterator<Item = &'a SealedHeader>,
     {
         self.commit(|tx| {
-            let headers = headers.collect::<Vec<_>>();
-
             let mut td = U256::ZERO;
-            for header in headers {
+            headers.into_iter().try_for_each(|header| {
+                Self::insert_header(tx, header)?;
                 td += header.difficulty;
-                tx.put::<tables::HeaderTD>(header.number, td.into())?;
-                tx.put::<tables::CanonicalHeaders>(header.number, header.hash())?;
-                tx.put::<tables::HeaderNumbers>(header.hash(), header.number)?;
-                tx.put::<tables::Headers>(header.number, header.clone().unseal())?;
-            }
-
-            Ok(())
+                tx.put::<tables::HeaderTD>(header.number, td.into())
+            })
         })
     }
 
     /// Insert ordered collection of [SealedBlock] into corresponding tables.
     /// Superset functionality of [TestTransaction::insert_headers].
+    ///
+    /// Assumes that there's a single transition for each transaction (i.e. no block rewards).
     pub fn insert_blocks<'a, I>(&self, blocks: I, tx_offset: Option<u64>) -> Result<(), DbError>
     where
         I: Iterator<Item = &'a SealedBlock>,
@@ -228,12 +232,8 @@ impl TestTransaction {
         self.commit(|tx| {
             let mut current_tx_id = tx_offset.unwrap_or_default();
 
-            for block in blocks {
-                // Insert into header tables.
-                tx.put::<tables::CanonicalHeaders>(block.number, block.hash())?;
-                tx.put::<tables::HeaderNumbers>(block.hash(), block.number)?;
-                tx.put::<tables::Headers>(block.number, block.header.clone().unseal())?;
-
+            blocks.into_iter().try_for_each(|block| {
+                Self::insert_header(tx, &block.header)?;
                 // Insert into body tables.
                 tx.put::<tables::BlockBodies>(
                     block.number,
@@ -242,13 +242,88 @@ impl TestTransaction {
                         tx_count: block.body.len() as u64,
                     },
                 )?;
-                for body_tx in block.body.clone() {
-                    tx.put::<tables::Transactions>(current_tx_id, body_tx)?;
+                block.body.iter().try_for_each(|body_tx| {
+                    tx.put::<tables::TxTransitionIndex>(current_tx_id, current_tx_id)?;
+                    tx.put::<tables::Transactions>(current_tx_id, body_tx.clone())?;
                     current_tx_id += 1;
-                }
-            }
+                    Ok(())
+                })?;
+                tx.put::<tables::BlockTransitionIndex>(block.number, current_tx_id)
+            })
+        })
+    }
 
-            Ok(())
+    /// Insert collection of ([Address], [Account]) into corresponding tables.
+    pub fn insert_accounts_and_storages<I, S>(&self, accounts: I) -> Result<(), DbError>
+    where
+        I: IntoIterator<Item = (Address, (Account, S))>,
+        S: IntoIterator<Item = StorageEntry>,
+    {
+        self.commit(|tx| {
+            accounts.into_iter().try_for_each(|(address, (account, storage))| {
+                let hashed_address = keccak256(address);
+
+                // Insert into account tables.
+                tx.put::<tables::PlainAccountState>(address, account)?;
+                tx.put::<tables::HashedAccount>(hashed_address, account)?;
+
+                // Insert into storage tables.
+                storage.into_iter().filter(|e| e.value != U256::ZERO).try_for_each(|entry| {
+                    let hashed_entry = StorageEntry { key: keccak256(entry.key), ..entry };
+
+                    let mut cursor = tx.cursor_dup_write::<tables::PlainStorageState>()?;
+                    if let Some(e) = cursor
+                        .seek_by_key_subkey(address, entry.key)?
+                        .filter(|e| e.key == entry.key)
+                    {
+                        cursor.delete_current()?;
+                    }
+                    cursor.upsert(address, entry)?;
+
+                    let mut cursor = tx.cursor_dup_write::<tables::HashedStorage>()?;
+                    if let Some(e) = cursor
+                        .seek_by_key_subkey(hashed_address, hashed_entry.key)?
+                        .filter(|e| e.key == hashed_entry.key)
+                    {
+                        cursor.delete_current()?;
+                    }
+                    cursor.upsert(hashed_address, hashed_entry)?;
+
+                    Ok(())
+                })
+            })
+        })
+    }
+
+    /// Insert collection of Vec<([Address], [Account], Vec<[StorageEntry]>)> into
+    /// corresponding tables.
+    pub fn insert_transitions<I>(
+        &self,
+        transitions: I,
+        transition_offset: Option<u64>,
+    ) -> Result<(), DbError>
+    where
+        I: IntoIterator<Item = Vec<(Address, Account, Vec<StorageEntry>)>>,
+    {
+        let offset = transition_offset.unwrap_or_default();
+        self.commit(|tx| {
+            transitions.into_iter().enumerate().try_for_each(|(transition_id, changes)| {
+                changes.into_iter().try_for_each(|(address, old_account, old_storage)| {
+                    let tid = offset + transition_id as u64;
+                    // Insert into account changeset.
+                    tx.put::<tables::AccountChangeSet>(
+                        tid,
+                        AccountBeforeTx { address, info: Some(old_account) },
+                    )?;
+
+                    let tid_address = (tid, address).into();
+
+                    // Insert into storage changeset.
+                    old_storage.into_iter().try_for_each(|entry| {
+                        tx.put::<tables::StorageChangeSet>(tid_address, entry)
+                    })
+                })
+            })
         })
     }
 }
diff --git a/crates/stages/src/trie/mod.rs b/crates/stages/src/trie/mod.rs
deleted file mode 100644
index d5f4cb94b80..00000000000
--- a/crates/stages/src/trie/mod.rs
+++ /dev/null
@@ -1,631 +0,0 @@
-use cita_trie::{PatriciaTrie, Trie};
-use hasher::HasherKeccak;
-use reth_db::{
-    cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO},
-    database::Database,
-    models::{AccountBeforeTx, TransitionIdAddress},
-    tables,
-    transaction::{DbTx, DbTxMut},
-};
-use reth_primitives::{
-    keccak256, proofs::EMPTY_ROOT, Account, Address, StorageEntry, StorageTrieEntry, TransitionId,
-    H256, KECCAK_EMPTY, U256,
-};
-use reth_provider::Transaction;
-use reth_rlp::{
-    encode_fixed_size, Decodable, DecodeError, Encodable, RlpDecodable, RlpEncodable,
-    EMPTY_STRING_CODE,
-};
-use std::{
-    collections::{BTreeMap, BTreeSet},
-    ops::Range,
-    sync::Arc,
-};
-use tracing::*;
-
-#[derive(Debug, thiserror::Error)]
-pub(crate) enum TrieError {
-    #[error("Some error occurred: {0}")]
-    InternalError(#[from] cita_trie::TrieError),
-    #[error("The root node wasn't found in the DB")]
-    MissingRoot(H256),
-    #[error("{0:?}")]
-    DatabaseError(#[from] reth_db::Error),
-    #[error("{0:?}")]
-    DecodeError(#[from] DecodeError),
-}
-
-/// Database wrapper implementing HashDB trait.
-struct HashDatabase<'tx, 'itx, DB: Database> {
-    tx: &'tx Transaction<'itx, DB>,
-}
-
-impl<'tx, 'itx, DB> cita_trie::DB for HashDatabase<'tx, 'itx, DB>
-where
-    DB: Database,
-{
-    type Error = TrieError;
-
-    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
-        Ok(self.tx.get::<tables::AccountsTrie>(H256::from_slice(key))?)
-    }
-
-    fn contains(&self, key: &[u8]) -> Result<bool, Self::Error> {
-        Ok(<Self as cita_trie::DB>::get(self, key)?.is_some())
-    }
-
-    fn insert(&self, key: Vec<u8>, value: Vec<u8>) -> Result<(), Self::Error> {
-        // Caching and bulk inserting shouldn't be needed, as the data is ordered
-        self.tx.put::<tables::AccountsTrie>(H256::from_slice(key.as_slice()), value)?;
-        Ok(())
-    }
-
-    fn remove(&self, key: &[u8]) -> Result<(), Self::Error> {
-        self.tx.delete::<tables::AccountsTrie>(H256::from_slice(key), None)?;
-        Ok(())
-    }
-
-    fn flush(&self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-}
-
-impl<'tx, 'itx, DB: Database> HashDatabase<'tx, 'itx, DB> {
-    /// Instantiates a new Database for the accounts trie, with an empty root
-    fn new(tx: &'tx Transaction<'itx, DB>) -> Result<Self, TrieError> {
-        let root = EMPTY_ROOT;
-        if tx.get::<tables::AccountsTrie>(root)?.is_none() {
-            tx.put::<tables::AccountsTrie>(root, [EMPTY_STRING_CODE].to_vec())?;
-        }
-        Ok(Self { tx })
-    }
-
-    /// Instantiates a new Database for the accounts trie, with an existing root
-    fn from_root(tx: &'tx Transaction<'itx, DB>, root: H256) -> Result<Self, TrieError> {
-        if root == EMPTY_ROOT {
-            return Self::new(tx)
-        }
-        tx.get::<tables::AccountsTrie>(root)?.ok_or(TrieError::MissingRoot(root))?;
-        Ok(Self { tx })
-    }
-}
-
-/// Database wrapper implementing HashDB trait.
-struct DupHashDatabase<'tx, 'itx, DB: Database> {
-    tx: &'tx Transaction<'itx, DB>,
-    key: H256,
-}
-
-impl<'tx, 'itx, DB> cita_trie::DB for DupHashDatabase<'tx, 'itx, DB>
-where
-    DB: Database,
-{
-    type Error = TrieError;
-
-    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
-        let mut cursor = self.tx.cursor_dup_read::<tables::StoragesTrie>()?;
-        Ok(cursor.seek_by_key_subkey(self.key, H256::from_slice(key))?.map(|entry| entry.node))
-    }
-
-    fn contains(&self, key: &[u8]) -> Result<bool, Self::Error> {
-        Ok(<Self as cita_trie::DB>::get(self, key)?.is_some())
-    }
-
-    fn insert(&self, key: Vec<u8>, value: Vec<u8>) -> Result<(), Self::Error> {
-        // Caching and bulk inserting shouldn't be needed, as the data is ordered
-        self.tx.put::<tables::StoragesTrie>(
-            self.key,
-            StorageTrieEntry { hash: H256::from_slice(key.as_slice()), node: value },
-        )?;
-        Ok(())
-    }
-
-    fn remove(&self, key: &[u8]) -> Result<(), Self::Error> {
-        let mut cursor = self.tx.cursor_dup_write::<tables::StoragesTrie>()?;
-        cursor
-            .seek_by_key_subkey(self.key, H256::from_slice(key))?
-            .map(|_| cursor.delete_current())
-            .transpose()?;
-        Ok(())
-    }
-
-    fn flush(&self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-}
-
-impl<'tx, 'itx, DB: Database> DupHashDatabase<'tx, 'itx, DB> {
-    /// Instantiates a new Database for the storage trie, with an empty root
-    fn new(tx: &'tx Transaction<'itx, DB>, key: H256) -> Result<Self, TrieError> {
-        let root = EMPTY_ROOT;
-        let mut cursor = tx.cursor_dup_write::<tables::StoragesTrie>()?;
-        if cursor.seek_by_key_subkey(key, root)?.is_none() {
-            tx.put::<tables::StoragesTrie>(
-                key,
-                StorageTrieEntry { hash: root, node: [EMPTY_STRING_CODE].to_vec() },
-            )?;
-        }
-        Ok(Self { tx, key })
-    }
-
-    /// Instantiates a new Database for the storage trie, with an existing root
-    fn from_root(tx: &'tx Transaction<'itx, DB>, key: H256, root: H256) -> Result<Self, TrieError> {
-        if root == EMPTY_ROOT {
-            return Self::new(tx, key)
-        }
-        tx.cursor_dup_read::<tables::StoragesTrie>()?
-            .seek_by_key_subkey(key, root)?
-            .ok_or(TrieError::MissingRoot(root))?;
-        Ok(Self { tx, key })
-    }
-}
-
-/// An Ethereum account, for RLP encoding traits deriving.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, RlpEncodable, RlpDecodable)]
-pub(crate) struct EthAccount {
-    /// Account nonce.
-    nonce: u64,
-    /// Account balance.
-    balance: U256,
-    /// Account's storage root.
-    storage_root: H256,
-    /// Hash of the account's bytecode.
-    code_hash: H256,
-}
-
-impl From<Account> for EthAccount {
-    fn from(acc: Account) -> Self {
-        EthAccount {
-            nonce: acc.nonce,
-            balance: acc.balance,
-            storage_root: EMPTY_ROOT,
-            code_hash: acc.bytecode_hash.unwrap_or(KECCAK_EMPTY),
-        }
-    }
-}
-
-impl EthAccount {
-    pub(crate) fn from_with_root(acc: Account, storage_root: H256) -> EthAccount {
-        Self { storage_root, ..Self::from(acc) }
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct DBTrieLoader;
-
-impl DBTrieLoader {
-    /// Calculates the root of the state trie, saving intermediate hashes in the database.
-    pub(crate) fn calculate_root<DB: Database>(
-        &self,
-        tx: &Transaction<'_, DB>,
-    ) -> Result<H256, TrieError> {
-        tx.clear::<tables::AccountsTrie>()?;
-        tx.clear::<tables::StoragesTrie>()?;
-
-        let mut accounts_cursor = tx.cursor_read::<tables::HashedAccount>()?;
-        let mut walker = accounts_cursor.walk(None)?;
-
-        let db = Arc::new(HashDatabase::new(tx)?);
-
-        let hasher = Arc::new(HasherKeccak::new());
-
-        let mut trie = PatriciaTrie::new(Arc::clone(&db), Arc::clone(&hasher));
-
-        while let Some((hashed_address, account)) = walker.next().transpose()? {
-            let value = EthAccount::from_with_root(
-                account,
-                self.calculate_storage_root(tx, hashed_address)?,
-            );
-
-            let mut out = Vec::new();
-            Encodable::encode(&value, &mut out);
-            trie.insert(hashed_address.as_bytes().to_vec(), out)?;
-        }
-        let root = H256::from_slice(trie.root()?.as_slice());
-
-        Ok(root)
-    }
-
-    fn calculate_storage_root<DB: Database>(
-        &self,
-        tx: &Transaction<'_, DB>,
-        address: H256,
-    ) -> Result<H256, TrieError> {
-        let db = Arc::new(DupHashDatabase::new(tx, address)?);
-
-        let hasher = Arc::new(HasherKeccak::new());
-
-        let mut trie = PatriciaTrie::new(Arc::clone(&db), Arc::clone(&hasher));
-
-        let mut storage_cursor = tx.cursor_dup_read::<tables::HashedStorage>()?;
-
-        // Should be able to use walk_dup, but any call to next() causes an assert fail in mdbx.c
-        // let mut walker = storage_cursor.walk_dup(address, H256::zero())?;
-        let mut current = storage_cursor.seek_by_key_subkey(address, H256::zero())?;
-
-        while let Some(StorageEntry { key: storage_key, value }) = current {
-            let out = encode_fixed_size(&value).to_vec();
-            trie.insert(storage_key.to_vec(), out)?;
-            current = storage_cursor.next_dup()?.map(|(_, v)| v);
-        }
-
-        let root = H256::from_slice(trie.root()?.as_slice());
-
-        Ok(root)
-    }
-
-    /// Calculates the root of the state trie by updating an existing trie.
-    pub(crate) fn update_root<DB: Database>(
-        &self,
-        tx: &Transaction<'_, DB>,
-        root: H256,
-        tid_range: Range<TransitionId>,
-    ) -> Result<H256, TrieError> {
-        let mut accounts_cursor = tx.cursor_read::<tables::HashedAccount>()?;
-
-        let changed_accounts = self.gather_changes(tx, tid_range)?;
-
-        let db = Arc::new(HashDatabase::from_root(tx, root)?);
-
-        let hasher = Arc::new(HasherKeccak::new());
-
-        let mut trie = PatriciaTrie::from(Arc::clone(&db), Arc::clone(&hasher), root.as_bytes())?;
-
-        for (address, changed_storages) in changed_accounts {
-            if let Some(account) = trie.get(address.as_slice())? {
-                let storage_root = EthAccount::decode(&mut account.as_slice())?.storage_root;
-                trie.remove(address.as_bytes())?;
-
-                if let Some((_, account)) = accounts_cursor.seek_exact(address)? {
-                    let value = EthAccount::from_with_root(
-                        account,
-                        self.update_storage_root(tx, storage_root, address, changed_storages)?,
-                    );
-
-                    let mut out = Vec::new();
-                    Encodable::encode(&value, &mut out);
-                    trie.insert(address.as_bytes().to_vec(), out)?;
-                }
-            }
-        }
-
-        let root = H256::from_slice(trie.root()?.as_slice());
-
-        Ok(root)
-    }
-
-    fn update_storage_root<DB: Database>(
-        &self,
-        tx: &Transaction<'_, DB>,
-        root: H256,
-        address: H256,
-        changed_storages: BTreeSet<H256>,
-    ) -> Result<H256, TrieError> {
-        let db = Arc::new(DupHashDatabase::from_root(tx, address, root)?);
-
-        let hasher = Arc::new(HasherKeccak::new());
-
-        let mut trie = PatriciaTrie::from(Arc::clone(&db), Arc::clone(&hasher), root.as_bytes())?;
-        let mut storage_cursor = tx.cursor_dup_read::<tables::HashedStorage>()?;
-
-        for key in changed_storages {
-            if let Some(StorageEntry { value, .. }) =
-                storage_cursor.seek_by_key_subkey(address, key)?
-            {
-                let out = encode_fixed_size(&value).to_vec();
-                trie.insert(key.as_bytes().to_vec(), out)?;
-            } else {
-                trie.remove(key.as_bytes())?;
-            }
-        }
-
-        let root = H256::from_slice(trie.root()?.as_slice());
-
-        Ok(root)
-    }
-
-    fn gather_changes<DB: Database>(
-        &self,
-        tx: &Transaction<'_, DB>,
-        tid_range: Range<TransitionId>,
-    ) -> Result<BTreeMap<H256, BTreeSet<H256>>, TrieError> {
-        let mut account_cursor = tx.cursor_read::<tables::AccountChangeSet>()?;
-
-        let mut account_changes: BTreeMap<Address, BTreeSet<H256>> = BTreeMap::new();
-
-        let mut walker = account_cursor.walk_range(tid_range.clone())?;
-
-        while let Some((_, AccountBeforeTx { address, .. })) = walker.next().transpose()? {
-            account_changes.insert(address, Default::default());
-        }
-
-        let mut storage_cursor = tx.cursor_dup_read::<tables::StorageChangeSet>()?;
-
-        let start = TransitionIdAddress((tid_range.start, Address::zero()));
-        let end = TransitionIdAddress((tid_range.end, Address::zero()));
-        let mut walker = storage_cursor.walk_range(start..end)?;
-
-        while let Some((TransitionIdAddress((_, address)), StorageEntry { key, .. })) =
-            walker.next().transpose()?
-        {
-            account_changes.entry(address).or_default().insert(key);
-        }
-
-        let hashed_changes = account_changes
-            .into_iter()
-            .map(|(address, storage)| {
-                (keccak256(address), storage.into_iter().map(keccak256).collect())
-            })
-            .collect();
-
-        Ok(hashed_changes)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use assert_matches::assert_matches;
-    use proptest::{prelude::ProptestConfig, proptest};
-    use reth_db::{mdbx::test_utils::create_test_rw_db, tables, transaction::DbTxMut};
-    use reth_primitives::{
-        hex_literal::hex,
-        keccak256,
-        proofs::{genesis_state_root, KeccakHasher, EMPTY_ROOT},
-        Address, ChainSpec,
-    };
-    use reth_staged_sync::utils::chainspec::chain_spec_value_parser;
-    use std::{collections::HashMap, str::FromStr};
-    use triehash::sec_trie_root;
-
-    #[test]
-    fn empty_trie() {
-        let trie = DBTrieLoader::default();
-        let db = create_test_rw_db();
-        let tx = Transaction::new(db.as_ref()).unwrap();
-        assert_matches!(trie.calculate_root(&tx), Ok(got) if got == EMPTY_ROOT);
-    }
-
-    #[test]
-    fn single_account_trie() {
-        let trie = DBTrieLoader::default();
-        let db = create_test_rw_db();
-        let tx = Transaction::new(db.as_ref()).unwrap();
-        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
-        let account = Account { nonce: 0, balance: U256::ZERO, bytecode_hash: None };
-        tx.put::<tables::HashedAccount>(keccak256(address), account).unwrap();
-        let mut encoded_account = Vec::new();
-        EthAccount::from(account).encode(&mut encoded_account);
-        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>([(address, encoded_account)]).0);
-        assert_matches!(
-            trie.calculate_root(&tx),
-            Ok(got) if got == expected
-        );
-    }
-
-    #[test]
-    fn two_accounts_trie() {
-        let trie = DBTrieLoader::default();
-        let db = create_test_rw_db();
-        let tx = Transaction::new(db.as_ref()).unwrap();
-
-        let accounts = [
-            (
-                Address::from(hex!("9fe4abd71ad081f091bd06dd1c16f7e92927561e")),
-                Account { nonce: 155, balance: U256::from(414241124), bytecode_hash: None },
-            ),
-            (
-                Address::from(hex!("f8a6edaad4a332e6e550d0915a7fd5300b0b12d1")),
-                Account { nonce: 3, balance: U256::from(78978), bytecode_hash: None },
-            ),
-        ];
-        for (address, account) in accounts {
-            tx.put::<tables::HashedAccount>(keccak256(address), account).unwrap();
-        }
-        let encoded_accounts = accounts.iter().map(|(k, v)| {
-            let mut out = Vec::new();
-            EthAccount::from(*v).encode(&mut out);
-            (k, out)
-        });
-        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_accounts).0);
-        assert_matches!(
-            trie.calculate_root(&tx),
-            Ok(got) if got == expected
-        );
-    }
-
-    #[test]
-    fn single_storage_trie() {
-        let trie = DBTrieLoader::default();
-        let db = create_test_rw_db();
-        let tx = Transaction::new(db.as_ref()).unwrap();
-
-        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
-        let hashed_address = keccak256(address);
-
-        let storage = Vec::from([(H256::from_low_u64_be(2), U256::from(1))]);
-        for (k, v) in storage.clone() {
-            tx.put::<tables::HashedStorage>(
-                hashed_address,
-                StorageEntry { key: keccak256(k), value: v },
-            )
-            .unwrap();
-        }
-        let encoded_storage = storage.iter().map(|(k, v)| {
-            let out = encode_fixed_size(v).to_vec();
-            (k, out)
-        });
-        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_storage).0);
-        assert_matches!(
-            trie.calculate_storage_root(&tx, hashed_address),
-            Ok(got) if got == expected
-        );
-    }
-
-    #[test]
-    fn single_account_with_storage_trie() {
-        let trie = DBTrieLoader::default();
-        let db = create_test_rw_db();
-        let tx = Transaction::new(db.as_ref()).unwrap();
-
-        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
-        let hashed_address = keccak256(address);
-
-        let storage = HashMap::from([
-            (H256::zero(), U256::from(3)),
-            (H256::from_low_u64_be(2), U256::from(1)),
-        ]);
-        let code = "el buen fla";
-        let account = Account {
-            nonce: 155,
-            balance: U256::from(414241124u32),
-            bytecode_hash: Some(keccak256(code)),
-        };
-        tx.put::<tables::HashedAccount>(hashed_address, account).unwrap();
-
-        for (k, v) in storage.clone() {
-            tx.put::<tables::HashedStorage>(
-                hashed_address,
-                StorageEntry { key: keccak256(k), value: v },
-            )
-            .unwrap();
-        }
-        let mut out = Vec::new();
-
-        let encoded_storage = storage.iter().map(|(k, v)| {
-            let out = encode_fixed_size(v).to_vec();
-            (k, out)
-        });
-
-        let eth_account = EthAccount::from_with_root(
-            account,
-            H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_storage).0),
-        );
-        eth_account.encode(&mut out);
-
-        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>([(address, out)]).0);
-        assert_matches!(
-            trie.calculate_root(&tx),
-            Ok(got) if got == expected
-        );
-    }
-
-    #[test]
-    fn verify_genesis() {
-        let trie = DBTrieLoader::default();
-        let db = create_test_rw_db();
-        let mut tx = Transaction::new(db.as_ref()).unwrap();
-        let ChainSpec { genesis, .. } = chain_spec_value_parser("mainnet").unwrap();
-
-        // Insert account state
-        for (address, account) in &genesis.alloc {
-            tx.put::<tables::HashedAccount>(
-                keccak256(address),
-                Account {
-                    nonce: account.nonce.unwrap_or_default(),
-                    balance: account.balance,
-                    bytecode_hash: None,
-                },
-            )
-            .unwrap();
-        }
-        tx.commit().unwrap();
-
-        let state_root = genesis_state_root(&genesis.alloc);
-
-        assert_matches!(
-            trie.calculate_root(&tx),
-            Ok(got) if got == state_root
-        );
-    }
-
-    #[test]
-    fn gather_changes() {
-        let db = create_test_rw_db();
-        let tx = Transaction::new(db.as_ref()).unwrap();
-
-        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
-        let hashed_address = keccak256(address);
-
-        let storage = HashMap::from([
-            (H256::zero(), U256::from(3)),
-            (H256::from_low_u64_be(2), U256::from(1)),
-        ]);
-        let code = "el buen fla";
-        let account = Account {
-            nonce: 155,
-            balance: U256::from(414241124u32),
-            bytecode_hash: Some(keccak256(code)),
-        };
-        tx.put::<tables::HashedAccount>(hashed_address, account).unwrap();
-        tx.put::<tables::AccountChangeSet>(31, AccountBeforeTx { address, info: None }).unwrap();
-
-        for (k, v) in storage {
-            tx.put::<tables::HashedStorage>(
-                hashed_address,
-                StorageEntry { key: keccak256(k), value: v },
-            )
-            .unwrap();
-            tx.put::<tables::StorageChangeSet>(
-                (32, address).into(),
-                StorageEntry { key: k, value: U256::ZERO },
-            )
-            .unwrap();
-        }
-
-        let expected = BTreeMap::from([(
-            hashed_address,
-            BTreeSet::from([keccak256(H256::zero()), keccak256(H256::from_low_u64_be(2))]),
-        )]);
-        assert_matches!(
-            DBTrieLoader::default().gather_changes(&tx, 32..33),
-            Ok(got) if got == expected
-        );
-    }
-
-    fn test_with_accounts(accounts: BTreeMap<Address, (Account, BTreeSet<StorageEntry>)>) {
-        let trie = DBTrieLoader::default();
-        let db = create_test_rw_db();
-        let tx = Transaction::new(db.as_ref()).unwrap();
-
-        let encoded_accounts = accounts
-            .into_iter()
-            .map(|(address, (account, storage))| {
-                let hashed_address = keccak256(address);
-                tx.put::<tables::HashedAccount>(hashed_address, account).unwrap();
-                // This is to mimic real data. Only contract accounts have storage.
-                let storage_root = if account.has_bytecode() {
-                    let encoded_storage = storage.into_iter().map(|StorageEntry { key, value }| {
-                        let hashed_key = keccak256(key);
-                        let out = encode_fixed_size(&value).to_vec();
-                        tx.put::<tables::HashedStorage>(
-                            hashed_address,
-                            StorageEntry { key: hashed_key, value },
-                        )
-                        .unwrap();
-                        (key, out)
-                    });
-                    H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_storage).0)
-                } else {
-                    EMPTY_ROOT
-                };
-                let mut out = Vec::new();
-                EthAccount::from_with_root(account, storage_root).encode(&mut out);
-                (address, out)
-            })
-            .collect::<Vec<(Address, Vec<u8>)>>();
-
-        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_accounts).0);
-        assert_matches!(
-            trie.calculate_root(&tx),
-            Ok(got) if got == expected
-        , "where expected is {expected:?}");
-    }
-
-    #[test]
-    fn arbitrary() {
-        proptest!(ProptestConfig::with_cases(10), |(accounts: BTreeMap<Address, (Account, BTreeSet<StorageEntry>)>)| {
-            test_with_accounts(accounts);
-        });
-    }
-}
diff --git a/crates/storage/codecs/derive/src/arbitrary.rs b/crates/storage/codecs/derive/src/arbitrary.rs
index 96c259b49ff..61f82057b59 100644
--- a/crates/storage/codecs/derive/src/arbitrary.rs
+++ b/crates/storage/codecs/derive/src/arbitrary.rs
@@ -36,10 +36,12 @@ pub fn maybe_generate_tests(args: TokenStream, ast: &DeriveInput) -> TokenStream
                 {
                     let mut buf = vec![];
 
-                    let len = field.clone().encode(&mut buf);
-                    let decoded = super::#type_ident::decode(&mut buf.as_slice()).unwrap();
-
-                    assert!(field == decoded);
+                    let len = field.encode(&mut buf);
+                    let mut b = &mut buf.as_slice();
+                    let decoded = super::#type_ident::decode(b).unwrap();
+                    assert_eq!(field, decoded);
+                    // ensure buffer is fully consumed by decode
+                    assert!(b.is_empty());
                 }
             });
         } else if let Ok(num) = arg.to_string().parse() {
diff --git a/crates/storage/db/Cargo.toml b/crates/storage/db/Cargo.toml
index 69f8dbd4538..e6c7647d484 100644
--- a/crates/storage/db/Cargo.toml
+++ b/crates/storage/db/Cargo.toml
@@ -22,7 +22,7 @@ parity-scale-codec = { version = "3.2.1", features = ["bytes"] }
 futures = "0.3.25"
 tokio-stream = "0.1.11"
 rand = "0.8.5"
-secp256k1 = { version = "0.24.2", default-features = false, features = [
+secp256k1 = { version = "0.26.0", default-features = false, features = [
     "alloc",
     "recovery",
     "rand",
@@ -59,7 +59,7 @@ tokio = { version = "1.21.2", features = ["full"] }
 reth-db = { path = ".", features = ["test-utils", "bench"] }
 
 # needed for test-fuzz to work properly, see https://github.com/paradigmxyz/reth/pull/177#discussion_r1021172198
-secp256k1 = "0.24.2"
+secp256k1 = "0.26.0"
 
 async-trait = "0.1.58"
 
diff --git a/crates/storage/db/benches/criterion.rs b/crates/storage/db/benches/criterion.rs
index c0f73d160b9..2034f7df428 100644
--- a/crates/storage/db/benches/criterion.rs
+++ b/crates/storage/db/benches/criterion.rs
@@ -147,7 +147,7 @@ where
                         crsr.append(k, v).expect("submit");
                     }
 
-                    tx.inner.commit().unwrap();
+                    tx.inner.commit().unwrap()
                 });
             },
         )
@@ -171,7 +171,7 @@ where
                         crsr.insert(k, v).expect("submit");
                     }
 
-                    tx.inner.commit().unwrap();
+                    tx.inner.commit().unwrap()
                 });
             },
         )
@@ -241,7 +241,7 @@ where
                         crsr.append_dup(k, v).expect("submit");
                     }
 
-                    tx.inner.commit().unwrap();
+                    tx.inner.commit().unwrap()
                 });
             },
         )
diff --git a/crates/storage/db/benches/hash_keys.rs b/crates/storage/db/benches/hash_keys.rs
index b7cb5929747..078ae5bee46 100644
--- a/crates/storage/db/benches/hash_keys.rs
+++ b/crates/storage/db/benches/hash_keys.rs
@@ -39,7 +39,7 @@ pub fn hash_keys(c: &mut Criterion) {
 
     group.sample_size(10);
 
-    for size in vec![10_000, 100_000, 1_000_000] {
+    for size in [10_000, 100_000, 1_000_000] {
         measure_table_insertion::<TxHashNumber>(&mut group, size);
     }
 }
@@ -134,6 +134,7 @@ where
 
 /// Generates two batches. The first is to be inserted into the database before running the
 /// benchmark. The second is to be benchmarked with.
+#[allow(clippy::type_complexity)]
 fn generate_batches<T>(size: usize) -> (Vec<(T::Key, T::Value)>, Vec<(T::Key, T::Value)>)
 where
     T: Table + Default,
@@ -176,7 +177,7 @@ where
                 crsr.append(k, v).expect("submit");
             }
 
-            tx.inner.commit().unwrap();
+            tx.inner.commit().unwrap()
         });
     }
     db
@@ -197,7 +198,7 @@ where
                 crsr.insert(k, v).expect("submit");
             }
 
-            tx.inner.commit().unwrap();
+            tx.inner.commit().unwrap()
         });
     }
     db
@@ -214,7 +215,7 @@ where
                 tx.put::<T>(k, v).expect("submit");
             }
 
-            tx.inner.commit().unwrap();
+            tx.inner.commit().unwrap()
         });
     }
     db
diff --git a/crates/storage/db/benches/utils.rs b/crates/storage/db/benches/utils.rs
index 08d88a9ba09..8f159ec1daa 100644
--- a/crates/storage/db/benches/utils.rs
+++ b/crates/storage/db/benches/utils.rs
@@ -1,3 +1,4 @@
+#[allow(unused_imports)]
 use reth_db::{
     database::Database,
     mdbx::{test_utils::create_test_db_with_path, EnvKind, WriteMap},
@@ -7,12 +8,15 @@ use reth_db::{
 use std::path::Path;
 
 /// Path where the DB is initialized for benchmarks.
+#[allow(unused)]
 const BENCH_DB_PATH: &str = "/tmp/reth-benches";
 
 /// Used for RandomRead and RandomWrite benchmarks.
+#[allow(unused)]
 const RANDOM_INDEXES: [usize; 10] = [23, 2, 42, 5, 3, 99, 54, 0, 33, 64];
 
 /// Returns bench vectors in the format: `Vec<(Key, EncodedKey, Value, CompressedValue)>`.
+#[allow(unused)]
 fn load_vectors<T: reth_db::table::Table>() -> Vec<(T::Key, bytes::Bytes, T::Value, bytes::Bytes)>
 where
     T: Default,
@@ -43,6 +47,7 @@ where
 
 /// Sets up a clear database at `bench_db_path`.
 #[allow(clippy::ptr_arg)]
+#[allow(unused)]
 fn set_up_db<T>(
     bench_db_path: &Path,
     pair: &Vec<(<T as Table>::Key, bytes::Bytes, <T as Table>::Value, bytes::Bytes)>,
diff --git a/crates/storage/db/src/abstraction/common.rs b/crates/storage/db/src/abstraction/common.rs
index 2e990e99ee2..f654a69c092 100644
--- a/crates/storage/db/src/abstraction/common.rs
+++ b/crates/storage/db/src/abstraction/common.rs
@@ -1,7 +1,9 @@
+/// Alias type containing key value pairs.
+pub type KeyValue<T> = (<T as Table>::Key, <T as Table>::Value);
 /// Alias type for a `(key, value)` result coming from a cursor.
-pub type PairResult<T> = Result<Option<(<T as Table>::Key, <T as Table>::Value)>, Error>;
+pub type PairResult<T> = Result<Option<KeyValue<T>>, Error>;
 /// Alias type for a `(key, value)` result coming from an iterator.
-pub type IterPairResult<T> = Option<Result<(<T as Table>::Key, <T as Table>::Value), Error>>;
+pub type IterPairResult<T> = Option<Result<KeyValue<T>, Error>>;
 /// Alias type for a value result coming from a cursor without its key.
 pub type ValueOnlyResult<T> = Result<Option<<T as Table>::Value>, Error>;
 
diff --git a/crates/storage/db/src/abstraction/cursor.rs b/crates/storage/db/src/abstraction/cursor.rs
index c5d1703b22a..16d6e147f6b 100644
--- a/crates/storage/db/src/abstraction/cursor.rs
+++ b/crates/storage/db/src/abstraction/cursor.rs
@@ -73,7 +73,7 @@ pub trait DbDupCursorRO<'tx, T: DupSort> {
     /// Returns the next `value` of a duplicate `key`.
     fn next_dup_val(&mut self) -> ValueOnlyResult<T>;
 
-    /// Seek by key and subkey
+    /// Seek by key and subkey. Make sure that the returned value subkey matches the queried one.
     fn seek_by_key_subkey(&mut self, key: T::Key, subkey: T::SubKey) -> ValueOnlyResult<T>;
 
     /// Returns an iterator starting at a key greater or equal than `start_key` of a DupSort
@@ -159,6 +159,15 @@ impl<'cursor, 'tx, T: Table, CURSOR: DbCursorRO<'tx, T>> Walker<'cursor, 'tx, T,
     }
 }
 
+impl<'cursor, 'tx, T: Table, CURSOR: DbCursorRW<'tx, T> + DbCursorRO<'tx, T>>
+    Walker<'cursor, 'tx, T, CURSOR>
+{
+    /// Delete current item that walker points to.
+    pub fn delete_current(&mut self) -> Result<(), Error> {
+        self.cursor.delete_current()
+    }
+}
+
 /// Provides a reverse iterator to `Cursor` when handling `Table`.
 /// Also check [`Walker`]
 pub struct ReverseWalker<'cursor, 'tx, T: Table, CURSOR: DbCursorRO<'tx, T>> {
@@ -183,6 +192,15 @@ impl<'cursor, 'tx, T: Table, CURSOR: DbCursorRO<'tx, T>> ReverseWalker<'cursor,
     }
 }
 
+impl<'cursor, 'tx, T: Table, CURSOR: DbCursorRW<'tx, T> + DbCursorRO<'tx, T>>
+    ReverseWalker<'cursor, 'tx, T, CURSOR>
+{
+    /// Delete current item that walker points to.
+    pub fn delete_current(&mut self) -> Result<(), Error> {
+        self.cursor.delete_current()
+    }
+}
+
 impl<'cursor, 'tx, T: Table, CURSOR: DbCursorRO<'tx, T>> std::iter::Iterator
     for ReverseWalker<'cursor, 'tx, T, CURSOR>
 {
@@ -268,6 +286,15 @@ impl<'cursor, 'tx, T: Table, CURSOR: DbCursorRO<'tx, T>> RangeWalker<'cursor, 't
     }
 }
 
+impl<'cursor, 'tx, T: Table, CURSOR: DbCursorRW<'tx, T> + DbCursorRO<'tx, T>>
+    RangeWalker<'cursor, 'tx, T, CURSOR>
+{
+    /// Delete current item that walker points to.
+    pub fn delete_current(&mut self) -> Result<(), Error> {
+        self.cursor.delete_current()
+    }
+}
+
 /// Provides an iterator to `Cursor` when handling a `DupSort` table.
 ///
 /// Reason why we have two lifetimes is to distinguish between `'cursor` lifetime
@@ -282,6 +309,15 @@ pub struct DupWalker<'cursor, 'tx, T: DupSort, CURSOR: DbDupCursorRO<'tx, T>> {
     pub _tx_phantom: PhantomData<&'tx T>,
 }
 
+impl<'cursor, 'tx, T: DupSort, CURSOR: DbCursorRW<'tx, T> + DbDupCursorRO<'tx, T>>
+    DupWalker<'cursor, 'tx, T, CURSOR>
+{
+    /// Delete current item that walker points to.
+    pub fn delete_current(&mut self) -> Result<(), Error> {
+        self.cursor.delete_current()
+    }
+}
+
 impl<'cursor, 'tx, T: DupSort, CURSOR: DbDupCursorRO<'tx, T>> std::iter::Iterator
     for DupWalker<'cursor, 'tx, T, CURSOR>
 {
diff --git a/crates/storage/db/src/abstraction/database.rs b/crates/storage/db/src/abstraction/database.rs
index 6a8a9aac673..f6559ac2431 100644
--- a/crates/storage/db/src/abstraction/database.rs
+++ b/crates/storage/db/src/abstraction/database.rs
@@ -43,7 +43,7 @@ pub trait Database: for<'a> DatabaseGAT<'a> {
     /// the end of the execution.
     fn update<T, F>(&self, f: F) -> Result<T, Error>
     where
-        F: Fn(&<Self as DatabaseGAT<'_>>::TXMut) -> T,
+        F: FnOnce(&<Self as DatabaseGAT<'_>>::TXMut) -> T,
     {
         let tx = self.tx_mut()?;
 
diff --git a/crates/storage/db/src/implementation/mdbx/cursor.rs b/crates/storage/db/src/implementation/mdbx/cursor.rs
index cce188f8411..64730b7550b 100644
--- a/crates/storage/db/src/implementation/mdbx/cursor.rs
+++ b/crates/storage/db/src/implementation/mdbx/cursor.rs
@@ -3,6 +3,7 @@
 use std::{borrow::Cow, collections::Bound, marker::PhantomData, ops::RangeBounds};
 
 use crate::{
+    common::{PairResult, ValueOnlyResult},
     cursor::{
         DbCursorRO, DbCursorRW, DbDupCursorRO, DbDupCursorRW, DupWalker, RangeWalker,
         ReverseWalker, Walker,
@@ -13,13 +14,6 @@ use crate::{
 };
 use reth_libmdbx::{self, Error as MDBXError, TransactionKind, WriteFlags, RO, RW};
 
-/// Alias type for a `(key, value)` result coming from a cursor.
-pub type PairResult<T> = Result<Option<(<T as Table>::Key, <T as Table>::Value)>, Error>;
-/// Alias type for a `(key, value)` result coming from an iterator.
-pub type IterPairResult<T> = Option<Result<(<T as Table>::Key, <T as Table>::Value), Error>>;
-/// Alias type for a value result coming from a cursor without its key.
-pub type ValueOnlyResult<T> = Result<Option<<T as Table>::Value>, Error>;
-
 /// Read only Cursor.
 pub type CursorRO<'tx, T> = Cursor<'tx, RO, T>;
 /// Read write cursor.
diff --git a/crates/storage/db/src/implementation/mdbx/mod.rs b/crates/storage/db/src/implementation/mdbx/mod.rs
index 8b9189c6956..92f4860ff89 100644
--- a/crates/storage/db/src/implementation/mdbx/mod.rs
+++ b/crates/storage/db/src/implementation/mdbx/mod.rs
@@ -279,6 +279,7 @@ mod tests {
         assert_eq!(walker.next(), None);
     }
 
+    #[allow(clippy::reversed_empty_ranges)]
     #[test]
     fn db_cursor_walk_range_invalid() {
         let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
diff --git a/crates/storage/db/src/tables/codecs/compact.rs b/crates/storage/db/src/tables/codecs/compact.rs
index a43fe7d76e9..c1689a4d8b8 100644
--- a/crates/storage/db/src/tables/codecs/compact.rs
+++ b/crates/storage/db/src/tables/codecs/compact.rs
@@ -43,7 +43,9 @@ impl_compression_for_compact!(
     StorageTrieEntry,
     StoredBlockBody,
     StoredBlockOmmers,
-    StoredBlockWithdrawals
+    StoredBlockWithdrawals,
+    Bytecode,
+    ProofCheckpoint
 );
 impl_compression_for_compact!(AccountBeforeTx, TransactionSigned);
 impl_compression_for_compact!(CompactU256);
diff --git a/crates/storage/db/src/tables/mod.rs b/crates/storage/db/src/tables/mod.rs
index a88e48a2125..7d058403df5 100644
--- a/crates/storage/db/src/tables/mod.rs
+++ b/crates/storage/db/src/tables/mod.rs
@@ -18,7 +18,7 @@ use crate::{
     },
 };
 use reth_primitives::{
-    Account, Address, BlockHash, BlockNumber, Header, IntegerList, Receipt, StorageEntry,
+    Account, Address, BlockHash, BlockNumber, Bytecode, Header, IntegerList, Receipt, StorageEntry,
     StorageTrieEntry, TransactionSigned, TransitionId, TxHash, TxNumber, H256,
 };
 
@@ -58,8 +58,8 @@ pub const TABLES: [(TableType, &str); 27] = [
     (TableType::Table, AccountsTrie::const_name()),
     (TableType::DupSort, StoragesTrie::const_name()),
     (TableType::Table, TxSenders::const_name()),
-    (TableType::Table, Config::const_name()),
     (TableType::Table, SyncStage::const_name()),
+    (TableType::Table, SyncStageProgress::const_name()),
 ];
 
 #[macro_export]
@@ -290,13 +290,13 @@ table!(
 );
 
 table!(
-    /// Configuration values.
-    ( Config ) ConfigKey | ConfigValue
+    /// Stores the highest synced block number of each stage.
+    ( SyncStage ) StageId | BlockNumber
 );
 
 table!(
-    /// Stores the highest synced block number of each stage.
-    ( SyncStage ) StageId | BlockNumber
+    /// Stores arbitrary data to keep track of a stage first-sync progress.
+    ( SyncStageProgress ) StageId | Vec<u8>
 );
 
 ///
@@ -305,15 +305,8 @@ table!(
 /// List with transaction numbers.
 pub type TransitionList = IntegerList;
 /// Encoded stage id.
-pub type StageId = Vec<u8>;
+pub type StageId = String;
 
 //
 // TODO: Temporary types, until they're properly defined alongside with the Encode and Decode Trait
 //
-
-/// Temporary placeholder type for DB.
-pub type ConfigKey = Vec<u8>;
-/// Temporary placeholder type for DB.
-pub type ConfigValue = Vec<u8>;
-/// Temporary placeholder type for DB.
-pub type Bytecode = Vec<u8>;
diff --git a/crates/storage/db/src/tables/models/blocks.rs b/crates/storage/db/src/tables/models/blocks.rs
index 87226a2bd64..9d2e48b938a 100644
--- a/crates/storage/db/src/tables/models/blocks.rs
+++ b/crates/storage/db/src/tables/models/blocks.rs
@@ -23,7 +23,7 @@ pub type NumTransactions = u64;
 pub struct StoredBlockBody {
     /// The id of the first transaction in this block
     pub start_tx_id: TxNumber,
-    /// The total number of transactions
+    /// The total number of transactions in the block
     pub tx_count: NumTransactions,
 }
 
@@ -40,10 +40,20 @@ impl StoredBlockBody {
         self.start_tx_id.saturating_add(self.tx_count).saturating_sub(1)
     }
 
+    /// First transaction index.
+    pub fn first_tx_index(&self) -> TxNumber {
+        self.start_tx_id
+    }
+
     /// Return a flag whether the block is empty
     pub fn is_empty(&self) -> bool {
         self.tx_count == 0
     }
+
+    /// Return number of transaction inside block
+    pub fn tx_count(&self) -> NumTransactions {
+        self.tx_count
+    }
 }
 
 /// The storage representation of a block ommers.
diff --git a/crates/storage/db/src/tables/models/mod.rs b/crates/storage/db/src/tables/models/mod.rs
index 545eca6366f..5d98e702579 100644
--- a/crates/storage/db/src/tables/models/mod.rs
+++ b/crates/storage/db/src/tables/models/mod.rs
@@ -83,3 +83,16 @@ impl Decode for H256 {
         Ok(H256::from_slice(&value.into()[..]))
     }
 }
+
+impl Encode for String {
+    type Encoded = Vec<u8>;
+    fn encode(self) -> Self::Encoded {
+        self.into_bytes()
+    }
+}
+
+impl Decode for String {
+    fn decode<B: Into<Bytes>>(value: B) -> Result<Self, Error> {
+        String::from_utf8(value.into().to_vec()).map_err(|_| Error::DecodeError)
+    }
+}
diff --git a/crates/storage/libmdbx-rs/src/cursor.rs b/crates/storage/libmdbx-rs/src/cursor.rs
index 4e3e8797231..94a47360f8c 100644
--- a/crates/storage/libmdbx-rs/src/cursor.rs
+++ b/crates/storage/libmdbx-rs/src/cursor.rs
@@ -760,15 +760,13 @@ where
                     let err_code =
                         unsafe { ffi::mdbx_cursor_get(cursor.cursor(), &mut key, &mut data, op) };
 
-                    if err_code == ffi::MDBX_SUCCESS {
-                        Some(IntoIter::new(
+                    (err_code == ffi::MDBX_SUCCESS).then(|| {
+                        IntoIter::new(
                             Cursor::new_at_position(&**cursor).unwrap(),
                             ffi::MDBX_GET_CURRENT,
                             ffi::MDBX_NEXT_DUP,
-                        ))
-                    } else {
-                        None
-                    }
+                        )
+                    })
                 })
             }
             IterDup::Err(err) => err.take().map(|e| IntoIter::Err(Some(e))),
diff --git a/crates/storage/provider/Cargo.toml b/crates/storage/provider/Cargo.toml
index 509009cbaf2..129830d4059 100644
--- a/crates/storage/provider/Cargo.toml
+++ b/crates/storage/provider/Cargo.toml
@@ -13,18 +13,36 @@ reth-primitives = { path = "../../primitives" }
 reth-interfaces = { path = "../../interfaces" }
 reth-revm-primitives = { path = "../../revm/revm-primitives" }
 reth-db = { path = "../db" }
+reth-codecs = { path = "../codecs" }
+reth-tracing = {path = "../../tracing"}
+reth-rlp = {path = "../../rlp"}
+
+revm-primitives = "1.0.0"
+
+# trie
+cita_trie = "4.0.0"
+hasher = "0.1.4"
+
+# tracing
+tracing = "0.1"
 
 # misc
 thiserror = "1.0.37"
 auto_impl = "1.0"
+itertools = "0.10"
 
 # feature test-utils
 parking_lot = { version = "0.12", optional = true }
-revm-primitives = "1.0"
 
 [dev-dependencies]
 reth-db = { path = "../db", features = ["test-utils"] }
+reth-primitives = { path = "../../primitives", features = ["arbitrary"] }
 parking_lot = "0.12"
+proptest = { version = "1.0" }
+assert_matches = "1.5"
+
+# trie
+triehash = "0.8"
 
 [features]
 bench = []
diff --git a/crates/storage/provider/src/lib.rs b/crates/storage/provider/src/lib.rs
index d7941257ae6..6acc1306037 100644
--- a/crates/storage/provider/src/lib.rs
+++ b/crates/storage/provider/src/lib.rs
@@ -11,8 +11,9 @@
 /// Various provider traits.
 mod traits;
 pub use traits::{
-    AccountProvider, BlockHashProvider, BlockIdProvider, BlockProvider, EvmEnvProvider,
-    HeaderProvider, StateProvider, StateProviderFactory, TransactionsProvider, WithdrawalsProvider,
+    AccountProvider, BlockExecutor, BlockHashProvider, BlockIdProvider, BlockProvider,
+    EvmEnvProvider, ExecutorFactory, HeaderProvider, ReceiptProvider, StateProvider,
+    StateProviderFactory, TransactionsProvider, WithdrawalsProvider,
 };
 
 /// Provider trait implementations.
@@ -22,6 +23,12 @@ pub use providers::{
     LatestStateProviderRef, ShareableDatabase,
 };
 
+/// Helper type for loading Merkle Patricia Trees from the database
+pub mod trie;
+
+/// Execution result
+pub mod post_state;
+
 /// Helper types for interacting with the database
 mod transaction;
 pub use transaction::{Transaction, TransactionError};
diff --git a/crates/storage/provider/src/post_state.rs b/crates/storage/provider/src/post_state.rs
new file mode 100644
index 00000000000..f425c10f979
--- /dev/null
+++ b/crates/storage/provider/src/post_state.rs
@@ -0,0 +1,841 @@
+//! Output of execution.
+use reth_db::{
+    cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO, DbDupCursorRW},
+    models::{AccountBeforeTx, TransitionIdAddress},
+    tables,
+    transaction::{DbTx, DbTxMut},
+    Error as DbError,
+};
+use reth_primitives::{
+    Account, Address, Bytecode, Receipt, StorageEntry, TransitionId, H256, U256,
+};
+use std::collections::BTreeMap;
+
+/// Storage for an account.
+///
+/// # Wiped Storage
+///
+/// The field `wiped` denotes whether any of the values contained in storage are valid or not; if
+/// `wiped` is `true`, the storage should be considered empty.
+#[derive(Debug, Default, Clone, Eq, PartialEq)]
+pub struct Storage {
+    /// Whether the storage was wiped or not.
+    pub wiped: bool,
+    /// The storage slots.
+    pub storage: BTreeMap<U256, U256>,
+}
+
+/// Storage for an account with the old and new values for each slot.
+/// TODO: Do we actually need (old, new) anymore, or is (old) sufficient? (Check the writes)
+/// If we don't, we can unify this and [Storage].
+pub type StorageChangeset = BTreeMap<U256, (U256, U256)>;
+
+/// A change to the state of accounts or storage.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Change {
+    /// A new account was created.
+    AccountCreated {
+        /// The ID of the transition this change is a part of.
+        id: TransitionId,
+        /// The address of the account that was created.
+        address: Address,
+        /// The account.
+        account: Account,
+    },
+    /// An existing account was changed.
+    AccountChanged {
+        /// The ID of the transition this change is a part of.
+        id: TransitionId,
+        /// The address of the account that was changed.
+        address: Address,
+        /// The account before the change.
+        old: Account,
+        /// The account after the change.
+        new: Account,
+    },
+    /// Storage slots for an account were changed.
+    StorageChanged {
+        /// The ID of the transition this change is a part of.
+        id: TransitionId,
+        /// The address of the account associated with the storage slots.
+        address: Address,
+        /// The storage changeset.
+        changeset: StorageChangeset,
+    },
+    /// Storage was wiped
+    StorageWiped {
+        /// The ID of the transition this change is a part of.
+        id: TransitionId,
+        /// The address of the account whose storage was wiped.
+        address: Address,
+    },
+    /// An account was destroyed.
+    ///
+    /// This removes all of the information associated with the account. An accompanying
+    /// [Change::StorageWiped] will also be present to mark the deletion of storage.
+    ///
+    /// If a change to an account satisfies the conditions for EIP-158, this change variant is also
+    /// applied instead of the change that would otherwise have happened.
+    AccountDestroyed {
+        /// The ID of the transition this change is a part of.
+        id: TransitionId,
+        /// The address of the destroyed account.
+        address: Address,
+        /// The account before it was destroyed.
+        old: Account,
+    },
+}
+
+impl Change {
+    /// Get the transition ID for the change
+    pub fn transition_id(&self) -> TransitionId {
+        match self {
+            Change::AccountChanged { id, .. } |
+            Change::AccountCreated { id, .. } |
+            Change::StorageChanged { id, .. } |
+            Change::StorageWiped { id, .. } |
+            Change::AccountDestroyed { id, .. } => *id,
+        }
+    }
+
+    /// Get the address of the account this change operates on.
+    pub fn address(&self) -> Address {
+        match self {
+            Change::AccountChanged { address, .. } |
+            Change::AccountCreated { address, .. } |
+            Change::StorageChanged { address, .. } |
+            Change::StorageWiped { address, .. } |
+            Change::AccountDestroyed { address, .. } => *address,
+        }
+    }
+
+    /// Set the transition ID of this change.
+    pub fn set_transition_id(&mut self, new_id: TransitionId) {
+        match self {
+            Change::AccountChanged { ref mut id, .. } |
+            Change::AccountCreated { ref mut id, .. } |
+            Change::StorageChanged { ref mut id, .. } |
+            Change::StorageWiped { ref mut id, .. } |
+            Change::AccountDestroyed { ref mut id, .. } => {
+                *id = new_id;
+            }
+        }
+    }
+}
+
+/// The state of accounts after execution of one or more transactions, including receipts and new
+/// bytecode.
+///
+/// The latest state can be found in `accounts`, `storage`, and `bytecode`. The receipts for the
+/// transactions that lead to these changes can be found in `receipts`, and each change leading to
+/// this state can be found in `changes`.
+///
+/// # Wiped Storage
+///
+/// The [Storage] type has a field, `wiped`, which denotes whether any of the values contained
+/// in storage are valid or not; if `wiped` is `true`, the storage for the account should be
+/// considered empty.
+///
+/// # Transitions
+///
+/// Each [Change] has an `id` field that marks what transition it is part of. Each transaction is
+/// its own transition, but there may be 0 or 1 transitions associated with the block.
+///
+/// The block level transition includes:
+///
+/// - Block rewards
+/// - Ommer rewards
+/// - Withdrawals
+/// - The irregular state change for the DAO hardfork
+///
+/// [PostState::finish_transition] *must* be called after every transaction, and after every block.
+///
+/// The first transaction executed and added to the [PostState] has a transition ID of 0, the next
+/// one a transition ID of 1, and so on. If the [PostState] is for a single block, and the number of
+/// transitions ([PostState::transitions_count]) is greater than the number of transactions in the
+/// block, then the last transition is the block transition.
+///
+/// For multi-block [PostState]s it is not possible to figure out what transition ID maps on to a
+/// transaction or a block.
+///
+/// # Shaving Allocations
+///
+/// Since most [PostState]s in reth are for multiple blocks it is better to pre-allocate capacity
+/// for receipts and changes, which [PostState::new] does, and thus it (or
+/// [PostState::with_tx_capacity]) should be preferred to using the [Default] implementation.
+#[derive(Debug, Default, Clone, Eq, PartialEq)]
+pub struct PostState {
+    /// The ID of the current transition.
+    current_transition_id: TransitionId,
+    /// The state of all modified accounts after execution.
+    ///
+    /// If the value contained is `None`, then the account should be deleted.
+    accounts: BTreeMap<Address, Option<Account>>,
+    /// The state of all modified storage after execution
+    ///
+    /// If the contained [Storage] is marked as wiped, then all storage values should be cleared
+    /// from the database.
+    storage: BTreeMap<Address, Storage>,
+    /// The changes to state that happened during execution
+    changes: Vec<Change>,
+    /// New code created during the execution
+    bytecode: BTreeMap<H256, Bytecode>,
+    /// The receipt(s) of the executed transaction(s).
+    receipts: Vec<Receipt>,
+}
+
+/// Used to determine preallocation sizes of [PostState]'s internal [Vec]s. It denotes the number of
+/// best-guess changes each transaction causes to state.
+const BEST_GUESS_CHANGES_PER_TX: usize = 8;
+
+/// How many [Change]s to preallocate for in [PostState].
+///
+/// This is just a guesstimate based on:
+///
+/// - Each block having ~200-300 transactions
+/// - Each transaction having some amount of changes
+const PREALLOC_CHANGES_SIZE: usize = 256 * BEST_GUESS_CHANGES_PER_TX;
+
+impl PostState {
+    /// Create an empty [PostState].
+    pub fn new() -> Self {
+        Self { changes: Vec::with_capacity(PREALLOC_CHANGES_SIZE), ..Default::default() }
+    }
+
+    /// Create an empty [PostState] with pre-allocated space for a certain amount of transactions.
+    pub fn with_tx_capacity(txs: usize) -> Self {
+        Self {
+            changes: Vec::with_capacity(txs * BEST_GUESS_CHANGES_PER_TX),
+            receipts: Vec::with_capacity(txs),
+            ..Default::default()
+        }
+    }
+
+    /// Get the latest state of accounts.
+    pub fn accounts(&self) -> &BTreeMap<Address, Option<Account>> {
+        &self.accounts
+    }
+
+    /// Get the latest state for a specific account.
+    ///
+    /// # Returns
+    ///
+    /// - `None` if the account does not exist
+    /// - `Some(&None)` if the account existed, but has since been deleted.
+    /// - `Some(..)` if the account currently exists
+    pub fn account(&self, address: &Address) -> Option<&Option<Account>> {
+        self.accounts.get(address)
+    }
+
+    /// Get the latest state of storage.
+    pub fn storage(&self) -> &BTreeMap<Address, Storage> {
+        &self.storage
+    }
+
+    /// Get the storage for an account.
+    pub fn account_storage(&self, address: &Address) -> Option<&Storage> {
+        self.storage.get(address)
+    }
+
+    /// Get the changes causing this [PostState].
+    pub fn changes(&self) -> &[Change] {
+        &self.changes
+    }
+
+    /// Get the newly created bytecodes
+    pub fn bytecodes(&self) -> &BTreeMap<H256, Bytecode> {
+        &self.bytecode
+    }
+
+    /// Get a bytecode in the post-state.
+    pub fn bytecode(&self, code_hash: &H256) -> Option<&Bytecode> {
+        self.bytecode.get(code_hash)
+    }
+
+    /// Get the receipts for the transactions executed to form this [PostState].
+    pub fn receipts(&self) -> &[Receipt] {
+        &self.receipts
+    }
+
+    /// Get the number of transitions causing this [PostState]
+    pub fn transitions_count(&self) -> usize {
+        self.current_transition_id as usize
+    }
+
+    /// Extend this [PostState] with the changes in another [PostState].
+    pub fn extend(&mut self, other: PostState) {
+        self.changes.reserve(other.changes.len());
+
+        let mut next_transition_id = self.current_transition_id;
+        for mut change in other.changes.into_iter() {
+            next_transition_id = self.current_transition_id + change.transition_id();
+            change.set_transition_id(next_transition_id);
+            self.add_and_apply(change);
+        }
+        self.receipts.extend(other.receipts);
+        self.bytecode.extend(other.bytecode);
+        self.current_transition_id = next_transition_id + 1;
+    }
+
+    /// Reverts each change up to and including any change that is part of `transition_id`.
+    ///
+    /// The reverted changes are removed from this post-state, and their effects are reverted.
+    ///
+    /// The reverted changes are returned.
+    pub fn revert_to(&mut self, transition_id: usize) -> Vec<Change> {
+        let mut changes_to_revert = Vec::new();
+        self.changes.retain(|change| {
+            if change.transition_id() >= transition_id as u64 {
+                changes_to_revert.push(change.clone());
+                false
+            } else {
+                true
+            }
+        });
+
+        for change in changes_to_revert.iter_mut().rev() {
+            change.set_transition_id(change.transition_id() - transition_id as TransitionId);
+            self.revert(change.clone());
+        }
+        self.current_transition_id = transition_id as TransitionId;
+        changes_to_revert
+    }
+
+    /// Reverts each change up to and including any change that is part of `transition_id`.
+    ///
+    /// The reverted changes are removed from this post-state, and their effects are reverted.
+    ///
+    /// A new post-state containing the pre-revert state, as well as the reverted changes *only* is
+    /// returned.
+    ///
+    /// This effectively splits the post state in two:
+    ///
+    /// 1. This post-state has the changes reverted
+    /// 2. The returned post-state does *not* have the changes reverted, but only contains the
+    /// descriptions of the changes that were reverted in the first post-state.
+    pub fn split_at(&mut self, transition_id: usize) -> Self {
+        // Clone ourselves
+        let mut non_reverted_state = self.clone();
+
+        // Revert the desired changes
+        let reverted_changes = self.revert_to(transition_id);
+
+        // Compute the new `current_transition_id` for `non_reverted_state`.
+        let new_transition_id =
+            reverted_changes.last().map(|c| c.transition_id()).unwrap_or_default();
+        non_reverted_state.changes = reverted_changes;
+        non_reverted_state.current_transition_id = new_transition_id + 1;
+
+        non_reverted_state
+    }
+
+    /// Add a newly created account to the post-state.
+    pub fn create_account(&mut self, address: Address, account: Account) {
+        self.add_and_apply(Change::AccountCreated {
+            id: self.current_transition_id,
+            address,
+            account,
+        });
+    }
+
+    /// Add a changed account to the post-state.
+    ///
+    /// If the account also has changed storage values, [PostState::change_storage] should also be
+    /// called.
+    pub fn change_account(&mut self, address: Address, old: Account, new: Account) {
+        self.add_and_apply(Change::AccountChanged {
+            id: self.current_transition_id,
+            address,
+            old,
+            new,
+        });
+    }
+
+    /// Mark an account as destroyed.
+    pub fn destroy_account(&mut self, address: Address, account: Account) {
+        self.add_and_apply(Change::AccountDestroyed {
+            id: self.current_transition_id,
+            address,
+            old: account,
+        });
+        self.add_and_apply(Change::StorageWiped { id: self.current_transition_id, address });
+    }
+
+    /// Add changed storage values to the post-state.
+    pub fn change_storage(&mut self, address: Address, changeset: StorageChangeset) {
+        self.add_and_apply(Change::StorageChanged {
+            id: self.current_transition_id,
+            address,
+            changeset,
+        });
+    }
+
+    /// Add new bytecode to the post-state.
+    pub fn add_bytecode(&mut self, code_hash: H256, bytecode: Bytecode) {
+        // TODO: Is this faster than just doing `.insert`?
+        // Assumption: `insert` will override the value if present, but since the code hash for a
+        // given bytecode will always be the same, we are overriding with the same value.
+        //
+        // In other words: if this entry already exists, replacing the bytecode will replace with
+        // the same value, which is wasteful.
+        self.bytecode.entry(code_hash).or_insert(bytecode);
+    }
+
+    /// Add a transaction receipt to the post-state.
+    ///
+    /// Transactions should always include their receipts in the post-state.
+    pub fn add_receipt(&mut self, receipt: Receipt) {
+        self.receipts.push(receipt);
+    }
+
+    /// Mark all prior changes as being part of one transition, and start a new one.
+    pub fn finish_transition(&mut self) {
+        self.current_transition_id += 1;
+    }
+
+    /// Add a new change, and apply its transformations to the current state
+    pub fn add_and_apply(&mut self, change: Change) {
+        match &change {
+            Change::AccountCreated { address, account, .. } |
+            Change::AccountChanged { address, new: account, .. } => {
+                self.accounts.insert(*address, Some(*account));
+            }
+            Change::AccountDestroyed { address, .. } => {
+                self.accounts.insert(*address, None);
+            }
+            Change::StorageChanged { address, changeset, .. } => {
+                let storage = self.storage.entry(*address).or_default();
+                storage.wiped = false;
+                for (slot, (_, current_value)) in changeset {
+                    storage.storage.insert(*slot, *current_value);
+                }
+            }
+            Change::StorageWiped { address, .. } => {
+                let storage = self.storage.entry(*address).or_default();
+                storage.wiped = true;
+            }
+        }
+
+        self.changes.push(change);
+    }
+
+    /// Revert a change, applying the inverse of its transformations to the current state.
+    fn revert(&mut self, change: Change) {
+        match &change {
+            Change::AccountCreated { address, .. } => {
+                self.accounts.remove(address);
+            }
+            Change::AccountChanged { address, old, .. } => {
+                self.accounts.insert(*address, Some(*old));
+            }
+            Change::AccountDestroyed { address, old, .. } => {
+                self.accounts.insert(*address, Some(*old));
+            }
+            Change::StorageChanged { address, changeset, .. } => {
+                let storage = self.storage.entry(*address).or_default();
+                storage.wiped = false;
+                for (slot, (old_value, _)) in changeset {
+                    storage.storage.insert(*slot, *old_value);
+                }
+            }
+            Change::StorageWiped { address, .. } => {
+                let storage = self.storage.entry(*address).or_default();
+                storage.wiped = false;
+            }
+        }
+    }
+
+    /// Write the post state to the database.
+    pub fn write_to_db<'a, TX: DbTxMut<'a> + DbTx<'a>>(
+        mut self,
+        tx: &TX,
+        first_transition_id: TransitionId,
+    ) -> Result<(), DbError> {
+        // Collect and sort changesets by their key to improve write performance
+        let mut changesets = std::mem::take(&mut self.changes);
+        changesets
+            .sort_unstable_by_key(|changeset| (changeset.transition_id(), changeset.address()));
+
+        // Partition changesets into account and storage changes
+        let (account_changes, storage_changes): (Vec<Change>, Vec<Change>) =
+            changesets.into_iter().partition(|changeset| {
+                matches!(
+                    changeset,
+                    Change::AccountChanged { .. } |
+                        Change::AccountCreated { .. } |
+                        Change::AccountDestroyed { .. }
+                )
+            });
+
+        // Write account changes
+        tracing::trace!(target: "provider::post_state", len = account_changes.len(), "Writing account changes");
+        let mut account_changeset_cursor = tx.cursor_dup_write::<tables::AccountChangeSet>()?;
+        for changeset in account_changes.into_iter() {
+            match changeset {
+                Change::AccountDestroyed { id, address, old } |
+                Change::AccountChanged { id, address, old, .. } => {
+                    let destroyed = matches!(changeset, Change::AccountDestroyed { .. });
+                    tracing::trace!(target: "provider::post_state", id, ?address, ?old, destroyed, "Account changed");
+                    account_changeset_cursor.append_dup(
+                        first_transition_id + id,
+                        AccountBeforeTx { address, info: Some(old) },
+                    )?;
+                }
+                Change::AccountCreated { id, address, .. } => {
+                    tracing::trace!(target: "provider::post_state", id, ?address, "Account created");
+                    account_changeset_cursor.append_dup(
+                        first_transition_id + id,
+                        AccountBeforeTx { address, info: None },
+                    )?;
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        // Write storage changes
+        tracing::trace!(target: "provider::post_state", len = storage_changes.len(), "Writing storage changes");
+        let mut storages_cursor = tx.cursor_dup_write::<tables::PlainStorageState>()?;
+        let mut storage_changeset_cursor = tx.cursor_dup_write::<tables::StorageChangeSet>()?;
+        for changeset in storage_changes.into_iter() {
+            match changeset {
+                Change::StorageChanged { id, address, changeset } => {
+                    let storage_id = TransitionIdAddress((first_transition_id + id, address));
+
+                    for (key, (old_value, _)) in changeset {
+                        tracing::trace!(target: "provider::post_state", ?storage_id, ?key, ?old_value, "Storage changed");
+                        storage_changeset_cursor.append_dup(
+                            storage_id,
+                            StorageEntry { key: H256(key.to_be_bytes()), value: old_value },
+                        )?;
+                    }
+                }
+                Change::StorageWiped { id, address } => {
+                    let storage_id = TransitionIdAddress((first_transition_id + id, address));
+
+                    if let Some((_, entry)) = storages_cursor.seek_exact(address)? {
+                        tracing::trace!(target: "provider::post_state", ?storage_id, key = ?entry.key, "Storage wiped");
+                        storage_changeset_cursor.append_dup(storage_id, entry)?;
+
+                        while let Some(entry) = storages_cursor.next_dup_val()? {
+                            storage_changeset_cursor.append_dup(storage_id, entry)?;
+                        }
+                    }
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        // Write new storage state
+        for (address, storage) in self.storage.into_iter() {
+            if storage.wiped {
+                tracing::trace!(target: "provider::post_state", ?address, "Wiping storage from plain state");
+                if storages_cursor.seek_exact(address)?.is_some() {
+                    storages_cursor.delete_current_duplicates()?;
+                }
+
+                // If the storage is marked as wiped, it might still contain values. This is to
+                // avoid deallocating where possible, but these values should not be written to the
+                // database.
+                continue
+            }
+
+            for (key, value) in storage.storage {
+                tracing::trace!(target: "provider::post_state", ?address, ?key, "Updating plain state storage");
+                let key = H256(key.to_be_bytes());
+                if let Some(entry) = storages_cursor.seek_by_key_subkey(address, key)? {
+                    if entry.key == key {
+                        storages_cursor.delete_current()?;
+                    }
+                }
+
+                if value != U256::ZERO {
+                    storages_cursor.upsert(address, StorageEntry { key, value })?;
+                }
+            }
+        }
+
+        // Write new account state
+        tracing::trace!(target: "provider::post_state", len = self.accounts.len(), "Writing new account state");
+        let mut accounts_cursor = tx.cursor_write::<tables::PlainAccountState>()?;
+        for (address, account) in self.accounts.into_iter() {
+            if let Some(account) = account {
+                tracing::trace!(target: "provider::post_state", ?address, "Updating plain state account");
+                accounts_cursor.upsert(address, account)?;
+            } else if accounts_cursor.seek_exact(address)?.is_some() {
+                tracing::trace!(target: "provider::post_state", ?address, "Deleting plain state account");
+                accounts_cursor.delete_current()?;
+            }
+        }
+
+        // Write bytecode
+        tracing::trace!(target: "provider::post_state", len = self.bytecode.len(), "Writing bytecods");
+        let mut bytecodes_cursor = tx.cursor_write::<tables::Bytecodes>()?;
+        for (hash, bytecode) in self.bytecode.into_iter() {
+            bytecodes_cursor.upsert(hash, bytecode)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reth_db::{
+        database::Database,
+        mdbx::{test_utils, Env, EnvKind, WriteMap},
+        transaction::DbTx,
+    };
+    use std::sync::Arc;
+
+    #[test]
+    fn extend() {
+        let mut a = PostState::new();
+        a.create_account(Address::zero(), Account::default());
+        a.destroy_account(Address::zero(), Account::default());
+        a.finish_transition();
+
+        assert_eq!(a.transitions_count(), 1);
+        assert_eq!(a.changes().len(), 3);
+
+        let mut b = PostState::new();
+        b.create_account(Address::repeat_byte(0xff), Account::default());
+        b.finish_transition();
+
+        assert_eq!(b.transitions_count(), 1);
+        assert_eq!(b.changes.len(), 1);
+
+        let mut c = a.clone();
+        c.extend(b.clone());
+
+        assert_eq!(c.transitions_count(), 2);
+        assert_eq!(c.changes.len(), a.changes.len() + b.changes.len());
+    }
+
+    #[test]
+    fn write_to_db_account_info() {
+        let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
+        let tx = db.tx_mut().expect("Could not get database tx");
+
+        let mut post_state = PostState::new();
+
+        let address_a = Address::zero();
+        let address_b = Address::repeat_byte(0xff);
+
+        let account_a = Account { balance: U256::from(1), nonce: 1, bytecode_hash: None };
+        let account_b = Account { balance: U256::from(2), nonce: 2, bytecode_hash: None };
+        let account_b_changed = Account { balance: U256::from(3), nonce: 3, bytecode_hash: None };
+
+        // 0x00.. is created
+        post_state.create_account(address_a, account_a);
+        // 0x11.. is changed (balance + 1, nonce + 1)
+        post_state.change_account(address_b, account_b, account_b_changed);
+        post_state.write_to_db(&tx, 0).expect("Could not write post state to DB");
+
+        // Check plain state
+        assert_eq!(
+            tx.get::<tables::PlainAccountState>(address_a).expect("Could not read account state"),
+            Some(account_a),
+            "Account A state is wrong"
+        );
+        assert_eq!(
+            tx.get::<tables::PlainAccountState>(address_b).expect("Could not read account state"),
+            Some(account_b_changed),
+            "Account B state is wrong"
+        );
+
+        // Check change set
+        let mut changeset_cursor = tx
+            .cursor_dup_read::<tables::AccountChangeSet>()
+            .expect("Could not open changeset cursor");
+        assert_eq!(
+            changeset_cursor.seek_exact(0).expect("Could not read account change set"),
+            Some((0, AccountBeforeTx { address: address_a, info: None })),
+            "Account A changeset is wrong"
+        );
+        assert_eq!(
+            changeset_cursor.next_dup().expect("Changeset table is malformed"),
+            Some((0, AccountBeforeTx { address: address_b, info: Some(account_b) })),
+            "Account B changeset is wrong"
+        );
+
+        let mut post_state = PostState::new();
+        // 0x11.. is destroyed
+        post_state.destroy_account(address_b, account_b_changed);
+        post_state.write_to_db(&tx, 1).expect("Could not write second post state to DB");
+
+        // Check new plain state for account B
+        assert_eq!(
+            tx.get::<tables::PlainAccountState>(address_b).expect("Could not read account state"),
+            None,
+            "Account B should be deleted"
+        );
+
+        // Check change set
+        assert_eq!(
+            changeset_cursor.seek_exact(1).expect("Could not read account change set"),
+            Some((1, AccountBeforeTx { address: address_b, info: Some(account_b_changed) })),
+            "Account B changeset is wrong after deletion"
+        );
+    }
+
+    #[test]
+    fn write_to_db_storage() {
+        let db: Arc<Env<WriteMap>> = test_utils::create_test_db(EnvKind::RW);
+        let tx = db.tx_mut().expect("Could not get database tx");
+
+        let mut post_state = PostState::new();
+
+        let address_a = Address::zero();
+        let address_b = Address::repeat_byte(0xff);
+
+        // 0x00 => 0 => 1
+        // 0x01 => 0 => 2
+        let storage_a_changeset = BTreeMap::from([
+            (U256::from(0), (U256::from(0), U256::from(1))),
+            (U256::from(1), (U256::from(0), U256::from(2))),
+        ]);
+
+        // 0x01 => 1 => 2
+        let storage_b_changeset = BTreeMap::from([(U256::from(1), (U256::from(1), U256::from(2)))]);
+
+        post_state.change_storage(address_a, storage_a_changeset);
+        post_state.change_storage(address_b, storage_b_changeset);
+        post_state.write_to_db(&tx, 0).expect("Could not write post state to DB");
+
+        // Check plain storage state
+        let mut storage_cursor = tx
+            .cursor_dup_read::<tables::PlainStorageState>()
+            .expect("Could not open plain storage state cursor");
+
+        assert_eq!(
+            storage_cursor.seek_exact(address_a).unwrap(),
+            Some((address_a, StorageEntry { key: H256::zero(), value: U256::from(1) })),
+            "Slot 0 for account A should be 1"
+        );
+        assert_eq!(
+            storage_cursor.next_dup().unwrap(),
+            Some((
+                address_a,
+                StorageEntry { key: H256::from(U256::from(1).to_be_bytes()), value: U256::from(2) }
+            )),
+            "Slot 1 for account A should be 2"
+        );
+        assert_eq!(
+            storage_cursor.next_dup().unwrap(),
+            None,
+            "Account A should only have 2 storage slots"
+        );
+
+        assert_eq!(
+            storage_cursor.seek_exact(address_b).unwrap(),
+            Some((
+                address_b,
+                StorageEntry { key: H256::from(U256::from(1).to_be_bytes()), value: U256::from(2) }
+            )),
+            "Slot 1 for account B should be 2"
+        );
+        assert_eq!(
+            storage_cursor.next_dup().unwrap(),
+            None,
+            "Account B should only have 1 storage slot"
+        );
+
+        // Check change set
+        let mut changeset_cursor = tx
+            .cursor_dup_read::<tables::StorageChangeSet>()
+            .expect("Could not open storage changeset cursor");
+        assert_eq!(
+            changeset_cursor.seek_exact(TransitionIdAddress((0, address_a))).unwrap(),
+            Some((
+                TransitionIdAddress((0, address_a)),
+                StorageEntry { key: H256::zero(), value: U256::from(0) }
+            )),
+            "Slot 0 for account A should have changed from 0"
+        );
+        assert_eq!(
+            changeset_cursor.next_dup().unwrap(),
+            Some((
+                TransitionIdAddress((0, address_a)),
+                StorageEntry { key: H256::from(U256::from(1).to_be_bytes()), value: U256::from(0) }
+            )),
+            "Slot 1 for account A should have changed from 0"
+        );
+        assert_eq!(
+            changeset_cursor.next_dup().unwrap(),
+            None,
+            "Account A should only be in the changeset 2 times"
+        );
+
+        assert_eq!(
+            changeset_cursor.seek_exact(TransitionIdAddress((0, address_b))).unwrap(),
+            Some((
+                TransitionIdAddress((0, address_b)),
+                StorageEntry { key: H256::from(U256::from(1).to_be_bytes()), value: U256::from(1) }
+            )),
+            "Slot 1 for account B should have changed from 1"
+        );
+        assert_eq!(
+            changeset_cursor.next_dup().unwrap(),
+            None,
+            "Account B should only be in the changeset 1 time"
+        );
+
+        // Delete account A
+        let mut post_state = PostState::new();
+        post_state.destroy_account(address_a, Account::default());
+        post_state.write_to_db(&tx, 1).expect("Could not write post state to DB");
+
+        assert_eq!(
+            storage_cursor.seek_exact(address_a).unwrap(),
+            None,
+            "Account A should have no storage slots after deletion"
+        );
+
+        assert_eq!(
+            changeset_cursor.seek_exact(TransitionIdAddress((1, address_a))).unwrap(),
+            Some((
+                TransitionIdAddress((1, address_a)),
+                StorageEntry { key: H256::zero(), value: U256::from(1) }
+            )),
+            "Slot 0 for account A should have changed from 1 on deletion"
+        );
+        assert_eq!(
+            changeset_cursor.next_dup().unwrap(),
+            Some((
+                TransitionIdAddress((1, address_a)),
+                StorageEntry { key: H256::from(U256::from(1).to_be_bytes()), value: U256::from(2) }
+            )),
+            "Slot 1 for account A should have changed from 2 on deletion"
+        );
+        assert_eq!(
+            changeset_cursor.next_dup().unwrap(),
+            None,
+            "Account A should only be in the changeset 2 times on deletion"
+        );
+    }
+
+    #[test]
+    fn revert_to() {
+        let mut state = PostState::new();
+        state.create_account(
+            Address::repeat_byte(0),
+            Account { nonce: 1, balance: U256::from(1), bytecode_hash: None },
+        );
+        state.finish_transition();
+        let revert_to = state.current_transition_id;
+        state.create_account(
+            Address::repeat_byte(0xff),
+            Account { nonce: 2, balance: U256::from(2), bytecode_hash: None },
+        );
+        state.finish_transition();
+
+        assert_eq!(state.transitions_count(), 2);
+        assert_eq!(state.accounts().len(), 2);
+
+        let reverted_changes = state.revert_to(revert_to as usize);
+        assert_eq!(state.accounts().len(), 1);
+        assert_eq!(state.transitions_count(), 1);
+        assert_eq!(reverted_changes.len(), 1);
+    }
+}
diff --git a/crates/storage/provider/src/providers/mod.rs b/crates/storage/provider/src/providers/mod.rs
index c67de018fb5..0e1d99857a2 100644
--- a/crates/storage/provider/src/providers/mod.rs
+++ b/crates/storage/provider/src/providers/mod.rs
@@ -10,17 +10,18 @@ use reth_db::{
 };
 use reth_interfaces::Result;
 use reth_primitives::{
-    Block, BlockHash, BlockId, BlockNumber, ChainInfo, ChainSpec, Hardfork, Head, Header,
+    Block, BlockHash, BlockId, BlockNumber, ChainInfo, ChainSpec, Hardfork, Head, Header, Receipt,
     TransactionSigned, TxHash, TxNumber, Withdrawal, H256, U256,
 };
 use reth_revm_primitives::{
     config::revm_spec,
     env::{fill_block_env, fill_cfg_and_block_env, fill_cfg_env},
 };
-use revm_primitives::{BlockEnv, CfgEnv, Env, SpecId};
+use revm_primitives::{BlockEnv, CfgEnv, SpecId};
 use std::{ops::RangeBounds, sync::Arc};
 
 mod state;
+use crate::traits::ReceiptProvider;
 pub use state::{
     chain::ChainState,
     historical::{HistoricalStateProvider, HistoricalStateProviderRef},
@@ -39,8 +40,8 @@ pub struct ShareableDatabase<DB> {
 
 impl<DB> ShareableDatabase<DB> {
     /// create new database provider
-    pub fn new(db: DB, chain_spec: ChainSpec) -> Self {
-        Self { db, chain_spec: Arc::new(chain_spec) }
+    pub fn new(db: DB, chain_spec: Arc<ChainSpec>) -> Self {
+        Self { db, chain_spec }
     }
 }
 
@@ -62,11 +63,7 @@ impl<DB: Database> HeaderProvider for ShareableDatabase<DB> {
     }
 
     fn header_by_number(&self, num: BlockNumber) -> Result<Option<Header>> {
-        if let Some(hash) = self.db.view(|tx| tx.get::<tables::CanonicalHeaders>(num))?? {
-            self.header(&hash)
-        } else {
-            Ok(None)
-        }
+        Ok(self.db.view(|tx| tx.get::<tables::Headers>(num))??)
     }
 
     fn header_td(&self, hash: &BlockHash) -> Result<Option<U256>> {
@@ -97,10 +94,20 @@ impl<DB: Database> HeaderProvider for ShareableDatabase<DB> {
 }
 
 impl<DB: Database> BlockHashProvider for ShareableDatabase<DB> {
-    fn block_hash(&self, number: U256) -> Result<Option<H256>> {
-        // TODO: This unwrap is potentially unsafe
+    fn block_hash(&self, number: u64) -> Result<Option<H256>> {
+        self.db.view(|tx| tx.get::<tables::CanonicalHeaders>(number))?.map_err(Into::into)
+    }
+
+    fn canonical_hashes_range(&self, start: BlockNumber, end: BlockNumber) -> Result<Vec<H256>> {
+        let range = start..end;
         self.db
-            .view(|tx| tx.get::<tables::CanonicalHeaders>(number.try_into().unwrap()))?
+            .view(|tx| {
+                let mut cursor = tx.cursor_read::<tables::CanonicalHeaders>()?;
+                cursor
+                    .walk_range(range)?
+                    .map(|result| result.map(|(_, hash)| hash).map_err(Into::into))
+                    .collect::<Result<Vec<_>>>()
+            })?
             .map_err(Into::into)
     }
 }
@@ -109,10 +116,10 @@ impl<DB: Database> BlockIdProvider for ShareableDatabase<DB> {
     fn chain_info(&self) -> Result<ChainInfo> {
         let best_number = self
             .db
-            .view(|tx| tx.get::<tables::SyncStage>("Finish".as_bytes().to_vec()))?
+            .view(|tx| tx.get::<tables::SyncStage>("Finish".to_string()))?
             .map_err(Into::<reth_interfaces::db::Error>::into)?
             .unwrap_or_default();
-        let best_hash = self.block_hash(U256::from(best_number))?.unwrap_or_default();
+        let best_hash = self.block_hash(best_number)?.unwrap_or_default();
         Ok(ChainInfo { best_hash, best_number, last_finalized: None, safe_finalized: None })
     }
 
@@ -179,8 +186,8 @@ impl<DB: Database> TransactionsProvider for ShareableDatabase<DB> {
             let tx = self.db.tx()?;
             if let Some(body) = tx.get::<tables::BlockBodies>(number)? {
                 let tx_range = body.tx_id_range();
-                if tx_range.is_empty() {
-                    Ok(Some(Vec::default()))
+                return if tx_range.is_empty() {
+                    Ok(Some(Vec::new()))
                 } else {
                     let mut tx_cursor = tx.cursor_read::<tables::Transactions>()?;
                     let transactions = tx_cursor
@@ -189,12 +196,9 @@ impl<DB: Database> TransactionsProvider for ShareableDatabase<DB> {
                         .collect::<std::result::Result<Vec<_>, _>>()?;
                     Ok(Some(transactions))
                 }
-            } else {
-                Ok(None)
             }
-        } else {
-            Ok(None)
         }
+        Ok(None)
     }
 
     fn transactions_by_block_range(
@@ -223,34 +227,85 @@ impl<DB: Database> TransactionsProvider for ShareableDatabase<DB> {
     }
 }
 
+impl<DB: Database> ReceiptProvider for ShareableDatabase<DB> {
+    fn receipt(&self, id: TxNumber) -> Result<Option<Receipt>> {
+        self.db.view(|tx| tx.get::<tables::Receipts>(id))?.map_err(Into::into)
+    }
+
+    fn receipt_by_hash(&self, hash: TxHash) -> Result<Option<Receipt>> {
+        self.db
+            .view(|tx| {
+                if let Some(id) = tx.get::<tables::TxHashNumber>(hash)? {
+                    tx.get::<tables::Receipts>(id)
+                } else {
+                    Ok(None)
+                }
+            })?
+            .map_err(Into::into)
+    }
+
+    fn receipts_by_block(&self, block: BlockId) -> Result<Option<Vec<Receipt>>> {
+        if let Some(number) = self.block_number_for_id(block)? {
+            let tx = self.db.tx()?;
+            if let Some(body) = tx.get::<tables::BlockBodies>(number)? {
+                let tx_range = body.tx_id_range();
+                return if tx_range.is_empty() {
+                    Ok(Some(Vec::new()))
+                } else {
+                    let mut tx_cursor = tx.cursor_read::<tables::Receipts>()?;
+                    let transactions = tx_cursor
+                        .walk_range(tx_range)?
+                        .map(|result| result.map(|(_, tx)| tx))
+                        .collect::<std::result::Result<Vec<_>, _>>()?;
+                    Ok(Some(transactions))
+                }
+            }
+        }
+        Ok(None)
+    }
+}
+
 impl<DB: Database> WithdrawalsProvider for ShareableDatabase<DB> {
     fn withdrawals_by_block(&self, id: BlockId, timestamp: u64) -> Result<Option<Vec<Withdrawal>>> {
         if self.chain_spec.fork(Hardfork::Shanghai).active_at_timestamp(timestamp) {
             if let Some(number) = self.block_number_for_id(id)? {
-                Ok(self
+                return Ok(self
                     .db
                     .view(|tx| tx.get::<tables::BlockWithdrawals>(number))??
                     .map(|w| w.withdrawals))
-            } else {
-                Ok(None)
             }
-        } else {
-            Ok(None)
         }
+        Ok(None)
+    }
+
+    fn latest_withdrawal(&self) -> Result<Option<Withdrawal>> {
+        let latest_block_withdrawal =
+            self.db.view(|tx| tx.cursor_read::<tables::BlockWithdrawals>()?.last())?;
+        latest_block_withdrawal
+            .map(|block_withdrawal_pair| {
+                block_withdrawal_pair
+                    .and_then(|(_, block_withdrawal)| block_withdrawal.withdrawals.last().cloned())
+            })
+            .map_err(Into::into)
     }
 }
 
 impl<DB: Database> EvmEnvProvider for ShareableDatabase<DB> {
-    fn fill_env_at(&self, env: &mut Env, at: BlockId) -> Result<()> {
+    fn fill_env_at(&self, cfg: &mut CfgEnv, block_env: &mut BlockEnv, at: BlockId) -> Result<()> {
         let hash = self.block_hash_for_id(at)?.ok_or(ProviderError::HeaderNotFound)?;
         let header = self.header(&hash)?.ok_or(ProviderError::HeaderNotFound)?;
-        self.fill_env_with_header(env, &header)
+        self.fill_env_with_header(cfg, block_env, &header)
     }
 
-    fn fill_env_with_header(&self, env: &mut Env, header: &Header) -> Result<()> {
+    fn fill_env_with_header(
+        &self,
+        cfg: &mut CfgEnv,
+        block_env: &mut BlockEnv,
+        header: &Header,
+    ) -> Result<()> {
         let total_difficulty =
             self.header_td_by_number(header.number)?.ok_or(ProviderError::HeaderNotFound)?;
-        fill_cfg_and_block_env(env, &self.chain_spec, header, total_difficulty);
+        fill_cfg_and_block_env(cfg, block_env, &self.chain_spec, header, total_difficulty);
         Ok(())
     }
 
@@ -297,6 +352,7 @@ impl<DB: Database> EvmEnvProvider for ShareableDatabase<DB> {
 impl<DB: Database> StateProviderFactory for ShareableDatabase<DB> {
     type HistorySP<'a> = HistoricalStateProvider<'a,<DB as DatabaseGAT<'a>>::TX> where Self: 'a;
     type LatestSP<'a> = LatestStateProvider<'a,<DB as DatabaseGAT<'a>>::TX> where Self: 'a;
+
     /// Storage provider for latest block
     fn latest(&self) -> Result<Self::LatestSP<'_>> {
         Ok(LatestStateProvider::new(self.db.tx()?))
@@ -331,6 +387,8 @@ impl<DB: Database> StateProviderFactory for ShareableDatabase<DB> {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
     use super::ShareableDatabase;
     use crate::{BlockIdProvider, StateProviderFactory};
     use reth_db::mdbx::{test_utils::create_test_db, EnvKind, WriteMap};
@@ -340,7 +398,7 @@ mod tests {
     fn common_history_provider() {
         let chain_spec = ChainSpecBuilder::mainnet().build();
         let db = create_test_db::<WriteMap>(EnvKind::RW);
-        let provider = ShareableDatabase::new(db, chain_spec);
+        let provider = ShareableDatabase::new(db, Arc::new(chain_spec));
         let _ = provider.latest();
     }
 
@@ -348,7 +406,7 @@ mod tests {
     fn default_chain_info() {
         let chain_spec = ChainSpecBuilder::mainnet().build();
         let db = create_test_db::<WriteMap>(EnvKind::RW);
-        let provider = ShareableDatabase::new(db, chain_spec);
+        let provider = ShareableDatabase::new(db, Arc::new(chain_spec));
 
         let chain_info = provider.chain_info().expect("should be ok");
         assert_eq!(chain_info.best_number, 0);
diff --git a/crates/storage/provider/src/providers/state/chain.rs b/crates/storage/provider/src/providers/state/chain.rs
index 567a9f82747..697d6b1fe8c 100644
--- a/crates/storage/provider/src/providers/state/chain.rs
+++ b/crates/storage/provider/src/providers/state/chain.rs
@@ -2,7 +2,6 @@ use crate::{
     providers::state::macros::delegate_provider_impls, AccountProvider, BlockHashProvider,
     StateProvider,
 };
-use std::marker::PhantomData;
 
 /// A type that can access the state at a specific access point (block number or tag)
 ///
@@ -16,16 +15,20 @@ use std::marker::PhantomData;
 ///
 /// Note: The lifetime of this type is limited by the type that created it.
 pub struct ChainState<'a> {
-    inner: Box<dyn StateProvider>,
-    _phantom: PhantomData<&'a ()>,
+    inner: Box<dyn StateProvider + 'a>,
 }
 
 // == impl ChainState ===
 
 impl<'a> ChainState<'a> {
     /// Wraps the given [StateProvider]
-    pub fn new(inner: Box<dyn StateProvider>) -> Self {
-        Self { inner, _phantom: Default::default() }
+    pub fn boxed<S: StateProvider + 'a>(inner: S) -> Self {
+        Self::new(Box::new(inner))
+    }
+
+    /// Wraps the given [StateProvider]
+    pub fn new(inner: Box<dyn StateProvider + 'a>) -> Self {
+        Self { inner }
     }
 
     /// Returns a new provider that takes the `TX` as reference
diff --git a/crates/storage/provider/src/providers/state/historical.rs b/crates/storage/provider/src/providers/state/historical.rs
index cd7ce2c8e77..e8776aee404 100644
--- a/crates/storage/provider/src/providers/state/historical.rs
+++ b/crates/storage/provider/src/providers/state/historical.rs
@@ -10,7 +10,7 @@ use reth_db::{
 };
 use reth_interfaces::Result;
 use reth_primitives::{
-    Account, Address, Bytes, StorageKey, StorageValue, TransitionId, H256, U256,
+    Account, Address, BlockNumber, Bytecode, Bytes, StorageKey, StorageValue, TransitionId, H256,
 };
 use std::marker::PhantomData;
 
@@ -56,6 +56,7 @@ impl<'a, 'b, TX: DbTx<'a>> AccountProvider for HistoricalStateProviderRef<'a, 'b
                 .tx
                 .cursor_dup_read::<tables::AccountChangeSet>()?
                 .seek_by_key_subkey(changeset_transition_id, address)?
+                .filter(|acc| acc.address == address)
                 .ok_or(ProviderError::AccountChangeset {
                     transition_id: changeset_transition_id,
                     address,
@@ -71,8 +72,21 @@ impl<'a, 'b, TX: DbTx<'a>> AccountProvider for HistoricalStateProviderRef<'a, 'b
 
 impl<'a, 'b, TX: DbTx<'a>> BlockHashProvider for HistoricalStateProviderRef<'a, 'b, TX> {
     /// Get block hash by number.
-    fn block_hash(&self, number: U256) -> Result<Option<H256>> {
-        self.tx.get::<tables::CanonicalHeaders>(number.to::<u64>()).map_err(Into::into)
+    fn block_hash(&self, number: u64) -> Result<Option<H256>> {
+        self.tx.get::<tables::CanonicalHeaders>(number).map_err(Into::into)
+    }
+
+    fn canonical_hashes_range(&self, start: BlockNumber, end: BlockNumber) -> Result<Vec<H256>> {
+        let range = start..end;
+        self.tx
+            .cursor_read::<tables::CanonicalHeaders>()
+            .map(|mut cursor| {
+                cursor
+                    .walk_range(range)?
+                    .map(|result| result.map(|(_, hash)| hash).map_err(Into::into))
+                    .collect::<Result<Vec<_>>>()
+            })?
+            .map_err(Into::into)
     }
 }
 
@@ -95,6 +109,7 @@ impl<'a, 'b, TX: DbTx<'a>> StateProvider for HistoricalStateProviderRef<'a, 'b,
                 .tx
                 .cursor_dup_read::<tables::StorageChangeSet>()?
                 .seek_by_key_subkey((changeset_transition_id, address).into(), storage_key)?
+                .filter(|entry| entry.key == storage_key)
                 .ok_or(ProviderError::StorageChangeset {
                     transition_id: changeset_transition_id,
                     address,
@@ -107,14 +122,24 @@ impl<'a, 'b, TX: DbTx<'a>> StateProvider for HistoricalStateProviderRef<'a, 'b,
             Ok(self
                 .tx
                 .cursor_dup_read::<tables::PlainStorageState>()?
-                .seek_by_key_subkey(address, storage_key)
-                .map(|r| r.map(|entry| entry.value))?)
+                .seek_by_key_subkey(address, storage_key)?
+                .filter(|entry| entry.key == storage_key)
+                .map(|entry| entry.value))
         }
     }
 
     /// Get account code by its hash
-    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytes>> {
-        self.tx.get::<tables::Bytecodes>(code_hash).map_err(Into::into).map(|r| r.map(Bytes::from))
+    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytecode>> {
+        self.tx.get::<tables::Bytecodes>(code_hash).map_err(Into::into)
+    }
+
+    /// Get account and storage proofs.
+    fn proof(
+        &self,
+        _address: Address,
+        _keys: &[H256],
+    ) -> Result<(Vec<Bytes>, H256, Vec<Vec<Bytes>>)> {
+        Err(ProviderError::HistoryStateRoot.into())
     }
 }
 
diff --git a/crates/storage/provider/src/providers/state/latest.rs b/crates/storage/provider/src/providers/state/latest.rs
index b1e5ea4833b..56d59250829 100644
--- a/crates/storage/provider/src/providers/state/latest.rs
+++ b/crates/storage/provider/src/providers/state/latest.rs
@@ -1,10 +1,17 @@
 use crate::{
-    providers::state::macros::delegate_provider_impls, AccountProvider, BlockHashProvider,
-    StateProvider,
+    providers::state::macros::delegate_provider_impls, trie::DBTrieLoader, AccountProvider,
+    BlockHashProvider, StateProvider,
+};
+use reth_db::{
+    cursor::{DbCursorRO, DbDupCursorRO},
+    tables,
+    transaction::DbTx,
+};
+use reth_interfaces::{provider::ProviderError, Result};
+use reth_primitives::{
+    keccak256, Account, Address, BlockNumber, Bytecode, Bytes, StorageKey, StorageValue, H256,
+    KECCAK_EMPTY,
 };
-use reth_db::{cursor::DbDupCursorRO, tables, transaction::DbTx};
-use reth_interfaces::Result;
-use reth_primitives::{Account, Address, Bytes, StorageKey, StorageValue, H256, U256};
 use std::marker::PhantomData;
 
 /// State provider over latest state that takes tx reference.
@@ -31,8 +38,21 @@ impl<'a, 'b, TX: DbTx<'a>> AccountProvider for LatestStateProviderRef<'a, 'b, TX
 
 impl<'a, 'b, TX: DbTx<'a>> BlockHashProvider for LatestStateProviderRef<'a, 'b, TX> {
     /// Get block hash by number.
-    fn block_hash(&self, number: U256) -> Result<Option<H256>> {
-        self.db.get::<tables::CanonicalHeaders>(number.to::<u64>()).map_err(Into::into)
+    fn block_hash(&self, number: u64) -> Result<Option<H256>> {
+        self.db.get::<tables::CanonicalHeaders>(number).map_err(Into::into)
+    }
+
+    fn canonical_hashes_range(&self, start: BlockNumber, end: BlockNumber) -> Result<Vec<H256>> {
+        let range = start..end;
+        self.db
+            .cursor_read::<tables::CanonicalHeaders>()
+            .map(|mut cursor| {
+                cursor
+                    .walk_range(range)?
+                    .map(|result| result.map(|(_, hash)| hash).map_err(Into::into))
+                    .collect::<Result<Vec<_>>>()
+            })?
+            .map_err(Into::into)
     }
 }
 
@@ -49,8 +69,44 @@ impl<'a, 'b, TX: DbTx<'a>> StateProvider for LatestStateProviderRef<'a, 'b, TX>
     }
 
     /// Get account code by its hash
-    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytes>> {
-        self.db.get::<tables::Bytecodes>(code_hash).map_err(Into::into).map(|r| r.map(Bytes::from))
+    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytecode>> {
+        self.db.get::<tables::Bytecodes>(code_hash).map_err(Into::into)
+    }
+
+    fn proof(
+        &self,
+        address: Address,
+        keys: &[H256],
+    ) -> Result<(Vec<Bytes>, H256, Vec<Vec<Bytes>>)> {
+        let hashed_address = keccak256(address);
+        let loader = DBTrieLoader::new(self.db);
+        let root = self
+            .db
+            .cursor_read::<tables::Headers>()?
+            .last()?
+            .ok_or(ProviderError::Header { number: 0 })?
+            .1
+            .state_root;
+
+        let (account_proof, storage_root) = loader
+            .generate_acount_proof(root, hashed_address)
+            .map_err(|_| ProviderError::StateTrie)?;
+        let account_proof = account_proof.into_iter().map(Bytes::from).collect();
+
+        let storage_proof = if storage_root == KECCAK_EMPTY {
+            // if there isn't storage, we return empty storage proofs
+            (0..keys.len()).map(|_| Vec::new()).collect()
+        } else {
+            let hashed_keys: Vec<H256> = keys.iter().map(keccak256).collect();
+            loader
+                .generate_storage_proofs(storage_root, hashed_address, &hashed_keys)
+                .map_err(|_| ProviderError::StateTrie)?
+                .into_iter()
+                .map(|v| v.into_iter().map(Bytes::from).collect())
+                .collect()
+        };
+
+        Ok((account_proof, storage_root, storage_proof))
     }
 }
 
diff --git a/crates/storage/provider/src/providers/state/macros.rs b/crates/storage/provider/src/providers/state/macros.rs
index b7d9a775a2f..d6d3f60ec83 100644
--- a/crates/storage/provider/src/providers/state/macros.rs
+++ b/crates/storage/provider/src/providers/state/macros.rs
@@ -5,12 +5,12 @@
 ///
 /// Used to implement provider traits.
 macro_rules! delegate_impls_to_as_ref {
-    (for $target:ty => $($trait:ident $(where [$($generics:tt)*])? {  $(fn $func:ident(&self, $($arg:ident: $argty:path),*) -> $ret:path;)* })* ) => {
+    (for $target:ty => $($trait:ident $(where [$($generics:tt)*])? {  $(fn $func:ident$(<$($generic_arg:ident: $generic_arg_ty:path),*>)?(&self, $($arg:ident: $argty:ty),*) -> $ret:path;)* })* ) => {
 
         $(
           impl<'a, $($($generics)*)?> $trait for $target {
               $(
-                  fn $func(&self, $($arg: $argty),*) -> $ret {
+                  fn $func$(<$($generic_arg: $generic_arg_ty),*>)?(&self, $($arg: $argty),*) -> $ret {
                     self.as_ref().$func($($arg),*)
                   }
               )*
@@ -34,11 +34,13 @@ macro_rules! delegate_provider_impls {
                 fn basic_account(&self, address: reth_primitives::Address) -> reth_interfaces::Result<Option<reth_primitives::Account>>;
             }
             BlockHashProvider $(where [$($generics)*])? {
-                fn block_hash(&self, number: reth_primitives::U256) -> reth_interfaces::Result<Option<reth_primitives::H256>>;
+                fn block_hash(&self, number: u64) -> reth_interfaces::Result<Option<reth_primitives::H256>>;
+                fn canonical_hashes_range(&self, start: reth_primitives::BlockNumber, end: reth_primitives::BlockNumber) -> reth_interfaces::Result<Vec<reth_primitives::H256>>;
             }
             StateProvider $(where [$($generics)*])?{
                 fn storage(&self, account: reth_primitives::Address, storage_key: reth_primitives::StorageKey) -> reth_interfaces::Result<Option<reth_primitives::StorageValue>>;
-                fn bytecode_by_hash(&self, code_hash: reth_primitives::H256) -> reth_interfaces::Result<Option<reth_primitives::Bytes>>;
+                fn proof(&self, address: reth_primitives::Address, keys: &[reth_primitives::H256]) -> reth_interfaces::Result<(Vec<reth_primitives::Bytes>, reth_primitives::H256, Vec<Vec<reth_primitives::Bytes>>)>;
+                fn bytecode_by_hash(&self, code_hash: reth_primitives::H256) -> reth_interfaces::Result<Option<reth_primitives::Bytecode>>;
             }
         );
     }
diff --git a/crates/storage/provider/src/test_utils/blocks.rs b/crates/storage/provider/src/test_utils/blocks.rs
new file mode 100644
index 00000000000..19d4545eacd
--- /dev/null
+++ b/crates/storage/provider/src/test_utils/blocks.rs
@@ -0,0 +1,140 @@
+//! Dummy blocks and data for tests
+
+use crate::{post_state::PostState, Transaction};
+use reth_db::{database::Database, models::StoredBlockBody, tables};
+use reth_primitives::{
+    hex_literal::hex, proofs::EMPTY_ROOT, Account, Header, SealedBlock, SealedBlockWithSenders,
+    Withdrawal, H160, H256, U256,
+};
+use reth_rlp::Decodable;
+use std::collections::BTreeMap;
+
+/// Assert genesis block
+pub fn assert_genesis_block<DB: Database>(tx: &Transaction<'_, DB>, g: SealedBlock) {
+    let n = g.number;
+    let h = H256::zero();
+    // check if all tables are empty
+    assert_eq!(tx.table::<tables::Headers>().unwrap(), vec![(g.number, g.header.clone().unseal())]);
+
+    assert_eq!(tx.table::<tables::HeaderNumbers>().unwrap(), vec![(h, n)]);
+    assert_eq!(tx.table::<tables::CanonicalHeaders>().unwrap(), vec![(n, h)]);
+    assert_eq!(tx.table::<tables::HeaderTD>().unwrap(), vec![(n, g.difficulty.into())]);
+    assert_eq!(tx.table::<tables::BlockBodies>().unwrap(), vec![(0, StoredBlockBody::default())]);
+    assert_eq!(tx.table::<tables::BlockOmmers>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::BlockWithdrawals>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::Transactions>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::TxHashNumber>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::Receipts>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::PlainAccountState>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::PlainStorageState>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::AccountHistory>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::StorageHistory>().unwrap(), vec![]);
+    // TODO check after this gets done: https://github.com/paradigmxyz/reth/issues/1588
+    // Bytecodes are not reverted assert_eq!(tx.table::<tables::Bytecodes>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::BlockTransitionIndex>().unwrap(), vec![(n, 0)]);
+    assert_eq!(tx.table::<tables::TxTransitionIndex>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::AccountChangeSet>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::StorageChangeSet>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::HashedAccount>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::HashedStorage>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::AccountsTrie>().unwrap(), vec![(EMPTY_ROOT, vec![0x80])]);
+    assert_eq!(tx.table::<tables::StoragesTrie>().unwrap(), vec![]);
+    assert_eq!(tx.table::<tables::TxSenders>().unwrap(), vec![]);
+    // SyncStage is not updated in tests
+}
+
+/// Test chain with genesis, blocks, execution results
+/// that have correcte changesets.
+pub struct BlockChainTestData {
+    /// Genesis
+    pub genesis: SealedBlock,
+    /// Blocks with its execution result
+    pub blocks: Vec<(SealedBlockWithSenders, PostState)>,
+}
+
+impl Default for BlockChainTestData {
+    fn default() -> Self {
+        Self { genesis: genesis(), blocks: vec![block1(), block2()] }
+    }
+}
+
+/// Genesis block
+pub fn genesis() -> SealedBlock {
+    SealedBlock {
+        header: Header { number: 0, difficulty: U256::from(1), ..Default::default() }
+            .seal(H256::zero()),
+        body: vec![],
+        ommers: vec![],
+        withdrawals: Some(vec![]),
+    }
+}
+
+/// Block one that points to genesis
+fn block1() -> (SealedBlockWithSenders, PostState) {
+    let mut block_rlp = hex!("f9025ff901f7a0c86e8cc0310ae7c531c758678ddbfd16fc51c8cef8cec650b032de9869e8b94fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa050554882fbbda2c2fd93fdc466db9946ea262a67f7a76cc169e714f105ab583da00967f09ef1dfed20c0eacfaa94d5cd4002eda3242ac47eae68972d07b106d192a0e3c8b47fbfc94667ef4cceb17e5cc21e3b1eebd442cebb27f07562b33836290db90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000001830f42408238108203e800a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f862f860800a83061a8094095e7baea6a6c7c4c2dfeb977efac326af552d8780801ba072ed817487b84ba367d15d2f039b5fc5f087d0a8882fbdf73e8cb49357e1ce30a0403d800545b8fc544f92ce8124e2255f8c3c6af93f28243a120585d4c4c6a2a3c0").as_slice();
+    let mut block = SealedBlock::decode(&mut block_rlp).unwrap();
+    block.withdrawals = Some(vec![Withdrawal::default()]);
+    let mut header = block.header.clone().unseal();
+    header.number = 1;
+    header.state_root =
+        H256(hex!("5d035ccb3e75a9057452ff060b773b213ec1fc353426174068edfc3971a0b6bd"));
+    header.parent_hash = H256::zero();
+    block.header = header.seal_slow();
+
+    let mut post_state = PostState::default();
+    // Transaction changes
+    post_state.create_account(
+        H160([0x60; 20]),
+        Account { nonce: 1, balance: U256::from(10), bytecode_hash: None },
+    );
+    post_state.change_storage(
+        H160([0x60; 20]),
+        BTreeMap::from([(U256::from(5), (U256::ZERO, U256::from(10)))]),
+    );
+    post_state.finish_transition();
+    // Block changes
+    post_state.create_account(
+        H160([0x61; 20]),
+        Account { nonce: 1, balance: U256::from(10), bytecode_hash: None },
+    );
+    post_state.finish_transition();
+
+    (SealedBlockWithSenders { block, senders: vec![H160([0x30; 20])] }, post_state)
+}
+
+/// Block two that points to block 1
+fn block2() -> (SealedBlockWithSenders, PostState) {
+    let mut block_rlp = hex!("f9025ff901f7a0c86e8cc0310ae7c531c758678ddbfd16fc51c8cef8cec650b032de9869e8b94fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa050554882fbbda2c2fd93fdc466db9946ea262a67f7a76cc169e714f105ab583da00967f09ef1dfed20c0eacfaa94d5cd4002eda3242ac47eae68972d07b106d192a0e3c8b47fbfc94667ef4cceb17e5cc21e3b1eebd442cebb27f07562b33836290db90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000001830f42408238108203e800a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f862f860800a83061a8094095e7baea6a6c7c4c2dfeb977efac326af552d8780801ba072ed817487b84ba367d15d2f039b5fc5f087d0a8882fbdf73e8cb49357e1ce30a0403d800545b8fc544f92ce8124e2255f8c3c6af93f28243a120585d4c4c6a2a3c0").as_slice();
+    let mut block = SealedBlock::decode(&mut block_rlp).unwrap();
+    block.withdrawals = Some(vec![Withdrawal::default()]);
+    let mut header = block.header.clone().unseal();
+    header.number = 2;
+    header.state_root =
+        H256(hex!("90101a13dd059fa5cca99ed93d1dc23657f63626c5b8f993a2ccbdf7446b64f8"));
+    // parent_hash points to block1 hash
+    header.parent_hash =
+        H256(hex!("d846db2ab174c492cfe985c18fa75b154e20572bc33bb1c67cf5d2995791bdb7"));
+    block.header = header.seal_slow();
+
+    let mut post_state = PostState::default();
+    // Transaction changes
+    post_state.change_account(
+        H160([0x60; 20]),
+        Account { nonce: 1, balance: U256::from(10), bytecode_hash: None },
+        Account { nonce: 2, balance: U256::from(15), bytecode_hash: None },
+    );
+    post_state.change_storage(
+        H160([0x60; 20]),
+        BTreeMap::from([(U256::from(5), (U256::from(10), U256::from(15)))]),
+    );
+    post_state.finish_transition();
+    // Block changes
+    post_state.change_account(
+        H160([0x60; 20]),
+        Account { nonce: 2, balance: U256::from(15), bytecode_hash: None },
+        Account { nonce: 3, balance: U256::from(20), bytecode_hash: None },
+    );
+    post_state.finish_transition();
+
+    (SealedBlockWithSenders { block, senders: vec![H160([0x31; 20])] }, post_state)
+}
diff --git a/crates/storage/provider/src/test_utils/mock.rs b/crates/storage/provider/src/test_utils/mock.rs
index a95bc0b7a15..176861b60b7 100644
--- a/crates/storage/provider/src/test_utils/mock.rs
+++ b/crates/storage/provider/src/test_utils/mock.rs
@@ -1,14 +1,15 @@
 use crate::{
-    AccountProvider, BlockHashProvider, BlockIdProvider, BlockProvider, EvmEnvProvider,
-    HeaderProvider, StateProvider, StateProviderFactory, TransactionsProvider,
+    traits::ReceiptProvider, AccountProvider, BlockHashProvider, BlockIdProvider, BlockProvider,
+    EvmEnvProvider, HeaderProvider, StateProvider, StateProviderFactory, TransactionsProvider,
 };
 use parking_lot::Mutex;
 use reth_interfaces::Result;
 use reth_primitives::{
-    keccak256, Account, Address, Block, BlockHash, BlockId, BlockNumber, BlockNumberOrTag, Bytes,
-    ChainInfo, Header, StorageKey, StorageValue, TransactionSigned, TxHash, H256, U256,
+    keccak256, Account, Address, Block, BlockHash, BlockId, BlockNumber, BlockNumberOrTag,
+    Bytecode, Bytes, ChainInfo, Header, Receipt, StorageKey, StorageValue, TransactionSigned,
+    TxHash, TxNumber, H256, U256,
 };
-use revm_primitives::{BlockEnv, CfgEnv, Env};
+use revm_primitives::{BlockEnv, CfgEnv};
 use std::{collections::HashMap, ops::RangeBounds, sync::Arc};
 
 /// A mock implementation for Provider interfaces.
@@ -26,7 +27,7 @@ pub struct MockEthProvider {
 #[derive(Debug, Clone)]
 pub struct ExtendedAccount {
     account: Account,
-    bytecode: Option<Bytes>,
+    bytecode: Option<Bytecode>,
     storage: HashMap<StorageKey, StorageValue>,
 }
 
@@ -44,7 +45,7 @@ impl ExtendedAccount {
     pub fn with_bytecode(mut self, bytecode: Bytes) -> Self {
         let hash = keccak256(&bytecode);
         self.account.bytecode_hash = Some(hash);
-        self.bytecode = Some(bytecode);
+        self.bytecode = Some(Bytecode::new_raw(bytecode.into()));
         self
     }
 }
@@ -123,7 +124,12 @@ impl HeaderProvider for MockEthProvider {
         range: impl RangeBounds<reth_primitives::BlockNumber>,
     ) -> Result<Vec<Header>> {
         let lock = self.headers.lock();
-        Ok(lock.values().filter(|header| range.contains(&header.number)).cloned().collect())
+
+        let mut headers: Vec<_> =
+            lock.values().filter(|header| range.contains(&header.number)).cloned().collect();
+        headers.sort_by_key(|header| header.number);
+
+        Ok(headers)
     }
 }
 
@@ -155,22 +161,38 @@ impl TransactionsProvider for MockEthProvider {
     }
 }
 
+impl ReceiptProvider for MockEthProvider {
+    fn receipt(&self, _id: TxNumber) -> Result<Option<Receipt>> {
+        Ok(None)
+    }
+
+    fn receipt_by_hash(&self, _hash: TxHash) -> Result<Option<Receipt>> {
+        Ok(None)
+    }
+
+    fn receipts_by_block(&self, _block: BlockId) -> Result<Option<Vec<Receipt>>> {
+        Ok(None)
+    }
+}
+
 impl BlockHashProvider for MockEthProvider {
-    fn block_hash(&self, number: U256) -> Result<Option<H256>> {
+    fn block_hash(&self, number: u64) -> Result<Option<H256>> {
         let lock = self.blocks.lock();
 
-        let hash =
-            lock.iter().find_map(
-                |(hash, b)| {
-                    if b.number == number.to::<u64>() {
-                        Some(*hash)
-                    } else {
-                        None
-                    }
-                },
-            );
+        let hash = lock.iter().find_map(|(hash, b)| (b.number == number).then_some(*hash));
         Ok(hash)
     }
+
+    fn canonical_hashes_range(&self, start: BlockNumber, end: BlockNumber) -> Result<Vec<H256>> {
+        let range = start..end;
+        let lock = self.blocks.lock();
+
+        let mut hashes: Vec<_> =
+            lock.iter().filter(|(_, block)| range.contains(&block.number)).collect();
+        hashes.sort_by_key(|(_, block)| block.number);
+
+        Ok(hashes.into_iter().map(|(hash, _)| *hash).collect())
+    }
 }
 
 impl BlockIdProvider for MockEthProvider {
@@ -190,7 +212,7 @@ impl BlockIdProvider for MockEthProvider {
 
     fn block_number(&self, hash: H256) -> Result<Option<reth_primitives::BlockNumber>> {
         let lock = self.blocks.lock();
-        let num = lock.iter().find_map(|(h, b)| if *h == hash { Some(b.number) } else { None });
+        let num = lock.iter().find_map(|(h, b)| (*h == hash).then_some(b.number));
         Ok(num)
     }
 }
@@ -226,7 +248,7 @@ impl StateProvider for MockEthProvider {
         Ok(lock.get(&account).and_then(|account| account.storage.get(&storage_key)).cloned())
     }
 
-    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytes>> {
+    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytecode>> {
         let lock = self.accounts.lock();
         Ok(lock.values().find_map(|account| {
             match (account.account.bytecode_hash.as_ref(), account.bytecode.as_ref()) {
@@ -237,14 +259,32 @@ impl StateProvider for MockEthProvider {
             }
         }))
     }
+
+    fn proof(
+        &self,
+        _address: Address,
+        _keys: &[H256],
+    ) -> Result<(Vec<Bytes>, H256, Vec<Vec<Bytes>>)> {
+        todo!()
+    }
 }
 
 impl EvmEnvProvider for MockEthProvider {
-    fn fill_env_at(&self, _env: &mut Env, _at: BlockId) -> Result<()> {
+    fn fill_env_at(
+        &self,
+        _cfg: &mut CfgEnv,
+        _block_env: &mut BlockEnv,
+        _at: BlockId,
+    ) -> Result<()> {
         unimplemented!()
     }
 
-    fn fill_env_with_header(&self, _env: &mut Env, _header: &Header) -> Result<()> {
+    fn fill_env_with_header(
+        &self,
+        _cfg: &mut CfgEnv,
+        _block_env: &mut BlockEnv,
+        _header: &Header,
+    ) -> Result<()> {
         unimplemented!()
     }
 
diff --git a/crates/storage/provider/src/test_utils/mod.rs b/crates/storage/provider/src/test_utils/mod.rs
index d8fb2726181..b3097bb5ff9 100644
--- a/crates/storage/provider/src/test_utils/mod.rs
+++ b/crates/storage/provider/src/test_utils/mod.rs
@@ -1,3 +1,4 @@
+pub mod blocks;
 mod mock;
 mod noop;
 
diff --git a/crates/storage/provider/src/test_utils/noop.rs b/crates/storage/provider/src/test_utils/noop.rs
index 8f24ea6fb47..b8f151e42e0 100644
--- a/crates/storage/provider/src/test_utils/noop.rs
+++ b/crates/storage/provider/src/test_utils/noop.rs
@@ -1,13 +1,14 @@
 use crate::{
-    AccountProvider, BlockHashProvider, BlockIdProvider, BlockProvider, EvmEnvProvider,
-    HeaderProvider, StateProvider, StateProviderFactory, TransactionsProvider,
+    traits::ReceiptProvider, AccountProvider, BlockHashProvider, BlockIdProvider, BlockProvider,
+    EvmEnvProvider, HeaderProvider, StateProvider, StateProviderFactory, TransactionsProvider,
 };
 use reth_interfaces::Result;
 use reth_primitives::{
-    Account, Address, Block, BlockHash, BlockId, BlockNumber, Bytes, ChainInfo, Header, StorageKey,
-    StorageValue, TransactionSigned, TxHash, TxNumber, H256, U256,
+    Account, Address, Block, BlockHash, BlockId, BlockNumber, Bytecode, Bytes, ChainInfo, Header,
+    Receipt, StorageKey, StorageValue, TransactionSigned, TxHash, TxNumber, H256, KECCAK_EMPTY,
+    U256,
 };
-use revm_primitives::{BlockEnv, CfgEnv, Env};
+use revm_primitives::{BlockEnv, CfgEnv};
 use std::ops::RangeBounds;
 
 /// Supports various api interfaces for testing purposes.
@@ -17,9 +18,13 @@ pub struct NoopProvider;
 
 /// Noop implementation for testing purposes
 impl BlockHashProvider for NoopProvider {
-    fn block_hash(&self, _number: U256) -> Result<Option<H256>> {
+    fn block_hash(&self, _number: u64) -> Result<Option<H256>> {
         Ok(None)
     }
+
+    fn canonical_hashes_range(&self, _start: BlockNumber, _end: BlockNumber) -> Result<Vec<H256>> {
+        Ok(vec![])
+    }
 }
 
 impl BlockIdProvider for NoopProvider {
@@ -63,6 +68,20 @@ impl TransactionsProvider for NoopProvider {
     }
 }
 
+impl ReceiptProvider for NoopProvider {
+    fn receipt(&self, _id: TxNumber) -> Result<Option<Receipt>> {
+        Ok(None)
+    }
+
+    fn receipt_by_hash(&self, _hash: TxHash) -> Result<Option<Receipt>> {
+        Ok(None)
+    }
+
+    fn receipts_by_block(&self, _block: BlockId) -> Result<Option<Vec<Receipt>>> {
+        Ok(None)
+    }
+}
+
 impl HeaderProvider for NoopProvider {
     fn header(&self, _block_hash: &BlockHash) -> Result<Option<Header>> {
         Ok(None)
@@ -96,17 +115,35 @@ impl StateProvider for NoopProvider {
         Ok(None)
     }
 
-    fn bytecode_by_hash(&self, _code_hash: H256) -> Result<Option<Bytes>> {
+    fn bytecode_by_hash(&self, _code_hash: H256) -> Result<Option<Bytecode>> {
         Ok(None)
     }
+
+    fn proof(
+        &self,
+        _address: Address,
+        _keys: &[H256],
+    ) -> Result<(Vec<Bytes>, H256, Vec<Vec<Bytes>>)> {
+        Ok((vec![], KECCAK_EMPTY, vec![]))
+    }
 }
 
 impl EvmEnvProvider for NoopProvider {
-    fn fill_env_at(&self, _env: &mut Env, _at: BlockId) -> Result<()> {
+    fn fill_env_at(
+        &self,
+        _cfg: &mut CfgEnv,
+        _block_env: &mut BlockEnv,
+        _at: BlockId,
+    ) -> Result<()> {
         Ok(())
     }
 
-    fn fill_env_with_header(&self, _env: &mut Env, _header: &Header) -> Result<()> {
+    fn fill_env_with_header(
+        &self,
+        _cfg: &mut CfgEnv,
+        _block_env: &mut BlockEnv,
+        _header: &Header,
+    ) -> Result<()> {
         Ok(())
     }
 
diff --git a/crates/storage/provider/src/traits/account.rs b/crates/storage/provider/src/traits/account.rs
index bd6864f35ec..fb2ba3943b9 100644
--- a/crates/storage/provider/src/traits/account.rs
+++ b/crates/storage/provider/src/traits/account.rs
@@ -3,7 +3,7 @@ use reth_interfaces::Result;
 use reth_primitives::{Account, Address};
 
 /// Account provider
-#[auto_impl(&)]
+#[auto_impl(&,Box)]
 pub trait AccountProvider: Send + Sync {
     /// Get basic account information.
     fn basic_account(&self, address: Address) -> Result<Option<Account>>;
diff --git a/crates/storage/provider/src/traits/block.rs b/crates/storage/provider/src/traits/block.rs
index 2b04b601e0b..044bb5fce7e 100644
--- a/crates/storage/provider/src/traits/block.rs
+++ b/crates/storage/provider/src/traits/block.rs
@@ -1,11 +1,11 @@
-use crate::{BlockIdProvider, HeaderProvider, TransactionsProvider};
+use crate::{BlockIdProvider, HeaderProvider, ReceiptProvider, TransactionsProvider};
 use reth_interfaces::Result;
 use reth_primitives::{Block, BlockId, BlockNumberOrTag, Header, H256};
 
 /// Api trait for fetching `Block` related data.
 #[auto_impl::auto_impl(&, Arc)]
 pub trait BlockProvider:
-    BlockIdProvider + HeaderProvider + TransactionsProvider + Send + Sync
+    BlockIdProvider + HeaderProvider + TransactionsProvider + ReceiptProvider + Send + Sync
 {
     /// Returns the block.
     ///
diff --git a/crates/storage/provider/src/traits/block_hash.rs b/crates/storage/provider/src/traits/block_hash.rs
index 6d4b99d5248..855c77a6151 100644
--- a/crates/storage/provider/src/traits/block_hash.rs
+++ b/crates/storage/provider/src/traits/block_hash.rs
@@ -1,11 +1,14 @@
 use auto_impl::auto_impl;
 use reth_interfaces::Result;
-use reth_primitives::{H256, U256};
+use reth_primitives::{BlockNumber, H256};
 
 /// Client trait for fetching block hashes by number.
-#[auto_impl(&, Arc)]
+#[auto_impl(&, Arc, Box)]
 pub trait BlockHashProvider: Send + Sync {
     /// Get the hash of the block with the given number. Returns `None` if no block with this number
     /// exists.
-    fn block_hash(&self, number: U256) -> Result<Option<H256>>;
+    fn block_hash(&self, number: BlockNumber) -> Result<Option<H256>>;
+
+    /// Get headers in range of block hashes or numbers
+    fn canonical_hashes_range(&self, start: BlockNumber, end: BlockNumber) -> Result<Vec<H256>>;
 }
diff --git a/crates/storage/provider/src/traits/block_id.rs b/crates/storage/provider/src/traits/block_id.rs
index fb393f35db8..42a9fa89add 100644
--- a/crates/storage/provider/src/traits/block_id.rs
+++ b/crates/storage/provider/src/traits/block_id.rs
@@ -1,6 +1,6 @@
 use super::BlockHashProvider;
 use reth_interfaces::Result;
-use reth_primitives::{BlockId, BlockNumberOrTag, ChainInfo, H256, U256};
+use reth_primitives::{BlockId, BlockNumberOrTag, ChainInfo, H256};
 
 /// Client trait for transforming [BlockId].
 #[auto_impl::auto_impl(&, Arc)]
@@ -33,7 +33,7 @@ pub trait BlockIdProvider: BlockHashProvider + Send + Sync {
                     return Ok(Some(self.chain_info()?.best_hash))
                 }
                 self.convert_block_number(num)?
-                    .map(|num| self.block_hash(U256::from(num)))
+                    .map(|num| self.block_hash(num))
                     .transpose()
                     .map(|maybe_hash| maybe_hash.flatten())
             }
diff --git a/crates/storage/provider/src/traits/evm_env.rs b/crates/storage/provider/src/traits/evm_env.rs
index 6f422e298c6..9afe1ce4715 100644
--- a/crates/storage/provider/src/traits/evm_env.rs
+++ b/crates/storage/provider/src/traits/evm_env.rs
@@ -1,17 +1,23 @@
 use reth_interfaces::Result;
 use reth_primitives::{BlockId, Header};
-use revm_primitives::{BlockEnv, CfgEnv, Env};
+use revm_primitives::{BlockEnv, CfgEnv};
 
-/// A provider type that knows chain specific information required to configure an [Env]
+/// A provider type that knows chain specific information required to configure an
+/// [Env](revm_primitives::Env)
 ///
 /// This type is mainly used to provide required data to configure the EVM environment.
 #[auto_impl::auto_impl(&, Arc)]
 pub trait EvmEnvProvider: Send + Sync {
     /// Fills the [CfgEnv] and [BlockEnv] fields with values specific to the given [BlockId].
-    fn fill_env_at(&self, env: &mut Env, at: BlockId) -> Result<()>;
+    fn fill_env_at(&self, cfg: &mut CfgEnv, block_env: &mut BlockEnv, at: BlockId) -> Result<()>;
 
     /// Fills the [CfgEnv] and [BlockEnv]  fields with values specific to the given [Header].
-    fn fill_env_with_header(&self, env: &mut Env, header: &Header) -> Result<()>;
+    fn fill_env_with_header(
+        &self,
+        cfg: &mut CfgEnv,
+        block_env: &mut BlockEnv,
+        header: &Header,
+    ) -> Result<()>;
 
     /// Fills the [BlockEnv] fields with values specific to the given [BlockId].
     fn fill_block_env_at(&self, block_env: &mut BlockEnv, at: BlockId) -> Result<()>;
diff --git a/crates/storage/provider/src/traits/executor.rs b/crates/storage/provider/src/traits/executor.rs
new file mode 100644
index 00000000000..e25ab2c5649
--- /dev/null
+++ b/crates/storage/provider/src/traits/executor.rs
@@ -0,0 +1,45 @@
+//! Executor Factory
+
+use crate::{post_state::PostState, StateProvider};
+use reth_interfaces::executor::Error;
+use reth_primitives::{Address, Block, ChainSpec, U256};
+
+/// Executor factory that would create the EVM with particular state provider.
+///
+/// It can be used to mock executor.
+pub trait ExecutorFactory: Send + Sync + 'static {
+    /// The executor produced by the factory
+    type Executor<T: StateProvider>: BlockExecutor<T>;
+
+    /// Executor with [`StateProvider`]
+    fn with_sp<SP: StateProvider>(&self, sp: SP) -> Self::Executor<SP>;
+
+    /// Return internal chainspec
+    fn chain_spec(&self) -> &ChainSpec;
+}
+
+/// An executor capable of executing a block.
+pub trait BlockExecutor<SP: StateProvider> {
+    /// Execute a block.
+    ///
+    /// The number of `senders` should be equal to the number of transactions in the block.
+    ///
+    /// If no senders are specified, the `execute` function MUST recover the senders for the
+    /// provided block's transactions internally. We use this to allow for calculating senders in
+    /// parallel in e.g. staged sync, so that execution can happen without paying for sender
+    /// recovery costs.
+    fn execute(
+        &mut self,
+        block: &Block,
+        total_difficulty: U256,
+        senders: Option<Vec<Address>>,
+    ) -> Result<PostState, Error>;
+
+    /// Executes the block and checks receipts
+    fn execute_and_verify_receipt(
+        &mut self,
+        block: &Block,
+        total_difficulty: U256,
+        senders: Option<Vec<Address>>,
+    ) -> Result<PostState, Error>;
+}
diff --git a/crates/storage/provider/src/traits/mod.rs b/crates/storage/provider/src/traits/mod.rs
index 7552ca7f638..93b3ae303c5 100644
--- a/crates/storage/provider/src/traits/mod.rs
+++ b/crates/storage/provider/src/traits/mod.rs
@@ -18,6 +18,9 @@ pub use evm_env::EvmEnvProvider;
 mod header;
 pub use header::HeaderProvider;
 
+mod receipts;
+pub use receipts::ReceiptProvider;
+
 mod state;
 pub use state::{StateProvider, StateProviderFactory};
 
@@ -26,3 +29,6 @@ pub use transactions::TransactionsProvider;
 
 mod withdrawals;
 pub use withdrawals::WithdrawalsProvider;
+
+mod executor;
+pub use executor::{BlockExecutor, ExecutorFactory};
diff --git a/crates/storage/provider/src/traits/receipts.rs b/crates/storage/provider/src/traits/receipts.rs
new file mode 100644
index 00000000000..fa5604b2811
--- /dev/null
+++ b/crates/storage/provider/src/traits/receipts.rs
@@ -0,0 +1,15 @@
+use reth_interfaces::Result;
+use reth_primitives::{BlockId, Receipt, TxHash, TxNumber};
+
+///  Client trait for fetching [Receipt] data .
+#[auto_impl::auto_impl(&, Arc)]
+pub trait ReceiptProvider: Send + Sync {
+    /// Get receipt by transaction number
+    fn receipt(&self, id: TxNumber) -> Result<Option<Receipt>>;
+
+    /// Get receipt by transaction hash.
+    fn receipt_by_hash(&self, hash: TxHash) -> Result<Option<Receipt>>;
+
+    /// Get receipts by block id.
+    fn receipts_by_block(&self, block: BlockId) -> Result<Option<Vec<Receipt>>>;
+}
diff --git a/crates/storage/provider/src/traits/state.rs b/crates/storage/provider/src/traits/state.rs
index dd050c63328..e2f502593c6 100644
--- a/crates/storage/provider/src/traits/state.rs
+++ b/crates/storage/provider/src/traits/state.rs
@@ -3,22 +3,27 @@ use crate::BlockHashProvider;
 use auto_impl::auto_impl;
 use reth_interfaces::Result;
 use reth_primitives::{
-    Address, BlockHash, BlockNumber, Bytes, StorageKey, StorageValue, H256, KECCAK_EMPTY, U256,
+    Address, BlockHash, BlockNumber, Bytecode, Bytes, StorageKey, StorageValue, H256, KECCAK_EMPTY,
+    U256,
 };
 
 /// An abstraction for a type that provides state data.
 #[auto_impl(&, Box)]
 pub trait StateProvider: BlockHashProvider + AccountProvider + Send + Sync {
-    /// Get storage.
+    /// Get storage of given account.
     fn storage(&self, account: Address, storage_key: StorageKey) -> Result<Option<StorageValue>>;
 
     /// Get account code by its hash
-    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytes>>;
+    fn bytecode_by_hash(&self, code_hash: H256) -> Result<Option<Bytecode>>;
+
+    /// Get account and storage proofs.
+    fn proof(&self, address: Address, keys: &[H256])
+        -> Result<(Vec<Bytes>, H256, Vec<Vec<Bytes>>)>;
 
     /// Get account code by its address.
     ///
     /// Returns `None` if the account doesn't exist or account is not a contract
-    fn account_code(&self, addr: Address) -> Result<Option<Bytes>> {
+    fn account_code(&self, addr: Address) -> Result<Option<Bytecode>> {
         // Get basic account information
         // Returns None if acc doesn't exist
         let acc = match self.basic_account(addr)? {
diff --git a/crates/storage/provider/src/traits/withdrawals.rs b/crates/storage/provider/src/traits/withdrawals.rs
index 2f37e3bc270..9a6fe804507 100644
--- a/crates/storage/provider/src/traits/withdrawals.rs
+++ b/crates/storage/provider/src/traits/withdrawals.rs
@@ -5,4 +5,7 @@ use reth_primitives::{BlockId, Withdrawal};
 pub trait WithdrawalsProvider: Send + Sync {
     /// Get withdrawals by block id.
     fn withdrawals_by_block(&self, id: BlockId, timestamp: u64) -> Result<Option<Vec<Withdrawal>>>;
+
+    /// Get latest withdrawal from this block or earlier .
+    fn latest_withdrawal(&self) -> Result<Option<Withdrawal>>;
 }
diff --git a/crates/storage/provider/src/transaction.rs b/crates/storage/provider/src/transaction.rs
index b1c1898fdcf..a4268c8df98 100644
--- a/crates/storage/provider/src/transaction.rs
+++ b/crates/storage/provider/src/transaction.rs
@@ -1,17 +1,33 @@
-#![allow(dead_code)]
+use crate::{
+    insert_canonical_block,
+    post_state::{Change, PostState, StorageChangeset},
+    trie::{DBTrieLoader, TrieError},
+};
+use itertools::{izip, Itertools};
 use reth_db::{
-    cursor::DbCursorRO,
+    common::KeyValue,
+    cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO},
     database::{Database, DatabaseGAT},
-    models::StoredBlockBody,
+    models::{
+        sharded_key,
+        storage_sharded_key::{self, StorageShardedKey},
+        AccountBeforeTx, ShardedKey, StoredBlockBody, TransitionIdAddress,
+    },
     table::Table,
     tables,
-    transaction::{DbTx, DbTxMut},
+    transaction::{DbTx, DbTxMut, DbTxMutGAT},
+    TransitionList,
 };
 use reth_interfaces::{db::Error as DbError, provider::ProviderError};
-use reth_primitives::{BlockHash, BlockNumber, Header, TransitionId, TxNumber, U256};
+use reth_primitives::{
+    keccak256, proofs::EMPTY_ROOT, Account, Address, BlockHash, BlockNumber, ChainSpec, Hardfork,
+    Header, SealedBlock, SealedBlockWithSenders, StorageEntry, TransactionSignedEcRecovered,
+    TransitionId, TxNumber, H256, U256,
+};
 use std::{
+    collections::{btree_map::Entry, BTreeMap, BTreeSet},
     fmt::Debug,
-    ops::{Deref, DerefMut},
+    ops::{Bound, Deref, DerefMut, Range, RangeBounds},
 };
 
 /// A container for any DB transaction that will open a new inner transaction when the current
@@ -71,6 +87,11 @@ where
         Ok(Self { db, tx: Some(db.tx_mut()?) })
     }
 
+    /// Creates a new container with given database and transaction handles.
+    pub fn new_raw(db: &'this DB, tx: <DB as DatabaseGAT<'this>>::TXMut) -> Self {
+        Self { db, tx: Some(tx) }
+    }
+
     /// Accessor to the internal Database
     pub fn inner(&self) -> &'this DB {
         self.db
@@ -213,6 +234,1221 @@ where
         }
         Ok(())
     }
+
+    /// Load last shard and check if it is full and remove if it is not. If list is empty, last
+    /// shard was full or there is no shards at all.
+    fn take_last_account_shard(&self, address: Address) -> Result<Vec<u64>, TransactionError> {
+        let mut cursor = self.cursor_read::<tables::AccountHistory>()?;
+        let last = cursor.seek_exact(ShardedKey::new(address, u64::MAX))?;
+        if let Some((shard_key, list)) = last {
+            // delete old shard so new one can be inserted.
+            self.delete::<tables::AccountHistory>(shard_key, None)?;
+            let list = list.iter(0).map(|i| i as u64).collect::<Vec<_>>();
+            return Ok(list)
+        }
+        Ok(Vec::new())
+    }
+
+    /// Load last shard and check if it is full and remove if it is not. If list is empty, last
+    /// shard was full or there is no shards at all.
+    pub fn take_last_storage_shard(
+        &self,
+        address: Address,
+        storage_key: H256,
+    ) -> Result<Vec<u64>, TransactionError> {
+        let mut cursor = self.cursor_read::<tables::StorageHistory>()?;
+        let last = cursor.seek_exact(StorageShardedKey::new(address, storage_key, u64::MAX))?;
+        if let Some((storage_shard_key, list)) = last {
+            // delete old shard so new one can be inserted.
+            self.delete::<tables::StorageHistory>(storage_shard_key, None)?;
+            let list = list.iter(0).map(|i| i as u64).collect::<Vec<_>>();
+            return Ok(list)
+        }
+        Ok(Vec::new())
+    }
+}
+
+/// Stages impl
+impl<'this, DB> Transaction<'this, DB>
+where
+    DB: Database,
+{
+    /// Get requested blocks transaction with signer
+    pub fn get_block_transaction_range(
+        &self,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<(BlockNumber, Vec<TransactionSignedEcRecovered>)>, TransactionError> {
+        self.get_take_block_transaction_range::<false>(range)
+    }
+
+    /// Take requested blocks transaction with signer
+    pub fn take_block_transaction_range(
+        &self,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<(BlockNumber, Vec<TransactionSignedEcRecovered>)>, TransactionError> {
+        self.get_take_block_transaction_range::<true>(range)
+    }
+
+    /// Return range of blocks and its execution result
+    pub fn get_block_range(
+        &self,
+        chain_spec: &ChainSpec,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<SealedBlockWithSenders>, TransactionError> {
+        self.get_take_block_range::<false>(chain_spec, range)
+    }
+
+    /// Return range of blocks and its execution result
+    pub fn take_block_range(
+        &self,
+        chain_spec: &ChainSpec,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<SealedBlockWithSenders>, TransactionError> {
+        self.get_take_block_range::<true>(chain_spec, range)
+    }
+
+    /// Transverse over changesets and plain state and recreated the execution results.
+    ///
+    /// Return results from database.
+    pub fn get_block_execution_result_range(
+        &self,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<PostState>, TransactionError> {
+        self.get_take_block_execution_result_range::<false>(range)
+    }
+
+    /// Transverse over changesets and plain state and recreated the execution results.
+    ///
+    /// Get results and remove them from database
+    pub fn take_block_execution_result_range(
+        &self,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<PostState>, TransactionError> {
+        self.get_take_block_execution_result_range::<true>(range)
+    }
+
+    /// Get range of blocks and its execution result
+    pub fn get_block_and_execution_range(
+        &self,
+        chain_spec: &ChainSpec,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<(SealedBlockWithSenders, PostState)>, TransactionError> {
+        self.get_take_block_and_execution_range::<false>(chain_spec, range)
+    }
+
+    /// Take range of blocks and its execution result
+    pub fn take_block_and_execution_range(
+        &self,
+        chain_spec: &ChainSpec,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<(SealedBlockWithSenders, PostState)>, TransactionError> {
+        self.get_take_block_and_execution_range::<true>(chain_spec, range)
+    }
+
+    /// Unwind and clear account hashing
+    pub fn unwind_account_hashing(
+        &self,
+        range: Range<TransitionId>,
+    ) -> Result<(), TransactionError> {
+        let mut hashed_accounts = self.cursor_write::<tables::HashedAccount>()?;
+
+        // Aggregate all transition changesets and and make list of account that have been changed.
+        self.cursor_read::<tables::AccountChangeSet>()?
+            .walk_range(range)?
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .rev()
+            // fold all account to get the old balance/nonces and account that needs to be removed
+            .fold(
+                BTreeMap::new(),
+                |mut accounts: BTreeMap<Address, Option<Account>>, (_, account_before)| {
+                    accounts.insert(account_before.address, account_before.info);
+                    accounts
+                },
+            )
+            .into_iter()
+            // hash addresses and collect it inside sorted BTreeMap.
+            // We are doing keccak only once per address.
+            .map(|(address, account)| (keccak256(address), account))
+            .collect::<BTreeMap<_, _>>()
+            .into_iter()
+            // Apply values to HashedState (if Account is None remove it);
+            .try_for_each(|(hashed_address, account)| -> Result<(), TransactionError> {
+                if let Some(account) = account {
+                    hashed_accounts.upsert(hashed_address, account)?;
+                } else if hashed_accounts.seek_exact(hashed_address)?.is_some() {
+                    hashed_accounts.delete_current()?;
+                }
+                Ok(())
+            })?;
+        Ok(())
+    }
+
+    /// Unwind and clear storage hashing
+    pub fn unwind_storage_hashing(
+        &self,
+        range: Range<TransitionIdAddress>,
+    ) -> Result<(), TransactionError> {
+        let mut hashed_storage = self.cursor_dup_write::<tables::HashedStorage>()?;
+
+        // Aggregate all transition changesets and make list of accounts that have been changed.
+        self.cursor_read::<tables::StorageChangeSet>()?
+            .walk_range(range)?
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .rev()
+            // fold all account to get the old balance/nonces and account that needs to be removed
+            .fold(
+                BTreeMap::new(),
+                |mut accounts: BTreeMap<(Address, H256), U256>,
+                 (TransitionIdAddress((_, address)), storage_entry)| {
+                    accounts.insert((address, storage_entry.key), storage_entry.value);
+                    accounts
+                },
+            )
+            .into_iter()
+            // hash addresses and collect it inside sorted BTreeMap.
+            // We are doing keccak only once per address.
+            .map(|((address, key), value)| ((keccak256(address), keccak256(key)), value))
+            .collect::<BTreeMap<_, _>>()
+            .into_iter()
+            // Apply values to HashedStorage (if Value is zero just remove it);
+            .try_for_each(|((hashed_address, key), value)| -> Result<(), TransactionError> {
+                if hashed_storage
+                    .seek_by_key_subkey(hashed_address, key)?
+                    .filter(|entry| entry.key == key)
+                    .is_some()
+                {
+                    hashed_storage.delete_current()?;
+                }
+
+                if value != U256::ZERO {
+                    hashed_storage.upsert(hashed_address, StorageEntry { key, value })?;
+                }
+                Ok(())
+            })?;
+        Ok(())
+    }
+
+    /// Unwind and clear account history indices
+    pub fn unwind_account_history_indices(
+        &self,
+        range: Range<TransitionId>,
+    ) -> Result<(), TransactionError> {
+        let mut cursor = self.cursor_write::<tables::AccountHistory>()?;
+
+        let account_changeset = self
+            .cursor_read::<tables::AccountChangeSet>()?
+            .walk_range(range)?
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let last_indices = account_changeset
+            .into_iter()
+            // reverse so we can get lowest transition id where we need to unwind account.
+            .rev()
+            // fold all account and get last transition index
+            .fold(BTreeMap::new(), |mut accounts: BTreeMap<Address, u64>, (index, account)| {
+                // we just need address and lowest transition id.
+                accounts.insert(account.address, index);
+                accounts
+            });
+        // try to unwind the index
+        for (address, rem_index) in last_indices {
+            let shard_part = unwind_account_history_shards::<DB>(&mut cursor, address, rem_index)?;
+
+            // check last shard_part, if present, items needs to be reinserted.
+            if !shard_part.is_empty() {
+                // there are items in list
+                self.put::<tables::AccountHistory>(
+                    ShardedKey::new(address, u64::MAX),
+                    TransitionList::new(shard_part)
+                        .expect("There is at least one element in list and it is sorted."),
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Unwind and clear storage history indices
+    pub fn unwind_storage_history_indices(
+        &self,
+        range: Range<TransitionIdAddress>,
+    ) -> Result<(), TransactionError> {
+        let mut cursor = self.cursor_write::<tables::StorageHistory>()?;
+
+        let storage_changesets = self
+            .cursor_read::<tables::StorageChangeSet>()?
+            .walk_range(range)?
+            .collect::<Result<Vec<_>, _>>()?;
+        let last_indices = storage_changesets
+            .into_iter()
+            // reverse so we can get lowest transition id where we need to unwind account.
+            .rev()
+            // fold all storages and get last transition index
+            .fold(
+                BTreeMap::new(),
+                |mut accounts: BTreeMap<(Address, H256), u64>, (index, storage)| {
+                    // we just need address and lowest transition id.
+                    accounts.insert((index.address(), storage.key), index.transition_id());
+                    accounts
+                },
+            );
+        for ((address, storage_key), rem_index) in last_indices {
+            let shard_part =
+                unwind_storage_history_shards::<DB>(&mut cursor, address, storage_key, rem_index)?;
+
+            // check last shard_part, if present, items needs to be reinserted.
+            if !shard_part.is_empty() {
+                // there are items in list
+                self.put::<tables::StorageHistory>(
+                    StorageShardedKey::new(address, storage_key, u64::MAX),
+                    TransitionList::new(shard_part)
+                        .expect("There is at least one element in list and it is sorted."),
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Insert full block and make it canonical.
+    ///
+    /// This inserts the block and builds history related indexes. Once all blocks in a chain have
+    /// been committed, the state root needs to be inserted separately with
+    /// [`Transaction::insert_hashes`].
+    ///
+    /// # Note
+    ///
+    /// This assumes that we are using beacon consensus and that the block is post-merge, which
+    /// means that the block will have no block reward.
+    pub fn insert_block(&mut self, block: SealedBlockWithSenders) -> Result<(), TransactionError> {
+        // Header, Body, SenderRecovery, TD, TxLookup stages
+        let (block, senders) = block.into_components();
+
+        let (from, to) =
+            insert_canonical_block(self.deref_mut(), block, Some(senders), false).unwrap();
+
+        // account history stage
+        {
+            let indices = self.get_account_transition_ids_from_changeset(from, to)?;
+            self.insert_account_history_index(indices)?;
+        }
+
+        // storage history stage
+        {
+            let indices = self.get_storage_transition_ids_from_changeset(from, to)?;
+            self.insert_storage_history_index(indices)?;
+        }
+
+        Ok(())
+    }
+
+    /// Calculate the hashes of all changed accounts and storages, and finally calculate the state
+    /// root.
+    ///
+    /// The chain goes from `fork_block_number + 1` to `current_block_number`, and hashes are
+    /// calculated from `from_transition_id` to `to_transition_id`.
+    ///
+    /// The resulting state root is compared with `expected_state_root`.
+    pub fn insert_hashes(
+        &mut self,
+        fork_block_number: BlockNumber,
+        from_transition_id: TransitionId,
+        to_transition_id: TransitionId,
+        current_block_number: BlockNumber,
+        current_block_hash: H256,
+        expected_state_root: H256,
+    ) -> Result<(), TransactionError> {
+        // storage hashing stage
+        {
+            let lists = self
+                .get_addresses_and_keys_of_changed_storages(from_transition_id, to_transition_id)?;
+            let storages = self.get_plainstate_storages(lists.into_iter())?;
+            self.insert_storage_for_hashing(storages.into_iter())?;
+        }
+
+        // account hashing stage
+        {
+            let lists =
+                self.get_addresses_of_changed_accounts(from_transition_id, to_transition_id)?;
+            let accounts = self.get_plainstate_accounts(lists.into_iter())?;
+            self.insert_account_for_hashing(accounts.into_iter())?;
+        }
+
+        // merkle tree
+        {
+            let current_root = self.get_header(fork_block_number)?.state_root;
+            let mut loader = DBTrieLoader::new(self.deref_mut());
+            let root = loader
+                .update_root(current_root, from_transition_id..to_transition_id)
+                .and_then(|e| e.root())?;
+            if root != expected_state_root {
+                return Err(TransactionError::StateTrieRootMismatch {
+                    got: root,
+                    expected: expected_state_root,
+                    block_number: current_block_number,
+                    block_hash: current_block_hash,
+                })
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Return list of entries from table
+    ///
+    /// If TAKE is true, opened cursor would be write and it would delete all values from db.
+    #[inline]
+    pub fn get_or_take<T: Table, const TAKE: bool>(
+        &self,
+        range: impl RangeBounds<T::Key>,
+    ) -> Result<Vec<KeyValue<T>>, DbError> {
+        if TAKE {
+            let mut cursor_write = self.cursor_write::<T>()?;
+            let mut walker = cursor_write.walk_range(range)?;
+            let mut items = Vec::new();
+            while let Some(i) = walker.next().transpose()? {
+                walker.delete_current()?;
+                items.push(i)
+            }
+            Ok(items)
+        } else {
+            self.cursor_read::<T>()?.walk_range(range)?.collect::<Result<Vec<_>, _>>()
+        }
+    }
+
+    /// Get requested blocks transaction with signer
+    fn get_take_block_transaction_range<const TAKE: bool>(
+        &self,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<(BlockNumber, Vec<TransactionSignedEcRecovered>)>, TransactionError> {
+        // Just read block tx id from table. as it is needed to get execution results.
+        let block_bodies = self.get_or_take::<tables::BlockBodies, false>(range)?;
+
+        if block_bodies.is_empty() {
+            return Ok(Vec::new())
+        }
+
+        // iterate over and get all transaction and signers
+        let first_transaction =
+            block_bodies.first().expect("If we have headers").1.first_tx_index();
+        let last_transaction = block_bodies.last().expect("Not empty").1.last_tx_index();
+
+        let transactions =
+            self.get_or_take::<tables::Transactions, TAKE>(first_transaction..=last_transaction)?;
+        let senders =
+            self.get_or_take::<tables::TxSenders, TAKE>(first_transaction..=last_transaction)?;
+
+        if TAKE {
+            // rm TxHashNumber
+            let mut tx_hash_cursor = self.cursor_write::<tables::TxHashNumber>()?;
+            for (_, tx) in transactions.iter() {
+                if tx_hash_cursor.seek_exact(tx.hash())?.is_some() {
+                    tx_hash_cursor.delete_current()?;
+                }
+            }
+            // rm TxTransitionId
+            self.get_or_take::<tables::TxTransitionIndex, TAKE>(
+                first_transaction..=last_transaction,
+            )?;
+        }
+
+        // Merge transaction into blocks
+        let mut block_tx = Vec::new();
+        let mut senders = senders.into_iter();
+        let mut transactions = transactions.into_iter();
+        for (block_number, block_body) in block_bodies {
+            let mut one_block_tx = Vec::new();
+            for _ in block_body.tx_id_range() {
+                let tx = transactions.next();
+                let sender = senders.next();
+
+                let recovered = match (tx, sender) {
+                    (Some((tx_id, tx)), Some((sender_tx_id, sender))) => {
+                        if tx_id != sender_tx_id {
+                            Err(ProviderError::MismatchOfTransactionAndSenderId { tx_id })
+                        } else {
+                            Ok(TransactionSignedEcRecovered::from_signed_transaction(tx, sender))
+                        }
+                    }
+                    (Some((tx_id, _)), _) | (_, Some((tx_id, _))) => {
+                        Err(ProviderError::MismatchOfTransactionAndSenderId { tx_id })
+                    }
+                    (None, None) => Err(ProviderError::BlockBodyTransactionCount),
+                }?;
+                one_block_tx.push(recovered)
+            }
+            block_tx.push((block_number, one_block_tx));
+        }
+
+        Ok(block_tx)
+    }
+
+    /// Return range of blocks and its execution result
+    fn get_take_block_range<const TAKE: bool>(
+        &self,
+        chain_spec: &ChainSpec,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<SealedBlockWithSenders>, TransactionError> {
+        // For block we need Headers, Bodies, Uncles, withdrawals, Transactions, Signers
+
+        let block_headers = self.get_or_take::<tables::Headers, TAKE>(range.clone())?;
+        if block_headers.is_empty() {
+            return Ok(Vec::new())
+        }
+
+        let block_header_hashes =
+            self.get_or_take::<tables::CanonicalHeaders, TAKE>(range.clone())?;
+        let block_ommers = self.get_or_take::<tables::BlockOmmers, TAKE>(range.clone())?;
+        let block_withdrawals =
+            self.get_or_take::<tables::BlockWithdrawals, TAKE>(range.clone())?;
+
+        let block_tx = self.get_take_block_transaction_range::<TAKE>(range.clone())?;
+
+        if TAKE {
+            // rm HeaderTD
+            self.get_or_take::<tables::HeaderTD, TAKE>(range)?;
+            // rm HeaderNumbers
+            let mut header_number_cursor = self.cursor_write::<tables::HeaderNumbers>()?;
+            for (_, hash) in block_header_hashes.iter() {
+                if header_number_cursor.seek_exact(*hash)?.is_some() {
+                    header_number_cursor.delete_current()?;
+                }
+            }
+        }
+
+        // merge all into block
+        let block_header_iter = block_headers.into_iter();
+        let block_header_hashes_iter = block_header_hashes.into_iter();
+        let block_tx_iter = block_tx.into_iter();
+
+        // can be not found in tables
+        let mut block_ommers_iter = block_ommers.into_iter();
+        let mut block_withdrawals_iter = block_withdrawals.into_iter();
+        let mut block_ommers = block_ommers_iter.next();
+        let mut block_withdrawals = block_withdrawals_iter.next();
+
+        let mut blocks = Vec::new();
+        for ((main_block_number, header), (_, header_hash), (_, tx)) in izip!(
+            block_header_iter.into_iter(),
+            block_header_hashes_iter.into_iter(),
+            block_tx_iter.into_iter()
+        ) {
+            let header = header.seal(header_hash);
+
+            let (body, senders) = tx.into_iter().map(|tx| tx.to_components()).unzip();
+
+            // Ommers can be missing
+            let mut ommers = Vec::new();
+            if let Some((block_number, _)) = block_ommers.as_ref() {
+                if *block_number == main_block_number {
+                    // Seal ommers as they dont have hash.
+                    ommers = block_ommers
+                        .take()
+                        .unwrap()
+                        .1
+                        .ommers
+                        .into_iter()
+                        .map(|h| h.seal_slow())
+                        .collect();
+                    block_ommers = block_ommers_iter.next();
+                }
+            };
+
+            // withdrawal can be missing
+            let shanghai_is_active =
+                chain_spec.fork(Hardfork::Paris).active_at_block(main_block_number);
+            let mut withdrawals = Some(Vec::new());
+            if shanghai_is_active {
+                if let Some((block_number, _)) = block_withdrawals.as_ref() {
+                    if *block_number == main_block_number {
+                        withdrawals = Some(block_withdrawals.take().unwrap().1.withdrawals);
+                        block_withdrawals = block_withdrawals_iter.next();
+                    }
+                }
+            } else {
+                withdrawals = None
+            }
+
+            blocks.push(SealedBlockWithSenders {
+                block: SealedBlock { header, body, ommers, withdrawals },
+                senders,
+            })
+        }
+
+        Ok(blocks)
+    }
+
+    /// Traverse over changesets and plain state and recreate the [`PostState`]s for the given range
+    /// of blocks.
+    ///
+    /// 1. Iterate over the [BlockTransitionIndex][tables::BlockTransitionIndex] table to get all
+    /// the transitions
+    /// 2. Iterate over the [StorageChangeSet][tables::StorageChangeSet] table
+    /// and the [AccountChangeSet][tables::AccountChangeSet] tables in reverse order to reconstruct
+    /// the changesets.
+    ///     - In order to have both the old and new values in the changesets, we also access the
+    ///       plain state tables.
+    /// 3. While iterating over the changeset tables, if we encounter a new account or storage slot,
+    /// we:
+    ///     1. Take the old value from the changeset
+    ///     2. Take the new value from the plain state
+    ///     3. Save the old value to the local state
+    /// 4. While iterating over the changeset tables, if we encounter an account/storage slot we
+    /// have seen before we:
+    ///     1. Take the old value from the changeset
+    ///     2. Take the new value from the local state
+    ///     3. Set the local state to the value in the changeset
+    ///
+    /// If `TAKE` is `true`, the local state will be written to the plain state tables.
+    fn get_take_block_execution_result_range<const TAKE: bool>(
+        &self,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<PostState>, TransactionError> {
+        let block_transition =
+            self.get_or_take::<tables::BlockTransitionIndex, TAKE>(range.clone())?;
+
+        if block_transition.is_empty() {
+            return Ok(Vec::new())
+        }
+        // get block transitions
+        let first_block_number =
+            block_transition.first().expect("Check for empty is already done").0;
+
+        // get block transition of parent block.
+        let from = self.get_block_transition(first_block_number.saturating_sub(1))?;
+        let to = block_transition.last().expect("Check for empty is already done").1;
+
+        // NOTE: Just get block bodies dont remove them
+        // it is connection point for bodies getter and execution result getter.
+        let block_bodies = self.get_or_take::<tables::BlockBodies, false>(range)?;
+
+        // get saved previous values
+        let from_storage: TransitionIdAddress = (from, Address::zero()).into();
+        let to_storage: TransitionIdAddress = (to, Address::zero()).into();
+
+        let storage_changeset =
+            self.get_or_take::<tables::StorageChangeSet, TAKE>(from_storage..to_storage)?;
+        let account_changeset = self.get_or_take::<tables::AccountChangeSet, TAKE>(from..to)?;
+
+        // iterate previous value and get plain state value to create changeset
+        // Double option around Account represent if Account state is know (first option) and
+        // account is removed (Second Option)
+        type LocalPlainState = BTreeMap<Address, (Option<Option<Account>>, BTreeMap<H256, U256>)>;
+        type Changesets = BTreeMap<TransitionId, Vec<Change>>;
+
+        let mut local_plain_state: LocalPlainState = BTreeMap::new();
+
+        // iterate in reverse and get plain state.
+
+        // Bundle execution changeset to its particular transaction and block
+        let mut all_changesets: Changesets = BTreeMap::new();
+
+        let mut plain_accounts_cursor = self.cursor_write::<tables::PlainAccountState>()?;
+        let mut plain_storage_cursor = self.cursor_dup_write::<tables::PlainStorageState>()?;
+
+        // add account changeset changes
+        for (transition_id, account_before) in account_changeset.into_iter().rev() {
+            let AccountBeforeTx { info: old_info, address } = account_before;
+            let new_info = match local_plain_state.entry(address) {
+                Entry::Vacant(entry) => {
+                    let new_account = plain_accounts_cursor.seek_exact(address)?.map(|kv| kv.1);
+                    entry.insert((Some(old_info), BTreeMap::new()));
+                    new_account
+                }
+                Entry::Occupied(mut entry) => {
+                    let new_account = std::mem::replace(&mut entry.get_mut().0, Some(old_info));
+                    new_account.expect("As we are stacking account first, account would always be Some(Some) or Some(None)")
+                }
+            };
+
+            let change = match (old_info, new_info) {
+                (Some(old), Some(new)) => {
+                    if new != old {
+                        Change::AccountChanged {
+                            id: transition_id,
+                            address,
+                            old,
+                            new,
+                        }
+                    } else {
+                        unreachable!("Junk data in database: an account changeset did not represent any change");
+                    }
+                }
+                (None, Some(account)) => Change::AccountCreated {
+                    id: transition_id,
+                    address,
+                    account
+                },
+                (Some(old), None) => Change::AccountDestroyed {
+                    id: transition_id,
+                    address,
+                    old
+                },
+                (None, None) => unreachable!("Junk data in database: an account changeset transitioned from no account to no account"),
+            };
+            all_changesets.entry(transition_id).or_default().push(change);
+        }
+
+        // add storage changeset changes
+        let mut storage_changes: BTreeMap<TransitionIdAddress, StorageChangeset> = BTreeMap::new();
+        for (transition_and_address, storage_entry) in storage_changeset.into_iter().rev() {
+            let TransitionIdAddress((_, address)) = transition_and_address;
+            let new_storage =
+                match local_plain_state.entry(address).or_default().1.entry(storage_entry.key) {
+                    Entry::Vacant(entry) => {
+                        let new_storage = plain_storage_cursor
+                            .seek_by_key_subkey(address, storage_entry.key)?
+                            .filter(|storage| storage.key == storage_entry.key)
+                            .unwrap_or_default();
+                        entry.insert(storage_entry.value);
+                        new_storage.value
+                    }
+                    Entry::Occupied(mut entry) => {
+                        std::mem::replace(entry.get_mut(), storage_entry.value)
+                    }
+                };
+            storage_changes.entry(transition_and_address).or_default().insert(
+                U256::from_be_bytes(storage_entry.key.0),
+                (storage_entry.value, new_storage),
+            );
+        }
+
+        for (TransitionIdAddress((transition_id, address)), storage_changeset) in
+            storage_changes.into_iter()
+        {
+            all_changesets.entry(transition_id).or_default().push(Change::StorageChanged {
+                id: transition_id,
+                address,
+                changeset: storage_changeset,
+            });
+        }
+
+        if TAKE {
+            // iterate over local plain state remove all account and all storages.
+            for (address, (account, storage)) in local_plain_state.into_iter() {
+                // revert account
+                if let Some(account) = account {
+                    plain_accounts_cursor.seek_exact(address)?;
+                    if let Some(account) = account {
+                        plain_accounts_cursor.upsert(address, account)?;
+                    } else {
+                        plain_accounts_cursor.delete_current()?;
+                    }
+                }
+
+                // revert storages
+                for (storage_key, storage_value) in storage.into_iter() {
+                    let storage_entry = StorageEntry { key: storage_key, value: storage_value };
+                    // delete previous value
+                    // TODO: This does not use dupsort features
+                    if plain_storage_cursor
+                        .seek_by_key_subkey(address, storage_key)?
+                        .filter(|s| s.key == storage_key)
+                        .is_some()
+                    {
+                        plain_storage_cursor.delete_current()?
+                    }
+
+                    // TODO: This does not use dupsort features
+                    // insert value if needed
+                    if storage_value != U256::ZERO {
+                        plain_storage_cursor.insert(address, storage_entry)?;
+                    }
+                }
+            }
+        }
+
+        // iterate over block body and create ExecutionResult
+        let mut block_exec_results = Vec::new();
+        let mut block_transition_iter = block_transition.into_iter();
+        let mut next_transition_id = from;
+
+        // loop break if we are at the end of the blocks.
+        for (_, block_body) in block_bodies.into_iter() {
+            let mut block_exec_res = PostState::new();
+            for _ in 0..block_body.tx_count {
+                if let Some(changes) = all_changesets.remove(&next_transition_id) {
+                    for mut change in changes.into_iter() {
+                        change
+                            .set_transition_id(block_exec_res.transitions_count() as TransitionId);
+                        block_exec_res.add_and_apply(change);
+                    }
+                }
+                block_exec_res.finish_transition();
+                next_transition_id += 1;
+            }
+
+            let Some((_,block_transition)) = block_transition_iter.next() else { break};
+            // if block transition points to 1+next transition id it means that there is block
+            // changeset.
+            if block_transition == next_transition_id + 1 {
+                if let Some(changes) = all_changesets.remove(&next_transition_id) {
+                    for mut change in changes.into_iter() {
+                        change
+                            .set_transition_id(block_exec_res.transitions_count() as TransitionId);
+                        block_exec_res.add_and_apply(change);
+                    }
+                    block_exec_res.finish_transition();
+                    next_transition_id += 1;
+                }
+            }
+            block_exec_results.push(block_exec_res)
+        }
+        Ok(block_exec_results)
+    }
+
+    /// Return range of blocks and its execution result
+    pub fn get_take_block_and_execution_range<const TAKE: bool>(
+        &self,
+        chain_spec: &ChainSpec,
+        range: impl RangeBounds<BlockNumber> + Clone,
+    ) -> Result<Vec<(SealedBlockWithSenders, PostState)>, TransactionError> {
+        if TAKE {
+            let (from_transition, parent_number, parent_state_root) = match range.start_bound() {
+                Bound::Included(n) => {
+                    let parent_number = n.saturating_sub(1);
+                    let transition = self.get_block_transition(parent_number)?;
+                    let parent = self.get_header(parent_number)?;
+                    (transition, parent_number, parent.state_root)
+                }
+                Bound::Excluded(n) => {
+                    let transition = self.get_block_transition(*n)?;
+                    let parent = self.get_header(*n)?;
+                    (transition, *n, parent.state_root)
+                }
+                Bound::Unbounded => (0, 0, EMPTY_ROOT),
+            };
+            let to_transition = match range.end_bound() {
+                Bound::Included(n) => self.get_block_transition(*n)?,
+                Bound::Excluded(n) => self.get_block_transition(n.saturating_sub(1))?,
+                Bound::Unbounded => TransitionId::MAX,
+            };
+
+            let transition_range = from_transition..to_transition;
+            let zero = Address::zero();
+            let transition_storage_range =
+                (from_transition, zero).into()..(to_transition, zero).into();
+
+            self.unwind_account_hashing(transition_range.clone())?;
+            self.unwind_account_history_indices(transition_range.clone())?;
+            self.unwind_storage_hashing(transition_storage_range.clone())?;
+            self.unwind_storage_history_indices(transition_storage_range)?;
+
+            // merkle tree
+            let new_state_root;
+            {
+                let (tip_number, _) =
+                    self.cursor_read::<tables::CanonicalHeaders>()?.last()?.unwrap_or_default();
+                let current_root = self.get_header(tip_number)?.state_root;
+                let mut loader = DBTrieLoader::new(self.deref());
+                new_state_root =
+                    loader.update_root(current_root, transition_range).and_then(|e| e.root())?;
+            }
+            // state root should be always correct as we are reverting state.
+            // but for sake of double verification we will check it again.
+            if new_state_root != parent_state_root {
+                let parent_hash = self.get_block_hash(parent_number)?;
+                return Err(TransactionError::StateTrieRootMismatch {
+                    got: new_state_root,
+                    expected: parent_state_root,
+                    block_number: parent_number,
+                    block_hash: parent_hash,
+                })
+            }
+        }
+        // get blocks
+        let blocks = self.get_take_block_range::<TAKE>(chain_spec, range.clone())?;
+        // get execution res
+        let execution_res = self.get_take_block_execution_result_range::<TAKE>(range.clone())?;
+        // combine them
+        let blocks_with_exec_result: Vec<_> =
+            blocks.into_iter().zip(execution_res.into_iter()).collect();
+
+        // remove block bodies it is needed for both get block range and get block execution results
+        // that is why it is deleted afterwards.
+        if TAKE {
+            // rm block bodies
+            self.get_or_take::<tables::BlockBodies, TAKE>(range)?;
+        }
+
+        // return them
+        Ok(blocks_with_exec_result)
+    }
+
+    /// Update all pipeline sync stage progress.
+    pub fn update_pipeline_stages(
+        &self,
+        block_number: BlockNumber,
+    ) -> Result<(), TransactionError> {
+        // iterate over
+        let mut cursor = self.cursor_write::<tables::SyncStage>()?;
+        while let Some((stage_name, _)) = cursor.next()? {
+            cursor.upsert(stage_name, block_number)?
+        }
+
+        Ok(())
+    }
+
+    /// Iterate over account changesets and return all account address that were changed.
+    pub fn get_addresses_and_keys_of_changed_storages(
+        &self,
+        from: TransitionId,
+        to: TransitionId,
+    ) -> Result<BTreeMap<Address, BTreeSet<H256>>, TransactionError> {
+        Ok(self
+            .cursor_read::<tables::StorageChangeSet>()?
+            .walk_range(
+                TransitionIdAddress((from, Address::zero()))..
+                    TransitionIdAddress((to, Address::zero())),
+            )?
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            // fold all storages and save its old state so we can remove it from HashedStorage
+            // it is needed as it is dup table.
+            .fold(
+                BTreeMap::new(),
+                |mut accounts: BTreeMap<Address, BTreeSet<H256>>,
+                 (TransitionIdAddress((_, address)), storage_entry)| {
+                    accounts.entry(address).or_default().insert(storage_entry.key);
+                    accounts
+                },
+            ))
+    }
+
+    ///  Get plainstate storages
+    #[allow(clippy::type_complexity)]
+    pub fn get_plainstate_storages(
+        &self,
+        iter: impl IntoIterator<Item = (Address, impl IntoIterator<Item = H256>)>,
+    ) -> Result<Vec<(Address, Vec<(H256, U256)>)>, TransactionError> {
+        let mut plain_storage = self.cursor_dup_read::<tables::PlainStorageState>()?;
+
+        iter.into_iter()
+            .map(|(address, storage)| {
+                storage
+                    .into_iter()
+                    .map(|key| -> Result<_, TransactionError> {
+                        let ret = plain_storage
+                            .seek_by_key_subkey(address, key)?
+                            .filter(|v| v.key == key)
+                            .unwrap_or_default();
+                        Ok((key, ret.value))
+                    })
+                    .collect::<Result<Vec<(_, _)>, _>>()
+                    .map(|storage| (address, storage))
+            })
+            .collect::<Result<Vec<(_, _)>, _>>()
+    }
+
+    /// iterate over storages and insert them to hashing table
+    pub fn insert_storage_for_hashing(
+        &self,
+        storages: impl IntoIterator<Item = (Address, impl IntoIterator<Item = (H256, U256)>)>,
+    ) -> Result<(), TransactionError> {
+        // hash values
+        let hashed = storages.into_iter().fold(BTreeMap::new(), |mut map, (address, storage)| {
+            let storage = storage.into_iter().fold(BTreeMap::new(), |mut map, (key, value)| {
+                map.insert(keccak256(key), value);
+                map
+            });
+            map.insert(keccak256(address), storage);
+            map
+        });
+
+        let mut hashed_storage = self.cursor_dup_write::<tables::HashedStorage>()?;
+        // Hash the address and key and apply them to HashedStorage (if Storage is None
+        // just remove it);
+        hashed.into_iter().try_for_each(|(hashed_address, storage)| {
+            storage.into_iter().try_for_each(|(key, value)| -> Result<(), TransactionError> {
+                if hashed_storage
+                    .seek_by_key_subkey(hashed_address, key)?
+                    .filter(|entry| entry.key == key)
+                    .is_some()
+                {
+                    hashed_storage.delete_current()?;
+                }
+
+                if value != U256::ZERO {
+                    hashed_storage.upsert(hashed_address, StorageEntry { key, value })?;
+                }
+                Ok(())
+            })
+        })?;
+        Ok(())
+    }
+
+    /// Iterate over account changesets and return all account address that were changed.
+    pub fn get_addresses_of_changed_accounts(
+        &self,
+        from: TransitionId,
+        to: TransitionId,
+    ) -> Result<BTreeSet<Address>, TransactionError> {
+        Ok(self
+            .cursor_read::<tables::AccountChangeSet>()?
+            .walk_range(from..to)?
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            // fold all account to one set of changed accounts
+            .fold(BTreeSet::new(), |mut accounts: BTreeSet<Address>, (_, account_before)| {
+                accounts.insert(account_before.address);
+                accounts
+            }))
+    }
+
+    /// Get plainstate account from iterator
+    pub fn get_plainstate_accounts(
+        &self,
+        iter: impl IntoIterator<Item = Address>,
+    ) -> Result<Vec<(Address, Option<Account>)>, TransactionError> {
+        let mut plain_accounts = self.cursor_read::<tables::PlainAccountState>()?;
+        Ok(iter
+            .into_iter()
+            .map(|address| plain_accounts.seek_exact(address).map(|a| (address, a.map(|(_, v)| v))))
+            .collect::<Result<Vec<_>, _>>()?)
+    }
+
+    /// iterate over accounts and insert them to hashing table
+    pub fn insert_account_for_hashing(
+        &self,
+        accounts: impl IntoIterator<Item = (Address, Option<Account>)>,
+    ) -> Result<(), TransactionError> {
+        let mut hashed_accounts = self.cursor_write::<tables::HashedAccount>()?;
+
+        let hashes_accounts = accounts.into_iter().fold(
+            BTreeMap::new(),
+            |mut map: BTreeMap<H256, Option<Account>>, (address, account)| {
+                map.insert(keccak256(address), account);
+                map
+            },
+        );
+
+        hashes_accounts.into_iter().try_for_each(
+            |(hashed_address, account)| -> Result<(), TransactionError> {
+                if let Some(account) = account {
+                    hashed_accounts.upsert(hashed_address, account)?
+                } else if hashed_accounts.seek_exact(hashed_address)?.is_some() {
+                    hashed_accounts.delete_current()?;
+                }
+                Ok(())
+            },
+        )?;
+        Ok(())
+    }
+
+    /// Get all transaction ids where account got changed.
+    pub fn get_storage_transition_ids_from_changeset(
+        &self,
+        from: TransitionId,
+        to: TransitionId,
+    ) -> Result<BTreeMap<(Address, H256), Vec<u64>>, TransactionError> {
+        let storage_changeset = self
+            .cursor_read::<tables::StorageChangeSet>()?
+            .walk(Some((from, Address::zero()).into()))?
+            .take_while(|res| res.as_ref().map(|(k, _)| k.transition_id() < to).unwrap_or_default())
+            .collect::<Result<Vec<_>, _>>()?;
+
+        // fold all storages to one set of changes
+        let storage_changeset_lists = storage_changeset.into_iter().fold(
+            BTreeMap::new(),
+            |mut storages: BTreeMap<(Address, H256), Vec<u64>>, (index, storage)| {
+                storages
+                    .entry((index.address(), storage.key))
+                    .or_default()
+                    .push(index.transition_id());
+                storages
+            },
+        );
+
+        Ok(storage_changeset_lists)
+    }
+
+    /// Get all transaction ids where account got changed.
+    pub fn get_account_transition_ids_from_changeset(
+        &self,
+        from: TransitionId,
+        to: TransitionId,
+    ) -> Result<BTreeMap<Address, Vec<u64>>, TransactionError> {
+        let account_changesets = self
+            .cursor_read::<tables::AccountChangeSet>()?
+            .walk(Some(from))?
+            .take_while(|res| res.as_ref().map(|(k, _)| *k < to).unwrap_or_default())
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let account_transtions = account_changesets
+            .into_iter()
+            // fold all account to one set of changed accounts
+            .fold(
+                BTreeMap::new(),
+                |mut accounts: BTreeMap<Address, Vec<u64>>, (index, account)| {
+                    accounts.entry(account.address).or_default().push(index);
+                    accounts
+                },
+            );
+
+        Ok(account_transtions)
+    }
+
+    /// Insert storage change index to database. Used inside StorageHistoryIndex stage
+    pub fn insert_storage_history_index(
+        &self,
+        storage_transitions: BTreeMap<(Address, H256), Vec<u64>>,
+    ) -> Result<(), TransactionError> {
+        for ((address, storage_key), mut indices) in storage_transitions {
+            let mut last_shard = self.take_last_storage_shard(address, storage_key)?;
+            last_shard.append(&mut indices);
+
+            // chunk indices and insert them in shards of N size.
+            let mut chunks = last_shard
+                .iter()
+                .chunks(storage_sharded_key::NUM_OF_INDICES_IN_SHARD)
+                .into_iter()
+                .map(|chunks| chunks.map(|i| *i as usize).collect::<Vec<usize>>())
+                .collect::<Vec<_>>();
+            let last_chunk = chunks.pop();
+
+            // chunk indices and insert them in shards of N size.
+            chunks.into_iter().try_for_each(|list| {
+                self.put::<tables::StorageHistory>(
+                    StorageShardedKey::new(
+                        address,
+                        storage_key,
+                        *list.last().expect("Chuck does not return empty list") as TransitionId,
+                    ),
+                    TransitionList::new(list).expect("Indices are presorted and not empty"),
+                )
+            })?;
+            // Insert last list with u64::MAX
+            if let Some(last_list) = last_chunk {
+                self.put::<tables::StorageHistory>(
+                    StorageShardedKey::new(address, storage_key, u64::MAX),
+                    TransitionList::new(last_list).expect("Indices are presorted and not empty"),
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Insert account change index to database. Used inside AccountHistoryIndex stage
+    pub fn insert_account_history_index(
+        &self,
+        account_transitions: BTreeMap<Address, Vec<u64>>,
+    ) -> Result<(), TransactionError> {
+        // insert indexes to AccountHistory.
+        for (address, mut indices) in account_transitions {
+            let mut last_shard = self.take_last_account_shard(address)?;
+            last_shard.append(&mut indices);
+            // chunk indices and insert them in shards of N size.
+            let mut chunks = last_shard
+                .iter()
+                .chunks(sharded_key::NUM_OF_INDICES_IN_SHARD)
+                .into_iter()
+                .map(|chunks| chunks.map(|i| *i as usize).collect::<Vec<usize>>())
+                .collect::<Vec<_>>();
+            let last_chunk = chunks.pop();
+
+            chunks.into_iter().try_for_each(|list| {
+                self.put::<tables::AccountHistory>(
+                    ShardedKey::new(
+                        address,
+                        *list.last().expect("Chuck does not return empty list") as TransitionId,
+                    ),
+                    TransitionList::new(list).expect("Indices are presorted and not empty"),
+                )
+            })?;
+            // Insert last list with u64::MAX
+            if let Some(last_list) = last_chunk {
+                self.put::<tables::AccountHistory>(
+                    ShardedKey::new(address, u64::MAX),
+                    TransitionList::new(last_list).expect("Indices are presorted and not empty"),
+                )?
+            }
+        }
+        Ok(())
+    }
+
+    /// Return full table as Vec
+    pub fn table<T: Table>(&self) -> Result<Vec<KeyValue<T>>, DbError>
+    where
+        T::Key: Default + Ord,
+    {
+        self.cursor_read::<T>()?.walk(Some(T::Key::default()))?.collect::<Result<Vec<_>, DbError>>()
+    }
+}
+
+/// Unwind all history shards. For boundary shard, remove it from database and
+/// return last part of shard with still valid items. If all full shard were removed, return list
+/// would be empty.
+fn unwind_account_history_shards<DB: Database>(
+    cursor: &mut <<DB as DatabaseGAT<'_>>::TXMut as DbTxMutGAT<'_>>::CursorMut<
+        tables::AccountHistory,
+    >,
+    address: Address,
+    transition_id: TransitionId,
+) -> Result<Vec<usize>, TransactionError> {
+    let mut item = cursor.seek_exact(ShardedKey::new(address, u64::MAX))?;
+
+    while let Some((sharded_key, list)) = item {
+        // there is no more shard for address
+        if sharded_key.key != address {
+            break
+        }
+        cursor.delete_current()?;
+        // check first item and if it is more and eq than `transition_id` delete current
+        // item.
+        let first = list.iter(0).next().expect("List can't empty");
+        if first >= transition_id as usize {
+            item = cursor.prev()?;
+            continue
+        } else if transition_id <= sharded_key.highest_transition_id {
+            // if first element is in scope whole list would be removed.
+            // so at least this first element is present.
+            return Ok(list.iter(0).take_while(|i| *i < transition_id as usize).collect::<Vec<_>>())
+        } else {
+            let new_list = list.iter(0).collect::<Vec<_>>();
+            return Ok(new_list)
+        }
+    }
+    Ok(Vec::new())
+}
+
+/// Unwind all history shards. For boundary shard, remove it from database and
+/// return last part of shard with still valid items. If all full shard were removed, return list
+/// would be empty but this does not mean that there is none shard left but that there is no
+/// splitted shards.
+fn unwind_storage_history_shards<DB: Database>(
+    cursor: &mut <<DB as DatabaseGAT<'_>>::TXMut as DbTxMutGAT<'_>>::CursorMut<
+        tables::StorageHistory,
+    >,
+    address: Address,
+    storage_key: H256,
+    transition_id: TransitionId,
+) -> Result<Vec<usize>, TransactionError> {
+    let mut item = cursor.seek_exact(StorageShardedKey::new(address, storage_key, u64::MAX))?;
+
+    while let Some((storage_sharded_key, list)) = item {
+        // there is no more shard for address
+        if storage_sharded_key.address != address ||
+            storage_sharded_key.sharded_key.key != storage_key
+        {
+            // there is no more shard for address and storage_key.
+            break
+        }
+        cursor.delete_current()?;
+        // check first item and if it is more and eq than `transition_id` delete current
+        // item.
+        let first = list.iter(0).next().expect("List can't empty");
+        if first >= transition_id as usize {
+            item = cursor.prev()?;
+            continue
+        } else if transition_id <= storage_sharded_key.sharded_key.highest_transition_id {
+            // if first element is in scope whole list would be removed.
+            // so at least this first element is present.
+            return Ok(list.iter(0).take_while(|i| *i < transition_id as usize).collect::<Vec<_>>())
+        } else {
+            return Ok(list.iter(0).collect::<Vec<_>>())
+        }
+    }
+    Ok(Vec::new())
 }
 
 /// An error that can occur when using the transaction container
@@ -224,4 +1460,116 @@ pub enum TransactionError {
     /// The transaction encountered a database integrity error.
     #[error("A database integrity error occurred: {0}")]
     DatabaseIntegrity(#[from] ProviderError),
+    /// The transaction encountered merkle trie error.
+    #[error("Merkle trie calculation error: {0}")]
+    MerkleTrie(#[from] TrieError),
+    /// Root mismatch
+    #[error("Merkle trie root mismatch on block: #{block_number:?} {block_hash:?}. got: {got:?} expected:{expected:?}")]
+    StateTrieRootMismatch {
+        /// Expected root
+        expected: H256,
+        /// Calculated root
+        got: H256,
+        /// Block number
+        block_number: BlockNumber,
+        /// Block hash
+        block_hash: BlockHash,
+    },
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{insert_canonical_block, test_utils::blocks::*, Transaction};
+    use reth_db::{mdbx::test_utils::create_test_rw_db, tables, transaction::DbTxMut};
+    use reth_primitives::{proofs::EMPTY_ROOT, ChainSpecBuilder, TransitionId, MAINNET};
+    use std::ops::DerefMut;
+
+    #[test]
+    fn insert_get_take() {
+        let db = create_test_rw_db();
+
+        // setup
+        let mut tx = Transaction::new(db.as_ref()).unwrap();
+        let chain_spec = ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(MAINNET.genesis.clone())
+            .shanghai_activated()
+            .build();
+
+        let data = BlockChainTestData::default();
+        let genesis = data.genesis.clone();
+        let (block1, exec_res1) = data.blocks[0].clone();
+        let (block2, exec_res2) = data.blocks[1].clone();
+
+        insert_canonical_block(tx.deref_mut(), data.genesis.clone(), None, false).unwrap();
+
+        tx.put::<tables::AccountsTrie>(EMPTY_ROOT, vec![0x80]).unwrap();
+        assert_genesis_block(&tx, data.genesis);
+
+        exec_res1.clone().write_to_db(tx.deref_mut(), 0).unwrap();
+        tx.insert_block(block1.clone()).unwrap();
+        tx.insert_hashes(
+            genesis.number,
+            0,
+            exec_res1.transitions_count() as TransitionId,
+            block1.number,
+            block1.hash,
+            block1.state_root,
+        )
+        .unwrap();
+
+        // get one block
+        let get = tx.get_block_and_execution_range(&chain_spec, 1..=1).unwrap();
+        assert_eq!(get, vec![(block1.clone(), exec_res1.clone())]);
+
+        // take one block
+        let take = tx.take_block_and_execution_range(&chain_spec, 1..=1).unwrap();
+        assert_eq!(take, vec![(block1.clone(), exec_res1.clone())]);
+        assert_genesis_block(&tx, genesis.clone());
+
+        exec_res1.clone().write_to_db(tx.deref_mut(), 0).unwrap();
+        tx.insert_block(block1.clone()).unwrap();
+        tx.insert_hashes(
+            genesis.number,
+            0,
+            exec_res1.transitions_count() as TransitionId,
+            block1.number,
+            block1.hash,
+            block1.state_root,
+        )
+        .unwrap();
+
+        exec_res2
+            .clone()
+            .write_to_db(tx.deref_mut(), exec_res1.transitions_count() as TransitionId)
+            .unwrap();
+        tx.insert_block(block2.clone()).unwrap();
+        tx.insert_hashes(
+            block1.number,
+            exec_res1.transitions_count() as TransitionId,
+            exec_res2.transitions_count() as TransitionId,
+            2,
+            block2.hash,
+            block2.state_root,
+        )
+        .unwrap();
+
+        // get second block
+        let get = tx.get_block_and_execution_range(&chain_spec, 2..=2).unwrap();
+        assert_eq!(get, vec![(block2.clone(), exec_res2.clone())]);
+
+        // get two blocks
+        let get = tx.get_block_and_execution_range(&chain_spec, 1..=2).unwrap();
+        assert_eq!(
+            get,
+            vec![(block1.clone(), exec_res1.clone()), (block2.clone(), exec_res2.clone())]
+        );
+
+        // take two blocks
+        let get = tx.take_block_and_execution_range(&chain_spec, 1..=2).unwrap();
+        assert_eq!(get, vec![(block1, exec_res1), (block2, exec_res2)]);
+
+        // assert genesis state
+        assert_genesis_block(&tx, genesis);
+    }
 }
diff --git a/crates/storage/provider/src/trie/mod.rs b/crates/storage/provider/src/trie/mod.rs
new file mode 100644
index 00000000000..8965d6da7d2
--- /dev/null
+++ b/crates/storage/provider/src/trie/mod.rs
@@ -0,0 +1,1230 @@
+use cita_trie::{PatriciaTrie, Trie};
+use hasher::HasherKeccak;
+use reth_codecs::Compact;
+use reth_db::{
+    cursor::{DbCursorRO, DbCursorRW, DbDupCursorRO},
+    models::{AccountBeforeTx, TransitionIdAddress},
+    tables,
+    transaction::{DbTx, DbTxMut},
+};
+use reth_primitives::{
+    keccak256, proofs::EMPTY_ROOT, Account, Address, ProofCheckpoint, StorageEntry,
+    StorageTrieEntry, TransitionId, H256, KECCAK_EMPTY, U256,
+};
+use reth_rlp::{
+    encode_fixed_size, Decodable, DecodeError, Encodable, RlpDecodable, RlpEncodable,
+    EMPTY_STRING_CODE,
+};
+use reth_tracing::tracing::*;
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    marker::PhantomData,
+    ops::Range,
+    sync::Arc,
+};
+
+/// Merkle Trie error types
+#[allow(missing_docs)]
+#[derive(Debug, thiserror::Error)]
+pub enum TrieError {
+    /// Error returned by the underlying implementation.
+    #[error("Some error occurred: {0}")]
+    InternalError(#[from] cita_trie::TrieError),
+    /// The database doesn't contain the root of the trie.
+    #[error("The root node wasn't found in the DB")]
+    MissingAccountRoot(H256),
+    #[error("The storage root node wasn't found in the DB")]
+    MissingStorageRoot(H256),
+    /// Error returned by the database.
+    #[error("{0:?}")]
+    DatabaseError(#[from] reth_db::Error),
+    /// Error when encoding/decoding a value.
+    #[error("{0:?}")]
+    DecodeError(#[from] DecodeError),
+    #[error("Trie requires committing a checkpoint.")]
+    UnexpectedCheckpoint,
+}
+
+/// Database wrapper implementing HashDB trait, with a read-write transaction.
+pub struct HashDatabaseMut<'tx, TX> {
+    tx: &'tx TX,
+}
+
+impl<'tx, 'db, TX> cita_trie::DB for HashDatabaseMut<'tx, TX>
+where
+    TX: DbTxMut<'db> + DbTx<'db> + Send + Sync,
+{
+    type Error = TrieError;
+
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+        Ok(self.tx.get::<tables::AccountsTrie>(H256::from_slice(key))?)
+    }
+
+    fn contains(&self, key: &[u8]) -> Result<bool, Self::Error> {
+        Ok(<Self as cita_trie::DB>::get(self, key)?.is_some())
+    }
+
+    fn insert(&self, _key: Vec<u8>, _value: Vec<u8>) -> Result<(), Self::Error> {
+        unreachable!("Use batch instead.");
+    }
+
+    // Insert a batch of data into the cache.
+    fn insert_batch(&self, keys: Vec<Vec<u8>>, values: Vec<Vec<u8>>) -> Result<(), Self::Error> {
+        let mut cursor = self.tx.cursor_write::<tables::AccountsTrie>()?;
+        for (key, value) in keys.into_iter().zip(values.into_iter()) {
+            cursor.upsert(H256::from_slice(key.as_slice()), value)?;
+        }
+        Ok(())
+    }
+
+    fn remove_batch(&self, keys: &[Vec<u8>]) -> Result<(), Self::Error> {
+        let mut cursor = self.tx.cursor_write::<tables::AccountsTrie>()?;
+        for key in keys {
+            if cursor.seek_exact(H256::from_slice(key.as_slice()))?.is_some() {
+                cursor.delete_current()?;
+            }
+        }
+        Ok(())
+    }
+
+    fn remove(&self, _key: &[u8]) -> Result<(), Self::Error> {
+        unreachable!("Use batch instead.");
+    }
+
+    fn flush(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<'tx, 'db, TX> HashDatabaseMut<'tx, TX>
+where
+    TX: DbTxMut<'db> + DbTx<'db> + Send + Sync,
+{
+    /// Instantiates a new Database for the accounts trie, with an empty root
+    pub fn new(tx: &'tx TX) -> Result<Self, TrieError> {
+        let root = EMPTY_ROOT;
+        if tx.get::<tables::AccountsTrie>(root)?.is_none() {
+            tx.put::<tables::AccountsTrie>(root, [EMPTY_STRING_CODE].to_vec())?;
+        }
+        Ok(Self { tx })
+    }
+
+    /// Instantiates a new Database for the accounts trie, with an existing root
+    pub fn from_root(tx: &'tx TX, root: H256) -> Result<Self, TrieError> {
+        if root == EMPTY_ROOT {
+            return Self::new(tx)
+        }
+        tx.get::<tables::AccountsTrie>(root)?.ok_or(TrieError::MissingAccountRoot(root))?;
+        Ok(Self { tx })
+    }
+}
+
+/// Database wrapper implementing HashDB trait, with a read-write transaction.
+pub struct DupHashDatabaseMut<'tx, TX> {
+    tx: &'tx TX,
+    key: H256,
+}
+
+impl<'tx, 'db, TX> cita_trie::DB for DupHashDatabaseMut<'tx, TX>
+where
+    TX: DbTxMut<'db> + DbTx<'db> + Send + Sync,
+{
+    type Error = TrieError;
+
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+        let mut cursor = self.tx.cursor_dup_read::<tables::StoragesTrie>()?;
+        let subkey = H256::from_slice(key);
+        Ok(cursor
+            .seek_by_key_subkey(self.key, subkey)?
+            .filter(|entry| entry.hash == subkey)
+            .map(|entry| entry.node))
+    }
+
+    fn contains(&self, key: &[u8]) -> Result<bool, Self::Error> {
+        Ok(<Self as cita_trie::DB>::get(self, key)?.is_some())
+    }
+
+    fn insert(&self, _key: Vec<u8>, _value: Vec<u8>) -> Result<(), Self::Error> {
+        unreachable!("Use batch instead.");
+    }
+
+    /// Insert a batch of data into the cache.
+    fn insert_batch(&self, keys: Vec<Vec<u8>>, values: Vec<Vec<u8>>) -> Result<(), Self::Error> {
+        let mut cursor = self.tx.cursor_dup_write::<tables::StoragesTrie>()?;
+        for (key, node) in keys.into_iter().zip(values.into_iter()) {
+            let hash = H256::from_slice(key.as_slice());
+            if cursor.seek_by_key_subkey(self.key, hash)?.filter(|e| e.hash == hash).is_some() {
+                cursor.delete_current()?;
+            }
+            cursor.upsert(self.key, StorageTrieEntry { hash, node })?;
+        }
+        Ok(())
+    }
+
+    fn remove_batch(&self, keys: &[Vec<u8>]) -> Result<(), Self::Error> {
+        let mut cursor = self.tx.cursor_dup_write::<tables::StoragesTrie>()?;
+        for key in keys {
+            let hash = H256::from_slice(key.as_slice());
+            if cursor.seek_by_key_subkey(self.key, hash)?.filter(|e| e.hash == hash).is_some() {
+                cursor.delete_current()?;
+            }
+        }
+        Ok(())
+    }
+
+    fn remove(&self, _key: &[u8]) -> Result<(), Self::Error> {
+        unreachable!("Use batch instead.");
+    }
+
+    fn flush(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<'tx, 'db, TX> DupHashDatabaseMut<'tx, TX>
+where
+    TX: DbTxMut<'db> + DbTx<'db> + Send + Sync,
+{
+    /// Instantiates a new Database for the storage trie, with an empty root
+    pub fn new(tx: &'tx TX, key: H256) -> Result<Self, TrieError> {
+        let root = EMPTY_ROOT;
+        let mut cursor = tx.cursor_dup_write::<tables::StoragesTrie>()?;
+        if cursor.seek_by_key_subkey(key, root)?.filter(|entry| entry.hash == root).is_none() {
+            tx.put::<tables::StoragesTrie>(
+                key,
+                StorageTrieEntry { hash: root, node: [EMPTY_STRING_CODE].to_vec() },
+            )?;
+        }
+        Ok(Self { tx, key })
+    }
+
+    /// Instantiates a new Database for the storage trie, with an existing root
+    pub fn from_root(tx: &'tx TX, key: H256, root: H256) -> Result<Self, TrieError> {
+        if root == EMPTY_ROOT {
+            return Self::new(tx, key)
+        }
+        tx.cursor_dup_read::<tables::StoragesTrie>()?
+            .seek_by_key_subkey(key, root)?
+            .filter(|entry| entry.hash == root)
+            .ok_or(TrieError::MissingStorageRoot(root))?;
+        Ok(Self { tx, key })
+    }
+}
+
+/// Database wrapper implementing HashDB trait, with a read-only transaction.
+pub struct HashDatabase<'tx, 'itx, TX: DbTx<'itx>> {
+    tx: &'tx TX,
+    _p: PhantomData<&'itx ()>, // to suppress "unused" lifetime 'itx
+}
+
+impl<'tx, 'itx, TX: DbTx<'itx>> HashDatabase<'tx, 'itx, TX> {
+    /// Creates a new Hash database with the given transaction
+    pub fn new(tx: &'tx TX) -> Self {
+        Self { tx, _p: Default::default() }
+    }
+}
+
+impl<'tx, 'itx, TX> cita_trie::DB for HashDatabase<'tx, 'itx, TX>
+where
+    TX: DbTx<'itx>,
+{
+    type Error = TrieError;
+
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+        Ok(self.tx.get::<tables::AccountsTrie>(H256::from_slice(key))?)
+    }
+
+    fn contains(&self, key: &[u8]) -> Result<bool, Self::Error> {
+        Ok(<Self as cita_trie::DB>::get(self, key)?.is_some())
+    }
+
+    fn insert(&self, _key: Vec<u8>, _value: Vec<u8>) -> Result<(), Self::Error> {
+        // this could be avoided if cita_trie::DB was split into two traits
+        // with read and write operations respectively
+        unimplemented!("insert isn't valid for read-only transaction");
+    }
+
+    fn remove(&self, _key: &[u8]) -> Result<(), Self::Error> {
+        unimplemented!("remove isn't valid for read-only transaction");
+    }
+
+    fn flush(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<'tx, 'itx, TX: DbTx<'itx>> HashDatabase<'tx, 'itx, TX> {
+    /// Instantiates a new Database for the accounts trie, with an existing root
+    fn from_root(tx: &'tx TX, root: H256) -> Result<Self, TrieError> {
+        tx.get::<tables::AccountsTrie>(root)?.ok_or(TrieError::MissingAccountRoot(root))?;
+        Ok(Self { tx, _p: Default::default() })
+    }
+}
+
+/// Database wrapper implementing HashDB trait, with a read-only transaction.
+pub struct DupHashDatabase<'tx, 'itx, TX: DbTx<'itx>> {
+    tx: &'tx TX,
+    key: H256,
+    _p: PhantomData<&'itx ()>, // to suppress "unused" lifetime 'itx
+}
+
+impl<'tx, 'itx, TX: DbTx<'itx>> DupHashDatabase<'tx, 'itx, TX> {
+    /// Creates a new DupHash database with the given transaction and key.
+    pub fn new(tx: &'tx TX, key: H256) -> Self {
+        Self { tx, key, _p: Default::default() }
+    }
+}
+
+impl<'tx, 'itx, TX> cita_trie::DB for DupHashDatabase<'tx, 'itx, TX>
+where
+    TX: DbTx<'itx>,
+{
+    type Error = TrieError;
+
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+        let mut cursor = self.tx.cursor_dup_read::<tables::StoragesTrie>()?;
+        Ok(cursor.seek_by_key_subkey(self.key, H256::from_slice(key))?.map(|entry| entry.node))
+    }
+
+    fn contains(&self, key: &[u8]) -> Result<bool, Self::Error> {
+        Ok(<Self as cita_trie::DB>::get(self, key)?.is_some())
+    }
+
+    fn insert(&self, _key: Vec<u8>, _value: Vec<u8>) -> Result<(), Self::Error> {
+        // Caching and bulk inserting shouldn't be needed, as the data is ordered
+        unimplemented!("insert isn't valid for read-only transaction");
+    }
+
+    fn remove(&self, _key: &[u8]) -> Result<(), Self::Error> {
+        unimplemented!("remove isn't valid for read-only transaction");
+    }
+
+    fn flush(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<'tx, 'itx, TX: DbTx<'itx>> DupHashDatabase<'tx, 'itx, TX> {
+    /// Instantiates a new Database for the storage trie, with an existing root
+    fn from_root(tx: &'tx TX, key: H256, root: H256) -> Result<Self, TrieError> {
+        tx.cursor_dup_read::<tables::StoragesTrie>()?
+            .seek_by_key_subkey(key, root)?
+            .ok_or(TrieError::MissingAccountRoot(root))?;
+        Ok(Self { tx, key, _p: Default::default() })
+    }
+}
+
+/// An Ethereum account, for RLP encoding traits deriving.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, RlpEncodable, RlpDecodable)]
+pub struct EthAccount {
+    /// Account nonce.
+    nonce: u64,
+    /// Account balance.
+    balance: U256,
+    /// Account's storage root.
+    storage_root: H256,
+    /// Hash of the account's bytecode.
+    code_hash: H256,
+}
+
+impl From<Account> for EthAccount {
+    fn from(acc: Account) -> Self {
+        EthAccount {
+            nonce: acc.nonce,
+            balance: acc.balance,
+            storage_root: EMPTY_ROOT,
+            code_hash: acc.bytecode_hash.unwrap_or(KECCAK_EMPTY),
+        }
+    }
+}
+
+impl EthAccount {
+    /// Set storage root on account.
+    pub fn with_storage_root(mut self, storage_root: H256) -> Self {
+        self.storage_root = storage_root;
+        self
+    }
+
+    /// Get account's storage root.
+    pub fn storage_root(&self) -> H256 {
+        self.storage_root
+    }
+}
+
+/// A merkle proof of existence (or nonexistence) of a leaf value. Consists
+/// of a the encoded nodes in the path from the root of the tree to the leaf.
+pub type MerkleProof = Vec<Vec<u8>>;
+
+/// Struct for calculating the root of a merkle patricia tree,
+/// while populating the database with intermediate hashes.
+#[derive(Debug)]
+pub struct DBTrieLoader<'tx, TX> {
+    /// The maximum number of keys to insert before committing. Both from `AccountsTrie` and
+    /// `StoragesTrie`.
+    pub commit_threshold: u64,
+    /// The current number of inserted keys from both `AccountsTrie` and `StoragesTrie`.
+    pub current: u64,
+    /// The transaction to use for inserting the trie nodes.
+    pub tx: &'tx TX,
+}
+
+/// Status of the trie calculation.
+#[derive(Debug, PartialEq, Copy, Clone)]
+pub enum TrieProgress {
+    /// Trie has finished with the passed root.
+    Complete(H256),
+    /// Trie has hit its commit threshold.
+    InProgress(ProofCheckpoint),
+}
+
+impl TrieProgress {
+    /// Consumes the root from its `Complete` variant. If that's not possible, throw
+    /// `TrieError::UnexpectedCheckpoint`.
+    pub fn root(self) -> Result<H256, TrieError> {
+        match self {
+            Self::Complete(root) => Ok(root),
+            _ => Err(TrieError::UnexpectedCheckpoint),
+        }
+    }
+}
+
+impl<'tx, TX> DBTrieLoader<'tx, TX> {
+    /// Create new instance of trie loader.
+    pub fn new(tx: &'tx TX) -> Self {
+        Self { tx, commit_threshold: 500_000, current: 0 }
+    }
+}
+
+// Read-write impls
+impl<'tx, 'db, TX> DBTrieLoader<'tx, TX>
+where
+    TX: DbTxMut<'db> + DbTx<'db> + Send + Sync,
+{
+    /// Calculates the root of the state trie, saving intermediate hashes in the database.
+    pub fn calculate_root(&mut self) -> Result<TrieProgress, TrieError> {
+        let mut checkpoint = self.get_checkpoint()?;
+
+        if checkpoint.hashed_address.is_none() {
+            self.tx.clear::<tables::AccountsTrie>()?;
+            self.tx.clear::<tables::StoragesTrie>()?;
+        }
+        let previous_root = checkpoint.account_root.unwrap_or(EMPTY_ROOT);
+
+        let hasher = Arc::new(HasherKeccak::new());
+        let mut trie = if let Some(root) = checkpoint.account_root {
+            PatriciaTrie::from(
+                Arc::new(HashDatabaseMut::from_root(self.tx, root)?),
+                hasher,
+                root.as_bytes(),
+            )?
+        } else {
+            PatriciaTrie::new(Arc::new(HashDatabaseMut::new(self.tx)?), hasher)
+        };
+
+        let mut accounts_cursor = self.tx.cursor_read::<tables::HashedAccount>()?;
+        let mut walker = accounts_cursor.walk(checkpoint.hashed_address.take())?;
+
+        while let Some((hashed_address, account)) = walker.next().transpose()? {
+            match self.calculate_storage_root(
+                hashed_address,
+                checkpoint.storage_key.take(),
+                checkpoint.storage_root.take(),
+            )? {
+                TrieProgress::Complete(root) => {
+                    let value = EthAccount::from(account).with_storage_root(root);
+
+                    let mut out = Vec::new();
+                    Encodable::encode(&value, &mut out);
+                    trie.insert(hashed_address.as_bytes().to_vec(), out)?;
+
+                    if self.has_hit_threshold() {
+                        return self.save_account_checkpoint(
+                            ProofCheckpoint::default(),
+                            self.replace_account_root(&mut trie, previous_root)?,
+                            hashed_address,
+                        )
+                    }
+                }
+                TrieProgress::InProgress(checkpoint) => {
+                    return self.save_account_checkpoint(
+                        checkpoint,
+                        self.replace_account_root(&mut trie, previous_root)?,
+                        hashed_address,
+                    )
+                }
+            }
+        }
+
+        // Reset inner stage progress
+        self.save_checkpoint(ProofCheckpoint::default())?;
+
+        Ok(TrieProgress::Complete(self.replace_account_root(&mut trie, previous_root)?))
+    }
+
+    fn calculate_storage_root(
+        &mut self,
+        address: H256,
+        next_storage: Option<H256>,
+        previous_root: Option<H256>,
+    ) -> Result<TrieProgress, TrieError> {
+        let mut storage_cursor = self.tx.cursor_dup_read::<tables::HashedStorage>()?;
+
+        let hasher = Arc::new(HasherKeccak::new());
+        let (mut current_entry, mut trie) = if let Some(entry) = next_storage {
+            (
+                storage_cursor.seek_by_key_subkey(address, entry)?.filter(|e| e.key == entry),
+                PatriciaTrie::from(
+                    Arc::new(DupHashDatabaseMut::from_root(
+                        self.tx,
+                        address,
+                        previous_root.expect("is some"),
+                    )?),
+                    hasher,
+                    previous_root.expect("is some").as_bytes(),
+                )?,
+            )
+        } else {
+            (
+                storage_cursor.seek_by_key_subkey(address, H256::zero())?,
+                PatriciaTrie::new(Arc::new(DupHashDatabaseMut::new(self.tx, address)?), hasher),
+            )
+        };
+
+        let previous_root = previous_root.unwrap_or(EMPTY_ROOT);
+
+        while let Some(StorageEntry { key: storage_key, value }) = current_entry {
+            let out = encode_fixed_size(&value).to_vec();
+            trie.insert(storage_key.to_vec(), out)?;
+            // Should be able to use walk_dup, but any call to next() causes an assert fail in
+            // mdbx.c
+            current_entry = storage_cursor.next_dup()?.map(|(_, v)| v);
+            let threshold = self.has_hit_threshold();
+            if let Some(current_entry) = current_entry {
+                if threshold {
+                    return Ok(TrieProgress::InProgress(ProofCheckpoint {
+                        storage_root: Some(self.replace_storage_root(
+                            trie,
+                            address,
+                            previous_root,
+                        )?),
+                        storage_key: Some(current_entry.key),
+                        ..Default::default()
+                    }))
+                }
+            }
+        }
+
+        Ok(TrieProgress::Complete(self.replace_storage_root(trie, address, previous_root)?))
+    }
+
+    /// Calculates the root of the state trie by updating an existing trie.
+    pub fn update_root(
+        &mut self,
+        mut previous_root: H256,
+        tid_range: Range<TransitionId>,
+    ) -> Result<TrieProgress, TrieError> {
+        let mut checkpoint = self.get_checkpoint()?;
+
+        if let Some(account_root) = checkpoint.account_root.take() {
+            previous_root = account_root;
+        }
+
+        let next_acc = checkpoint.hashed_address.take();
+        let changed_accounts = self
+            .gather_changes(tid_range)?
+            .into_iter()
+            .skip_while(|(addr, _)| next_acc.is_some() && next_acc.expect("is some") != *addr);
+
+        let mut trie = PatriciaTrie::from(
+            Arc::new(HashDatabaseMut::from_root(self.tx, previous_root)?),
+            Arc::new(HasherKeccak::new()),
+            previous_root.as_bytes(),
+        )?;
+
+        let mut accounts_cursor = self.tx.cursor_read::<tables::HashedAccount>()?;
+
+        for (hashed_address, changed_storages) in changed_accounts {
+            let res = if let Some(account) = trie.get(hashed_address.as_slice())? {
+                trie.remove(hashed_address.as_bytes())?;
+
+                let storage_root = EthAccount::decode(&mut account.as_slice())?.storage_root;
+                self.update_storage_root(
+                    checkpoint.storage_root.take().unwrap_or(storage_root),
+                    hashed_address,
+                    changed_storages,
+                    checkpoint.storage_key.take(),
+                )?
+            } else {
+                self.calculate_storage_root(
+                    hashed_address,
+                    checkpoint.storage_key.take(),
+                    checkpoint.storage_root.take(),
+                )?
+            };
+
+            let storage_root = match res {
+                TrieProgress::Complete(root) => root,
+                TrieProgress::InProgress(checkpoint) => {
+                    return self.save_account_checkpoint(
+                        checkpoint,
+                        self.replace_account_root(&mut trie, previous_root)?,
+                        hashed_address,
+                    )
+                }
+            };
+
+            if let Some((_, account)) = accounts_cursor.seek_exact(hashed_address)? {
+                let value = EthAccount::from(account).with_storage_root(storage_root);
+
+                let mut out = Vec::new();
+                Encodable::encode(&value, &mut out);
+
+                trie.insert(hashed_address.as_bytes().to_vec(), out)?;
+
+                if self.has_hit_threshold() {
+                    return self.save_account_checkpoint(
+                        ProofCheckpoint::default(),
+                        self.replace_account_root(&mut trie, previous_root)?,
+                        hashed_address,
+                    )
+                }
+            }
+        }
+
+        // Reset inner stage progress
+        self.save_checkpoint(ProofCheckpoint::default())?;
+
+        Ok(TrieProgress::Complete(self.replace_account_root(&mut trie, previous_root)?))
+    }
+
+    /// Update the account's storage root
+    fn update_storage_root(
+        &mut self,
+        previous_root: H256,
+        address: H256,
+        changed_storages: BTreeSet<H256>,
+        next_storage: Option<H256>,
+    ) -> Result<TrieProgress, TrieError> {
+        let mut hashed_storage_cursor = self.tx.cursor_dup_read::<tables::HashedStorage>()?;
+        let mut trie = PatriciaTrie::new(
+            Arc::new(DupHashDatabaseMut::from_root(self.tx, address, previous_root)?),
+            Arc::new(HasherKeccak::new()),
+        );
+
+        let changed_storages = changed_storages
+            .into_iter()
+            .skip_while(|k| next_storage.is_some() && *k == next_storage.expect("is some"));
+
+        for key in changed_storages {
+            if let Some(StorageEntry { value, .. }) =
+                hashed_storage_cursor.seek_by_key_subkey(address, key)?.filter(|e| e.key == key)
+            {
+                let out = encode_fixed_size(&value).to_vec();
+                trie.insert(key.as_bytes().to_vec(), out)?;
+                if self.has_hit_threshold() {
+                    return Ok(TrieProgress::InProgress(ProofCheckpoint {
+                        storage_root: Some(self.replace_storage_root(
+                            trie,
+                            address,
+                            previous_root,
+                        )?),
+                        storage_key: Some(key),
+                        ..Default::default()
+                    }))
+                }
+            } else {
+                trie.remove(key.as_bytes())?;
+            }
+        }
+
+        Ok(TrieProgress::Complete(self.replace_storage_root(trie, address, previous_root)?))
+    }
+
+    fn gather_changes(
+        &self,
+        tid_range: Range<TransitionId>,
+    ) -> Result<BTreeMap<H256, BTreeSet<H256>>, TrieError> {
+        let mut account_cursor = self.tx.cursor_read::<tables::AccountChangeSet>()?;
+
+        let mut account_changes: BTreeMap<Address, BTreeSet<H256>> = BTreeMap::new();
+
+        let mut walker = account_cursor.walk_range(tid_range.clone())?;
+
+        while let Some((_, AccountBeforeTx { address, .. })) = walker.next().transpose()? {
+            account_changes.insert(address, Default::default());
+        }
+
+        let mut storage_cursor = self.tx.cursor_dup_read::<tables::StorageChangeSet>()?;
+
+        let start = TransitionIdAddress((tid_range.start, Address::zero()));
+        let end = TransitionIdAddress((tid_range.end, Address::zero()));
+        let mut walker = storage_cursor.walk_range(start..end)?;
+
+        while let Some((TransitionIdAddress((_, address)), StorageEntry { key, .. })) =
+            walker.next().transpose()?
+        {
+            account_changes.entry(address).or_default().insert(key);
+        }
+
+        let hashed_changes = account_changes
+            .into_iter()
+            .map(|(address, storage)| {
+                (keccak256(address), storage.into_iter().map(keccak256).collect())
+            })
+            .collect();
+
+        Ok(hashed_changes)
+    }
+
+    fn save_account_checkpoint(
+        &mut self,
+        mut checkpoint: ProofCheckpoint,
+        root: H256,
+        hashed_address: H256,
+    ) -> Result<TrieProgress, TrieError> {
+        checkpoint.account_root = Some(root);
+        checkpoint.hashed_address = Some(hashed_address);
+
+        debug!(target: "sync::stages::merkle::exec", account = ?hashed_address, storage = ?checkpoint.storage_key, "Saving inner trie checkpoint");
+
+        self.save_checkpoint(checkpoint)?;
+
+        Ok(TrieProgress::InProgress(checkpoint))
+    }
+
+    fn has_hit_threshold(&mut self) -> bool {
+        self.current += 1;
+        self.current >= self.commit_threshold
+    }
+
+    /// Saves the trie progress
+    pub fn save_checkpoint(&mut self, checkpoint: ProofCheckpoint) -> Result<(), TrieError> {
+        let mut buf = vec![];
+        checkpoint.to_compact(&mut buf);
+
+        // It allows unwind (which commits), to reuse this instance.
+        self.current = 0;
+
+        Ok(self.tx.put::<tables::SyncStageProgress>("TrieLoader".into(), buf)?)
+    }
+
+    /// Gets the trie progress
+    pub fn get_checkpoint(&self) -> Result<ProofCheckpoint, TrieError> {
+        let buf =
+            self.tx.get::<tables::SyncStageProgress>("TrieLoader".into())?.unwrap_or_default();
+
+        if buf.is_empty() {
+            return Ok(ProofCheckpoint::default())
+        }
+
+        let (checkpoint, _) = ProofCheckpoint::from_compact(&buf, buf.len());
+
+        if checkpoint.account_root.is_some() {
+            debug!(target: "sync::stages::merkle::exec", checkpoint = ?checkpoint, "Continuing inner trie checkpoint");
+        }
+
+        Ok(checkpoint)
+    }
+
+    /// Finds the most recent account trie root and removes the previous one if applicable.
+    fn replace_account_root(
+        &self,
+        trie: &mut PatriciaTrie<HashDatabaseMut<'_, TX>, HasherKeccak>,
+        previous_root: H256,
+    ) -> Result<H256, TrieError> {
+        let new_root = H256::from_slice(trie.root()?.as_slice());
+
+        if new_root != previous_root {
+            let mut cursor = self.tx.cursor_write::<tables::AccountsTrie>()?;
+            if cursor.seek_exact(previous_root)?.is_some() {
+                cursor.delete_current()?;
+            }
+        }
+
+        Ok(new_root)
+    }
+
+    /// Finds the most recent storage trie root and removes the previous one if applicable.
+    fn replace_storage_root(
+        &self,
+        mut trie: PatriciaTrie<DupHashDatabaseMut<'_, TX>, HasherKeccak>,
+        address: H256,
+        previous_root: H256,
+    ) -> Result<H256, TrieError> {
+        let new_root = H256::from_slice(trie.root()?.as_slice());
+
+        if new_root != previous_root {
+            let mut trie_cursor = self.tx.cursor_dup_write::<tables::StoragesTrie>()?;
+
+            if trie_cursor
+                .seek_by_key_subkey(address, previous_root)?
+                .filter(|entry| entry.hash == previous_root)
+                .is_some()
+            {
+                trie_cursor.delete_current()?;
+            }
+        }
+
+        if new_root == EMPTY_ROOT {
+            self.tx.delete::<tables::StoragesTrie>(address, None)?;
+        }
+
+        Ok(new_root)
+    }
+}
+
+// Read-only impls
+impl<'tx, 'db, TX> DBTrieLoader<'tx, TX>
+where
+    TX: DbTx<'db> + Send + Sync,
+{
+    /// Returns a Merkle proof of the given account, plus its storage root hash.
+    pub fn generate_acount_proof(
+        &self,
+        root: H256,
+        address: H256,
+    ) -> Result<(MerkleProof, H256), TrieError> {
+        let db = Arc::new(HashDatabase::from_root(self.tx, root)?);
+        let hasher = Arc::new(HasherKeccak::new());
+
+        let trie = PatriciaTrie::from(Arc::clone(&db), Arc::clone(&hasher), root.as_bytes())?;
+        let proof = trie.get_proof(address.as_bytes())?;
+
+        let Some(account) = trie.get(address.as_slice())? else { return Ok((proof, KECCAK_EMPTY)) };
+
+        let storage_root = EthAccount::decode(&mut account.as_slice())?.storage_root;
+
+        Ok((proof, storage_root))
+    }
+
+    /// Returns a Merkle proof of the given storage keys, starting at the given root hash.
+    pub fn generate_storage_proofs(
+        &self,
+        storage_root: H256,
+        address: H256,
+        keys: &[H256],
+    ) -> Result<Vec<MerkleProof>, TrieError> {
+        let db = Arc::new(DupHashDatabase::from_root(self.tx, address, storage_root)?);
+        let hasher = Arc::new(HasherKeccak::new());
+
+        let trie =
+            PatriciaTrie::from(Arc::clone(&db), Arc::clone(&hasher), storage_root.as_bytes())?;
+
+        let proof =
+            keys.iter().map(|key| trie.get_proof(key.as_bytes())).collect::<Result<Vec<_>, _>>()?;
+
+        Ok(proof)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::Transaction;
+    use std::ops::DerefMut;
+
+    use super::*;
+    use assert_matches::assert_matches;
+    use proptest::{prelude::ProptestConfig, proptest};
+    use reth_db::{
+        database::{Database, DatabaseGAT},
+        mdbx::{test_utils::create_test_rw_db, Env, WriteMap},
+        tables,
+        transaction::DbTxMut,
+    };
+    use reth_primitives::{
+        hex_literal::hex,
+        keccak256,
+        proofs::{genesis_state_root, KeccakHasher, EMPTY_ROOT},
+        Address, Bytes, ChainSpec, Genesis, MAINNET,
+    };
+    use std::{collections::HashMap, ops::Deref, str::FromStr};
+    use triehash::sec_trie_root;
+
+    fn load_mainnet_genesis_root<DB: Database>(tx: &mut Transaction<'_, DB>) -> Genesis {
+        let ChainSpec { genesis, .. } = MAINNET.clone();
+
+        // Insert account state
+        for (address, account) in &genesis.alloc {
+            tx.put::<tables::PlainAccountState>(
+                *address,
+                Account {
+                    nonce: account.nonce.unwrap_or_default(),
+                    balance: account.balance,
+                    bytecode_hash: None,
+                },
+            )
+            .unwrap();
+            tx.put::<tables::HashedAccount>(
+                keccak256(address),
+                Account {
+                    nonce: account.nonce.unwrap_or_default(),
+                    balance: account.balance,
+                    bytecode_hash: None,
+                },
+            )
+            .unwrap();
+        }
+        tx.commit().unwrap();
+
+        genesis
+    }
+
+    fn create_test_loader<'tx, 'db>(
+        tx: &'tx Transaction<'db, Env<WriteMap>>,
+    ) -> DBTrieLoader<'tx, <Arc<Env<WriteMap>> as DatabaseGAT<'db>>::TXMut> {
+        DBTrieLoader::new(tx.deref())
+    }
+
+    #[test]
+    fn empty_trie() {
+        let db = create_test_rw_db();
+        let tx = Transaction::new(db.as_ref()).unwrap();
+        assert_matches!(
+            create_test_loader(&tx).calculate_root(),
+            Ok(got) if got.root().unwrap() == EMPTY_ROOT
+        );
+    }
+
+    #[test]
+    fn single_account_trie() {
+        let db = create_test_rw_db();
+        let tx = Transaction::new(db.as_ref()).unwrap();
+        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
+        let account = Account { nonce: 0, balance: U256::ZERO, bytecode_hash: None };
+        tx.put::<tables::HashedAccount>(keccak256(address), account).unwrap();
+        let mut encoded_account = Vec::new();
+        EthAccount::from(account).encode(&mut encoded_account);
+        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>([(address, encoded_account)]).0);
+        assert_matches!(
+            create_test_loader(&tx).calculate_root(),
+            Ok(got) if got.root().unwrap() == expected
+        );
+    }
+
+    #[test]
+    fn two_accounts_trie() {
+        let db = create_test_rw_db();
+        let mut tx = Transaction::new(db.as_ref()).unwrap();
+        let mut trie = DBTrieLoader::new(tx.deref_mut());
+
+        let accounts = [
+            (
+                Address::from(hex!("9fe4abd71ad081f091bd06dd1c16f7e92927561e")),
+                Account { nonce: 155, balance: U256::from(414241124), bytecode_hash: None },
+            ),
+            (
+                Address::from(hex!("f8a6edaad4a332e6e550d0915a7fd5300b0b12d1")),
+                Account { nonce: 3, balance: U256::from(78978), bytecode_hash: None },
+            ),
+        ];
+        for (address, account) in accounts {
+            trie.tx.put::<tables::HashedAccount>(keccak256(address), account).unwrap();
+        }
+        let encoded_accounts = accounts.iter().map(|(k, v)| {
+            let mut out = Vec::new();
+            EthAccount::from(*v).encode(&mut out);
+            (k, out)
+        });
+        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_accounts).0);
+        assert_matches!(
+            trie.calculate_root(),
+            Ok(got) if got.root().unwrap() == expected
+        );
+    }
+
+    #[test]
+    fn single_storage_trie() {
+        let db = create_test_rw_db();
+        let mut tx = Transaction::new(db.as_ref()).unwrap();
+        let mut trie = DBTrieLoader::new(tx.deref_mut());
+
+        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
+        let hashed_address = keccak256(address);
+
+        let storage = Vec::from([(H256::from_low_u64_be(2), U256::from(1))]);
+        for (k, v) in storage.clone() {
+            trie.tx
+                .put::<tables::HashedStorage>(
+                    hashed_address,
+                    StorageEntry { key: keccak256(k), value: v },
+                )
+                .unwrap();
+        }
+        let encoded_storage = storage.iter().map(|(k, v)| {
+            let out = encode_fixed_size(v).to_vec();
+            (k, out)
+        });
+        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_storage).0);
+        assert_matches!(
+            trie.calculate_storage_root(hashed_address, None, None),
+            Ok(got) if got.root().unwrap() == expected
+        );
+    }
+
+    #[test]
+    fn single_account_with_storage_trie() {
+        let db = create_test_rw_db();
+        let tx = Transaction::new(db.as_ref()).unwrap();
+
+        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
+        let hashed_address = keccak256(address);
+
+        let storage = HashMap::from([
+            (H256::zero(), U256::from(3)),
+            (H256::from_low_u64_be(2), U256::from(1)),
+        ]);
+        let code = "el buen fla";
+        let account = Account {
+            nonce: 155,
+            balance: U256::from(414241124u32),
+            bytecode_hash: Some(keccak256(code)),
+        };
+        tx.put::<tables::HashedAccount>(hashed_address, account).unwrap();
+
+        for (k, v) in storage.clone() {
+            tx.put::<tables::HashedStorage>(
+                hashed_address,
+                StorageEntry { key: keccak256(k), value: v },
+            )
+            .unwrap();
+        }
+        let mut out = Vec::new();
+
+        let encoded_storage = storage.iter().map(|(k, v)| {
+            let out = encode_fixed_size(v).to_vec();
+            (k, out)
+        });
+
+        let storage_root = H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_storage).0);
+        let eth_account = EthAccount::from(account).with_storage_root(storage_root);
+        eth_account.encode(&mut out);
+
+        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>([(address, out)]).0);
+        assert_matches!(
+            create_test_loader(&tx).calculate_root(),
+            Ok(got) if got.root().unwrap() == expected
+        );
+    }
+
+    #[test]
+    fn verify_genesis() {
+        let db = create_test_rw_db();
+        let mut tx = Transaction::new(db.as_ref()).unwrap();
+
+        let genesis = load_mainnet_genesis_root(&mut tx);
+
+        let state_root = genesis_state_root(&genesis.alloc);
+
+        assert_matches!(
+            create_test_loader(&tx).calculate_root(),
+            Ok(got) if got.root().unwrap() == state_root
+        );
+    }
+
+    #[test]
+    fn gather_changes() {
+        let db = create_test_rw_db();
+        let tx = Transaction::new(db.as_ref()).unwrap();
+
+        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
+        let hashed_address = keccak256(address);
+
+        let storage = HashMap::from([
+            (H256::zero(), U256::from(3)),
+            (H256::from_low_u64_be(2), U256::from(1)),
+        ]);
+        let code = "el buen fla";
+        let account = Account {
+            nonce: 155,
+            balance: U256::from(414241124u32),
+            bytecode_hash: Some(keccak256(code)),
+        };
+        tx.put::<tables::HashedAccount>(hashed_address, account).unwrap();
+        tx.put::<tables::AccountChangeSet>(31, AccountBeforeTx { address, info: None }).unwrap();
+
+        for (k, v) in storage {
+            tx.put::<tables::HashedStorage>(
+                hashed_address,
+                StorageEntry { key: keccak256(k), value: v },
+            )
+            .unwrap();
+            tx.put::<tables::StorageChangeSet>(
+                (32, address).into(),
+                StorageEntry { key: k, value: U256::ZERO },
+            )
+            .unwrap();
+        }
+
+        let expected = BTreeMap::from([(
+            hashed_address,
+            BTreeSet::from([keccak256(H256::zero()), keccak256(H256::from_low_u64_be(2))]),
+        )]);
+        assert_matches!(
+            create_test_loader(&tx).gather_changes(32..33),
+            Ok(got) if got == expected
+        );
+    }
+
+    fn test_with_accounts(accounts: BTreeMap<Address, (Account, BTreeSet<StorageEntry>)>) {
+        let db = create_test_rw_db();
+        let tx = Transaction::new(db.as_ref()).unwrap();
+
+        let encoded_accounts = accounts
+            .into_iter()
+            .map(|(address, (account, storage))| {
+                let hashed_address = keccak256(address);
+                tx.put::<tables::HashedAccount>(hashed_address, account).unwrap();
+                // This is to mimic real data. Only contract accounts have storage.
+                let storage_root = if account.has_bytecode() {
+                    let encoded_storage = storage.into_iter().map(|StorageEntry { key, value }| {
+                        let hashed_key = keccak256(key);
+                        let out = encode_fixed_size(&value).to_vec();
+                        tx.put::<tables::HashedStorage>(
+                            hashed_address,
+                            StorageEntry { key: hashed_key, value },
+                        )
+                        .unwrap();
+                        (key, out)
+                    });
+                    H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_storage).0)
+                } else {
+                    EMPTY_ROOT
+                };
+                let mut out = Vec::new();
+                EthAccount::from(account).with_storage_root(storage_root).encode(&mut out);
+                (address, out)
+            })
+            .collect::<Vec<(Address, Vec<u8>)>>();
+
+        let expected = H256(sec_trie_root::<KeccakHasher, _, _, _>(encoded_accounts).0);
+        assert_matches!(
+            create_test_loader(&tx).calculate_root(),
+            Ok(got) if got.root().unwrap() == expected
+        , "where expected is {expected:?}");
+    }
+
+    #[test]
+    fn arbitrary() {
+        proptest!(ProptestConfig::with_cases(10), |(accounts: BTreeMap<Address, (Account, BTreeSet<StorageEntry>)>)| {
+            test_with_accounts(accounts);
+        });
+    }
+
+    #[test]
+    fn get_proof() {
+        let db = create_test_rw_db();
+        let mut tx = Transaction::new(db.as_ref()).unwrap();
+
+        load_mainnet_genesis_root(&mut tx);
+
+        let root = {
+            let mut trie = create_test_loader(&tx);
+            trie.calculate_root().expect("should be able to load trie").root().unwrap()
+        };
+
+        tx.commit().unwrap();
+
+        let address = Address::from(hex!("000d836201318ec6899a67540690382780743280"));
+
+        let trie = create_test_loader(&tx);
+        let (proof, storage_root) =
+            trie.generate_acount_proof(root, keccak256(address)).expect("failed to generate proof");
+
+        // values extracted from geth via rpc:
+        // {
+        //  "method": "eth_getProof",
+        //  "params": ["0x000d836201318ec6899a67540690382780743280", [], "0x0"]
+        // }
+        let expected = [
+            hex!("f90211a090dcaf88c40c7bbc95a912cbdde67c175767b31173df9ee4b0d733bfdd511c43a0babe369f6b12092f49181ae04ca173fb68d1a5456f18d20fa32cba73954052bda0473ecf8a7e36a829e75039a3b055e51b8332cbf03324ab4af2066bbd6fbf0021a0bbda34753d7aa6c38e603f360244e8f59611921d9e1f128372fec0d586d4f9e0a04e44caecff45c9891f74f6a2156735886eedf6f1a733628ebc802ec79d844648a0a5f3f2f7542148c973977c8a1e154c4300fec92f755f7846f1b734d3ab1d90e7a0e823850f50bf72baae9d1733a36a444ab65d0a6faaba404f0583ce0ca4dad92da0f7a00cbe7d4b30b11faea3ae61b7f1f2b315b61d9f6bd68bfe587ad0eeceb721a07117ef9fc932f1a88e908eaead8565c19b5645dc9e5b1b6e841c5edbdfd71681a069eb2de283f32c11f859d7bcf93da23990d3e662935ed4d6b39ce3673ec84472a0203d26456312bbc4da5cd293b75b840fc5045e493d6f904d180823ec22bfed8ea09287b5c21f2254af4e64fca76acc5cd87399c7f1ede818db4326c98ce2dc2208a06fc2d754e304c48ce6a517753c62b1a9c1d5925b89707486d7fc08919e0a94eca07b1c54f15e299bd58bdfef9741538c7828b5d7d11a489f9c20d052b3471df475a051f9dd3739a927c89e357580a4c97b40234aa01ed3d5e0390dc982a7975880a0a089d613f26159af43616fd9455bb461f4869bfede26f2130835ed067a8b967bfb80").as_slice(),
+            hex!("f90211a0dae48f5b47930c28bb116fbd55e52cd47242c71bf55373b55eb2805ee2e4a929a00f1f37f337ec800e2e5974e2e7355f10f1a4832b39b846d916c3597a460e0676a0da8f627bb8fbeead17b318e0a8e4f528db310f591bb6ab2deda4a9f7ca902ab5a0971c662648d58295d0d0aa4b8055588da0037619951217c22052802549d94a2fa0ccc701efe4b3413fd6a61a6c9f40e955af774649a8d9fd212d046a5a39ddbb67a0d607cdb32e2bd635ee7f2f9e07bc94ddbd09b10ec0901b66628e15667aec570ba05b89203dc940e6fa70ec19ad4e01d01849d3a5baa0a8f9c0525256ed490b159fa0b84227d48df68aecc772939a59afa9e1a4ab578f7b698bdb1289e29b6044668ea0fd1c992070b94ace57e48cbf6511a16aa770c645f9f5efba87bbe59d0a042913a0e16a7ccea6748ae90de92f8aef3b3dc248a557b9ac4e296934313f24f7fced5fa042373cf4a00630d94de90d0a23b8f38ced6b0f7cb818b8925fee8f0c2a28a25aa05f89d2161c1741ff428864f7889866484cef622de5023a46e795dfdec336319fa07597a017664526c8c795ce1da27b8b72455c49657113e0455552dbc068c5ba31a0d5be9089012fda2c585a1b961e988ea5efcd3a06988e150a8682091f694b37c5a0f7b0352e38c315b2d9a14d51baea4ddee1770974c806e209355233c3c89dce6ea049bf6e8df0acafd0eff86defeeb305568e44d52d2235cf340ae15c6034e2b24180").as_slice(),
+            hex!("f901f1a0cf67e0f5d5f8d70e53a6278056a14ddca46846f5ef69c7bde6810d058d4a9eda80a06732ada65afd192197fe7ce57792a7f25d26978e64e954b7b84a1f7857ac279da05439f8d011683a6fc07efb90afca198fd7270c795c835c7c85d91402cda992eaa0449b93033b6152d289045fdb0bf3f44926f831566faa0e616b7be1abaad2cb2da031be6c3752bcd7afb99b1bb102baf200f8567c394d464315323a363697646616a0a40e3ed11d906749aa501279392ffde868bd35102db41364d9c601fd651f974aa0044bfa4fe8dd1a58e6c7144da79326e94d1331c0b00373f6ae7f3662f45534b7a098005e3e48db68cb1dc9b9f034ff74d2392028ddf718b0f2084133017da2c2e7a02a62bc40414ee95b02e202a9e89babbabd24bef0abc3fc6dcd3e9144ceb0b725a0239facd895bbf092830390a8676f34b35b29792ae561f196f86614e0448a5792a0a4080f88925daff6b4ce26d188428841bd65655d8e93509f2106020e76d41eefa04918987904be42a6894256ca60203283d1b89139cf21f09f5719c44b8cdbb8f7a06201fc3ef0827e594d953b5e3165520af4fceb719e11cc95fd8d3481519bfd8ca05d0e353d596bd725b09de49c01ede0f29023f0153d7b6d401556aeb525b2959ba0cd367d0679950e9c5f2aa4298fd4b081ade2ea429d71ff390c50f8520e16e30880").as_slice(),
+            hex!("f87180808080808080a0dbee8b33c73b86df839f309f7ac92eee19836e08b39302ffa33921b3c6a09f66a06068b283d51aeeee682b8fb5458354315d0b91737441ede5e137c18b4775174a8080808080a0fe7779c7d58c2fda43eba0a6644043c86ebb9ceb4836f89e30831f23eb059ece8080").as_slice(),
+            hex!("f8719f20b71c90b0d523dd5004cf206f325748da347685071b34812e21801f5270c4b84ff84d80890ad78ebc5ac6200000a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a0c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").as_slice(),
+        ];
+
+        assert_eq!(storage_root, EMPTY_ROOT);
+
+        assert_eq!(proof.len(), 5);
+
+        for (node, expected) in proof.into_iter().zip(expected.into_iter()) {
+            assert_eq!(Bytes::from(node.as_slice()), Bytes::from(expected));
+        }
+    }
+
+    #[test]
+    fn get_storage_proofs() {
+        let db = create_test_rw_db();
+        let mut tx = Transaction::new(db.as_ref()).unwrap();
+
+        let address = Address::from_str("9fe4abd71ad081f091bd06dd1c16f7e92927561e").unwrap();
+        let hashed_address = keccak256(address);
+
+        let storage = HashMap::from([
+            (H256::zero(), U256::from(3)),
+            (H256::from_low_u64_be(2), U256::from(1)),
+        ]);
+
+        let code = "el buen fla";
+        let account = Account {
+            nonce: 155,
+            balance: U256::from(414241124u32),
+            bytecode_hash: Some(keccak256(code)),
+        };
+        tx.put::<tables::HashedAccount>(hashed_address, account).unwrap();
+
+        for (k, v) in storage {
+            tx.put::<tables::HashedStorage>(
+                hashed_address,
+                StorageEntry { key: keccak256(k), value: v },
+            )
+            .unwrap();
+        }
+
+        let root = {
+            let mut trie = create_test_loader(&tx);
+            trie.calculate_root().expect("should be able to load trie").root().unwrap()
+        };
+
+        tx.commit().unwrap();
+
+        let trie = create_test_loader(&tx);
+        let (account_proof, storage_root) =
+            trie.generate_acount_proof(root, hashed_address).expect("failed to generate proof");
+
+        // values extracted from geth via rpc:
+        let expected_account = hex!("f86fa1205126413e7857595763591580306b3f228f999498c4c5dfa74f633364936e7651b84bf849819b8418b0d164a029ff6f4d518044318d75b118cf439d8d3d7249c8afcba06ba9ecdf8959410571a02ce1a85814ad94a94ed2a1abaf7c57e9b64326622c1b8c21b4ba4d0e7df61392").as_slice();
+        let expected_storage = [
+            [
+                // 0x0000000000000000000000000000000000000000000000000000000000000002
+                hex!("f8518080a04355bd3061ad2d17e0782413925b4fd81a56bd162d91eedb2a00d6c87611471480a015503e91f9250654cf72906e38a7cb14c3f1cc06658379d37f0c5b5c32482880808080808080808080808080").as_slice(),
+                hex!("e2a0305787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace01").as_slice(),
+            ],
+            [
+                // 0x0000000000000000000000000000000000000000000000000000000000000000
+                hex!("f8518080a04355bd3061ad2d17e0782413925b4fd81a56bd162d91eedb2a00d6c87611471480a015503e91f9250654cf72906e38a7cb14c3f1cc06658379d37f0c5b5c32482880808080808080808080808080").as_slice(),
+                hex!("e2a0390decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e56303").as_slice(),
+            ]
+        ];
+
+        assert!(storage_root != EMPTY_ROOT);
+
+        assert_eq!(account_proof.len(), 1);
+        assert_eq!(account_proof[0], expected_account);
+
+        let storage_proofs = trie
+            .generate_storage_proofs(
+                storage_root,
+                hashed_address,
+                &[keccak256(H256::from_low_u64_be(2)), keccak256(H256::zero())],
+            )
+            .expect("couldn't generate storage proof");
+
+        for (proof, expected) in storage_proofs.into_iter().zip(expected_storage) {
+            assert_eq!(proof.len(), expected.len());
+            for (got_node, expected_node) in proof.into_iter().zip(expected) {
+                assert_eq!(got_node, expected_node);
+            }
+        }
+    }
+}
diff --git a/crates/storage/provider/src/utils.rs b/crates/storage/provider/src/utils.rs
index 086cc7fc8c6..1262328a81f 100644
--- a/crates/storage/provider/src/utils.rs
+++ b/crates/storage/provider/src/utils.rs
@@ -4,34 +4,41 @@ use reth_db::{
     transaction::{DbTx, DbTxMut},
 };
 use reth_interfaces::{provider::ProviderError, Result};
-use reth_primitives::{SealedBlock, U256};
+use reth_primitives::{Address, SealedBlock, TransitionId};
 
 /// Insert block data into corresponding tables. Used mainly for testing & internal tooling.
 ///
 ///
 /// Check parent dependency in [tables::HeaderNumbers] and in [tables::BlockBodies] tables.
-/// Inserts blocks data to [tables::CanonicalHeaders], [tables::Headers], [tables::HeaderNumbers],
-/// and transactions data to [tables::TxSenders], [tables::Transactions],
-/// [tables::BlockBodies] and [tables::BlockBodies]
+/// Inserts header data to [tables::CanonicalHeaders], [tables::Headers], [tables::HeaderNumbers].
+/// and transactions data to [tables::TxSenders], [tables::Transactions], [tables::TxHashNumber].
+/// and transition indexes to [tables::BlockTransitionIndex] and [tables::TxTransitionIndex].
+/// And block data [tables::BlockBodies], [tables::BlockBodies] and [tables::BlockWithdrawals].
+///
+/// Return [TransitionId] `(from,to)`
 pub fn insert_block<'a, TX: DbTxMut<'a> + DbTx<'a>>(
     tx: &TX,
-    block: &SealedBlock,
+    block: SealedBlock,
+    senders: Option<Vec<Address>>,
     has_block_reward: bool,
     parent_tx_num_transition_id: Option<(u64, u64)>,
-) -> Result<()> {
+) -> Result<(TransitionId, TransitionId)> {
+    let block_number = block.number;
     tx.put::<tables::CanonicalHeaders>(block.number, block.hash())?;
     // Put header with canonical hashes.
     tx.put::<tables::Headers>(block.number, block.header.as_ref().clone())?;
     tx.put::<tables::HeaderNumbers>(block.hash(), block.number)?;
-    tx.put::<tables::HeaderTD>(
-        block.number,
-        if has_block_reward {
-            U256::ZERO
-        } else {
-            U256::from(58_750_000_000_000_000_000_000_u128) + block.difficulty
-        }
-        .into(),
-    )?;
+
+    // total difficulty
+    let ttd = if block.number == 0 {
+        block.difficulty
+    } else {
+        let parent_block_number = block.number - 1;
+        let parent_ttd = tx.get::<tables::HeaderTD>(parent_block_number)?.unwrap_or_default();
+        parent_ttd.0 + block.difficulty
+    };
+
+    tx.put::<tables::HeaderTD>(block.number, ttd.into())?;
 
     // insert body ommers data
     if !block.ommers.is_empty() {
@@ -56,28 +63,43 @@ pub fn insert_block<'a, TX: DbTxMut<'a> + DbTx<'a>>(
                 .ok_or(ProviderError::BlockTransition { block_number: prev_block_num })?;
             (prev_body.start_tx_id + prev_body.tx_count, last_transition_id)
         };
-
+    let from_transition = transition_id;
     // insert body data
     tx.put::<tables::BlockBodies>(
         block.number,
         StoredBlockBody { start_tx_id: current_tx_id, tx_count: block.body.len() as u64 },
     )?;
 
-    for transaction in block.body.iter() {
-        let rec_tx = transaction.clone().into_ecrecovered().unwrap();
-        tx.put::<tables::TxSenders>(current_tx_id, rec_tx.signer())?;
-        tx.put::<tables::Transactions>(current_tx_id, rec_tx.into())?;
+    let senders_len = senders.as_ref().map(|s| s.len());
+    let tx_iter = if Some(block.body.len()) == senders_len {
+        block.body.into_iter().zip(senders.unwrap().into_iter()).collect::<Vec<(_, _)>>()
+    } else {
+        block
+            .body
+            .into_iter()
+            .map(|tx| {
+                let signer = tx.recover_signer();
+                (tx, signer.unwrap_or_default())
+            })
+            .collect::<Vec<(_, _)>>()
+    };
+
+    for (transaction, sender) in tx_iter {
+        let hash = transaction.hash();
+        tx.put::<tables::TxSenders>(current_tx_id, sender)?;
+        tx.put::<tables::Transactions>(current_tx_id, transaction)?;
         tx.put::<tables::TxTransitionIndex>(current_tx_id, transition_id)?;
+        tx.put::<tables::TxHashNumber>(hash, current_tx_id)?;
         transition_id += 1;
         current_tx_id += 1;
     }
 
     let mut has_withdrawals = false;
-    if let Some(withdrawals) = block.withdrawals.clone() {
+    if let Some(withdrawals) = block.withdrawals {
         if !withdrawals.is_empty() {
             has_withdrawals = true;
             tx.put::<tables::BlockWithdrawals>(
-                block.number,
+                block_number,
                 StoredBlockWithdrawals { withdrawals },
             )?;
         }
@@ -86,17 +108,19 @@ pub fn insert_block<'a, TX: DbTxMut<'a> + DbTx<'a>>(
     if has_block_reward || has_withdrawals {
         transition_id += 1;
     }
-    tx.put::<tables::BlockTransitionIndex>(block.number, transition_id)?;
+    tx.put::<tables::BlockTransitionIndex>(block_number, transition_id)?;
 
-    Ok(())
+    let to_transition = transition_id;
+    Ok((from_transition, to_transition))
 }
 
 /// Inserts canonical block in blockchain. Parent tx num and transition id is taken from
 /// parent block in database.
 pub fn insert_canonical_block<'a, TX: DbTxMut<'a> + DbTx<'a>>(
     tx: &TX,
-    block: &SealedBlock,
+    block: SealedBlock,
+    senders: Option<Vec<Address>>,
     has_block_reward: bool,
-) -> Result<()> {
-    insert_block(tx, block, has_block_reward, None)
+) -> Result<(TransitionId, TransitionId)> {
+    insert_block(tx, block, senders, has_block_reward, None)
 }
diff --git a/crates/tasks/src/lib.rs b/crates/tasks/src/lib.rs
index e9e93ac7092..0802c0ba9ee 100644
--- a/crates/tasks/src/lib.rs
+++ b/crates/tasks/src/lib.rs
@@ -66,10 +66,13 @@ pub mod shutdown;
 /// ```
 ///
 /// The [TaskSpawner] trait is [DynClone] so `Box<dyn TaskSpawner>` are also `Clone`.
-pub trait TaskSpawner: Send + Sync + std::fmt::Debug + DynClone {
+pub trait TaskSpawner: Send + Sync + Unpin + std::fmt::Debug + DynClone {
     /// Spawns the task onto the runtime.
     /// See also [`Handle::spawn`].
     fn spawn(&self, fut: BoxFuture<'static, ()>) -> JoinHandle<()>;
+
+    /// This spawns a critical task onto the runtime.
+    fn spawn_critical(&self, name: &'static str, fut: BoxFuture<'static, ()>) -> JoinHandle<()>;
 }
 
 dyn_clone::clone_trait_object!(TaskSpawner);
@@ -83,6 +86,10 @@ impl TaskSpawner for TokioTaskExecutor {
     fn spawn(&self, fut: BoxFuture<'static, ()>) -> JoinHandle<()> {
         tokio::task::spawn(fut)
     }
+
+    fn spawn_critical(&self, _name: &'static str, fut: BoxFuture<'static, ()>) -> JoinHandle<()> {
+        tokio::task::spawn(fut)
+    }
 }
 
 /// Many reth components require to spawn tasks for long-running jobs. For example `discovery`
@@ -331,6 +338,10 @@ impl TaskSpawner for TaskExecutor {
     fn spawn(&self, fut: BoxFuture<'static, ()>) -> JoinHandle<()> {
         self.spawn(fut)
     }
+
+    fn spawn_critical(&self, name: &'static str, fut: BoxFuture<'static, ()>) -> JoinHandle<()> {
+        TaskExecutor::spawn_critical(self, name, fut)
+    }
 }
 
 /// Determines how a task is spawned
diff --git a/crates/transaction-pool/Cargo.toml b/crates/transaction-pool/Cargo.toml
index 846686b3c2d..b3326d3d7a8 100644
--- a/crates/transaction-pool/Cargo.toml
+++ b/crates/transaction-pool/Cargo.toml
@@ -19,6 +19,7 @@ normal = [
 
 # reth
 reth-primitives = { path  = "../primitives" }
+reth-provider = { path = "../storage/provider" }
 reth-rlp = { path = "../rlp" }
 
 # async/futures
@@ -32,7 +33,7 @@ metrics = "0.20.1"
 reth-metrics-derive = { path = "../metrics/metrics-derive" }
 
 # misc
-aquamarine = "0.2.1" # docs
+aquamarine = "0.3.0"
 thiserror = "1.0"
 tracing = "0.1"
 serde = { version = "1.0", features = ["derive", "rc"], optional = true }
diff --git a/crates/transaction-pool/src/error.rs b/crates/transaction-pool/src/error.rs
index ee8133787aa..1a9a1e6b04b 100644
--- a/crates/transaction-pool/src/error.rs
+++ b/crates/transaction-pool/src/error.rs
@@ -1,6 +1,6 @@
 //! Transaction pool errors
 
-use reth_primitives::{Address, TxHash};
+use reth_primitives::{Address, InvalidTransactionError, TxHash};
 
 /// Transaction pool result type.
 pub type PoolResult<T> = Result<T, PoolError>;
@@ -21,14 +21,13 @@ pub enum PoolError {
     /// respect the size limits of the pool.
     #[error("[{0:?}] Transaction discarded outright due to pool size constraints.")]
     DiscardedOnInsert(TxHash),
-    /// Thrown when a new transaction is added to the pool, but then immediately discarded to
-    /// respect the size limits of the pool.
-    #[error("[{0:?}] Transaction's gas limit {1} exceeds block's gas limit {2}.")]
-    TxExceedsGasLimit(TxHash, u64, u64),
-    /// Thrown when a new transaction is added to the pool, but then immediately discarded to
-    /// respect the max_init_code_size.
-    #[error("[{0:?}] Transaction's size {1} exceeds max_init_code_size {2}.")]
-    TxExceedsMaxInitCodeSize(TxHash, usize, usize),
+    /// Thrown when the transaction is considered invalid.
+    #[error("[{0:?}] {1:?}")]
+    InvalidTransaction(TxHash, InvalidPoolTransactionError),
+    /// Any other error that occurred while inserting/validating a transaction. e.g. IO database
+    /// error
+    #[error("[{0:?}] {1:?}")]
+    Other(TxHash, Box<dyn std::error::Error + Send + Sync>),
 }
 
 // === impl PoolError ===
@@ -41,8 +40,34 @@ impl PoolError {
             PoolError::ProtocolFeeCapTooLow(hash, _) => hash,
             PoolError::SpammerExceededCapacity(_, hash) => hash,
             PoolError::DiscardedOnInsert(hash) => hash,
-            PoolError::TxExceedsGasLimit(hash, _, _) => hash,
-            PoolError::TxExceedsMaxInitCodeSize(hash, _, _) => hash,
+            PoolError::InvalidTransaction(hash, _) => hash,
+            PoolError::Other(hash, _) => hash,
         }
     }
 }
+
+/// Represents errors that can happen when validating transactions for the pool
+///
+/// See [TransactionValidator](crate::TransactionValidator).
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum InvalidPoolTransactionError {
+    /// Hard consensus errors
+    #[error(transparent)]
+    Consensus(#[from] InvalidTransactionError),
+    /// Thrown when a new transaction is added to the pool, but then immediately discarded to
+    /// respect the size limits of the pool.
+    #[error("Transaction's gas limit {0} exceeds block's gas limit {1}.")]
+    ExceedsGasLimit(u64, u64),
+    /// Thrown when a new transaction is added to the pool, but then immediately discarded to
+    /// respect the max_init_code_size.
+    #[error("Transaction's size {0} exceeds max_init_code_size {1}.")]
+    ExceedsMaxInitCodeSize(usize, usize),
+    /// Thrown if the transaction contains an invalid signature
+    #[error("Invalid sender")]
+    AccountNotFound,
+    /// Thrown if the input data of a transaction is greater
+    /// than some meaningful limit a user might use. This is not a consensus error
+    /// making the transaction invalid, rather a DOS protection.
+    #[error("Input data too large")]
+    OversizedData(usize, usize),
+}
diff --git a/crates/transaction-pool/src/identifier.rs b/crates/transaction-pool/src/identifier.rs
index 0c2df6d211c..7b20effee17 100644
--- a/crates/transaction-pool/src/identifier.rs
+++ b/crates/transaction-pool/src/identifier.rs
@@ -102,20 +102,12 @@ impl TransactionId {
             return None
         }
         let prev_nonce = transaction_nonce.saturating_sub(1);
-        if on_chain_nonce <= prev_nonce {
-            Some(Self::new(sender, prev_nonce))
-        } else {
-            None
-        }
+        (on_chain_nonce <= prev_nonce).then(|| Self::new(sender, prev_nonce))
     }
 
     /// Returns the `TransactionId` that would come before this transaction.
     pub(crate) fn unchecked_ancestor(&self) -> Option<TransactionId> {
-        if self.nonce == 0 {
-            None
-        } else {
-            Some(TransactionId::new(self.sender, self.nonce - 1))
-        }
+        (self.nonce != 0).then(|| TransactionId::new(self.sender, self.nonce - 1))
     }
 
     /// Returns the `TransactionId` that directly follows this transaction: `self.nonce + 1`
diff --git a/crates/transaction-pool/src/lib.rs b/crates/transaction-pool/src/lib.rs
index 5b356d58309..cd006c14c62 100644
--- a/crates/transaction-pool/src/lib.rs
+++ b/crates/transaction-pool/src/lib.rs
@@ -81,19 +81,23 @@
 
 pub use crate::{
     config::PoolConfig,
-    ordering::TransactionOrdering,
+    ordering::{CostOrdering, TransactionOrdering},
     traits::{
-        BestTransactions, OnNewBlockEvent, PoolTransaction, PropagateKind, PropagatedTransactions,
-        TransactionOrigin, TransactionPool,
+        BestTransactions, OnNewBlockEvent, PoolTransaction, PooledTransaction, PropagateKind,
+        PropagatedTransactions, TransactionOrigin, TransactionPool,
+    },
+    validate::{
+        EthTransactionValidator, TransactionValidationOutcome, TransactionValidator,
+        ValidPoolTransaction,
     },
-    validate::{TransactionValidationOutcome, TransactionValidator},
 };
 use crate::{
     error::PoolResult,
     pool::PoolInner,
     traits::{NewTransactionEvent, PoolSize},
-    validate::ValidPoolTransaction,
 };
+
+use crate::error::PoolError;
 use reth_primitives::{TxHash, U256};
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::mpsc::Receiver;
@@ -111,6 +115,24 @@ mod validate;
 /// Common test helpers for mocking A pool
 pub mod test_utils;
 
+// TX_SLOT_SIZE is used to calculate how many data slots a single transaction
+// takes up based on its size. The slots are used as DoS protection, ensuring
+// that validating a new transaction remains a constant operation (in reality
+// O(maxslots), where max slots are 4 currently).
+pub(crate) const TX_SLOT_SIZE: usize = 32 * 1024;
+
+// TX_MAX_SIZE is the maximum size a single transaction can have. This field has
+// non-trivial consequences: larger transactions are significantly harder and
+// more expensive to propagate; larger transactions also take more resources
+// to validate whether they fit into the pool or not.
+pub(crate) const TX_MAX_SIZE: usize = 4 * TX_SLOT_SIZE; //128KB
+
+// Maximum bytecode to permit for a contract
+pub(crate) const MAX_CODE_SIZE: usize = 24576;
+
+// Maximum initcode to permit in a creation transaction and create instructions
+pub(crate) const MAX_INIT_CODE_SIZE: usize = 2 * MAX_CODE_SIZE;
+
 /// A shareable, generic, customizable `TransactionPool` implementation.
 #[derive(Debug)]
 pub struct Pool<V: TransactionValidator, T: TransactionOrdering> {
@@ -126,8 +148,8 @@ where
     T: TransactionOrdering<Transaction = <V as TransactionValidator>::Transaction>,
 {
     /// Create a new transaction pool instance.
-    pub fn new(client: Arc<V>, ordering: Arc<T>, config: PoolConfig) -> Self {
-        Self { pool: Arc::new(PoolInner::new(client, ordering, config)) }
+    pub fn new(validator: V, ordering: T, config: PoolConfig) -> Self {
+        Self { pool: Arc::new(PoolInner::new(validator, ordering, config)) }
     }
 
     /// Returns the wrapped pool.
@@ -163,8 +185,10 @@ where
         transaction: V::Transaction,
     ) -> (TxHash, TransactionValidationOutcome<V::Transaction>) {
         let hash = *transaction.hash();
+
         // TODO(mattsse): this is where additional validate checks would go, like banned senders
         // etc...
+
         let outcome = self.pool.validator().validate_transaction(origin, transaction).await;
 
         (hash, outcome)
@@ -204,7 +228,18 @@ where
         transaction: Self::Transaction,
     ) -> PoolResult<TxHash> {
         let (_, tx) = self.validate(origin, transaction).await;
-        self.pool.add_transactions(origin, std::iter::once(tx)).pop().expect("exists; qed")
+
+        match tx {
+            TransactionValidationOutcome::Valid { .. } => {
+                self.pool.add_transactions(origin, std::iter::once(tx)).pop().expect("exists; qed")
+            }
+            TransactionValidationOutcome::Invalid(transaction, error) => {
+                Err(PoolError::InvalidTransaction(*transaction.hash(), error))
+            }
+            TransactionValidationOutcome::Error(transaction, error) => {
+                Err(PoolError::Other(*transaction.hash(), error))
+            }
+        }
     }
 
     async fn add_transactions(
@@ -213,6 +248,7 @@ where
         transactions: Vec<Self::Transaction>,
     ) -> PoolResult<Vec<PoolResult<TxHash>>> {
         let validated = self.validate_all(origin, transactions).await?;
+
         let transactions = self.pool.add_transactions(origin, validated.into_values());
         Ok(transactions)
     }
@@ -266,7 +302,7 @@ where
     }
 }
 
-impl<V: TransactionValidator, O: TransactionOrdering> Clone for Pool<V, O> {
+impl<V: TransactionValidator, T: TransactionOrdering> Clone for Pool<V, T> {
     fn clone(&self) -> Self {
         Self { pool: Arc::clone(&self.pool) }
     }
diff --git a/crates/transaction-pool/src/ordering.rs b/crates/transaction-pool/src/ordering.rs
index f5bf68eb953..b96db095480 100644
--- a/crates/transaction-pool/src/ordering.rs
+++ b/crates/transaction-pool/src/ordering.rs
@@ -1,5 +1,6 @@
 use crate::traits::PoolTransaction;
-use std::fmt;
+use reth_primitives::U256;
+use std::{fmt, marker::PhantomData};
 
 /// Transaction ordering trait to determine the order of transactions.
 ///
@@ -18,3 +19,23 @@ pub trait TransactionOrdering: Send + Sync + 'static {
     /// Returns the priority score for the given transaction.
     fn priority(&self, transaction: &Self::Transaction) -> Self::Priority;
 }
+
+/// Default ordering for the pool.
+///
+/// The transactions are ordered by their cost. The higher the cost,
+/// the higher the priority of this transaction is.
+#[derive(Debug, Default)]
+#[non_exhaustive]
+pub struct CostOrdering<T>(PhantomData<T>);
+
+impl<T> TransactionOrdering for CostOrdering<T>
+where
+    T: PoolTransaction + 'static,
+{
+    type Priority = U256;
+    type Transaction = T;
+
+    fn priority(&self, transaction: &Self::Transaction) -> Self::Priority {
+        transaction.cost()
+    }
+}
diff --git a/crates/transaction-pool/src/pool/best.rs b/crates/transaction-pool/src/pool/best.rs
index 078e68a58a4..ce68fc5d99c 100644
--- a/crates/transaction-pool/src/pool/best.rs
+++ b/crates/transaction-pool/src/pool/best.rs
@@ -83,7 +83,7 @@ mod tests {
 
     #[test]
     fn test_best_iter() {
-        let mut pool = PendingPool::new(Arc::new(MockOrdering::default()));
+        let mut pool = PendingPool::new(MockOrdering::default());
         let mut f = MockTransactionFactory::default();
 
         let num_tx = 10;
@@ -109,7 +109,7 @@ mod tests {
 
     #[test]
     fn test_best_iter_invalid() {
-        let mut pool = PendingPool::new(Arc::new(MockOrdering::default()));
+        let mut pool = PendingPool::new(MockOrdering::default());
         let mut f = MockTransactionFactory::default();
 
         let num_tx = 10;
diff --git a/crates/transaction-pool/src/pool/mod.rs b/crates/transaction-pool/src/pool/mod.rs
index 3772b41861b..bbcd5aa9d97 100644
--- a/crates/transaction-pool/src/pool/mod.rs
+++ b/crates/transaction-pool/src/pool/mod.rs
@@ -1,7 +1,7 @@
 //! Transaction Pool internals.
 //!
-//! Incoming transactions are before they enter the pool first. The validation outcome can have 3
-//! states:
+//! Incoming transactions validated are before they enter the pool first. The validation outcome can
+//! have 3 states:
 //!
 //!  1. Transaction can _never_ be valid
 //!  2. Transaction is _currently_ valid
@@ -92,7 +92,6 @@ mod parked;
 pub(crate) mod pending;
 pub(crate) mod size;
 pub(crate) mod state;
-mod transaction;
 pub mod txpool;
 mod update;
 
@@ -101,7 +100,7 @@ pub struct PoolInner<V: TransactionValidator, T: TransactionOrdering> {
     /// Internal mapping of addresses to plain ints.
     identifiers: RwLock<SenderIdentifiers>,
     /// Transaction validation.
-    validator: Arc<V>,
+    validator: V,
     /// The internal pool that manages all transactions.
     pool: RwLock<TxPool<T>>,
     /// Pool settings.
@@ -116,13 +115,13 @@ pub struct PoolInner<V: TransactionValidator, T: TransactionOrdering> {
 
 // === impl PoolInner ===
 
-impl<V: TransactionValidator, T: TransactionOrdering> PoolInner<V, T>
+impl<V, T> PoolInner<V, T>
 where
     V: TransactionValidator,
     T: TransactionOrdering<Transaction = <V as TransactionValidator>::Transaction>,
 {
     /// Create a new transaction pool instance.
-    pub(crate) fn new(validator: Arc<V>, ordering: Arc<T>, config: PoolConfig) -> Self {
+    pub(crate) fn new(validator: V, ordering: T, config: PoolConfig) -> Self {
         Self {
             identifiers: Default::default(),
             validator,
@@ -233,7 +232,12 @@ where
             TransactionValidationOutcome::Invalid(tx, err) => {
                 let mut listener = self.event_listener.write();
                 listener.discarded(tx.hash());
-                Err(err)
+                Err(PoolError::InvalidTransaction(*tx.hash(), err))
+            }
+            TransactionValidationOutcome::Error(tx, err) => {
+                let mut listener = self.event_listener.write();
+                listener.discarded(tx.hash());
+                Err(PoolError::Other(*tx.hash(), err))
             }
         }
     }
@@ -418,19 +422,12 @@ pub struct AddedPendingTransaction<T: PoolTransaction> {
     promoted: Vec<TxHash>,
     /// transaction that failed and became discarded
     discarded: Vec<TxHash>,
-    /// Transactions removed from the Ready pool
-    removed: Vec<Arc<ValidPoolTransaction<T>>>,
 }
 
 impl<T: PoolTransaction> AddedPendingTransaction<T> {
     /// Create a new, empty transaction.
     fn new(transaction: Arc<ValidPoolTransaction<T>>) -> Self {
-        Self {
-            transaction,
-            promoted: Default::default(),
-            discarded: Default::default(),
-            removed: Default::default(),
-        }
+        Self { transaction, promoted: Default::default(), discarded: Default::default() }
     }
 }
 
diff --git a/crates/transaction-pool/src/pool/parked.rs b/crates/transaction-pool/src/pool/parked.rs
index 94105a16098..b931d83d473 100644
--- a/crates/transaction-pool/src/pool/parked.rs
+++ b/crates/transaction-pool/src/pool/parked.rs
@@ -4,10 +4,15 @@ use crate::{
 use fnv::FnvHashMap;
 use std::{cmp::Ordering, collections::BTreeSet, ops::Deref, sync::Arc};
 
-/// A pool of transaction that are currently parked and wait for external changes that eventually
-/// move the transaction into the pending pool.
+/// A pool of transactions that are currently parked and are waiting for external changes (e.g.
+/// basefee, ancestor transactions, balance) that eventually move the transaction into the pending
+/// pool.
 ///
-/// This pool is a bijection: at all times each set contains the same transactions.
+/// This pool is a bijection: at all times each set (`best`, `by_id`) contains the same
+/// transactions.
+///
+/// Note: This type is generic over [ParkedPool] which enforces that the underlying transaction type
+/// is [ValidPoolTransaction] wrapped in an [Arc].
 pub(crate) struct ParkedPool<T: ParkedOrd> {
     /// Keeps track of transactions inserted in the pool.
     ///
@@ -231,8 +236,8 @@ impl<T: PoolTransaction> Ord for BasefeeOrd<T> {
 /// `Queued` transactions are transactions that are currently blocked by other parked (basefee,
 /// queued) or missing transactions.
 ///
-/// The primary order function for is always compares via the timestamp when the transaction was
-/// created
+/// The primary order function always compares the transaction costs first. In case these
+/// are equal, it compares the timestamps when the transactions were created.
 #[derive(Debug)]
 pub(crate) struct QueuedOrd<T: PoolTransaction>(Arc<ValidPoolTransaction<T>>);
 
@@ -240,6 +245,9 @@ impl_ord_wrapper!(QueuedOrd);
 
 impl<T: PoolTransaction> Ord for QueuedOrd<T> {
     fn cmp(&self, other: &Self) -> Ordering {
-        other.timestamp.cmp(&self.timestamp)
+        // Higher cost is better
+        self.cost.cmp(&other.cost).then_with(||
+            // Lower timestamp is better
+            other.timestamp.cmp(&self.timestamp))
     }
 }
diff --git a/crates/transaction-pool/src/pool/pending.rs b/crates/transaction-pool/src/pool/pending.rs
index e5751c6877a..1efdde6dece 100644
--- a/crates/transaction-pool/src/pool/pending.rs
+++ b/crates/transaction-pool/src/pool/pending.rs
@@ -22,7 +22,7 @@ use std::{
 /// is also pending, then this will be moved to the `independent` queue.
 pub(crate) struct PendingPool<T: TransactionOrdering> {
     /// How to order transactions.
-    ordering: Arc<T>,
+    ordering: T,
     /// Keeps track of transactions inserted in the pool.
     ///
     /// This way we can determine when transactions where submitted to the pool.
@@ -46,7 +46,7 @@ pub(crate) struct PendingPool<T: TransactionOrdering> {
 
 impl<T: TransactionOrdering> PendingPool<T> {
     /// Create a new pool instance.
-    pub(crate) fn new(ordering: Arc<T>) -> Self {
+    pub(crate) fn new(ordering: T) -> Self {
         Self {
             ordering,
             submission_id: 0,
diff --git a/crates/transaction-pool/src/pool/transaction.rs b/crates/transaction-pool/src/pool/transaction.rs
deleted file mode 100644
index 8b137891791..00000000000
--- a/crates/transaction-pool/src/pool/transaction.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/crates/transaction-pool/src/pool/txpool.rs b/crates/transaction-pool/src/pool/txpool.rs
index 983a9d48ac2..5458d7ddc05 100644
--- a/crates/transaction-pool/src/pool/txpool.rs
+++ b/crates/transaction-pool/src/pool/txpool.rs
@@ -1,7 +1,7 @@
 //! The internal transaction pool implementation.
 use crate::{
     config::MAX_ACCOUNT_SLOTS_PER_SENDER,
-    error::PoolError,
+    error::{InvalidPoolTransactionError, PoolError},
     identifier::{SenderId, TransactionId},
     metrics::TxPoolMetrics,
     pool::{
@@ -26,9 +26,11 @@ use std::{
     sync::Arc,
 };
 
-/// The minimal value the basefee can decrease to
+/// The minimal value the basefee can decrease to.
 ///
-/// The `BASE_FEE_MAX_CHANGE_DENOMINATOR` <https://eips.ethereum.org/EIPS/eip-1559> is `8`, or 12.5%, once the base fee has dropped to `7` WEI it cannot decrease further because 12.5% of 7 is less than 1.
+/// The `BASE_FEE_MAX_CHANGE_DENOMINATOR` <https://eips.ethereum.org/EIPS/eip-1559> is `8`, or 12.5%.
+/// Once the base fee has dropped to `7` WEI it cannot decrease further because 12.5% of 7 is less
+/// than 1.
 pub(crate) const MIN_PROTOCOL_BASE_FEE: u128 = 7;
 
 /// A pool that manages transactions.
@@ -66,9 +68,11 @@ pub(crate) const MIN_PROTOCOL_BASE_FEE: u128 = 7;
 ///   new -->  |apply state changes| pool
 /// ```
 pub struct TxPool<T: TransactionOrdering> {
-    /// Contains the currently known info
+    /// Contains the currently known information about the senders.
     sender_info: FnvHashMap<SenderId, SenderInfo>,
     /// pending subpool
+    ///
+    /// Holds transactions that are ready to be executed on the current state.
     pending_pool: PendingPool<T>,
     /// Pool settings to enforce limits etc.
     config: PoolConfig,
@@ -94,7 +98,7 @@ pub struct TxPool<T: TransactionOrdering> {
 
 impl<T: TransactionOrdering> TxPool<T> {
     /// Create a new graph pool instance.
-    pub(crate) fn new(ordering: Arc<T>, config: PoolConfig) -> Self {
+    pub(crate) fn new(ordering: T, config: PoolConfig) -> Self {
         Self {
             sender_info: Default::default(),
             pending_pool: PendingPool::new(ordering),
@@ -136,7 +140,7 @@ impl<T: TransactionOrdering> TxPool<T> {
         self.pending_pool.best()
     }
 
-    /// Returns if the transaction for the given hash is already included in this pool
+    /// Returns `true` if the transaction with the given hash is already included in this pool.
     pub(crate) fn contains(&self, tx_hash: &TxHash) -> bool {
         self.all_transactions.contains(tx_hash)
     }
@@ -149,7 +153,7 @@ impl<T: TransactionOrdering> TxPool<T> {
         self.all_transactions.by_hash.get(tx_hash).cloned()
     }
 
-    /// Returns all transaction for the hashes, if it exists.
+    /// Returns transactions for the multiple given hashes, if they exist.
     pub(crate) fn get_all<'a>(
         &'a self,
         txs: impl IntoIterator<Item = TxHash> + 'a,
@@ -174,7 +178,7 @@ impl<T: TransactionOrdering> TxPool<T> {
             self.all_transactions.update(event.pending_block_base_fee, &event.state_changes);
 
         // Process the sub-pool updates
-        let UpdateOutcome { promoted, discarded, .. } = self.process_updates(updates);
+        let UpdateOutcome { promoted, discarded } = self.process_updates(updates);
 
         OnNewBlockOutcome {
             block_hash: event.hash,
@@ -189,21 +193,21 @@ impl<T: TransactionOrdering> TxPool<T> {
     /// This pool consists of two three-pools: `Queued`, `Pending` and `BaseFee`.
     ///
     /// The `Queued` pool contains transactions with gaps in its dependency tree: It requires
-    /// additional transaction that are note yet present in the pool. And transactions that the
+    /// additional transactions that are note yet present in the pool. And transactions that the
     /// sender can not afford with the current balance.
     ///
     /// The `Pending` pool contains all transactions that have no nonce gaps, and can be afforded by
     /// the sender. It only contains transactions that are ready to be included in the pending
-    /// block. In the pending pool are all transactions that could be listed currently, but not
+    /// block. The pending pool contains all transactions that could be listed currently, but not
     /// necessarily independently. However, this pool never contains transactions with nonce gaps. A
     /// transaction is considered `ready` when it has the lowest nonce of all transactions from the
     /// same sender. Which is equals to the chain nonce of the sender in the pending pool.
     ///
-    /// The `BaseFee` pool contains transaction that currently can't satisfy the dynamic fee
+    /// The `BaseFee` pool contains transactions that currently can't satisfy the dynamic fee
     /// requirement. With EIP-1559, transactions can become executable or not without any changes to
-    /// the sender's balance or nonce and instead their feeCap determines whether the
+    /// the sender's balance or nonce and instead their `feeCap` determines whether the
     /// transaction is _currently_ (on the current state) ready or needs to be parked until the
-    /// feeCap satisfies the block's baseFee.
+    /// `feeCap` satisfies the block's `baseFee`.
     pub(crate) fn add_transaction(
         &mut self,
         tx: ValidPoolTransaction<T::Transaction>,
@@ -216,14 +220,12 @@ impl<T: TransactionOrdering> TxPool<T> {
             .or_default()
             .update(on_chain_nonce, on_chain_balance);
 
-        let _hash = *tx.hash();
-
         match self.all_transactions.insert_tx(tx, on_chain_balance, on_chain_nonce) {
             Ok(InsertOk { transaction, move_to, replaced_tx, updates, .. }) => {
                 self.add_new_transaction(transaction.clone(), replaced_tx, move_to);
                 // Update inserted transactions metric
                 self.metrics.inserted_transactions.increment(1);
-                let UpdateOutcome { promoted, discarded, removed } = self.process_updates(updates);
+                let UpdateOutcome { promoted, discarded } = self.process_updates(updates);
 
                 // This transaction was moved to the pending pool.
                 let res = if move_to.is_pending() {
@@ -231,7 +233,6 @@ impl<T: TransactionOrdering> TxPool<T> {
                         transaction,
                         promoted,
                         discarded,
-                        removed,
                     })
                 } else {
                     AddedTransaction::Parked { transaction, subpool: move_to }
@@ -259,10 +260,9 @@ impl<T: TransactionOrdering> TxPool<T> {
                         transaction,
                         block_gas_limit,
                         tx_gas_limit,
-                    } => Err(PoolError::TxExceedsGasLimit(
+                    } => Err(PoolError::InvalidTransaction(
                         *transaction.hash(),
-                        block_gas_limit,
-                        tx_gas_limit,
+                        InvalidPoolTransactionError::ExceedsGasLimit(block_gas_limit, tx_gas_limit),
                     )),
                 }
             }
@@ -272,10 +272,7 @@ impl<T: TransactionOrdering> TxPool<T> {
     /// Maintenance task to apply a series of updates.
     ///
     /// This will move/discard the given transaction according to the `PoolUpdate`
-    fn process_updates(
-        &mut self,
-        updates: impl IntoIterator<Item = PoolUpdate>,
-    ) -> UpdateOutcome<T::Transaction> {
+    fn process_updates(&mut self, updates: impl IntoIterator<Item = PoolUpdate>) -> UpdateOutcome {
         let mut outcome = UpdateOutcome::default();
         for update in updates {
             let PoolUpdate { id, hash, current, destination } = update;
@@ -286,6 +283,9 @@ impl<T: TransactionOrdering> TxPool<T> {
                 Destination::Pool(move_to) => {
                     debug_assert!(!move_to.eq(&current), "destination must be different");
                     self.move_transaction(current, move_to, &id);
+                    if matches!(move_to, SubPool::Pending) {
+                        outcome.promoted.push(hash);
+                    }
                 }
             }
         }
@@ -294,11 +294,11 @@ impl<T: TransactionOrdering> TxPool<T> {
 
     /// Moves a transaction from one sub pool to another.
     ///
-    /// This will remove the given transaction from one sub-pool and insert it in the other
+    /// This will remove the given transaction from one sub-pool and insert it into the other
     /// sub-pool.
     fn move_transaction(&mut self, from: SubPool, to: SubPool, id: &TransactionId) {
         if let Some(tx) = self.remove_from_subpool(from, id) {
-            self.add_transaction_to_pool(to, tx);
+            self.add_transaction_to_subpool(to, tx);
         }
     }
 
@@ -372,8 +372,8 @@ impl<T: TransactionOrdering> TxPool<T> {
         }
     }
 
-    /// Removes the transaction from the given pool
-    fn add_transaction_to_pool(
+    /// Inserts the transaction into the given sub-pool.
+    fn add_transaction_to_subpool(
         &mut self,
         pool: SubPool,
         tx: Arc<ValidPoolTransaction<T::Transaction>>,
@@ -391,7 +391,8 @@ impl<T: TransactionOrdering> TxPool<T> {
         }
     }
 
-    /// Inserts the transaction into the given sub-pool
+    /// Inserts the transaction into the given sub-pool.
+    /// Optionally, removes the replacement transaction.
     fn add_new_transaction(
         &mut self,
         transaction: Arc<ValidPoolTransaction<T::Transaction>>,
@@ -403,7 +404,7 @@ impl<T: TransactionOrdering> TxPool<T> {
             self.remove_from_subpool(replaced_pool, replaced.id());
         }
 
-        self.add_transaction_to_pool(pool, transaction)
+        self.add_transaction_to_subpool(pool, transaction)
     }
 
     /// Ensures that the transactions in the sub-pools are within the given bounds.
@@ -1078,27 +1079,19 @@ impl<T: PoolTransaction> PoolInternalTransaction<T> {
 }
 
 /// Tracks the result after updating the pool
-#[derive(Debug)]
-pub struct UpdateOutcome<T: PoolTransaction> {
+#[derive(Default, Debug)]
+pub struct UpdateOutcome {
     /// transactions promoted to the ready queue
     promoted: Vec<TxHash>,
     /// transaction that failed and became discarded
     discarded: Vec<TxHash>,
-    /// Transactions removed from the Ready pool
-    removed: Vec<Arc<ValidPoolTransaction<T>>>,
-}
-
-impl<T: PoolTransaction> Default for UpdateOutcome<T> {
-    fn default() -> Self {
-        Self { promoted: vec![], discarded: vec![], removed: vec![] }
-    }
 }
 
 /// Represents the outcome of a prune
 pub struct PruneResult<T: PoolTransaction> {
     /// A list of added transactions that a pruned marker satisfied
     pub promoted: Vec<AddedTransaction<T>>,
-    /// all transactions that  failed to be promoted and now are discarded
+    /// all transactions that failed to be promoted and now are discarded
     pub failed: Vec<TxHash>,
     /// all transactions that were pruned from the ready pool
     pub pruned: Vec<Arc<ValidPoolTransaction<T>>>,
diff --git a/crates/transaction-pool/src/test_utils/mock.rs b/crates/transaction-pool/src/test_utils/mock.rs
index 422d5af6dc4..31d0c5e9081 100644
--- a/crates/transaction-pool/src/test_utils/mock.rs
+++ b/crates/transaction-pool/src/test_utils/mock.rs
@@ -32,7 +32,7 @@ use reth_primitives::Bytes;
 
 /// Create an empty `TxPool`
 pub(crate) fn mock_tx_pool() -> MockTxPool {
-    MockTxPool::new(Arc::new(Default::default()), Default::default())
+    MockTxPool::new(Default::default(), Default::default())
 }
 
 /// Sets the value for the field
@@ -405,6 +405,10 @@ impl PoolTransaction for MockTransaction {
     fn encoded_length(&self) -> usize {
         0
     }
+
+    fn chain_id(&self) -> Option<u64> {
+        Some(1)
+    }
 }
 
 impl FromRecoveredTransaction for MockTransaction {
diff --git a/crates/transaction-pool/src/test_utils/mod.rs b/crates/transaction-pool/src/test_utils/mod.rs
index 7fd1da50bbd..4a0d67534d7 100644
--- a/crates/transaction-pool/src/test_utils/mod.rs
+++ b/crates/transaction-pool/src/test_utils/mod.rs
@@ -16,11 +16,7 @@ pub type TestPool = Pool<NoopTransactionValidator<MockTransaction>, MockOrdering
 
 /// Returns a new [Pool] used for testing purposes
 pub fn testing_pool() -> TestPool {
-    Pool::new(
-        Arc::new(NoopTransactionValidator::default()),
-        Arc::new(MockOrdering::default()),
-        Default::default(),
-    )
+    Pool::new(NoopTransactionValidator::default(), MockOrdering::default(), Default::default())
 }
 
 // A [`TransactionValidator`] that does nothing.
diff --git a/crates/transaction-pool/src/test_utils/pool.rs b/crates/transaction-pool/src/test_utils/pool.rs
index 30217a86724..c8d79fb16ec 100644
--- a/crates/transaction-pool/src/test_utils/pool.rs
+++ b/crates/transaction-pool/src/test_utils/pool.rs
@@ -41,7 +41,7 @@ impl MockPool {
 
 impl Default for MockPool {
     fn default() -> Self {
-        Self { pool: TxPool::new(Arc::new(MockOrdering::default()), Default::default()) }
+        Self { pool: TxPool::new(MockOrdering::default(), Default::default()) }
     }
 }
 
diff --git a/crates/transaction-pool/src/traits.rs b/crates/transaction-pool/src/traits.rs
index f833e3e5df9..68a48a0e317 100644
--- a/crates/transaction-pool/src/traits.rs
+++ b/crates/transaction-pool/src/traits.rs
@@ -250,7 +250,9 @@ impl<T> BestTransactions for std::iter::Empty<T> {
 }
 
 /// Trait for transaction types used inside the pool
-pub trait PoolTransaction: fmt::Debug + Send + Sync + FromRecoveredTransaction {
+pub trait PoolTransaction:
+    fmt::Debug + Send + Sync + FromRecoveredTransaction + IntoRecoveredTransaction
+{
     /// Hash of the transaction.
     fn hash(&self) -> &TxHash;
 
@@ -295,6 +297,9 @@ pub trait PoolTransaction: fmt::Debug + Send + Sync + FromRecoveredTransaction {
 
     /// Returns the length of the rlp encoded object
     fn encoded_length(&self) -> usize;
+
+    /// Returns chain_id
+    fn chain_id(&self) -> Option<u64>;
 }
 
 /// The default [PoolTransaction] for the [Pool](crate::Pool).
@@ -302,7 +307,7 @@ pub trait PoolTransaction: fmt::Debug + Send + Sync + FromRecoveredTransaction {
 /// This type is essentially a wrapper around [TransactionSignedEcRecovered] with additional fields
 /// derived from the transaction that are frequently used by the pools for ordering.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PooledTransaction {
+pub struct PooledTransaction {
     /// EcRecovered transaction info
     pub(crate) transaction: TransactionSignedEcRecovered,
 
@@ -313,6 +318,13 @@ pub(crate) struct PooledTransaction {
     pub(crate) effective_gas_price: u128,
 }
 
+impl PooledTransaction {
+    /// Return the reference to the underlying transaction.
+    pub fn transaction(&self) -> &TransactionSignedEcRecovered {
+        &self.transaction
+    }
+}
+
 impl PoolTransaction for PooledTransaction {
     /// Returns hash of the transaction.
     fn hash(&self) -> &TxHash {
@@ -394,6 +406,11 @@ impl PoolTransaction for PooledTransaction {
     fn encoded_length(&self) -> usize {
         self.transaction.length()
     }
+
+    /// Returns chain_id
+    fn chain_id(&self) -> Option<u64> {
+        self.transaction.chain_id()
+    }
 }
 
 impl FromRecoveredTransaction for PooledTransaction {
diff --git a/crates/transaction-pool/src/validate.rs b/crates/transaction-pool/src/validate.rs
index a5d855b3a09..37c1829be63 100644
--- a/crates/transaction-pool/src/validate.rs
+++ b/crates/transaction-pool/src/validate.rs
@@ -1,12 +1,18 @@
 //! Transaction validation abstractions.
 
 use crate::{
-    error::PoolError,
+    error::InvalidPoolTransactionError,
     identifier::{SenderId, TransactionId},
     traits::{PoolTransaction, TransactionOrigin},
+    MAX_INIT_CODE_SIZE, TX_MAX_SIZE,
 };
-use reth_primitives::{Address, TransactionKind, TxHash, U256};
-use std::{fmt, time::Instant};
+use reth_primitives::{
+    Address, ChainSpec, IntoRecoveredTransaction, InvalidTransactionError, TransactionKind,
+    TransactionSignedEcRecovered, TxHash, EIP1559_TX_TYPE_ID, EIP2930_TX_TYPE_ID,
+    LEGACY_TX_TYPE_ID, U256,
+};
+use reth_provider::AccountProvider;
+use std::{fmt, sync::Arc, time::Instant};
 
 /// A Result type returned after checking a transaction's validity.
 #[derive(Debug)]
@@ -22,7 +28,9 @@ pub enum TransactionValidationOutcome<T: PoolTransaction> {
     },
     /// The transaction is considered invalid indefinitely: It violates constraints that prevent
     /// this transaction from ever becoming valid.
-    Invalid(T, PoolError),
+    Invalid(T, InvalidPoolTransactionError),
+    /// An error occurred while trying to validate the transaction
+    Error(T, Box<dyn std::error::Error + Send + Sync>),
 }
 
 /// Provides support for validating transaction at any given state of the chain
@@ -61,16 +69,10 @@ pub trait TransactionValidator: Send + Sync {
         &self,
         transaction: Self::Transaction,
         max_init_code_size: usize,
-    ) -> Result<(), PoolError> {
-        // TODO check whether we are in the Shanghai stage.
-        // if !self.shanghai {
-        //     return Ok(())
-        // }
-
+    ) -> Result<(), InvalidPoolTransactionError> {
         if *transaction.kind() == TransactionKind::Create && transaction.size() > max_init_code_size
         {
-            Err(PoolError::TxExceedsMaxInitCodeSize(
-                *transaction.hash(),
+            Err(InvalidPoolTransactionError::ExceedsMaxInitCodeSize(
                 transaction.size(),
                 max_init_code_size,
             ))
@@ -80,6 +82,202 @@ pub trait TransactionValidator: Send + Sync {
     }
 }
 
+/// A [TransactionValidator] implementation that validates ethereum transaction.
+#[derive(Debug, Clone)]
+pub struct EthTransactionValidator<Client> {
+    /// Spec of the chain
+    chain_spec: Arc<ChainSpec>,
+    /// This type fetches account info from the db
+    client: Client,
+    /// Fork indicator whether we are in the Shanghai stage.
+    shanghai: bool,
+    /// Fork indicator whether we are using EIP-2718 type transactions.
+    eip2718: bool,
+    /// Fork indicator whether we are using EIP-1559 type transactions.
+    eip1559: bool,
+    /// The current max gas limit
+    current_max_gas_limit: u64,
+    /// Current base fee.
+    base_fee: Option<u128>,
+}
+
+// === impl EthTransactionValidator ===
+
+impl<Client> EthTransactionValidator<Client> {
+    /// Creates a new instance for the given [ChainSpec]
+    pub fn new(client: Client, chain_spec: Arc<ChainSpec>) -> Self {
+        // TODO(mattsse): improve these settings by checking against hardfork
+        // See [reth_consensus::validation::validate_transaction_regarding_header]
+        Self {
+            chain_spec,
+            client,
+            shanghai: true,
+            eip2718: true,
+            eip1559: true,
+            current_max_gas_limit: 30_000_000,
+            base_fee: None,
+        }
+    }
+
+    /// Returns the configured chain id
+    pub fn chain_id(&self) -> u64 {
+        self.chain_spec.chain().id()
+    }
+}
+
+#[async_trait::async_trait]
+impl<T: PoolTransaction + AccountProvider + Clone> TransactionValidator
+    for EthTransactionValidator<T>
+{
+    type Transaction = T;
+
+    async fn validate_transaction(
+        &self,
+        origin: TransactionOrigin,
+        transaction: Self::Transaction,
+    ) -> TransactionValidationOutcome<Self::Transaction> {
+        // Checks for tx_type
+        match transaction.tx_type() {
+            LEGACY_TX_TYPE_ID => {
+                // Accept legacy transactions
+            }
+
+            EIP2930_TX_TYPE_ID => {
+                // Accept only legacy transactions until EIP-2718/2930 activates
+                if !self.eip2718 {
+                    return TransactionValidationOutcome::Invalid(
+                        transaction,
+                        InvalidTransactionError::Eip1559Disabled.into(),
+                    )
+                }
+            }
+
+            EIP1559_TX_TYPE_ID => {
+                // Reject dynamic fee transactions until EIP-1559 activates.
+                if !self.eip1559 {
+                    return TransactionValidationOutcome::Invalid(
+                        transaction,
+                        InvalidTransactionError::Eip1559Disabled.into(),
+                    )
+                }
+            }
+
+            _ => {
+                return TransactionValidationOutcome::Invalid(
+                    transaction,
+                    InvalidTransactionError::TxTypeNotSupported.into(),
+                )
+            }
+        };
+
+        // Reject transactions over defined size to prevent DOS attacks
+        if transaction.size() > TX_MAX_SIZE {
+            return TransactionValidationOutcome::Invalid(
+                transaction.clone(),
+                InvalidPoolTransactionError::OversizedData(transaction.size(), TX_MAX_SIZE),
+            )
+        }
+
+        // Check whether the init code size has been exceeded.
+        if self.shanghai {
+            if let Err(err) =
+                self.ensure_max_init_code_size(transaction.clone(), MAX_INIT_CODE_SIZE)
+            {
+                return TransactionValidationOutcome::Invalid(transaction, err)
+            }
+        }
+
+        // Checks for gas limit
+        if transaction.gas_limit() > self.current_max_gas_limit {
+            return TransactionValidationOutcome::Invalid(
+                transaction.clone(),
+                InvalidPoolTransactionError::ExceedsGasLimit(
+                    transaction.gas_limit(),
+                    self.current_max_gas_limit,
+                ),
+            )
+        }
+
+        // Ensure max_fee_per_gas is greater than or equal to max_priority_fee_per_gas.
+        if transaction.max_fee_per_gas() <= transaction.max_priority_fee_per_gas() {
+            return TransactionValidationOutcome::Invalid(
+                transaction,
+                InvalidTransactionError::TipAboveFeeCap.into(),
+            )
+        }
+
+        // Drop non-local transactions under our own minimal accepted gas price or tip
+        if !origin.is_local() && transaction.max_fee_per_gas() < self.base_fee {
+            return TransactionValidationOutcome::Invalid(
+                transaction,
+                InvalidTransactionError::MaxFeeLessThenBaseFee.into(),
+            )
+        }
+
+        // Checks for chainid
+        if transaction.chain_id() != Some(self.chain_id()) {
+            return TransactionValidationOutcome::Invalid(
+                transaction,
+                InvalidTransactionError::ChainIdMismatch.into(),
+            )
+        }
+
+        let account = match self.client.basic_account(transaction.sender()) {
+            Ok(account) => account,
+            Err(err) => return TransactionValidationOutcome::Error(transaction, Box::new(err)),
+        };
+
+        let account = match account {
+            Some(account) => {
+                // Signer account shouldn't have bytecode. Presence of bytecode means this is a
+                // smartcontract.
+                if account.has_bytecode() {
+                    return TransactionValidationOutcome::Invalid(
+                        transaction,
+                        InvalidTransactionError::SignerAccountHasBytecode.into(),
+                    )
+                } else {
+                    account
+                }
+            }
+            None => {
+                return TransactionValidationOutcome::Invalid(
+                    transaction,
+                    InvalidPoolTransactionError::AccountNotFound,
+                )
+            }
+        };
+
+        // Checks for nonce
+        if transaction.nonce() < account.nonce {
+            return TransactionValidationOutcome::Invalid(
+                transaction,
+                InvalidTransactionError::NonceNotConsistent.into(),
+            )
+        }
+
+        // Checks for max cost
+        if transaction.cost() > account.balance {
+            let max_fee = transaction.max_fee_per_gas().unwrap_or_default();
+            return TransactionValidationOutcome::Invalid(
+                transaction,
+                InvalidTransactionError::InsufficientFunds {
+                    max_fee,
+                    available_funds: account.balance,
+                }
+                .into(),
+            )
+        }
+
+        // Return the valid transaction
+        TransactionValidationOutcome::Valid {
+            balance: account.balance,
+            state_nonce: account.nonce,
+            transaction,
+        }
+    }
+}
+
 /// A valid transaction in the pool.
 pub struct ValidPoolTransaction<T: PoolTransaction> {
     /// The transaction
@@ -106,6 +304,11 @@ impl<T: PoolTransaction> ValidPoolTransaction<T> {
         self.transaction.hash()
     }
 
+    /// Returns the type identifier of the transaction
+    pub fn tx_type(&self) -> u8 {
+        self.transaction.tx_type()
+    }
+
     /// Returns the address of the sender
     pub fn sender(&self) -> Address {
         self.transaction.sender()
@@ -152,6 +355,12 @@ impl<T: PoolTransaction> ValidPoolTransaction<T> {
     }
 }
 
+impl<T: PoolTransaction> IntoRecoveredTransaction for ValidPoolTransaction<T> {
+    fn to_recovered_transaction(&self) -> TransactionSignedEcRecovered {
+        self.transaction.to_recovered_transaction()
+    }
+}
+
 #[cfg(test)]
 impl<T: PoolTransaction + Clone> Clone for ValidPoolTransaction<T> {
     fn clone(&self) -> Self {
diff --git a/deny.toml b/deny.toml
index 7c1d703f3f8..6fe43eb8b35 100644
--- a/deny.toml
+++ b/deny.toml
@@ -57,6 +57,8 @@ exceptions = [
     { allow = ["CC0-1.0"], name = "secp256k1-sys" },
     { allow = ["CC0-1.0"], name = "tiny-keccak" },
     { allow = ["CC0-1.0"], name = "more-asserts" },
+    # MIT with no attribution https://choosealicense.com/licenses/mit-0/
+    { allow = ["MIT-0"], name = "dunce" },
 
     # TODO: ethers transitive deps
     { allow = ["GPL-3.0"], name = "fastrlp" },