From 5114facbfdfd86344c70b797828a31380c801d34 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Sat, 23 Nov 2024 21:40:47 +0400
Subject: [PATCH 01/15] feat: make more block types generic

---
 bin/reth-bench/src/bench/new_payload_fcu.rs   |   6 +-
 bin/reth-bench/src/bench/new_payload_only.rs  |   6 +-
 .../src/commands/debug_cmd/build_block.rs     |  12 +-
 .../commands/debug_cmd/in_memory_merkle.rs    |   1 +
 bin/reth/src/commands/debug_cmd/merkle.rs     |   3 +-
 crates/blockchain-tree/src/blockchain_tree.rs |   6 +-
 crates/blockchain-tree/src/externals.rs       |  30 +-
 crates/chain-state/src/test_utils.rs          |   4 +-
 crates/cli/commands/src/common.rs             |  14 +-
 .../commands/src/init_state/without_evm.rs    |   5 +-
 crates/consensus/beacon/src/engine/mod.rs     |   1 +
 crates/consensus/common/src/validation.rs     |   4 +-
 crates/e2e-test-utils/src/lib.rs              |   7 +-
 crates/e2e-test-utils/src/node.rs             |   2 +-
 crates/engine/local/src/miner.rs              |  13 +-
 crates/engine/tree/src/persistence.rs         |   8 +-
 crates/engine/tree/src/tree/mod.rs            |   1 +
 crates/engine/util/src/reorg.rs               |   2 +-
 crates/ethereum/evm/src/execute.rs            |   4 +-
 crates/ethereum/node/tests/e2e/dev.rs         |   2 +-
 crates/ethereum/payload/src/lib.rs            |   2 +-
 crates/evm/execution-types/src/chain.rs       |   6 +-
 crates/exex/exex/src/backfill/job.rs          |   2 +-
 crates/exex/exex/src/backfill/test_utils.rs   |  18 +-
 crates/exex/exex/src/manager.rs               |   2 +-
 crates/exex/exex/src/notifications.rs         |   4 +-
 crates/exex/exex/src/wal/mod.rs               |  10 +-
 crates/exex/test-utils/src/lib.rs             |   4 +-
 crates/node/builder/src/builder/mod.rs        |   6 +-
 crates/node/builder/src/launch/engine.rs      |   8 +-
 crates/node/builder/src/launch/mod.rs         |   9 +-
 crates/optimism/payload/src/builder.rs        |   4 +-
 crates/payload/builder/src/test_utils.rs      |   2 +-
 crates/payload/validator/src/lib.rs           |   2 +-
 crates/primitives-traits/src/block/body.rs    |   4 +-
 crates/primitives-traits/src/block/mod.rs     |  12 +-
 crates/primitives/src/block.rs                | 312 +++++++++---------
 crates/primitives/src/lib.rs                  |   3 +
 crates/primitives/src/proofs.rs               |   8 +-
 crates/primitives/src/traits.rs               | 123 +++++++
 crates/primitives/src/traits/mod.rs           |   9 -
 crates/primitives/src/transaction/mod.rs      |  21 ++
 crates/rpc/rpc-builder/tests/it/auth.rs       |   2 +-
 .../rpc-eth-api/src/helpers/pending_block.rs  |   4 +-
 .../rpc-eth-api/src/helpers/transaction.rs    |   2 +-
 crates/rpc/rpc-types-compat/src/block.rs      |   2 +-
 .../rpc-types-compat/src/engine/payload.rs    |   3 +-
 crates/rpc/rpc/src/debug.rs                   |   2 +-
 crates/stages/stages/src/stages/bodies.rs     |   4 +-
 .../src/providers/blockchain_provider.rs      |   4 +-
 .../src/providers/database/provider.rs        |  22 +-
 crates/storage/provider/src/providers/mod.rs  |   2 +
 crates/storage/provider/src/traits/block.rs   |   9 +-
 crates/storage/provider/src/writer/mod.rs     |   4 +-
 .../src/mined_sidecar.rs                      |   2 +
 examples/custom-dev-node/src/main.rs          |   2 +-
 .../custom-payload-builder/src/generator.rs   |   2 +-
 examples/db-access/src/main.rs                |   2 +-
 58 files changed, 486 insertions(+), 284 deletions(-)
 create mode 100644 crates/primitives/src/traits.rs
 delete mode 100644 crates/primitives/src/traits/mod.rs

diff --git a/bin/reth-bench/src/bench/new_payload_fcu.rs b/bin/reth-bench/src/bench/new_payload_fcu.rs
index dd2f863e2c94..6c1e06730197 100644
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ b/bin/reth-bench/src/bench/new_payload_fcu.rs
@@ -18,7 +18,7 @@ use clap::Parser;
 use csv::Writer;
 use reth_cli_runner::CliContext;
 use reth_node_core::args::BenchmarkArgs;
-use reth_primitives::Block;
+use reth_primitives::{Block, BlockSealExt};
 use reth_rpc_types_compat::engine::payload::block_to_payload;
 use std::time::Instant;
 use tracing::{debug, info};
@@ -75,11 +75,11 @@ impl Command {
 
         while let Some((block, head, safe, finalized)) = receiver.recv().await {
             // just put gas used here
-            let gas_used = block.header.gas_used;
+            let gas_used = block.gas_used;
             let block_number = block.header.number;
 
             let versioned_hashes: Vec<B256> =
-                block.blob_versioned_hashes().into_iter().copied().collect();
+                block.body.blob_versioned_hashes().into_iter().copied().collect();
             let parent_beacon_block_root = block.parent_beacon_block_root;
             let payload = block_to_payload(block);
 
diff --git a/bin/reth-bench/src/bench/new_payload_only.rs b/bin/reth-bench/src/bench/new_payload_only.rs
index 68b2f76527df..b2f6e8088ba2 100644
--- a/bin/reth-bench/src/bench/new_payload_only.rs
+++ b/bin/reth-bench/src/bench/new_payload_only.rs
@@ -16,7 +16,7 @@ use clap::Parser;
 use csv::Writer;
 use reth_cli_runner::CliContext;
 use reth_node_core::args::BenchmarkArgs;
-use reth_primitives::Block;
+use reth_primitives::{Block, BlockSealExt};
 use reth_rpc_types_compat::engine::payload::block_to_payload;
 use std::time::Instant;
 use tracing::{debug, info};
@@ -60,10 +60,10 @@ impl Command {
 
         while let Some(block) = receiver.recv().await {
             // just put gas used here
-            let gas_used = block.header.gas_used;
+            let gas_used = block.gas_used;
 
             let versioned_hashes: Vec<B256> =
-                block.blob_versioned_hashes().into_iter().copied().collect();
+                block.body.blob_versioned_hashes().into_iter().copied().collect();
             let parent_beacon_block_root = block.parent_beacon_block_root;
             let payload = block_to_payload(block);
 
diff --git a/bin/reth/src/commands/debug_cmd/build_block.rs b/bin/reth/src/commands/debug_cmd/build_block.rs
index aa89b4112c3b..e48eb53165fd 100644
--- a/bin/reth/src/commands/debug_cmd/build_block.rs
+++ b/bin/reth/src/commands/debug_cmd/build_block.rs
@@ -22,11 +22,11 @@ use reth_errors::RethResult;
 use reth_evm::execute::{BlockExecutorProvider, Executor};
 use reth_execution_types::ExecutionOutcome;
 use reth_fs_util as fs;
-use reth_node_api::{EngineApiMessageVersion, PayloadBuilderAttributes};
+use reth_node_api::{EngineApiMessageVersion, NodePrimitives, PayloadBuilderAttributes};
 use reth_node_ethereum::{EthEvmConfig, EthExecutorProvider};
 use reth_primitives::{
-    BlobTransaction, PooledTransactionsElement, SealedBlock, SealedBlockWithSenders, SealedHeader,
-    Transaction, TransactionSigned,
+    BlobTransaction, BlockSealExt, PooledTransactionsElement, SealedBlock, SealedBlockWithSenders,
+    SealedHeader, Transaction, TransactionSigned,
 };
 use reth_provider::{
     providers::{BlockchainProvider, ProviderNodeTypes},
@@ -258,8 +258,10 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
                 consensus.validate_block_pre_execution(block)?;
 
                 let senders = block.senders().expect("sender recovery failed");
-                let block_with_senders =
-                    SealedBlockWithSenders::new(block.clone(), senders).unwrap();
+                let block_with_senders = SealedBlockWithSenders::<
+                    <N::Primitives as NodePrimitives>::Block,
+                >::new(block.clone(), senders)
+                .unwrap();
 
                 let db = StateProviderDatabase::new(blockchain_db.latest()?);
                 let executor =
diff --git a/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs b/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs
index ce5f318632e5..35ecc380ab95 100644
--- a/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs
+++ b/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs
@@ -20,6 +20,7 @@ use reth_execution_types::ExecutionOutcome;
 use reth_network::{BlockDownloaderProvider, NetworkHandle};
 use reth_network_api::NetworkInfo;
 use reth_node_ethereum::EthExecutorProvider;
+use reth_primitives::BlockSealExt;
 use reth_provider::{
     providers::ProviderNodeTypes, writer::UnifiedStorageWriter, AccountExtReader,
     ChainSpecProvider, HashingWriter, HeaderProvider, LatestStateProviderRef, OriginalValuesKnown,
diff --git a/bin/reth/src/commands/debug_cmd/merkle.rs b/bin/reth/src/commands/debug_cmd/merkle.rs
index bb8a6a2c4a10..f14482423c67 100644
--- a/bin/reth/src/commands/debug_cmd/merkle.rs
+++ b/bin/reth/src/commands/debug_cmd/merkle.rs
@@ -17,6 +17,7 @@ use reth_evm::execute::{BatchExecutor, BlockExecutorProvider};
 use reth_network::{BlockDownloaderProvider, NetworkHandle};
 use reth_network_api::NetworkInfo;
 use reth_network_p2p::full_block::FullBlockClient;
+use reth_node_api::NodePrimitives;
 use reth_node_ethereum::EthExecutorProvider;
 use reth_provider::{
     providers::ProviderNodeTypes, writer::UnifiedStorageWriter, BlockNumReader, BlockWriter,
@@ -144,7 +145,7 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
         for block in blocks.into_iter().rev() {
             let block_number = block.number;
             let sealed_block = block
-                .try_seal_with_senders()
+                .try_seal_with_senders::<<N::Primitives as NodePrimitives>::Block>()
                 .map_err(|block| eyre::eyre!("Error sealing block with senders: {block:?}"))?;
             trace!(target: "reth::cli", block_number, "Executing block");
 
diff --git a/crates/blockchain-tree/src/blockchain_tree.rs b/crates/blockchain-tree/src/blockchain_tree.rs
index d2ff0f5c8445..bbf1cb099617 100644
--- a/crates/blockchain-tree/src/blockchain_tree.rs
+++ b/crates/blockchain-tree/src/blockchain_tree.rs
@@ -1589,7 +1589,9 @@ mod tests {
                           body: Vec<TransactionSignedEcRecovered>,
                           num_of_signer_txs: u64|
          -> SealedBlockWithSenders {
-            let transactions_root = calculate_transaction_root(&body);
+            let signed_body =
+                body.clone().into_iter().map(|tx| tx.into_signed()).collect::<Vec<_>>();
+            let transactions_root = calculate_transaction_root(&signed_body);
             let receipts = body
                 .iter()
                 .enumerate()
@@ -1635,7 +1637,7 @@ mod tests {
                 SealedBlock {
                     header: SealedHeader::seal(header),
                     body: BlockBody {
-                        transactions: body.clone().into_iter().map(|tx| tx.into_signed()).collect(),
+                        transactions: signed_body,
                         ommers: Vec::new(),
                         withdrawals: Some(Withdrawals::default()),
                     },
diff --git a/crates/blockchain-tree/src/externals.rs b/crates/blockchain-tree/src/externals.rs
index 2b9dae9a3dfd..f61de4c4336d 100644
--- a/crates/blockchain-tree/src/externals.rs
+++ b/crates/blockchain-tree/src/externals.rs
@@ -5,24 +5,40 @@ use reth_consensus::Consensus;
 use reth_db::{static_file::BlockHashMask, tables};
 use reth_db_api::{cursor::DbCursorRO, transaction::DbTx};
 use reth_node_types::{FullNodePrimitives, NodeTypesWithDB};
-use reth_primitives::{BlockBody, StaticFileSegment};
+use reth_primitives::StaticFileSegment;
 use reth_provider::{
-    providers::ProviderNodeTypes, ChainStateBlockReader, ChainStateBlockWriter, ProviderFactory,
-    StaticFileProviderFactory, StatsReader,
+    providers::{NodeTypesForProvider, ProviderNodeTypes},
+    ChainStateBlockReader, ChainStateBlockWriter, ProviderFactory, StaticFileProviderFactory,
+    StatsReader,
 };
 use reth_storage_errors::provider::ProviderResult;
 use std::{collections::BTreeMap, sync::Arc};
 
 /// A helper trait with requirements for [`ProviderNodeTypes`] to be used within [`TreeExternals`].
-pub trait TreeNodeTypes:
-    ProviderNodeTypes<Primitives: FullNodePrimitives<BlockBody = BlockBody>>
+pub trait NodeTypesForTree:
+    NodeTypesForProvider<
+    Primitives: FullNodePrimitives<
+        Block = reth_primitives::Block,
+        BlockBody = reth_primitives::BlockBody,
+    >,
+>
 {
 }
-impl<T> TreeNodeTypes for T where
-    T: ProviderNodeTypes<Primitives: FullNodePrimitives<BlockBody = BlockBody>>
+
+impl<T> NodeTypesForTree for T where
+    T: NodeTypesForProvider<
+        Primitives: FullNodePrimitives<
+            Block = reth_primitives::Block,
+            BlockBody = reth_primitives::BlockBody,
+        >,
+    >
 {
 }
 
+/// A helper trait with requirements for [`ProviderNodeTypes`] to be used within [`TreeExternals`].
+pub trait TreeNodeTypes: ProviderNodeTypes + NodeTypesForTree {}
+impl<T> TreeNodeTypes for T where T: ProviderNodeTypes + NodeTypesForTree {}
+
 /// A container for external components.
 ///
 /// This is a simple container for external components used throughout the blockchain tree
diff --git a/crates/chain-state/src/test_utils.rs b/crates/chain-state/src/test_utils.rs
index af0c363fe486..866a6d74a0b5 100644
--- a/crates/chain-state/src/test_utils.rs
+++ b/crates/chain-state/src/test_utils.rs
@@ -139,7 +139,9 @@ impl TestBlockBuilder {
             gas_limit: self.chain_spec.max_gas_limit,
             mix_hash: B256::random(),
             base_fee_per_gas: Some(INITIAL_BASE_FEE),
-            transactions_root: calculate_transaction_root(&transactions),
+            transactions_root: calculate_transaction_root(
+                &transactions.clone().into_iter().map(|tx| tx.into_signed()).collect::<Vec<_>>(),
+            ),
             receipts_root: calculate_receipt_root(&receipts),
             beneficiary: Address::random(),
             state_root: state_root_unhashed(HashMap::from([(
diff --git a/crates/cli/commands/src/common.rs b/crates/cli/commands/src/common.rs
index 251e01a105a9..4a42d9f29f7a 100644
--- a/crates/cli/commands/src/common.rs
+++ b/crates/cli/commands/src/common.rs
@@ -197,11 +197,21 @@ impl AccessRights {
 /// [`NodeTypes`](reth_node_builder::NodeTypes) in CLI.
 pub trait CliNodeTypes:
     NodeTypesWithEngine
-    + NodeTypesForProvider<Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>>
+    + NodeTypesForProvider<
+        Primitives: FullNodePrimitives<
+            Block = reth_primitives::Block,
+            BlockBody = reth_primitives::BlockBody,
+        >,
+    >
 {
 }
 impl<N> CliNodeTypes for N where
     N: NodeTypesWithEngine
-        + NodeTypesForProvider<Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>>
+        + NodeTypesForProvider<
+            Primitives: FullNodePrimitives<
+                Block = reth_primitives::Block,
+                BlockBody = reth_primitives::BlockBody,
+            >,
+        >
 {
 }
diff --git a/crates/cli/commands/src/init_state/without_evm.rs b/crates/cli/commands/src/init_state/without_evm.rs
index e3594a593638..22236d14c76b 100644
--- a/crates/cli/commands/src/init_state/without_evm.rs
+++ b/crates/cli/commands/src/init_state/without_evm.rs
@@ -33,7 +33,7 @@ pub fn setup_without_evm<Provider>(
 where
     Provider: StaticFileProviderFactory
         + StageCheckpointWriter
-        + BlockWriter<Body: reth_node_api::BlockBody>,
+        + BlockWriter<Block: reth_node_api::Block<Header = reth_primitives::Header>>,
 {
     info!(target: "reth::cli", "Setting up dummy EVM chain before importing state.");
 
@@ -64,7 +64,8 @@ fn append_first_block<Provider>(
     total_difficulty: U256,
 ) -> Result<(), eyre::Error>
 where
-    Provider: BlockWriter<Body: reth_node_api::BlockBody> + StaticFileProviderFactory,
+    Provider: BlockWriter<Block: reth_node_api::Block<Header = reth_primitives::Header>>
+        + StaticFileProviderFactory,
 {
     provider_rw.insert_block(
         SealedBlockWithSenders::new(SealedBlock::new(header.clone(), Default::default()), vec![])
diff --git a/crates/consensus/beacon/src/engine/mod.rs b/crates/consensus/beacon/src/engine/mod.rs
index 0fedbdd452de..338299c3ba23 100644
--- a/crates/consensus/beacon/src/engine/mod.rs
+++ b/crates/consensus/beacon/src/engine/mod.rs
@@ -1992,6 +1992,7 @@ mod tests {
     use assert_matches::assert_matches;
     use reth_chainspec::{ChainSpecBuilder, MAINNET};
     use reth_node_types::FullNodePrimitives;
+    use reth_primitives::BlockSealExt;
     use reth_provider::{BlockWriter, ProviderFactory, StorageLocation};
     use reth_rpc_types_compat::engine::payload::block_to_payload_v1;
     use reth_stages::{ExecOutput, PipelineError, StageError};
diff --git a/crates/consensus/common/src/validation.rs b/crates/consensus/common/src/validation.rs
index 6042f16bf50f..1709e3a14f4d 100644
--- a/crates/consensus/common/src/validation.rs
+++ b/crates/consensus/common/src/validation.rs
@@ -4,7 +4,9 @@ use alloy_consensus::{constants::MAXIMUM_EXTRA_DATA_SIZE, Header};
 use alloy_eips::eip4844::{DATA_GAS_PER_BLOB, MAX_DATA_GAS_PER_BLOCK};
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
 use reth_consensus::ConsensusError;
-use reth_primitives::{BlockBody, EthereumHardfork, GotExpected, SealedBlock, SealedHeader};
+use reth_primitives::{
+    BlockBody, BlockBodyTxExt, EthereumHardfork, GotExpected, SealedBlock, SealedHeader,
+};
 use revm_primitives::calc_excess_blob_gas;
 
 /// Gas used needs to be less than gas limit. Gas used is going to be checked after execution.
diff --git a/crates/e2e-test-utils/src/lib.rs b/crates/e2e-test-utils/src/lib.rs
index 73a7e39f1a49..b9279b16a7fc 100644
--- a/crates/e2e-test-utils/src/lib.rs
+++ b/crates/e2e-test-utils/src/lib.rs
@@ -5,6 +5,7 @@ use std::sync::Arc;
 use node::NodeTestContext;
 use reth::{
     args::{DiscoveryArgs, NetworkArgs, RpcServerArgs},
+    blockchain_tree::externals::NodeTypesForTree,
     builder::{FullNodePrimitives, NodeBuilder, NodeConfig, NodeHandle},
     network::PeersHandleProvider,
     rpc::server_types::RpcModuleSelection,
@@ -53,13 +54,12 @@ pub async fn setup<N>(
     attributes_generator: impl Fn(u64) -> <<N as NodeTypesWithEngine>::Engine as PayloadTypes>::PayloadBuilderAttributes + Copy + 'static,
 ) -> eyre::Result<(Vec<NodeHelperType<N, N::AddOns>>, TaskManager, Wallet)>
 where
-    N: Default + Node<TmpNodeAdapter<N>> + NodeTypesForProvider + NodeTypesWithEngine,
+    N: Default + Node<TmpNodeAdapter<N>> + NodeTypesForTree + NodeTypesWithEngine,
     N::ComponentsBuilder: NodeComponentsBuilder<
         TmpNodeAdapter<N>,
         Components: NodeComponents<TmpNodeAdapter<N>, Network: PeersHandleProvider>,
     >,
     N::AddOns: RethRpcAddOns<Adapter<N>>,
-    N::Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>,
 {
     let tasks = TaskManager::current();
     let exec = tasks.executor();
@@ -134,7 +134,8 @@ where
     LocalPayloadAttributesBuilder<N::ChainSpec>: PayloadAttributesBuilder<
         <<N as NodeTypesWithEngine>::Engine as PayloadTypes>::PayloadAttributes,
     >,
-    N::Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>,
+    N::Primitives:
+        FullNodePrimitives<Block = reth_primitives::Block, BlockBody = reth_primitives::BlockBody>,
 {
     let tasks = TaskManager::current();
     let exec = tasks.executor();
diff --git a/crates/e2e-test-utils/src/node.rs b/crates/e2e-test-utils/src/node.rs
index c3dff527eb20..09c54a867ce4 100644
--- a/crates/e2e-test-utils/src/node.rs
+++ b/crates/e2e-test-utils/src/node.rs
@@ -216,7 +216,7 @@ where
         // get head block from notifications stream and verify the tx has been pushed to the
         // pool is actually present in the canonical block
         let head = self.engine_api.canonical_stream.next().await.unwrap();
-        let tx = head.tip().transactions().next();
+        let tx = head.tip().transactions().first();
         assert_eq!(tx.unwrap().hash().as_slice(), tip_tx_hash.as_slice());
 
         loop {
diff --git a/crates/engine/local/src/miner.rs b/crates/engine/local/src/miner.rs
index 3a0f5a2f1925..a5c7cf4d4c60 100644
--- a/crates/engine/local/src/miner.rs
+++ b/crates/engine/local/src/miner.rs
@@ -210,12 +210,13 @@ where
 
         let block = payload.block();
 
-        let cancun_fields =
-            self.provider.chain_spec().is_cancun_active_at_timestamp(block.timestamp).then(|| {
-                CancunPayloadFields {
-                    parent_beacon_block_root: block.parent_beacon_block_root.unwrap(),
-                    versioned_hashes: block.blob_versioned_hashes().into_iter().copied().collect(),
-                }
+        let cancun_fields = self
+            .provider
+            .chain_spec()
+            .is_cancun_active_at_timestamp(block.timestamp)
+            .then(|| CancunPayloadFields {
+                parent_beacon_block_root: block.parent_beacon_block_root.unwrap(),
+                versioned_hashes: block.body.blob_versioned_hashes().into_iter().copied().collect(),
             });
 
         let (tx, rx) = oneshot::channel();
diff --git a/crates/engine/tree/src/persistence.rs b/crates/engine/tree/src/persistence.rs
index 86d18ceb48ce..e56ed30c58bf 100644
--- a/crates/engine/tree/src/persistence.rs
+++ b/crates/engine/tree/src/persistence.rs
@@ -21,11 +21,15 @@ use tracing::{debug, error};
 /// A helper trait with requirements for [`ProviderNodeTypes`] to be used within
 /// [`PersistenceService`].
 pub trait PersistenceNodeTypes:
-    ProviderNodeTypes<Primitives: FullNodePrimitives<BlockBody = BlockBody>>
+    ProviderNodeTypes<
+    Primitives: FullNodePrimitives<Block = reth_primitives::Block, BlockBody = BlockBody>,
+>
 {
 }
 impl<T> PersistenceNodeTypes for T where
-    T: ProviderNodeTypes<Primitives: FullNodePrimitives<BlockBody = BlockBody>>
+    T: ProviderNodeTypes<
+        Primitives: FullNodePrimitives<Block = reth_primitives::Block, BlockBody = BlockBody>,
+    >
 {
 }
 /// Writes parts of reth's in memory tree state to the database and static files.
diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 39843377684c..8aa46f165c5e 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -2609,6 +2609,7 @@ mod tests {
     use reth_engine_primitives::ForkchoiceStatus;
     use reth_ethereum_engine_primitives::EthEngineTypes;
     use reth_evm::test_utils::MockExecutorProvider;
+    use reth_primitives::BlockSealExt;
     use reth_provider::test_utils::MockEthProvider;
     use reth_rpc_types_compat::engine::{block_to_payload_v1, payload::block_to_payload_v3};
     use reth_trie::updates::TrieUpdates;
diff --git a/crates/engine/util/src/reorg.rs b/crates/engine/util/src/reorg.rs
index fd80fa9e1658..0758b2fd5922 100644
--- a/crates/engine/util/src/reorg.rs
+++ b/crates/engine/util/src/reorg.rs
@@ -18,7 +18,7 @@ use reth_evm::{
     ConfigureEvm,
 };
 use reth_payload_validator::ExecutionPayloadValidator;
-use reth_primitives::{proofs, Block, BlockBody, Receipt, Receipts};
+use reth_primitives::{proofs, Block, BlockBody, BlockSealExt, Receipt, Receipts};
 use reth_provider::{BlockReader, ExecutionOutcome, ProviderError, StateProviderFactory};
 use reth_revm::{
     database::StateProviderDatabase,
diff --git a/crates/ethereum/evm/src/execute.rs b/crates/ethereum/evm/src/execute.rs
index e339268a99a7..7c17ef64a33e 100644
--- a/crates/ethereum/evm/src/execute.rs
+++ b/crates/ethereum/evm/src/execute.rs
@@ -319,7 +319,9 @@ mod tests {
         BasicBlockExecutorProvider, BatchExecutor, BlockExecutorProvider, Executor,
     };
     use reth_execution_types::BlockExecutionOutput;
-    use reth_primitives::{public_key_to_address, Account, Block, BlockBody, Transaction};
+    use reth_primitives::{
+        public_key_to_address, Account, Block, BlockBody, BlockSealExt, Transaction,
+    };
     use reth_revm::{
         database::StateProviderDatabase, test_utils::StateProviderTest, TransitionState,
     };
diff --git a/crates/ethereum/node/tests/e2e/dev.rs b/crates/ethereum/node/tests/e2e/dev.rs
index b6d0ffcfaaaf..bdf444c81093 100644
--- a/crates/ethereum/node/tests/e2e/dev.rs
+++ b/crates/ethereum/node/tests/e2e/dev.rs
@@ -63,7 +63,7 @@ where
 
     let head = notifications.next().await.unwrap();
 
-    let tx = head.tip().transactions().next().unwrap();
+    let tx = &head.tip().transactions()[0];
     assert_eq!(tx.hash(), hash);
     println!("mined transaction: {hash}");
 }
diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index b2f78da6de97..a90e700bdd7c 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -27,7 +27,7 @@ use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::PayloadBuilderAttributes;
 use reth_primitives::{
     proofs::{self},
-    Block, BlockBody, EthereumHardforks, Receipt,
+    Block, BlockBody, BlockSealExt, EthereumHardforks, Receipt,
 };
 use reth_provider::{ChainSpecProvider, StateProviderFactory};
 use reth_revm::database::StateProviderDatabase;
diff --git a/crates/evm/execution-types/src/chain.rs b/crates/evm/execution-types/src/chain.rs
index 200a37423cfa..6aed8422bc33 100644
--- a/crates/evm/execution-types/src/chain.rs
+++ b/crates/evm/execution-types/src/chain.rs
@@ -236,7 +236,7 @@ impl<N: NodePrimitives> Chain<N> {
             self.blocks().iter().zip(self.execution_outcome.receipts().iter())
         {
             let mut tx_receipts = Vec::with_capacity(receipts.len());
-            for (tx, receipt) in block.body.transactions().zip(receipts.iter()) {
+            for (tx, receipt) in block.body.transactions.iter().zip(receipts.iter()) {
                 tx_receipts.push((
                     tx.hash(),
                     receipt.as_ref().expect("receipts have not been pruned").clone(),
@@ -417,7 +417,7 @@ impl ChainBlocks<'_> {
     /// Returns an iterator over all transactions in the chain.
     #[inline]
     pub fn transactions(&self) -> impl Iterator<Item = &TransactionSigned> + '_ {
-        self.blocks.values().flat_map(|block| block.body.transactions())
+        self.blocks.values().flat_map(|block| block.body.transactions.iter())
     }
 
     /// Returns an iterator over all transactions and their senders.
@@ -441,7 +441,7 @@ impl ChainBlocks<'_> {
     /// Returns an iterator over all transaction hashes in the block
     #[inline]
     pub fn transaction_hashes(&self) -> impl Iterator<Item = TxHash> + '_ {
-        self.blocks.values().flat_map(|block| block.transactions().map(|tx| tx.hash()))
+        self.blocks.values().flat_map(|block| block.transactions().iter().map(|tx| tx.hash()))
     }
 }
 
diff --git a/crates/exex/exex/src/backfill/job.rs b/crates/exex/exex/src/backfill/job.rs
index 77a7b50477b0..468515db217c 100644
--- a/crates/exex/exex/src/backfill/job.rs
+++ b/crates/exex/exex/src/backfill/job.rs
@@ -8,7 +8,7 @@ use alloy_primitives::BlockNumber;
 use reth_evm::execute::{
     BatchExecutor, BlockExecutionError, BlockExecutionOutput, BlockExecutorProvider, Executor,
 };
-use reth_primitives::{Block, BlockWithSenders, Receipt};
+use reth_primitives::{Block, BlockSealExt, BlockWithSenders, Receipt};
 use reth_primitives_traits::format_gas_throughput;
 use reth_provider::{
     BlockReader, Chain, HeaderProvider, ProviderError, StateProviderFactory, TransactionVariant,
diff --git a/crates/exex/exex/src/backfill/test_utils.rs b/crates/exex/exex/src/backfill/test_utils.rs
index 169d2d758de7..f0d8afbab859 100644
--- a/crates/exex/exex/src/backfill/test_utils.rs
+++ b/crates/exex/exex/src/backfill/test_utils.rs
@@ -11,7 +11,7 @@ use reth_evm::execute::{
 use reth_evm_ethereum::execute::EthExecutorProvider;
 use reth_node_api::FullNodePrimitives;
 use reth_primitives::{
-    Block, BlockBody, BlockWithSenders, Receipt, SealedBlockWithSenders, Transaction,
+    Block, BlockBody, BlockSealExt, BlockWithSenders, Receipt, SealedBlockWithSenders, Transaction,
 };
 use reth_provider::{
     providers::ProviderNodeTypes, BlockWriter as _, ExecutionOutcome, LatestStateProviderRef,
@@ -58,7 +58,12 @@ pub(crate) fn execute_block_and_commit_to_database<N>(
     block: &BlockWithSenders,
 ) -> eyre::Result<BlockExecutionOutput<Receipt>>
 where
-    N: ProviderNodeTypes<Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>>,
+    N: ProviderNodeTypes<
+        Primitives: FullNodePrimitives<
+            Block = reth_primitives::Block,
+            BlockBody = reth_primitives::BlockBody,
+        >,
+    >,
 {
     let provider = provider_factory.provider()?;
 
@@ -162,7 +167,12 @@ pub(crate) fn blocks_and_execution_outputs<N>(
     key_pair: Keypair,
 ) -> eyre::Result<Vec<(SealedBlockWithSenders, BlockExecutionOutput<Receipt>)>>
 where
-    N: ProviderNodeTypes<Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>>,
+    N: ProviderNodeTypes<
+        Primitives: FullNodePrimitives<
+            Block = reth_primitives::Block,
+            BlockBody = reth_primitives::BlockBody,
+        >,
+    >,
 {
     let (block1, block2) = blocks(chain_spec.clone(), key_pair)?;
 
@@ -184,7 +194,7 @@ pub(crate) fn blocks_and_execution_outcome<N>(
 ) -> eyre::Result<(Vec<SealedBlockWithSenders>, ExecutionOutcome)>
 where
     N: ProviderNodeTypes,
-    N::Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>,
+    N::Primitives: FullNodePrimitives<Block = reth_primitives::Block>,
 {
     let (block1, block2) = blocks(chain_spec.clone(), key_pair)?;
 
diff --git a/crates/exex/exex/src/manager.rs b/crates/exex/exex/src/manager.rs
index e3d3a3c06901..ea5ddf2e8c62 100644
--- a/crates/exex/exex/src/manager.rs
+++ b/crates/exex/exex/src/manager.rs
@@ -1235,7 +1235,7 @@ mod tests {
             genesis_block.number + 1,
             BlockParams { parent: Some(genesis_hash), ..Default::default() },
         )
-        .seal_with_senders()
+        .seal_with_senders::<reth_primitives::Block>()
         .unwrap();
         let provider_rw = provider_factory.database_provider_rw().unwrap();
         provider_rw.insert_block(block.clone(), StorageLocation::Database).unwrap();
diff --git a/crates/exex/exex/src/notifications.rs b/crates/exex/exex/src/notifications.rs
index baf504166d19..ed574a65aa31 100644
--- a/crates/exex/exex/src/notifications.rs
+++ b/crates/exex/exex/src/notifications.rs
@@ -400,7 +400,7 @@ mod tests {
     use futures::StreamExt;
     use reth_db_common::init::init_genesis;
     use reth_evm_ethereum::execute::EthExecutorProvider;
-    use reth_primitives::Block;
+    use reth_primitives::{Block, BlockSealExt};
     use reth_provider::{
         providers::BlockchainProvider2, test_utils::create_test_provider_factory, BlockWriter,
         Chain, DatabaseProviderFactory, StorageLocation,
@@ -567,7 +567,7 @@ mod tests {
             genesis_block.number + 1,
             BlockParams { parent: Some(genesis_hash), tx_count: Some(0), ..Default::default() },
         )
-        .seal_with_senders()
+        .seal_with_senders::<reth_primitives::Block>()
         .ok_or_eyre("failed to recover senders")?;
         let node_head = Head {
             number: node_head_block.number,
diff --git a/crates/exex/exex/src/wal/mod.rs b/crates/exex/exex/src/wal/mod.rs
index 41a7829a70f3..066fbe1b58c1 100644
--- a/crates/exex/exex/src/wal/mod.rs
+++ b/crates/exex/exex/src/wal/mod.rs
@@ -268,21 +268,25 @@ mod tests {
         // Create 4 canonical blocks and one reorged block with number 2
         let blocks = random_block_range(&mut rng, 0..=3, BlockRangeParams::default())
             .into_iter()
-            .map(|block| block.seal_with_senders().ok_or_eyre("failed to recover senders"))
+            .map(|block| {
+                block
+                    .seal_with_senders::<reth_primitives::Block>()
+                    .ok_or_eyre("failed to recover senders")
+            })
             .collect::<eyre::Result<Vec<_>>>()?;
         let block_1_reorged = random_block(
             &mut rng,
             1,
             BlockParams { parent: Some(blocks[0].hash()), ..Default::default() },
         )
-        .seal_with_senders()
+        .seal_with_senders::<reth_primitives::Block>()
         .ok_or_eyre("failed to recover senders")?;
         let block_2_reorged = random_block(
             &mut rng,
             2,
             BlockParams { parent: Some(blocks[1].hash()), ..Default::default() },
         )
-        .seal_with_senders()
+        .seal_with_senders::<reth_primitives::Block>()
         .ok_or_eyre("failed to recover senders")?;
 
         // Create notifications for the above blocks.
diff --git a/crates/exex/test-utils/src/lib.rs b/crates/exex/test-utils/src/lib.rs
index 5b2267505c57..069da6668afd 100644
--- a/crates/exex/test-utils/src/lib.rs
+++ b/crates/exex/test-utils/src/lib.rs
@@ -45,7 +45,7 @@ use reth_node_ethereum::{
     EthEngineTypes, EthEvmConfig,
 };
 use reth_payload_builder::noop::NoopPayloadBuilderService;
-use reth_primitives::{EthPrimitives, Head, SealedBlockWithSenders};
+use reth_primitives::{BlockSealExt, EthPrimitives, Head, SealedBlockWithSenders};
 use reth_provider::{
     providers::{BlockchainProvider, StaticFileProvider},
     BlockReader, EthStorage, ProviderFactory,
@@ -306,7 +306,7 @@ pub async fn test_exex_context_with_chain_spec(
         .block_by_hash(genesis_hash)?
         .ok_or_else(|| eyre::eyre!("genesis block not found"))?
         .seal_slow()
-        .seal_with_senders()
+        .seal_with_senders::<reth_primitives::Block>()
         .ok_or_else(|| eyre::eyre!("failed to recover senders"))?;
 
     let head = Head {
diff --git a/crates/node/builder/src/builder/mod.rs b/crates/node/builder/src/builder/mod.rs
index 65ae704fe831..7cbad445da1e 100644
--- a/crates/node/builder/src/builder/mod.rs
+++ b/crates/node/builder/src/builder/mod.rs
@@ -10,6 +10,7 @@ use crate::{
     DefaultNodeLauncher, LaunchNode, Node, NodeHandle,
 };
 use futures::Future;
+use reth_blockchain_tree::externals::NodeTypesForTree;
 use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
 use reth_cli_util::get_secret_key;
 use reth_db_api::{
@@ -358,7 +359,7 @@ where
         >,
     >
     where
-        N: Node<RethFullAdapter<DB, N>, ChainSpec = ChainSpec> + NodeTypesForProvider,
+        N: Node<RethFullAdapter<DB, N>, ChainSpec = ChainSpec> + NodeTypesForTree,
         N::AddOns: RethRpcAddOns<
             NodeAdapter<
                 RethFullAdapter<DB, N>,
@@ -553,10 +554,9 @@ where
 impl<T, DB, CB, AO> WithLaunchContext<NodeBuilderWithComponents<RethFullAdapter<DB, T>, CB, AO>>
 where
     DB: Database + DatabaseMetrics + DatabaseMetadata + Clone + Unpin + 'static,
-    T: NodeTypesWithEngine + NodeTypesForProvider,
+    T: NodeTypesWithEngine + NodeTypesForTree,
     CB: NodeComponentsBuilder<RethFullAdapter<DB, T>>,
     AO: RethRpcAddOns<NodeAdapter<RethFullAdapter<DB, T>, CB::Components>>,
-    T::Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>,
 {
     /// Launches the node with the [`DefaultNodeLauncher`] that sets up engine API consensus and rpc
     pub async fn launch(
diff --git a/crates/node/builder/src/launch/engine.rs b/crates/node/builder/src/launch/engine.rs
index ef1edc899ebe..6afcace5b152 100644
--- a/crates/node/builder/src/launch/engine.rs
+++ b/crates/node/builder/src/launch/engine.rs
@@ -12,6 +12,7 @@ use reth_engine_local::{LocalEngineService, LocalPayloadAttributesBuilder};
 use reth_engine_service::service::{ChainEvent, EngineService};
 use reth_engine_tree::{
     engine::{EngineApiRequest, EngineRequestHandler},
+    persistence::PersistenceNodeTypes,
     tree::TreeConfig,
 };
 use reth_engine_util::EngineMessageStreamExt;
@@ -19,8 +20,8 @@ use reth_exex::ExExManagerHandle;
 use reth_network::{NetworkSyncUpdater, SyncState};
 use reth_network_api::BlockDownloaderProvider;
 use reth_node_api::{
-    BuiltPayload, FullNodePrimitives, FullNodeTypes, NodeTypesWithEngine, PayloadAttributesBuilder,
-    PayloadBuilder, PayloadTypes,
+    BuiltPayload, FullNodeTypes, NodeTypesWithEngine, PayloadAttributesBuilder, PayloadBuilder,
+    PayloadTypes,
 };
 use reth_node_core::{
     dirs::{ChainPath, DataDirPath},
@@ -70,14 +71,13 @@ impl EngineNodeLauncher {
 
 impl<Types, T, CB, AO> LaunchNode<NodeBuilderWithComponents<T, CB, AO>> for EngineNodeLauncher
 where
-    Types: ProviderNodeTypes + NodeTypesWithEngine,
+    Types: ProviderNodeTypes + NodeTypesWithEngine + PersistenceNodeTypes,
     T: FullNodeTypes<Types = Types, Provider = BlockchainProvider2<Types>>,
     CB: NodeComponentsBuilder<T>,
     AO: RethRpcAddOns<NodeAdapter<T, CB::Components>>,
     LocalPayloadAttributesBuilder<Types::ChainSpec>: PayloadAttributesBuilder<
         <<Types as NodeTypesWithEngine>::Engine as PayloadTypes>::PayloadAttributes,
     >,
-    Types::Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>,
 {
     type Node = NodeHandle<NodeAdapter<T, CB::Components>, AO>;
 
diff --git a/crates/node/builder/src/launch/mod.rs b/crates/node/builder/src/launch/mod.rs
index a1819948ee48..4335073b404c 100644
--- a/crates/node/builder/src/launch/mod.rs
+++ b/crates/node/builder/src/launch/mod.rs
@@ -16,13 +16,15 @@ use reth_beacon_consensus::{
     hooks::{EngineHooks, PruneHook, StaticFileHook},
     BeaconConsensusEngine,
 };
-use reth_blockchain_tree::{noop::NoopBlockchainTree, BlockchainTreeConfig};
+use reth_blockchain_tree::{
+    externals::TreeNodeTypes, noop::NoopBlockchainTree, BlockchainTreeConfig,
+};
 use reth_chainspec::EthChainSpec;
 use reth_consensus_debug_client::{DebugConsensusClient, EtherscanBlockProvider, RpcBlockProvider};
 use reth_engine_util::EngineMessageStreamExt;
 use reth_exex::ExExManagerHandle;
 use reth_network::BlockDownloaderProvider;
-use reth_node_api::{AddOnsContext, FullNodePrimitives, FullNodeTypes, NodeTypesWithEngine};
+use reth_node_api::{AddOnsContext, FullNodeTypes, NodeTypesWithEngine};
 use reth_node_core::{
     dirs::{ChainPath, DataDirPath},
     exit::NodeExitFuture,
@@ -98,11 +100,10 @@ impl DefaultNodeLauncher {
 
 impl<Types, T, CB, AO> LaunchNode<NodeBuilderWithComponents<T, CB, AO>> for DefaultNodeLauncher
 where
-    Types: ProviderNodeTypes + NodeTypesWithEngine,
+    Types: ProviderNodeTypes + NodeTypesWithEngine + TreeNodeTypes,
     T: FullNodeTypes<Provider = BlockchainProvider<Types>, Types = Types>,
     CB: NodeComponentsBuilder<T>,
     AO: RethRpcAddOns<NodeAdapter<T, CB::Components>>,
-    Types::Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>,
 {
     type Node = NodeHandle<NodeAdapter<T, CB::Components>, AO>;
 
diff --git a/crates/optimism/payload/src/builder.rs b/crates/optimism/payload/src/builder.rs
index 132c26492721..2185d1982ea8 100644
--- a/crates/optimism/payload/src/builder.rs
+++ b/crates/optimism/payload/src/builder.rs
@@ -18,7 +18,9 @@ use reth_optimism_forks::OpHardforks;
 use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::PayloadBuilderAttributes;
 use reth_payload_util::PayloadTransactions;
-use reth_primitives::{proofs, Block, BlockBody, Receipt, SealedHeader, TransactionSigned, TxType};
+use reth_primitives::{
+    proofs, Block, BlockBody, BlockSealExt, Receipt, SealedHeader, TransactionSigned, TxType,
+};
 use reth_provider::{ProviderError, StateProofProvider, StateProviderFactory, StateRootProvider};
 use reth_revm::database::StateProviderDatabase;
 use reth_transaction_pool::{
diff --git a/crates/payload/builder/src/test_utils.rs b/crates/payload/builder/src/test_utils.rs
index 5025a12ed718..2f478f8add7e 100644
--- a/crates/payload/builder/src/test_utils.rs
+++ b/crates/payload/builder/src/test_utils.rs
@@ -9,7 +9,7 @@ use alloy_primitives::U256;
 use reth_chain_state::{CanonStateNotification, ExecutedBlock};
 use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::{PayloadKind, PayloadTypes};
-use reth_primitives::Block;
+use reth_primitives::{Block, BlockSealExt};
 use std::{
     future::Future,
     pin::Pin,
diff --git a/crates/payload/validator/src/lib.rs b/crates/payload/validator/src/lib.rs
index e74b5f48d40f..cfaac1fbc70a 100644
--- a/crates/payload/validator/src/lib.rs
+++ b/crates/payload/validator/src/lib.rs
@@ -12,7 +12,7 @@ use alloy_rpc_types::engine::{
     ExecutionPayload, ExecutionPayloadSidecar, MaybeCancunPayloadFields, PayloadError,
 };
 use reth_chainspec::EthereumHardforks;
-use reth_primitives::SealedBlock;
+use reth_primitives::{BlockSealExt, SealedBlock};
 use reth_rpc_types_compat::engine::payload::try_into_block;
 use std::sync::Arc;
 
diff --git a/crates/primitives-traits/src/block/body.rs b/crates/primitives-traits/src/block/body.rs
index fd7f7f1c631f..fa0e4f256b75 100644
--- a/crates/primitives-traits/src/block/body.rs
+++ b/crates/primitives-traits/src/block/body.rs
@@ -12,7 +12,6 @@ pub trait FullBlockBody: BlockBody<Transaction: FullSignedTx> {}
 impl<T> FullBlockBody for T where T: BlockBody<Transaction: FullSignedTx> {}
 
 /// Abstraction for block's body.
-#[auto_impl::auto_impl(&, Arc)]
 pub trait BlockBody:
     Send
     + Sync
@@ -33,4 +32,7 @@ pub trait BlockBody:
 
     /// Returns reference to transactions in block.
     fn transactions(&self) -> &[Self::Transaction];
+
+    /// Consume the block body and return a [`Vec`] of transactions.
+    fn into_transactions(self) -> Vec<Self::Transaction>;
 }
diff --git a/crates/primitives-traits/src/block/mod.rs b/crates/primitives-traits/src/block/mod.rs
index c0f5a1ffc63c..10521075095c 100644
--- a/crates/primitives-traits/src/block/mod.rs
+++ b/crates/primitives-traits/src/block/mod.rs
@@ -6,7 +6,8 @@ pub mod header;
 use alloc::fmt;
 
 use crate::{
-    BlockHeader, FullBlockBody, FullBlockHeader, InMemorySize, MaybeArbitrary, MaybeSerde,
+    BlockBody, BlockHeader, FullBlockBody, FullBlockHeader, InMemorySize, MaybeArbitrary,
+    MaybeSerde,
 };
 
 /// Helper trait that unifies all behaviour required by block to support full node operations.
@@ -26,7 +27,6 @@ impl<T> FullBlock for T where
 // todo: make sealable super-trait, depends on <https://github.com/paradigmxyz/reth/issues/11449>
 // todo: make with senders extension trait, so block can be impl by block type already containing
 // senders
-#[auto_impl::auto_impl(&, Arc)]
 pub trait Block:
     Send
     + Sync
@@ -44,11 +44,17 @@ pub trait Block:
     type Header: BlockHeader + 'static;
 
     /// The block's body contains the transactions in the block.
-    type Body: Send + Sync + Unpin + 'static;
+    type Body: BlockBody + Send + Sync + Unpin + 'static;
+
+    /// Create new block instance.
+    fn new(header: Self::Header, body: Self::Body) -> Self;
 
     /// Returns reference to block header.
     fn header(&self) -> &Self::Header;
 
     /// Returns reference to block body.
     fn body(&self) -> &Self::Body;
+
+    /// Splits the block into its header and body.
+    fn split(self) -> (Self::Header, Self::Body);
 }
diff --git a/crates/primitives/src/block.rs b/crates/primitives/src/block.rs
index a93b1cf538a7..fbb08d084152 100644
--- a/crates/primitives/src/block.rs
+++ b/crates/primitives/src/block.rs
@@ -1,13 +1,16 @@
-use crate::{GotExpected, SealedHeader, TransactionSigned, TransactionSignedEcRecovered};
+use crate::{
+    traits::BlockSealExt, transaction::SignedTransactionIntoRecoveredExt, BlockBodyTxExt,
+    GotExpected, SealedHeader, TransactionSigned, TransactionSignedEcRecovered,
+};
 use alloc::vec::Vec;
 use alloy_consensus::Header;
 use alloy_eips::{eip2718::Encodable2718, eip4895::Withdrawals};
-use alloy_primitives::{Address, Bytes, Sealable, B256};
+use alloy_primitives::{Address, Bytes, B256};
 use alloy_rlp::{Decodable, Encodable, RlpDecodable, RlpEncodable};
 use derive_more::{Deref, DerefMut};
 #[cfg(any(test, feature = "arbitrary"))]
 pub use reth_primitives_traits::test_utils::{generate_valid_header, valid_header_strategy};
-use reth_primitives_traits::InMemorySize;
+use reth_primitives_traits::{BlockBody as _, InMemorySize, SignedTransaction};
 use serde::{Deserialize, Serialize};
 
 /// Ethereum full block.
@@ -23,73 +26,14 @@ pub struct Block {
     pub body: BlockBody,
 }
 
-impl Block {
-    /// Calculate the header hash and seal the block so that it can't be changed.
-    pub fn seal_slow(self) -> SealedBlock {
-        SealedBlock { header: SealedHeader::seal(self.header), body: self.body }
-    }
-
-    /// Seal the block with a known hash.
-    ///
-    /// WARNING: This method does not perform validation whether the hash is correct.
-    pub fn seal(self, hash: B256) -> SealedBlock {
-        SealedBlock { header: SealedHeader::new(self.header, hash), body: self.body }
-    }
-
-    /// Expensive operation that recovers transaction signer. See [`SealedBlockWithSenders`].
-    pub fn senders(&self) -> Option<Vec<Address>> {
-        self.body.recover_signers()
-    }
-
-    /// Transform into a [`BlockWithSenders`].
-    ///
-    /// # Panics
-    ///
-    /// If the number of senders does not match the number of transactions in the block
-    /// and the signer recovery for one of the transactions fails.
-    ///
-    /// Note: this is expected to be called with blocks read from disk.
-    #[track_caller]
-    pub fn with_senders_unchecked(self, senders: Vec<Address>) -> BlockWithSenders {
-        self.try_with_senders_unchecked(senders).expect("stored block is valid")
-    }
-
-    /// Transform into a [`BlockWithSenders`] using the given senders.
-    ///
-    /// If the number of senders does not match the number of transactions in the block, this falls
-    /// back to manually recovery, but _without ensuring that the signature has a low `s` value_.
-    /// See also [`TransactionSigned::recover_signer_unchecked`]
-    ///
-    /// Returns an error if a signature is invalid.
-    #[track_caller]
-    pub fn try_with_senders_unchecked(
-        self,
-        senders: Vec<Address>,
-    ) -> Result<BlockWithSenders, Self> {
-        let senders = if self.body.transactions.len() == senders.len() {
-            senders
-        } else {
-            let Some(senders) = self.body.recover_signers_unchecked() else { return Err(self) };
-            senders
-        };
-
-        Ok(BlockWithSenders::new_unchecked(self, senders))
-    }
-
-    /// **Expensive**. Transform into a [`BlockWithSenders`] by recovering senders in the contained
-    /// transactions.
-    ///
-    /// Returns `None` if a transaction is invalid.
-    pub fn with_recovered_senders(self) -> Option<BlockWithSenders> {
-        let senders = self.senders()?;
-        Some(BlockWithSenders::new_unchecked(self, senders))
-    }
-}
-
 impl reth_primitives_traits::Block for Block {
     type Header = Header;
     type Body = BlockBody;
 
+    fn new(header: Self::Header, body: Self::Body) -> Self {
+        Self { header, body }
+    }
+
     fn header(&self) -> &Self::Header {
         &self.header
     }
@@ -97,6 +41,10 @@ impl reth_primitives_traits::Block for Block {
     fn body(&self) -> &Self::Body {
         &self.body
     }
+
+    fn split(self) -> (Self::Header, Self::Body) {
+        (self.header, self.body)
+    }
 }
 
 impl InMemorySize for Block {
@@ -204,44 +152,44 @@ impl<'a> arbitrary::Arbitrary<'a> for Block {
 
 /// Sealed block with senders recovered from transactions.
 #[derive(Debug, Clone, PartialEq, Eq, Default, Deref, DerefMut)]
-pub struct BlockWithSenders {
+pub struct BlockWithSenders<B: reth_primitives_traits::Block = Block> {
     /// Block
     #[deref]
     #[deref_mut]
-    pub block: Block,
+    pub block: B,
     /// List of senders that match the transactions in the block
     pub senders: Vec<Address>,
 }
 
-impl BlockWithSenders {
+impl<B: reth_primitives_traits::Block> BlockWithSenders<B> {
     /// New block with senders
-    pub const fn new_unchecked(block: Block, senders: Vec<Address>) -> Self {
+    pub const fn new_unchecked(block: B, senders: Vec<Address>) -> Self {
         Self { block, senders }
     }
 
     /// New block with senders. Return none if len of tx and senders does not match
-    pub fn new(block: Block, senders: Vec<Address>) -> Option<Self> {
-        (block.body.transactions.len() == senders.len()).then_some(Self { block, senders })
+    pub fn new(block: B, senders: Vec<Address>) -> Option<Self> {
+        (block.body().transactions().len() == senders.len()).then_some(Self { block, senders })
     }
 
     /// Seal the block with a known hash.
     ///
     /// WARNING: This method does not perform validation whether the hash is correct.
     #[inline]
-    pub fn seal(self, hash: B256) -> SealedBlockWithSenders {
+    pub fn seal(self, hash: B256) -> SealedBlockWithSenders<B> {
         let Self { block, senders } = self;
-        SealedBlockWithSenders { block: block.seal(hash), senders }
+        SealedBlockWithSenders::<B> { block: block.seal(hash), senders }
     }
 
     /// Calculate the header hash and seal the block with senders so that it can't be changed.
     #[inline]
-    pub fn seal_slow(self) -> SealedBlockWithSenders {
+    pub fn seal_slow(self) -> SealedBlockWithSenders<B> {
         SealedBlockWithSenders { block: self.block.seal_slow(), senders: self.senders }
     }
 
     /// Split Structure to its components
     #[inline]
-    pub fn into_components(self) -> (Block, Vec<Address>) {
+    pub fn into_components(self) -> (B, Vec<Address>) {
         (self.block, self.senders)
     }
 
@@ -249,18 +197,27 @@ impl BlockWithSenders {
     #[inline]
     pub fn transactions_with_sender(
         &self,
-    ) -> impl Iterator<Item = (&Address, &TransactionSigned)> + '_ {
-        self.senders.iter().zip(self.block.body.transactions())
+    ) -> impl Iterator<Item = (&Address, &<B::Body as reth_primitives_traits::BlockBody>::Transaction)>
+           + '_ {
+        self.senders.iter().zip(self.block.body().transactions())
     }
 
     /// Returns an iterator over all transactions in the chain.
     #[inline]
     pub fn into_transactions_ecrecovered(
         self,
-    ) -> impl Iterator<Item = TransactionSignedEcRecovered> {
+    ) -> impl Iterator<
+        Item = TransactionSignedEcRecovered<
+            <B::Body as reth_primitives_traits::BlockBody>::Transaction,
+        >,
+    >
+    where
+        <B::Body as reth_primitives_traits::BlockBody>::Transaction: SignedTransaction,
+    {
         self.block
-            .body
-            .transactions
+            .split()
+            .1
+            .into_transactions()
             .into_iter()
             .zip(self.senders)
             .map(|(tx, sender)| tx.with_signer(sender))
@@ -268,8 +225,10 @@ impl BlockWithSenders {
 
     /// Consumes the block and returns the transactions of the block.
     #[inline]
-    pub fn into_transactions(self) -> Vec<TransactionSigned> {
-        self.block.body.transactions
+    pub fn into_transactions(
+        self,
+    ) -> Vec<<B::Body as reth_primitives_traits::BlockBody>::Transaction> {
+        self.block.split().1.into_transactions()
     }
 }
 
@@ -308,10 +267,9 @@ impl<H, B> SealedBlock<H, B> {
 }
 
 impl SealedBlock {
-    /// Splits the sealed block into underlying components
-    #[inline]
-    pub fn split(self) -> (SealedHeader, Vec<TransactionSigned>, Vec<Header>) {
-        (self.header, self.body.transactions, self.body.ommers)
+    /// Unseal the block
+    pub fn unseal(self) -> Block {
+        Block { header: self.header.unseal(), body: self.body }
     }
 
     /// Returns an iterator over all blob transactions of the block
@@ -320,6 +278,23 @@ impl SealedBlock {
         self.body.blob_transactions_iter()
     }
 
+    /// Calculates the total gas used by blob transactions in the sealed block.
+    pub fn blob_gas_used(&self) -> u64 {
+        self.blob_transactions().iter().filter_map(|tx| tx.blob_gas_used()).sum()
+    }
+
+    /// Returns whether or not the block contains any blob transactions.
+    #[inline]
+    pub fn has_blob_transactions(&self) -> bool {
+        self.body.has_blob_transactions()
+    }
+
+    /// Returns whether or not the block contains any eip-7702 transactions.
+    #[inline]
+    pub fn has_eip7702_transactions(&self) -> bool {
+        self.body.has_eip7702_transactions()
+    }
+
     /// Returns only the blob transactions, if any, from the block body.
     #[inline]
     pub fn blob_transactions(&self) -> Vec<&TransactionSigned> {
@@ -333,25 +308,42 @@ impl SealedBlock {
             .filter_map(|tx| tx.as_eip4844().map(|blob_tx| &blob_tx.blob_versioned_hashes))
             .flatten()
     }
+}
 
-    /// Returns all blob versioned hashes from the block body.
+impl<H, B> SealedBlock<H, B>
+where
+    H: reth_primitives_traits::BlockHeader,
+    B: reth_primitives_traits::BlockBody,
+{
+    /// Splits the sealed block into underlying components
     #[inline]
-    pub fn blob_versioned_hashes(&self) -> Vec<&B256> {
-        self.blob_versioned_hashes_iter().collect()
+    pub fn split(self) -> (SealedHeader<H>, B) {
+        (self.header, self.body)
     }
 
     /// Expensive operation that recovers transaction signer. See [`SealedBlockWithSenders`].
-    pub fn senders(&self) -> Option<Vec<Address>> {
+    pub fn senders(&self) -> Option<Vec<Address>>
+    where
+        B::Transaction: SignedTransaction,
+    {
         self.body.recover_signers()
     }
 
     /// Seal sealed block with recovered transaction senders.
-    pub fn seal_with_senders(self) -> Option<SealedBlockWithSenders> {
+    pub fn seal_with_senders<T>(self) -> Option<SealedBlockWithSenders<T>>
+    where
+        B::Transaction: SignedTransaction,
+        T: reth_primitives_traits::Block<Header = H, Body = B>,
+    {
         self.try_seal_with_senders().ok()
     }
 
     /// Seal sealed block with recovered transaction senders.
-    pub fn try_seal_with_senders(self) -> Result<SealedBlockWithSenders, Self> {
+    pub fn try_seal_with_senders<T>(self) -> Result<SealedBlockWithSenders<T>, Self>
+    where
+        B::Transaction: SignedTransaction,
+        T: reth_primitives_traits::Block<Header = H, Body = B>,
+    {
         match self.senders() {
             Some(senders) => Ok(SealedBlockWithSenders { block: self, senders }),
             None => Err(self),
@@ -365,7 +357,11 @@ impl SealedBlock {
     /// If the number of senders does not match the number of transactions in the block
     /// and the signer recovery for one of the transactions fails.
     #[track_caller]
-    pub fn with_senders_unchecked(self, senders: Vec<Address>) -> SealedBlockWithSenders {
+    pub fn with_senders_unchecked<T>(self, senders: Vec<Address>) -> SealedBlockWithSenders<T>
+    where
+        B::Transaction: SignedTransaction,
+        T: reth_primitives_traits::Block<Header = H, Body = B>,
+    {
         self.try_with_senders_unchecked(senders).expect("stored block is valid")
     }
 
@@ -377,11 +373,15 @@ impl SealedBlock {
     ///
     /// Returns an error if a signature is invalid.
     #[track_caller]
-    pub fn try_with_senders_unchecked(
+    pub fn try_with_senders_unchecked<T>(
         self,
         senders: Vec<Address>,
-    ) -> Result<SealedBlockWithSenders, Self> {
-        let senders = if self.body.transactions.len() == senders.len() {
+    ) -> Result<SealedBlockWithSenders<T>, Self>
+    where
+        B::Transaction: SignedTransaction,
+        T: reth_primitives_traits::Block<Header = H, Body = B>,
+    {
+        let senders = if self.body.transactions().len() == senders.len() {
             senders
         } else {
             let Some(senders) = self.body.recover_signers_unchecked() else { return Err(self) };
@@ -391,28 +391,6 @@ impl SealedBlock {
         Ok(SealedBlockWithSenders { block: self, senders })
     }
 
-    /// Unseal the block
-    pub fn unseal(self) -> Block {
-        Block { header: self.header.unseal(), body: self.body }
-    }
-
-    /// Calculates the total gas used by blob transactions in the sealed block.
-    pub fn blob_gas_used(&self) -> u64 {
-        self.blob_transactions().iter().filter_map(|tx| tx.blob_gas_used()).sum()
-    }
-
-    /// Returns whether or not the block contains any blob transactions.
-    #[inline]
-    pub fn has_blob_transactions(&self) -> bool {
-        self.body.has_blob_transactions()
-    }
-
-    /// Returns whether or not the block contains any eip-7702 transactions.
-    #[inline]
-    pub fn has_eip7702_transactions(&self) -> bool {
-        self.body.has_eip7702_transactions()
-    }
-
     /// Ensures that the transaction root in the block header is valid.
     ///
     /// The transaction root is the Keccak 256-bit hash of the root node of the trie structure
@@ -425,13 +403,16 @@ impl SealedBlock {
     ///
     /// Returns `Err(error)` if the transaction root validation fails, providing a `GotExpected`
     /// error containing the calculated and expected roots.
-    pub fn ensure_transaction_root_valid(&self) -> Result<(), GotExpected<B256>> {
+    pub fn ensure_transaction_root_valid(&self) -> Result<(), GotExpected<B256>>
+    where
+        B::Transaction: Encodable2718,
+    {
         let calculated_root = self.body.calculate_tx_root();
 
-        if self.header.transactions_root != calculated_root {
+        if self.header.transactions_root() != calculated_root {
             return Err(GotExpected {
                 got: calculated_root,
-                expected: self.header.transactions_root,
+                expected: self.header.transactions_root(),
             })
         }
 
@@ -440,8 +421,11 @@ impl SealedBlock {
 
     /// Returns a vector of transactions RLP encoded with
     /// [`alloy_eips::eip2718::Encodable2718::encoded_2718`].
-    pub fn raw_transactions(&self) -> Vec<Bytes> {
-        self.body.transactions().map(|tx| tx.encoded_2718().into()).collect()
+    pub fn raw_transactions(&self) -> Vec<Bytes>
+    where
+        B::Transaction: Encodable2718,
+    {
+        self.body.transactions().iter().map(|tx| tx.encoded_2718().into()).collect()
     }
 }
 
@@ -477,6 +461,10 @@ where
     type Header = H;
     type Body = B;
 
+    fn new(header: Self::Header, body: Self::Body) -> Self {
+        Self { header: SealedHeader::seal(header), body }
+    }
+
     fn header(&self) -> &Self::Header {
         self.header.header()
     }
@@ -484,6 +472,10 @@ where
     fn body(&self) -> &Self::Body {
         &self.body
     }
+
+    fn split(self) -> (Self::Header, Self::Body) {
+        (self.header.unseal(), self.body)
+    }
 }
 
 #[cfg(any(test, feature = "arbitrary"))]
@@ -499,45 +491,48 @@ where
 
 /// Sealed block with senders recovered from transactions.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Deref, DerefMut)]
-pub struct SealedBlockWithSenders<H = Header, B = BlockBody> {
+pub struct SealedBlockWithSenders<B: reth_primitives_traits::Block = Block> {
     /// Sealed block
     #[deref]
     #[deref_mut]
-    pub block: SealedBlock<H, B>,
+    #[serde(bound = "SealedBlock<B::Header, B::Body>: Serialize + serde::de::DeserializeOwned")]
+    pub block: SealedBlock<B::Header, B::Body>,
     /// List of senders that match transactions from block.
     pub senders: Vec<Address>,
 }
 
-impl<H: Default + Sealable, B: Default> Default for SealedBlockWithSenders<H, B> {
+impl<B: reth_primitives_traits::Block> Default for SealedBlockWithSenders<B> {
     fn default() -> Self {
         Self { block: SealedBlock::default(), senders: Default::default() }
     }
 }
 
-impl<H, B: reth_primitives_traits::BlockBody> SealedBlockWithSenders<H, B> {
+impl<B: reth_primitives_traits::Block> SealedBlockWithSenders<B> {
     /// New sealed block with sender. Return none if len of tx and senders does not match
-    pub fn new(block: SealedBlock<H, B>, senders: Vec<Address>) -> Option<Self> {
+    pub fn new(block: SealedBlock<B::Header, B::Body>, senders: Vec<Address>) -> Option<Self> {
         (block.body.transactions().len() == senders.len()).then_some(Self { block, senders })
     }
 }
 
-impl SealedBlockWithSenders {
+impl<B: reth_primitives_traits::Block> SealedBlockWithSenders<B> {
     /// Split Structure to its components
     #[inline]
-    pub fn into_components(self) -> (SealedBlock, Vec<Address>) {
+    pub fn into_components(self) -> (SealedBlock<B::Header, B::Body>, Vec<Address>) {
         (self.block, self.senders)
     }
 
     /// Returns the unsealed [`BlockWithSenders`]
     #[inline]
-    pub fn unseal(self) -> BlockWithSenders {
-        let Self { block, senders } = self;
-        BlockWithSenders::new_unchecked(block.unseal(), senders)
+    pub fn unseal(self) -> BlockWithSenders<B> {
+        let (block, senders) = self.into_components();
+        let (header, body) = block.split();
+        let header = header.unseal();
+        BlockWithSenders::new_unchecked(B::new(header, body), senders)
     }
 
     /// Returns an iterator over all transactions in the block.
     #[inline]
-    pub fn transactions(&self) -> impl Iterator<Item = &TransactionSigned> + '_ {
+    pub fn transactions(&self) -> &[<B::Body as reth_primitives_traits::BlockBody>::Transaction] {
         self.block.body.transactions()
     }
 
@@ -545,24 +540,34 @@ impl SealedBlockWithSenders {
     #[inline]
     pub fn transactions_with_sender(
         &self,
-    ) -> impl Iterator<Item = (&Address, &TransactionSigned)> + '_ {
+    ) -> impl Iterator<Item = (&Address, &<B::Body as reth_primitives_traits::BlockBody>::Transaction)>
+           + '_ {
         self.senders.iter().zip(self.block.body.transactions())
     }
 
     /// Consumes the block and returns the transactions of the block.
     #[inline]
-    pub fn into_transactions(self) -> Vec<TransactionSigned> {
-        self.block.body.transactions
+    pub fn into_transactions(
+        self,
+    ) -> Vec<<B::Body as reth_primitives_traits::BlockBody>::Transaction> {
+        self.block.body.into_transactions()
     }
 
     /// Returns an iterator over all transactions in the chain.
     #[inline]
     pub fn into_transactions_ecrecovered(
         self,
-    ) -> impl Iterator<Item = TransactionSignedEcRecovered> {
+    ) -> impl Iterator<
+        Item = TransactionSignedEcRecovered<
+            <B::Body as reth_primitives_traits::BlockBody>::Transaction,
+        >,
+    >
+    where
+        <B::Body as reth_primitives_traits::BlockBody>::Transaction: SignedTransaction,
+    {
         self.block
             .body
-            .transactions
+            .into_transactions()
             .into_iter()
             .zip(self.senders)
             .map(|(tx, sender)| tx.with_signer(sender))
@@ -608,11 +613,6 @@ impl BlockBody {
         Block { header, body: self }
     }
 
-    /// Calculate the transaction root for the block body.
-    pub fn calculate_tx_root(&self) -> B256 {
-        crate::proofs::calculate_transaction_root(&self.transactions)
-    }
-
     /// Calculate the ommers root for the block body.
     pub fn calculate_ommers_root(&self) -> B256 {
         crate::proofs::calculate_ommers_root(&self.ommers)
@@ -624,20 +624,6 @@ impl BlockBody {
         self.withdrawals.as_ref().map(|w| crate::proofs::calculate_withdrawals_root(w))
     }
 
-    /// Recover signer addresses for all transactions in the block body.
-    pub fn recover_signers(&self) -> Option<Vec<Address>> {
-        TransactionSigned::recover_signers(&self.transactions, self.transactions.len())
-    }
-
-    /// Recover signer addresses for all transactions in the block body _without ensuring that the
-    /// signature has a low `s` value_.
-    ///
-    /// Returns `None`, if some transaction's signature is invalid, see also
-    /// [`TransactionSigned::recover_signer_unchecked`].
-    pub fn recover_signers_unchecked(&self) -> Option<Vec<Address>> {
-        TransactionSigned::recover_signers_unchecked(&self.transactions, self.transactions.len())
-    }
-
     /// Returns whether or not the block body contains any blob transactions.
     #[inline]
     pub fn has_blob_transactions(&self) -> bool {
@@ -703,6 +689,10 @@ impl reth_primitives_traits::BlockBody for BlockBody {
     fn transactions(&self) -> &[Self::Transaction] {
         &self.transactions
     }
+
+    fn into_transactions(self) -> Vec<Self::Transaction> {
+        self.transactions
+    }
 }
 
 impl From<Block> for BlockBody {
@@ -1168,9 +1158,9 @@ mod tests {
             Some(BlockWithSenders { block: block.clone(), senders: vec![sender] })
         );
         let sealed = block.seal_slow();
-        assert_eq!(SealedBlockWithSenders::new(sealed.clone(), vec![]), None);
+        assert_eq!(SealedBlockWithSenders::<Block>::new(sealed.clone(), vec![]), None);
         assert_eq!(
-            SealedBlockWithSenders::new(sealed.clone(), vec![sender]),
+            SealedBlockWithSenders::<Block>::new(sealed.clone(), vec![sender]),
             Some(SealedBlockWithSenders { block: sealed, senders: vec![sender] })
         );
     }
diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs
index 203880209a2f..049d4f202a6a 100644
--- a/crates/primitives/src/lib.rs
+++ b/crates/primitives/src/lib.rs
@@ -21,6 +21,9 @@
 
 extern crate alloc;
 
+mod traits;
+pub use traits::*;
+
 #[cfg(feature = "alloy-compat")]
 mod alloy_compat;
 mod block;
diff --git a/crates/primitives/src/proofs.rs b/crates/primitives/src/proofs.rs
index 1712112281f4..81c26d7180e0 100644
--- a/crates/primitives/src/proofs.rs
+++ b/crates/primitives/src/proofs.rs
@@ -1,7 +1,7 @@
 //! Helper function for calculating Merkle proofs and hashes.
 
-use crate::{Receipt, ReceiptWithBloom, ReceiptWithBloomRef, TransactionSigned};
-use alloc::vec::Vec;
+use crate::{Receipt, ReceiptWithBloom, ReceiptWithBloomRef};
+use alloc::{borrow::Borrow, vec::Vec};
 use alloy_consensus::{Header, EMPTY_OMMER_ROOT_HASH};
 use alloy_eips::{eip2718::Encodable2718, eip4895::Withdrawal};
 use alloy_primitives::{keccak256, B256};
@@ -12,9 +12,9 @@ use alloy_trie::root::{ordered_trie_root, ordered_trie_root_with_encoder};
 /// `(rlp(index), encoded(tx))` pairs.
 pub fn calculate_transaction_root<T>(transactions: &[T]) -> B256
 where
-    T: AsRef<TransactionSigned>,
+    T: Encodable2718,
 {
-    ordered_trie_root_with_encoder(transactions, |tx: &T, buf| tx.as_ref().encode_2718(buf))
+    ordered_trie_root_with_encoder(transactions, |tx, buf| tx.borrow().encode_2718(buf))
 }
 
 /// Calculates the root hash of the withdrawals.
diff --git a/crates/primitives/src/traits.rs b/crates/primitives/src/traits.rs
new file mode 100644
index 000000000000..c4dce4d99d71
--- /dev/null
+++ b/crates/primitives/src/traits.rs
@@ -0,0 +1,123 @@
+use alloy_eips::eip2718::Encodable2718;
+use reth_primitives_traits::{Block, BlockBody, SealedHeader, SignedTransaction};
+use revm_primitives::{Address, B256};
+
+use crate::{
+    transaction::{recover_signers, recover_signers_unchecked},
+    BlockWithSenders, SealedBlock,
+};
+
+/// Extension trait for [`reth_primitives_traits::Block`] implementations
+/// allowing for conversions into common block parts cotainers such as [`SealedBlock`],
+/// [`BlockWithSenders`], etc.
+pub trait BlockSealExt: Block {
+    /// Calculate the header hash and seal the block so that it can't be changed.
+    fn seal_slow(self) -> SealedBlock<Self::Header, Self::Body> {
+        let (header, body) = self.split();
+        SealedBlock { header: SealedHeader::seal(header), body }
+    }
+
+    /// Seal the block with a known hash.
+    ///
+    /// WARNING: This method does not perform validation whether the hash is correct.
+    fn seal(self, hash: B256) -> SealedBlock<Self::Header, Self::Body> {
+        let (header, body) = self.split();
+        SealedBlock { header: SealedHeader::new(header, hash), body }
+    }
+
+    /// Expensive operation that recovers transaction signer.
+    fn senders(&self) -> Option<Vec<Address>>
+    where
+        <Self::Body as BlockBody>::Transaction: SignedTransaction,
+    {
+        self.body().recover_signers()
+    }
+
+    /// Transform into a [`BlockWithSenders`].
+    ///
+    /// # Panics
+    ///
+    /// If the number of senders does not match the number of transactions in the block
+    /// and the signer recovery for one of the transactions fails.
+    ///
+    /// Note: this is expected to be called with blocks read from disk.
+    #[track_caller]
+    fn with_senders_unchecked(self, senders: Vec<Address>) -> BlockWithSenders<Self>
+    where
+        <Self::Body as BlockBody>::Transaction: SignedTransaction,
+    {
+        self.try_with_senders_unchecked(senders).expect("stored block is valid")
+    }
+
+    /// Transform into a [`BlockWithSenders`] using the given senders.
+    ///
+    /// If the number of senders does not match the number of transactions in the block, this falls
+    /// back to manually recovery, but _without ensuring that the signature has a low `s` value_.
+    /// See also [`TransactionSigned::recover_signer_unchecked`]
+    ///
+    /// Returns an error if a signature is invalid.
+    #[track_caller]
+    fn try_with_senders_unchecked(
+        self,
+        senders: Vec<Address>,
+    ) -> Result<BlockWithSenders<Self>, Self>
+    where
+        <Self::Body as BlockBody>::Transaction: SignedTransaction,
+    {
+        let senders = if self.body().transactions().len() == senders.len() {
+            senders
+        } else {
+            let Some(senders) = self.body().recover_signers_unchecked() else { return Err(self) };
+            senders
+        };
+
+        Ok(BlockWithSenders::new_unchecked(self, senders))
+    }
+
+    /// **Expensive**. Transform into a [`BlockWithSenders`] by recovering senders in the contained
+    /// transactions.
+    ///
+    /// Returns `None` if a transaction is invalid.
+    fn with_recovered_senders(self) -> Option<BlockWithSenders<Self>>
+    where
+        <Self::Body as BlockBody>::Transaction: SignedTransaction,
+    {
+        let senders = self.senders()?;
+        Some(BlockWithSenders::new_unchecked(self, senders))
+    }
+}
+
+impl<T: Block> BlockSealExt for T {}
+
+/// Extension trait for [`BlockBody`] adding helper methods operating with transactions.
+pub trait BlockBodyTxExt: BlockBody {
+    /// Calculate the transaction root for the block body.
+    fn calculate_tx_root(&self) -> B256
+    where
+        Self::Transaction: Encodable2718,
+    {
+        crate::proofs::calculate_transaction_root(self.transactions())
+    }
+
+    /// Recover signer addresses for all transactions in the block body.
+    fn recover_signers(&self) -> Option<Vec<Address>>
+    where
+        Self::Transaction: SignedTransaction,
+    {
+        recover_signers(self.transactions(), self.transactions().len())
+    }
+
+    /// Recover signer addresses for all transactions in the block body _without ensuring that the
+    /// signature has a low `s` value_.
+    ///
+    /// Returns `None`, if some transaction's signature is invalid, see also
+    /// [`recover_signer_unchecked`].
+    fn recover_signers_unchecked(&self) -> Option<Vec<Address>>
+    where
+        Self::Transaction: SignedTransaction,
+    {
+        recover_signers_unchecked(self.transactions(), self.transactions().len())
+    }
+}
+
+impl<T: BlockBody> BlockBodyTxExt for T {}
diff --git a/crates/primitives/src/traits/mod.rs b/crates/primitives/src/traits/mod.rs
deleted file mode 100644
index 49fb73ea5555..000000000000
--- a/crates/primitives/src/traits/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//! Abstractions of primitive data types
-
-pub mod block;
-pub mod transaction;
-
-pub use block::{body::BlockBody, Block};
-pub use transaction::signed::SignedTransaction;
-
-pub use alloy_consensus::BlockHeader;
diff --git a/crates/primitives/src/transaction/mod.rs b/crates/primitives/src/transaction/mod.rs
index b8a3f4a719bc..f61415ec2ecd 100644
--- a/crates/primitives/src/transaction/mod.rs
+++ b/crates/primitives/src/transaction/mod.rs
@@ -1712,6 +1712,11 @@ pub trait SignedTransactionIntoRecoveredExt: SignedTransaction {
         let signer = self.recover_signer_unchecked()?;
         Some(TransactionSignedEcRecovered::from_signed_transaction(self, signer))
     }
+
+    /// Returns the [`TransactionSignedEcRecovered`] transaction with the given sender.
+    fn with_signer(self, signer: Address) -> TransactionSignedEcRecovered<Self> {
+        TransactionSignedEcRecovered::from_signed_transaction(self, signer)
+    }
 }
 
 impl<T> SignedTransactionIntoRecoveredExt for T where T: SignedTransaction {}
@@ -1936,6 +1941,22 @@ where
     }
 }
 
+/// Recovers a list of signers from a transaction list iterator _without ensuring that the
+/// signature has a low `s` value_.
+///
+/// Returns `None`, if some transaction's signature is invalid.
+pub fn recover_signers_unchecked<'a, I, T>(txes: I, num_txes: usize) -> Option<Vec<Address>>
+where
+    T: SignedTransaction,
+    I: IntoParallelIterator<Item = &'a T> + IntoIterator<Item = &'a T> + Send,
+{
+    if num_txes < *PARALLEL_SENDER_RECOVERY_THRESHOLD {
+        txes.into_iter().map(|tx| tx.recover_signer_unchecked()).collect()
+    } else {
+        txes.into_par_iter().map(|tx| tx.recover_signer_unchecked()).collect()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{
diff --git a/crates/rpc/rpc-builder/tests/it/auth.rs b/crates/rpc/rpc-builder/tests/it/auth.rs
index 71e8bf39f9ea..b5b1c98e7416 100644
--- a/crates/rpc/rpc-builder/tests/it/auth.rs
+++ b/crates/rpc/rpc-builder/tests/it/auth.rs
@@ -5,7 +5,7 @@ use alloy_primitives::U64;
 use alloy_rpc_types_engine::{ForkchoiceState, PayloadId, TransitionConfiguration};
 use jsonrpsee::core::client::{ClientT, SubscriptionClientT};
 use reth_ethereum_engine_primitives::EthEngineTypes;
-use reth_primitives::Block;
+use reth_primitives::{Block, BlockSealExt};
 use reth_rpc_api::clients::EngineApiClient;
 use reth_rpc_layer::JwtSecret;
 use reth_rpc_types_compat::engine::payload::{
diff --git a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
index 548f9101023d..a1c405f9385e 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
@@ -17,8 +17,8 @@ use reth_evm::{
 };
 use reth_execution_types::ExecutionOutcome;
 use reth_primitives::{
-    proofs::calculate_transaction_root, Block, BlockBody, Receipt, SealedBlockWithSenders,
-    SealedHeader, TransactionSignedEcRecovered,
+    proofs::calculate_transaction_root, Block, BlockBody, BlockSealExt, Receipt,
+    SealedBlockWithSenders, SealedHeader, TransactionSignedEcRecovered,
 };
 use reth_provider::{
     BlockReader, BlockReaderIdExt, ChainSpecProvider, EvmEnvProvider, ProviderError,
diff --git a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
index 2223ecdc9f71..d898c0fe832e 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
@@ -315,7 +315,7 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
     {
         async move {
             if let Some(block) = self.block_with_senders(block_id).await? {
-                if let Some(tx) = block.transactions().nth(index) {
+                if let Some(tx) = block.transactions().get(index) {
                     return Ok(Some(tx.encoded_2718().into()))
                 }
             }
diff --git a/crates/rpc/rpc-types-compat/src/block.rs b/crates/rpc/rpc-types-compat/src/block.rs
index f2b1d93be83e..564f5a939fc1 100644
--- a/crates/rpc/rpc-types-compat/src/block.rs
+++ b/crates/rpc/rpc-types-compat/src/block.rs
@@ -43,7 +43,7 @@ pub fn from_block_with_tx_hashes<T>(
     block_hash: Option<B256>,
 ) -> Block<T> {
     let block_hash = block_hash.unwrap_or_else(|| block.header.hash_slow());
-    let transactions = block.body.transactions().map(|tx| tx.hash()).collect();
+    let transactions = block.body.transactions.iter().map(|tx| tx.hash()).collect();
 
     from_block_with_transactions(
         block.length(),
diff --git a/crates/rpc/rpc-types-compat/src/engine/payload.rs b/crates/rpc/rpc-types-compat/src/engine/payload.rs
index 7f260a7693c4..552238903410 100644
--- a/crates/rpc/rpc-types-compat/src/engine/payload.rs
+++ b/crates/rpc/rpc-types-compat/src/engine/payload.rs
@@ -15,7 +15,7 @@ use alloy_rpc_types_engine::{
 };
 use reth_primitives::{
     proofs::{self},
-    Block, BlockBody, SealedBlock, TransactionSigned,
+    Block, BlockBody, BlockSealExt, SealedBlock, TransactionSigned,
 };
 
 /// Converts [`ExecutionPayloadV1`] to [`Block`]
@@ -363,6 +363,7 @@ mod tests {
         CancunPayloadFields, ExecutionPayload, ExecutionPayloadSidecar, ExecutionPayloadV1,
         ExecutionPayloadV2, ExecutionPayloadV3,
     };
+    use reth_primitives::BlockSealExt;
 
     #[test]
     fn roundtrip_payload_to_block() {
diff --git a/crates/rpc/rpc/src/debug.rs b/crates/rpc/rpc/src/debug.rs
index dd6bf9bbc24e..07f0a0e3197a 100644
--- a/crates/rpc/rpc/src/debug.rs
+++ b/crates/rpc/rpc/src/debug.rs
@@ -18,7 +18,7 @@ use reth_evm::{
     execute::{BlockExecutorProvider, Executor},
     ConfigureEvmEnv,
 };
-use reth_primitives::{Block, SealedBlockWithSenders};
+use reth_primitives::{Block, BlockSealExt, SealedBlockWithSenders};
 use reth_provider::{
     BlockReaderIdExt, ChainSpecProvider, HeaderProvider, StateProofProvider, StateProviderFactory,
     TransactionVariant,
diff --git a/crates/stages/stages/src/stages/bodies.rs b/crates/stages/stages/src/stages/bodies.rs
index b90729c71311..c2de92924021 100644
--- a/crates/stages/stages/src/stages/bodies.rs
+++ b/crates/stages/stages/src/stages/bodies.rs
@@ -5,7 +5,7 @@ use std::{
 
 use futures_util::TryStreamExt;
 use reth_codecs::Compact;
-use reth_primitives_traits::BlockBody;
+use reth_primitives_traits::{Block, BlockBody};
 use tracing::*;
 
 use alloy_primitives::TxNumber;
@@ -151,7 +151,7 @@ where
         + StaticFileProviderFactory
         + StatsReader
         + BlockReader
-        + BlockWriter<Body = D::Body>,
+        + BlockWriter<Block: Block<Body = D::Body>>,
     D: BodyDownloader<Body: BlockBody<Transaction: Compact>>,
 {
     /// Return the id of the stage
diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs
index 967ac785b47e..0fd459b899c8 100644
--- a/crates/storage/provider/src/providers/blockchain_provider.rs
+++ b/crates/storage/provider/src/providers/blockchain_provider.rs
@@ -793,7 +793,9 @@ mod tests {
     use reth_db_api::{cursor::DbCursorRO, transaction::DbTx};
     use reth_errors::ProviderError;
     use reth_execution_types::{Chain, ExecutionOutcome};
-    use reth_primitives::{Receipt, SealedBlock, StaticFileSegment, TransactionSignedNoHash};
+    use reth_primitives::{
+        BlockSealExt, Receipt, SealedBlock, StaticFileSegment, TransactionSignedNoHash,
+    };
     use reth_storage_api::{
         BlockHashReader, BlockIdReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource,
         ChangeSetReader, DatabaseProviderFactory, HeaderProvider, ReceiptProvider,
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index bf9762037262..c08196063a3d 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -48,9 +48,9 @@ use reth_execution_types::{Chain, ExecutionOutcome};
 use reth_network_p2p::headers::downloader::SyncTarget;
 use reth_node_types::{NodeTypes, TxTy};
 use reth_primitives::{
-    Account, Block, BlockBody, BlockWithSenders, Bytecode, GotExpected, NodePrimitives, Receipt,
-    SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
-    TransactionMeta, TransactionSigned, TransactionSignedNoHash,
+    Account, Block, BlockBody, BlockSealExt, BlockWithSenders, Bytecode, GotExpected,
+    NodePrimitives, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment,
+    StorageEntry, TransactionMeta, TransactionSigned, TransactionSignedNoHash,
 };
 use reth_primitives_traits::{BlockBody as _, SignedTransaction};
 use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
@@ -380,7 +380,7 @@ impl<Tx: DbTx + DbTxMut + 'static, N: NodeTypesForProvider + 'static> DatabasePr
     /// Inserts an historical block. **Used for setting up test environments**
     pub fn insert_historical_block(
         &self,
-        block: SealedBlockWithSenders<Header, <Self as BlockWriter>::Body>,
+        block: SealedBlockWithSenders<<Self as BlockWriter>::Block>,
     ) -> ProviderResult<StoredBlockBodyIndices> {
         let ttd = if block.number == 0 {
             block.difficulty
@@ -2751,7 +2751,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockExecu
 impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWriter
     for DatabaseProvider<TX, N>
 {
-    type Body = <<N::Primitives as NodePrimitives>::Block as reth_primitives_traits::Block>::Body;
+    type Block = <N::Primitives as NodePrimitives>::Block;
 
     /// Inserts the block into the database, always modifying the following tables:
     /// * [`CanonicalHeaders`](tables::CanonicalHeaders)
@@ -2775,7 +2775,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
     /// [`TransactionHashNumbers`](tables::TransactionHashNumbers).
     fn insert_block(
         &self,
-        block: SealedBlockWithSenders<Header, Self::Body>,
+        block: SealedBlockWithSenders<Self::Block>,
         write_transactions_to: StorageLocation,
     ) -> ProviderResult<StoredBlockBodyIndices> {
         let block_number = block.number;
@@ -2849,7 +2849,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
 
     fn append_block_bodies(
         &self,
-        bodies: Vec<(BlockNumber, Option<Self::Body>)>,
+        bodies: Vec<(BlockNumber, Option<<Self::Block as reth_primitives_traits::Block>::Body>)>,
         write_transactions_to: StorageLocation,
     ) -> ProviderResult<()> {
         let Some(from_block) = bodies.first().map(|(block, _)| *block) else { return Ok(()) };
@@ -2868,11 +2868,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
         // Initialize cursor if we will be writing transactions to database
         let mut tx_cursor = write_transactions_to
             .database()
-            .then(|| {
-                self.tx.cursor_write::<tables::Transactions<
-                    <Self::Body as reth_primitives_traits::BlockBody>::Transaction,
-                >>()
-            })
+            .then(|| self.tx.cursor_write::<tables::Transactions<TxTy<N>>>())
             .transpose()?;
 
         // Get id for the next tx_num of zero if there are no transactions.
@@ -3017,7 +3013,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
     /// TODO(joshie): this fn should be moved to `UnifiedStorageWriter` eventually
     fn append_blocks_with_state(
         &self,
-        blocks: Vec<SealedBlockWithSenders<Header, Self::Body>>,
+        blocks: Vec<SealedBlockWithSenders<Self::Block>>,
         execution_outcome: ExecutionOutcome,
         hashed_state: HashedPostStateSorted,
         trie_updates: TrieUpdates,
diff --git a/crates/storage/provider/src/providers/mod.rs b/crates/storage/provider/src/providers/mod.rs
index 68d1a168f150..497f817b88a8 100644
--- a/crates/storage/provider/src/providers/mod.rs
+++ b/crates/storage/provider/src/providers/mod.rs
@@ -78,6 +78,7 @@ where
         Storage: ChainStorage<Self::Primitives>,
         Primitives: FullNodePrimitives<
             SignedTx: Value + From<TransactionSigned> + Into<TransactionSigned>,
+            BlockHeader = alloy_consensus::Header,
         >,
     >,
 {
@@ -89,6 +90,7 @@ impl<T> NodeTypesForProvider for T where
         Storage: ChainStorage<T::Primitives>,
         Primitives: FullNodePrimitives<
             SignedTx: Value + From<TransactionSigned> + Into<TransactionSigned>,
+            BlockHeader = alloy_consensus::Header,
         >,
     >
 {
diff --git a/crates/storage/provider/src/traits/block.rs b/crates/storage/provider/src/traits/block.rs
index c2ce477051d4..aec54362656b 100644
--- a/crates/storage/provider/src/traits/block.rs
+++ b/crates/storage/provider/src/traits/block.rs
@@ -1,4 +1,3 @@
-use alloy_consensus::Header;
 use alloy_primitives::BlockNumber;
 use reth_db_api::models::StoredBlockBodyIndices;
 use reth_execution_types::{Chain, ExecutionOutcome};
@@ -62,7 +61,7 @@ pub trait StateReader: Send + Sync {
 #[auto_impl::auto_impl(&, Arc, Box)]
 pub trait BlockWriter: Send + Sync {
     /// The body this writer can write.
-    type Body: Send + Sync;
+    type Block: reth_primitives_traits::Block;
 
     /// Insert full block and make it canonical. Parent tx num and transition id is taken from
     /// parent block in database.
@@ -71,7 +70,7 @@ pub trait BlockWriter: Send + Sync {
     /// transition in the block.
     fn insert_block(
         &self,
-        block: SealedBlockWithSenders<Header, Self::Body>,
+        block: SealedBlockWithSenders<Self::Block>,
         write_transactions_to: StorageLocation,
     ) -> ProviderResult<StoredBlockBodyIndices>;
 
@@ -82,7 +81,7 @@ pub trait BlockWriter: Send + Sync {
     /// Bodies are passed as [`Option`]s, if body is `None` the corresponding block is empty.
     fn append_block_bodies(
         &self,
-        bodies: Vec<(BlockNumber, Option<Self::Body>)>,
+        bodies: Vec<(BlockNumber, Option<<Self::Block as reth_primitives_traits::Block>::Body>)>,
         write_transactions_to: StorageLocation,
     ) -> ProviderResult<()>;
 
@@ -118,7 +117,7 @@ pub trait BlockWriter: Send + Sync {
     /// Returns `Ok(())` on success, or an error if any operation fails.
     fn append_blocks_with_state(
         &self,
-        blocks: Vec<SealedBlockWithSenders<Header, Self::Body>>,
+        blocks: Vec<SealedBlockWithSenders<Self::Block>>,
         execution_outcome: ExecutionOutcome,
         hashed_state: HashedPostStateSorted,
         trie_updates: TrieUpdates,
diff --git a/crates/storage/provider/src/writer/mod.rs b/crates/storage/provider/src/writer/mod.rs
index 30c5f0d5291d..e91ea3bea3e1 100644
--- a/crates/storage/provider/src/writer/mod.rs
+++ b/crates/storage/provider/src/writer/mod.rs
@@ -15,7 +15,7 @@ use reth_db::{
 };
 use reth_errors::{ProviderError, ProviderResult};
 use reth_execution_types::ExecutionOutcome;
-use reth_primitives::{BlockBody, SealedBlock, StaticFileSegment};
+use reth_primitives::{SealedBlock, StaticFileSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_storage_api::{
     DBProvider, HeaderProvider, ReceiptWriter, StageCheckpointWriter, TransactionsProviderExt,
@@ -148,7 +148,7 @@ impl UnifiedStorageWriter<'_, (), ()> {
 impl<ProviderDB> UnifiedStorageWriter<'_, ProviderDB, &StaticFileProvider<ProviderDB::Primitives>>
 where
     ProviderDB: DBProvider<Tx: DbTx + DbTxMut>
-        + BlockWriter<Body = BlockBody>
+        + BlockWriter<Block = reth_primitives::Block>
         + TransactionsProviderExt
         + StateChangeWriter
         + TrieWriter
diff --git a/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs b/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs
index d2077edafff4..5ab851191843 100644
--- a/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs
+++ b/examples/beacon-api-sidecar-fetcher/src/mined_sidecar.rs
@@ -98,6 +98,7 @@ where
     fn process_block(&mut self, block: &SealedBlockWithSenders) {
         let txs: Vec<_> = block
             .transactions()
+            .iter()
             .filter(|tx| tx.is_eip4844())
             .map(|tx| (tx.clone(), tx.blob_versioned_hashes().unwrap().len()))
             .collect();
@@ -191,6 +192,7 @@ where
                             for (_, block) in old.blocks().iter() {
                                 let txs: Vec<BlobTransactionEvent> = block
                                     .transactions()
+                                    .iter()
                                     .filter(|tx: &&reth::primitives::TransactionSigned| {
                                         tx.is_eip4844()
                                     })
diff --git a/examples/custom-dev-node/src/main.rs b/examples/custom-dev-node/src/main.rs
index 7fa44418c523..42bb83782aa3 100644
--- a/examples/custom-dev-node/src/main.rs
+++ b/examples/custom-dev-node/src/main.rs
@@ -50,7 +50,7 @@ async fn main() -> eyre::Result<()> {
 
     let head = notifications.next().await.unwrap();
 
-    let tx = head.tip().transactions().next().unwrap();
+    let tx = &head.tip().transactions()[0];
     assert_eq!(tx.hash(), hash);
     println!("mined transaction: {hash}");
     Ok(())
diff --git a/examples/custom-payload-builder/src/generator.rs b/examples/custom-payload-builder/src/generator.rs
index 2e264d017a3b..047d6ebf3ab3 100644
--- a/examples/custom-payload-builder/src/generator.rs
+++ b/examples/custom-payload-builder/src/generator.rs
@@ -9,7 +9,7 @@ use reth::{
 use reth_basic_payload_builder::{BasicPayloadJobGeneratorConfig, PayloadBuilder, PayloadConfig};
 use reth_node_api::PayloadBuilderAttributes;
 use reth_payload_builder::{PayloadBuilderError, PayloadJobGenerator};
-use reth_primitives::SealedHeader;
+use reth_primitives::{BlockSealExt, SealedHeader};
 use std::sync::Arc;
 
 /// The generator type that creates new jobs that builds empty blocks.
diff --git a/examples/db-access/src/main.rs b/examples/db-access/src/main.rs
index 179d12160535..cc8f18a2ad8e 100644
--- a/examples/db-access/src/main.rs
+++ b/examples/db-access/src/main.rs
@@ -4,7 +4,7 @@ use reth_chainspec::ChainSpecBuilder;
 use reth_db::{open_db_read_only, DatabaseEnv};
 use reth_node_ethereum::EthereumNode;
 use reth_node_types::NodeTypesWithDBAdapter;
-use reth_primitives::{SealedHeader, TransactionSigned};
+use reth_primitives::{BlockSealExt, SealedHeader, TransactionSigned};
 use reth_provider::{
     providers::StaticFileProvider, AccountReader, BlockReader, BlockSource, HeaderProvider,
     ProviderFactory, ReceiptProvider, StateProvider, TransactionsProvider,

From db15e9df31b15f0154f0352d7efd2d4cd4cf69da Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Sat, 23 Nov 2024 22:15:30 +0400
Subject: [PATCH 02/15] fixes

---
 crates/primitives-traits/src/block/body.rs | 2 +-
 crates/primitives/src/traits.rs            | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/primitives-traits/src/block/body.rs b/crates/primitives-traits/src/block/body.rs
index fa0e4f256b75..b01ef96d6f5f 100644
--- a/crates/primitives-traits/src/block/body.rs
+++ b/crates/primitives-traits/src/block/body.rs
@@ -1,6 +1,6 @@
 //! Block body abstraction.
 
-use alloc::fmt;
+use alloc::{fmt, vec::Vec};
 
 use alloy_consensus::Transaction;
 
diff --git a/crates/primitives/src/traits.rs b/crates/primitives/src/traits.rs
index c4dce4d99d71..4e62f74fb1be 100644
--- a/crates/primitives/src/traits.rs
+++ b/crates/primitives/src/traits.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 
 /// Extension trait for [`reth_primitives_traits::Block`] implementations
-/// allowing for conversions into common block parts cotainers such as [`SealedBlock`],
+/// allowing for conversions into common block parts containers such as [`SealedBlock`],
 /// [`BlockWithSenders`], etc.
 pub trait BlockSealExt: Block {
     /// Calculate the header hash and seal the block so that it can't be changed.
@@ -53,7 +53,7 @@ pub trait BlockSealExt: Block {
     ///
     /// If the number of senders does not match the number of transactions in the block, this falls
     /// back to manually recovery, but _without ensuring that the signature has a low `s` value_.
-    /// See also [`TransactionSigned::recover_signer_unchecked`]
+    /// See also [`recover_signers_unchecked`]
     ///
     /// Returns an error if a signature is invalid.
     #[track_caller]
@@ -111,7 +111,7 @@ pub trait BlockBodyTxExt: BlockBody {
     /// signature has a low `s` value_.
     ///
     /// Returns `None`, if some transaction's signature is invalid, see also
-    /// [`recover_signer_unchecked`].
+    /// [`recover_signers_unchecked`].
     fn recover_signers_unchecked(&self) -> Option<Vec<Address>>
     where
         Self::Transaction: SignedTransaction,

From 9e8e1eb0ca3d0201a71b4f88a71b29be905881f5 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Sat, 23 Nov 2024 23:39:43 +0400
Subject: [PATCH 03/15] fix

---
 crates/primitives/src/traits.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/primitives/src/traits.rs b/crates/primitives/src/traits.rs
index 4e62f74fb1be..c5e7d316968c 100644
--- a/crates/primitives/src/traits.rs
+++ b/crates/primitives/src/traits.rs
@@ -1,11 +1,11 @@
-use alloy_eips::eip2718::Encodable2718;
-use reth_primitives_traits::{Block, BlockBody, SealedHeader, SignedTransaction};
-use revm_primitives::{Address, B256};
-
 use crate::{
     transaction::{recover_signers, recover_signers_unchecked},
     BlockWithSenders, SealedBlock,
 };
+use alloc::vec::Vec;
+use alloy_eips::eip2718::Encodable2718;
+use reth_primitives_traits::{Block, BlockBody, SealedHeader, SignedTransaction};
+use revm_primitives::{Address, B256};
 
 /// Extension trait for [`reth_primitives_traits::Block`] implementations
 /// allowing for conversions into common block parts containers such as [`SealedBlock`],

From a587d19556b41742e3769e534d1725ed9e851c9d Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 03:53:29 +0400
Subject: [PATCH 04/15] use aliases

---
 bin/reth/src/commands/debug_cmd/build_block.rs         |  8 +++-----
 bin/reth/src/commands/debug_cmd/merkle.rs              |  4 ++--
 crates/node/builder/src/setup.rs                       |  6 ++----
 crates/node/types/src/lib.rs                           |  3 +++
 .../static-file/src/segments/transactions.rs           |  2 +-
 .../provider/src/providers/database/provider.rs        | 10 +++++-----
 6 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/bin/reth/src/commands/debug_cmd/build_block.rs b/bin/reth/src/commands/debug_cmd/build_block.rs
index e48eb53165fd..8246255c7c4c 100644
--- a/bin/reth/src/commands/debug_cmd/build_block.rs
+++ b/bin/reth/src/commands/debug_cmd/build_block.rs
@@ -22,7 +22,7 @@ use reth_errors::RethResult;
 use reth_evm::execute::{BlockExecutorProvider, Executor};
 use reth_execution_types::ExecutionOutcome;
 use reth_fs_util as fs;
-use reth_node_api::{EngineApiMessageVersion, NodePrimitives, PayloadBuilderAttributes};
+use reth_node_api::{BlockTy, EngineApiMessageVersion, PayloadBuilderAttributes};
 use reth_node_ethereum::{EthEvmConfig, EthExecutorProvider};
 use reth_primitives::{
     BlobTransaction, BlockSealExt, PooledTransactionsElement, SealedBlock, SealedBlockWithSenders,
@@ -258,10 +258,8 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
                 consensus.validate_block_pre_execution(block)?;
 
                 let senders = block.senders().expect("sender recovery failed");
-                let block_with_senders = SealedBlockWithSenders::<
-                    <N::Primitives as NodePrimitives>::Block,
-                >::new(block.clone(), senders)
-                .unwrap();
+                let block_with_senders =
+                    SealedBlockWithSenders::<BlockTy<N>>::new(block.clone(), senders).unwrap();
 
                 let db = StateProviderDatabase::new(blockchain_db.latest()?);
                 let executor =
diff --git a/bin/reth/src/commands/debug_cmd/merkle.rs b/bin/reth/src/commands/debug_cmd/merkle.rs
index f14482423c67..fe9b76d8c7d1 100644
--- a/bin/reth/src/commands/debug_cmd/merkle.rs
+++ b/bin/reth/src/commands/debug_cmd/merkle.rs
@@ -17,7 +17,7 @@ use reth_evm::execute::{BatchExecutor, BlockExecutorProvider};
 use reth_network::{BlockDownloaderProvider, NetworkHandle};
 use reth_network_api::NetworkInfo;
 use reth_network_p2p::full_block::FullBlockClient;
-use reth_node_api::NodePrimitives;
+use reth_node_api::BlockTy;
 use reth_node_ethereum::EthExecutorProvider;
 use reth_provider::{
     providers::ProviderNodeTypes, writer::UnifiedStorageWriter, BlockNumReader, BlockWriter,
@@ -145,7 +145,7 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>> Command<C> {
         for block in blocks.into_iter().rev() {
             let block_number = block.number;
             let sealed_block = block
-                .try_seal_with_senders::<<N::Primitives as NodePrimitives>::Block>()
+                .try_seal_with_senders::<BlockTy<N>>()
                 .map_err(|block| eyre::eyre!("Error sealing block with senders: {block:?}"))?;
             trace!(target: "reth::cli", block_number, "Executing block");
 
diff --git a/crates/node/builder/src/setup.rs b/crates/node/builder/src/setup.rs
index 3258ba8fe544..9b4532340195 100644
--- a/crates/node/builder/src/setup.rs
+++ b/crates/node/builder/src/setup.rs
@@ -14,7 +14,7 @@ use reth_exex::ExExManagerHandle;
 use reth_network_p2p::{
     bodies::downloader::BodyDownloader, headers::downloader::HeaderDownloader, EthBlockClient,
 };
-use reth_node_api::{FullNodePrimitives, NodePrimitives};
+use reth_node_api::{BodyTy, FullNodePrimitives};
 use reth_provider::{providers::ProviderNodeTypes, ProviderFactory};
 use reth_stages::{prelude::DefaultStages, stages::ExecutionStage, Pipeline, StageSet};
 use reth_static_file::StaticFileProducer;
@@ -87,9 +87,7 @@ pub fn build_pipeline<N, H, B, Executor>(
 where
     N: ProviderNodeTypes,
     H: HeaderDownloader<Header = alloy_consensus::Header> + 'static,
-    B: BodyDownloader<
-            Body = <<N::Primitives as NodePrimitives>::Block as reth_node_api::Block>::Body,
-        > + 'static,
+    B: BodyDownloader<Body = BodyTy<N>> + 'static,
     Executor: BlockExecutorProvider,
     N::Primitives: FullNodePrimitives<BlockBody = reth_primitives::BlockBody>,
 {
diff --git a/crates/node/types/src/lib.rs b/crates/node/types/src/lib.rs
index a23b9bfe4146..40d0defe24ec 100644
--- a/crates/node/types/src/lib.rs
+++ b/crates/node/types/src/lib.rs
@@ -233,6 +233,9 @@ where
     type Engine = E;
 }
 
+/// Helper adapter type for accessing [`NodePrimitives::Block`] on [`NodeTypes`].
+pub type BlockTy<N> = <<N as NodeTypes>::Primitives as NodePrimitives>::Block;
+
 /// Helper adapter type for accessing [`NodePrimitives::BlockHeader`] on [`NodeTypes`].
 pub type HeaderTy<N> = <<N as NodeTypes>::Primitives as NodePrimitives>::BlockHeader;
 
diff --git a/crates/static-file/static-file/src/segments/transactions.rs b/crates/static-file/static-file/src/segments/transactions.rs
index 168ae94817b6..5b686cfe109f 100644
--- a/crates/static-file/static-file/src/segments/transactions.rs
+++ b/crates/static-file/static-file/src/segments/transactions.rs
@@ -44,7 +44,7 @@ where
                 .ok_or(ProviderError::BlockBodyIndicesNotFound(block))?;
 
             let mut transactions_cursor = provider.tx_ref().cursor_read::<tables::Transactions<
-                <<Provider as StaticFileProviderFactory>::Primitives as NodePrimitives>::SignedTx,
+                <Provider::Primitives as NodePrimitives>::SignedTx,
             >>()?;
             let transactions_walker =
                 transactions_cursor.walk_range(block_body_indices.tx_num_range())?;
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index c08196063a3d..614a376b10d1 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -46,11 +46,11 @@ use reth_db_api::{
 use reth_evm::ConfigureEvmEnv;
 use reth_execution_types::{Chain, ExecutionOutcome};
 use reth_network_p2p::headers::downloader::SyncTarget;
-use reth_node_types::{NodeTypes, TxTy};
+use reth_node_types::{BlockTy, NodeTypes, TxTy};
 use reth_primitives::{
-    Account, Block, BlockBody, BlockSealExt, BlockWithSenders, Bytecode, GotExpected,
-    NodePrimitives, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment,
-    StorageEntry, TransactionMeta, TransactionSigned, TransactionSignedNoHash,
+    Account, Block, BlockBody, BlockSealExt, BlockWithSenders, Bytecode, GotExpected, Receipt,
+    SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
+    TransactionMeta, TransactionSigned, TransactionSignedNoHash,
 };
 use reth_primitives_traits::{BlockBody as _, SignedTransaction};
 use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
@@ -2751,7 +2751,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockExecu
 impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWriter
     for DatabaseProvider<TX, N>
 {
-    type Block = <N::Primitives as NodePrimitives>::Block;
+    type Block = BlockTy<N>;
 
     /// Inserts the block into the database, always modifying the following tables:
     /// * [`CanonicalHeaders`](tables::CanonicalHeaders)

From f7c301d88362e4fcaae1410cb5e5e16d10ca36f7 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 03:57:11 +0400
Subject: [PATCH 05/15] relax bound

---
 crates/primitives/src/block.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/primitives/src/block.rs b/crates/primitives/src/block.rs
index fbb08d084152..11882e019c10 100644
--- a/crates/primitives/src/block.rs
+++ b/crates/primitives/src/block.rs
@@ -152,7 +152,7 @@ impl<'a> arbitrary::Arbitrary<'a> for Block {
 
 /// Sealed block with senders recovered from transactions.
 #[derive(Debug, Clone, PartialEq, Eq, Default, Deref, DerefMut)]
-pub struct BlockWithSenders<B: reth_primitives_traits::Block = Block> {
+pub struct BlockWithSenders<B = Block> {
     /// Block
     #[deref]
     #[deref_mut]

From d54846db4326365fcb6bbfe19e0d25ba9ed05eff Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 03:57:58 +0400
Subject: [PATCH 06/15] rename trait

---
 bin/reth-bench/src/bench/new_payload_fcu.rs                  | 2 +-
 bin/reth-bench/src/bench/new_payload_only.rs                 | 2 +-
 bin/reth/src/commands/debug_cmd/build_block.rs               | 2 +-
 bin/reth/src/commands/debug_cmd/in_memory_merkle.rs          | 2 +-
 crates/consensus/beacon/src/engine/mod.rs                    | 2 +-
 crates/engine/tree/src/tree/mod.rs                           | 2 +-
 crates/engine/util/src/reorg.rs                              | 2 +-
 crates/ethereum/evm/src/execute.rs                           | 2 +-
 crates/ethereum/payload/src/lib.rs                           | 2 +-
 crates/exex/exex/src/backfill/job.rs                         | 2 +-
 crates/exex/exex/src/backfill/test_utils.rs                  | 2 +-
 crates/exex/exex/src/notifications.rs                        | 2 +-
 crates/exex/test-utils/src/lib.rs                            | 2 +-
 crates/optimism/payload/src/builder.rs                       | 2 +-
 crates/payload/builder/src/test_utils.rs                     | 2 +-
 crates/payload/validator/src/lib.rs                          | 2 +-
 crates/primitives/src/block.rs                               | 4 ++--
 crates/primitives/src/traits.rs                              | 4 ++--
 crates/rpc/rpc-builder/tests/it/auth.rs                      | 2 +-
 crates/rpc/rpc-eth-api/src/helpers/pending_block.rs          | 2 +-
 crates/rpc/rpc-types-compat/src/engine/payload.rs            | 4 ++--
 crates/rpc/rpc/src/debug.rs                                  | 2 +-
 crates/storage/provider/src/providers/blockchain_provider.rs | 2 +-
 crates/storage/provider/src/providers/database/provider.rs   | 2 +-
 examples/custom-payload-builder/src/generator.rs             | 2 +-
 examples/db-access/src/main.rs                               | 2 +-
 26 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/bin/reth-bench/src/bench/new_payload_fcu.rs b/bin/reth-bench/src/bench/new_payload_fcu.rs
index 6c1e06730197..9e573a8957e1 100644
--- a/bin/reth-bench/src/bench/new_payload_fcu.rs
+++ b/bin/reth-bench/src/bench/new_payload_fcu.rs
@@ -18,7 +18,7 @@ use clap::Parser;
 use csv::Writer;
 use reth_cli_runner::CliContext;
 use reth_node_core::args::BenchmarkArgs;
-use reth_primitives::{Block, BlockSealExt};
+use reth_primitives::{Block, BlockExt};
 use reth_rpc_types_compat::engine::payload::block_to_payload;
 use std::time::Instant;
 use tracing::{debug, info};
diff --git a/bin/reth-bench/src/bench/new_payload_only.rs b/bin/reth-bench/src/bench/new_payload_only.rs
index b2f6e8088ba2..0611faabf101 100644
--- a/bin/reth-bench/src/bench/new_payload_only.rs
+++ b/bin/reth-bench/src/bench/new_payload_only.rs
@@ -16,7 +16,7 @@ use clap::Parser;
 use csv::Writer;
 use reth_cli_runner::CliContext;
 use reth_node_core::args::BenchmarkArgs;
-use reth_primitives::{Block, BlockSealExt};
+use reth_primitives::{Block, BlockExt};
 use reth_rpc_types_compat::engine::payload::block_to_payload;
 use std::time::Instant;
 use tracing::{debug, info};
diff --git a/bin/reth/src/commands/debug_cmd/build_block.rs b/bin/reth/src/commands/debug_cmd/build_block.rs
index 8246255c7c4c..5fc78e884e9a 100644
--- a/bin/reth/src/commands/debug_cmd/build_block.rs
+++ b/bin/reth/src/commands/debug_cmd/build_block.rs
@@ -25,7 +25,7 @@ use reth_fs_util as fs;
 use reth_node_api::{BlockTy, EngineApiMessageVersion, PayloadBuilderAttributes};
 use reth_node_ethereum::{EthEvmConfig, EthExecutorProvider};
 use reth_primitives::{
-    BlobTransaction, BlockSealExt, PooledTransactionsElement, SealedBlock, SealedBlockWithSenders,
+    BlobTransaction, BlockExt, PooledTransactionsElement, SealedBlock, SealedBlockWithSenders,
     SealedHeader, Transaction, TransactionSigned,
 };
 use reth_provider::{
diff --git a/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs b/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs
index 35ecc380ab95..9f82ef0574b3 100644
--- a/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs
+++ b/bin/reth/src/commands/debug_cmd/in_memory_merkle.rs
@@ -20,7 +20,7 @@ use reth_execution_types::ExecutionOutcome;
 use reth_network::{BlockDownloaderProvider, NetworkHandle};
 use reth_network_api::NetworkInfo;
 use reth_node_ethereum::EthExecutorProvider;
-use reth_primitives::BlockSealExt;
+use reth_primitives::BlockExt;
 use reth_provider::{
     providers::ProviderNodeTypes, writer::UnifiedStorageWriter, AccountExtReader,
     ChainSpecProvider, HashingWriter, HeaderProvider, LatestStateProviderRef, OriginalValuesKnown,
diff --git a/crates/consensus/beacon/src/engine/mod.rs b/crates/consensus/beacon/src/engine/mod.rs
index 338299c3ba23..3d0f65423e46 100644
--- a/crates/consensus/beacon/src/engine/mod.rs
+++ b/crates/consensus/beacon/src/engine/mod.rs
@@ -1992,7 +1992,7 @@ mod tests {
     use assert_matches::assert_matches;
     use reth_chainspec::{ChainSpecBuilder, MAINNET};
     use reth_node_types::FullNodePrimitives;
-    use reth_primitives::BlockSealExt;
+    use reth_primitives::BlockExt;
     use reth_provider::{BlockWriter, ProviderFactory, StorageLocation};
     use reth_rpc_types_compat::engine::payload::block_to_payload_v1;
     use reth_stages::{ExecOutput, PipelineError, StageError};
diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 8aa46f165c5e..66eff882c92b 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -2609,7 +2609,7 @@ mod tests {
     use reth_engine_primitives::ForkchoiceStatus;
     use reth_ethereum_engine_primitives::EthEngineTypes;
     use reth_evm::test_utils::MockExecutorProvider;
-    use reth_primitives::BlockSealExt;
+    use reth_primitives::BlockExt;
     use reth_provider::test_utils::MockEthProvider;
     use reth_rpc_types_compat::engine::{block_to_payload_v1, payload::block_to_payload_v3};
     use reth_trie::updates::TrieUpdates;
diff --git a/crates/engine/util/src/reorg.rs b/crates/engine/util/src/reorg.rs
index 0758b2fd5922..1e2451f24c3c 100644
--- a/crates/engine/util/src/reorg.rs
+++ b/crates/engine/util/src/reorg.rs
@@ -18,7 +18,7 @@ use reth_evm::{
     ConfigureEvm,
 };
 use reth_payload_validator::ExecutionPayloadValidator;
-use reth_primitives::{proofs, Block, BlockBody, BlockSealExt, Receipt, Receipts};
+use reth_primitives::{proofs, Block, BlockBody, BlockExt, Receipt, Receipts};
 use reth_provider::{BlockReader, ExecutionOutcome, ProviderError, StateProviderFactory};
 use reth_revm::{
     database::StateProviderDatabase,
diff --git a/crates/ethereum/evm/src/execute.rs b/crates/ethereum/evm/src/execute.rs
index 7c17ef64a33e..f04ff46d9e53 100644
--- a/crates/ethereum/evm/src/execute.rs
+++ b/crates/ethereum/evm/src/execute.rs
@@ -320,7 +320,7 @@ mod tests {
     };
     use reth_execution_types::BlockExecutionOutput;
     use reth_primitives::{
-        public_key_to_address, Account, Block, BlockBody, BlockSealExt, Transaction,
+        public_key_to_address, Account, Block, BlockBody, BlockExt, Transaction,
     };
     use reth_revm::{
         database::StateProviderDatabase, test_utils::StateProviderTest, TransitionState,
diff --git a/crates/ethereum/payload/src/lib.rs b/crates/ethereum/payload/src/lib.rs
index a90e700bdd7c..49065ec0d8a8 100644
--- a/crates/ethereum/payload/src/lib.rs
+++ b/crates/ethereum/payload/src/lib.rs
@@ -27,7 +27,7 @@ use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::PayloadBuilderAttributes;
 use reth_primitives::{
     proofs::{self},
-    Block, BlockBody, BlockSealExt, EthereumHardforks, Receipt,
+    Block, BlockBody, BlockExt, EthereumHardforks, Receipt,
 };
 use reth_provider::{ChainSpecProvider, StateProviderFactory};
 use reth_revm::database::StateProviderDatabase;
diff --git a/crates/exex/exex/src/backfill/job.rs b/crates/exex/exex/src/backfill/job.rs
index 468515db217c..08d91e39197e 100644
--- a/crates/exex/exex/src/backfill/job.rs
+++ b/crates/exex/exex/src/backfill/job.rs
@@ -8,7 +8,7 @@ use alloy_primitives::BlockNumber;
 use reth_evm::execute::{
     BatchExecutor, BlockExecutionError, BlockExecutionOutput, BlockExecutorProvider, Executor,
 };
-use reth_primitives::{Block, BlockSealExt, BlockWithSenders, Receipt};
+use reth_primitives::{Block, BlockExt, BlockWithSenders, Receipt};
 use reth_primitives_traits::format_gas_throughput;
 use reth_provider::{
     BlockReader, Chain, HeaderProvider, ProviderError, StateProviderFactory, TransactionVariant,
diff --git a/crates/exex/exex/src/backfill/test_utils.rs b/crates/exex/exex/src/backfill/test_utils.rs
index f0d8afbab859..861d42f042b0 100644
--- a/crates/exex/exex/src/backfill/test_utils.rs
+++ b/crates/exex/exex/src/backfill/test_utils.rs
@@ -11,7 +11,7 @@ use reth_evm::execute::{
 use reth_evm_ethereum::execute::EthExecutorProvider;
 use reth_node_api::FullNodePrimitives;
 use reth_primitives::{
-    Block, BlockBody, BlockSealExt, BlockWithSenders, Receipt, SealedBlockWithSenders, Transaction,
+    Block, BlockBody, BlockExt, BlockWithSenders, Receipt, SealedBlockWithSenders, Transaction,
 };
 use reth_provider::{
     providers::ProviderNodeTypes, BlockWriter as _, ExecutionOutcome, LatestStateProviderRef,
diff --git a/crates/exex/exex/src/notifications.rs b/crates/exex/exex/src/notifications.rs
index ed574a65aa31..6c1e12d8d766 100644
--- a/crates/exex/exex/src/notifications.rs
+++ b/crates/exex/exex/src/notifications.rs
@@ -400,7 +400,7 @@ mod tests {
     use futures::StreamExt;
     use reth_db_common::init::init_genesis;
     use reth_evm_ethereum::execute::EthExecutorProvider;
-    use reth_primitives::{Block, BlockSealExt};
+    use reth_primitives::{Block, BlockExt};
     use reth_provider::{
         providers::BlockchainProvider2, test_utils::create_test_provider_factory, BlockWriter,
         Chain, DatabaseProviderFactory, StorageLocation,
diff --git a/crates/exex/test-utils/src/lib.rs b/crates/exex/test-utils/src/lib.rs
index 069da6668afd..15c770c5e9ea 100644
--- a/crates/exex/test-utils/src/lib.rs
+++ b/crates/exex/test-utils/src/lib.rs
@@ -45,7 +45,7 @@ use reth_node_ethereum::{
     EthEngineTypes, EthEvmConfig,
 };
 use reth_payload_builder::noop::NoopPayloadBuilderService;
-use reth_primitives::{BlockSealExt, EthPrimitives, Head, SealedBlockWithSenders};
+use reth_primitives::{BlockExt, EthPrimitives, Head, SealedBlockWithSenders};
 use reth_provider::{
     providers::{BlockchainProvider, StaticFileProvider},
     BlockReader, EthStorage, ProviderFactory,
diff --git a/crates/optimism/payload/src/builder.rs b/crates/optimism/payload/src/builder.rs
index 2185d1982ea8..fbf99c78d9e7 100644
--- a/crates/optimism/payload/src/builder.rs
+++ b/crates/optimism/payload/src/builder.rs
@@ -19,7 +19,7 @@ use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::PayloadBuilderAttributes;
 use reth_payload_util::PayloadTransactions;
 use reth_primitives::{
-    proofs, Block, BlockBody, BlockSealExt, Receipt, SealedHeader, TransactionSigned, TxType,
+    proofs, Block, BlockBody, BlockExt, Receipt, SealedHeader, TransactionSigned, TxType,
 };
 use reth_provider::{ProviderError, StateProofProvider, StateProviderFactory, StateRootProvider};
 use reth_revm::database::StateProviderDatabase;
diff --git a/crates/payload/builder/src/test_utils.rs b/crates/payload/builder/src/test_utils.rs
index 2f478f8add7e..4690ca14f0d8 100644
--- a/crates/payload/builder/src/test_utils.rs
+++ b/crates/payload/builder/src/test_utils.rs
@@ -9,7 +9,7 @@ use alloy_primitives::U256;
 use reth_chain_state::{CanonStateNotification, ExecutedBlock};
 use reth_payload_builder_primitives::PayloadBuilderError;
 use reth_payload_primitives::{PayloadKind, PayloadTypes};
-use reth_primitives::{Block, BlockSealExt};
+use reth_primitives::{Block, BlockExt};
 use std::{
     future::Future,
     pin::Pin,
diff --git a/crates/payload/validator/src/lib.rs b/crates/payload/validator/src/lib.rs
index cfaac1fbc70a..0a872a68ddfa 100644
--- a/crates/payload/validator/src/lib.rs
+++ b/crates/payload/validator/src/lib.rs
@@ -12,7 +12,7 @@ use alloy_rpc_types::engine::{
     ExecutionPayload, ExecutionPayloadSidecar, MaybeCancunPayloadFields, PayloadError,
 };
 use reth_chainspec::EthereumHardforks;
-use reth_primitives::{BlockSealExt, SealedBlock};
+use reth_primitives::{BlockExt, SealedBlock};
 use reth_rpc_types_compat::engine::payload::try_into_block;
 use std::sync::Arc;
 
diff --git a/crates/primitives/src/block.rs b/crates/primitives/src/block.rs
index 11882e019c10..b381b7dd807e 100644
--- a/crates/primitives/src/block.rs
+++ b/crates/primitives/src/block.rs
@@ -1,6 +1,6 @@
 use crate::{
-    traits::BlockSealExt, transaction::SignedTransactionIntoRecoveredExt, BlockBodyTxExt,
-    GotExpected, SealedHeader, TransactionSigned, TransactionSignedEcRecovered,
+    traits::BlockExt, transaction::SignedTransactionIntoRecoveredExt, BlockBodyTxExt, GotExpected,
+    SealedHeader, TransactionSigned, TransactionSignedEcRecovered,
 };
 use alloc::vec::Vec;
 use alloy_consensus::Header;
diff --git a/crates/primitives/src/traits.rs b/crates/primitives/src/traits.rs
index c5e7d316968c..73eabd8ec986 100644
--- a/crates/primitives/src/traits.rs
+++ b/crates/primitives/src/traits.rs
@@ -10,7 +10,7 @@ use revm_primitives::{Address, B256};
 /// Extension trait for [`reth_primitives_traits::Block`] implementations
 /// allowing for conversions into common block parts containers such as [`SealedBlock`],
 /// [`BlockWithSenders`], etc.
-pub trait BlockSealExt: Block {
+pub trait BlockExt: Block {
     /// Calculate the header hash and seal the block so that it can't be changed.
     fn seal_slow(self) -> SealedBlock<Self::Header, Self::Body> {
         let (header, body) = self.split();
@@ -87,7 +87,7 @@ pub trait BlockSealExt: Block {
     }
 }
 
-impl<T: Block> BlockSealExt for T {}
+impl<T: Block> BlockExt for T {}
 
 /// Extension trait for [`BlockBody`] adding helper methods operating with transactions.
 pub trait BlockBodyTxExt: BlockBody {
diff --git a/crates/rpc/rpc-builder/tests/it/auth.rs b/crates/rpc/rpc-builder/tests/it/auth.rs
index b5b1c98e7416..390ea7d6ba40 100644
--- a/crates/rpc/rpc-builder/tests/it/auth.rs
+++ b/crates/rpc/rpc-builder/tests/it/auth.rs
@@ -5,7 +5,7 @@ use alloy_primitives::U64;
 use alloy_rpc_types_engine::{ForkchoiceState, PayloadId, TransitionConfiguration};
 use jsonrpsee::core::client::{ClientT, SubscriptionClientT};
 use reth_ethereum_engine_primitives::EthEngineTypes;
-use reth_primitives::{Block, BlockSealExt};
+use reth_primitives::{Block, BlockExt};
 use reth_rpc_api::clients::EngineApiClient;
 use reth_rpc_layer::JwtSecret;
 use reth_rpc_types_compat::engine::payload::{
diff --git a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
index a1c405f9385e..0f20cb4204eb 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
@@ -17,7 +17,7 @@ use reth_evm::{
 };
 use reth_execution_types::ExecutionOutcome;
 use reth_primitives::{
-    proofs::calculate_transaction_root, Block, BlockBody, BlockSealExt, Receipt,
+    proofs::calculate_transaction_root, Block, BlockBody, BlockExt, Receipt,
     SealedBlockWithSenders, SealedHeader, TransactionSignedEcRecovered,
 };
 use reth_provider::{
diff --git a/crates/rpc/rpc-types-compat/src/engine/payload.rs b/crates/rpc/rpc-types-compat/src/engine/payload.rs
index 552238903410..46bc9502c579 100644
--- a/crates/rpc/rpc-types-compat/src/engine/payload.rs
+++ b/crates/rpc/rpc-types-compat/src/engine/payload.rs
@@ -15,7 +15,7 @@ use alloy_rpc_types_engine::{
 };
 use reth_primitives::{
     proofs::{self},
-    Block, BlockBody, BlockSealExt, SealedBlock, TransactionSigned,
+    Block, BlockBody, BlockExt, SealedBlock, TransactionSigned,
 };
 
 /// Converts [`ExecutionPayloadV1`] to [`Block`]
@@ -363,7 +363,7 @@ mod tests {
         CancunPayloadFields, ExecutionPayload, ExecutionPayloadSidecar, ExecutionPayloadV1,
         ExecutionPayloadV2, ExecutionPayloadV3,
     };
-    use reth_primitives::BlockSealExt;
+    use reth_primitives::BlockExt;
 
     #[test]
     fn roundtrip_payload_to_block() {
diff --git a/crates/rpc/rpc/src/debug.rs b/crates/rpc/rpc/src/debug.rs
index 07f0a0e3197a..5425de402f85 100644
--- a/crates/rpc/rpc/src/debug.rs
+++ b/crates/rpc/rpc/src/debug.rs
@@ -18,7 +18,7 @@ use reth_evm::{
     execute::{BlockExecutorProvider, Executor},
     ConfigureEvmEnv,
 };
-use reth_primitives::{Block, BlockSealExt, SealedBlockWithSenders};
+use reth_primitives::{Block, BlockExt, SealedBlockWithSenders};
 use reth_provider::{
     BlockReaderIdExt, ChainSpecProvider, HeaderProvider, StateProofProvider, StateProviderFactory,
     TransactionVariant,
diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs
index 0fd459b899c8..6801abee40d7 100644
--- a/crates/storage/provider/src/providers/blockchain_provider.rs
+++ b/crates/storage/provider/src/providers/blockchain_provider.rs
@@ -794,7 +794,7 @@ mod tests {
     use reth_errors::ProviderError;
     use reth_execution_types::{Chain, ExecutionOutcome};
     use reth_primitives::{
-        BlockSealExt, Receipt, SealedBlock, StaticFileSegment, TransactionSignedNoHash,
+        BlockExt, Receipt, SealedBlock, StaticFileSegment, TransactionSignedNoHash,
     };
     use reth_storage_api::{
         BlockHashReader, BlockIdReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource,
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index 614a376b10d1..d45b4e531242 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -48,7 +48,7 @@ use reth_execution_types::{Chain, ExecutionOutcome};
 use reth_network_p2p::headers::downloader::SyncTarget;
 use reth_node_types::{BlockTy, NodeTypes, TxTy};
 use reth_primitives::{
-    Account, Block, BlockBody, BlockSealExt, BlockWithSenders, Bytecode, GotExpected, Receipt,
+    Account, Block, BlockBody, BlockExt, BlockWithSenders, Bytecode, GotExpected, Receipt,
     SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
     TransactionMeta, TransactionSigned, TransactionSignedNoHash,
 };
diff --git a/examples/custom-payload-builder/src/generator.rs b/examples/custom-payload-builder/src/generator.rs
index 047d6ebf3ab3..14001d147f2c 100644
--- a/examples/custom-payload-builder/src/generator.rs
+++ b/examples/custom-payload-builder/src/generator.rs
@@ -9,7 +9,7 @@ use reth::{
 use reth_basic_payload_builder::{BasicPayloadJobGeneratorConfig, PayloadBuilder, PayloadConfig};
 use reth_node_api::PayloadBuilderAttributes;
 use reth_payload_builder::{PayloadBuilderError, PayloadJobGenerator};
-use reth_primitives::{BlockSealExt, SealedHeader};
+use reth_primitives::{BlockExt, SealedHeader};
 use std::sync::Arc;
 
 /// The generator type that creates new jobs that builds empty blocks.
diff --git a/examples/db-access/src/main.rs b/examples/db-access/src/main.rs
index cc8f18a2ad8e..e2955d01768d 100644
--- a/examples/db-access/src/main.rs
+++ b/examples/db-access/src/main.rs
@@ -4,7 +4,7 @@ use reth_chainspec::ChainSpecBuilder;
 use reth_db::{open_db_read_only, DatabaseEnv};
 use reth_node_ethereum::EthereumNode;
 use reth_node_types::NodeTypesWithDBAdapter;
-use reth_primitives::{BlockSealExt, SealedHeader, TransactionSigned};
+use reth_primitives::{BlockExt, SealedHeader, TransactionSigned};
 use reth_provider::{
     providers::StaticFileProvider, AccountReader, BlockReader, BlockSource, HeaderProvider,
     ProviderFactory, ReceiptProvider, StateProvider, TransactionsProvider,

From 94d8acde3c6a00fab2b4c263d88e4da8fb0afeb5 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 04:01:49 +0400
Subject: [PATCH 07/15] fix doc

---
 crates/payload/builder/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/payload/builder/src/lib.rs b/crates/payload/builder/src/lib.rs
index 0887a5ca74ac..b6191ea7fd11 100644
--- a/crates/payload/builder/src/lib.rs
+++ b/crates/payload/builder/src/lib.rs
@@ -31,7 +31,7 @@
 //! use alloy_consensus::Header;
 //! use alloy_primitives::U256;
 //! use reth_payload_builder::{EthBuiltPayload, PayloadBuilderError, KeepPayloadJobAlive, EthPayloadBuilderAttributes, PayloadJob, PayloadJobGenerator, PayloadKind};
-//! use reth_primitives::Block;
+//! use reth_primitives::{Block, BlockExt};
 //!
 //! /// The generator type that creates new jobs that builds empty blocks.
 //! pub struct EmptyBlockPayloadJobGenerator;

From 2b7cb7d5b75b919379c69318b0ef72e4591387fa Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 05:27:13 +0400
Subject: [PATCH 08/15] feat: ChainStorageReader

---
 Cargo.lock                                    |   1 +
 crates/chain-state/Cargo.toml                 |   1 +
 crates/chain-state/src/in_memory.rs           |  13 +-
 crates/optimism/node/src/node.rs              |  31 +++-
 crates/primitives/src/block.rs                |   6 -
 crates/prune/prune/src/segments/mod.rs        |   7 +-
 crates/storage/errors/src/provider.rs         |   2 +
 .../src/providers/blockchain_provider.rs      |   2 +
 .../provider/src/providers/consistent.rs      |  30 +---
 .../provider/src/providers/database/chain.rs  |  24 ++-
 .../src/providers/database/provider.rs        | 161 +++++++-----------
 crates/storage/provider/src/providers/mod.rs  |   7 +-
 crates/storage/storage-api/src/chain.rs       |  81 ++++++++-
 .../transaction-pool/src/blobstore/tracker.rs |   2 +
 14 files changed, 220 insertions(+), 148 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6463fd11a016..9641d8e26ae2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6614,6 +6614,7 @@ dependencies = [
  "reth-execution-types",
  "reth-metrics",
  "reth-primitives",
+ "reth-primitives-traits",
  "reth-storage-api",
  "reth-testing-utils",
  "reth-trie",
diff --git a/crates/chain-state/Cargo.toml b/crates/chain-state/Cargo.toml
index ff62b76e5dfb..6f7cf15d68c7 100644
--- a/crates/chain-state/Cargo.toml
+++ b/crates/chain-state/Cargo.toml
@@ -18,6 +18,7 @@ reth-errors.workspace = true
 reth-execution-types.workspace = true
 reth-metrics.workspace = true
 reth-primitives.workspace = true
+reth-primitives-traits.workspace = true
 reth-storage-api.workspace = true
 reth-trie.workspace = true
 
diff --git a/crates/chain-state/src/in_memory.rs b/crates/chain-state/src/in_memory.rs
index 24f394a761f5..c85176850322 100644
--- a/crates/chain-state/src/in_memory.rs
+++ b/crates/chain-state/src/in_memory.rs
@@ -15,6 +15,7 @@ use reth_primitives::{
     BlockWithSenders, NodePrimitives, Receipts, SealedBlock, SealedBlockWithSenders, SealedHeader,
     TransactionMeta, TransactionSigned,
 };
+use reth_primitives_traits::BlockBody as _;
 use reth_storage_api::StateProviderBox;
 use reth_trie::{updates::TrieUpdates, HashedPostState};
 use std::{collections::BTreeMap, sync::Arc, time::Instant};
@@ -534,8 +535,13 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
     /// Returns a `TransactionSigned` for the given `TxHash` if found.
     pub fn transaction_by_hash(&self, hash: TxHash) -> Option<TransactionSigned> {
         for block_state in self.canonical_chain() {
-            if let Some(tx) =
-                block_state.block_ref().block().body.transactions().find(|tx| tx.hash() == hash)
+            if let Some(tx) = block_state
+                .block_ref()
+                .block()
+                .body
+                .transactions()
+                .iter()
+                .find(|tx| tx.hash() == hash)
             {
                 return Some(tx.clone())
             }
@@ -555,6 +561,7 @@ impl<N: NodePrimitives> CanonicalInMemoryState<N> {
                 .block()
                 .body
                 .transactions()
+                .iter()
                 .enumerate()
                 .find(|(_, tx)| tx.hash() == tx_hash)
             {
@@ -735,6 +742,7 @@ impl<N: NodePrimitives> BlockState<N> {
                 .block()
                 .body
                 .transactions()
+                .iter()
                 .find(|tx| tx.hash() == hash)
                 .cloned()
         })
@@ -751,6 +759,7 @@ impl<N: NodePrimitives> BlockState<N> {
                 .block()
                 .body
                 .transactions()
+                .iter()
                 .enumerate()
                 .find(|(_, tx)| tx.hash() == tx_hash)
                 .map(|(index, tx)| {
diff --git a/crates/optimism/node/src/node.rs b/crates/optimism/node/src/node.rs
index 82b2ce2ebc2b..cc0a61833e41 100644
--- a/crates/optimism/node/src/node.rs
+++ b/crates/optimism/node/src/node.rs
@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use alloy_consensus::Header;
 use reth_basic_payload_builder::{BasicPayloadJobGenerator, BasicPayloadJobGeneratorConfig};
-use reth_chainspec::{EthChainSpec, Hardforks};
+use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
 use reth_db::transaction::{DbTx, DbTxMut};
 use reth_evm::{execute::BasicBlockExecutorProvider, ConfigureEvm};
 use reth_network::{NetworkConfig, NetworkHandle, NetworkManager, PeersInfo};
@@ -32,8 +32,8 @@ use reth_optimism_rpc::{
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
 use reth_primitives::BlockBody;
 use reth_provider::{
-    providers::ChainStorage, BlockBodyWriter, CanonStateSubscriptions, DBProvider, EthStorage,
-    ProviderResult,
+    providers::ChainStorage, BlockBodyReader, BlockBodyWriter, CanonStateSubscriptions,
+    ChainSpecProvider, DBProvider, EthStorage, ProviderResult, ReadBodyInput,
 };
 use reth_rpc_server_types::RethRpcModule;
 use reth_tracing::tracing::{debug, info};
@@ -72,7 +72,31 @@ impl<Provider: DBProvider<Tx: DbTxMut>> BlockBodyWriter<Provider, BlockBody> for
     }
 }
 
+impl<Provider: DBProvider + ChainSpecProvider<ChainSpec: EthereumHardforks>>
+    BlockBodyReader<Provider> for OpStorage
+{
+    type Block = reth_primitives::Block;
+
+    fn read_block_bodies(
+        &self,
+        provider: &Provider,
+        inputs: Vec<ReadBodyInput<'_, Self::Block>>,
+    ) -> ProviderResult<Vec<BlockBody>> {
+        self.0.read_block_bodies(provider, inputs)
+    }
+}
+
 impl ChainStorage<OpPrimitives> for OpStorage {
+    fn reader<TX, Types>(
+        &self,
+    ) -> impl reth_provider::ChainStorageReader<reth_provider::DatabaseProvider<TX, Types>, OpPrimitives>
+    where
+        TX: DbTx + 'static,
+        Types: reth_provider::providers::NodeTypesForProvider<Primitives = OpPrimitives>,
+    {
+        self
+    }
+
     fn writer<TX, Types>(
         &self,
     ) -> impl reth_provider::ChainStorageWriter<reth_provider::DatabaseProvider<TX, Types>, OpPrimitives>
@@ -83,6 +107,7 @@ impl ChainStorage<OpPrimitives> for OpStorage {
         self
     }
 }
+
 /// Type configuration for a regular Optimism node.
 #[derive(Debug, Default, Clone)]
 #[non_exhaustive]
diff --git a/crates/primitives/src/block.rs b/crates/primitives/src/block.rs
index b381b7dd807e..d7babfc62894 100644
--- a/crates/primitives/src/block.rs
+++ b/crates/primitives/src/block.rs
@@ -661,12 +661,6 @@ impl BlockBody {
     pub fn blob_versioned_hashes(&self) -> Vec<&B256> {
         self.blob_versioned_hashes_iter().collect()
     }
-
-    /// Returns an iterator over all transactions.
-    #[inline]
-    pub fn transactions(&self) -> impl Iterator<Item = &TransactionSigned> + '_ {
-        self.transactions.iter()
-    }
 }
 
 impl InMemorySize for BlockBody {
diff --git a/crates/prune/prune/src/segments/mod.rs b/crates/prune/prune/src/segments/mod.rs
index b3b40aab5b3b..e828512fa824 100644
--- a/crates/prune/prune/src/segments/mod.rs
+++ b/crates/prune/prune/src/segments/mod.rs
@@ -148,6 +148,7 @@ impl PruneInput {
 mod tests {
     use super::*;
     use alloy_primitives::B256;
+    use reth_primitives_traits::BlockBody;
     use reth_provider::{
         providers::BlockchainProvider2,
         test_utils::{create_test_provider_factory, MockEthProvider},
@@ -245,7 +246,7 @@ mod tests {
 
         // Calculate the total number of transactions
         let num_txs =
-            blocks.iter().map(|block| block.body.transactions().count() as u64).sum::<u64>();
+            blocks.iter().map(|block| block.body.transactions().len() as u64).sum::<u64>();
 
         assert_eq!(range, 0..=num_txs - 1);
     }
@@ -292,7 +293,7 @@ mod tests {
 
         // Calculate the total number of transactions
         let num_txs =
-            blocks.iter().map(|block| block.body.transactions().count() as u64).sum::<u64>();
+            blocks.iter().map(|block| block.body.transactions().len() as u64).sum::<u64>();
 
         assert_eq!(range, 0..=num_txs - 1,);
     }
@@ -327,7 +328,7 @@ mod tests {
         // Get the last tx number
         // Calculate the total number of transactions
         let num_txs =
-            blocks.iter().map(|block| block.body.transactions().count() as u64).sum::<u64>();
+            blocks.iter().map(|block| block.body.transactions().len() as u64).sum::<u64>();
         let max_range = num_txs - 1;
 
         // Create a prune input with a previous checkpoint that is the last tx number
diff --git a/crates/storage/errors/src/provider.rs b/crates/storage/errors/src/provider.rs
index 9e6720b84403..e69c0343f564 100644
--- a/crates/storage/errors/src/provider.rs
+++ b/crates/storage/errors/src/provider.rs
@@ -133,6 +133,8 @@ pub enum ProviderError {
     StorageLockError(StorageLockError),
     /// Storage writer error.
     UnifiedStorageWriterError(UnifiedStorageWriterError),
+    /// Received invalid output from configured storage implementation.
+    InvalidStorageOutput,
 }
 
 impl From<DatabaseError> for ProviderError {
diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs
index 6801abee40d7..d90b227c1122 100644
--- a/crates/storage/provider/src/providers/blockchain_provider.rs
+++ b/crates/storage/provider/src/providers/blockchain_provider.rs
@@ -30,6 +30,7 @@ use reth_primitives::{
     Account, Block, BlockWithSenders, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
     StorageEntry, TransactionMeta, TransactionSigned, TransactionSignedNoHash,
 };
+use reth_primitives_traits::BlockBody as _;
 use reth_prune_types::{PruneCheckpoint, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_storage_api::{DBProvider, StorageChangeSetReader};
@@ -796,6 +797,7 @@ mod tests {
     use reth_primitives::{
         BlockExt, Receipt, SealedBlock, StaticFileSegment, TransactionSignedNoHash,
     };
+    use reth_primitives_traits::BlockBody as _;
     use reth_storage_api::{
         BlockHashReader, BlockIdReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource,
         ChangeSetReader, DatabaseProviderFactory, HeaderProvider, ReceiptProvider,
diff --git a/crates/storage/provider/src/providers/consistent.rs b/crates/storage/provider/src/providers/consistent.rs
index fc9d739b0fea..740392ad9938 100644
--- a/crates/storage/provider/src/providers/consistent.rs
+++ b/crates/storage/provider/src/providers/consistent.rs
@@ -977,7 +977,7 @@ impl<N: ProviderNodeTypes> TransactionsProvider for ConsistentProvider<N> {
 
     fn transaction_by_hash(&self, hash: TxHash) -> ProviderResult<Option<Self::Transaction>> {
         if let Some(tx) = self.head_block.as_ref().and_then(|b| b.transaction_on_chain(hash)) {
-            return Ok(Some(tx.into()))
+            return Ok(Some(tx))
         }
 
         self.storage_provider.transaction_by_hash(hash)
@@ -990,7 +990,7 @@ impl<N: ProviderNodeTypes> TransactionsProvider for ConsistentProvider<N> {
         if let Some((tx, meta)) =
             self.head_block.as_ref().and_then(|b| b.transaction_meta_on_chain(tx_hash))
         {
-            return Ok(Some((tx.into(), meta)))
+            return Ok(Some((tx, meta)))
         }
 
         self.storage_provider.transaction_by_hash_with_meta(tx_hash)
@@ -1011,18 +1011,7 @@ impl<N: ProviderNodeTypes> TransactionsProvider for ConsistentProvider<N> {
         self.get_in_memory_or_storage_by_block(
             id,
             |provider| provider.transactions_by_block(id),
-            |block_state| {
-                Ok(Some(
-                    block_state
-                        .block_ref()
-                        .block()
-                        .body
-                        .transactions
-                        .iter()
-                        .map(|tx| tx.clone().into())
-                        .collect(),
-                ))
-            },
+            |block_state| Ok(Some(block_state.block_ref().block().body.transactions.clone())),
         )
     }
 
@@ -1033,18 +1022,7 @@ impl<N: ProviderNodeTypes> TransactionsProvider for ConsistentProvider<N> {
         self.get_in_memory_or_storage_by_block_range_while(
             range,
             |db_provider, range, _| db_provider.transactions_by_block_range(range),
-            |block_state, _| {
-                Some(
-                    block_state
-                        .block_ref()
-                        .block()
-                        .body
-                        .transactions
-                        .iter()
-                        .map(|tx| tx.clone().into())
-                        .collect(),
-                )
-            },
+            |block_state, _| Some(block_state.block_ref().block().body.transactions.clone()),
             |_| true,
         )
     }
diff --git a/crates/storage/provider/src/providers/database/chain.rs b/crates/storage/provider/src/providers/database/chain.rs
index 8f9a6395a9dd..57bc2e0b5ce6 100644
--- a/crates/storage/provider/src/providers/database/chain.rs
+++ b/crates/storage/provider/src/providers/database/chain.rs
@@ -1,25 +1,41 @@
-use crate::{providers::NodeTypes, DatabaseProvider};
+use crate::{providers::NodeTypesForProvider, DatabaseProvider};
 use reth_db::transaction::{DbTx, DbTxMut};
 use reth_node_types::FullNodePrimitives;
 use reth_primitives::EthPrimitives;
-use reth_storage_api::{ChainStorageWriter, EthStorage};
+use reth_storage_api::{ChainStorageReader, ChainStorageWriter, EthStorage};
 
 /// Trait that provides access to implementations of [`ChainStorage`]
 pub trait ChainStorage<Primitives: FullNodePrimitives>: Send + Sync {
+    /// Provides access to the chain reader.
+    fn reader<TX, Types>(&self) -> impl ChainStorageReader<DatabaseProvider<TX, Types>, Primitives>
+    where
+        TX: DbTx + 'static,
+        Types: NodeTypesForProvider<Primitives = Primitives>;
+
     /// Provides access to the chain writer.
     fn writer<TX, Types>(&self) -> impl ChainStorageWriter<DatabaseProvider<TX, Types>, Primitives>
     where
         TX: DbTxMut + DbTx + 'static,
-        Types: NodeTypes<Primitives = Primitives>;
+        Types: NodeTypesForProvider<Primitives = Primitives>;
 }
 
 impl ChainStorage<EthPrimitives> for EthStorage {
+    fn reader<TX, Types>(
+        &self,
+    ) -> impl ChainStorageReader<DatabaseProvider<TX, Types>, EthPrimitives>
+    where
+        TX: DbTx + 'static,
+        Types: NodeTypesForProvider<Primitives = EthPrimitives>,
+    {
+        self
+    }
+
     fn writer<TX, Types>(
         &self,
     ) -> impl ChainStorageWriter<DatabaseProvider<TX, Types>, EthPrimitives>
     where
         TX: DbTxMut + DbTx + 'static,
-        Types: NodeTypes<Primitives = EthPrimitives>,
+        Types: NodeTypesForProvider<Primitives = EthPrimitives>,
     {
         self
     }
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index d45b4e531242..47d9308283fd 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -50,12 +50,14 @@ use reth_node_types::{BlockTy, NodeTypes, TxTy};
 use reth_primitives::{
     Account, Block, BlockBody, BlockExt, BlockWithSenders, Bytecode, GotExpected, Receipt,
     SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
-    TransactionMeta, TransactionSigned, TransactionSignedNoHash,
+    TransactionMeta, TransactionSignedNoHash,
 };
 use reth_primitives_traits::{BlockBody as _, SignedTransaction};
 use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
-use reth_storage_api::{StateProvider, StorageChangeSetReader, TryIntoHistoricalStateProvider};
+use reth_storage_api::{
+    BlockBodyReader, StateProvider, StorageChangeSetReader, TryIntoHistoricalStateProvider,
+};
 use reth_storage_errors::provider::{ProviderResult, RootMismatch};
 use reth_trie::{
     prefix_set::{PrefixSet, PrefixSetMut, TriePrefixSets},
@@ -517,21 +519,11 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         N::ChainSpec: EthereumHardforks,
         H: AsRef<Header>,
         HF: FnOnce(BlockNumber) -> ProviderResult<Option<H>>,
-        BF: FnOnce(
-            H,
-            Vec<TransactionSigned>,
-            Vec<Address>,
-            Vec<Header>,
-            Option<Withdrawals>,
-        ) -> ProviderResult<Option<B>>,
+        BF: FnOnce(H, BlockBody, Vec<Address>) -> ProviderResult<Option<B>>,
     {
         let Some(block_number) = self.convert_hash_or_number(id)? else { return Ok(None) };
         let Some(header) = header_by_number(block_number)? else { return Ok(None) };
 
-        let ommers = self.ommers(block_number.into())?.unwrap_or_default();
-        let withdrawals =
-            self.withdrawals_by_block(block_number.into(), header.as_ref().timestamp)?;
-
         // Get the block body
         //
         // If the body indices are not found, this means that the transactions either do not exist
@@ -548,9 +540,14 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
             (self.transactions_by_tx_range(tx_range.clone())?, self.senders_by_tx_range(tx_range)?)
         };
 
-        let body = transactions.into_iter().map(Into::into).collect();
+        let body = self
+            .storage
+            .reader()
+            .read_block_bodies(self, vec![(header.as_ref(), transactions)])?
+            .pop()
+            .ok_or(ProviderError::InvalidStorageOutput)?;
 
-        construct_block(header, body, senders, ommers, withdrawals)
+        construct_block(header, body, senders)
     }
 
     /// Returns a range of blocks from the database.
@@ -572,7 +569,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         N::ChainSpec: EthereumHardforks,
         H: AsRef<Header>,
         HF: FnOnce(RangeInclusive<BlockNumber>) -> ProviderResult<Vec<H>>,
-        F: FnMut(H, Range<TxNumber>, Vec<Header>, Option<Withdrawals>) -> ProviderResult<R>,
+        F: FnMut(H, BlockBody, Range<TxNumber>) -> ProviderResult<R>,
     {
         if range.is_empty() {
             return Ok(Vec::new())
@@ -582,50 +579,41 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         let mut blocks = Vec::with_capacity(len);
 
         let headers = headers_range(range)?;
-        let mut ommers_cursor = self.tx.cursor_read::<tables::BlockOmmers>()?;
-        let mut withdrawals_cursor = self.tx.cursor_read::<tables::BlockWithdrawals>()?;
+        let mut tx_cursor = self.tx.cursor_read::<tables::Transactions<TxTy<N>>>()?;
         let mut block_body_cursor = self.tx.cursor_read::<tables::BlockBodyIndices>()?;
 
+        let mut present_headers = Vec::new();
         for header in headers {
-            let header_ref = header.as_ref();
             // If the body indices are not found, this means that the transactions either do
             // not exist in the database yet, or they do exit but are
             // not indexed. If they exist but are not indexed, we don't
             // have enough information to return the block anyways, so
             // we skip the block.
             if let Some((_, block_body_indices)) =
-                block_body_cursor.seek_exact(header_ref.number)?
+                block_body_cursor.seek_exact(header.as_ref().number)?
             {
                 let tx_range = block_body_indices.tx_num_range();
-
-                // If we are past shanghai, then all blocks should have a withdrawal list,
-                // even if empty
-                let withdrawals =
-                    if self.chain_spec.is_shanghai_active_at_timestamp(header_ref.timestamp) {
-                        withdrawals_cursor
-                            .seek_exact(header_ref.number)?
-                            .map(|(_, w)| w.withdrawals)
-                            .unwrap_or_default()
-                            .into()
-                    } else {
-                        None
-                    };
-                let ommers =
-                    if self.chain_spec.final_paris_total_difficulty(header_ref.number).is_some() {
-                        Vec::new()
-                    } else {
-                        ommers_cursor
-                            .seek_exact(header_ref.number)?
-                            .map(|(_, o)| o.ommers)
-                            .unwrap_or_default()
-                    };
-
-                if let Ok(b) = assemble_block(header, tx_range, ommers, withdrawals) {
-                    blocks.push(b);
-                }
+                present_headers.push((header, tx_range));
             }
         }
 
+        let mut inputs = Vec::new();
+        for (header, tx_range) in &present_headers {
+            let transactions = if tx_range.is_empty() {
+                Vec::new()
+            } else {
+                self.transactions_by_tx_range_with_cursor(tx_range.clone(), &mut tx_cursor)?
+            };
+
+            inputs.push((header.as_ref(), transactions));
+        }
+
+        let bodies = self.storage.reader().read_block_bodies(self, inputs)?;
+
+        for ((header, tx_range), body) in present_headers.into_iter().zip(bodies) {
+            blocks.push(assemble_block(header, body, tx_range)?);
+        }
+
         Ok(blocks)
     }
 
@@ -649,34 +637,22 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         N::ChainSpec: EthereumHardforks,
         H: AsRef<Header>,
         HF: Fn(RangeInclusive<BlockNumber>) -> ProviderResult<Vec<H>>,
-        BF: Fn(
-            H,
-            Vec<TransactionSigned>,
-            Vec<Header>,
-            Option<Withdrawals>,
-            Vec<Address>,
-        ) -> ProviderResult<B>,
+        BF: Fn(H, BlockBody, Vec<Address>) -> ProviderResult<B>,
     {
-        let mut tx_cursor = self.tx.cursor_read::<tables::Transactions<TxTy<N>>>()?;
         let mut senders_cursor = self.tx.cursor_read::<tables::TransactionSenders>()?;
 
-        self.block_range(range, headers_range, |header, tx_range, ommers, withdrawals| {
-            let (body, senders) = if tx_range.is_empty() {
-                (Vec::new(), Vec::new())
+        self.block_range(range, headers_range, |header, body, tx_range| {
+            let senders = if tx_range.is_empty() {
+                Vec::new()
             } else {
-                let body = self
-                    .transactions_by_tx_range_with_cursor(tx_range.clone(), &mut tx_cursor)?
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<TransactionSigned>>();
                 // fetch senders from the senders table
                 let known_senders =
                     senders_cursor
                         .walk_range(tx_range.clone())?
                         .collect::<Result<HashMap<_, _>, _>>()?;
 
-                let mut senders = Vec::with_capacity(body.len());
-                for (tx_num, tx) in tx_range.zip(body.iter()) {
+                let mut senders = Vec::with_capacity(body.transactions.len());
+                for (tx_num, tx) in tx_range.zip(body.transactions()) {
                     match known_senders.get(&tx_num) {
                         None => {
                             // recover the sender from the transaction if not found
@@ -689,10 +665,10 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
                     }
                 }
 
-                (body, senders)
+                senders
             };
 
-            assemble_block(header, body, ommers, withdrawals, senders)
+            assemble_block(header, body, senders)
         })
     }
 
@@ -1230,21 +1206,22 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
     fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
         if let Some(number) = self.convert_hash_or_number(id)? {
             if let Some(header) = self.header_by_number(number)? {
-                let withdrawals = self.withdrawals_by_block(number.into(), header.timestamp)?;
-                let ommers = self.ommers(number.into())?.unwrap_or_default();
                 // If the body indices are not found, this means that the transactions either do not
                 // exist in the database yet, or they do exit but are not indexed.
                 // If they exist but are not indexed, we don't have enough
                 // information to return the block anyways, so we return `None`.
-                let transactions = match self.transactions_by_block(number.into())? {
-                    Some(transactions) => transactions.into_iter().map(Into::into).collect(),
-                    None => return Ok(None),
+                let Some(transactions) = self.transactions_by_block(number.into())? else {
+                    return Ok(None)
                 };
 
-                return Ok(Some(Block {
-                    header,
-                    body: BlockBody { transactions, ommers, withdrawals },
-                }))
+                let body = self
+                    .storage
+                    .reader()
+                    .read_block_bodies(self, vec![(&header, transactions)])?
+                    .pop()
+                    .ok_or(ProviderError::InvalidStorageOutput)?;
+
+                return Ok(Some(Block { header, body }))
             }
         }
 
@@ -1303,8 +1280,8 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
             id,
             transaction_kind,
             |block_number| self.header_by_number(block_number),
-            |header, transactions, senders, ommers, withdrawals| {
-                Block { header, body: BlockBody { transactions, ommers, withdrawals } }
+            |header, body, senders| {
+                Block { header, body }
                     // Note: we're using unchecked here because we know the block contains valid txs
                     // wrt to its height and can ignore the s value check so pre
                     // EIP-2 txs are allowed
@@ -1324,8 +1301,8 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
             id,
             transaction_kind,
             |block_number| self.sealed_header(block_number),
-            |header, transactions, senders, ommers, withdrawals| {
-                SealedBlock { header, body: BlockBody { transactions, ommers, withdrawals } }
+            |header, body, senders| {
+                SealedBlock { header, body }
                     // Note: we're using unchecked here because we know the block contains valid txs
                     // wrt to its height and can ignore the s value check so pre
                     // EIP-2 txs are allowed
@@ -1337,21 +1314,10 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
     }
 
     fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
-        let mut tx_cursor = self.tx.cursor_read::<tables::Transactions<TxTy<N>>>()?;
         self.block_range(
             range,
             |range| self.headers_range(range),
-            |header, tx_range, ommers, withdrawals| {
-                let transactions = if tx_range.is_empty() {
-                    Vec::new()
-                } else {
-                    self.transactions_by_tx_range_with_cursor(tx_range, &mut tx_cursor)?
-                        .into_iter()
-                        .map(Into::into)
-                        .collect()
-                };
-                Ok(Block { header, body: BlockBody { transactions, ommers, withdrawals } })
-            },
+            |header, body, _| Ok(Block { header, body }),
         )
     }
 
@@ -1362,8 +1328,8 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
         self.block_with_senders_range(
             range,
             |range| self.headers_range(range),
-            |header, transactions, ommers, withdrawals, senders| {
-                Block { header, body: BlockBody { transactions, ommers, withdrawals } }
+            |header, body, senders| {
+                Block { header, body }
                     .try_with_senders_unchecked(senders)
                     .map_err(|_| ProviderError::SenderRecoveryError)
             },
@@ -1377,12 +1343,9 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
         self.block_with_senders_range(
             range,
             |range| self.sealed_headers_range(range),
-            |header, transactions, ommers, withdrawals, senders| {
-                SealedBlockWithSenders::new(
-                    SealedBlock { header, body: BlockBody { transactions, ommers, withdrawals } },
-                    senders,
-                )
-                .ok_or(ProviderError::SenderRecoveryError)
+            |header, body, senders| {
+                SealedBlockWithSenders::new(SealedBlock { header, body }, senders)
+                    .ok_or(ProviderError::SenderRecoveryError)
             },
         )
     }
diff --git a/crates/storage/provider/src/providers/mod.rs b/crates/storage/provider/src/providers/mod.rs
index 497f817b88a8..b41173f293c7 100644
--- a/crates/storage/provider/src/providers/mod.rs
+++ b/crates/storage/provider/src/providers/mod.rs
@@ -20,7 +20,6 @@ use reth_blockchain_tree_api::{
 };
 use reth_chain_state::{ChainInfoTracker, ForkChoiceNotifications, ForkChoiceSubscriptions};
 use reth_chainspec::{ChainInfo, EthereumHardforks};
-use reth_db::table::Value;
 use reth_db_api::models::{AccountBeforeTx, StoredBlockBodyIndices};
 use reth_evm::ConfigureEvmEnv;
 use reth_node_types::{FullNodePrimitives, NodeTypes, NodeTypesWithDB, TxTy};
@@ -77,8 +76,9 @@ where
         ChainSpec: EthereumHardforks,
         Storage: ChainStorage<Self::Primitives>,
         Primitives: FullNodePrimitives<
-            SignedTx: Value + From<TransactionSigned> + Into<TransactionSigned>,
+            SignedTx = TransactionSigned,
             BlockHeader = alloy_consensus::Header,
+            BlockBody = reth_primitives::BlockBody,
         >,
     >,
 {
@@ -89,8 +89,9 @@ impl<T> NodeTypesForProvider for T where
         ChainSpec: EthereumHardforks,
         Storage: ChainStorage<T::Primitives>,
         Primitives: FullNodePrimitives<
-            SignedTx: Value + From<TransactionSigned> + Into<TransactionSigned>,
+            SignedTx = TransactionSigned,
             BlockHeader = alloy_consensus::Header,
+            BlockBody = reth_primitives::BlockBody,
         >,
     >
 {
diff --git a/crates/storage/storage-api/src/chain.rs b/crates/storage/storage-api/src/chain.rs
index d5228bdddf72..baee2f870a99 100644
--- a/crates/storage/storage-api/src/chain.rs
+++ b/crates/storage/storage-api/src/chain.rs
@@ -1,10 +1,11 @@
 use crate::DBProvider;
 use alloy_primitives::BlockNumber;
+use reth_chainspec::{ChainSpecProvider, EthereumHardforks};
 use reth_db::{
-    cursor::DbCursorRW,
+    cursor::{DbCursorRO, DbCursorRW},
     models::{StoredBlockOmmers, StoredBlockWithdrawals},
     tables,
-    transaction::DbTxMut,
+    transaction::{DbTx, DbTxMut},
     DbTxUnwindExt,
 };
 use reth_primitives_traits::{Block, BlockBody, FullNodePrimitives};
@@ -41,6 +42,38 @@ impl<T, Provider, Primitives: FullNodePrimitives> ChainStorageWriter<Provider, P
 {
 }
 
+/// Input for reading a block body. Contains a header of block being read and a list of pre-fetched
+/// transactions.
+pub type ReadBodyInput<'a, B> =
+    (&'a <B as Block>::Header, Vec<<<B as Block>::Body as BlockBody>::Transaction>);
+
+/// Trait that implements how block bodies are read from the storage.
+///
+/// Note: Within the current abstraction, transactions persistence is handled separately, thus this
+/// trait is provided with transactions read beforehand and is expected to construct the block body
+/// from those transactions and additional data read from elsewhere.
+#[auto_impl::auto_impl(&, Arc)]
+pub trait BlockBodyReader<Provider> {
+    /// The block type.
+    type Block: Block;
+
+    /// Receives a list of block headers along with block transactions and returns the block bodies.
+    fn read_block_bodies(
+        &self,
+        provider: &Provider,
+        inputs: Vec<ReadBodyInput<'_, Self::Block>>,
+    ) -> ProviderResult<Vec<<Self::Block as Block>::Body>>;
+}
+
+/// Trait that implements how chain-specific types are read from storage.
+pub trait ChainStorageReader<Provider, Primitives: FullNodePrimitives>:
+    BlockBodyReader<Provider, Block = Primitives::Block>
+{
+}
+impl<T, Provider, Primitives: FullNodePrimitives> ChainStorageReader<Provider, Primitives> for T where
+    T: BlockBodyReader<Provider, Block = Primitives::Block>
+{
+}
 /// Ethereum storage implementation.
 #[derive(Debug, Default, Clone, Copy)]
 pub struct EthStorage;
@@ -89,3 +122,47 @@ where
         Ok(())
     }
 }
+
+impl<Provider> BlockBodyReader<Provider> for EthStorage
+where
+    Provider: DBProvider + ChainSpecProvider<ChainSpec: EthereumHardforks>,
+{
+    type Block = reth_primitives::Block;
+
+    fn read_block_bodies(
+        &self,
+        provider: &Provider,
+        inputs: Vec<ReadBodyInput<'_, Self::Block>>,
+    ) -> ProviderResult<Vec<<Self::Block as Block>::Body>> {
+        // TODO: Ideally storage should hold its own copy of chain spec
+        let chain_spec = provider.chain_spec();
+
+        let mut ommers_cursor = provider.tx_ref().cursor_read::<tables::BlockOmmers>()?;
+        let mut withdrawals_cursor = provider.tx_ref().cursor_read::<tables::BlockWithdrawals>()?;
+
+        let mut bodies = Vec::with_capacity(inputs.len());
+
+        for (header, transactions) in inputs {
+            // If we are past shanghai, then all blocks should have a withdrawal list,
+            // even if empty
+            let withdrawals = if chain_spec.is_shanghai_active_at_timestamp(header.timestamp) {
+                withdrawals_cursor
+                    .seek_exact(header.number)?
+                    .map(|(_, w)| w.withdrawals)
+                    .unwrap_or_default()
+                    .into()
+            } else {
+                None
+            };
+            let ommers = if chain_spec.final_paris_total_difficulty(header.number).is_some() {
+                Vec::new()
+            } else {
+                ommers_cursor.seek_exact(header.number)?.map(|(_, o)| o.ommers).unwrap_or_default()
+            };
+
+            bodies.push(reth_primitives::BlockBody { transactions, ommers, withdrawals });
+        }
+
+        Ok(bodies)
+    }
+}
diff --git a/crates/transaction-pool/src/blobstore/tracker.rs b/crates/transaction-pool/src/blobstore/tracker.rs
index 0f48c89a4995..b3670496b5a8 100644
--- a/crates/transaction-pool/src/blobstore/tracker.rs
+++ b/crates/transaction-pool/src/blobstore/tracker.rs
@@ -2,6 +2,7 @@
 
 use alloy_primitives::{BlockNumber, B256};
 use reth_execution_types::ChainBlocks;
+use reth_primitives_traits::BlockBody as _;
 use std::collections::BTreeMap;
 
 /// The type that is used to track canonical blob transactions.
@@ -42,6 +43,7 @@ impl BlobStoreCanonTracker {
             let iter = block
                 .body
                 .transactions()
+                .iter()
                 .filter(|tx| tx.transaction.is_eip4844())
                 .map(|tx| tx.hash());
             (*num, iter)

From 9da514e0a8e8a5b2ad02e5532ebbe37a4d63e1e7 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 05:43:31 +0400
Subject: [PATCH 09/15] fix

---
 crates/chain-state/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/chain-state/Cargo.toml b/crates/chain-state/Cargo.toml
index 6f7cf15d68c7..54f7ac43de11 100644
--- a/crates/chain-state/Cargo.toml
+++ b/crates/chain-state/Cargo.toml
@@ -63,6 +63,7 @@ test-utils = [
     "revm",
     "reth-chainspec/test-utils",
     "reth-primitives/test-utils",
+    "reth-primitives-traits/test-utils",
     "reth-trie/test-utils",
     "revm?/test-utils",
 ]

From db32cf215696bdf48a2f237aff73bdd1b1c11dc4 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Sat, 23 Nov 2024 18:34:26 +0400
Subject: [PATCH 10/15] feat: add Block AT to BlockReader

---
 Cargo.lock                                    |   1 +
 crates/consensus/beacon/src/engine/mod.rs     |  14 +-
 crates/e2e-test-utils/Cargo.toml              |   1 +
 crates/e2e-test-utils/src/node.rs             |  14 +-
 crates/e2e-test-utils/src/rpc.rs              |   9 +-
 crates/engine/tree/src/tree/mod.rs            |  13 +-
 crates/engine/util/src/reorg.rs               |   4 +-
 crates/ethereum/node/src/node.rs              |   4 +-
 crates/exex/exex/Cargo.toml                   |   1 +
 crates/exex/exex/src/backfill/job.rs          |  31 +--
 crates/exex/exex/src/backfill/stream.rs       |  16 +-
 crates/exex/exex/src/context.rs               |  19 +-
 crates/exex/exex/src/dyn_context.rs           |   3 +-
 crates/exex/exex/src/notifications.rs         |  28 ++-
 crates/exex/test-utils/src/lib.rs             |   4 +-
 crates/net/network/src/config.rs              |   2 +-
 crates/net/network/src/eth_requests.rs        |  11 +-
 crates/net/network/src/test_utils/testnet.rs  |   6 +-
 crates/node/builder/src/builder/mod.rs        |   4 +-
 crates/optimism/node/src/node.rs              |  10 +-
 crates/optimism/node/src/txpool.rs            |   4 +-
 crates/optimism/node/tests/it/priority.rs     |  10 +-
 crates/optimism/rpc/src/eth/mod.rs            |   6 +-
 crates/optimism/rpc/src/eth/pending_block.rs  |   2 +-
 crates/primitives/src/block.rs                |   5 +
 crates/primitives/src/lib.rs                  |   4 +-
 crates/prune/prune/src/builder.rs             |  12 +-
 crates/prune/prune/src/segments/set.rs        |   6 +-
 .../src/segments/user/transaction_lookup.rs   |   4 +-
 crates/rpc/rpc-builder/Cargo.toml             |   1 +
 crates/rpc/rpc-builder/src/eth.rs             |   7 +-
 crates/rpc/rpc-builder/src/lib.rs             |  18 +-
 crates/rpc/rpc-engine-api/src/engine_api.rs   |  14 +-
 crates/rpc/rpc-eth-api/src/helpers/block.rs   |  31 ++-
 crates/rpc/rpc-eth-api/src/helpers/call.rs    |   8 +-
 crates/rpc/rpc-eth-api/src/helpers/fee.rs     |   5 +-
 .../rpc-eth-api/src/helpers/pending_block.rs  |  10 +-
 crates/rpc/rpc-eth-api/src/helpers/trace.rs   |   5 +-
 .../rpc-eth-api/src/helpers/transaction.rs    |  10 +-
 crates/rpc/rpc-eth-types/Cargo.toml           |   2 +-
 crates/rpc/rpc-eth-types/src/cache/mod.rs     |  21 +-
 crates/rpc/rpc-eth-types/src/logs_utils.rs    |   3 +-
 crates/rpc/rpc-eth-types/src/pending_block.rs |  16 +-
 crates/rpc/rpc/src/debug.rs                   |   2 +-
 crates/rpc/rpc/src/eth/core.rs                |   2 +-
 .../rpc/rpc/src/eth/helpers/pending_block.rs  |   2 +-
 crates/rpc/rpc/src/eth/helpers/trace.rs       |   3 +-
 crates/rpc/rpc/src/trace.rs                   |   4 +-
 crates/stages/stages/src/stages/execution.rs  |  16 +-
 .../src/providers/blockchain_provider.rs      |  41 ++--
 .../provider/src/providers/consistent.rs      |  41 ++--
 .../provider/src/providers/database/mod.rs    |  34 ++--
 .../src/providers/database/provider.rs        |  56 ++---
 crates/storage/provider/src/providers/mod.rs  |  40 ++--
 .../src/providers/static_file/manager.rs      |  36 ++--
 .../storage/provider/src/test_utils/mock.rs   |   2 +
 .../storage/provider/src/test_utils/noop.rs   |   8 +-
 crates/storage/provider/src/traits/full.rs    |   6 +-
 crates/storage/storage-api/src/block.rs       | 192 ++++++++++++++++--
 crates/storage/storage-api/src/chain.rs       |   1 +
 .../custom-payload-builder/src/generator.rs   |   6 +-
 examples/custom-payload-builder/src/main.rs   |   9 +-
 examples/db-access/src/main.rs                |   5 +-
 examples/rpc-db/src/myrpc_ext.rs              |   2 +-
 64 files changed, 649 insertions(+), 258 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9641d8e26ae2..dd476dec6071 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7095,6 +7095,7 @@ dependencies = [
  "alloy-eips",
  "alloy-network",
  "alloy-primitives",
+ "alloy-rlp",
  "alloy-rpc-types-engine",
  "alloy-rpc-types-eth",
  "alloy-signer",
diff --git a/crates/consensus/beacon/src/engine/mod.rs b/crates/consensus/beacon/src/engine/mod.rs
index 3d0f65423e46..13195a5885de 100644
--- a/crates/consensus/beacon/src/engine/mod.rs
+++ b/crates/consensus/beacon/src/engine/mod.rs
@@ -1,4 +1,4 @@
-use alloy_consensus::Header;
+use alloy_consensus::{BlockHeader, Header};
 use alloy_eips::{merge::EPOCH_SLOTS, BlockNumHash};
 use alloy_primitives::{BlockNumber, B256};
 use alloy_rpc_types_engine::{
@@ -21,7 +21,7 @@ use reth_network_p2p::{
     sync::{NetworkSyncUpdater, SyncState},
     EthBlockClient,
 };
-use reth_node_types::NodeTypesWithEngine;
+use reth_node_types::{Block, BlockTy, NodeTypesWithEngine};
 use reth_payload_builder::PayloadBuilderHandle;
 use reth_payload_builder_primitives::PayloadBuilder;
 use reth_payload_primitives::{PayloadAttributes, PayloadBuilderAttributes};
@@ -228,7 +228,7 @@ impl<N, BT, Client> BeaconConsensusEngine<N, BT, Client>
 where
     N: EngineNodeTypes,
     BT: BlockchainTreeEngine
-        + BlockReader
+        + BlockReader<Block = BlockTy<N>>
         + BlockIdReader
         + CanonChainTracker
         + StageCheckpointReader
@@ -946,7 +946,7 @@ where
                 .blockchain
                 .find_block_by_hash(safe_block_hash, BlockSource::Any)?
                 .ok_or(ProviderError::UnknownBlockHash(safe_block_hash))?;
-            self.blockchain.set_safe(SealedHeader::new(safe.header, safe_block_hash));
+            self.blockchain.set_safe(SealedHeader::new(safe.split().0, safe_block_hash));
         }
         Ok(())
     }
@@ -966,9 +966,9 @@ where
                 .blockchain
                 .find_block_by_hash(finalized_block_hash, BlockSource::Any)?
                 .ok_or(ProviderError::UnknownBlockHash(finalized_block_hash))?;
-            self.blockchain.finalize_block(finalized.number)?;
+            self.blockchain.finalize_block(finalized.header().number())?;
             self.blockchain
-                .set_finalized(SealedHeader::new(finalized.header, finalized_block_hash));
+                .set_finalized(SealedHeader::new(finalized.split().0, finalized_block_hash));
         }
         Ok(())
     }
@@ -1798,7 +1798,7 @@ where
     N: EngineNodeTypes,
     Client: EthBlockClient + 'static,
     BT: BlockchainTreeEngine
-        + BlockReader
+        + BlockReader<Block = BlockTy<N>>
         + BlockIdReader
         + CanonChainTracker
         + StageCheckpointReader
diff --git a/crates/e2e-test-utils/Cargo.toml b/crates/e2e-test-utils/Cargo.toml
index 9c40e2ba99d2..4619c357335a 100644
--- a/crates/e2e-test-utils/Cargo.toml
+++ b/crates/e2e-test-utils/Cargo.toml
@@ -35,6 +35,7 @@ url.workspace = true
 # ethereum
 alloy-primitives.workspace = true
 alloy-eips.workspace = true
+alloy-rlp.workspace = true
 op-alloy-rpc-types-engine.workspace = true
 
 futures-util.workspace = true
diff --git a/crates/e2e-test-utils/src/node.rs b/crates/e2e-test-utils/src/node.rs
index 09c54a867ce4..cbe69558e655 100644
--- a/crates/e2e-test-utils/src/node.rs
+++ b/crates/e2e-test-utils/src/node.rs
@@ -1,5 +1,6 @@
 use std::{marker::PhantomData, pin::Pin};
 
+use alloy_consensus::{BlockHeader, Sealable};
 use alloy_primitives::{BlockHash, BlockNumber, Bytes, B256};
 use alloy_rpc_types_eth::BlockNumberOrTag;
 use eyre::Ok;
@@ -15,6 +16,7 @@ use reth::{
     },
 };
 use reth_chainspec::EthereumHardforks;
+use reth_node_api::{Block, FullBlock, NodePrimitives};
 use reth_node_builder::{rpc::RethRpcAddOns, NodeTypes, NodeTypesWithEngine};
 use reth_stages_types::StageId;
 use tokio_stream::StreamExt;
@@ -51,7 +53,11 @@ impl<Node, Engine, AddOns> NodeTestContext<Node, AddOns>
 where
     Engine: EngineTypes,
     Node: FullNodeComponents,
-    Node::Types: NodeTypesWithEngine<ChainSpec: EthereumHardforks, Engine = Engine>,
+    Node::Types: NodeTypesWithEngine<
+        ChainSpec: EthereumHardforks,
+        Engine = Engine,
+        Primitives: NodePrimitives<Block: FullBlock>,
+    >,
     Node::Network: PeersHandleProvider,
     AddOns: RethRpcAddOns<Node>,
 {
@@ -178,7 +184,7 @@ where
 
             if check {
                 if let Some(latest_block) = self.inner.provider.block_by_number(number)? {
-                    assert_eq!(latest_block.hash_slow(), expected_block_hash);
+                    assert_eq!(latest_block.header().hash_slow(), expected_block_hash);
                     break
                 }
                 assert!(
@@ -225,10 +231,10 @@ where
             if let Some(latest_block) =
                 self.inner.provider.block_by_number_or_tag(BlockNumberOrTag::Latest)?
             {
-                if latest_block.number == block_number {
+                if latest_block.header().number() == block_number {
                     // make sure the block hash we submitted via FCU engine api is the new latest
                     // block using an RPC call
-                    assert_eq!(latest_block.hash_slow(), block_hash);
+                    assert_eq!(latest_block.header().hash_slow(), block_hash);
                     break
                 }
             }
diff --git a/crates/e2e-test-utils/src/rpc.rs b/crates/e2e-test-utils/src/rpc.rs
index 7b7dabdf2404..a57861d2b14a 100644
--- a/crates/e2e-test-utils/src/rpc.rs
+++ b/crates/e2e-test-utils/src/rpc.rs
@@ -1,6 +1,7 @@
 use alloy_consensus::TxEnvelope;
 use alloy_network::eip2718::Decodable2718;
 use alloy_primitives::{Bytes, B256};
+use alloy_rlp::Encodable;
 use reth::{
     builder::{rpc::RpcRegistry, FullNodeComponents},
     rpc::api::{
@@ -12,6 +13,7 @@ use reth::{
     },
 };
 use reth_chainspec::EthereumHardforks;
+use reth_node_api::NodePrimitives;
 use reth_node_builder::NodeTypes;
 
 #[allow(missing_debug_implementations)]
@@ -21,7 +23,12 @@ pub struct RpcTestContext<Node: FullNodeComponents, EthApi: EthApiTypes> {
 
 impl<Node, EthApi> RpcTestContext<Node, EthApi>
 where
-    Node: FullNodeComponents<Types: NodeTypes<ChainSpec: EthereumHardforks>>,
+    Node: FullNodeComponents<
+        Types: NodeTypes<
+            ChainSpec: EthereumHardforks,
+            Primitives: NodePrimitives<Block: Encodable>,
+        >,
+    >,
     EthApi: EthApiSpec + EthTransactions + TraceExt,
 {
     /// Injects a raw transaction into the node tx pool via RPC server
diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs
index 66eff882c92b..f36ab3ea853c 100644
--- a/crates/engine/tree/src/tree/mod.rs
+++ b/crates/engine/tree/src/tree/mod.rs
@@ -4,7 +4,7 @@ use crate::{
     engine::{DownloadRequest, EngineApiEvent, FromEngine},
     persistence::PersistenceHandle,
 };
-use alloy_consensus::Header;
+use alloy_consensus::{BlockHeader, Header};
 use alloy_eips::BlockNumHash;
 use alloy_primitives::{
     map::{HashMap, HashSet},
@@ -536,7 +536,12 @@ impl<P: Debug, E: Debug, T: EngineTypes + Debug, Spec: Debug> std::fmt::Debug
 
 impl<P, E, T, Spec> EngineApiTreeHandler<P, E, T, Spec>
 where
-    P: DatabaseProviderFactory + BlockReader + StateProviderFactory + StateReader + Clone + 'static,
+    P: DatabaseProviderFactory
+        + BlockReader<Block = reth_primitives::Block>
+        + StateProviderFactory
+        + StateReader
+        + Clone
+        + 'static,
     <P as DatabaseProviderFactory>::Provider: BlockReader,
     E: BlockExecutorProvider,
     T: EngineTypes,
@@ -1539,8 +1544,8 @@ where
             .ok_or_else(|| ProviderError::HeaderNotFound(hash.into()))?;
         let execution_output = self
             .provider
-            .get_state(block.number)?
-            .ok_or_else(|| ProviderError::StateForNumberNotFound(block.number))?;
+            .get_state(block.number())?
+            .ok_or_else(|| ProviderError::StateForNumberNotFound(block.number()))?;
         let hashed_state = execution_output.hash_state_slow();
 
         Ok(Some(ExecutedBlock {
diff --git a/crates/engine/util/src/reorg.rs b/crates/engine/util/src/reorg.rs
index 1e2451f24c3c..46a5e08a7386 100644
--- a/crates/engine/util/src/reorg.rs
+++ b/crates/engine/util/src/reorg.rs
@@ -109,7 +109,7 @@ impl<S, Engine, Provider, Evm, Spec> Stream for EngineReorg<S, Engine, Provider,
 where
     S: Stream<Item = BeaconEngineMessage<Engine>>,
     Engine: EngineTypes,
-    Provider: BlockReader + StateProviderFactory,
+    Provider: BlockReader<Block = reth_primitives::Block> + StateProviderFactory,
     Evm: ConfigureEvm<Header = Header>,
     Spec: EthereumHardforks,
 {
@@ -256,7 +256,7 @@ fn create_reorg_head<Provider, Evm, Spec>(
     next_sidecar: ExecutionPayloadSidecar,
 ) -> RethResult<(ExecutionPayload, ExecutionPayloadSidecar)>
 where
-    Provider: BlockReader + StateProviderFactory,
+    Provider: BlockReader<Block = reth_primitives::Block> + StateProviderFactory,
     Evm: ConfigureEvm<Header = Header>,
     Spec: EthereumHardforks,
 {
diff --git a/crates/ethereum/node/src/node.rs b/crates/ethereum/node/src/node.rs
index a2ae2374b966..c4e1de2760f1 100644
--- a/crates/ethereum/node/src/node.rs
+++ b/crates/ethereum/node/src/node.rs
@@ -53,7 +53,7 @@ impl EthereumNode {
         EthereumConsensusBuilder,
     >
     where
-        Node: FullNodeTypes<Types: NodeTypes<ChainSpec = ChainSpec>>,
+        Node: FullNodeTypes<Types: NodeTypes<ChainSpec = ChainSpec, Primitives = EthPrimitives>>,
         <Node::Types as NodeTypesWithEngine>::Engine: PayloadTypes<
             BuiltPayload = EthBuiltPayload,
             PayloadAttributes = EthPayloadAttributes,
@@ -304,7 +304,7 @@ pub struct EthereumNetworkBuilder {
 
 impl<Node, Pool> NetworkBuilder<Node, Pool> for EthereumNetworkBuilder
 where
-    Node: FullNodeTypes<Types: NodeTypes<ChainSpec = ChainSpec>>,
+    Node: FullNodeTypes<Types: NodeTypes<ChainSpec = ChainSpec, Primitives = EthPrimitives>>,
     Pool: TransactionPool + Unpin + 'static,
 {
     async fn build_network(
diff --git a/crates/exex/exex/Cargo.toml b/crates/exex/exex/Cargo.toml
index 3cbeb115b066..b70fb921599e 100644
--- a/crates/exex/exex/Cargo.toml
+++ b/crates/exex/exex/Cargo.toml
@@ -35,6 +35,7 @@ reth-tasks.workspace = true
 reth-tracing.workspace = true
 
 # alloy
+alloy-consensus.workspace = true
 alloy-primitives.workspace = true
 alloy-eips.workspace = true
 
diff --git a/crates/exex/exex/src/backfill/job.rs b/crates/exex/exex/src/backfill/job.rs
index 08d91e39197e..7e670620472c 100644
--- a/crates/exex/exex/src/backfill/job.rs
+++ b/crates/exex/exex/src/backfill/job.rs
@@ -4,12 +4,14 @@ use std::{
     time::{Duration, Instant},
 };
 
+use alloy_consensus::BlockHeader;
 use alloy_primitives::BlockNumber;
 use reth_evm::execute::{
     BatchExecutor, BlockExecutionError, BlockExecutionOutput, BlockExecutorProvider, Executor,
 };
-use reth_primitives::{Block, BlockExt, BlockWithSenders, Receipt};
-use reth_primitives_traits::format_gas_throughput;
+use reth_node_api::{Block as _, BlockBody as _};
+use reth_primitives::{BlockExt, BlockWithSenders, Receipt};
+use reth_primitives_traits::{format_gas_throughput, SignedTransaction};
 use reth_provider::{
     BlockReader, Chain, HeaderProvider, ProviderError, StateProviderFactory, TransactionVariant,
 };
@@ -37,7 +39,9 @@ pub struct BackfillJob<E, P> {
 impl<E, P> Iterator for BackfillJob<E, P>
 where
     E: BlockExecutorProvider,
-    P: HeaderProvider + BlockReader + StateProviderFactory,
+    P: HeaderProvider
+        + BlockReader<Transaction: SignedTransaction, Block = reth_primitives::Block>
+        + StateProviderFactory,
 {
     type Item = BackfillJobResult<Chain>;
 
@@ -53,7 +57,9 @@ where
 impl<E, P> BackfillJob<E, P>
 where
     E: BlockExecutorProvider,
-    P: BlockReader + HeaderProvider + StateProviderFactory,
+    P: BlockReader<Transaction: SignedTransaction, Block = reth_primitives::Block>
+        + HeaderProvider
+        + StateProviderFactory,
 {
     /// Converts the backfill job into a single block backfill job.
     pub fn into_single_blocks(self) -> SingleBlockBackfillJob<E, P> {
@@ -100,10 +106,10 @@ where
 
             fetch_block_duration += fetch_block_start.elapsed();
 
-            cumulative_gas += block.gas_used;
+            cumulative_gas += block.gas_used();
 
             // Configure the executor to use the current state.
-            trace!(target: "exex::backfill", number = block_number, txs = block.body.transactions.len(), "Executing block");
+            trace!(target: "exex::backfill", number = block_number, txs = block.body.transactions().len(), "Executing block");
 
             // Execute the block
             let execute_start = Instant::now();
@@ -111,8 +117,7 @@ where
             // Unseal the block for execution
             let (block, senders) = block.into_components();
             let (unsealed_header, hash) = block.header.split();
-            let block =
-                Block { header: unsealed_header, body: block.body }.with_senders_unchecked(senders);
+            let block = P::Block::new(unsealed_header, block.body).with_senders_unchecked(senders);
 
             executor.execute_and_verify_one((&block, td).into())?;
             execution_duration += execute_start.elapsed();
@@ -134,7 +139,7 @@ where
             }
         }
 
-        let last_block_number = blocks.last().expect("blocks should not be empty").number;
+        let last_block_number = blocks.last().expect("blocks should not be empty").number();
         debug!(
             target: "exex::backfill",
             range = ?*self.range.start()..=last_block_number,
@@ -165,7 +170,7 @@ pub struct SingleBlockBackfillJob<E, P> {
 impl<E, P> Iterator for SingleBlockBackfillJob<E, P>
 where
     E: BlockExecutorProvider,
-    P: HeaderProvider + BlockReader + StateProviderFactory,
+    P: HeaderProvider + BlockReader<Block = reth_primitives::Block> + StateProviderFactory,
 {
     type Item = BackfillJobResult<(BlockWithSenders, BlockExecutionOutput<Receipt>)>;
 
@@ -177,7 +182,7 @@ where
 impl<E, P> SingleBlockBackfillJob<E, P>
 where
     E: BlockExecutorProvider,
-    P: HeaderProvider + BlockReader + StateProviderFactory,
+    P: HeaderProvider + BlockReader<Block = reth_primitives::Block> + StateProviderFactory,
 {
     /// Converts the single block backfill job into a stream.
     pub fn into_stream(
@@ -189,7 +194,7 @@ where
     pub(crate) fn execute_block(
         &self,
         block_number: u64,
-    ) -> BackfillJobResult<(BlockWithSenders, BlockExecutionOutput<Receipt>)> {
+    ) -> BackfillJobResult<(BlockWithSenders<P::Block>, BlockExecutionOutput<Receipt>)> {
         let td = self
             .provider
             .header_td_by_number(block_number)?
@@ -206,7 +211,7 @@ where
             self.provider.history_by_block_number(block_number.saturating_sub(1))?,
         ));
 
-        trace!(target: "exex::backfill", number = block_number, txs = block_with_senders.block.body.transactions.len(), "Executing block");
+        trace!(target: "exex::backfill", number = block_number, txs = block_with_senders.block.body().transactions().len(), "Executing block");
 
         let block_execution_output = executor.execute((&block_with_senders, td).into())?;
 
diff --git a/crates/exex/exex/src/backfill/stream.rs b/crates/exex/exex/src/backfill/stream.rs
index c55b8651daf1..46177ceda122 100644
--- a/crates/exex/exex/src/backfill/stream.rs
+++ b/crates/exex/exex/src/backfill/stream.rs
@@ -103,7 +103,13 @@ where
 impl<E, P> Stream for StreamBackfillJob<E, P, SingleBlockStreamItem>
 where
     E: BlockExecutorProvider + Clone + Send + 'static,
-    P: HeaderProvider + BlockReader + StateProviderFactory + Clone + Send + Unpin + 'static,
+    P: HeaderProvider
+        + BlockReader<Block = reth_primitives::Block>
+        + StateProviderFactory
+        + Clone
+        + Send
+        + Unpin
+        + 'static,
 {
     type Item = BackfillJobResult<SingleBlockStreamItem>;
 
@@ -136,7 +142,13 @@ where
 impl<E, P> Stream for StreamBackfillJob<E, P, BatchBlockStreamItem>
 where
     E: BlockExecutorProvider + Clone + Send + 'static,
-    P: HeaderProvider + BlockReader + StateProviderFactory + Clone + Send + Unpin + 'static,
+    P: HeaderProvider
+        + BlockReader<Block = reth_primitives::Block>
+        + StateProviderFactory
+        + Clone
+        + Send
+        + Unpin
+        + 'static,
 {
     type Item = BackfillJobResult<BatchBlockStreamItem>;
 
diff --git a/crates/exex/exex/src/context.rs b/crates/exex/exex/src/context.rs
index 4e0d9f5956c7..3d303c9bbac0 100644
--- a/crates/exex/exex/src/context.rs
+++ b/crates/exex/exex/src/context.rs
@@ -3,6 +3,7 @@ use reth_exex_types::ExExHead;
 use reth_node_api::{FullNodeComponents, NodeTypes};
 use reth_node_core::node_config::NodeConfig;
 use reth_primitives::Head;
+use reth_provider::BlockReader;
 use reth_tasks::TaskExecutor;
 use std::fmt::Debug;
 use tokio::sync::mpsc::UnboundedSender;
@@ -56,7 +57,7 @@ where
 impl<Node> ExExContext<Node>
 where
     Node: FullNodeComponents,
-    Node::Provider: Debug,
+    Node::Provider: Debug + BlockReader<Block = reth_primitives::Block>,
     Node::Executor: Debug,
 {
     /// Returns dynamic version of the context
@@ -106,13 +107,19 @@ where
 
     /// Sets notifications stream to [`crate::ExExNotificationsWithoutHead`], a stream of
     /// notifications without a head.
-    pub fn set_notifications_without_head(&mut self) {
+    pub fn set_notifications_without_head(&mut self)
+    where
+        Node::Provider: BlockReader<Block = reth_primitives::Block>,
+    {
         self.notifications.set_without_head();
     }
 
     /// Sets notifications stream to [`crate::ExExNotificationsWithHead`], a stream of notifications
     /// with the provided head.
-    pub fn set_notifications_with_head(&mut self, head: ExExHead) {
+    pub fn set_notifications_with_head(&mut self, head: ExExHead)
+    where
+        Node::Provider: BlockReader<Block = reth_primitives::Block>,
+    {
         self.notifications.set_with_head(head);
     }
 }
@@ -121,6 +128,7 @@ where
 mod tests {
     use reth_exex_types::ExExHead;
     use reth_node_api::FullNodeComponents;
+    use reth_provider::BlockReader;
 
     use crate::ExExContext;
 
@@ -132,7 +140,10 @@ mod tests {
             ctx: ExExContext<Node>,
         }
 
-        impl<Node: FullNodeComponents> ExEx<Node> {
+        impl<Node: FullNodeComponents> ExEx<Node>
+        where
+            Node::Provider: BlockReader<Block = reth_primitives::Block>,
+        {
             async fn _test_bounds(mut self) -> eyre::Result<()> {
                 self.ctx.pool();
                 self.ctx.block_executor();
diff --git a/crates/exex/exex/src/dyn_context.rs b/crates/exex/exex/src/dyn_context.rs
index b48a6ebc951f..3ce0f488f40c 100644
--- a/crates/exex/exex/src/dyn_context.rs
+++ b/crates/exex/exex/src/dyn_context.rs
@@ -6,6 +6,7 @@ use std::fmt::Debug;
 use reth_chainspec::{EthChainSpec, Head};
 use reth_node_api::FullNodeComponents;
 use reth_node_core::node_config::NodeConfig;
+use reth_provider::BlockReader;
 use tokio::sync::mpsc;
 
 use crate::{ExExContext, ExExEvent, ExExNotificationsStream};
@@ -51,7 +52,7 @@ impl Debug for ExExContextDyn {
 impl<Node> From<ExExContext<Node>> for ExExContextDyn
 where
     Node: FullNodeComponents,
-    Node::Provider: Debug,
+    Node::Provider: Debug + BlockReader<Block = reth_primitives::Block>,
     Node::Executor: Debug,
 {
     fn from(ctx: ExExContext<Node>) -> Self {
diff --git a/crates/exex/exex/src/notifications.rs b/crates/exex/exex/src/notifications.rs
index 6c1e12d8d766..954a057fc09c 100644
--- a/crates/exex/exex/src/notifications.rs
+++ b/crates/exex/exex/src/notifications.rs
@@ -90,7 +90,12 @@ impl<P, E> ExExNotifications<P, E> {
 
 impl<P, E> ExExNotificationsStream for ExExNotifications<P, E>
 where
-    P: BlockReader + HeaderProvider + StateProviderFactory + Clone + Unpin + 'static,
+    P: BlockReader<Block = reth_primitives::Block>
+        + HeaderProvider
+        + StateProviderFactory
+        + Clone
+        + Unpin
+        + 'static,
     E: BlockExecutorProvider + Clone + Unpin + 'static,
 {
     fn set_without_head(&mut self) {
@@ -139,7 +144,12 @@ where
 
 impl<P, E> Stream for ExExNotifications<P, E>
 where
-    P: BlockReader + HeaderProvider + StateProviderFactory + Clone + Unpin + 'static,
+    P: BlockReader<Block = reth_primitives::Block>
+        + HeaderProvider
+        + StateProviderFactory
+        + Clone
+        + Unpin
+        + 'static,
     E: BlockExecutorProvider + Clone + Unpin + 'static,
 {
     type Item = eyre::Result<ExExNotification>;
@@ -262,7 +272,12 @@ impl<P, E> ExExNotificationsWithHead<P, E> {
 
 impl<P, E> ExExNotificationsWithHead<P, E>
 where
-    P: BlockReader + HeaderProvider + StateProviderFactory + Clone + Unpin + 'static,
+    P: BlockReader<Block = reth_primitives::Block>
+        + HeaderProvider
+        + StateProviderFactory
+        + Clone
+        + Unpin
+        + 'static,
     E: BlockExecutorProvider + Clone + Unpin + 'static,
 {
     /// Checks if the ExEx head is on the canonical chain.
@@ -339,7 +354,12 @@ where
 
 impl<P, E> Stream for ExExNotificationsWithHead<P, E>
 where
-    P: BlockReader + HeaderProvider + StateProviderFactory + Clone + Unpin + 'static,
+    P: BlockReader<Block = reth_primitives::Block>
+        + HeaderProvider
+        + StateProviderFactory
+        + Clone
+        + Unpin
+        + 'static,
     E: BlockExecutorProvider + Clone + Unpin + 'static,
 {
     type Item = eyre::Result<ExExNotification>;
diff --git a/crates/exex/test-utils/src/lib.rs b/crates/exex/test-utils/src/lib.rs
index 15c770c5e9ea..ca0ea46551c5 100644
--- a/crates/exex/test-utils/src/lib.rs
+++ b/crates/exex/test-utils/src/lib.rs
@@ -265,7 +265,7 @@ pub async fn test_exex_context_with_chain_spec(
 
     let (static_dir, _) = create_test_static_files_dir();
     let db = create_test_rw_db();
-    let provider_factory = ProviderFactory::new(
+    let provider_factory = ProviderFactory::<NodeTypesWithDBAdapter<TestNode, _>>::new(
         db,
         chain_spec.clone(),
         StaticFileProvider::read_write(static_dir.into_path()).expect("static file provider"),
@@ -289,7 +289,7 @@ pub async fn test_exex_context_with_chain_spec(
 
     let (_, payload_builder) = NoopPayloadBuilderService::<EthEngineTypes>::new();
 
-    let components = NodeAdapter::<FullNodeTypesAdapter<NodeTypesWithDBAdapter<TestNode, _>, _>, _> {
+    let components = NodeAdapter::<FullNodeTypesAdapter<_, _>, _> {
         components: Components {
             transaction_pool,
             evm_config,
diff --git a/crates/net/network/src/config.rs b/crates/net/network/src/config.rs
index e54000895a79..2e8f9f4cc7ad 100644
--- a/crates/net/network/src/config.rs
+++ b/crates/net/network/src/config.rs
@@ -147,7 +147,7 @@ where
 
 impl<C> NetworkConfig<C>
 where
-    C: BlockReader + HeaderProvider + Clone + Unpin + 'static,
+    C: BlockReader<Block = reth_primitives::Block> + HeaderProvider + Clone + Unpin + 'static,
 {
     /// Starts the networking stack given a [`NetworkConfig`] and returns a handle to the network.
     pub async fn start_network(self) -> Result<NetworkHandle, NetworkError> {
diff --git a/crates/net/network/src/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index 0f9348a42ce4..c0d22f97da8d 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -15,7 +15,7 @@ use reth_eth_wire::{
 use reth_network_api::test_utils::PeersHandle;
 use reth_network_p2p::error::RequestResult;
 use reth_network_peers::PeerId;
-use reth_primitives::BlockBody;
+use reth_primitives_traits::Block;
 use reth_storage_api::{BlockReader, HeaderProvider, ReceiptProvider};
 use std::{
     future::Future,
@@ -157,7 +157,9 @@ where
         &self,
         _peer_id: PeerId,
         request: GetBlockBodies,
-        response: oneshot::Sender<RequestResult<BlockBodies<BlockBody>>>,
+        response: oneshot::Sender<
+            RequestResult<BlockBodies<<C::Block as reth_primitives_traits::Block>::Body>>,
+        >,
     ) {
         self.metrics.eth_bodies_requests_received_total.increment(1);
         let mut bodies = Vec::new();
@@ -166,8 +168,7 @@ where
 
         for hash in request.0 {
             if let Some(block) = self.client.block_by_hash(hash).unwrap_or_default() {
-                let body: BlockBody = block.into();
-
+                let (_, body) = block.split();
                 total_bytes += body.length();
                 bodies.push(body);
 
@@ -223,7 +224,7 @@ where
 /// This should be spawned or used as part of `tokio::select!`.
 impl<C> Future for EthRequestHandler<C>
 where
-    C: BlockReader + HeaderProvider + Unpin,
+    C: BlockReader<Block = reth_primitives::Block> + HeaderProvider + Unpin,
 {
     type Output = ();
 
diff --git a/crates/net/network/src/test_utils/testnet.rs b/crates/net/network/src/test_utils/testnet.rs
index a64084f2cf9b..34c08f637bad 100644
--- a/crates/net/network/src/test_utils/testnet.rs
+++ b/crates/net/network/src/test_utils/testnet.rs
@@ -194,7 +194,7 @@ where
 
 impl<C, Pool> Testnet<C, Pool>
 where
-    C: BlockReader + HeaderProvider + Clone + Unpin + 'static,
+    C: BlockReader<Block = reth_primitives::Block> + HeaderProvider + Clone + Unpin + 'static,
     Pool: TransactionPool + Unpin + 'static,
 {
     /// Spawns the testnet to a separate task
@@ -253,7 +253,7 @@ impl<C, Pool> fmt::Debug for Testnet<C, Pool> {
 
 impl<C, Pool> Future for Testnet<C, Pool>
 where
-    C: BlockReader + HeaderProvider + Unpin + 'static,
+    C: BlockReader<Block = reth_primitives::Block> + HeaderProvider + Unpin + 'static,
     Pool: TransactionPool + Unpin + 'static,
 {
     type Output = ();
@@ -448,7 +448,7 @@ where
 
 impl<C, Pool> Future for Peer<C, Pool>
 where
-    C: BlockReader + HeaderProvider + Unpin + 'static,
+    C: BlockReader<Block = reth_primitives::Block> + HeaderProvider + Unpin + 'static,
     Pool: TransactionPool + Unpin + 'static,
 {
     type Output = ();
diff --git a/crates/node/builder/src/builder/mod.rs b/crates/node/builder/src/builder/mod.rs
index 7cbad445da1e..56ee7d9d640d 100644
--- a/crates/node/builder/src/builder/mod.rs
+++ b/crates/node/builder/src/builder/mod.rs
@@ -34,7 +34,7 @@ use reth_node_core::{
 };
 use reth_provider::{
     providers::{BlockchainProvider, NodeTypesForProvider},
-    ChainSpecProvider, FullProvider,
+    BlockReader, ChainSpecProvider, FullProvider,
 };
 use reth_tasks::TaskExecutor;
 use reth_transaction_pool::{PoolConfig, TransactionPool};
@@ -651,6 +651,7 @@ impl<Node: FullNodeTypes> BuilderContext<Node> {
     pub fn start_network<Pool>(&self, builder: NetworkBuilder<(), ()>, pool: Pool) -> NetworkHandle
     where
         Pool: TransactionPool + Unpin + 'static,
+        Node::Provider: BlockReader<Block = reth_primitives::Block>,
     {
         self.start_network_with(builder, pool, Default::default())
     }
@@ -669,6 +670,7 @@ impl<Node: FullNodeTypes> BuilderContext<Node> {
     ) -> NetworkHandle
     where
         Pool: TransactionPool + Unpin + 'static,
+        Node::Provider: BlockReader<Block = reth_primitives::Block>,
     {
         let (handle, network, txpool, eth) = builder
             .transactions(pool, tx_config)
diff --git a/crates/optimism/node/src/node.rs b/crates/optimism/node/src/node.rs
index cc0a61833e41..2150b6bafd46 100644
--- a/crates/optimism/node/src/node.rs
+++ b/crates/optimism/node/src/node.rs
@@ -135,7 +135,11 @@ impl OpNode {
     >
     where
         Node: FullNodeTypes<
-            Types: NodeTypesWithEngine<Engine = OpEngineTypes, ChainSpec = OpChainSpec>,
+            Types: NodeTypesWithEngine<
+                Engine = OpEngineTypes,
+                ChainSpec = OpChainSpec,
+                Primitives = OpPrimitives,
+            >,
         >,
     {
         let RollupArgs { disable_txpool_gossip, compute_pending_block, discovery_v4, .. } = args;
@@ -293,7 +297,7 @@ pub struct OpPoolBuilder {
 
 impl<Node> PoolBuilder<Node> for OpPoolBuilder
 where
-    Node: FullNodeTypes<Types: NodeTypes<ChainSpec = OpChainSpec>>,
+    Node: FullNodeTypes<Types: NodeTypes<ChainSpec = OpChainSpec, Primitives = OpPrimitives>>,
 {
     type Pool = OpTransactionPool<Node::Provider, DiskFileBlobStore>;
 
@@ -522,7 +526,7 @@ impl OpNetworkBuilder {
 
 impl<Node, Pool> NetworkBuilder<Node, Pool> for OpNetworkBuilder
 where
-    Node: FullNodeTypes<Types: NodeTypes<ChainSpec = OpChainSpec>>,
+    Node: FullNodeTypes<Types: NodeTypes<ChainSpec = OpChainSpec, Primitives = OpPrimitives>>,
     Pool: TransactionPool + Unpin + 'static,
 {
     async fn build_network(
diff --git a/crates/optimism/node/src/txpool.rs b/crates/optimism/node/src/txpool.rs
index a5616569c86f..6db5d69568b6 100644
--- a/crates/optimism/node/src/txpool.rs
+++ b/crates/optimism/node/src/txpool.rs
@@ -69,7 +69,7 @@ impl<Client, Tx> OpTransactionValidator<Client, Tx> {
 
 impl<Client, Tx> OpTransactionValidator<Client, Tx>
 where
-    Client: StateProviderFactory + BlockReaderIdExt,
+    Client: StateProviderFactory + BlockReaderIdExt<Block = reth_primitives::Block>,
     Tx: EthPoolTransaction,
 {
     /// Create a new [`OpTransactionValidator`].
@@ -195,7 +195,7 @@ where
 
 impl<Client, Tx> TransactionValidator for OpTransactionValidator<Client, Tx>
 where
-    Client: StateProviderFactory + BlockReaderIdExt,
+    Client: StateProviderFactory + BlockReaderIdExt<Block = reth_primitives::Block>,
     Tx: EthPoolTransaction,
 {
     type Transaction = Tx;
diff --git a/crates/optimism/node/tests/it/priority.rs b/crates/optimism/node/tests/it/priority.rs
index c1df9180ce39..66aeaa295cb4 100644
--- a/crates/optimism/node/tests/it/priority.rs
+++ b/crates/optimism/node/tests/it/priority.rs
@@ -25,6 +25,7 @@ use reth_optimism_node::{
     OpEngineTypes, OpNode,
 };
 use reth_optimism_payload_builder::builder::OpPayloadTransactions;
+use reth_optimism_primitives::OpPrimitives;
 use reth_payload_util::{PayloadTransactions, PayloadTransactionsChain, PayloadTransactionsFixed};
 use reth_primitives::{SealedBlock, Transaction, TransactionSigned, TransactionSignedEcRecovered};
 use reth_provider::providers::BlockchainProvider2;
@@ -90,8 +91,13 @@ fn build_components<Node>(
     OpConsensusBuilder,
 >
 where
-    Node:
-        FullNodeTypes<Types: NodeTypesWithEngine<Engine = OpEngineTypes, ChainSpec = OpChainSpec>>,
+    Node: FullNodeTypes<
+        Types: NodeTypesWithEngine<
+            Engine = OpEngineTypes,
+            ChainSpec = OpChainSpec,
+            Primitives = OpPrimitives,
+        >,
+    >,
 {
     let RollupArgs { disable_txpool_gossip, compute_pending_block, discovery_v4, .. } =
         RollupArgs::default();
diff --git a/crates/optimism/rpc/src/eth/mod.rs b/crates/optimism/rpc/src/eth/mod.rs
index 60af6542e282..8690d1a262af 100644
--- a/crates/optimism/rpc/src/eth/mod.rs
+++ b/crates/optimism/rpc/src/eth/mod.rs
@@ -20,8 +20,8 @@ use reth_evm::ConfigureEvm;
 use reth_network_api::NetworkInfo;
 use reth_node_builder::EthApiBuilderCtx;
 use reth_provider::{
-    BlockNumReader, BlockReaderIdExt, CanonStateSubscriptions, ChainSpecProvider, EvmEnvProvider,
-    StageCheckpointReader, StateProviderFactory,
+    BlockNumReader, BlockReader, BlockReaderIdExt, CanonStateSubscriptions, ChainSpecProvider,
+    EvmEnvProvider, StageCheckpointReader, StateProviderFactory,
 };
 use reth_rpc::eth::{core::EthApiInner, DevSigner};
 use reth_rpc_eth_api::{
@@ -249,7 +249,7 @@ where
 
 impl<N> Trace for OpEthApi<N>
 where
-    Self: LoadState<Evm: ConfigureEvm<Header = Header>>,
+    Self: RpcNodeCore<Provider: BlockReader> + LoadState<Evm: ConfigureEvm<Header = Header>>,
     N: RpcNodeCore,
 {
 }
diff --git a/crates/optimism/rpc/src/eth/pending_block.rs b/crates/optimism/rpc/src/eth/pending_block.rs
index 782f78dd4aa9..0319e15c81ea 100644
--- a/crates/optimism/rpc/src/eth/pending_block.rs
+++ b/crates/optimism/rpc/src/eth/pending_block.rs
@@ -24,7 +24,7 @@ impl<N> LoadPendingBlock for OpEthApi<N>
 where
     Self: SpawnBlocking,
     N: RpcNodeCore<
-        Provider: BlockReaderIdExt
+        Provider: BlockReaderIdExt<Block = reth_primitives::Block>
                       + EvmEnvProvider
                       + ChainSpecProvider<ChainSpec: EthChainSpec + EthereumHardforks>
                       + StateProviderFactory,
diff --git a/crates/primitives/src/block.rs b/crates/primitives/src/block.rs
index d7babfc62894..ac71c791c334 100644
--- a/crates/primitives/src/block.rs
+++ b/crates/primitives/src/block.rs
@@ -489,6 +489,11 @@ where
     }
 }
 
+/// A helepr trait to construct [`SealedBlock`] from a [`reth_primitives_traits::Block`].
+pub type SealedBlockFor<B> = SealedBlock<
+    <B as reth_primitives_traits::Block>::Header,
+    <B as reth_primitives_traits::Block>::Body,
+>;
 /// Sealed block with senders recovered from transactions.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Deref, DerefMut)]
 pub struct SealedBlockWithSenders<B: reth_primitives_traits::Block = Block> {
diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs
index 049d4f202a6a..52d573f2b3b4 100644
--- a/crates/primitives/src/lib.rs
+++ b/crates/primitives/src/lib.rs
@@ -35,7 +35,9 @@ pub use reth_static_file_types as static_file;
 pub mod transaction;
 #[cfg(any(test, feature = "arbitrary"))]
 pub use block::{generate_valid_header, valid_header_strategy};
-pub use block::{Block, BlockBody, BlockWithSenders, SealedBlock, SealedBlockWithSenders};
+pub use block::{
+    Block, BlockBody, BlockWithSenders, SealedBlock, SealedBlockFor, SealedBlockWithSenders,
+};
 #[cfg(feature = "reth-codec")]
 pub use compression::*;
 pub use receipt::{
diff --git a/crates/prune/prune/src/builder.rs b/crates/prune/prune/src/builder.rs
index 85697160115b..d987ed1edb60 100644
--- a/crates/prune/prune/src/builder.rs
+++ b/crates/prune/prune/src/builder.rs
@@ -1,11 +1,12 @@
 use crate::{segments::SegmentSet, Pruner};
+use alloy_eips::eip2718::Encodable2718;
 use reth_chainspec::MAINNET;
 use reth_config::PruneConfig;
 use reth_db::transaction::DbTxMut;
 use reth_exex_types::FinishedExExHeight;
 use reth_provider::{
     providers::StaticFileProvider, BlockReader, DBProvider, DatabaseProviderFactory,
-    PruneCheckpointWriter, StaticFileProviderFactory, TransactionsProvider,
+    PruneCheckpointWriter, StaticFileProviderFactory,
 };
 use reth_prune_types::PruneModes;
 use std::time::Duration;
@@ -77,7 +78,9 @@ impl PrunerBuilder {
     pub fn build_with_provider_factory<PF>(self, provider_factory: PF) -> Pruner<PF::ProviderRW, PF>
     where
         PF: DatabaseProviderFactory<
-                ProviderRW: PruneCheckpointWriter + BlockReader + StaticFileProviderFactory,
+                ProviderRW: PruneCheckpointWriter
+                                + BlockReader<Transaction: Encodable2718>
+                                + StaticFileProviderFactory,
             > + StaticFileProviderFactory<
                 Primitives = <PF::ProviderRW as StaticFileProviderFactory>::Primitives,
             >,
@@ -103,9 +106,8 @@ impl PrunerBuilder {
     where
         Provider: StaticFileProviderFactory
             + DBProvider<Tx: DbTxMut>
-            + BlockReader
-            + PruneCheckpointWriter
-            + TransactionsProvider,
+            + BlockReader<Transaction: Encodable2718>
+            + PruneCheckpointWriter,
     {
         let segments = SegmentSet::<Provider>::from_components(static_file_provider, self.segments);
 
diff --git a/crates/prune/prune/src/segments/set.rs b/crates/prune/prune/src/segments/set.rs
index 62c252fc54b6..198d01ce44dc 100644
--- a/crates/prune/prune/src/segments/set.rs
+++ b/crates/prune/prune/src/segments/set.rs
@@ -2,10 +2,11 @@ use crate::segments::{
     AccountHistory, ReceiptsByLogs, Segment, SenderRecovery, StorageHistory, TransactionLookup,
     UserReceipts,
 };
+use alloy_eips::eip2718::Encodable2718;
 use reth_db::transaction::DbTxMut;
 use reth_provider::{
     providers::StaticFileProvider, BlockReader, DBProvider, PruneCheckpointWriter,
-    StaticFileProviderFactory, TransactionsProvider,
+    StaticFileProviderFactory,
 };
 use reth_prune_types::PruneModes;
 
@@ -47,9 +48,8 @@ impl<Provider> SegmentSet<Provider>
 where
     Provider: StaticFileProviderFactory
         + DBProvider<Tx: DbTxMut>
-        + TransactionsProvider
         + PruneCheckpointWriter
-        + BlockReader,
+        + BlockReader<Transaction: Encodable2718>,
 {
     /// Creates a [`SegmentSet`] from an existing components, such as [`StaticFileProvider`] and
     /// [`PruneModes`].
diff --git a/crates/prune/prune/src/segments/user/transaction_lookup.rs b/crates/prune/prune/src/segments/user/transaction_lookup.rs
index ce9d90c291b7..27f4f5085d2b 100644
--- a/crates/prune/prune/src/segments/user/transaction_lookup.rs
+++ b/crates/prune/prune/src/segments/user/transaction_lookup.rs
@@ -6,7 +6,7 @@ use crate::{
 use alloy_eips::eip2718::Encodable2718;
 use rayon::prelude::*;
 use reth_db::{tables, transaction::DbTxMut};
-use reth_provider::{BlockReader, DBProvider, TransactionsProvider};
+use reth_provider::{BlockReader, DBProvider};
 use reth_prune_types::{
     PruneMode, PruneProgress, PrunePurpose, PruneSegment, SegmentOutputCheckpoint,
 };
@@ -25,7 +25,7 @@ impl TransactionLookup {
 
 impl<Provider> Segment<Provider> for TransactionLookup
 where
-    Provider: DBProvider<Tx: DbTxMut> + TransactionsProvider + BlockReader,
+    Provider: DBProvider<Tx: DbTxMut> + BlockReader<Transaction: Encodable2718>,
 {
     fn segment(&self) -> PruneSegment {
         PruneSegment::TransactionLookup
diff --git a/crates/rpc/rpc-builder/Cargo.toml b/crates/rpc/rpc-builder/Cargo.toml
index 04e97f99e34d..a0712d617b66 100644
--- a/crates/rpc/rpc-builder/Cargo.toml
+++ b/crates/rpc/rpc-builder/Cargo.toml
@@ -19,6 +19,7 @@ reth-consensus.workspace = true
 reth-network-api.workspace = true
 reth-node-core.workspace = true
 reth-provider.workspace = true
+reth-primitives.workspace = true
 reth-rpc.workspace = true
 reth-rpc-api.workspace = true
 reth-rpc-eth-api.workspace = true
diff --git a/crates/rpc/rpc-builder/src/eth.rs b/crates/rpc/rpc-builder/src/eth.rs
index e88f6aa86bbd..5326a10e4634 100644
--- a/crates/rpc/rpc-builder/src/eth.rs
+++ b/crates/rpc/rpc-builder/src/eth.rs
@@ -27,7 +27,12 @@ pub struct EthHandlers<Provider, Pool, Network, Events, EthApi: EthApiTypes> {
 
 impl<Provider, Pool, Network, Events, EthApi> EthHandlers<Provider, Pool, Network, Events, EthApi>
 where
-    Provider: StateProviderFactory + BlockReader + EvmEnvProvider + Clone + Unpin + 'static,
+    Provider: StateProviderFactory
+        + BlockReader<Block = reth_primitives::Block>
+        + EvmEnvProvider
+        + Clone
+        + Unpin
+        + 'static,
     Pool: Send + Sync + Clone + 'static,
     Network: Clone + 'static,
     Events: CanonStateSubscriptions + Clone + 'static,
diff --git a/crates/rpc/rpc-builder/src/lib.rs b/crates/rpc/rpc-builder/src/lib.rs
index ccf19ed1a0bc..51bf40ecbada 100644
--- a/crates/rpc/rpc-builder/src/lib.rs
+++ b/crates/rpc/rpc-builder/src/lib.rs
@@ -258,7 +258,7 @@ pub async fn launch<Provider, Pool, Network, Tasks, Events, EvmConfig, EthApi, B
     consensus: Arc<dyn Consensus>,
 ) -> Result<RpcServerHandle, RpcError>
 where
-    Provider: FullRpcProvider + AccountReader + ChangeSetReader,
+    Provider: FullRpcProvider<Block = reth_primitives::Block> + AccountReader + ChangeSetReader,
     Pool: TransactionPool + 'static,
     Network: NetworkInfo + Peers + Clone + 'static,
     Tasks: TaskSpawner + Clone + 'static,
@@ -641,6 +641,7 @@ where
         EngineT: EngineTypes,
         EngineApi: EngineApiServer<EngineT>,
         EthApi: FullEthApiServer,
+        Provider: BlockReader<Block = <EthApi::Provider as BlockReader>::Block>,
     {
         let Self {
             provider,
@@ -716,6 +717,7 @@ where
     ) -> RpcRegistryInner<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>
     where
         EthApi: EthApiTypes + 'static,
+        Provider: BlockReader<Block = reth_primitives::Block>,
     {
         let Self {
             provider,
@@ -750,6 +752,7 @@ where
     ) -> TransportRpcModules<()>
     where
         EthApi: FullEthApiServer,
+        Provider: BlockReader<Block = <EthApi::Provider as BlockReader>::Block>,
     {
         let mut modules = TransportRpcModules::default();
 
@@ -907,7 +910,12 @@ pub struct RpcRegistryInner<
 impl<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>
     RpcRegistryInner<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>
 where
-    Provider: StateProviderFactory + BlockReader + EvmEnvProvider + Clone + Unpin + 'static,
+    Provider: StateProviderFactory
+        + BlockReader<Block = reth_primitives::Block>
+        + EvmEnvProvider
+        + Clone
+        + Unpin
+        + 'static,
     Pool: Send + Sync + Clone + 'static,
     Network: Clone + 'static,
     Events: CanonStateSubscriptions + Clone + 'static,
@@ -1112,6 +1120,7 @@ where
     pub fn register_debug(&mut self) -> &mut Self
     where
         EthApi: EthApiSpec + EthTransactions + TraceExt,
+        Provider: BlockReader<Block = <EthApi::Provider as BlockReader>::Block>,
     {
         let debug_api = self.debug_api();
         self.modules.insert(RethRpcModule::Debug, debug_api.into_rpc().into());
@@ -1126,6 +1135,7 @@ where
     pub fn register_trace(&mut self) -> &mut Self
     where
         EthApi: TraceExt,
+        Provider: BlockReader<Block = <EthApi::Provider as BlockReader>::Block>,
     {
         let trace_api = self.trace_api();
         self.modules.insert(RethRpcModule::Trace, trace_api.into_rpc().into());
@@ -1264,7 +1274,9 @@ where
 impl<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>
     RpcRegistryInner<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>
 where
-    Provider: FullRpcProvider + AccountReader + ChangeSetReader,
+    Provider: FullRpcProvider<Block = <EthApi::Provider as BlockReader>::Block>
+        + AccountReader
+        + ChangeSetReader,
     Pool: TransactionPool + 'static,
     Network: NetworkInfo + Peers + Clone + 'static,
     Tasks: TaskSpawner + Clone + 'static,
diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs
index 7773b5084c9e..1062363eafb8 100644
--- a/crates/rpc/rpc-engine-api/src/engine_api.rs
+++ b/crates/rpc/rpc-engine-api/src/engine_api.rs
@@ -75,7 +75,11 @@ struct EngineApiInner<Provider, EngineT: EngineTypes, Pool, Validator, ChainSpec
 impl<Provider, EngineT, Pool, Validator, ChainSpec>
     EngineApi<Provider, EngineT, Pool, Validator, ChainSpec>
 where
-    Provider: HeaderProvider + BlockReader + StateProviderFactory + EvmEnvProvider + 'static,
+    Provider: HeaderProvider
+        + BlockReader<Block = reth_primitives::Block>
+        + StateProviderFactory
+        + EvmEnvProvider
+        + 'static,
     EngineT: EngineTypes,
     Pool: TransactionPool + 'static,
     Validator: EngineValidator<EngineT>,
@@ -487,7 +491,7 @@ where
         f: F,
     ) -> EngineApiResult<Vec<Option<R>>>
     where
-        F: Fn(Block) -> R + Send + 'static,
+        F: Fn(Provider::Block) -> R + Send + 'static,
         R: Send + 'static,
     {
         let (tx, rx) = oneshot::channel();
@@ -735,7 +739,11 @@ where
 impl<Provider, EngineT, Pool, Validator, ChainSpec> EngineApiServer<EngineT>
     for EngineApi<Provider, EngineT, Pool, Validator, ChainSpec>
 where
-    Provider: HeaderProvider + BlockReader + StateProviderFactory + EvmEnvProvider + 'static,
+    Provider: HeaderProvider
+        + BlockReader<Block = reth_primitives::Block>
+        + StateProviderFactory
+        + EvmEnvProvider
+        + 'static,
     EngineT: EngineTypes,
     Pool: TransactionPool + 'static,
     Validator: EngineValidator<EngineT>,
diff --git a/crates/rpc/rpc-eth-api/src/helpers/block.rs b/crates/rpc/rpc-eth-api/src/helpers/block.rs
index 251ca225eb19..c78c7c598768 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/block.rs
@@ -2,21 +2,32 @@
 
 use std::sync::Arc;
 
+use alloy_consensus::BlockHeader;
 use alloy_eips::BlockId;
 use alloy_rpc_types_eth::{Block, Header, Index};
 use futures::Future;
-use reth_primitives::{Receipt, SealedBlock, SealedBlockWithSenders};
+use reth_node_api::BlockBody;
+use reth_primitives::{Receipt, SealedBlockFor, SealedBlockWithSenders};
 use reth_provider::{BlockIdReader, BlockReader, BlockReaderIdExt, HeaderProvider};
 use reth_rpc_types_compat::block::from_block;
 
-use crate::{node::RpcNodeCoreExt, FromEthApiError, FullEthApiTypes, RpcBlock, RpcReceipt};
+use crate::{
+    node::RpcNodeCoreExt, EthApiTypes, FromEthApiError, FullEthApiTypes, RpcBlock, RpcNodeCore,
+    RpcReceipt,
+};
 
 use super::{LoadPendingBlock, LoadReceipt, SpawnBlocking};
 
 /// Result type of the fetched block receipts.
 pub type BlockReceiptsResult<N, E> = Result<Option<Vec<RpcReceipt<N>>>, E>;
 /// Result type of the fetched block and its receipts.
-pub type BlockAndReceiptsResult<E> = Result<Option<(SealedBlock, Arc<Vec<Receipt>>)>, E>;
+pub type BlockAndReceiptsResult<Eth> = Result<
+    Option<(
+        SealedBlockFor<<<Eth as RpcNodeCore>::Provider as BlockReader>::Block>,
+        Arc<Vec<Receipt>>,
+    )>,
+    <Eth as EthApiTypes>::Error,
+>;
 
 /// Block related functions for the [`EthApiServer`](crate::EthApiServer) trait in the
 /// `eth_` namespace.
@@ -49,7 +60,7 @@ pub trait EthBlocks: LoadBlock {
             let block_hash = block.hash();
             let mut total_difficulty = self
                 .provider()
-                .header_td_by_number(block.number)
+                .header_td_by_number(block.number())
                 .map_err(Self::Error::from_eth_err)?;
             if total_difficulty.is_none() {
                 // if we failed to find td after we successfully loaded the block, try again using
@@ -83,7 +94,7 @@ pub trait EthBlocks: LoadBlock {
                     .provider()
                     .pending_block()
                     .map_err(Self::Error::from_eth_err)?
-                    .map(|block| block.body.transactions.len()))
+                    .map(|block| block.body.transactions().len()))
             }
 
             let block_hash = match self
@@ -120,7 +131,7 @@ pub trait EthBlocks: LoadBlock {
     fn load_block_and_receipts(
         &self,
         block_id: BlockId,
-    ) -> impl Future<Output = BlockAndReceiptsResult<Self::Error>> + Send
+    ) -> impl Future<Output = BlockAndReceiptsResult<Self>> + Send
     where
         Self: LoadReceipt,
     {
@@ -198,10 +209,16 @@ pub trait EthBlocks: LoadBlock {
 /// Behaviour shared by several `eth_` RPC methods, not exclusive to `eth_` blocks RPC methods.
 pub trait LoadBlock: LoadPendingBlock + SpawnBlocking + RpcNodeCoreExt {
     /// Returns the block object for the given block id.
+    #[expect(clippy::type_complexity)]
     fn block_with_senders(
         &self,
         block_id: BlockId,
-    ) -> impl Future<Output = Result<Option<Arc<SealedBlockWithSenders>>, Self::Error>> + Send {
+    ) -> impl Future<
+        Output = Result<
+            Option<Arc<SealedBlockWithSenders<<Self::Provider as BlockReader>::Block>>>,
+            Self::Error,
+        >,
+    > + Send {
         async move {
             if block_id.is_pending() {
                 // Pending block can be fetched directly without need for caching
diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs
index d7e74c37b567..c7f346e951e3 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/call.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs
@@ -18,6 +18,7 @@ use alloy_rpc_types_eth::{
 use futures::Future;
 use reth_chainspec::EthChainSpec;
 use reth_evm::{ConfigureEvm, ConfigureEvmEnv};
+use reth_node_api::BlockBody;
 use reth_primitives::TransactionSigned;
 use reth_provider::{BlockIdReader, ChainSpecProvider, HeaderProvider};
 use reth_revm::{
@@ -278,14 +279,15 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock {
             // we're essentially replaying the transactions in the block here, hence we need the
             // state that points to the beginning of the block, which is the state at
             // the parent block
-            let mut at = block.parent_hash;
+            let mut at = block.parent_hash();
             let mut replay_block_txs = true;
 
-            let num_txs = transaction_index.index().unwrap_or(block.body.transactions.len());
+            let num_txs =
+                transaction_index.index().unwrap_or_else(|| block.body.transactions().len());
             // but if all transactions are to be replayed, we can use the state at the block itself,
             // however only if we're not targeting the pending block, because for pending we can't
             // rely on the block's state being available
-            if !is_block_target_pending && num_txs == block.body.transactions.len() {
+            if !is_block_target_pending && num_txs == block.body.transactions().len() {
                 at = block.hash();
                 replay_block_txs = false;
             }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/fee.rs b/crates/rpc/rpc-eth-api/src/helpers/fee.rs
index 8ed45d2ac080..0099e0f6b160 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/fee.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/fee.rs
@@ -1,5 +1,6 @@
 //! Loads fee history from database. Helper trait for `eth_` fee and transaction RPC methods.
 
+use alloy_consensus::BlockHeader;
 use alloy_primitives::U256;
 use alloy_rpc_types_eth::{BlockNumberOrTag, FeeHistory};
 use futures::Future;
@@ -287,7 +288,7 @@ pub trait LoadFee: LoadBlock {
                         .block_with_senders(BlockNumberOrTag::Pending.into())
                         .await?
                         .ok_or(EthApiError::HeaderNotFound(BlockNumberOrTag::Pending.into()))?
-                        .base_fee_per_gas
+                        .base_fee_per_gas()
                         .ok_or(EthApiError::InvalidTransaction(
                             RpcInvalidTransactionError::TxTypeNotSupported,
                         ))?;
@@ -324,7 +325,7 @@ pub trait LoadFee: LoadBlock {
         let suggested_tip = self.suggested_priority_fee();
         async move {
             let (header, suggested_tip) = futures::try_join!(header, suggested_tip)?;
-            let base_fee = header.and_then(|h| h.base_fee_per_gas).unwrap_or_default();
+            let base_fee = header.and_then(|h| h.base_fee_per_gas()).unwrap_or_default();
             Ok(suggested_tip + U256::from(base_fee))
         }
     }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
index 0f20cb4204eb..c166c31d7554 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs
@@ -45,7 +45,7 @@ use tracing::debug;
 pub trait LoadPendingBlock:
     EthApiTypes
     + RpcNodeCore<
-        Provider: BlockReaderIdExt
+        Provider: BlockReaderIdExt<Block = reth_primitives::Block>
                       + EvmEnvProvider
                       + ChainSpecProvider<ChainSpec: EthChainSpec + EthereumHardforks>
                       + StateProviderFactory,
@@ -114,9 +114,15 @@ pub trait LoadPendingBlock:
     }
 
     /// Returns the locally built pending block
+    #[expect(clippy::type_complexity)]
     fn local_pending_block(
         &self,
-    ) -> impl Future<Output = Result<Option<(SealedBlockWithSenders, Vec<Receipt>)>, Self::Error>> + Send
+    ) -> impl Future<
+        Output = Result<
+            Option<(SealedBlockWithSenders<<Self::Provider as BlockReader>::Block>, Vec<Receipt>)>,
+            Self::Error,
+        >,
+    > + Send
     where
         Self: SpawnBlocking,
     {
diff --git a/crates/rpc/rpc-eth-api/src/helpers/trace.rs b/crates/rpc/rpc-eth-api/src/helpers/trace.rs
index a1e6084da55d..114b4c41d905 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/trace.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/trace.rs
@@ -10,6 +10,7 @@ use futures::Future;
 use reth_chainspec::ChainSpecProvider;
 use reth_evm::{system_calls::SystemCaller, ConfigureEvm, ConfigureEvmEnv};
 use reth_primitives::SealedBlockWithSenders;
+use reth_provider::BlockReader;
 use reth_revm::database::StateProviderDatabase;
 use reth_rpc_eth_types::{
     cache::db::{StateCacheDb, StateCacheDbRefMutWrapper, StateProviderTraitObjWrapper},
@@ -24,7 +25,7 @@ use revm_primitives::{
 use super::{Call, LoadBlock, LoadPendingBlock, LoadState, LoadTransaction};
 
 /// Executes CPU heavy tasks.
-pub trait Trace: LoadState<Evm: ConfigureEvm<Header = Header>> {
+pub trait Trace: LoadState<Provider: BlockReader, Evm: ConfigureEvm<Header = Header>> {
     /// Executes the [`EnvWithHandlerCfg`] against the given [Database] without committing state
     /// changes.
     fn inspect<DB, I>(
@@ -230,7 +231,7 @@ pub trait Trace: LoadState<Evm: ConfigureEvm<Header = Header>> {
     fn trace_block_until<F, R>(
         &self,
         block_id: BlockId,
-        block: Option<Arc<SealedBlockWithSenders>>,
+        block: Option<Arc<SealedBlockWithSenders<<Self::Provider as BlockReader>::Block>>>,
         highest_index: Option<u64>,
         config: TracingInspectorConfig,
         f: F,
diff --git a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
index d898c0fe832e..3b6fc837c40c 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs
@@ -1,7 +1,7 @@
 //! Database access for `eth_` transaction RPC methods. Loads transaction and receipt data w.r.t.
 //! network.
 
-use alloy_consensus::Transaction;
+use alloy_consensus::{BlockHeader, Transaction};
 use alloy_dyn_abi::TypedData;
 use alloy_eips::{eip2718::Encodable2718, BlockId};
 use alloy_network::TransactionBuilder;
@@ -199,8 +199,8 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
         async move {
             if let Some(block) = self.block_with_senders(block_id).await? {
                 let block_hash = block.hash();
-                let block_number = block.number;
-                let base_fee_per_gas = block.base_fee_per_gas;
+                let block_number = block.number();
+                let base_fee_per_gas = block.base_fee_per_gas();
                 if let Some((signer, tx)) = block.transactions_with_sender().nth(index) {
                     let tx_info = TransactionInfo {
                         hash: Some(tx.hash()),
@@ -275,8 +275,8 @@ pub trait EthTransactions: LoadTransaction<Provider: BlockReaderIdExt> {
                 .await?
                 .and_then(|block| {
                     let block_hash = block.hash();
-                    let block_number = block.number;
-                    let base_fee_per_gas = block.base_fee_per_gas;
+                    let block_number = block.number();
+                    let base_fee_per_gas = block.base_fee_per_gas();
 
                     block
                         .transactions_with_sender()
diff --git a/crates/rpc/rpc-eth-types/Cargo.toml b/crates/rpc/rpc-eth-types/Cargo.toml
index 98b9530d63c2..11bf6c6231d2 100644
--- a/crates/rpc/rpc-eth-types/Cargo.toml
+++ b/crates/rpc/rpc-eth-types/Cargo.toml
@@ -29,6 +29,7 @@ reth-transaction-pool.workspace = true
 reth-trie.workspace = true
 
 # ethereum
+alloy-eips.workspace = true
 alloy-primitives.workspace = true
 alloy-consensus.workspace = true
 alloy-sol-types.workspace = true
@@ -36,7 +37,6 @@ alloy-rpc-types-eth.workspace = true
 revm.workspace = true
 revm-inspectors.workspace = true
 revm-primitives = { workspace = true, features = ["dev"] }
-alloy-eips.workspace = true
 
 # rpc
 jsonrpsee-core.workspace = true
diff --git a/crates/rpc/rpc-eth-types/src/cache/mod.rs b/crates/rpc/rpc-eth-types/src/cache/mod.rs
index b4a110e96af7..9e83e323c1a7 100644
--- a/crates/rpc/rpc-eth-types/src/cache/mod.rs
+++ b/crates/rpc/rpc-eth-types/src/cache/mod.rs
@@ -105,7 +105,12 @@ impl EthStateCache {
         evm_config: EvmConfig,
     ) -> Self
     where
-        Provider: StateProviderFactory + BlockReader + EvmEnvProvider + Clone + Unpin + 'static,
+        Provider: StateProviderFactory
+            + BlockReader<Block = reth_primitives::Block>
+            + EvmEnvProvider
+            + Clone
+            + Unpin
+            + 'static,
         EvmConfig: ConfigureEvm<Header = Header>,
     {
         Self::spawn_with(provider, config, TokioTaskExecutor::default(), evm_config)
@@ -122,7 +127,12 @@ impl EthStateCache {
         evm_config: EvmConfig,
     ) -> Self
     where
-        Provider: StateProviderFactory + BlockReader + EvmEnvProvider + Clone + Unpin + 'static,
+        Provider: StateProviderFactory
+            + BlockReader<Block = reth_primitives::Block>
+            + EvmEnvProvider
+            + Clone
+            + Unpin
+            + 'static,
         Tasks: TaskSpawner + Clone + 'static,
         EvmConfig: ConfigureEvm<Header = Header>,
     {
@@ -337,7 +347,12 @@ where
 
 impl<Provider, Tasks, EvmConfig> Future for EthStateCacheService<Provider, Tasks, EvmConfig>
 where
-    Provider: StateProviderFactory + BlockReader + EvmEnvProvider + Clone + Unpin + 'static,
+    Provider: StateProviderFactory
+        + BlockReader<Block = reth_primitives::Block>
+        + EvmEnvProvider
+        + Clone
+        + Unpin
+        + 'static,
     Tasks: TaskSpawner + Clone + 'static,
     EvmConfig: ConfigureEvm<Header = Header>,
 {
diff --git a/crates/rpc/rpc-eth-types/src/logs_utils.rs b/crates/rpc/rpc-eth-types/src/logs_utils.rs
index 5ead11b71156..2e41c7a1183d 100644
--- a/crates/rpc/rpc-eth-types/src/logs_utils.rs
+++ b/crates/rpc/rpc-eth-types/src/logs_utils.rs
@@ -8,6 +8,7 @@ use alloy_rpc_types_eth::{FilteredParams, Log};
 use reth_chainspec::ChainInfo;
 use reth_errors::ProviderError;
 use reth_primitives::{Receipt, SealedBlockWithSenders};
+use reth_primitives_traits::SignedTransaction;
 use reth_storage_api::BlockReader;
 use std::sync::Arc;
 
@@ -58,7 +59,7 @@ pub enum ProviderOrBlock<'a, P: BlockReader> {
 
 /// Appends all matching logs of a block's receipts.
 /// If the log matches, look up the corresponding transaction hash.
-pub fn append_matching_block_logs<P: BlockReader>(
+pub fn append_matching_block_logs<P: BlockReader<Transaction: SignedTransaction>>(
     all_logs: &mut Vec<Log>,
     provider_or_block: ProviderOrBlock<'_, P>,
     filter: &FilteredParams,
diff --git a/crates/rpc/rpc-eth-types/src/pending_block.rs b/crates/rpc/rpc-eth-types/src/pending_block.rs
index d8f413650a30..116026c2ddde 100644
--- a/crates/rpc/rpc-eth-types/src/pending_block.rs
+++ b/crates/rpc/rpc-eth-types/src/pending_block.rs
@@ -4,10 +4,12 @@
 
 use std::time::Instant;
 
+use alloy_consensus::BlockHeader;
 use alloy_eips::{BlockId, BlockNumberOrTag};
 use alloy_primitives::B256;
 use derive_more::Constructor;
 use reth_primitives::{Receipt, SealedBlockWithSenders, SealedHeader};
+use reth_primitives_traits::Block;
 use revm_primitives::{BlockEnv, CfgEnvWithHandlerCfg};
 
 /// Configured [`BlockEnv`] and [`CfgEnvWithHandlerCfg`] for a pending block.
@@ -23,26 +25,26 @@ pub struct PendingBlockEnv {
 
 /// The origin for a configured [`PendingBlockEnv`]
 #[derive(Clone, Debug)]
-pub enum PendingBlockEnvOrigin {
+pub enum PendingBlockEnvOrigin<B: Block = reth_primitives::Block> {
     /// The pending block as received from the CL.
-    ActualPending(SealedBlockWithSenders),
+    ActualPending(SealedBlockWithSenders<B>),
     /// The _modified_ header of the latest block.
     ///
     /// This derives the pending state based on the latest header by modifying:
     ///  - the timestamp
     ///  - the block number
     ///  - fees
-    DerivedFromLatest(SealedHeader),
+    DerivedFromLatest(SealedHeader<B::Header>),
 }
 
-impl PendingBlockEnvOrigin {
+impl<B: Block> PendingBlockEnvOrigin<B> {
     /// Returns true if the origin is the actual pending block as received from the CL.
     pub const fn is_actual_pending(&self) -> bool {
         matches!(self, Self::ActualPending(_))
     }
 
     /// Consumes the type and returns the actual pending block.
-    pub fn into_actual_pending(self) -> Option<SealedBlockWithSenders> {
+    pub fn into_actual_pending(self) -> Option<SealedBlockWithSenders<B>> {
         match self {
             Self::ActualPending(block) => Some(block),
             _ => None,
@@ -67,13 +69,13 @@ impl PendingBlockEnvOrigin {
     /// header.
     pub fn build_target_hash(&self) -> B256 {
         match self {
-            Self::ActualPending(block) => block.parent_hash,
+            Self::ActualPending(block) => block.header().parent_hash(),
             Self::DerivedFromLatest(header) => header.hash(),
         }
     }
 
     /// Returns the header this pending block is based on.
-    pub fn header(&self) -> &SealedHeader {
+    pub fn header(&self) -> &SealedHeader<B::Header> {
         match self {
             Self::ActualPending(block) => &block.header,
             Self::DerivedFromLatest(header) => header,
diff --git a/crates/rpc/rpc/src/debug.rs b/crates/rpc/rpc/src/debug.rs
index 5425de402f85..ad3294d503c8 100644
--- a/crates/rpc/rpc/src/debug.rs
+++ b/crates/rpc/rpc/src/debug.rs
@@ -793,7 +793,7 @@ where
 #[async_trait]
 impl<Provider, Eth, BlockExecutor> DebugApiServer for DebugApi<Provider, Eth, BlockExecutor>
 where
-    Provider: BlockReaderIdExt
+    Provider: BlockReaderIdExt<Block: Encodable>
         + HeaderProvider
         + ChainSpecProvider<ChainSpec: EthereumHardforks>
         + StateProviderFactory
diff --git a/crates/rpc/rpc/src/eth/core.rs b/crates/rpc/rpc/src/eth/core.rs
index dac371529426..3087af52d695 100644
--- a/crates/rpc/rpc/src/eth/core.rs
+++ b/crates/rpc/rpc/src/eth/core.rs
@@ -432,7 +432,7 @@ mod tests {
     use crate::EthApi;
 
     fn build_test_eth_api<
-        P: BlockReaderIdExt
+        P: BlockReaderIdExt<Block = reth_primitives::Block>
             + BlockReader
             + ChainSpecProvider<ChainSpec = ChainSpec>
             + EvmEnvProvider
diff --git a/crates/rpc/rpc/src/eth/helpers/pending_block.rs b/crates/rpc/rpc/src/eth/helpers/pending_block.rs
index 8540a4684bf8..23e5f671dbec 100644
--- a/crates/rpc/rpc/src/eth/helpers/pending_block.rs
+++ b/crates/rpc/rpc/src/eth/helpers/pending_block.rs
@@ -18,7 +18,7 @@ impl<Provider, Pool, Network, EvmConfig> LoadPendingBlock
 where
     Self: SpawnBlocking
         + RpcNodeCore<
-            Provider: BlockReaderIdExt
+            Provider: BlockReaderIdExt<Block = reth_primitives::Block>
                           + EvmEnvProvider
                           + ChainSpecProvider<ChainSpec: EthChainSpec + EthereumHardforks>
                           + StateProviderFactory,
diff --git a/crates/rpc/rpc/src/eth/helpers/trace.rs b/crates/rpc/rpc/src/eth/helpers/trace.rs
index d9fe5e18a05b..9c60a4c105f9 100644
--- a/crates/rpc/rpc/src/eth/helpers/trace.rs
+++ b/crates/rpc/rpc/src/eth/helpers/trace.rs
@@ -2,11 +2,12 @@
 
 use alloy_consensus::Header;
 use reth_evm::ConfigureEvm;
+use reth_provider::BlockReader;
 use reth_rpc_eth_api::helpers::{LoadState, Trace};
 
 use crate::EthApi;
 
 impl<Provider, Pool, Network, EvmConfig> Trace for EthApi<Provider, Pool, Network, EvmConfig> where
-    Self: LoadState<Evm: ConfigureEvm<Header = Header>>
+    Self: LoadState<Provider: BlockReader, Evm: ConfigureEvm<Header = Header>>
 {
 }
diff --git a/crates/rpc/rpc/src/trace.rs b/crates/rpc/rpc/src/trace.rs
index 81dc8ff8b8a8..f81eefdc5ff1 100644
--- a/crates/rpc/rpc/src/trace.rs
+++ b/crates/rpc/rpc/src/trace.rs
@@ -74,7 +74,7 @@ impl<Provider, Eth> TraceApi<Provider, Eth> {
 
 impl<Provider, Eth> TraceApi<Provider, Eth>
 where
-    Provider: BlockReader
+    Provider: BlockReader<Block = <Eth::Provider as BlockReader>::Block>
         + StateProviderFactory
         + EvmEnvProvider
         + ChainSpecProvider<ChainSpec: EthereumHardforks>
@@ -565,7 +565,7 @@ where
 #[async_trait]
 impl<Provider, Eth> TraceApiServer for TraceApi<Provider, Eth>
 where
-    Provider: BlockReader
+    Provider: BlockReader<Block = <Eth::Provider as BlockReader>::Block>
         + StateProviderFactory
         + EvmEnvProvider
         + ChainSpecProvider<ChainSpec: EthereumHardforks>
diff --git a/crates/stages/stages/src/stages/execution.rs b/crates/stages/stages/src/stages/execution.rs
index 16234ad483f7..c76c2c732a21 100644
--- a/crates/stages/stages/src/stages/execution.rs
+++ b/crates/stages/stages/src/stages/execution.rs
@@ -1,5 +1,5 @@
 use crate::stages::MERKLE_STAGE_DEFAULT_CLEAN_THRESHOLD;
-use alloy_consensus::Header;
+use alloy_consensus::{BlockHeader, Header};
 use alloy_primitives::BlockNumber;
 use num_traits::Zero;
 use reth_config::config::ExecutionConfig;
@@ -12,7 +12,7 @@ use reth_evm::{
 use reth_execution_types::Chain;
 use reth_exex::{ExExManagerHandle, ExExNotification, ExExNotificationSource};
 use reth_primitives::{SealedHeader, StaticFileSegment};
-use reth_primitives_traits::{format_gas_throughput, NodePrimitives};
+use reth_primitives_traits::{format_gas_throughput, Block, BlockBody, NodePrimitives};
 use reth_provider::{
     providers::{StaticFileProvider, StaticFileProviderRWRefMut, StaticFileWriter},
     writer::UnifiedStorageWriter,
@@ -176,7 +176,7 @@ impl<E, Provider> Stage<Provider> for ExecutionStage<E>
 where
     E: BlockExecutorProvider,
     Provider: DBProvider
-        + BlockReader
+        + BlockReader<Block = reth_primitives::Block>
         + StaticFileProviderFactory
         + StatsReader
         + StateChangeWriter
@@ -270,17 +270,17 @@ where
 
             fetch_block_duration += fetch_block_start.elapsed();
 
-            cumulative_gas += block.gas_used;
+            cumulative_gas += block.header().gas_used();
 
             // Configure the executor to use the current state.
-            trace!(target: "sync::stages::execution", number = block_number, txs = block.body.transactions.len(), "Executing block");
+            trace!(target: "sync::stages::execution", number = block_number, txs = block.body().transactions().len(), "Executing block");
 
             // Execute the block
             let execute_start = Instant::now();
 
             self.metrics.metered_one((&block, td).into(), |input| {
                 executor.execute_and_verify_one(input).map_err(|error| StageError::Block {
-                    block: Box::new(SealedHeader::seal(block.header.clone())),
+                    block: Box::new(SealedHeader::seal(block.header().clone())),
                     error: BlockErrorKind::Execution(error),
                 })
             })?;
@@ -304,7 +304,7 @@ where
             }
 
             stage_progress = block_number;
-            stage_checkpoint.progress.processed += block.gas_used;
+            stage_checkpoint.progress.processed += block.gas_used();
 
             // If we have ExExes we need to save the block in memory for later
             if self.exex_manager_handle.has_exexs() {
@@ -343,7 +343,7 @@ where
         // the `has_exexs` check here as well
         if !blocks.is_empty() {
             let blocks = blocks.into_iter().map(|block| {
-                let hash = block.header.hash_slow();
+                let hash = block.header().hash_slow();
                 block.seal(hash)
             });
 
diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs
index d90b227c1122..385ae67d68fd 100644
--- a/crates/storage/provider/src/providers/blockchain_provider.rs
+++ b/crates/storage/provider/src/providers/blockchain_provider.rs
@@ -25,10 +25,11 @@ use reth_db::{models::BlockNumberAddress, transaction::DbTx, Database};
 use reth_db_api::models::{AccountBeforeTx, StoredBlockBodyIndices};
 use reth_evm::ConfigureEvmEnv;
 use reth_execution_types::ExecutionOutcome;
-use reth_node_types::{NodeTypesWithDB, TxTy};
+use reth_node_types::{BlockTy, NodeTypesWithDB, TxTy};
 use reth_primitives::{
-    Account, Block, BlockWithSenders, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
-    StorageEntry, TransactionMeta, TransactionSigned, TransactionSignedNoHash,
+    Account, Block, BlockWithSenders, NodePrimitives, Receipt, SealedBlock, SealedBlockFor,
+    SealedBlockWithSenders, SealedHeader, StorageEntry, TransactionMeta, TransactionSigned,
+    TransactionSignedNoHash,
 };
 use reth_primitives_traits::BlockBody as _;
 use reth_prune_types::{PruneCheckpoint, PruneSegment};
@@ -259,23 +260,33 @@ impl<N: ProviderNodeTypes> BlockIdReader for BlockchainProvider2<N> {
 }
 
 impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider2<N> {
-    fn find_block_by_hash(&self, hash: B256, source: BlockSource) -> ProviderResult<Option<Block>> {
+    type Block = BlockTy<N>;
+
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>> {
         self.consistent_provider()?.find_block_by_hash(hash, source)
     }
 
-    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
         self.consistent_provider()?.block(id)
     }
 
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
         Ok(self.canonical_in_memory_state.pending_block())
     }
 
-    fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         Ok(self.canonical_in_memory_state.pending_block_with_senders())
     }
 
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>> {
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
         Ok(self.canonical_in_memory_state.pending_block_and_receipts())
     }
 
@@ -300,7 +311,7 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider2<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>> {
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
         self.consistent_provider()?.block_with_senders(id, transaction_kind)
     }
 
@@ -308,25 +319,25 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider2<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         self.consistent_provider()?.sealed_block_with_senders(id, transaction_kind)
     }
 
-    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
         self.consistent_provider()?.block_range(range)
     }
 
     fn block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<BlockWithSenders>> {
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
         self.consistent_provider()?.block_with_senders_range(range)
     }
 
     fn sealed_block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
         self.consistent_provider()?.sealed_block_with_senders_range(range)
     }
 }
@@ -670,9 +681,9 @@ where
 
 impl<N: ProviderNodeTypes> BlockReaderIdExt for BlockchainProvider2<N>
 where
-    Self: BlockReader + ReceiptProviderIdExt,
+    Self: ReceiptProviderIdExt,
 {
-    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Block>> {
+    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Self::Block>> {
         self.consistent_provider()?.block_by_id(id)
     }
 
diff --git a/crates/storage/provider/src/providers/consistent.rs b/crates/storage/provider/src/providers/consistent.rs
index 740392ad9938..0abd23749c25 100644
--- a/crates/storage/provider/src/providers/consistent.rs
+++ b/crates/storage/provider/src/providers/consistent.rs
@@ -18,11 +18,12 @@ use reth_db::models::BlockNumberAddress;
 use reth_db_api::models::{AccountBeforeTx, StoredBlockBodyIndices};
 use reth_evm::ConfigureEvmEnv;
 use reth_execution_types::{BundleStateInit, ExecutionOutcome, RevertsInit};
-use reth_node_types::TxTy;
+use reth_node_types::{BlockTy, TxTy};
 use reth_primitives::{
-    Account, Block, BlockWithSenders, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
+    Account, BlockWithSenders, Receipt, SealedBlockFor, SealedBlockWithSenders, SealedHeader,
     StorageEntry, TransactionMeta,
 };
+use reth_primitives_traits::{Block, BlockBody};
 use reth_prune_types::{PruneCheckpoint, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_storage_api::{DatabaseProviderFactory, StateProvider, StorageChangeSetReader};
@@ -778,7 +779,13 @@ impl<N: ProviderNodeTypes> BlockIdReader for ConsistentProvider<N> {
 }
 
 impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
-    fn find_block_by_hash(&self, hash: B256, source: BlockSource) -> ProviderResult<Option<Block>> {
+    type Block = BlockTy<N>;
+
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>> {
         match source {
             BlockSource::Any | BlockSource::Canonical => {
                 // Note: it's fine to return the unsealed block because the caller already has
@@ -795,7 +802,7 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
         }
     }
 
-    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
         self.get_in_memory_or_storage_by_block(
             id,
             |db_provider| db_provider.block(id),
@@ -803,15 +810,19 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
         )
     }
 
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
         Ok(self.canonical_in_memory_state.pending_block())
     }
 
-    fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         Ok(self.canonical_in_memory_state.pending_block_with_senders())
     }
 
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>> {
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
         Ok(self.canonical_in_memory_state.pending_block_and_receipts())
     }
 
@@ -873,7 +884,7 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>> {
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
         self.get_in_memory_or_storage_by_block(
             id,
             |db_provider| db_provider.block_with_senders(id, transaction_kind),
@@ -885,7 +896,7 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         self.get_in_memory_or_storage_by_block(
             id,
             |db_provider| db_provider.sealed_block_with_senders(id, transaction_kind),
@@ -893,7 +904,7 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
         )
     }
 
-    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
         self.get_in_memory_or_storage_by_block_range_while(
             range,
             |db_provider, range, _| db_provider.block_range(range),
@@ -905,7 +916,7 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
     fn block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<BlockWithSenders>> {
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
         self.get_in_memory_or_storage_by_block_range_while(
             range,
             |db_provider, range, _| db_provider.block_with_senders_range(range),
@@ -917,7 +928,7 @@ impl<N: ProviderNodeTypes> BlockReader for ConsistentProvider<N> {
     fn sealed_block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
         self.get_in_memory_or_storage_by_block_range_while(
             range,
             |db_provider, range, _| db_provider.sealed_block_with_senders_range(range),
@@ -1011,7 +1022,7 @@ impl<N: ProviderNodeTypes> TransactionsProvider for ConsistentProvider<N> {
         self.get_in_memory_or_storage_by_block(
             id,
             |provider| provider.transactions_by_block(id),
-            |block_state| Ok(Some(block_state.block_ref().block().body.transactions.clone())),
+            |block_state| Ok(Some(block_state.block_ref().block().body().transactions().to_vec())),
         )
     }
 
@@ -1022,7 +1033,7 @@ impl<N: ProviderNodeTypes> TransactionsProvider for ConsistentProvider<N> {
         self.get_in_memory_or_storage_by_block_range_while(
             range,
             |db_provider, range, _| db_provider.transactions_by_block_range(range),
-            |block_state, _| Some(block_state.block_ref().block().body.transactions.clone()),
+            |block_state, _| Some(block_state.block_ref().block().body().transactions().to_vec()),
             |_| true,
         )
     }
@@ -1289,7 +1300,7 @@ impl<N: ProviderNodeTypes> ChainSpecProvider for ConsistentProvider<N> {
 }
 
 impl<N: ProviderNodeTypes> BlockReaderIdExt for ConsistentProvider<N> {
-    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Block>> {
+    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Self::Block>> {
         match id {
             BlockId::Number(num) => self.block_by_number_or_tag(num),
             BlockId::Hash(hash) => {
diff --git a/crates/storage/provider/src/providers/database/mod.rs b/crates/storage/provider/src/providers/database/mod.rs
index 57f09e72306f..b2ea85191637 100644
--- a/crates/storage/provider/src/providers/database/mod.rs
+++ b/crates/storage/provider/src/providers/database/mod.rs
@@ -19,9 +19,9 @@ use reth_db::{init_db, mdbx::DatabaseArguments, DatabaseEnv};
 use reth_db_api::{database::Database, models::StoredBlockBodyIndices};
 use reth_errors::{RethError, RethResult};
 use reth_evm::ConfigureEvmEnv;
-use reth_node_types::{NodeTypesWithDB, TxTy};
+use reth_node_types::{BlockTy, NodeTypesWithDB, TxTy};
 use reth_primitives::{
-    Block, BlockWithSenders, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
+    BlockWithSenders, Receipt, SealedBlockFor, SealedBlockWithSenders, SealedHeader,
     StaticFileSegment, TransactionMeta,
 };
 use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
@@ -353,23 +353,33 @@ impl<N: ProviderNodeTypes> BlockNumReader for ProviderFactory<N> {
 }
 
 impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
-    fn find_block_by_hash(&self, hash: B256, source: BlockSource) -> ProviderResult<Option<Block>> {
+    type Block = BlockTy<N>;
+
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>> {
         self.provider()?.find_block_by_hash(hash, source)
     }
 
-    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
         self.provider()?.block(id)
     }
 
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
         self.provider()?.pending_block()
     }
 
-    fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         self.provider()?.pending_block_with_senders()
     }
 
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>> {
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
         self.provider()?.pending_block_and_receipts()
     }
 
@@ -388,7 +398,7 @@ impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>> {
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
         self.provider()?.block_with_senders(id, transaction_kind)
     }
 
@@ -396,25 +406,25 @@ impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         self.provider()?.sealed_block_with_senders(id, transaction_kind)
     }
 
-    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
         self.provider()?.block_range(range)
     }
 
     fn block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<BlockWithSenders>> {
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
         self.provider()?.block_with_senders_range(range)
     }
 
     fn sealed_block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
         self.provider()?.sealed_block_with_senders_range(range)
     }
 }
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index 47d9308283fd..3723e2606dcc 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -46,13 +46,13 @@ use reth_db_api::{
 use reth_evm::ConfigureEvmEnv;
 use reth_execution_types::{Chain, ExecutionOutcome};
 use reth_network_p2p::headers::downloader::SyncTarget;
-use reth_node_types::{BlockTy, NodeTypes, TxTy};
+use reth_node_types::{BlockTy, BodyTy, NodeTypes, TxTy};
 use reth_primitives::{
-    Account, Block, BlockBody, BlockExt, BlockWithSenders, Bytecode, GotExpected, Receipt,
-    SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
+    Account, Block, BlockExt, BlockWithSenders, Bytecode, GotExpected, Receipt, SealedBlock,
+    SealedBlockFor, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
     TransactionMeta, TransactionSignedNoHash,
 };
-use reth_primitives_traits::{BlockBody as _, SignedTransaction};
+use reth_primitives_traits::{Block as _, BlockBody as _, SignedTransaction};
 use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_storage_api::{
@@ -457,7 +457,7 @@ where
     Ok(Vec::new())
 }
 
-impl<TX: DbTx + 'static, N: NodeTypes> DatabaseProvider<TX, N> {
+impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
     /// Creates a provider with an inner read-only transaction.
     pub const fn new(
         tx: TX,
@@ -519,7 +519,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         N::ChainSpec: EthereumHardforks,
         H: AsRef<Header>,
         HF: FnOnce(BlockNumber) -> ProviderResult<Option<H>>,
-        BF: FnOnce(H, BlockBody, Vec<Address>) -> ProviderResult<Option<B>>,
+        BF: FnOnce(H, BodyTy<N>, Vec<Address>) -> ProviderResult<Option<B>>,
     {
         let Some(block_number) = self.convert_hash_or_number(id)? else { return Ok(None) };
         let Some(header) = header_by_number(block_number)? else { return Ok(None) };
@@ -569,7 +569,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         N::ChainSpec: EthereumHardforks,
         H: AsRef<Header>,
         HF: FnOnce(RangeInclusive<BlockNumber>) -> ProviderResult<Vec<H>>,
-        F: FnMut(H, BlockBody, Range<TxNumber>) -> ProviderResult<R>,
+        F: FnMut(H, BodyTy<N>, Range<TxNumber>) -> ProviderResult<R>,
     {
         if range.is_empty() {
             return Ok(Vec::new())
@@ -637,7 +637,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
         N::ChainSpec: EthereumHardforks,
         H: AsRef<Header>,
         HF: Fn(RangeInclusive<BlockNumber>) -> ProviderResult<Vec<H>>,
-        BF: Fn(H, BlockBody, Vec<Address>) -> ProviderResult<B>,
+        BF: Fn(H, BodyTy<N>, Vec<Address>) -> ProviderResult<B>,
     {
         let mut senders_cursor = self.tx.cursor_read::<tables::TransactionSenders>()?;
 
@@ -651,7 +651,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> DatabaseProvider<TX, N> {
                         .walk_range(tx_range.clone())?
                         .collect::<Result<HashMap<_, _>, _>>()?;
 
-                let mut senders = Vec::with_capacity(body.transactions.len());
+                let mut senders = Vec::with_capacity(body.transactions().len());
                 for (tx_num, tx) in tx_range.zip(body.transactions()) {
                     match known_senders.get(&tx_num) {
                         None => {
@@ -1190,7 +1190,13 @@ impl<TX: DbTx + 'static, N: NodeTypes> BlockNumReader for DatabaseProvider<TX, N
 }
 
 impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvider<TX, N> {
-    fn find_block_by_hash(&self, hash: B256, source: BlockSource) -> ProviderResult<Option<Block>> {
+    type Block = BlockTy<N>;
+
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>> {
         if source.is_canonical() {
             self.block(hash.into())
         } else {
@@ -1203,7 +1209,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
     /// If the header for this block is not found, this returns `None`.
     /// If the header is found, but the transactions either do not exist, or are not indexed, this
     /// will return None.
-    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
         if let Some(number) = self.convert_hash_or_number(id)? {
             if let Some(header) = self.header_by_number(number)? {
                 // If the body indices are not found, this means that the transactions either do not
@@ -1228,15 +1234,19 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
         Ok(None)
     }
 
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
         Ok(None)
     }
 
-    fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         Ok(None)
     }
 
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>> {
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
         Ok(None)
     }
 
@@ -1275,13 +1285,13 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>> {
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
         self.block_with_senders(
             id,
             transaction_kind,
             |block_number| self.header_by_number(block_number),
             |header, body, senders| {
-                Block { header, body }
+                Self::Block::new(header, body)
                     // Note: we're using unchecked here because we know the block contains valid txs
                     // wrt to its height and can ignore the s value check so pre
                     // EIP-2 txs are allowed
@@ -1296,7 +1306,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         self.block_with_senders(
             id,
             transaction_kind,
@@ -1313,23 +1323,23 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
         )
     }
 
-    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
         self.block_range(
             range,
             |range| self.headers_range(range),
-            |header, body, _| Ok(Block { header, body }),
+            |header, body, _| Ok(Self::Block::new(header, body)),
         )
     }
 
     fn block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<BlockWithSenders>> {
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
         self.block_with_senders_range(
             range,
             |range| self.headers_range(range),
             |header, body, senders| {
-                Block { header, body }
+                Self::Block::new(header, body)
                     .try_with_senders_unchecked(senders)
                     .map_err(|_| ProviderError::SenderRecoveryError)
             },
@@ -1339,7 +1349,7 @@ impl<TX: DbTx + 'static, N: NodeTypesForProvider> BlockReader for DatabaseProvid
     fn sealed_block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
         self.block_with_senders_range(
             range,
             |range| self.sealed_headers_range(range),
@@ -2812,7 +2822,7 @@ impl<TX: DbTxMut + DbTx + 'static, N: NodeTypesForProvider + 'static> BlockWrite
 
     fn append_block_bodies(
         &self,
-        bodies: Vec<(BlockNumber, Option<<Self::Block as reth_primitives_traits::Block>::Body>)>,
+        bodies: Vec<(BlockNumber, Option<BodyTy<N>>)>,
         write_transactions_to: StorageLocation,
     ) -> ProviderResult<()> {
         let Some(from_block) = bodies.first().map(|(block, _)| *block) else { return Ok(()) };
diff --git a/crates/storage/provider/src/providers/mod.rs b/crates/storage/provider/src/providers/mod.rs
index 30cac220d8ba..abd92312715c 100644
--- a/crates/storage/provider/src/providers/mod.rs
+++ b/crates/storage/provider/src/providers/mod.rs
@@ -22,10 +22,10 @@ use reth_chain_state::{ChainInfoTracker, ForkChoiceNotifications, ForkChoiceSubs
 use reth_chainspec::{ChainInfo, EthereumHardforks};
 use reth_db_api::models::{AccountBeforeTx, StoredBlockBodyIndices};
 use reth_evm::ConfigureEvmEnv;
-use reth_node_types::{FullNodePrimitives, NodeTypes, NodeTypesWithDB, TxTy};
+use reth_node_types::{BlockTy, FullNodePrimitives, NodeTypes, NodeTypesWithDB, TxTy};
 use reth_primitives::{
-    Account, Block, BlockWithSenders, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
-    TransactionMeta, TransactionSigned,
+    Account, BlockWithSenders, Receipt, SealedBlock, SealedBlockFor, SealedBlockWithSenders,
+    SealedHeader, TransactionMeta, TransactionSigned,
 };
 use reth_prune_types::{PruneCheckpoint, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
@@ -79,6 +79,7 @@ where
             SignedTx = TransactionSigned,
             BlockHeader = alloy_consensus::Header,
             BlockBody = reth_primitives::BlockBody,
+            Block = reth_primitives::Block,
         >,
     >,
 {
@@ -92,6 +93,7 @@ impl<T> NodeTypesForProvider for T where
             SignedTx = TransactionSigned,
             BlockHeader = alloy_consensus::Header,
             BlockBody = reth_primitives::BlockBody,
+            Block = reth_primitives::Block,
         >,
     >
 {
@@ -333,7 +335,13 @@ impl<N: ProviderNodeTypes> BlockIdReader for BlockchainProvider<N> {
 }
 
 impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
-    fn find_block_by_hash(&self, hash: B256, source: BlockSource) -> ProviderResult<Option<Block>> {
+    type Block = BlockTy<N>;
+
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>> {
         let block = match source {
             BlockSource::Any => {
                 // check database first
@@ -352,22 +360,26 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
         Ok(block)
     }
 
-    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
         match id {
             BlockHashOrNumber::Hash(hash) => self.find_block_by_hash(hash, BlockSource::Any),
             BlockHashOrNumber::Number(num) => self.database.block_by_number(num),
         }
     }
 
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
         Ok(self.tree.pending_block())
     }
 
-    fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         Ok(self.tree.pending_block_with_senders())
     }
 
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>> {
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
         Ok(self.tree.pending_block_and_receipts())
     }
 
@@ -392,7 +404,7 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>> {
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
         self.database.block_with_senders(id, transaction_kind)
     }
 
@@ -400,25 +412,25 @@ impl<N: ProviderNodeTypes> BlockReader for BlockchainProvider<N> {
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         self.database.sealed_block_with_senders(id, transaction_kind)
     }
 
-    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
         self.database.block_range(range)
     }
 
     fn block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<BlockWithSenders>> {
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
         self.database.block_with_senders_range(range)
     }
 
     fn sealed_block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
         self.database.sealed_block_with_senders_range(range)
     }
 }
@@ -847,7 +859,7 @@ impl<N: ProviderNodeTypes> BlockReaderIdExt for BlockchainProvider<N>
 where
     Self: BlockReader + ReceiptProviderIdExt,
 {
-    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Block>> {
+    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Self::Block>> {
         match id {
             BlockId::Number(num) => self.block_by_number_or_tag(num),
             BlockId::Hash(hash) => {
diff --git a/crates/storage/provider/src/providers/static_file/manager.rs b/crates/storage/provider/src/providers/static_file/manager.rs
index 14821fde547d..34f3b91f6275 100644
--- a/crates/storage/provider/src/providers/static_file/manager.rs
+++ b/crates/storage/provider/src/providers/static_file/manager.rs
@@ -31,14 +31,14 @@ use reth_db_api::{
     cursor::DbCursorRO, models::StoredBlockBodyIndices, table::Table, transaction::DbTx,
 };
 use reth_nippy_jar::{NippyJar, NippyJarChecker, CONFIG_FILE_EXTENSION};
-use reth_node_types::NodePrimitives;
+use reth_node_types::{FullNodePrimitives, NodePrimitives};
 use reth_primitives::{
     static_file::{
         find_fixed_range, HighestStaticFiles, SegmentHeader, SegmentRangeInclusive,
         DEFAULT_BLOCKS_PER_STATIC_FILE,
     },
     transaction::recover_signers,
-    Block, BlockWithSenders, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
+    BlockWithSenders, Receipt, SealedBlockFor, SealedBlockWithSenders, SealedHeader,
     StaticFileSegment, TransactionMeta, TransactionSignedNoHash,
 };
 use reth_primitives_traits::SignedTransaction;
@@ -1380,9 +1380,7 @@ impl<N: NodePrimitives<SignedTx: Value + SignedTransaction>> ReceiptProvider
     }
 }
 
-impl<N: NodePrimitives<SignedTx: Value + SignedTransaction>> TransactionsProviderExt
-    for StaticFileProvider<N>
-{
+impl<N: FullNodePrimitives<SignedTx: Value>> TransactionsProviderExt for StaticFileProvider<N> {
     fn transaction_hashes_by_range(
         &self,
         tx_range: Range<TxNumber>,
@@ -1577,32 +1575,38 @@ impl<N: NodePrimitives> BlockNumReader for StaticFileProvider<N> {
     }
 }
 
-impl<N: NodePrimitives<SignedTx: Value + SignedTransaction>> BlockReader for StaticFileProvider<N> {
+impl<N: FullNodePrimitives<SignedTx: Value>> BlockReader for StaticFileProvider<N> {
+    type Block = N::Block;
+
     fn find_block_by_hash(
         &self,
         _hash: B256,
         _source: BlockSource,
-    ) -> ProviderResult<Option<Block>> {
+    ) -> ProviderResult<Option<Self::Block>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
 
-    fn block(&self, _id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
+    fn block(&self, _id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
 
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
 
-    fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
 
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>> {
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
@@ -1621,7 +1625,7 @@ impl<N: NodePrimitives<SignedTx: Value + SignedTransaction>> BlockReader for Sta
         &self,
         _id: BlockHashOrNumber,
         _transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>> {
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
@@ -1630,12 +1634,12 @@ impl<N: NodePrimitives<SignedTx: Value + SignedTransaction>> BlockReader for Sta
         &self,
         _id: BlockHashOrNumber,
         _transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
 
-    fn block_range(&self, _range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>> {
+    fn block_range(&self, _range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
         // Required data not present in static_files
         Err(ProviderError::UnsupportedProvider)
     }
@@ -1643,14 +1647,14 @@ impl<N: NodePrimitives<SignedTx: Value + SignedTransaction>> BlockReader for Sta
     fn block_with_senders_range(
         &self,
         _range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<BlockWithSenders>> {
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
         Err(ProviderError::UnsupportedProvider)
     }
 
     fn sealed_block_with_senders_range(
         &self,
         _range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<SealedBlockWithSenders>> {
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
         Err(ProviderError::UnsupportedProvider)
     }
 }
diff --git a/crates/storage/provider/src/test_utils/mock.rs b/crates/storage/provider/src/test_utils/mock.rs
index a0ecb7256cb8..a99b85af9049 100644
--- a/crates/storage/provider/src/test_utils/mock.rs
+++ b/crates/storage/provider/src/test_utils/mock.rs
@@ -470,6 +470,8 @@ impl BlockIdReader for MockEthProvider {
 }
 
 impl BlockReader for MockEthProvider {
+    type Block = Block;
+
     fn find_block_by_hash(
         &self,
         hash: B256,
diff --git a/crates/storage/provider/src/test_utils/noop.rs b/crates/storage/provider/src/test_utils/noop.rs
index 9a88c8c9ab74..892965fbff2e 100644
--- a/crates/storage/provider/src/test_utils/noop.rs
+++ b/crates/storage/provider/src/test_utils/noop.rs
@@ -22,8 +22,8 @@ use reth_db_api::models::{AccountBeforeTx, StoredBlockBodyIndices};
 use reth_errors::ProviderError;
 use reth_evm::ConfigureEvmEnv;
 use reth_primitives::{
-    Account, Block, BlockWithSenders, Bytecode, Receipt, SealedBlock, SealedBlockWithSenders,
-    SealedHeader, TransactionMeta, TransactionSigned,
+    Account, Block, BlockWithSenders, Bytecode, EthPrimitives, Receipt, SealedBlock,
+    SealedBlockWithSenders, SealedHeader, TransactionMeta, TransactionSigned,
 };
 use reth_prune_types::{PruneCheckpoint, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
@@ -92,6 +92,8 @@ impl BlockNumReader for NoopProvider {
 }
 
 impl BlockReader for NoopProvider {
+    type Block = Block;
+
     fn find_block_by_hash(
         &self,
         hash: B256,
@@ -558,7 +560,7 @@ impl PruneCheckpointReader for NoopProvider {
 }
 
 impl StaticFileProviderFactory for NoopProvider {
-    type Primitives = ();
+    type Primitives = EthPrimitives;
 
     fn static_file_provider(&self) -> StaticFileProvider<Self::Primitives> {
         StaticFileProvider::read_only(PathBuf::default(), false).unwrap()
diff --git a/crates/storage/provider/src/traits/full.rs b/crates/storage/provider/src/traits/full.rs
index 9bb357e33a3c..2735859e3a8a 100644
--- a/crates/storage/provider/src/traits/full.rs
+++ b/crates/storage/provider/src/traits/full.rs
@@ -7,13 +7,13 @@ use crate::{
 };
 use reth_chain_state::{CanonStateSubscriptions, ForkChoiceSubscriptions};
 use reth_chainspec::EthereumHardforks;
-use reth_node_types::{NodeTypesWithDB, TxTy};
+use reth_node_types::{BlockTy, NodeTypesWithDB, TxTy};
 
 /// Helper trait to unify all provider traits for simplicity.
 pub trait FullProvider<N: NodeTypesWithDB>:
     DatabaseProviderFactory<DB = N::DB>
     + StaticFileProviderFactory<Primitives = N::Primitives>
-    + BlockReaderIdExt<Transaction = TxTy<N>>
+    + BlockReaderIdExt<Transaction = TxTy<N>, Block = BlockTy<N>>
     + AccountReader
     + StateProviderFactory
     + EvmEnvProvider
@@ -31,7 +31,7 @@ pub trait FullProvider<N: NodeTypesWithDB>:
 impl<T, N: NodeTypesWithDB> FullProvider<N> for T where
     T: DatabaseProviderFactory<DB = N::DB>
         + StaticFileProviderFactory<Primitives = N::Primitives>
-        + BlockReaderIdExt<Transaction = TxTy<N>>
+        + BlockReaderIdExt<Transaction = TxTy<N>, Block = BlockTy<N>>
         + AccountReader
         + StateProviderFactory
         + EvmEnvProvider
diff --git a/crates/storage/storage-api/src/block.rs b/crates/storage/storage-api/src/block.rs
index 37c7857f1c25..b9fe4a63fc92 100644
--- a/crates/storage/storage-api/src/block.rs
+++ b/crates/storage/storage-api/src/block.rs
@@ -7,7 +7,7 @@ use alloy_eips::{BlockHashOrNumber, BlockId, BlockNumberOrTag};
 use alloy_primitives::{BlockNumber, B256};
 use reth_db_models::StoredBlockBodyIndices;
 use reth_primitives::{
-    Block, BlockWithSenders, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
+    BlockWithSenders, Receipt, SealedBlockFor, SealedBlockWithSenders, SealedHeader,
 };
 use reth_storage_errors::provider::ProviderResult;
 use std::ops::RangeInclusive;
@@ -47,7 +47,6 @@ impl BlockSource {
 ///
 /// If not requested otherwise, implementers of this trait should prioritize fetching blocks from
 /// the database.
-#[auto_impl::auto_impl(&, Arc)]
 pub trait BlockReader:
     BlockNumReader
     + HeaderProvider
@@ -57,32 +56,46 @@ pub trait BlockReader:
     + Send
     + Sync
 {
+    /// The block type this provider reads.
+    type Block: reth_primitives_traits::Block<
+        Body: reth_primitives_traits::BlockBody<Transaction = Self::Transaction>,
+    >;
+
     /// Tries to find in the given block source.
     ///
     /// Note: this only operates on the hash because the number might be ambiguous.
     ///
     /// Returns `None` if block is not found.
-    fn find_block_by_hash(&self, hash: B256, source: BlockSource) -> ProviderResult<Option<Block>>;
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>>;
 
     /// Returns the block with given id from the database.
     ///
     /// Returns `None` if block is not found.
-    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>>;
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>>;
 
     /// Returns the pending block if available
     ///
-    /// Note: This returns a [SealedBlock] because it's expected that this is sealed by the provider
-    /// and the caller does not know the hash.
-    fn pending_block(&self) -> ProviderResult<Option<SealedBlock>>;
+    /// Note: This returns a [`SealedBlock`] because it's expected that this is sealed by the
+    /// provider and the caller does not know the hash.
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>>;
 
     /// Returns the pending block if available
     ///
-    /// Note: This returns a [SealedBlockWithSenders] because it's expected that this is sealed by
+    /// Note: This returns a [`SealedBlockWithSenders`] because it's expected that this is sealed by
     /// the provider and the caller does not know the hash.
-    fn pending_block_with_senders(&self) -> ProviderResult<Option<SealedBlockWithSenders>>;
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>>;
 
     /// Returns the pending block and receipts if available.
-    fn pending_block_and_receipts(&self) -> ProviderResult<Option<(SealedBlock, Vec<Receipt>)>>;
+    #[allow(clippy::type_complexity)]
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>>;
 
     /// Returns the ommers/uncle headers of the given block from the database.
     ///
@@ -92,14 +105,14 @@ pub trait BlockReader:
     /// Returns the block with matching hash from the database.
     ///
     /// Returns `None` if block is not found.
-    fn block_by_hash(&self, hash: B256) -> ProviderResult<Option<Block>> {
+    fn block_by_hash(&self, hash: B256) -> ProviderResult<Option<Self::Block>> {
         self.block(hash.into())
     }
 
     /// Returns the block with matching number from database.
     ///
     /// Returns `None` if block is not found.
-    fn block_by_number(&self, num: u64) -> ProviderResult<Option<Block>> {
+    fn block_by_number(&self, num: u64) -> ProviderResult<Option<Self::Block>> {
         self.block(num.into())
     }
 
@@ -117,7 +130,7 @@ pub trait BlockReader:
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>>;
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>>;
 
     /// Returns the sealed block with senders with matching number or hash from database.
     ///
@@ -128,26 +141,164 @@ pub trait BlockReader:
         &self,
         id: BlockHashOrNumber,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<SealedBlockWithSenders>>;
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>>;
 
     /// Returns all blocks in the given inclusive range.
     ///
     /// Note: returns only available blocks
-    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Block>>;
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>>;
 
     /// Returns a range of blocks from the database, along with the senders of each
     /// transaction in the blocks.
     fn block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<BlockWithSenders>>;
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>>;
 
     /// Returns a range of sealed blocks from the database, along with the senders of each
     /// transaction in the blocks.
     fn sealed_block_with_senders_range(
         &self,
         range: RangeInclusive<BlockNumber>,
-    ) -> ProviderResult<Vec<SealedBlockWithSenders>>;
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>>;
+}
+
+impl<T: BlockReader> BlockReader for std::sync::Arc<T> {
+    type Block = T::Block;
+
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>> {
+        T::find_block_by_hash(self, hash, source)
+    }
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
+        T::block(self, id)
+    }
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
+        T::pending_block(self)
+    }
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
+        T::pending_block_with_senders(self)
+    }
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
+        T::pending_block_and_receipts(self)
+    }
+    fn ommers(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Vec<Header>>> {
+        T::ommers(self, id)
+    }
+    fn block_by_hash(&self, hash: B256) -> ProviderResult<Option<Self::Block>> {
+        T::block_by_hash(self, hash)
+    }
+    fn block_by_number(&self, num: u64) -> ProviderResult<Option<Self::Block>> {
+        T::block_by_number(self, num)
+    }
+    fn block_body_indices(&self, num: u64) -> ProviderResult<Option<StoredBlockBodyIndices>> {
+        T::block_body_indices(self, num)
+    }
+    fn block_with_senders(
+        &self,
+        id: BlockHashOrNumber,
+        transaction_kind: TransactionVariant,
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
+        T::block_with_senders(self, id, transaction_kind)
+    }
+    fn sealed_block_with_senders(
+        &self,
+        id: BlockHashOrNumber,
+        transaction_kind: TransactionVariant,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
+        T::sealed_block_with_senders(self, id, transaction_kind)
+    }
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
+        T::block_range(self, range)
+    }
+    fn block_with_senders_range(
+        &self,
+        range: RangeInclusive<BlockNumber>,
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
+        T::block_with_senders_range(self, range)
+    }
+    fn sealed_block_with_senders_range(
+        &self,
+        range: RangeInclusive<BlockNumber>,
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
+        T::sealed_block_with_senders_range(self, range)
+    }
+}
+
+impl<T: BlockReader> BlockReader for &T {
+    type Block = T::Block;
+
+    fn find_block_by_hash(
+        &self,
+        hash: B256,
+        source: BlockSource,
+    ) -> ProviderResult<Option<Self::Block>> {
+        T::find_block_by_hash(self, hash, source)
+    }
+    fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Self::Block>> {
+        T::block(self, id)
+    }
+    fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>> {
+        T::pending_block(self)
+    }
+    fn pending_block_with_senders(
+        &self,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
+        T::pending_block_with_senders(self)
+    }
+    fn pending_block_and_receipts(
+        &self,
+    ) -> ProviderResult<Option<(SealedBlockFor<Self::Block>, Vec<Receipt>)>> {
+        T::pending_block_and_receipts(self)
+    }
+    fn ommers(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Vec<Header>>> {
+        T::ommers(self, id)
+    }
+    fn block_by_hash(&self, hash: B256) -> ProviderResult<Option<Self::Block>> {
+        T::block_by_hash(self, hash)
+    }
+    fn block_by_number(&self, num: u64) -> ProviderResult<Option<Self::Block>> {
+        T::block_by_number(self, num)
+    }
+    fn block_body_indices(&self, num: u64) -> ProviderResult<Option<StoredBlockBodyIndices>> {
+        T::block_body_indices(self, num)
+    }
+    fn block_with_senders(
+        &self,
+        id: BlockHashOrNumber,
+        transaction_kind: TransactionVariant,
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
+        T::block_with_senders(self, id, transaction_kind)
+    }
+    fn sealed_block_with_senders(
+        &self,
+        id: BlockHashOrNumber,
+        transaction_kind: TransactionVariant,
+    ) -> ProviderResult<Option<SealedBlockWithSenders<Self::Block>>> {
+        T::sealed_block_with_senders(self, id, transaction_kind)
+    }
+    fn block_range(&self, range: RangeInclusive<BlockNumber>) -> ProviderResult<Vec<Self::Block>> {
+        T::block_range(self, range)
+    }
+    fn block_with_senders_range(
+        &self,
+        range: RangeInclusive<BlockNumber>,
+    ) -> ProviderResult<Vec<BlockWithSenders<Self::Block>>> {
+        T::block_with_senders_range(self, range)
+    }
+    fn sealed_block_with_senders_range(
+        &self,
+        range: RangeInclusive<BlockNumber>,
+    ) -> ProviderResult<Vec<SealedBlockWithSenders<Self::Block>>> {
+        T::sealed_block_with_senders_range(self, range)
+    }
 }
 
 /// Trait extension for `BlockReader`, for types that implement `BlockId` conversion.
@@ -160,12 +311,11 @@ pub trait BlockReader:
 /// so this trait can only be implemented for types that implement `BlockIdReader`. The
 /// `BlockIdReader` methods should be used to resolve `BlockId`s to block numbers or hashes, and
 /// retrieving the block should be done using the type's `BlockReader` methods.
-#[auto_impl::auto_impl(&, Arc)]
 pub trait BlockReaderIdExt: BlockReader + ReceiptProviderIdExt {
     /// Returns the block with matching tag from the database
     ///
     /// Returns `None` if block is not found.
-    fn block_by_number_or_tag(&self, id: BlockNumberOrTag) -> ProviderResult<Option<Block>> {
+    fn block_by_number_or_tag(&self, id: BlockNumberOrTag) -> ProviderResult<Option<Self::Block>> {
         self.convert_block_number(id)?.map_or_else(|| Ok(None), |num| self.block(num.into()))
     }
 
@@ -204,7 +354,7 @@ pub trait BlockReaderIdExt: BlockReader + ReceiptProviderIdExt {
     /// Returns the block with the matching [`BlockId`] from the database.
     ///
     /// Returns `None` if block is not found.
-    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Block>>;
+    fn block_by_id(&self, id: BlockId) -> ProviderResult<Option<Self::Block>>;
 
     /// Returns the block with senders with matching [`BlockId`].
     ///
@@ -215,7 +365,7 @@ pub trait BlockReaderIdExt: BlockReader + ReceiptProviderIdExt {
         &self,
         id: BlockId,
         transaction_kind: TransactionVariant,
-    ) -> ProviderResult<Option<BlockWithSenders>> {
+    ) -> ProviderResult<Option<BlockWithSenders<Self::Block>>> {
         match id {
             BlockId::Hash(hash) => {
                 self.block_with_senders(hash.block_hash.into(), transaction_kind)
diff --git a/crates/storage/storage-api/src/chain.rs b/crates/storage/storage-api/src/chain.rs
index baee2f870a99..9b9c24c68633 100644
--- a/crates/storage/storage-api/src/chain.rs
+++ b/crates/storage/storage-api/src/chain.rs
@@ -74,6 +74,7 @@ impl<T, Provider, Primitives: FullNodePrimitives> ChainStorageReader<Provider, P
     T: BlockBodyReader<Provider, Block = Primitives::Block>
 {
 }
+
 /// Ethereum storage implementation.
 #[derive(Debug, Default, Clone, Copy)]
 pub struct EthStorage;
diff --git a/examples/custom-payload-builder/src/generator.rs b/examples/custom-payload-builder/src/generator.rs
index 14001d147f2c..da48a0754f9c 100644
--- a/examples/custom-payload-builder/src/generator.rs
+++ b/examples/custom-payload-builder/src/generator.rs
@@ -48,7 +48,11 @@ impl<Client, Pool, Tasks, Builder> EmptyBlockPayloadJobGenerator<Client, Pool, T
 impl<Client, Pool, Tasks, Builder> PayloadJobGenerator
     for EmptyBlockPayloadJobGenerator<Client, Pool, Tasks, Builder>
 where
-    Client: StateProviderFactory + BlockReaderIdExt + Clone + Unpin + 'static,
+    Client: StateProviderFactory
+        + BlockReaderIdExt<Block = reth_primitives::Block>
+        + Clone
+        + Unpin
+        + 'static,
     Pool: TransactionPool + Unpin + 'static,
     Tasks: TaskSpawner + Clone + Unpin + 'static,
     Builder: PayloadBuilder<Pool, Client> + Unpin + 'static,
diff --git a/examples/custom-payload-builder/src/main.rs b/examples/custom-payload-builder/src/main.rs
index e46b969adaa1..6047da0dd1ba 100644
--- a/examples/custom-payload-builder/src/main.rs
+++ b/examples/custom-payload-builder/src/main.rs
@@ -24,6 +24,7 @@ use reth_chainspec::ChainSpec;
 use reth_node_api::NodeTypesWithEngine;
 use reth_node_ethereum::{node::EthereumAddOns, EthEngineTypes, EthEvmConfig, EthereumNode};
 use reth_payload_builder::PayloadBuilderService;
+use reth_primitives::EthPrimitives;
 
 pub mod generator;
 pub mod job;
@@ -34,7 +35,13 @@ pub struct CustomPayloadBuilder;
 
 impl<Node, Pool> PayloadServiceBuilder<Node, Pool> for CustomPayloadBuilder
 where
-    Node: FullNodeTypes<Types: NodeTypesWithEngine<Engine = EthEngineTypes, ChainSpec = ChainSpec>>,
+    Node: FullNodeTypes<
+        Types: NodeTypesWithEngine<
+            Engine = EthEngineTypes,
+            ChainSpec = ChainSpec,
+            Primitives = EthPrimitives,
+        >,
+    >,
     Pool: TransactionPool + Unpin + 'static,
 {
     async fn spawn_payload_service(
diff --git a/examples/db-access/src/main.rs b/examples/db-access/src/main.rs
index e2955d01768d..1fbf833293dc 100644
--- a/examples/db-access/src/main.rs
+++ b/examples/db-access/src/main.rs
@@ -119,7 +119,10 @@ fn txs_provider_example<T: TransactionsProvider<Transaction = TransactionSigned>
 }
 
 /// The `BlockReader` allows querying the headers-related tables.
-fn block_provider_example<T: BlockReader>(provider: T, number: u64) -> eyre::Result<()> {
+fn block_provider_example<T: BlockReader<Block = reth_primitives::Block>>(
+    provider: T,
+    number: u64,
+) -> eyre::Result<()> {
     // Can query a block by number
     let block = provider.block(number.into())?.ok_or(eyre::eyre!("block num not found"))?;
     assert_eq!(block.number, number);
diff --git a/examples/rpc-db/src/myrpc_ext.rs b/examples/rpc-db/src/myrpc_ext.rs
index e38b6fc24d37..6cc7a4142f5f 100644
--- a/examples/rpc-db/src/myrpc_ext.rs
+++ b/examples/rpc-db/src/myrpc_ext.rs
@@ -22,7 +22,7 @@ pub struct MyRpcExt<Provider> {
 
 impl<Provider> MyRpcExtApiServer for MyRpcExt<Provider>
 where
-    Provider: BlockReaderIdExt + 'static,
+    Provider: BlockReaderIdExt<Block = reth::primitives::Block> + 'static,
 {
     /// Showcasing how to implement a custom rpc method
     /// using the provider.

From bdd962e6b6cbf0abd8c4bfe9611abb83e87a6c88 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 14:32:40 +0400
Subject: [PATCH 11/15] fix

---
 crates/storage/storage-api/src/block.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/storage/storage-api/src/block.rs b/crates/storage/storage-api/src/block.rs
index b9fe4a63fc92..494a7e5aa411 100644
--- a/crates/storage/storage-api/src/block.rs
+++ b/crates/storage/storage-api/src/block.rs
@@ -79,7 +79,7 @@ pub trait BlockReader:
 
     /// Returns the pending block if available
     ///
-    /// Note: This returns a [`SealedBlock`] because it's expected that this is sealed by the
+    /// Note: This returns a [`SealedBlockFor`] because it's expected that this is sealed by the
     /// provider and the caller does not know the hash.
     fn pending_block(&self) -> ProviderResult<Option<SealedBlockFor<Self::Block>>>;
 

From 37f704cb4b8189367fff6eff48d3b722294d0790 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 15:45:40 +0400
Subject: [PATCH 12/15] fix docs

---
 crates/rpc/rpc-builder/src/lib.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/crates/rpc/rpc-builder/src/lib.rs b/crates/rpc/rpc-builder/src/lib.rs
index 51bf40ecbada..0f850f0457a2 100644
--- a/crates/rpc/rpc-builder/src/lib.rs
+++ b/crates/rpc/rpc-builder/src/lib.rs
@@ -37,8 +37,9 @@
 //!     block_executor: BlockExecutor,
 //!     consensus: Consensus,
 //! ) where
-//!     Provider:
-//!         FullRpcProvider<Transaction = TransactionSigned> + AccountReader + ChangeSetReader,
+//!     Provider: FullRpcProvider<Transaction = TransactionSigned, Block = reth_primitives::Block>
+//!         + AccountReader
+//!         + ChangeSetReader,
 //!     Pool: TransactionPool + Unpin + 'static,
 //!     Network: NetworkInfo + Peers + Clone + 'static,
 //!     Events: CanonStateSubscriptions + Clone + 'static,
@@ -112,8 +113,9 @@
 //!     block_executor: BlockExecutor,
 //!     consensus: Consensus,
 //! ) where
-//!     Provider:
-//!         FullRpcProvider<Transaction = TransactionSigned> + AccountReader + ChangeSetReader,
+//!     Provider: FullRpcProvider<Transaction = TransactionSigned, Block = reth_primitives::Block>
+//!         + AccountReader
+//!         + ChangeSetReader,
 //!     Pool: TransactionPool + Unpin + 'static,
 //!     Network: NetworkInfo + Peers + Clone + 'static,
 //!     Events: CanonStateSubscriptions + Clone + 'static,

From d05239c01f61f0db5460de0f6a860b43c11791b4 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 15:58:27 +0400
Subject: [PATCH 13/15] fix book

---
 book/sources/exex/hello-world/src/bin/3.rs    | 4 +++-
 book/sources/exex/remote/src/exex.rs          | 4 +++-
 book/sources/exex/remote/src/exex_4.rs        | 4 +++-
 book/sources/exex/tracking-state/src/bin/1.rs | 4 +++-
 book/sources/exex/tracking-state/src/bin/2.rs | 4 +++-
 5 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/book/sources/exex/hello-world/src/bin/3.rs b/book/sources/exex/hello-world/src/bin/3.rs
index 21bd25a56dbf..7b3967cea7db 100644
--- a/book/sources/exex/hello-world/src/bin/3.rs
+++ b/book/sources/exex/hello-world/src/bin/3.rs
@@ -3,8 +3,10 @@ use reth::api::FullNodeComponents;
 use reth_exex::{ExExContext, ExExEvent, ExExNotification};
 use reth_node_ethereum::EthereumNode;
 use reth_tracing::tracing::info;
+use reth::providers::BlockReader;
+use reth::primitives::Block;
 
-async fn my_exex<Node: FullNodeComponents>(mut ctx: ExExContext<Node>) -> eyre::Result<()> {
+async fn my_exex<Node: FullNodeComponents<Provider: BlockReader<Block = Block>>>(mut ctx: ExExContext<Node>) -> eyre::Result<()> {
     while let Some(notification) = ctx.notifications.try_next().await? {
         match &notification {
             ExExNotification::ChainCommitted { new } => {
diff --git a/book/sources/exex/remote/src/exex.rs b/book/sources/exex/remote/src/exex.rs
index 1ae4785db8b8..932529caf107 100644
--- a/book/sources/exex/remote/src/exex.rs
+++ b/book/sources/exex/remote/src/exex.rs
@@ -11,6 +11,8 @@ use std::sync::Arc;
 use tokio::sync::{broadcast, mpsc};
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{transport::Server, Request, Response, Status};
+use reth::providers::BlockReader;
+use reth::primitives::Block;
 
 struct ExExService {
     notifications: Arc<broadcast::Sender<ExExNotification>>,
@@ -44,7 +46,7 @@ impl RemoteExEx for ExExService {
     }
 }
 
-async fn remote_exex<Node: FullNodeComponents>(
+async fn remote_exex<Node: FullNodeComponents<Provider: BlockReader<Block = Block>>>(
     mut ctx: ExExContext<Node>,
     notifications: Arc<broadcast::Sender<ExExNotification>>,
 ) -> eyre::Result<()> {
diff --git a/book/sources/exex/remote/src/exex_4.rs b/book/sources/exex/remote/src/exex_4.rs
index 24c7bf2c2f11..7e0ecee245f6 100644
--- a/book/sources/exex/remote/src/exex_4.rs
+++ b/book/sources/exex/remote/src/exex_4.rs
@@ -11,6 +11,8 @@ use std::sync::Arc;
 use tokio::sync::{broadcast, mpsc};
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{transport::Server, Request, Response, Status};
+use reth::providers::BlockReader;
+use reth::primitives::Block;
 
 struct ExExService {
     notifications: Arc<broadcast::Sender<ExExNotification>>,
@@ -46,7 +48,7 @@ impl RemoteExEx for ExExService {
 
 // ANCHOR: snippet
 #[allow(dead_code)]
-async fn remote_exex<Node: FullNodeComponents>(
+async fn remote_exex<Node: FullNodeComponents<Provider: BlockReader<Block = Block>>>(
     mut ctx: ExExContext<Node>,
     notifications: Arc<broadcast::Sender<ExExNotification>>,
 ) -> eyre::Result<()> {
diff --git a/book/sources/exex/tracking-state/src/bin/1.rs b/book/sources/exex/tracking-state/src/bin/1.rs
index 0d42e0791a17..246f3be91823 100644
--- a/book/sources/exex/tracking-state/src/bin/1.rs
+++ b/book/sources/exex/tracking-state/src/bin/1.rs
@@ -9,12 +9,14 @@ use reth::api::FullNodeComponents;
 use reth_exex::{ExExContext, ExExEvent, ExExNotification};
 use reth_node_ethereum::EthereumNode;
 use reth_tracing::tracing::info;
+use reth::providers::BlockReader;
+use reth::primitives::Block;
 
 struct MyExEx<Node: FullNodeComponents> {
     ctx: ExExContext<Node>,
 }
 
-impl<Node: FullNodeComponents> Future for MyExEx<Node> {
+impl<Node: FullNodeComponents<Provider: BlockReader<Block = Block>>> Future for MyExEx<Node> {
     type Output = eyre::Result<()>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
diff --git a/book/sources/exex/tracking-state/src/bin/2.rs b/book/sources/exex/tracking-state/src/bin/2.rs
index 9416810668f5..da7f3059454b 100644
--- a/book/sources/exex/tracking-state/src/bin/2.rs
+++ b/book/sources/exex/tracking-state/src/bin/2.rs
@@ -10,6 +10,8 @@ use reth::api::FullNodeComponents;
 use reth_exex::{ExExContext, ExExEvent};
 use reth_node_ethereum::EthereumNode;
 use reth_tracing::tracing::info;
+use reth::providers::BlockReader;
+use reth::primitives::Block;
 
 struct MyExEx<Node: FullNodeComponents> {
     ctx: ExExContext<Node>,
@@ -25,7 +27,7 @@ impl<Node: FullNodeComponents> MyExEx<Node> {
     }
 }
 
-impl<Node: FullNodeComponents> Future for MyExEx<Node> {
+impl<Node: FullNodeComponents<Provider: BlockReader<Block = Block>>> Future for MyExEx<Node> {
     type Output = eyre::Result<()>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

From bad113699f6a5584701b78547678b2fc10275267 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 16:40:37 +0400
Subject: [PATCH 14/15] fmt

---
 book/sources/exex/hello-world/src/bin/3.rs    | 8 ++++----
 book/sources/exex/remote/src/exex.rs          | 3 +--
 book/sources/exex/remote/src/exex_4.rs        | 3 +--
 book/sources/exex/tracking-state/src/bin/1.rs | 4 +---
 book/sources/exex/tracking-state/src/bin/2.rs | 4 +---
 5 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/book/sources/exex/hello-world/src/bin/3.rs b/book/sources/exex/hello-world/src/bin/3.rs
index 7b3967cea7db..ebeaf6c84f19 100644
--- a/book/sources/exex/hello-world/src/bin/3.rs
+++ b/book/sources/exex/hello-world/src/bin/3.rs
@@ -1,12 +1,12 @@
 use futures_util::TryStreamExt;
-use reth::api::FullNodeComponents;
+use reth::{api::FullNodeComponents, primitives::Block, providers::BlockReader};
 use reth_exex::{ExExContext, ExExEvent, ExExNotification};
 use reth_node_ethereum::EthereumNode;
 use reth_tracing::tracing::info;
-use reth::providers::BlockReader;
-use reth::primitives::Block;
 
-async fn my_exex<Node: FullNodeComponents<Provider: BlockReader<Block = Block>>>(mut ctx: ExExContext<Node>) -> eyre::Result<()> {
+async fn my_exex<Node: FullNodeComponents<Provider: BlockReader<Block = Block>>>(
+    mut ctx: ExExContext<Node>,
+) -> eyre::Result<()> {
     while let Some(notification) = ctx.notifications.try_next().await? {
         match &notification {
             ExExNotification::ChainCommitted { new } => {
diff --git a/book/sources/exex/remote/src/exex.rs b/book/sources/exex/remote/src/exex.rs
index 932529caf107..00392b4dad10 100644
--- a/book/sources/exex/remote/src/exex.rs
+++ b/book/sources/exex/remote/src/exex.rs
@@ -3,6 +3,7 @@ use remote_exex::proto::{
     self,
     remote_ex_ex_server::{RemoteExEx, RemoteExExServer},
 };
+use reth::{primitives::Block, providers::BlockReader};
 use reth_exex::{ExExContext, ExExEvent, ExExNotification};
 use reth_node_api::FullNodeComponents;
 use reth_node_ethereum::EthereumNode;
@@ -11,8 +12,6 @@ use std::sync::Arc;
 use tokio::sync::{broadcast, mpsc};
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{transport::Server, Request, Response, Status};
-use reth::providers::BlockReader;
-use reth::primitives::Block;
 
 struct ExExService {
     notifications: Arc<broadcast::Sender<ExExNotification>>,
diff --git a/book/sources/exex/remote/src/exex_4.rs b/book/sources/exex/remote/src/exex_4.rs
index 7e0ecee245f6..c37f26d739dc 100644
--- a/book/sources/exex/remote/src/exex_4.rs
+++ b/book/sources/exex/remote/src/exex_4.rs
@@ -3,6 +3,7 @@ use remote_exex::proto::{
     self,
     remote_ex_ex_server::{RemoteExEx, RemoteExExServer},
 };
+use reth::{primitives::Block, providers::BlockReader};
 use reth_exex::{ExExContext, ExExEvent, ExExNotification};
 use reth_node_api::FullNodeComponents;
 use reth_node_ethereum::EthereumNode;
@@ -11,8 +12,6 @@ use std::sync::Arc;
 use tokio::sync::{broadcast, mpsc};
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{transport::Server, Request, Response, Status};
-use reth::providers::BlockReader;
-use reth::primitives::Block;
 
 struct ExExService {
     notifications: Arc<broadcast::Sender<ExExNotification>>,
diff --git a/book/sources/exex/tracking-state/src/bin/1.rs b/book/sources/exex/tracking-state/src/bin/1.rs
index 246f3be91823..2cf43bec3a17 100644
--- a/book/sources/exex/tracking-state/src/bin/1.rs
+++ b/book/sources/exex/tracking-state/src/bin/1.rs
@@ -5,12 +5,10 @@ use std::{
 };
 
 use futures_util::{FutureExt, TryStreamExt};
-use reth::api::FullNodeComponents;
+use reth::{api::FullNodeComponents, primitives::Block, providers::BlockReader};
 use reth_exex::{ExExContext, ExExEvent, ExExNotification};
 use reth_node_ethereum::EthereumNode;
 use reth_tracing::tracing::info;
-use reth::providers::BlockReader;
-use reth::primitives::Block;
 
 struct MyExEx<Node: FullNodeComponents> {
     ctx: ExExContext<Node>,
diff --git a/book/sources/exex/tracking-state/src/bin/2.rs b/book/sources/exex/tracking-state/src/bin/2.rs
index da7f3059454b..b58d2a39c85c 100644
--- a/book/sources/exex/tracking-state/src/bin/2.rs
+++ b/book/sources/exex/tracking-state/src/bin/2.rs
@@ -6,12 +6,10 @@ use std::{
 
 use alloy_primitives::BlockNumber;
 use futures_util::{FutureExt, TryStreamExt};
-use reth::api::FullNodeComponents;
+use reth::{api::FullNodeComponents, primitives::Block, providers::BlockReader};
 use reth_exex::{ExExContext, ExExEvent};
 use reth_node_ethereum::EthereumNode;
 use reth_tracing::tracing::info;
-use reth::providers::BlockReader;
-use reth::primitives::Block;
 
 struct MyExEx<Node: FullNodeComponents> {
     ctx: ExExContext<Node>,

From 0bfd5d38e3ac6c49154e14f40816d4ba9c0913a7 Mon Sep 17 00:00:00 2001
From: Arsenii Kulikov <klkvrr@gmail.com>
Date: Mon, 25 Nov 2024 18:13:41 +0400
Subject: [PATCH 15/15] fix

---
 crates/storage/provider/src/providers/database/provider.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index 3781447da736..3723e2606dcc 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -48,8 +48,8 @@ use reth_execution_types::{Chain, ExecutionOutcome};
 use reth_network_p2p::headers::downloader::SyncTarget;
 use reth_node_types::{BlockTy, BodyTy, NodeTypes, TxTy};
 use reth_primitives::{
-    Account, Block, BlockBody, BlockExt, BlockWithSenders, Bytecode, GotExpected, Receipt,
-    SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
+    Account, Block, BlockExt, BlockWithSenders, Bytecode, GotExpected, Receipt, SealedBlock,
+    SealedBlockFor, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
     TransactionMeta, TransactionSignedNoHash,
 };
 use reth_primitives_traits::{Block as _, BlockBody as _, SignedTransaction};