chore: Patch reth to allow zero state root on unwind

fix: Setup correct context for context_for_payload as well
Merge pull request #35 from hl-archive-node/feat/testnet-node-builder
2025-12-06 10:59:55 +00:00 · 2025-08-22 12:51:30 -04:00 · 2025-08-22 12:51:02 -04:00 · 2025-08-22 23:42:52 +09:00 · 2025-08-22 10:40:36 -04:00 · 2025-08-22 10:40:14 -04:00
35 changed files with 1889 additions and 2108 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -25,86 +25,86 @@ lto = "fat"
 codegen-units = 1

 [dependencies]
-reth = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-cli = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-cli-commands = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-basic-payload-builder = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-db = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-db-api = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-chainspec = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-cli-util = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-discv4 = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-engine-primitives = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-ethereum-forks = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-ethereum-payload-builder = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-ethereum-primitives = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-eth-wire = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-eth-wire-types = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-evm = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-evm-ethereum = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-node-core = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-revm = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-network = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-network-p2p = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-network-api = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-node-ethereum = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-network-peers = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-payload-primitives = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-primitives = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-primitives-traits = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-provider = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc", features = ["test-utils"] }
-reth-rpc = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-rpc-eth-api = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-rpc-engine-api = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-tracing = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-trie-common = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-trie-db = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-codecs = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-transaction-pool = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-reth-stages-types = { git = "https://github.com/sprites0/reth", rev = "fc754e5983f055365325dc9a04632d5ba2c4a8bc" }
-revm = { version = "26.0.1" }
+reth = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-cli = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-cli-commands = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-basic-payload-builder = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-db = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-db-api = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-chainspec = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-cli-util = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-discv4 = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-engine-primitives = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-ethereum-forks = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-ethereum-payload-builder = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-ethereum-primitives = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-eth-wire = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-eth-wire-types = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-evm = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-evm-ethereum = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-node-core = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-revm = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-network = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-network-p2p = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-network-api = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-node-ethereum = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-network-peers = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-payload-primitives = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-primitives = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-primitives-traits = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-provider = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb", features = ["test-utils"] }
+reth-rpc = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-rpc-eth-api = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-rpc-engine-api = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-tracing = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-trie-common = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-trie-db = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-codecs = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-transaction-pool = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+reth-stages-types = { git = "https://github.com/sprites0/reth", rev = "a690ef25b56039195e7e4a4abd01c78aedcc73fb" }
+revm = { version = "28.0.1", default-features = false }

 # alloy dependencies
-alloy-genesis = "1.0.13"
-alloy-consensus = { version = "1.0.13", features = ["serde"] }
-alloy-chains = "0.2.0"
-alloy-eips = "1.0.13"
-alloy-evm = "0.12"
-alloy-json-abi = { version = "1.0.0", default-features = false }
-alloy-json-rpc = { version = "1.0.13", default-features = false }
-alloy-dyn-abi = "1.2.0"
-alloy-network = "1.0.13"
-alloy-primitives = { version = "1.2.0", default-features = false, features = ["map-foldhash"] }
+alloy-genesis = { version = "1.0.23", default-features = false }
+alloy-consensus = { version = "1.0.23", default-features = false }
+alloy-chains = { version = "0.2.5", default-features = false }
+alloy-eips = { version = "1.0.23", default-features = false }
+alloy-evm = { version = "0.18.2", default-features = false }
+alloy-json-abi = { version = "1.3.1", default-features = false }
+alloy-json-rpc = { version = "1.0.23", default-features = false }
+alloy-dyn-abi = "1.3.1"
+alloy-network = { version = "1.0.23", default-features = false }
+alloy-primitives = { version = "1.3.1", default-features = false, features = ["map-foldhash"] }
 alloy-rlp = { version = "0.3.10", default-features = false, features = ["core-net"] }
-alloy-rpc-types = { version = "1.0.13", features = ["engine"] }
-alloy-rpc-types-eth = "1.0.13"
-alloy-rpc-types-engine = "1.0.13"
-alloy-signer = "1.0.13"
-alloy-sol-macro = "1.2.0"
-alloy-sol-types = { version = "1.2.0", default-features = false }
+alloy-rpc-types = { version = "1.0.23", features = ["eth"], default-features = false }
+alloy-rpc-types-eth = { version = "1.0.23", default-features = false }
+alloy-rpc-types-engine = { version = "1.0.23", default-features = false }
+alloy-signer = { version = "1.0.23", default-features = false }
+alloy-sol-macro = "1.3.1"
+alloy-sol-types = { version = "1.3.1", default-features = false }

 jsonrpsee = "0.25.1"
-jsonrpsee-core = { version = "0.25.1" }
+jsonrpsee-core = "0.25.1"
 jsonrpsee-types = "0.25.1"

 # misc dependencies
 auto_impl = "1"
-async-trait = "0.1"
-bytes = "1.5"
+async-trait = "0.1.68"
+bytes = { version = "1.5", default-features = false }
 clap = { version = "4", features = ["derive"] }
 cfg-if = { version = "1.0", default-features = false }
 derive_more = { version = "2", default-features = false, features = ["full"] }
 eyre = "0.6"
 futures = "0.3"
 lazy_static = "1.4.0"
-once_cell = { version = "1.19", default-features = false, features = ["alloc"] }
+once_cell = { version = "1.19", default-features = false, features = ["critical-section"] }
 parking_lot = "0.12"
 serde = { version = "1.0", features = ["derive"], default-features = false }
-serde_json = "1.0"
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 thiserror = { version = "2.0.0", default-features = false }
 tokio = { version = "1.44.2", features = ["full"] }
-tokio-stream = "0.1"
-tracing = "0.1"
+tokio-stream = "0.1.11"
+tracing = { version = "0.1.0", default-features = false }
 rmp-serde = "1.3"
 lz4_flex = "0.11"
 ureq = "3.0.12"
--- a/src/call_forwarder.rs
+++ b/src/call_forwarder.rs
@ -1,8 +1,8 @@
 use alloy_eips::BlockId;
+use alloy_json_rpc::RpcObject;
 use alloy_primitives::{Bytes, U256};
 use alloy_rpc_types_eth::{
    state::{EvmOverrides, StateOverride},
-    transaction::TransactionRequest,
    BlockOverrides,
 };
 use jsonrpsee::{
@ -12,16 +12,17 @@ use jsonrpsee::{
    types::{error::INTERNAL_ERROR_CODE, ErrorObject},
 };
 use jsonrpsee_core::{async_trait, client::ClientT, ClientError, RpcResult};
-use reth_rpc_eth_api::helpers::EthCall;
+use reth_rpc::eth::EthApiTypes;
+use reth_rpc_eth_api::{helpers::EthCall, RpcTxReq};

 #[rpc(server, namespace = "eth")]
-pub(crate) trait CallForwarderApi {
+pub(crate) trait CallForwarderApi<TxReq: RpcObject> {
    /// Executes a new message call immediately without creating a transaction on the block chain.
    #[method(name = "call")]
    async fn call(
        &self,
-        request: TransactionRequest,
-        block_number: Option<BlockId>,
+        request: TxReq,
+        block_id: Option<BlockId>,
        state_overrides: Option<StateOverride>,
        block_overrides: Option<Box<BlockOverrides>>,
    ) -> RpcResult<Bytes>;
@ -31,8 +32,8 @@ pub(crate) trait CallForwarderApi {
    #[method(name = "estimateGas")]
    async fn estimate_gas(
        &self,
-        request: TransactionRequest,
-        block_number: Option<BlockId>,
+        request: TxReq,
+        block_id: Option<BlockId>,
        state_override: Option<StateOverride>,
    ) -> RpcResult<U256>;
 }
@ -52,23 +53,24 @@ impl<EthApi> CallForwarderExt<EthApi> {
 }

 #[async_trait]
-impl<EthApi> CallForwarderApiServer for CallForwarderExt<EthApi>
+impl<EthApi> CallForwarderApiServer<RpcTxReq<<EthApi as EthApiTypes>::NetworkTypes>>
+    for CallForwarderExt<EthApi>
 where
    EthApi: EthCall + Send + Sync + 'static,
 {
    async fn call(
        &self,
-        request: TransactionRequest,
-        block_number: Option<BlockId>,
+        request: RpcTxReq<<EthApi as EthApiTypes>::NetworkTypes>,
+        block_id: Option<BlockId>,
        state_overrides: Option<StateOverride>,
        block_overrides: Option<Box<BlockOverrides>>,
    ) -> RpcResult<Bytes> {
-        let is_latest = block_number.as_ref().map(|b| b.is_latest()).unwrap_or(true);
+        let is_latest = block_id.as_ref().map(|b| b.is_latest()).unwrap_or(true);
        let result = if is_latest {
            self.upstream_client
                .request(
                    "eth_call",
-                    rpc_params![request, block_number, state_overrides, block_overrides],
+                    rpc_params![request, block_id, state_overrides, block_overrides],
                )
                .await
                .map_err(|e| match e {
@ -83,7 +85,7 @@ where
            EthCall::call(
                &self.eth_api,
                request,
-                block_number,
+                block_id,
                EvmOverrides::new(state_overrides, block_overrides),
            )
            .await
@ -97,14 +99,14 @@ where

    async fn estimate_gas(
        &self,
-        request: TransactionRequest,
-        block_number: Option<BlockId>,
+        request: RpcTxReq<<EthApi as EthApiTypes>::NetworkTypes>,
+        block_id: Option<BlockId>,
        state_override: Option<StateOverride>,
    ) -> RpcResult<U256> {
-        let is_latest = block_number.as_ref().map(|b| b.is_latest()).unwrap_or(true);
+        let is_latest = block_id.as_ref().map(|b| b.is_latest()).unwrap_or(true);
        let result = if is_latest {
            self.upstream_client
-                .request("eth_estimateGas", rpc_params![request, block_number, state_override])
+                .request("eth_estimateGas", rpc_params![request, block_id, state_override])
                .await
                .map_err(|e| match e {
                    ClientError::Call(e) => e,
@ -118,7 +120,7 @@ where
            EthCall::estimate_gas_at(
                &self.eth_api,
                request,
-                block_number.unwrap_or_default(),
+                block_id.unwrap_or_default(),
                state_override,
            )
            .await
--- a/src/chainspec/hl.rs
+++ b/src/chainspec/hl.rs
@ -34,12 +34,10 @@ pub static HL_HARDFORKS: LazyLock<ChainHardforks> = LazyLock::new(|| {
    ])
 });

-/// The Hyperliqiud Mainnet spec
-pub fn hl_mainnet() -> ChainSpec {
+pub fn hl_chainspec(chain: Chain, genesis: &'static str) -> ChainSpec {
    ChainSpec {
-        chain: Chain::from_named(NamedChain::Hyperliquid),
-        genesis: serde_json::from_str(include_str!("genesis.json"))
-            .expect("Can't deserialize Hyperliquid Mainnet genesis json"),
+        chain,
+        genesis: serde_json::from_str(genesis).expect("Can't deserialize Hyperliquid genesis json"),
        genesis_header: empty_genesis_header(),
        paris_block_and_final_difficulty: Some((0, U256::from(0))),
        hardforks: HL_HARDFORKS.clone(),
@ -48,6 +46,18 @@ pub fn hl_mainnet() -> ChainSpec {
    }
 }

+/// The Hyperliqiud Mainnet spec
+pub fn hl_mainnet() -> ChainSpec {
+    hl_chainspec(Chain::from_named(NamedChain::Hyperliquid), include_str!("genesis.json"))
+}
+
+/// The Hyperliqiud Testnet spec
+pub fn hl_testnet() -> ChainSpec {
+    // Note: Testnet sync starts from snapshotted state [1] instead of genesis block.
+    // So the `alloc` field is not used, which makes it fine to reuse mainnet genesis file.
+    hl_chainspec(Chain::from_id_unchecked(998), include_str!("genesis.json"))
+}
+
 /// Empty genesis header for Hyperliquid Mainnet.
 ///
 /// The exact value is not known per se, but the parent hash of block 1 is known to be
--- a/src/chainspec/mod.rs
+++ b/src/chainspec/mod.rs
@ -15,6 +15,9 @@ use reth_discv4::NodeRecord;
 use reth_evm::eth::spec::EthExecutorSpec;
 use std::{fmt::Display, sync::Arc};

+pub const MAINNET_CHAIN_ID: u64 = 999;
+pub const TESTNET_CHAIN_ID: u64 = 998;
+
 /// Hl chain spec type.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct HlChainSpec {
@ -144,8 +147,16 @@ impl HlChainSpec {

    pub fn official_rpc_url(&self) -> &'static str {
        match self.inner.chain().id() {
-            999 => Self::MAINNET_RPC_URL,
-            998 => Self::TESTNET_RPC_URL,
+            MAINNET_CHAIN_ID => Self::MAINNET_RPC_URL,
+            TESTNET_CHAIN_ID => Self::TESTNET_RPC_URL,
+            _ => unreachable!("Unreachable since ChainSpecParser won't return other chains"),
+        }
+    }
+
+    pub fn official_s3_bucket(self) -> &'static str {
+        match self.inner.chain().id() {
+            MAINNET_CHAIN_ID => "hl-mainnet-evm-blocks",
+            TESTNET_CHAIN_ID => "hl-testnet-evm-blocks",
            _ => unreachable!("Unreachable since ChainSpecParser won't return other chains"),
        }
    }
--- a/src/chainspec/parser.rs
+++ b/src/chainspec/parser.rs
@ -1,11 +1,11 @@
-use crate::chainspec::HlChainSpec;
+use crate::chainspec::{hl::hl_testnet, HlChainSpec};

 use super::hl::hl_mainnet;
 use reth_cli::chainspec::ChainSpecParser;
 use std::sync::Arc;

 /// Chains supported by HyperEVM. First value should be used as the default.
-pub const SUPPORTED_CHAINS: &[&str] = &["mainnet"];
+pub const SUPPORTED_CHAINS: &[&str] = &["mainnet", "testnet"];

 /// Hyperliquid chain specification parser.
 #[derive(Debug, Clone, Default)]
@ -27,6 +27,7 @@ impl ChainSpecParser for HlChainSpecParser {
 pub fn chain_value_parser(s: &str) -> eyre::Result<Arc<HlChainSpec>> {
    match s {
        "mainnet" => Ok(Arc::new(HlChainSpec { inner: hl_mainnet() })),
+        "testnet" => Ok(Arc::new(HlChainSpec { inner: hl_testnet() })),
        _ => Err(eyre::eyre!("Unsupported chain: {}", s)),
    }
 }
--- a/src/evm/api/mod.rs
+++ b/src/evm/api/mod.rs
@ -1,4 +1,5 @@
 use revm::{
+    bytecode::opcode::BLOCKHASH,
    context::{ContextSetters, Evm, FrameStack},
    context_interface::ContextTr,
    handler::{
@ -7,13 +8,16 @@ use revm::{
        EthFrame, EthPrecompiles, EvmTr, FrameInitOrResult, FrameTr, PrecompileProvider,
    },
    inspector::{InspectorEvmTr, JournalExt},
-    interpreter::{interpreter::EthInterpreter, InterpreterResult},
+    interpreter::{interpreter::EthInterpreter, Instruction, InterpreterResult},
    Inspector,
 };

+use crate::chainspec::MAINNET_CHAIN_ID;
+
 pub mod builder;
 pub mod ctx;
 mod exec;
+mod patch;

 pub struct HlEvmInner<
    CTX: ContextTr,
@ -26,10 +30,22 @@ impl<CTX: ContextTr, INSP>
    HlEvmInner<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles>
 {
    pub fn new(ctx: CTX, inspector: INSP) -> Self {
+        let mut instruction = EthInstructions::new_mainnet();
+
+        const NON_PLACEHOLDER_BLOCK_HASH_HEIGHT: u64 = 243_538;
+        if ctx.chain_id() == MAINNET_CHAIN_ID &&
+            ctx.block_number() < NON_PLACEHOLDER_BLOCK_HASH_HEIGHT
+        {
+            instruction.insert_instruction(
+                BLOCKHASH,
+                Instruction::new(patch::blockhash_returning_placeholder, 20),
+            );
+        }
+
        Self(Evm {
            ctx,
            inspector,
-            instruction: EthInstructions::new_mainnet(),
+            instruction,
            precompiles: EthPrecompiles::default(),
            frame_stack: FrameStack::new(),
        })
@ -125,23 +141,3 @@ where
        self.0.frame_return_result(result)
    }
 }
-
-// #[cfg(test)]
-// mod test {
-//     use super::{builder::HlBuilder, ctx::DefaultHl};
-//     use revm::{
-//         inspector::{InspectEvm, NoOpInspector},
-//         Context, ExecuteEvm,
-//     };
-
-//     #[test]
-//     fn default_run_bsc() {
-//         let ctx = Context::bsc();
-//         let mut evm = ctx.build_bsc_with_inspector(NoOpInspector {});
-
-//         // execute
-//         let _ = evm.replay();
-//         // inspect
-//         let _ = evm.inspect_replay();
-//     }
-// }
--- a/src/evm/api/patch.rs
+++ b/src/evm/api/patch.rs
@ -0,0 +1,73 @@
+//! Modified version of `blockhash` instruction before block `243538`.
+//!
+//! This is a mainnet-specific fix for the `blockhash` instruction,
+//! copied and modified from revm-interpreter-25.0.1/src/instructions/host.rs.
+
+use alloy_primitives::keccak256;
+use revm::{
+    context::Host,
+    interpreter::{
+        as_u64_saturated, interpreter_types::StackTr, popn_top, InstructionContext,
+        InterpreterTypes,
+    },
+    primitives::{BLOCK_HASH_HISTORY, U256},
+};
+
+#[doc(hidden)]
+#[macro_export]
+#[collapse_debuginfo(yes)]
+macro_rules! _count {
+    (@count) => { 0 };
+    (@count $head:tt $($tail:tt)*) => { 1 + _count!(@count $($tail)*) };
+    ($($arg:tt)*) => { _count!(@count $($arg)*) };
+}
+
+/// Pops n values from the stack and returns the top value. Fails the instruction if n values can't
+/// be popped.
+#[macro_export]
+#[collapse_debuginfo(yes)]
+macro_rules! popn_top {
+    ([ $($x:ident),* ], $top:ident, $interpreter:expr $(,$ret:expr)? ) => {
+        // Workaround for https://github.com/rust-lang/rust/issues/144329.
+        if $interpreter.stack.len() < (1 + $crate::_count!($($x)*)) {
+            $interpreter.halt_underflow();
+            return $($ret)?;
+        }
+        let ([$( $x ),*], $top) = unsafe { $interpreter.stack.popn_top().unwrap_unchecked() };
+    };
+}
+
+/// Implements the BLOCKHASH instruction.
+///
+/// Gets the hash of one of the 256 most recent complete blocks.
+pub fn blockhash_returning_placeholder<WIRE: InterpreterTypes, H: Host + ?Sized>(
+    context: InstructionContext<'_, H, WIRE>,
+) {
+    //gas!(context.interpreter, gas::BLOCKHASH);
+    popn_top!([], number, context.interpreter);
+
+    let requested_number = *number;
+    let block_number = context.host.block_number();
+
+    let Some(diff) = block_number.checked_sub(requested_number) else {
+        *number = U256::ZERO;
+        return;
+    };
+
+    let diff = as_u64_saturated!(diff);
+
+    // blockhash should push zero if number is same as current block number.
+    if diff == 0 {
+        *number = U256::ZERO;
+        return;
+    }
+
+    *number = if diff <= BLOCK_HASH_HISTORY {
+        // NOTE: This is HL-specific modifcation that returns the placeholder hash before specific
+        // block.
+        let hash = keccak256(as_u64_saturated!(requested_number).to_string().as_bytes());
+        U256::from_be_bytes(hash.0)
+    } else {
+        U256::ZERO
+    }
+}
--- a/src/evm/spec.rs
+++ b/src/evm/spec.rs
@ -4,8 +4,6 @@ use std::str::FromStr;
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[allow(non_camel_case_types)]
-#[allow(clippy::upper_case_acronyms)]
 pub enum HlSpecId {
    #[default]
    V1, // V1
--- a/src/evm/transaction.rs
+++ b/src/evm/transaction.rs
@ -13,7 +13,7 @@ use revm::{
 #[auto_impl(&, &mut, Box, Arc)]
 pub trait HlTxTr: Transaction {}

-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct HlTxEnv<T: Transaction> {
    pub base: T,
@ -25,12 +25,6 @@ impl<T: Transaction> HlTxEnv<T> {
    }
 }

-impl Default for HlTxEnv<TxEnv> {
-    fn default() -> Self {
-        Self { base: TxEnv::default() }
-    }
-}
-
 impl<T: Transaction> Transaction for HlTxEnv<T> {
    type AccessListItem<'a>
        = T::AccessListItem<'a>
--- a/src/hl_node_compliance.rs
+++ b/src/hl_node_compliance.rs
@ -1,36 +1,36 @@
-/// We need to override the following methods:
-/// Filter:
-/// - eth_getLogs
-/// - eth_subscribe
-///
-/// Block (handled by HlEthApi already):
-/// - eth_getBlockByNumber/eth_getBlockByHash
-/// - eth_getBlockReceipts
-use crate::HlBlock;
-use alloy_consensus::TxReceipt;
+use alloy_consensus::{transaction::TransactionMeta, TxReceipt};
+use alloy_eips::{BlockId, BlockNumberOrTag};
+use alloy_json_rpc::RpcObject;
+use alloy_primitives::{B256, U256};
 use alloy_rpc_types::{
    pubsub::{Params, SubscriptionKind},
-    Filter, FilterChanges, FilterId, Log, PendingTransactionFilterKind,
+    BlockTransactions, Filter, FilterChanges, FilterId, Log, PendingTransactionFilterKind,
 };
-use jsonrpsee::{PendingSubscriptionSink, SubscriptionMessage, SubscriptionSink};
+use jsonrpsee::{proc_macros::rpc, PendingSubscriptionSink, SubscriptionMessage, SubscriptionSink};
 use jsonrpsee_core::{async_trait, RpcResult};
 use jsonrpsee_types::ErrorObject;
 use reth::{
    api::FullNodeComponents, builder::rpc::RpcContext, rpc::result::internal_rpc_err,
    tasks::TaskSpawner,
 };
-use reth_network::NetworkInfo;
-use reth_primitives::NodePrimitives;
-use reth_provider::{BlockIdReader, BlockReader, ReceiptProvider, TransactionsProvider};
+use reth_primitives_traits::{BlockBody as _, SignedTransaction};
+use reth_provider::{BlockIdReader, BlockReader, BlockReaderIdExt, ReceiptProvider};
 use reth_rpc::{EthFilter, EthPubSub};
 use reth_rpc_eth_api::{
-    EthApiServer, EthFilterApiServer, EthPubSubApiServer, FullEthApiTypes, RpcBlock, RpcHeader,
-    RpcNodeCore, RpcNodeCoreExt, RpcReceipt, RpcTransaction, RpcTxReq,
+    helpers::{EthBlocks, EthTransactions, LoadReceipt},
+    transaction::ConvertReceiptInput,
+    EthApiServer, EthApiTypes, EthFilterApiServer, EthPubSubApiServer, FullEthApiTypes, RpcBlock,
+    RpcConvert, RpcHeader, RpcNodeCoreExt, RpcReceipt, RpcTransaction, RpcTxReq,
 };
 use serde::Serialize;
-use std::sync::Arc;
+use std::{borrow::Cow, marker::PhantomData, sync::Arc};
 use tokio_stream::{Stream, StreamExt};
-use tracing::trace;
+use tracing::{info, trace, Instrument};
+
+use crate::{
+    node::primitives::{HlPrimitives, TransactionSigned},
+    HlBlock,
+};

 pub trait EthWrapper:
    EthApiServer<
@ -39,34 +39,30 @@ pub trait EthWrapper:
        RpcBlock<Self::NetworkTypes>,
        RpcReceipt<Self::NetworkTypes>,
        RpcHeader<Self::NetworkTypes>,
-    > + FullEthApiTypes
-    + RpcNodeCoreExt<
-        Provider: BlockIdReader + BlockReader<Block = HlBlock>,
-        Primitives: NodePrimitives<
-            SignedTx = <<Self as RpcNodeCore>::Provider as TransactionsProvider>::Transaction,
-        >,
-        Network: NetworkInfo,
-    > + 'static
+    > + FullEthApiTypes<Primitives = HlPrimitives>
+    + RpcNodeCoreExt<Provider: BlockReader<Block = HlBlock>>
+    + EthBlocks
+    + EthTransactions
+    + LoadReceipt
+    + 'static
 {
 }

-impl <
-    T:
-        EthApiServer<
+impl<
+        T: EthApiServer<
                RpcTxReq<Self::NetworkTypes>,
                RpcTransaction<Self::NetworkTypes>,
                RpcBlock<Self::NetworkTypes>,
                RpcReceipt<Self::NetworkTypes>,
                RpcHeader<Self::NetworkTypes>,
-        > + FullEthApiTypes
-        + RpcNodeCoreExt<
-            Provider: BlockIdReader + BlockReader<Block = HlBlock>,
-            Primitives: NodePrimitives<
-                SignedTx = <<Self as RpcNodeCore>::Provider as TransactionsProvider>::Transaction,
-            >,
-            Network: NetworkInfo,
-        > + 'static
-> EthWrapper for T {
+            > + FullEthApiTypes<Primitives = HlPrimitives>
+            + RpcNodeCoreExt<Provider: BlockReader<Block = HlBlock>>
+            + EthBlocks
+            + EthTransactions
+            + LoadReceipt
+            + 'static,
+    > EthWrapper for T
+{
 }

 pub struct HlNodeFilterHttp<Eth: EthWrapper> {
@ -138,7 +134,7 @@ impl<Eth: EthWrapper> EthFilterApiServer<RpcTransaction<Eth::NetworkTypes>>
        let logs = EthFilterApiServer::logs(&*self.filter, filter).await?;
        let provider = self.provider.clone();

-        Ok(logs.into_iter().filter_map(|log| exclude_system_tx::<Eth>(log, &provider)).collect())
+        Ok(logs.into_iter().filter_map(|log| adjust_log::<Eth>(log, &provider)).collect())
    }
 }

@ -184,9 +180,7 @@ impl<Eth: EthWrapper> EthPubSubApiServer<RpcTransaction<Eth::NetworkTypes>>
                };
                let _ = pipe_from_stream(
                    sink,
-                    pubsub
-                        .log_stream(filter)
-                        .filter_map(|log| exclude_system_tx::<Eth>(log, &provider)),
+                    pubsub.log_stream(filter).filter_map(|log| adjust_log::<Eth>(log, &provider)),
                )
                .await;
            } else {
@ -198,7 +192,7 @@ impl<Eth: EthWrapper> EthPubSubApiServer<RpcTransaction<Eth::NetworkTypes>>
    }
 }

-fn exclude_system_tx<Eth: EthWrapper>(mut log: Log, provider: &Eth::Provider) -> Option<Log> {
+fn adjust_log<Eth: EthWrapper>(mut log: Log, provider: &Eth::Provider) -> Option<Log> {
    let transaction_index = log.transaction_index?;
    let log_index = log.log_index?;

@ -283,6 +277,235 @@ where
    }
 }

+pub struct HlNodeBlockFilterHttp<Eth: EthWrapper> {
+    eth_api: Arc<Eth>,
+    _marker: PhantomData<Eth>,
+}
+
+impl<Eth: EthWrapper> HlNodeBlockFilterHttp<Eth> {
+    pub fn new(eth_api: Arc<Eth>) -> Self {
+        Self { eth_api, _marker: PhantomData }
+    }
+}
+
+#[rpc(server, namespace = "eth")]
+pub trait EthBlockApi<B: RpcObject, R: RpcObject> {
+    /// Returns information about a block by hash.
+    #[method(name = "getBlockByHash")]
+    async fn block_by_hash(&self, hash: B256, full: bool) -> RpcResult<Option<B>>;
+
+    /// Returns information about a block by number.
+    #[method(name = "getBlockByNumber")]
+    async fn block_by_number(&self, number: BlockNumberOrTag, full: bool) -> RpcResult<Option<B>>;
+
+    /// Returns all transaction receipts for a given block.
+    #[method(name = "getBlockReceipts")]
+    async fn block_receipts(&self, block_id: BlockId) -> RpcResult<Option<Vec<R>>>;
+
+    #[method(name = "getBlockTransactionCountByHash")]
+    async fn block_transaction_count_by_hash(&self, hash: B256) -> RpcResult<Option<U256>>;
+
+    #[method(name = "getBlockTransactionCountByNumber")]
+    async fn block_transaction_count_by_number(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> RpcResult<Option<U256>>;
+
+    #[method(name = "getTransactionReceipt")]
+    async fn transaction_receipt(&self, hash: B256) -> RpcResult<Option<R>>;
+}
+
+macro_rules! engine_span {
+    () => {
+        tracing::trace_span!(target: "rpc", "engine")
+    };
+}
+
+fn is_system_tx(tx: &TransactionSigned) -> bool {
+    tx.is_system_transaction()
+}
+
+fn adjust_block<Eth: EthWrapper>(
+    recovered_block: &RpcBlock<Eth::NetworkTypes>,
+    eth_api: &Eth,
+) -> RpcBlock<Eth::NetworkTypes> {
+    let system_tx_count = system_tx_count_for_block(eth_api, recovered_block.number().into());
+    let mut new_block = recovered_block.clone();
+
+    new_block.transactions = match new_block.transactions {
+        BlockTransactions::Full(mut transactions) => {
+            transactions.drain(..system_tx_count);
+            BlockTransactions::Full(transactions)
+        }
+        BlockTransactions::Hashes(mut hashes) => {
+            hashes.drain(..system_tx_count);
+            BlockTransactions::Hashes(hashes)
+        }
+        BlockTransactions::Uncle => BlockTransactions::Uncle,
+    };
+    new_block
+}
+
+async fn adjust_block_receipts<Eth: EthWrapper>(
+    block_id: BlockId,
+    eth_api: &Eth,
+) -> Result<Option<(usize, Vec<RpcReceipt<Eth::NetworkTypes>>)>, Eth::Error> {
+    // Modified from EthBlocks::block_receipt. See `NOTE` comment below.
+    let system_tx_count = system_tx_count_for_block(eth_api, block_id);
+    if let Some((block, receipts)) = EthBlocks::load_block_and_receipts(eth_api, block_id).await? {
+        let block_number = block.number;
+        let base_fee = block.base_fee_per_gas;
+        let block_hash = block.hash();
+        let excess_blob_gas = block.excess_blob_gas;
+        let timestamp = block.timestamp;
+        let mut gas_used = 0;
+        let mut next_log_index = 0;
+
+        let inputs = block
+            .transactions_recovered()
+            .zip(receipts.iter())
+            .enumerate()
+            .filter_map(|(idx, (tx, receipt))| {
+                if receipt.cumulative_gas_used() == 0 {
+                    // NOTE: modified to exclude system tx
+                    return None;
+                }
+                let meta = TransactionMeta {
+                    tx_hash: *tx.tx_hash(),
+                    index: (idx - system_tx_count) as u64,
+                    block_hash,
+                    block_number,
+                    base_fee,
+                    excess_blob_gas,
+                    timestamp,
+                };
+
+                let input = ConvertReceiptInput {
+                    receipt: Cow::Borrowed(receipt),
+                    tx,
+                    gas_used: receipt.cumulative_gas_used() - gas_used,
+                    next_log_index,
+                    meta,
+                };
+
+                gas_used = receipt.cumulative_gas_used();
+                next_log_index += receipt.logs().len();
+
+                Some(input)
+            })
+            .collect::<Vec<_>>();
+
+        return eth_api
+            .tx_resp_builder()
+            .convert_receipts(inputs)
+            .map(|receipts| Some((system_tx_count, receipts)));
+    }
+
+    Ok(None)
+}
+
+async fn adjust_transaction_receipt<Eth: EthWrapper>(
+    tx_hash: B256,
+    eth_api: &Eth,
+) -> Result<Option<RpcReceipt<Eth::NetworkTypes>>, Eth::Error> {
+    match eth_api.load_transaction_and_receipt(tx_hash).await? {
+        Some((_, meta, _)) => {
+            // LoadReceipt::block_transaction_receipt loads the block again, so loading blocks again doesn't hurt performance much
+            info!("block hash: {:?}", meta.block_hash);
+            let Some((system_tx_count, block_receipts)) =
+                adjust_block_receipts(meta.block_hash.into(), eth_api).await?
+            else {
+                unreachable!();
+            };
+            Ok(Some(block_receipts.into_iter().nth(meta.index as usize - system_tx_count).unwrap()))
+        }
+        None => Ok(None),
+    }
+}
+
+fn system_tx_count_for_block<Eth: EthWrapper>(eth_api: &Eth, block_id: BlockId) -> usize {
+    let provider = eth_api.provider();
+    let block = provider.block_by_id(block_id).unwrap().unwrap();
+    let system_tx_count = block.body.transactions().iter().filter(|tx| is_system_tx(tx)).count();
+    system_tx_count
+}
+
+#[async_trait]
+impl<Eth: EthWrapper> EthBlockApiServer<RpcBlock<Eth::NetworkTypes>, RpcReceipt<Eth::NetworkTypes>>
+    for HlNodeBlockFilterHttp<Eth>
+where
+    Eth: EthApiTypes + 'static,
+    ErrorObject<'static>: From<Eth::Error>,
+{
+    /// Handler for: `eth_getBlockByHash`
+    async fn block_by_hash(
+        &self,
+        hash: B256,
+        full: bool,
+    ) -> RpcResult<Option<RpcBlock<Eth::NetworkTypes>>> {
+        let res = self.eth_api.block_by_hash(hash, full).instrument(engine_span!()).await?;
+        Ok(res.map(|block| adjust_block(&block, &*self.eth_api)))
+    }
+
+    /// Handler for: `eth_getBlockByNumber`
+    async fn block_by_number(
+        &self,
+        number: BlockNumberOrTag,
+        full: bool,
+    ) -> RpcResult<Option<RpcBlock<Eth::NetworkTypes>>> {
+        trace!(target: "rpc::eth", ?number, ?full, "Serving eth_getBlockByNumber");
+        let res = self.eth_api.block_by_number(number, full).instrument(engine_span!()).await?;
+        Ok(res.map(|block| adjust_block(&block, &*self.eth_api)))
+    }
+
+    /// Handler for: `eth_getBlockTransactionCountByHash`
+    async fn block_transaction_count_by_hash(&self, hash: B256) -> RpcResult<Option<U256>> {
+        trace!(target: "rpc::eth", ?hash, "Serving eth_getBlockTransactionCountByHash");
+        let res =
+            self.eth_api.block_transaction_count_by_hash(hash).instrument(engine_span!()).await?;
+        Ok(res.map(|count| {
+            count
+                - U256::from(system_tx_count_for_block(&*self.eth_api, BlockId::Hash(hash.into())))
+        }))
+    }
+
+    /// Handler for: `eth_getBlockTransactionCountByNumber`
+    async fn block_transaction_count_by_number(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> RpcResult<Option<U256>> {
+        trace!(target: "rpc::eth", ?number, "Serving eth_getBlockTransactionCountByNumber");
+        let res = self
+            .eth_api
+            .block_transaction_count_by_number(number)
+            .instrument(engine_span!())
+            .await?;
+        Ok(res.map(|count| {
+            count - U256::from(system_tx_count_for_block(&*self.eth_api, number.into()))
+        }))
+    }
+
+    async fn transaction_receipt(
+        &self,
+        hash: B256,
+    ) -> RpcResult<Option<RpcReceipt<Eth::NetworkTypes>>> {
+        trace!(target: "rpc::eth", ?hash, "Serving eth_getTransactionReceipt");
+        let eth_api = &*self.eth_api;
+        Ok(adjust_transaction_receipt(hash, eth_api).instrument(engine_span!()).await?)
+    }
+
+    /// Handler for: `eth_getBlockReceipts`
+    async fn block_receipts(
+        &self,
+        block_id: BlockId,
+    ) -> RpcResult<Option<Vec<RpcReceipt<Eth::NetworkTypes>>>> {
+        trace!(target: "rpc::eth", ?block_id, "Serving eth_getBlockReceipts");
+        let result =
+            adjust_block_receipts(block_id, &*self.eth_api).instrument(engine_span!()).await?;
+        Ok(result.map(|(_, receipts)| receipts))
+    }
+}
+
 pub fn install_hl_node_compliance<Node, EthApi>(
    ctx: RpcContext<Node, EthApi>,
 ) -> Result<(), eyre::Error>
@ -290,6 +513,7 @@ where
    Node: FullNodeComponents,
    Node::Provider: BlockIdReader + BlockReader<Block = crate::HlBlock>,
    EthApi: EthWrapper,
+    ErrorObject<'static>: From<EthApi::Error>,
 {
    ctx.modules.replace_configured(
        HlNodeFilterHttp::new(
@ -306,5 +530,9 @@ where
        )
        .into_rpc(),
    )?;
+
+    ctx.modules.replace_configured(
+        HlNodeBlockFilterHttp::new(Arc::new(ctx.registry.eth_api().clone())).into_rpc(),
+    )?;
    Ok(())
 }
--- a/src/main.rs
+++ b/src/main.rs
@ -1,8 +1,11 @@
+use std::sync::Arc;
+
 use clap::Parser;
-use reth::builder::NodeHandle;
+use reth::builder::{NodeBuilder, NodeHandle, WithLaunchContext};
+use reth_db::DatabaseEnv;
 use reth_hl::{
    call_forwarder::{self, CallForwarderApiServer},
-    chainspec::parser::HlChainSpecParser,
+    chainspec::{parser::HlChainSpecParser, HlChainSpec},
    hl_node_compliance::install_hl_node_compliance,
    node::{
        cli::{Cli, HlNodeArgs},
@ -26,12 +29,12 @@ fn main() -> eyre::Result<()> {
        std::env::set_var("RUST_BACKTRACE", "1");
    }

-    Cli::<HlChainSpecParser, HlNodeArgs>::parse().run(|builder, ext| async move {
+    Cli::<HlChainSpecParser, HlNodeArgs>::parse().run(
+        |builder: WithLaunchContext<NodeBuilder<Arc<DatabaseEnv>, HlChainSpec>>,
+         ext: HlNodeArgs| async move {
            let default_upstream_rpc_url = builder.config().chain.official_rpc_url();
-        builder.builder.database.create_tables_for::<Tables>()?;

-        let (node, engine_handle_tx) =
-            HlNode::new(ext.block_source_args.parse().await?, ext.hl_node_compliant);
+            let (node, engine_handle_tx) = HlNode::new(ext.block_source_args.parse().await?);
            let NodeHandle { node, node_exit_future: exit_future } = builder
                .node(node)
                .extend_rpc_modules(move |ctx| {
@ -61,12 +64,17 @@ fn main() -> eyre::Result<()> {

                    Ok(())
                })
+                .apply(|builder| {
+                    builder.db().create_tables_for::<Tables>().expect("create tables");
+                    builder
+                })
                .launch()
                .await?;

            engine_handle_tx.send(node.beacon_engine_handle.clone()).unwrap();

            exit_future.await
-    })?;
+        },
+    )?;
    Ok(())
 }
--- a/src/node/cli.rs
+++ b/src/node/cli.rs
@ -1,8 +1,6 @@
 use crate::{
    chainspec::{parser::HlChainSpecParser, HlChainSpec},
-    node::{
-        consensus::HlConsensus, evm::config::HlEvmConfig, network::HlNetworkPrimitives, HlNode,
-    },
+    node::{consensus::HlConsensus, evm::config::HlEvmConfig, storage::tables::Tables, HlNode},
    pseudo_peer::BlockSourceArgs,
 };
 use clap::{Args, Parser};
@ -11,21 +9,26 @@ use reth::{
    builder::{NodeBuilder, WithLaunchContext},
    cli::Commands,
    prometheus_exporter::install_prometheus_recorder,
-    version::{LONG_VERSION, SHORT_VERSION},
+    version::version_metadata,
    CliRunner,
 };
 use reth_chainspec::EthChainSpec;
 use reth_cli::chainspec::ChainSpecParser;
-use reth_cli_commands::launcher::FnLauncher;
-use reth_db::DatabaseEnv;
+use reth_cli_commands::{common::EnvironmentArgs, launcher::FnLauncher};
+use reth_db::{init_db, mdbx::init_db_for, DatabaseEnv};
 use reth_tracing::FileWorkerGuard;
 use std::{
    fmt::{self},
-    future::Future,
    sync::Arc,
 };
 use tracing::info;

+macro_rules! not_applicable {
+    ($command:ident) => {
+        todo!("{} is not applicable for HL", stringify!($command))
+    };
+}
+
 #[derive(Debug, Clone, Args)]
 #[non_exhaustive]
 pub struct HlNodeArgs {
@ -58,7 +61,7 @@ pub struct HlNodeArgs {
 ///
 /// This is the entrypoint to the executable.
 #[derive(Debug, Parser)]
-#[command(author, version = SHORT_VERSION, long_version = LONG_VERSION, about = "Reth", long_about = None)]
+#[command(author, version =version_metadata().short_version.as_ref(), long_version = version_metadata().long_version.as_ref(), about = "Reth", long_about = None)]
 pub struct Cli<Spec: ChainSpecParser = HlChainSpecParser, Ext: clap::Args + fmt::Debug = HlNodeArgs>
 {
    /// The command to run
@ -78,20 +81,25 @@ where
    ///
    /// This accepts a closure that is used to launch the node via the
    /// [`NodeCommand`](reth_cli_commands::node::NodeCommand).
-    pub fn run<L, Fut>(self, launcher: L) -> eyre::Result<()>
-    where
-        L: FnOnce(WithLaunchContext<NodeBuilder<Arc<DatabaseEnv>, C::ChainSpec>>, Ext) -> Fut,
-        Fut: Future<Output = eyre::Result<()>>,
-    {
+    pub fn run(
+        self,
+        launcher: impl AsyncFnOnce(
+            WithLaunchContext<NodeBuilder<Arc<DatabaseEnv>, C::ChainSpec>>,
+            Ext,
+        ) -> eyre::Result<()>,
+    ) -> eyre::Result<()> {
        self.with_runner(CliRunner::try_default_runtime()?, launcher)
    }

    /// Execute the configured cli command with the provided [`CliRunner`].
-    pub fn with_runner<L, Fut>(mut self, runner: CliRunner, launcher: L) -> eyre::Result<()>
-    where
-        L: FnOnce(WithLaunchContext<NodeBuilder<Arc<DatabaseEnv>, C::ChainSpec>>, Ext) -> Fut,
-        Fut: Future<Output = eyre::Result<()>>,
-    {
+    pub fn with_runner(
+        mut self,
+        runner: CliRunner,
+        launcher: impl AsyncFnOnce(
+            WithLaunchContext<NodeBuilder<Arc<DatabaseEnv>, C::ChainSpec>>,
+            Ext,
+        ) -> eyre::Result<()>,
+    ) -> eyre::Result<()> {
        // Add network name if available to the logs dir
        if let Some(chain_spec) = self.command.chain_spec() {
            self.logs.log_file_directory =
@ -115,15 +123,14 @@ where
                runner.run_blocking_until_ctrl_c(command.execute::<HlNode>())
            }
            Commands::InitState(command) => {
+                // Need to invoke `init_db_for` to create `BlockReadPrecompileCalls` table
+                Self::init_db(&command.env)?;
                runner.run_blocking_until_ctrl_c(command.execute::<HlNode>())
            }
            Commands::DumpGenesis(command) => runner.run_blocking_until_ctrl_c(command.execute()),
            Commands::Db(command) => runner.run_blocking_until_ctrl_c(command.execute::<HlNode>()),
-            Commands::Stage(command) => runner.run_command_until_exit(|ctx| {
-                command.execute::<HlNode, _, _, HlNetworkPrimitives>(ctx, components)
-            }),
-            Commands::P2P(command) => {
-                runner.run_until_ctrl_c(command.execute::<HlNetworkPrimitives>())
+            Commands::Stage(command) => {
+                runner.run_command_until_exit(|ctx| command.execute::<HlNode, _>(ctx, components))
            }
            Commands::Config(command) => runner.run_until_ctrl_c(command.execute()),
            Commands::Recover(command) => {
@ -131,17 +138,15 @@ where
            }
            Commands::Prune(command) => runner.run_until_ctrl_c(command.execute::<HlNode>()),
            Commands::Import(command) => {
-                runner.run_blocking_until_ctrl_c(command.execute::<HlNode, _, _>(components))
+                runner.run_blocking_until_ctrl_c(command.execute::<HlNode, _>(components))
            }
-            Commands::Debug(_command) => todo!(),
+            Commands::P2P(_command) => not_applicable!(P2P),
+            Commands::ImportEra(_command) => not_applicable!(ImportEra),
+            Commands::Download(_command) => not_applicable!(Download),
+            Commands::ExportEra(_) => not_applicable!(ExportEra),
+            Commands::ReExecute(_) => not_applicable!(ReExecute),
            #[cfg(feature = "dev")]
-            Commands::TestVectors(_command) => todo!(),
-            Commands::ImportEra(_command) => {
-                todo!()
-            }
-            Commands::Download(_command) => {
-                todo!()
-            }
+            Commands::TestVectors(_command) => not_applicable!(TestVectors),
        }
    }

@ -153,4 +158,12 @@ where
        let guard = self.logs.init_tracing()?;
        Ok(guard)
    }
+
+    fn init_db(env: &EnvironmentArgs<C>) -> eyre::Result<()> {
+        let data_dir = env.datadir.clone().resolve_datadir(env.chain.chain());
+        let db_path = data_dir.db();
+        init_db(db_path.clone(), env.db.database_args())?;
+        init_db_for::<_, Tables>(db_path, env.db.database_args())?;
+        Ok(())
+    }
 }
--- a/src/node/consensus/mod.rs
+++ b/src/node/consensus/mod.rs
@ -1,4 +1,5 @@
 use crate::{hardforks::HlHardforks, node::HlNode, HlBlock, HlBlockBody, HlPrimitives};
+use alloy_consensus::Header;
 use reth::{
    api::FullNodeTypes,
    beacon_consensus::EthBeaconConsensus,
@ -39,7 +40,10 @@ pub struct HlConsensus<ChainSpec> {
    chain_spec: Arc<ChainSpec>,
 }

-impl<ChainSpec: EthChainSpec + HlHardforks> HlConsensus<ChainSpec> {
+impl<ChainSpec> HlConsensus<ChainSpec>
+where
+    ChainSpec: EthChainSpec + HlHardforks,
+{
    /// Create a new instance of [`HlConsensus`]
    pub fn new(chain_spec: Arc<ChainSpec>) -> Self {
        Self { inner: EthBeaconConsensus::new(chain_spec.clone()), chain_spec }
@ -62,15 +66,19 @@ pub fn validate_against_parent_timestamp<H: BlockHeader>(
    Ok(())
 }

-impl<ChainSpec: EthChainSpec + HlHardforks> HeaderValidator for HlConsensus<ChainSpec> {
-    fn validate_header(&self, header: &SealedHeader) -> Result<(), ConsensusError> {
+impl<H, ChainSpec> HeaderValidator<H> for HlConsensus<ChainSpec>
+where
+    H: BlockHeader,
+    ChainSpec: EthChainSpec<Header = H> + HlHardforks,
+{
+    fn validate_header(&self, header: &SealedHeader<H>) -> Result<(), ConsensusError> {
        self.inner.validate_header(header)
    }

    fn validate_header_against_parent(
        &self,
-        header: &SealedHeader,
-        parent: &SealedHeader,
+        header: &SealedHeader<H>,
+        parent: &SealedHeader<H>,
    ) -> Result<(), ConsensusError> {
        validate_against_parent_hash_number(header.header(), parent)?;

@ -83,7 +91,7 @@ impl<ChainSpec: EthChainSpec + HlHardforks> HeaderValidator for HlConsensus<Chai
        // )?;

        // ensure that the blob gas fields for this block
-        if let Some(blob_params) = self.chain_spec.blob_params_at_timestamp(header.timestamp) {
+        if let Some(blob_params) = self.chain_spec.blob_params_at_timestamp(header.timestamp()) {
            validate_against_parent_4844(header.header(), parent.header(), blob_params)?;
        }

@ -91,7 +99,10 @@ impl<ChainSpec: EthChainSpec + HlHardforks> HeaderValidator for HlConsensus<Chai
    }
 }

-impl<ChainSpec: EthChainSpec + HlHardforks> Consensus<HlBlock> for HlConsensus<ChainSpec> {
+impl<ChainSpec> Consensus<HlBlock> for HlConsensus<ChainSpec>
+where
+    ChainSpec: EthChainSpec<Header = Header> + HlHardforks,
+{
    type Error = ConsensusError;

    fn validate_body_against_header(
@ -135,8 +146,9 @@ impl<ChainSpec: EthChainSpec + HlHardforks> Consensus<HlBlock> for HlConsensus<C

 mod reth_copy;

-impl<ChainSpec: EthChainSpec<Header = alloy_consensus::Header> + HlHardforks>
-    FullConsensus<HlPrimitives> for HlConsensus<ChainSpec>
+impl<ChainSpec> FullConsensus<HlPrimitives> for HlConsensus<ChainSpec>
+where
+    ChainSpec: EthChainSpec<Header = Header> + HlHardforks,
 {
    fn validate_block_post_execution(
        &self,
--- a/src/node/evm/config.rs
+++ b/src/node/evm/config.rs
@ -6,12 +6,13 @@ use crate::{
    node::{
        evm::{executor::is_system_transaction, receipt_builder::RethReceiptBuilder},
        primitives::{BlockBody, TransactionSigned},
+        rpc::engine_api::validator::HlExecutionData,
        types::HlExtras,
    },
    HlBlock, HlBlockBody, HlPrimitives,
 };
 use alloy_consensus::{BlockHeader, Header, Transaction as _, TxReceipt, EMPTY_OMMER_ROOT_HASH};
-use alloy_eips::merge::BEACON_NONCE;
+use alloy_eips::{merge::BEACON_NONCE, Encodable2718};
 use alloy_primitives::{Log, U256};
 use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
 use reth_evm::{
@ -19,12 +20,13 @@ use reth_evm::{
    eth::{receipt_builder::ReceiptBuilder, EthBlockExecutionCtx},
    execute::{BlockAssembler, BlockAssemblerInput},
    precompiles::PrecompilesMap,
-    ConfigureEvm, EvmEnv, EvmFactory, ExecutionCtxFor, FromRecoveredTx, FromTxWithEncoded,
-    IntoTxEnv, NextBlockEnvAttributes,
+    ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, EvmFactory, ExecutableTxIterator,
+    ExecutionCtxFor, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, NextBlockEnvAttributes,
 };
 use reth_evm_ethereum::EthBlockAssembler;
+use reth_payload_primitives::NewPayloadError;
 use reth_primitives::{logs_bloom, BlockTy, HeaderTy, Receipt, SealedBlock, SealedHeader};
-use reth_primitives_traits::proofs;
+use reth_primitives_traits::{proofs, SignerRecoverable, WithEncoded};
 use reth_provider::BlockExecutionResult;
 use reth_revm::State;
 use revm::{
@ -407,6 +409,39 @@ where
    }
 }

+impl ConfigureEngineEvm<HlExecutionData> for HlEvmConfig {
+    fn evm_env_for_payload(&self, payload: &HlExecutionData) -> EvmEnvFor<Self> {
+        self.evm_env(&payload.0.header)
+    }
+
+    fn context_for_payload<'a>(&self, payload: &'a HlExecutionData) -> ExecutionCtxFor<'a, Self> {
+        let block = &payload.0;
+        let extras = HlExtras {
+            read_precompile_calls: block.body.read_precompile_calls.clone(),
+            highest_precompile_address: block.body.highest_precompile_address,
+        };
+        HlBlockExecutionCtx {
+            ctx: EthBlockExecutionCtx {
+                parent_hash: block.header.parent_hash,
+                parent_beacon_block_root: block.header.parent_beacon_block_root,
+                ommers: &block.body.ommers,
+                withdrawals: block.body.withdrawals.as_ref().map(Cow::Borrowed),
+            },
+            extras,
+        }
+    }
+
+    fn tx_iterator_for_payload(
+        &self,
+        payload: &HlExecutionData,
+    ) -> impl ExecutableTxIterator<Self> {
+        payload.0.body.transactions.clone().into_iter().map(move |tx| {
+            let recovered = tx.try_into_recovered().map_err(NewPayloadError::other)?;
+            Ok::<_, NewPayloadError>(WithEncoded::new(recovered.encoded_2718().into(), recovered))
+        })
+    }
+}
+
 /// Map the latest active hardfork at the given timestamp or block number to a [`HlSpecId`].
 pub fn revm_spec_by_timestamp_and_block_number(
    _chain_spec: impl HlHardforks,
--- a/src/node/evm/executor.rs
+++ b/src/node/evm/executor.rs
@ -72,7 +72,7 @@ fn run_precompile(

    match *get {
        ReadPrecompileResult::Ok { gas_used, ref bytes } => {
-            Ok(PrecompileOutput { gas_used, bytes: bytes.clone() })
+            Ok(PrecompileOutput { gas_used, bytes: bytes.clone(), reverted: false })
        }
        ReadPrecompileResult::OutOfGas => {
            // Use all the gas passed to this precompile
@ -181,7 +181,7 @@ where
        // Execute transaction.
        let ResultAndState { result, mut state } = self
            .evm
-            .transact(tx)
+            .transact(&tx)
            .map_err(|err| BlockExecutionError::evm(err, tx.tx().trie_hash()))?;

        if !f(&result).should_commit() {
--- a/src/node/evm/mod.rs
+++ b/src/node/evm/mod.rs
@ -12,7 +12,7 @@ use reth::{
    api::FullNodeTypes,
    builder::{components::ExecutorBuilder, BuilderContext},
 };
-use reth_evm::{Evm, EvmEnv};
+use reth_evm::{Database, Evm, EvmEnv};
 use revm::{
    context::{
        result::{EVMError, ExecutionResult, HaltReason, Output, ResultAndState, SuccessReason},
@ -21,7 +21,7 @@ use revm::{
    handler::{instructions::EthInstructions, EthPrecompiles, PrecompileProvider},
    interpreter::{interpreter::EthInterpreter, InterpreterResult},
    state::EvmState,
-    Context, Database, ExecuteEvm, InspectEvm, Inspector,
+    Context, ExecuteEvm, InspectEvm, Inspector,
 };
 use std::ops::{Deref, DerefMut};

@ -75,7 +75,6 @@ where
    DB: Database,
    I: Inspector<HlContext<DB>>,
    P: PrecompileProvider<HlContext<DB>, Output = InterpreterResult>,
-    <DB as revm::Database>::Error: std::marker::Send + std::marker::Sync + 'static,
 {
    type DB = DB;
    type Tx = HlTxEnv<TxEnv>;
@ -127,10 +126,6 @@ where
        ))
    }

-    fn db_mut(&mut self) -> &mut Self::DB {
-        &mut self.journaled_state.database
-    }
-
    fn finish(self) -> (Self::DB, EvmEnv<Self::Spec>) {
        let Context { block: block_env, cfg: cfg_env, journaled_state, .. } = self.inner.0.ctx;

@ -141,20 +136,20 @@ where
        self.inspect = enabled;
    }

-    fn precompiles_mut(&mut self) -> &mut Self::Precompiles {
-        &mut self.inner.0.precompiles
+    fn components(&self) -> (&Self::DB, &Self::Inspector, &Self::Precompiles) {
+        (
+            &self.inner.0.ctx.journaled_state.database,
+            &self.inner.0.inspector,
+            &self.inner.0.precompiles,
+        )
    }

-    fn inspector_mut(&mut self) -> &mut Self::Inspector {
-        &mut self.inner.0.inspector
-    }
-
-    fn precompiles(&self) -> &Self::Precompiles {
-        &self.inner.0.precompiles
-    }
-
-    fn inspector(&self) -> &Self::Inspector {
-        &self.inner.0.inspector
+    fn components_mut(&mut self) -> (&mut Self::DB, &mut Self::Inspector, &mut Self::Precompiles) {
+        (
+            &mut self.inner.0.ctx.journaled_state.database,
+            &mut self.inner.0.inspector,
+            &mut self.inner.0.precompiles,
+        )
    }
 }

--- a/src/node/mod.rs
+++ b/src/node/mod.rs
@ -2,11 +2,11 @@ use crate::{
    chainspec::HlChainSpec,
    node::{
        pool::HlPoolBuilder,
-        primitives::{BlockBody, HlBlock, HlBlockBody, HlPrimitives, TransactionSigned},
+        primitives::{HlBlock, HlPrimitives},
        rpc::{
            engine_api::{
                builder::HlEngineApiBuilder, payload::HlPayloadTypes,
-                validator::HlEngineValidatorBuilder,
+                validator::HlPayloadValidatorBuilder,
            },
            HlEthApiBuilder,
        },
@ -19,15 +19,11 @@ use engine::HlPayloadServiceBuilder;
 use evm::HlExecutorBuilder;
 use network::HlNetworkBuilder;
 use reth::{
-    api::{FullNodeComponents, FullNodeTypes, NodeTypes},
-    builder::{
-        components::ComponentsBuilder, rpc::RpcAddOns, DebugNode, Node, NodeAdapter,
-        NodeComponentsBuilder,
-    },
+    api::{FullNodeTypes, NodeTypes},
+    builder::{components::ComponentsBuilder, rpc::RpcAddOns, Node, NodeAdapter},
 };
-use reth_engine_primitives::BeaconConsensusEngineHandle;
-use reth_trie_db::MerklePatriciaTrie;
-use std::sync::Arc;
+use reth_engine_primitives::ConsensusEngineHandle;
+use std::{marker::PhantomData, sync::Arc};
 use tokio::sync::{oneshot, Mutex};

 pub mod cli;
@ -43,31 +39,21 @@ pub mod types;

 /// Hl addons configuring RPC types
 pub type HlNodeAddOns<N> =
-    RpcAddOns<N, HlEthApiBuilder, HlEngineValidatorBuilder, HlEngineApiBuilder>;
+    RpcAddOns<N, HlEthApiBuilder, HlPayloadValidatorBuilder, HlEngineApiBuilder>;

 /// Type configuration for a regular Hl node.
 #[derive(Debug, Clone)]
 pub struct HlNode {
-    engine_handle_rx:
-        Arc<Mutex<Option<oneshot::Receiver<BeaconConsensusEngineHandle<HlPayloadTypes>>>>>,
+    engine_handle_rx: Arc<Mutex<Option<oneshot::Receiver<ConsensusEngineHandle<HlPayloadTypes>>>>>,
    block_source_config: BlockSourceConfig,
-    hl_node_compliant: bool,
 }

 impl HlNode {
    pub fn new(
        block_source_config: BlockSourceConfig,
-        hl_node_compliant: bool,
-    ) -> (Self, oneshot::Sender<BeaconConsensusEngineHandle<HlPayloadTypes>>) {
+    ) -> (Self, oneshot::Sender<ConsensusEngineHandle<HlPayloadTypes>>) {
        let (tx, rx) = oneshot::channel();
-        (
-            Self {
-                engine_handle_rx: Arc::new(Mutex::new(Some(rx))),
-                block_source_config,
-                hl_node_compliant,
-            },
-            tx,
-        )
+        (Self { engine_handle_rx: Arc::new(Mutex::new(Some(rx))), block_source_config }, tx)
    }
 }

@ -103,7 +89,6 @@ impl HlNode {
 impl NodeTypes for HlNode {
    type Primitives = HlPrimitives;
    type ChainSpec = HlChainSpec;
-    type StateCommitment = MerklePatriciaTrie;
    type Storage = HlStorage;
    type Payload = HlPayloadTypes;
 }
@ -121,9 +106,7 @@ where
        HlConsensusBuilder,
    >;

-    type AddOns = HlNodeAddOns<
-        NodeAdapter<N, <Self::ComponentsBuilder as NodeComponentsBuilder<N>>::Components>,
-    >;
+    type AddOns = HlNodeAddOns<NodeAdapter<N>>;

    fn components_builder(&self) -> Self::ComponentsBuilder {
        Self::components(self)
@ -131,37 +114,11 @@ where

    fn add_ons(&self) -> Self::AddOns {
        HlNodeAddOns::new(
-            HlEthApiBuilder { hl_node_compliant: self.hl_node_compliant },
+            HlEthApiBuilder { _nt: PhantomData },
+            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
        )
    }
 }
-
-impl<N> DebugNode<N> for HlNode
-where
-    N: FullNodeComponents<Types = Self>,
-{
-    type RpcBlock = alloy_rpc_types::Block;
-
-    fn rpc_to_primitive_block(rpc_block: Self::RpcBlock) -> HlBlock {
-        let alloy_rpc_types::Block { header, transactions, withdrawals, .. } = rpc_block;
-        HlBlock {
-            header: header.inner,
-            body: HlBlockBody {
-                inner: BlockBody {
-                    transactions: transactions
-                        .into_transactions()
-                        .map(|tx| TransactionSigned::Default(tx.inner.into_inner().into()))
-                        .collect(),
-                    ommers: Default::default(),
-                    withdrawals,
-                },
-                sidecars: None,
-                read_precompile_calls: None,
-                highest_precompile_address: None,
-            },
-        }
-    }
-}
--- a/src/node/network/block_import/service.rs
+++ b/src/node/network/block_import/service.rs
@ -12,7 +12,7 @@ use alloy_consensus::{BlockBody, Header};
 use alloy_primitives::U128;
 use alloy_rpc_types::engine::{ForkchoiceState, PayloadStatusEnum};
 use futures::{future::Either, stream::FuturesUnordered, StreamExt};
-use reth_engine_primitives::{BeaconConsensusEngineHandle, EngineTypes};
+use reth_engine_primitives::{ConsensusEngineHandle, EngineTypes};
 use reth_eth_wire::NewBlock;
 use reth_network::{
    import::{BlockImportError, BlockImportEvent, BlockImportOutcome, BlockValidation},
@ -55,7 +55,7 @@ where
    Provider: BlockNumReader + Clone,
 {
    /// The handle to communicate with the engine service
-    engine: BeaconConsensusEngineHandle<HlPayloadTypes>,
+    engine: ConsensusEngineHandle<HlPayloadTypes>,
    /// The consensus implementation
    consensus: Arc<HlConsensus<Provider>>,
    /// Receive the new block from the network
@ -73,7 +73,7 @@ where
    /// Create a new block import service
    pub fn new(
        consensus: Arc<HlConsensus<Provider>>,
-        engine: BeaconConsensusEngineHandle<HlPayloadTypes>,
+        engine: ConsensusEngineHandle<HlPayloadTypes>,
        from_network: UnboundedReceiver<IncomingBlock>,
        to_network: UnboundedSender<ImportEvent>,
    ) -> Self {
@ -341,7 +341,7 @@ mod tests {
        async fn new(responses: EngineResponses) -> Self {
            let consensus = Arc::new(HlConsensus { provider: MockProvider });
            let (to_engine, from_engine) = mpsc::unbounded_channel();
-            let engine_handle = BeaconConsensusEngineHandle::new(to_engine);
+            let engine_handle = ConsensusEngineHandle::new(to_engine);

            handle_engine_msg(from_engine, responses).await;

--- a/src/node/network/mod.rs
+++ b/src/node/network/mod.rs
@ -19,7 +19,7 @@ use reth::{
    transaction_pool::{PoolTransaction, TransactionPool},
 };
 use reth_discv4::NodeRecord;
-use reth_engine_primitives::BeaconConsensusEngineHandle;
+use reth_engine_primitives::ConsensusEngineHandle;
 use reth_eth_wire::{BasicNetworkPrimitives, NewBlock, NewBlockPayload};
 use reth_ethereum_primitives::PooledTransactionVariant;
 use reth_network::{NetworkConfig, NetworkHandle, NetworkManager};
@ -31,8 +31,7 @@ use tokio::sync::{mpsc, oneshot, Mutex};
 use tracing::info;

 pub mod block_import;
-// pub mod handshake;
-// pub(crate) mod upgrade_status;
+
 /// HL `NewBlock` message value.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct HlNewBlock(pub NewBlock<HlBlock>);
@ -157,7 +156,7 @@ pub type HlNetworkPrimitives =
 #[derive(Debug)]
 pub struct HlNetworkBuilder {
    pub(crate) engine_handle_rx:
-        Arc<Mutex<Option<oneshot::Receiver<BeaconConsensusEngineHandle<HlPayloadTypes>>>>>,
+        Arc<Mutex<Option<oneshot::Receiver<ConsensusEngineHandle<HlPayloadTypes>>>>>,

    pub(crate) block_source_config: BlockSourceConfig,
 }
@ -237,13 +236,16 @@ where
        let chain_spec = ctx.chain_spec();
        info!(target: "reth::cli", enode=%local_node_record, "P2P networking initialized");

-        let next_block_number =
-            ctx.provider().get_stage_checkpoint(StageId::Finish)?.unwrap_or_default().block_number
-                + 1;
+        let next_block_number = ctx
+            .provider()
+            .get_stage_checkpoint(StageId::Finish)?
+            .unwrap_or_default()
+            .block_number +
+            1;

        ctx.task_executor().spawn_critical("pseudo peer", async move {
            let block_source =
-                block_source_config.create_cached_block_source(next_block_number).await;
+                block_source_config.create_cached_block_source((&*chain_spec).clone(), next_block_number).await;
            start_pseudo_peer(chain_spec, local_node_record.to_string(), block_source)
                .await
                .unwrap();
--- a/src/node/pool.rs
+++ b/src/node/pool.rs
@ -10,43 +10,30 @@ use crate::node::{primitives::TransactionSigned, HlNode};
 use alloy_consensus::{
    error::ValueError, EthereumTxEnvelope, Transaction as TransactionTrait, TxEip4844,
 };
-use alloy_eips::{
-    eip4844::BlobAndProofV2, eip7594::BlobTransactionSidecarVariant, eip7702::SignedAuthorization,
-    Typed2718,
-};
+use alloy_eips::{eip7702::SignedAuthorization, Typed2718};
 use alloy_primitives::{Address, Bytes, ChainId, TxHash, TxKind, B256, U256};
 use alloy_rpc_types::AccessList;
-use alloy_rpc_types_engine::BlobAndProofV1;
 use reth::{
-    api::FullNodeTypes,
-    builder::components::PoolBuilder,
-    transaction_pool::{PoolResult, PoolSize, PoolTransaction, TransactionOrigin, TransactionPool},
+    api::FullNodeTypes, builder::components::PoolBuilder, transaction_pool::PoolTransaction,
 };
-use reth_eth_wire::HandleMempoolData;
 use reth_ethereum_primitives::PooledTransactionVariant;
 use reth_primitives::Recovered;
 use reth_primitives_traits::InMemorySize;
-use reth_transaction_pool::{
-    error::InvalidPoolTransactionError, AllPoolTransactions, AllTransactionsEvents,
-    BestTransactions, BestTransactionsAttributes, BlobStoreError, BlockInfo, EthPoolTransaction,
-    GetPooledTransactionLimit, NewBlobSidecar, NewTransactionEvent, PropagatedTransactions,
-    TransactionEvents, TransactionListenerKind, ValidPoolTransaction,
-};
-use std::{collections::HashSet, sync::Arc};
-use tokio::sync::mpsc::{self, Receiver};
+use reth_transaction_pool::{noop::NoopTransactionPool, EthPoolTransaction};
+use std::sync::Arc;

 pub struct HlPoolBuilder;
 impl<Node> PoolBuilder<Node> for HlPoolBuilder
 where
    Node: FullNodeTypes<Types = HlNode>,
 {
-    type Pool = HlTransactionPool;
+    type Pool = NoopTransactionPool<HlPooledTransaction>;

    async fn build_pool(
        self,
        _ctx: &reth::builder::BuilderContext<Node>,
    ) -> eyre::Result<Self::Pool> {
-        Ok(HlTransactionPool)
+        Ok(NoopTransactionPool::new())
    }
 }

@ -124,16 +111,6 @@ impl PoolTransaction for HlPooledTransaction {
    type Consensus = TransactionSigned;
    type Pooled = PooledTransactionVariant;

-    fn try_from_consensus(
-        _tx: Recovered<Self::Consensus>,
-    ) -> Result<Self, Self::TryFromConsensusError> {
-        unreachable!()
-    }
-
-    fn clone_into_consensus(&self) -> Recovered<Self::Consensus> {
-        unreachable!()
-    }
-
    fn into_consensus(self) -> Recovered<Self::Consensus> {
        unreachable!()
    }
@ -161,13 +138,6 @@ impl PoolTransaction for HlPooledTransaction {
    fn encoded_length(&self) -> usize {
        0
    }
-
-    fn ensure_max_init_code_size(
-        &self,
-        _max_init_code_size: usize,
-    ) -> Result<(), InvalidPoolTransactionError> {
-        Ok(())
-    }
 }

 impl EthPoolTransaction for HlPooledTransaction {
@ -197,243 +167,3 @@ impl EthPoolTransaction for HlPooledTransaction {
        Ok(())
    }
 }
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct HlTransactionPool;
-impl TransactionPool for HlTransactionPool {
-    type Transaction = HlPooledTransaction;
-
-    fn pool_size(&self) -> PoolSize {
-        PoolSize::default()
-    }
-
-    fn block_info(&self) -> BlockInfo {
-        BlockInfo::default()
-    }
-
-    async fn add_transaction_and_subscribe(
-        &self,
-        _origin: TransactionOrigin,
-        _transaction: Self::Transaction,
-    ) -> PoolResult<TransactionEvents> {
-        unreachable!()
-    }
-
-    async fn add_transaction(
-        &self,
-        _origin: TransactionOrigin,
-        _transaction: Self::Transaction,
-    ) -> PoolResult<TxHash> {
-        Ok(TxHash::default())
-    }
-
-    async fn add_transactions(
-        &self,
-        _origin: TransactionOrigin,
-        _transactions: Vec<Self::Transaction>,
-    ) -> Vec<PoolResult<TxHash>> {
-        vec![]
-    }
-
-    fn transaction_event_listener(&self, _tx_hash: TxHash) -> Option<TransactionEvents> {
-        None
-    }
-
-    fn all_transactions_event_listener(&self) -> AllTransactionsEvents<Self::Transaction> {
-        unreachable!()
-    }
-
-    fn pending_transactions_listener_for(
-        &self,
-        _kind: TransactionListenerKind,
-    ) -> Receiver<TxHash> {
-        mpsc::channel(1).1
-    }
-
-    fn blob_transaction_sidecars_listener(&self) -> Receiver<NewBlobSidecar> {
-        mpsc::channel(1).1
-    }
-
-    fn new_transactions_listener_for(
-        &self,
-        _kind: TransactionListenerKind,
-    ) -> Receiver<NewTransactionEvent<Self::Transaction>> {
-        mpsc::channel(1).1
-    }
-    fn pooled_transaction_hashes(&self) -> Vec<TxHash> {
-        vec![]
-    }
-    fn pooled_transaction_hashes_max(&self, _max: usize) -> Vec<TxHash> {
-        vec![]
-    }
-    fn pooled_transactions(&self) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn pooled_transactions_max(
-        &self,
-        _max: usize,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn get_pooled_transaction_elements(
-        &self,
-        _tx_hashes: Vec<TxHash>,
-        _limit: GetPooledTransactionLimit,
-    ) -> Vec<<Self::Transaction as PoolTransaction>::Pooled> {
-        vec![]
-    }
-    fn get_pooled_transaction_element(
-        &self,
-        _tx_hash: TxHash,
-    ) -> Option<Recovered<<Self::Transaction as PoolTransaction>::Pooled>> {
-        None
-    }
-    fn best_transactions(
-        &self,
-    ) -> Box<dyn BestTransactions<Item = Arc<ValidPoolTransaction<Self::Transaction>>>> {
-        Box::new(std::iter::empty())
-    }
-    fn best_transactions_with_attributes(
-        &self,
-        _best_transactions_attributes: BestTransactionsAttributes,
-    ) -> Box<dyn BestTransactions<Item = Arc<ValidPoolTransaction<Self::Transaction>>>> {
-        Box::new(std::iter::empty())
-    }
-    fn pending_transactions(&self) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn pending_transactions_max(
-        &self,
-        _max: usize,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn queued_transactions(&self) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn all_transactions(&self) -> AllPoolTransactions<Self::Transaction> {
-        AllPoolTransactions::default()
-    }
-    fn remove_transactions(
-        &self,
-        _hashes: Vec<TxHash>,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn remove_transactions_and_descendants(
-        &self,
-        _hashes: Vec<TxHash>,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn remove_transactions_by_sender(
-        &self,
-        _sender: Address,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn retain_unknown<A>(&self, _announcement: &mut A)
-    where
-        A: HandleMempoolData,
-    {
-        // do nothing
-    }
-    fn get(&self, _tx_hash: &TxHash) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        None
-    }
-    fn get_all(&self, _txs: Vec<TxHash>) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn on_propagated(&self, _txs: PropagatedTransactions) {
-        // do nothing
-    }
-    fn get_transactions_by_sender(
-        &self,
-        _sender: Address,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn get_pending_transactions_with_predicate(
-        &self,
-        _predicate: impl FnMut(&ValidPoolTransaction<Self::Transaction>) -> bool,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn get_pending_transactions_by_sender(
-        &self,
-        _sender: Address,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        vec![]
-    }
-    fn get_queued_transactions_by_sender(
-        &self,
-        _sender: Address,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        unreachable!()
-    }
-    fn get_highest_transaction_by_sender(
-        &self,
-        _sender: Address,
-    ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        None
-    }
-    fn get_highest_consecutive_transaction_by_sender(
-        &self,
-        _sender: Address,
-        _on_chain_nonce: u64,
-    ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        None
-    }
-    fn get_transaction_by_sender_and_nonce(
-        &self,
-        _sender: Address,
-        _nonce: u64,
-    ) -> Option<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        None
-    }
-    fn get_transactions_by_origin(
-        &self,
-        _origin: TransactionOrigin,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        unreachable!()
-    }
-    fn get_pending_transactions_by_origin(
-        &self,
-        _origin: TransactionOrigin,
-    ) -> Vec<Arc<ValidPoolTransaction<Self::Transaction>>> {
-        unreachable!()
-    }
-    fn unique_senders(&self) -> HashSet<Address> {
-        unreachable!()
-    }
-    fn get_blob(
-        &self,
-        _tx_hash: TxHash,
-    ) -> Result<Option<Arc<BlobTransactionSidecarVariant>>, BlobStoreError> {
-        unreachable!()
-    }
-    fn get_all_blobs(
-        &self,
-        _tx_hashes: Vec<TxHash>,
-    ) -> Result<Vec<(TxHash, Arc<BlobTransactionSidecarVariant>)>, BlobStoreError> {
-        unreachable!()
-    }
-    fn get_all_blobs_exact(
-        &self,
-        _tx_hashes: Vec<TxHash>,
-    ) -> Result<Vec<Arc<BlobTransactionSidecarVariant>>, BlobStoreError> {
-        unreachable!()
-    }
-    fn get_blobs_for_versioned_hashes_v1(
-        &self,
-        _versioned_hashes: &[B256],
-    ) -> Result<Vec<Option<BlobAndProofV1>>, BlobStoreError> {
-        unreachable!()
-    }
-    fn get_blobs_for_versioned_hashes_v2(
-        &self,
-        _versioned_hashes: &[B256],
-    ) -> Result<Option<Vec<BlobAndProofV2>>, BlobStoreError> {
-        unreachable!()
-    }
-}
--- a/src/node/primitives/tx_wrapper.rs
+++ b/src/node/primitives/tx_wrapper.rs
@ -1,11 +1,12 @@
 //! HlNodePrimitives::TransactionSigned; it's the same as ethereum transaction type,
 //! except that it supports pseudo signer for system transactions.
 use alloy_consensus::{
-    crypto::RecoveryError, error::ValueError, EthereumTxEnvelope, SignableTransaction, Signed,
-    Transaction as TransactionTrait, TransactionEnvelope, TxEip1559, TxEip2930, TxEip4844,
-    TxEip4844WithSidecar, TxEip7702, TxLegacy, TxType, TypedTransaction,
+    crypto::RecoveryError, error::ValueError, EthereumTxEnvelope, EthereumTypedTransaction,
+    SignableTransaction, Signed, Transaction as TransactionTrait, TransactionEnvelope, TxEip1559,
+    TxEip2930, TxEip4844, TxEip4844WithSidecar, TxEip7702, TxLegacy, TxType, TypedTransaction,
 };
 use alloy_eips::{eip7594::BlobTransactionSidecarVariant, Encodable2718};
+use alloy_network::TxSigner;
 use alloy_primitives::{address, Address, TxHash, U256};
 use alloy_rpc_types::{Transaction, TransactionInfo, TransactionRequest};
 use alloy_signer::Signature;
@ -21,7 +22,7 @@ use reth_primitives_traits::{
 };
 use reth_rpc_eth_api::{
    transaction::{FromConsensusTx, TryIntoTxEnv},
-    EthTxEnvError, TryIntoSimTx,
+    EthTxEnvError, SignTxRequestError, SignableTxRequest, TryIntoSimTx,
 };
 use revm::context::{BlockEnv, CfgEnv, TxEnv};

@ -59,22 +60,19 @@ impl SignerRecoverable for TransactionSigned {
        }
        self.inner().recover_signer_unchecked()
    }
+
+    fn recover_unchecked_with_buf(&self, buf: &mut Vec<u8>) -> Result<Address, RecoveryError> {
+        if self.is_system_transaction() {
+            return Ok(s_to_address(self.signature().s()));
+        }
+        self.inner().recover_unchecked_with_buf(buf)
+    }
 }

 impl SignedTransaction for TransactionSigned {
    fn tx_hash(&self) -> &TxHash {
        self.inner().tx_hash()
    }
-
-    fn recover_signer_unchecked_with_buf(
-        &self,
-        buf: &mut Vec<u8>,
-    ) -> Result<Address, RecoveryError> {
-        if self.is_system_transaction() {
-            return Ok(s_to_address(self.signature().s()));
-        }
-        self.inner().recover_signer_unchecked_with_buf(buf)
-    }
 }

 // ------------------------------------------------------------
@ -296,3 +294,32 @@ impl FromConsensusTx<TransactionSigned> for Transaction {
        Self::from_transaction(Recovered::new_unchecked(tx.into_inner().into(), signer), tx_info)
    }
 }
+
+impl SignableTxRequest<TransactionSigned> for TransactionRequest {
+    async fn try_build_and_sign(
+        self,
+        signer: impl TxSigner<Signature> + Send,
+    ) -> Result<TransactionSigned, SignTxRequestError> {
+        let mut tx =
+            self.build_typed_tx().map_err(|_| SignTxRequestError::InvalidTransactionRequest)?;
+        let signature = signer.sign_transaction(&mut tx).await?;
+        let signed = match tx {
+            EthereumTypedTransaction::Legacy(tx) => {
+                EthereumTxEnvelope::Legacy(tx.into_signed(signature))
+            }
+            EthereumTypedTransaction::Eip2930(tx) => {
+                EthereumTxEnvelope::Eip2930(tx.into_signed(signature))
+            }
+            EthereumTypedTransaction::Eip1559(tx) => {
+                EthereumTxEnvelope::Eip1559(tx.into_signed(signature))
+            }
+            EthereumTypedTransaction::Eip4844(tx) => {
+                EthereumTxEnvelope::Eip4844(TxEip4844::from(tx).into_signed(signature))
+            }
+            EthereumTypedTransaction::Eip7702(tx) => {
+                EthereumTxEnvelope::Eip7702(tx.into_signed(signature))
+            }
+        };
+        Ok(TransactionSigned::Default(signed))
+    }
+}
--- a/src/node/rpc/block.rs
+++ b/src/node/rpc/block.rs
@ -1,263 +1,56 @@
-use std::{future::Future, sync::Arc};
-
-use crate::{
-    chainspec::HlChainSpec,
-    node::{
-        primitives::TransactionSigned,
-        rpc::{HlEthApi, HlNodeCore},
-    },
-    HlBlock,
-};
-use alloy_consensus::{BlockHeader, ReceiptEnvelope, TxType};
-use alloy_primitives::B256;
-use reth::{
-    api::NodeTypes,
-    builder::FullNodeComponents,
-    primitives::{Receipt, SealedHeader, TransactionMeta},
-    providers::{BlockReaderIdExt, ProviderHeader, ReceiptProvider, TransactionsProvider},
-    rpc::{
-        eth::EthApiTypes,
-        server_types::eth::{
-            error::FromEvmError, receipt::build_receipt, EthApiError, PendingBlock,
-        },
-        types::{BlockId, TransactionReceipt},
-    },
-    transaction_pool::{PoolTransaction, TransactionPool},
-};
-use reth_chainspec::{EthChainSpec, EthereumHardforks};
-use reth_evm::{ConfigureEvm, NextBlockEnvAttributes};
-use reth_primitives::{NodePrimitives, SealedBlock};
-use reth_primitives_traits::{BlockBody as _, RecoveredBlock, SignedTransaction as _};
-use reth_provider::{
-    BlockIdReader, BlockReader, ChainSpecProvider, HeaderProvider, ProviderBlock, ProviderReceipt,
-    ProviderTx, StateProviderFactory,
+use crate::node::rpc::HlEthApi;
+use reth::rpc::server_types::eth::{
+    builder::config::PendingBlockKind, error::FromEvmError, EthApiError, PendingBlock,
 };
 use reth_rpc_eth_api::{
-    helpers::{EthBlocks, LoadBlock, LoadPendingBlock, LoadReceipt, SpawnBlocking},
-    types::RpcTypes,
-    FromEthApiError, RpcConvert, RpcNodeCore, RpcNodeCoreExt, RpcReceipt,
+    helpers::{
+        pending_block::PendingEnvBuilder, EthBlocks, LoadBlock, LoadPendingBlock, LoadReceipt,
+    },
+    RpcConvert, RpcNodeCore,
 };

-fn is_system_tx(tx: &TransactionSigned) -> bool {
-    tx.is_system_transaction()
-}
-
-impl<N> EthBlocks for HlEthApi<N>
+impl<N, Rpc> EthBlocks for HlEthApi<N, Rpc>
 where
-    Self: LoadBlock<
-        Error = EthApiError,
-        NetworkTypes: RpcTypes<Receipt = TransactionReceipt>,
-        Provider: BlockReader<Transaction = TransactionSigned, Receipt = Receipt>,
-    >,
-    N: HlNodeCore<Provider: ChainSpecProvider<ChainSpec = HlChainSpec> + HeaderProvider>,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
-    async fn block_receipts(
-        &self,
-        block_id: BlockId,
-    ) -> Result<Option<Vec<RpcReceipt<Self::NetworkTypes>>>, Self::Error>
-    where
-        Self: LoadReceipt,
-    {
-        if let Some((block, receipts)) = self.load_block_and_receipts(block_id).await? {
-            let block_number = block.number();
-            let base_fee = block.base_fee_per_gas();
-            let block_hash = block.hash();
-            let excess_blob_gas = block.excess_blob_gas();
-            let timestamp = block.timestamp();
-            let blob_params = self.provider().chain_spec().blob_params_at_timestamp(timestamp);
-
-            return block
-                .body()
-                .transactions()
-                .iter()
-                .zip(receipts.iter())
-                .filter(|(tx, _)| !is_system_tx(tx))
-                .enumerate()
-                .map(|(idx, (tx, receipt))| {
-                    let meta = TransactionMeta {
-                        tx_hash: *tx.tx_hash(),
-                        index: idx as u64,
-                        block_hash,
-                        block_number,
-                        base_fee,
-                        excess_blob_gas,
-                        timestamp,
-                    };
-                    build_receipt(tx, meta, receipt, &receipts, blob_params, |receipt_with_bloom| {
-                        match receipt.tx_type {
-                            TxType::Legacy => ReceiptEnvelope::Legacy(receipt_with_bloom),
-                            TxType::Eip2930 => ReceiptEnvelope::Eip2930(receipt_with_bloom),
-                            TxType::Eip1559 => ReceiptEnvelope::Eip1559(receipt_with_bloom),
-                            TxType::Eip4844 => ReceiptEnvelope::Eip4844(receipt_with_bloom),
-                            TxType::Eip7702 => ReceiptEnvelope::Eip7702(receipt_with_bloom),
-                        }
-                    })
-                })
-                .collect::<Result<Vec<_>, Self::Error>>()
-                .map(Some);
-        }
-
-        Ok(None)
-    }
 }

-impl<N> LoadBlock for HlEthApi<N>
+impl<N, Rpc> LoadBlock for HlEthApi<N, Rpc>
 where
-    Self: LoadPendingBlock
-        + SpawnBlocking
-        + RpcNodeCoreExt<
-            Pool: TransactionPool<
-                Transaction: PoolTransaction<Consensus = ProviderTx<Self::Provider>>,
-            >,
-        > + RpcNodeCore<Provider: BlockReader<Block = crate::HlBlock>>,
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
-    fn recovered_block(
-        &self,
-        block_id: BlockId,
-    ) -> impl Future<
-        Output = Result<
-            Option<Arc<RecoveredBlock<<Self::Provider as BlockReader>::Block>>>,
-            Self::Error,
-        >,
-    > + Send {
-        let hl_node_compliant = self.hl_node_compliant;
-        async move {
-            // Copy of LoadBlock::recovered_block, but with --hl-node-compliant support
-            if block_id.is_pending() {
-                return Ok(None);
-            }
-
-            let block_hash = match self
-                .provider()
-                .block_hash_for_id(block_id)
-                .map_err(Self::Error::from_eth_err)?
-            {
-                Some(block_hash) => block_hash,
-                None => return Ok(None),
-            };
-
-            let recovered_block = self
-                .cache()
-                .get_recovered_block(block_hash)
-                .await
-                .map_err(Self::Error::from_eth_err)?;
-
-            if let Some(recovered_block) = recovered_block {
-                let recovered_block = if hl_node_compliant {
-                    filter_if_hl_node_compliant(&recovered_block)
-                } else {
-                    (*recovered_block).clone()
-                };
-                return Ok(Some(std::sync::Arc::new(recovered_block)));
-            }
-
-            Ok(None)
-        }
-    }
 }

-fn filter_if_hl_node_compliant(
-    recovered_block: &RecoveredBlock<HlBlock>,
-) -> RecoveredBlock<HlBlock> {
-    let sealed_block = recovered_block.sealed_block();
-    let transactions = sealed_block.body().transactions();
-    let to_skip = transactions
-        .iter()
-        .position(|tx| !tx.is_system_transaction())
-        .unwrap_or(transactions.len());
-
-    let mut new_block: HlBlock = sealed_block.clone_block();
-    new_block.body.transactions.drain(..to_skip);
-    let new_sealed_block = SealedBlock::new_unchecked(new_block, sealed_block.hash());
-    let new_senders = recovered_block.senders()[to_skip..].to_vec();
-
-    RecoveredBlock::new_sealed(new_sealed_block, new_senders)
-}
-
-impl<N> LoadPendingBlock for HlEthApi<N>
+impl<N, Rpc> LoadPendingBlock for HlEthApi<N, Rpc>
 where
-    Self: SpawnBlocking
-        + EthApiTypes<
-            NetworkTypes: RpcTypes<
-                Header = alloy_rpc_types_eth::Header<ProviderHeader<Self::Provider>>,
-            >,
-            Error: FromEvmError<Self::Evm>,
-            RpcConvert: RpcConvert<Network = Self::NetworkTypes>,
-        >,
-    N: RpcNodeCore<
-        Provider: BlockReaderIdExt
-                      + ChainSpecProvider<ChainSpec: EthChainSpec + EthereumHardforks>
-                      + StateProviderFactory,
-        Pool: TransactionPool<Transaction: PoolTransaction<Consensus = ProviderTx<N::Provider>>>,
-        Evm: ConfigureEvm<
-            Primitives = <Self as RpcNodeCore>::Primitives,
-            NextBlockEnvCtx: From<NextBlockEnvAttributes>,
-        >,
-        Primitives: NodePrimitives<
-            BlockHeader = ProviderHeader<Self::Provider>,
-            SignedTx = ProviderTx<Self::Provider>,
-            Receipt = ProviderReceipt<Self::Provider>,
-            Block = ProviderBlock<Self::Provider>,
-        >,
-    >,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
    #[inline]
-    fn pending_block(
-        &self,
-    ) -> &tokio::sync::Mutex<
-        Option<PendingBlock<ProviderBlock<Self::Provider>, ProviderReceipt<Self::Provider>>>,
-    > {
+    fn pending_block(&self) -> &tokio::sync::Mutex<Option<PendingBlock<N::Primitives>>> {
        self.inner.eth_api.pending_block()
    }

-    fn next_env_attributes(
-        &self,
-        parent: &SealedHeader<ProviderHeader<Self::Provider>>,
-    ) -> Result<<Self::Evm as reth_evm::ConfigureEvm>::NextBlockEnvCtx, Self::Error> {
-        Ok(NextBlockEnvAttributes {
-            timestamp: parent.timestamp().saturating_add(12),
-            suggested_fee_recipient: parent.beneficiary(),
-            prev_randao: B256::random(),
-            gas_limit: parent.gas_limit(),
-            parent_beacon_block_root: parent.parent_beacon_block_root(),
-            withdrawals: None,
+    #[inline]
+    fn pending_env_builder(&self) -> &dyn PendingEnvBuilder<Self::Evm> {
+        self.inner.eth_api.pending_env_builder()
    }
-        .into())
+
+    #[inline]
+    fn pending_block_kind(&self) -> PendingBlockKind {
+        self.inner.eth_api.pending_block_kind()
    }
 }

-impl<N> LoadReceipt for HlEthApi<N>
+impl<N, Rpc> LoadReceipt for HlEthApi<N, Rpc>
 where
-    Self: Send + Sync,
-    N: FullNodeComponents<Types: NodeTypes<ChainSpec = HlChainSpec>>,
-    Self::Provider:
-        TransactionsProvider<Transaction = TransactionSigned> + ReceiptProvider<Receipt = Receipt>,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
-    async fn build_transaction_receipt(
-        &self,
-        tx: TransactionSigned,
-        meta: TransactionMeta,
-        receipt: Receipt,
-    ) -> Result<RpcReceipt<Self::NetworkTypes>, Self::Error> {
-        let hash = meta.block_hash;
-        // get all receipts for the block
-        let all_receipts = self
-            .cache()
-            .get_receipts(hash)
-            .await
-            .map_err(Self::Error::from_eth_err)?
-            .ok_or(EthApiError::HeaderNotFound(hash.into()))?;
-        let blob_params = self.provider().chain_spec().blob_params_at_timestamp(meta.timestamp);
-
-        build_receipt(&tx, meta, &receipt, &all_receipts, blob_params, |receipt_with_bloom| {
-            match receipt.tx_type {
-                TxType::Legacy => ReceiptEnvelope::Legacy(receipt_with_bloom),
-                TxType::Eip2930 => ReceiptEnvelope::Eip2930(receipt_with_bloom),
-                TxType::Eip1559 => ReceiptEnvelope::Eip1559(receipt_with_bloom),
-                TxType::Eip4844 => ReceiptEnvelope::Eip4844(receipt_with_bloom),
-                TxType::Eip7702 => ReceiptEnvelope::Eip7702(receipt_with_bloom),
-            }
-        })
-    }
 }
--- a/src/node/rpc/call.rs
+++ b/src/node/rpc/call.rs
@ -1,51 +1,32 @@
-use super::{HlEthApi, HlNodeCore};
-use crate::evm::transaction::HlTxEnv;
-use alloy_rpc_types::TransactionRequest;
+use super::HlEthApi;
 use reth::rpc::server_types::eth::EthApiError;
-use reth_evm::{block::BlockExecutorFactory, ConfigureEvm, EvmFactory, TxEnvFor};
-use reth_primitives::NodePrimitives;
-use reth_provider::{ProviderError, ProviderHeader, ProviderTx};
+use reth_evm::TxEnvFor;
 use reth_rpc_eth_api::{
-    helpers::{estimate::EstimateCall, Call, EthCall, LoadBlock, LoadState, SpawnBlocking},
-    FromEvmError, FullEthApiTypes, RpcConvert, RpcTypes,
+    helpers::{estimate::EstimateCall, Call, EthCall},
+    FromEvmError, RpcConvert, RpcNodeCore,
 };
-use revm::context::TxEnv;

-impl<N> EthCall for HlEthApi<N>
+impl<N, Rpc> EthCall for HlEthApi<N, Rpc>
 where
-    Self: EstimateCall + LoadBlock + FullEthApiTypes,
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, TxEnv = TxEnvFor<N::Evm>>,
 {
 }

-impl<N> EstimateCall for HlEthApi<N>
+impl<N, Rpc> EstimateCall for HlEthApi<N, Rpc>
 where
-    Self: Call,
-    Self::Error: From<EthApiError>,
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, TxEnv = TxEnvFor<N::Evm>>,
 {
 }

-impl<N> Call for HlEthApi<N>
+impl<N, Rpc> Call for HlEthApi<N, Rpc>
 where
-    Self: LoadState<
-            Evm: ConfigureEvm<
-                Primitives: NodePrimitives<
-                    BlockHeader = ProviderHeader<Self::Provider>,
-                    SignedTx = ProviderTx<Self::Provider>,
-                >,
-                BlockExecutorFactory: BlockExecutorFactory<
-                    EvmFactory: EvmFactory<Tx = HlTxEnv<TxEnv>>,
-                >,
-            >,
-            RpcConvert: RpcConvert<TxEnv = TxEnvFor<Self::Evm>, Network = Self::NetworkTypes>,
-            NetworkTypes: RpcTypes<TransactionRequest: From<TransactionRequest>>,
-            Error: FromEvmError<Self::Evm>
-                       + From<<Self::RpcConvert as RpcConvert>::Error>
-                       + From<ProviderError>,
-        > + SpawnBlocking,
-    Self::Error: From<EthApiError>,
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError, TxEnv = TxEnvFor<N::Evm>>,
 {
    #[inline]
    fn call_gas_limit(&self) -> u64 {
--- a/src/node/rpc/engine_api/validator.rs
+++ b/src/node/rpc/engine_api/validator.rs
@ -6,20 +6,15 @@ use crate::{
 use alloy_consensus::BlockHeader;
 use alloy_eips::eip4895::Withdrawal;
 use alloy_primitives::B256;
-use alloy_rpc_types_engine::{PayloadAttributes, PayloadError};
+use alloy_rpc_types_engine::PayloadError;
 use reth::{
    api::{FullNodeComponents, NodeTypes},
-    builder::{rpc::EngineValidatorBuilder, AddOnsContext},
-    consensus::ConsensusError,
-};
-use reth_engine_primitives::{EngineValidator, ExecutionPayload, PayloadValidator};
-use reth_payload_primitives::{
-    EngineApiMessageVersion, EngineObjectValidationError, NewPayloadError, PayloadOrAttributes,
-    PayloadTypes,
+    builder::{rpc::PayloadValidatorBuilder, AddOnsContext},
 };
+use reth_engine_primitives::{ExecutionPayload, PayloadValidator};
+use reth_payload_primitives::NewPayloadError;
 use reth_primitives::{RecoveredBlock, SealedBlock};
 use reth_primitives_traits::Block as _;
-use reth_trie_common::HashedPostState;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;

@ -27,27 +22,27 @@ use super::payload::HlPayloadTypes;

 #[derive(Debug, Default, Clone)]
 #[non_exhaustive]
-pub struct HlEngineValidatorBuilder;
+pub struct HlPayloadValidatorBuilder;

-impl<Node, Types> EngineValidatorBuilder<Node> for HlEngineValidatorBuilder
+impl<Node, Types> PayloadValidatorBuilder<Node> for HlPayloadValidatorBuilder
 where
    Types: NodeTypes<ChainSpec = HlChainSpec, Payload = HlPayloadTypes, Primitives = HlPrimitives>,
    Node: FullNodeComponents<Types = Types>,
 {
-    type Validator = HlEngineValidator;
+    type Validator = HlPayloadValidator;

    async fn build(self, ctx: &AddOnsContext<'_, Node>) -> eyre::Result<Self::Validator> {
-        Ok(HlEngineValidator::new(Arc::new(ctx.config.chain.clone().as_ref().clone())))
+        Ok(HlPayloadValidator::new(Arc::new(ctx.config.chain.clone().as_ref().clone())))
    }
 }

 /// Validator for Optimism engine API.
 #[derive(Debug, Clone)]
-pub struct HlEngineValidator {
+pub struct HlPayloadValidator {
    inner: HlExecutionPayloadValidator<HlChainSpec>,
 }

-impl HlEngineValidator {
+impl HlPayloadValidator {
    /// Instantiates a new validator.
    pub fn new(chain_spec: Arc<HlChainSpec>) -> Self {
        Self { inner: HlExecutionPayloadValidator { inner: chain_spec } }
@ -87,47 +82,17 @@ impl ExecutionPayload for HlExecutionData {
    }
 }

-impl PayloadValidator for HlEngineValidator {
+impl PayloadValidator<HlPayloadTypes> for HlPayloadValidator {
    type Block = HlBlock;
-    type ExecutionData = HlExecutionData;

    fn ensure_well_formed_payload(
        &self,
-        payload: Self::ExecutionData,
+        payload: HlExecutionData,
    ) -> Result<RecoveredBlock<Self::Block>, NewPayloadError> {
        let sealed_block =
            self.inner.ensure_well_formed_payload(payload).map_err(NewPayloadError::other)?;
        sealed_block.try_recover().map_err(|e| NewPayloadError::Other(e.into()))
    }
-
-    fn validate_block_post_execution_with_hashed_state(
-        &self,
-        _state_updates: &HashedPostState,
-        _block: &RecoveredBlock<Self::Block>,
-    ) -> Result<(), ConsensusError> {
-        Ok(())
-    }
-}
-
-impl<Types> EngineValidator<Types> for HlEngineValidator
-where
-    Types: PayloadTypes<PayloadAttributes = PayloadAttributes, ExecutionData = HlExecutionData>,
-{
-    fn validate_version_specific_fields(
-        &self,
-        _version: EngineApiMessageVersion,
-        _payload_or_attrs: PayloadOrAttributes<'_, Self::ExecutionData, PayloadAttributes>,
-    ) -> Result<(), EngineObjectValidationError> {
-        Ok(())
-    }
-
-    fn ensure_well_formed_attributes(
-        &self,
-        _version: EngineApiMessageVersion,
-        _attributes: &PayloadAttributes,
-    ) -> Result<(), EngineObjectValidationError> {
-        Ok(())
-    }
 }

 /// Execution payload validator.
--- a/src/node/rpc/mod.rs
+++ b/src/node/rpc/mod.rs
@ -1,104 +1,92 @@
 use alloy_network::Ethereum;
 use alloy_primitives::U256;
 use reth::{
+    api::{FullNodeTypes, HeaderTy, NodeTypes, PrimitivesTy},
    builder::{
        rpc::{EthApiBuilder, EthApiCtx},
        FullNodeComponents,
    },
-    chainspec::EthChainSpec,
-    primitives::EthereumHardforks,
-    providers::ChainSpecProvider,
    rpc::{
        eth::{core::EthApiInner, DevSigner, FullEthApiServer},
-        server_types::eth::{EthApiError, EthStateCache, FeeHistoryCache, GasPriceOracle},
+        server_types::eth::{
+            receipt::EthReceiptConverter, EthApiError, EthStateCache, FeeHistoryCache,
+            GasPriceOracle,
+        },
    },
    tasks::{
        pool::{BlockingTaskGuard, BlockingTaskPool},
        TaskSpawner,
    },
-    transaction_pool::TransactionPool,
 };
 use reth_evm::ConfigureEvm;
-use reth_network::NetworkInfo;
-use reth_primitives::NodePrimitives;
-use reth_provider::{
-    BlockNumReader, BlockReader, BlockReaderIdExt, ProviderBlock, ProviderHeader, ProviderReceipt,
-    ProviderTx, StageCheckpointReader, StateProviderFactory,
-};
+use reth_provider::{ChainSpecProvider, ProviderHeader, ProviderTx};
+use reth_rpc::RpcTypes;
 use reth_rpc_eth_api::{
    helpers::{
-        AddDevSigners, EthApiSpec, EthFees, EthSigner, EthState, LoadBlock, LoadFee, LoadState,
-        SpawnBlocking, Trace,
+        pending_block::BuildPendingEnv, spec::SignersForApi, AddDevSigners, EthApiSpec, EthFees,
+        EthState, LoadFee, LoadState, SpawnBlocking, Trace,
    },
-    EthApiTypes, FromEvmError, RpcConverter, RpcNodeCore, RpcNodeCoreExt,
+    EthApiTypes, FromEvmError, RpcConvert, RpcConverter, RpcNodeCore, RpcNodeCoreExt,
+    SignableTxRequest,
 };
-use std::{fmt, sync::Arc};
+use std::{fmt, marker::PhantomData, sync::Arc};
+
+use crate::chainspec::HlChainSpec;

 mod block;
 mod call;
 pub mod engine_api;
 mod transaction;

-/// A helper trait with requirements for [`RpcNodeCore`] to be used in [`HlEthApi`].
-pub trait HlNodeCore: RpcNodeCore<Provider: BlockReader> {}
-impl<T> HlNodeCore for T where T: RpcNodeCore<Provider: BlockReader> {}
-
-/// Adapter for [`EthApiInner`], which holds all the data required to serve core `eth_` API.
-pub type EthApiNodeBackend<N> = EthApiInner<
-    <N as RpcNodeCore>::Provider,
-    <N as RpcNodeCore>::Pool,
-    <N as RpcNodeCore>::Network,
-    <N as RpcNodeCore>::Evm,
->;
-
 /// Container type `HlEthApi`
-#[allow(missing_debug_implementations)]
-pub(crate) struct HlEthApiInner<N: HlNodeCore> {
+pub(crate) struct HlEthApiInner<N: RpcNodeCore, Rpc: RpcConvert> {
    /// Gateway to node's core components.
-    pub(crate) eth_api: EthApiNodeBackend<N>,
+    pub(crate) eth_api: EthApiInner<N, Rpc>,
 }

+type HlRpcConvert<N, NetworkT> =
+    RpcConverter<NetworkT, <N as FullNodeComponents>::Evm, EthReceiptConverter<HlChainSpec>>;
+
 #[derive(Clone)]
-pub struct HlEthApi<N: HlNodeCore> {
+pub struct HlEthApi<N: RpcNodeCore, Rpc: RpcConvert> {
    /// Gateway to node's core components.
-    pub(crate) inner: Arc<HlEthApiInner<N>>,
-    /// Converter for RPC types.
-    tx_resp_builder: RpcConverter<Ethereum, N::Evm, EthApiError, ()>,
-    /// Whether the node is in HL node compliant mode.
-    pub(crate) hl_node_compliant: bool,
+    pub(crate) inner: Arc<HlEthApiInner<N, Rpc>>,
 }

-impl<N: HlNodeCore> fmt::Debug for HlEthApi<N> {
+impl<N, Rpc> fmt::Debug for HlEthApi<N, Rpc>
+where
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
+{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("HlEthApi").finish_non_exhaustive()
    }
 }

-impl<N> EthApiTypes for HlEthApi<N>
+impl<N, Rpc> EthApiTypes for HlEthApi<N, Rpc>
 where
-    Self: Send + Sync,
-    N: HlNodeCore,
-    N::Evm: std::fmt::Debug,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
    type Error = EthApiError;
-    type NetworkTypes = Ethereum;
-    type RpcConvert = RpcConverter<Ethereum, N::Evm, EthApiError, ()>;
+    type NetworkTypes = Rpc::Network;
+    type RpcConvert = Rpc;

    fn tx_resp_builder(&self) -> &Self::RpcConvert {
-        &self.tx_resp_builder
+        self.inner.eth_api.tx_resp_builder()
    }
 }

-impl<N> RpcNodeCore for HlEthApi<N>
+impl<N, Rpc> RpcNodeCore for HlEthApi<N, Rpc>
 where
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives>,
 {
    type Primitives = N::Primitives;
    type Provider = N::Provider;
    type Pool = N::Pool;
-    type Evm = <N as RpcNodeCore>::Evm;
-    type Network = <N as RpcNodeCore>::Network;
-    type PayloadBuilder = ();
+    type Evm = N::Evm;
+    type Network = N::Network;

    #[inline]
    fn pool(&self) -> &Self::Pool {
@ -115,37 +103,30 @@ where
        self.inner.eth_api.network()
    }

-    #[inline]
-    fn payload_builder(&self) -> &Self::PayloadBuilder {
-        &()
-    }
-
    #[inline]
    fn provider(&self) -> &Self::Provider {
        self.inner.eth_api.provider()
    }
 }

-impl<N> RpcNodeCoreExt for HlEthApi<N>
+impl<N, Rpc> RpcNodeCoreExt for HlEthApi<N, Rpc>
 where
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
    #[inline]
-    fn cache(&self) -> &EthStateCache<ProviderBlock<N::Provider>, ProviderReceipt<N::Provider>> {
+    fn cache(&self) -> &EthStateCache<N::Primitives> {
        self.inner.eth_api.cache()
    }
 }

-impl<N> EthApiSpec for HlEthApi<N>
+impl<N, Rpc> EthApiSpec for HlEthApi<N, Rpc>
 where
-    N: HlNodeCore<
-        Provider: ChainSpecProvider<ChainSpec: EthereumHardforks>
-                      + BlockNumReader
-                      + StageCheckpointReader,
-        Network: NetworkInfo,
-    >,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
    type Transaction = ProviderTx<Self::Provider>;
+    type Rpc = Rpc::Network;

    #[inline]
    fn starting_block(&self) -> U256 {
@ -153,16 +134,15 @@ where
    }

    #[inline]
-    fn signers(&self) -> &parking_lot::RwLock<Vec<Box<dyn EthSigner<ProviderTx<Self::Provider>>>>> {
+    fn signers(&self) -> &SignersForApi<Self> {
        self.inner.eth_api.signers()
    }
 }

-impl<N> SpawnBlocking for HlEthApi<N>
+impl<N, Rpc> SpawnBlocking for HlEthApi<N, Rpc>
 where
-    Self: Send + Sync + Clone + 'static,
-    N: HlNodeCore,
-    N::Evm: std::fmt::Debug,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
    #[inline]
    fn io_task_spawner(&self) -> impl TaskSpawner {
@ -180,14 +160,11 @@ where
    }
 }

-impl<N> LoadFee for HlEthApi<N>
+impl<N, Rpc> LoadFee for HlEthApi<N, Rpc>
 where
-    Self: LoadBlock<Provider = N::Provider>,
-    N: HlNodeCore<
-        Provider: BlockReaderIdExt
-                      + ChainSpecProvider<ChainSpec: EthChainSpec + EthereumHardforks>
-                      + StateProviderFactory,
-    >,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
    #[inline]
    fn gas_oracle(&self) -> &GasPriceOracle<Self::Provider> {
@ -195,25 +172,22 @@ where
    }

    #[inline]
-    fn fee_history_cache(&self) -> &FeeHistoryCache {
+    fn fee_history_cache(&self) -> &FeeHistoryCache<ProviderHeader<N::Provider>> {
        self.inner.eth_api.fee_history_cache()
    }
 }

-impl<N> LoadState for HlEthApi<N>
+impl<N, Rpc> LoadState for HlEthApi<N, Rpc>
 where
-    N: HlNodeCore<
-        Provider: StateProviderFactory + ChainSpecProvider<ChainSpec: EthereumHardforks>,
-        Pool: TransactionPool,
-    >,
-    N::Evm: std::fmt::Debug,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
 }

-impl<N> EthState for HlEthApi<N>
+impl<N, Rpc> EthState for HlEthApi<N, Rpc>
 where
-    Self: LoadState + SpawnBlocking,
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
    #[inline]
    fn max_proof_window(&self) -> u64 {
@ -221,36 +195,28 @@ where
    }
 }

-impl<N> EthFees for HlEthApi<N>
+impl<N, Rpc> EthFees for HlEthApi<N, Rpc>
 where
-    Self: LoadFee<
-        Provider: ChainSpecProvider<
-            ChainSpec: EthChainSpec<Header = ProviderHeader<Self::Provider>>,
-        >,
-    >,
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
 }

-impl<N> Trace for HlEthApi<N>
+impl<N, Rpc> Trace for HlEthApi<N, Rpc>
 where
-    Self: RpcNodeCore<Provider: BlockReader>
-        + LoadState<
-            Evm: ConfigureEvm<
-                Primitives: NodePrimitives<
-                    BlockHeader = ProviderHeader<Self::Provider>,
-                    SignedTx = ProviderTx<Self::Provider>,
-                >,
-            >,
-            Error: FromEvmError<Self::Evm>,
-        >,
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    EthApiError: FromEvmError<N::Evm>,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
 }

-impl<N> AddDevSigners for HlEthApi<N>
+impl<N, Rpc> AddDevSigners for HlEthApi<N, Rpc>
 where
-    N: HlNodeCore,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<
+        Network: RpcTypes<TransactionRequest: SignableTxRequest<ProviderTx<N::Provider>>>,
+    >,
 {
    fn with_dev_accounts(&self) {
        *self.inner.eth_api.signers().write() = DevSigner::random_signers(20)
@ -258,40 +224,41 @@ where
 }

 /// Builds [`HlEthApi`] for HL.
-#[derive(Debug, Default)]
+#[derive(Debug)]
 #[non_exhaustive]
-pub struct HlEthApiBuilder {
-    /// Whether the node is in HL node compliant mode.
-    pub(crate) hl_node_compliant: bool,
+pub struct HlEthApiBuilder<NetworkT = Ethereum> {
+    /// Marker for network types.
+    pub(crate) _nt: PhantomData<NetworkT>,
 }

-impl<N> EthApiBuilder<N> for HlEthApiBuilder
-where
-    N: FullNodeComponents,
-    HlEthApi<N>: FullEthApiServer<Provider = N::Provider, Pool = N::Pool>,
-{
-    type EthApi = HlEthApi<N>;
-
-    async fn build_eth_api(self, ctx: EthApiCtx<'_, N>) -> eyre::Result<Self::EthApi> {
-        let eth_api = reth::rpc::eth::EthApiBuilder::new(
-            ctx.components.provider().clone(),
-            ctx.components.pool().clone(),
-            ctx.components.network().clone(),
-            ctx.components.evm_config().clone(),
-        )
-        .eth_cache(ctx.cache)
-        .task_spawner(ctx.components.task_executor().clone())
-        .gas_cap(ctx.config.rpc_gas_cap.into())
-        .max_simulate_blocks(ctx.config.rpc_max_simulate_blocks)
-        .eth_proof_window(ctx.config.eth_proof_window)
-        .fee_history_cache_config(ctx.config.fee_history_cache)
-        .proof_permits(ctx.config.proof_permits)
-        .build_inner();
-
-        Ok(HlEthApi {
-            inner: Arc::new(HlEthApiInner { eth_api }),
-            tx_resp_builder: Default::default(),
-            hl_node_compliant: self.hl_node_compliant,
-        })
+impl<NetworkT> Default for HlEthApiBuilder<NetworkT> {
+    fn default() -> Self {
+        Self { _nt: PhantomData }
+    }
+}
+
+impl<N, NetworkT> EthApiBuilder<N> for HlEthApiBuilder<NetworkT>
+where
+    N: FullNodeComponents<Types: NodeTypes<ChainSpec = HlChainSpec>>
+        + RpcNodeCore<
+            Primitives = PrimitivesTy<N::Types>,
+            Evm: ConfigureEvm<NextBlockEnvCtx: BuildPendingEnv<HeaderTy<N::Types>>>,
+        >,
+    NetworkT: RpcTypes,
+    HlRpcConvert<N, NetworkT>: RpcConvert<Network = NetworkT, Primitives = PrimitivesTy<N::Types>>,
+    HlEthApi<N, HlRpcConvert<N, NetworkT>>: FullEthApiServer<
+            Provider = <N as FullNodeTypes>::Provider,
+            Pool = <N as FullNodeComponents>::Pool,
+        > + AddDevSigners,
+{
+    type EthApi = HlEthApi<N, HlRpcConvert<N, NetworkT>>;
+
+    async fn build_eth_api(self, ctx: EthApiCtx<'_, N>) -> eyre::Result<Self::EthApi> {
+        let provider = FullNodeComponents::provider(ctx.components);
+        let rpc_converter =
+            RpcConverter::new(EthReceiptConverter::<HlChainSpec>::new(provider.chain_spec()));
+        let eth_api = ctx.eth_api_builder().with_rpc_converter(rpc_converter).build_inner();
+
+        Ok(HlEthApi { inner: Arc::new(HlEthApiInner { eth_api }) })
    }
 }
--- a/src/node/rpc/transaction.rs
+++ b/src/node/rpc/transaction.rs
@ -1,51 +1,28 @@
-use super::HlNodeCore;
 use crate::node::rpc::HlEthApi;
 use alloy_primitives::{Bytes, B256};
-use reth::{
-    rpc::server_types::eth::utils::recover_raw_transaction,
-    transaction_pool::{PoolTransaction, TransactionOrigin, TransactionPool},
-};
-use reth_provider::{BlockReader, BlockReaderIdExt, ProviderTx, TransactionsProvider};
+use reth::rpc::server_types::eth::EthApiError;
 use reth_rpc_eth_api::{
-    helpers::{EthSigner, EthTransactions, LoadTransaction, SpawnBlocking},
-    FromEthApiError, FullEthApiTypes, RpcNodeCore, RpcNodeCoreExt,
+    helpers::{spec::SignersForRpc, EthTransactions, LoadTransaction},
+    RpcConvert, RpcNodeCore,
 };

-impl<N> LoadTransaction for HlEthApi<N>
+impl<N, Rpc> LoadTransaction for HlEthApi<N, Rpc>
 where
-    Self: SpawnBlocking + FullEthApiTypes + RpcNodeCoreExt,
-    N: HlNodeCore<Provider: TransactionsProvider, Pool: TransactionPool>,
-    Self::Pool: TransactionPool,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
 }

-impl<N> EthTransactions for HlEthApi<N>
+impl<N, Rpc> EthTransactions for HlEthApi<N, Rpc>
 where
-    Self: LoadTransaction<Provider: BlockReaderIdExt>,
-    N: HlNodeCore<Provider: BlockReader<Transaction = ProviderTx<Self::Provider>>>,
+    N: RpcNodeCore,
+    Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
 {
-    fn signers(&self) -> &parking_lot::RwLock<Vec<Box<dyn EthSigner<ProviderTx<Self::Provider>>>>> {
+    fn signers(&self) -> &SignersForRpc<Self::Provider, Self::NetworkTypes> {
        self.inner.eth_api.signers()
    }

-    /// Decodes and recovers the transaction and submits it to the pool.
-    ///
-    /// Returns the hash of the transaction.
-    async fn send_raw_transaction(&self, tx: Bytes) -> Result<B256, Self::Error> {
-        let recovered = recover_raw_transaction(&tx)?;
-
-        // broadcast raw transaction to subscribers if there is any.
-        self.inner.eth_api.broadcast_raw_transaction(tx);
-
-        let pool_transaction = <Self::Pool as TransactionPool>::Transaction::from_pooled(recovered);
-
-        // submit the transaction to the pool with a `Local` origin
-        let hash = self
-            .pool()
-            .add_transaction(TransactionOrigin::Local, pool_transaction)
-            .await
-            .map_err(Self::Error::from_eth_err)?;
-
-        Ok(hash)
+    async fn send_raw_transaction(&self, _tx: Bytes) -> Result<B256, Self::Error> {
+        unreachable!()
    }
 }
--- a/src/node/spot_meta.rs
+++ b/src/node/spot_meta.rs
@ -3,8 +3,7 @@ use eyre::{Error, Result};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;

-pub(crate) const MAINNET_CHAIN_ID: u64 = 999;
-pub(crate) const TESTNET_CHAIN_ID: u64 = 998;
+use crate::chainspec::{MAINNET_CHAIN_ID, TESTNET_CHAIN_ID};

 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct EvmContract {
--- a/src/node/types/mod.rs
+++ b/src/node/types/mod.rs
@ -7,7 +7,7 @@ use alloy_rlp::{Decodable, Encodable, RlpDecodable, RlpEncodable};
 use bytes::BufMut;
 use serde::{Deserialize, Serialize};

-use crate::{node::spot_meta::MAINNET_CHAIN_ID, HlBlock};
+use crate::HlBlock;

 pub type ReadPrecompileCall = (Address, Vec<(ReadPrecompileInput, ReadPrecompileResult)>);

@ -50,13 +50,13 @@ pub struct BlockAndReceipts {
 }

 impl BlockAndReceipts {
-    pub fn to_reth_block(self) -> HlBlock {
+    pub fn to_reth_block(self, chain_id: u64) -> HlBlock {
        let EvmBlock::Reth115(block) = self.block;
        block.to_reth_block(
            self.read_precompile_calls.clone(),
            self.highest_precompile_address,
            self.system_txs.clone(),
-            MAINNET_CHAIN_ID,
+            chain_id,
        )
    }

--- a/src/pseudo_peer/config.rs
+++ b/src/pseudo_peer/config.rs
@ -1,8 +1,7 @@
-use super::{
-    consts::DEFAULT_S3_BUCKET,
-    sources::{
+use crate::chainspec::HlChainSpec;
+
+use super::sources::{
    BlockSourceBoxed, CachedBlockSource, HlNodeBlockSource, LocalBlockSource, S3BlockSource,
-    },
 };
 use aws_config::BehaviorVersion;
 use std::{env::home_dir, path::PathBuf, sync::Arc};
@ -15,16 +14,14 @@ pub struct BlockSourceConfig {

 #[derive(Debug, Clone)]
 pub enum BlockSourceType {
+    S3Default,
    S3 { bucket: String },
    Local { path: PathBuf },
 }

 impl BlockSourceConfig {
    pub async fn s3_default() -> Self {
-        Self {
-            source_type: BlockSourceType::S3 { bucket: DEFAULT_S3_BUCKET.to_string() },
-            block_source_from_node: None,
-        }
+        Self { source_type: BlockSourceType::S3Default, block_source_from_node: None }
    }

    pub async fn s3(bucket: String) -> Self {
@ -53,17 +50,10 @@ impl BlockSourceConfig {
        self
    }

-    pub async fn create_block_source(&self) -> BlockSourceBoxed {
+    pub async fn create_block_source(&self, chain_spec: HlChainSpec) -> BlockSourceBoxed {
        match &self.source_type {
-            BlockSourceType::S3 { bucket } => {
-                let client = aws_sdk_s3::Client::new(
-                    &aws_config::defaults(BehaviorVersion::latest())
-                        .region("ap-northeast-1")
-                        .load()
-                        .await,
-                );
-                Arc::new(Box::new(S3BlockSource::new(client, bucket.clone())))
-            }
+            BlockSourceType::S3Default => s3_block_source(chain_spec.official_s3_bucket()).await,
+            BlockSourceType::S3 { bucket } => s3_block_source(bucket).await,
            BlockSourceType::Local { path } => {
                Arc::new(Box::new(LocalBlockSource::new(path.clone())))
            }
@ -89,9 +79,21 @@ impl BlockSourceConfig {
        ))
    }

-    pub async fn create_cached_block_source(&self, next_block_number: u64) -> BlockSourceBoxed {
-        let block_source = self.create_block_source().await;
-        let block_source = self.create_block_source_from_node(next_block_number, block_source).await;
+    pub async fn create_cached_block_source(
+        &self,
+        chain_spec: HlChainSpec,
+        next_block_number: u64,
+    ) -> BlockSourceBoxed {
+        let block_source = self.create_block_source(chain_spec).await;
+        let block_source =
+            self.create_block_source_from_node(next_block_number, block_source).await;
        Arc::new(Box::new(CachedBlockSource::new(block_source)))
    }
 }
+
+async fn s3_block_source(bucket: impl AsRef<str>) -> BlockSourceBoxed {
+    let client = aws_sdk_s3::Client::new(
+        &aws_config::defaults(BehaviorVersion::latest()).region("ap-northeast-1").load().await,
+    );
+    Arc::new(Box::new(S3BlockSource::new(client, bucket.as_ref().to_string())))
+}
--- a/src/pseudo_peer/consts.rs
+++ b/src/pseudo_peer/consts.rs
@ -1,2 +1 @@
 pub const MAX_CONCURRENCY: usize = 100;
-pub const DEFAULT_S3_BUCKET: &str = "hl-mainnet-evm-blocks";
--- a/src/pseudo_peer/mod.rs
+++ b/src/pseudo_peer/mod.rs
@ -50,6 +50,7 @@ pub async fn start_pseudo_peer(

    // Create network manager
    let (mut network, start_tx) = create_network_manager::<BlockSourceBoxed>(
+        (*chain_spec).clone(),
        destination_peer,
        block_source.clone(),
        blockhash_cache.clone(),
--- a/src/pseudo_peer/network.rs
+++ b/src/pseudo_peer/network.rs
@ -1,9 +1,5 @@
 use super::service::{BlockHashCache, BlockPoller};
-use crate::{
-    chainspec::{parser::chain_value_parser, HlChainSpec},
-    node::network::HlNetworkPrimitives,
-    HlPrimitives,
-};
+use crate::{chainspec::HlChainSpec, node::network::HlNetworkPrimitives, HlPrimitives};
 use reth_network::{
    config::{rng_secret_key, SecretKey},
    NetworkConfig, NetworkManager, PeersConfig,
@ -19,6 +15,7 @@ pub struct NetworkBuilder {
    boot_nodes: Vec<TrustedPeer>,
    discovery_port: u16,
    listener_port: u16,
+    chain_spec: HlChainSpec,
 }

 impl Default for NetworkBuilder {
@ -29,6 +26,7 @@ impl Default for NetworkBuilder {
            boot_nodes: vec![],
            discovery_port: 0,
            listener_port: 0,
+            chain_spec: HlChainSpec::default(),
        }
    }
 }
@ -55,6 +53,11 @@ impl NetworkBuilder {
        self
    }

+    pub fn with_chain_spec(mut self, chain_spec: HlChainSpec) -> Self {
+        self.chain_spec = chain_spec;
+        self
+    }
+
    pub async fn build<BS>(
        self,
        block_source: Arc<Box<dyn super::sources::BlockSource>>,
@ -65,13 +68,15 @@ impl NetworkBuilder {
            .peer_config(self.peer_config)
            .discovery_port(self.discovery_port)
            .listener_port(self.listener_port);
+        let chain_id = self.chain_spec.inner.chain().id();

-        let (block_poller, start_tx) = BlockPoller::new_suspended(block_source, blockhash_cache);
+        let (block_poller, start_tx) =
+            BlockPoller::new_suspended(chain_id, block_source, blockhash_cache);
        let config = builder.block_import(Box::new(block_poller)).build(Arc::new(NoopProvider::<
            HlChainSpec,
            HlPrimitives,
        >::new(
-            chain_value_parser("mainnet").unwrap(),
+            self.chain_spec.into(),
        )));

        let network = NetworkManager::new(config).await.map_err(|e| eyre::eyre!(e))?;
@ -80,12 +85,14 @@ impl NetworkBuilder {
 }

 pub async fn create_network_manager<BS>(
+    chain_spec: HlChainSpec,
    destination_peer: String,
    block_source: Arc<Box<dyn super::sources::BlockSource>>,
    blockhash_cache: BlockHashCache,
 ) -> eyre::Result<(NetworkManager<HlNetworkPrimitives>, mpsc::Sender<()>)> {
    NetworkBuilder::default()
        .with_boot_nodes(vec![TrustedPeer::from_str(&destination_peer).unwrap()])
+        .with_chain_spec(chain_spec)
        .build::<BS>(block_source, blockhash_cache)
        .await
 }
--- a/src/pseudo_peer/service.rs
+++ b/src/pseudo_peer/service.rs
@ -42,6 +42,7 @@ pub fn new_blockhash_cache() -> BlockHashCache {
 /// A block poller that polls blocks from `BlockSource` and sends them to the `block_tx`
 #[derive(Debug)]
 pub struct BlockPoller {
+    chain_id: u64,
    block_rx: mpsc::Receiver<(u64, BlockAndReceipts)>,
    task: JoinHandle<eyre::Result<()>>,
    blockhash_cache: BlockHashCache,
@ -51,6 +52,7 @@ impl BlockPoller {
    const POLL_INTERVAL: Duration = Duration::from_millis(25);

    pub fn new_suspended<BS: BlockSource>(
+        chain_id: u64,
        block_source: BS,
        blockhash_cache: BlockHashCache,
    ) -> (Self, mpsc::Sender<()>) {
@ -59,7 +61,7 @@ impl BlockPoller {
        let (block_tx, block_rx) = mpsc::channel(100);
        let block_tx_clone = block_tx.clone();
        let task = tokio::spawn(Self::task(start_rx, block_source, block_tx_clone));
-        (Self { block_rx, task, blockhash_cache: blockhash_cache.clone() }, start_tx)
+        (Self { chain_id, block_rx, task, blockhash_cache: blockhash_cache.clone() }, start_tx)
    }

    #[allow(unused)]
@ -98,7 +100,7 @@ impl BlockImport<HlNewBlock> for BlockPoller {
        match Pin::new(&mut self.block_rx).poll_recv(_cx) {
            Poll::Ready(Some((number, block))) => {
                debug!("Polled block: {}", number);
-                let reth_block = block.to_reth_block();
+                let reth_block = block.to_reth_block(self.chain_id);
                let hash = reth_block.header.hash_slow();
                self.blockhash_cache.write().insert(hash, number);
                let td = U128::from(reth_block.header.difficulty);
@ -167,6 +169,7 @@ impl<BS: BlockSource> PseudoPeer<BS> {
        &mut self,
        eth_req: IncomingEthRequest<HlNetworkPrimitives>,
    ) -> eyre::Result<()> {
+        let chain_id = self.chain_spec.inner.chain().id();
        match eth_req {
            IncomingEthRequest::GetBlockHeaders {
                peer_id: _,
@ -189,7 +192,7 @@ impl<BS: BlockSource> PseudoPeer<BS> {
                    }
                }
                .into_par_iter()
-                .map(|block| block.to_reth_block().header.clone())
+                .map(|block| block.to_reth_block(chain_id).header.clone())
                .collect::<Vec<_>>();

                let _ = response.send(Ok(BlockHeaders(block_headers)));
@ -207,7 +210,7 @@ impl<BS: BlockSource> PseudoPeer<BS> {
                    .collect_blocks(numbers)
                    .await
                    .into_iter()
-                    .map(|block| block.to_reth_block().body)
+                    .map(|block| block.to_reth_block(chain_id).body)
                    .collect::<Vec<_>>();

                let _ = response.send(Ok(BlockBodies(block_bodies)));
--- a/src/pseudo_peer/sources/hl_node.rs
+++ b/src/pseudo_peer/sources/hl_node.rs
@ -138,7 +138,8 @@ pub struct HlNodeBlockSource {
    pub fallback: BlockSourceBoxed,
    pub local_ingest_dir: PathBuf,
    pub local_blocks_cache: Arc<Mutex<LocalBlocksCache>>, // height → block
-    pub last_local_fetch: Arc<Mutex<Option<(u64, OffsetDateTime)>>>, // for rate limiting requests to fallback
+    // for rate limiting requests to fallback
+    pub last_local_fetch: Arc<Mutex<Option<(u64, OffsetDateTime)>>>,
 }

 impl BlockSource for HlNodeBlockSource {
@ -217,9 +218,7 @@ fn read_last_complete_line<R: Read + Seek>(read: &mut R) -> Option<(BlockAndRece

        if let Some(idx) = last_line.iter().rposition(|&b| b == b'\n') {
            let candidate = &last_line[idx + 1..];
-            if let Ok((evm_block, height)) =
-                line_to_evm_block(str::from_utf8(candidate).unwrap())
-            {
+            if let Ok((evm_block, height)) = line_to_evm_block(str::from_utf8(candidate).unwrap()) {
                return Some((evm_block, height));
            }
            // Incomplete line; truncate and continue
@ -241,7 +240,8 @@ impl HlNodeBlockSource {
    /// requests to S3 while it'll return 404.
    ///
    /// To avoid unnecessary fallback, we set a short threshold period.
-    /// This threshold is several times longer than the expected block time, reducing redundant fallback attempts.
+    /// This threshold is several times longer than the expected block time, reducing redundant
+    /// fallback attempts.
    pub(crate) const MAX_ALLOWED_THRESHOLD_BEFORE_FALLBACK: Duration = Duration::milliseconds(5000);

    async fn update_last_fetch(&self, height: u64, now: OffsetDateTime) {
@ -327,7 +327,8 @@ impl HlNodeBlockSource {
                &mut 0,
                ScanOptions { start_height: cutoff_height, only_load_ranges: true },
            );
-            // Only store the block ranges for now; actual block data will be loaded lazily later to optimize memory usage
+            // Only store the block ranges for now; actual block data will be loaded lazily later to
+            // optimize memory usage
            scan_result.new_blocks.clear();
            u_cache.load_scan_result(scan_result);
        }
@ -434,13 +435,13 @@ impl HlNodeBlockSource {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::node::types::reth_compat;
-    use crate::node::types::ReadPrecompileCalls;
-    use crate::pseudo_peer::sources::LocalBlockSource;
+    use crate::{
+        node::types::{reth_compat, ReadPrecompileCalls},
+        pseudo_peer::sources::LocalBlockSource,
+    };
    use alloy_consensus::{BlockBody, Header};
    use alloy_primitives::{Address, Bloom, Bytes, B256, B64, U256};
-    use std::io::Write;
-    use std::time::Duration;
+    use std::{io::Write, time::Duration};

    #[test]
    fn test_datetime_from_path() {
Author	SHA1	Message	Date
sprites0	b91fa639f7	chore: Patch reth to allow zero state root on unwind	2025-08-22 12:51:30 -04:00
sprites0	cf4e76db20	fix: Setup correct context for `context_for_payload` as well	2025-08-22 12:51:02 -04:00
sprites0	5af7182919	Merge pull request #35 from hl-archive-node/feat/testnet-node-builder feat: Support testnet (node-builder)	2025-08-22 23:42:52 +09:00
sprites0	b6d5031865	feat: Support testnet sync - Add testnet S3 bucket - Use testnet RPC properly - Use testnet chainspec on pseudo peer	2025-08-22 10:40:36 -04:00
sprites0	7daf203bc2	fix: Initialize DB with HL-specific tables on init-state	2025-08-22 10:40:14 -04:00
sprites0	20610ccc82	chore: Patch reth to allow zero state root on init-state	2025-08-22 10:39:25 -04:00
sprites0	6543fac314	feat: Add testnet chainspec	2025-08-22 10:38:52 -04:00
sprites0	26c1973503	Merge pull request #34 from hl-archive-node/fix/hl-node-compliance-receipts fix: Fix block and transaction receipts' gas and transaction index	2025-08-22 23:10:22 +09:00
sprites0	095ad0f65d	fix: Fix block and transaction receipts' gas and transaction index	2025-08-22 10:09:35 -04:00
sprites0	67cc8b8360	fix: Fix typo	2025-08-22 05:46:16 -04:00
sprites0	ff67ae87c8	Merge pull request #33 from hl-archive-node/refactor/1.6.0-dev chore: Upgrade to reth v1.6.0-dev	2025-08-22 18:40:25 +09:00
sprites0	7f0f7c94a6	chore: Make constants consistent	2025-08-21 06:52:12 -04:00
sprites0	2712cbb413	chore: Simplify traits	2025-08-21 06:52:01 -04:00
sprites0	4be1aa83de	Port to reth 1.6.0-dev	2025-08-21 05:58:37 -04:00