diff --git a/Cargo.lock b/Cargo.lock
index b483fd6641db9..cd182872822ce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8083,8 +8083,8 @@ dependencies = [
  "reth-chainspec",
  "reth-db-api",
  "reth-engine-primitives",
- "reth-primitives",
  "reth-primitives-traits",
+ "reth-storage-api",
 ]
 
 [[package]]
@@ -9057,6 +9057,7 @@ dependencies = [
  "reth-db-models",
  "reth-execution-types",
  "reth-primitives",
+ "reth-primitives-traits",
  "reth-prune-types",
  "reth-stages-types",
  "reth-storage-errors",
diff --git a/crates/ethereum/node/Cargo.toml b/crates/ethereum/node/Cargo.toml
index 98224b99e26b2..a41265b72319a 100644
--- a/crates/ethereum/node/Cargo.toml
+++ b/crates/ethereum/node/Cargo.toml
@@ -31,11 +31,12 @@ reth-node-api.workspace = true
 reth-chainspec.workspace = true
 reth-primitives.workspace = true
 reth-revm = { workspace = true, features = ["std"] }
-
+reth-db.workspace = true
 # revm with required ethereum features
 revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg"] }
 
 # misc
+alloy-eips.workspace = true
 eyre.workspace = true
 
 [dev-dependencies]
diff --git a/crates/ethereum/node/src/node.rs b/crates/ethereum/node/src/node.rs
index dbd6ce0a134a4..0863ae6a3df3d 100644
--- a/crates/ethereum/node/src/node.rs
+++ b/crates/ethereum/node/src/node.rs
@@ -2,10 +2,12 @@
 
 use std::sync::Arc;
 
+use alloy_eips::BlockHashOrNumber;
 use reth_auto_seal_consensus::AutoSealConsensus;
 use reth_basic_payload_builder::{BasicPayloadJobGenerator, BasicPayloadJobGeneratorConfig};
 use reth_beacon_consensus::EthBeaconConsensus;
 use reth_chainspec::ChainSpec;
+use reth_db::transaction::{DbTx, DbTxMut};
 use reth_ethereum_engine_primitives::{
     EthBuiltPayload, EthPayloadAttributes, EthPayloadBuilderAttributes, EthereumEngineValidator,
 };
@@ -26,8 +28,11 @@ use reth_node_builder::{
     BuilderContext, Node, NodeAdapter, NodeComponentsBuilder, PayloadBuilderConfig, PayloadTypes,
 };
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
-use reth_primitives::{Block, Header};
-use reth_provider::CanonStateSubscriptions;
+use reth_primitives::{Block, BlockBody, Header};
+use reth_provider::{
+    BlockNumReader, BlockReader, CanonStateSubscriptions, ChainStorageReader, DBProvider,
+    HeaderProvider, ProviderResult, TransactionsProvider, WithdrawalsProvider,
+};
 use reth_rpc::EthApi;
 use reth_tracing::tracing::{debug, info};
 use reth_transaction_pool::{
@@ -81,6 +86,7 @@ impl EthereumNode {
 impl NodeTypes for EthereumNode {
     type Primitives = EthPrimitives;
     type ChainSpec = ChainSpec;
+    type Storage = EthStorage;
 }
 
 impl NodeTypesWithEngine for EthereumNode {
@@ -126,6 +132,61 @@ where
     }
 }
 
+/// Ethereum storage that implements [`ChainStorageReader`].
+#[derive(Debug, Default)]
+pub struct EthStorage;
+
+impl ChainStorageReader for EthStorage {
+    type Primitives = EthPrimitives;
+
+    fn read_block<P>(
+        &self,
+        provider: &P,
+        id: BlockHashOrNumber,
+    ) -> ProviderResult<Option<<Self::Primitives as NodePrimitives>::Block>>
+    where
+        P: DBProvider<Tx: DbTx>
+            + TransactionsProvider
+            + BlockReader
+            + WithdrawalsProvider
+            + HeaderProvider
+            + BlockNumReader,
+    {
+        if let Some(number) = provider.convert_hash_or_number(id)? {
+            if let Some(header) = provider.header_by_number(number)? {
+                let withdrawals = provider.withdrawals_by_block(number.into(), header.timestamp)?;
+                let ommers = provider.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 provider.transactions_by_block(number.into())? {
+                    Some(transactions) => transactions,
+                    None => return Ok(None),
+                };
+
+                return Ok(Some(Block {
+                    header,
+                    body: BlockBody { transactions, ommers, withdrawals },
+                }))
+            }
+        }
+
+        Ok(None)
+    }
+
+    fn write_block<P>(
+        &self,
+        _provider: &P,
+        _block: &<Self::Primitives as NodePrimitives>::Block,
+    ) -> ProviderResult<()>
+    where
+        P: DBProvider<Tx: DbTxMut>,
+    {
+        todo!()
+    }
+}
+
 /// A regular ethereum evm and executor builder.
 #[derive(Debug, Default, Clone, Copy)]
 #[non_exhaustive]
diff --git a/crates/exex/test-utils/src/lib.rs b/crates/exex/test-utils/src/lib.rs
index 1f6ea75ce6d91..3f075449dba77 100644
--- a/crates/exex/test-utils/src/lib.rs
+++ b/crates/exex/test-utils/src/lib.rs
@@ -119,6 +119,7 @@ pub struct TestNode;
 impl NodeTypes for TestNode {
     type Primitives = ();
     type ChainSpec = ChainSpec;
+    type Storage = ();
 }
 
 impl NodeTypesWithEngine for TestNode {
diff --git a/crates/node/builder/src/node.rs b/crates/node/builder/src/node.rs
index 3b2f467d61c0e..0111b4138d59d 100644
--- a/crates/node/builder/src/node.rs
+++ b/crates/node/builder/src/node.rs
@@ -69,6 +69,8 @@ where
     type Primitives = <N::Types as NodeTypes>::Primitives;
 
     type ChainSpec = <N::Types as NodeTypes>::ChainSpec;
+
+    type Storage = <N::Types as NodeTypes>::Storage;
 }
 
 impl<N, C, AO> NodeTypesWithEngine for AnyNode<N, C, AO>
diff --git a/crates/node/types/Cargo.toml b/crates/node/types/Cargo.toml
index 5747abe9c34b3..664f17bddf9a3 100644
--- a/crates/node/types/Cargo.toml
+++ b/crates/node/types/Cargo.toml
@@ -15,5 +15,5 @@ workspace = true
 reth-chainspec.workspace = true
 reth-db-api.workspace = true
 reth-engine-primitives.workspace = true
-reth-primitives.workspace = true
 reth-primitives-traits.workspace = true
+reth-storage-api.workspace =true
diff --git a/crates/node/types/src/lib.rs b/crates/node/types/src/lib.rs
index 5ba03e6795aba..436560547afea 100644
--- a/crates/node/types/src/lib.rs
+++ b/crates/node/types/src/lib.rs
@@ -8,7 +8,8 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
-pub use reth_primitives_traits::{Block, BlockBody};
+pub use reth_primitives_traits::{Block, BlockBody, NodePrimitives};
+use reth_storage_api::ChainStorageReader;
 
 use std::marker::PhantomData;
 
@@ -19,16 +20,6 @@ use reth_db_api::{
 };
 use reth_engine_primitives::EngineTypes;
 
-/// Configures all the primitive types of the node.
-pub trait NodePrimitives {
-    /// Block primitive.
-    type Block;
-}
-
-impl NodePrimitives for () {
-    type Block = reth_primitives::Block;
-}
-
 /// The type that configures the essential types of an Ethereum-like node.
 ///
 /// This includes the primitive types of a node and chain specification.
@@ -39,6 +30,8 @@ pub trait NodeTypes: Send + Sync + Unpin + 'static {
     type Primitives: NodePrimitives;
     /// The type used for configuration of the EVM.
     type ChainSpec: EthChainSpec;
+    /// The type used for reading chain specific types from storage.
+    type Storage: ChainStorageReader<Primitives = Self::Primitives>;
 }
 
 /// The type that configures an Ethereum-like node with an engine for consensus.
@@ -89,6 +82,7 @@ where
 {
     type Primitives = Types::Primitives;
     type ChainSpec = Types::ChainSpec;
+    type Storage = Types::Storage;
 }
 
 impl<Types, DB> NodeTypesWithEngine for NodeTypesWithDBAdapter<Types, DB>
@@ -109,34 +103,41 @@ where
 
 /// A [`NodeTypes`] type builder.
 #[derive(Default, Debug)]
-pub struct AnyNodeTypes<P = (), C = ()>(PhantomData<P>, PhantomData<C>);
+pub struct AnyNodeTypes<P = (), C = (), S = ()>(PhantomData<P>, PhantomData<C>, PhantomData<S>);
 
-impl<P, C> AnyNodeTypes<P, C> {
+impl<P, C, S> AnyNodeTypes<P, C, S> {
     /// Sets the `Primitives` associated type.
-    pub const fn primitives<T>(self) -> AnyNodeTypes<T, C> {
-        AnyNodeTypes::<T, C>(PhantomData::<T>, PhantomData::<C>)
+    pub const fn primitives<T>(self) -> AnyNodeTypes<T, C, S> {
+        AnyNodeTypes::<T, C, S>(PhantomData::<T>, PhantomData::<C>, PhantomData::<S>)
     }
 
     /// Sets the `ChainSpec` associated type.
-    pub const fn chain_spec<T>(self) -> AnyNodeTypes<P, T> {
-        AnyNodeTypes::<P, T>(PhantomData::<P>, PhantomData::<T>)
+    pub const fn chain_spec<T>(self) -> AnyNodeTypes<P, T, S> {
+        AnyNodeTypes::<P, T, S>(PhantomData::<P>, PhantomData::<T>, PhantomData::<S>)
+    }
+
+    /// Sets the `Storage` associated type.
+    pub const fn storage<T>(self) -> AnyNodeTypes<P, C, T> {
+        AnyNodeTypes::<P, C, T>(PhantomData::<P>, PhantomData::<C>, PhantomData::<T>)
     }
 }
 
-impl<P, C> NodeTypes for AnyNodeTypes<P, C>
+impl<P, C, S> NodeTypes for AnyNodeTypes<P, C, S>
 where
     P: NodePrimitives + Send + Sync + Unpin + 'static,
     C: EthChainSpec + 'static,
+    S: ChainStorageReader<Primitives = P> + 'static,
 {
     type Primitives = P;
     type ChainSpec = C;
+    type Storage = S;
 }
 
 /// A [`NodeTypesWithEngine`] type builder.
 #[derive(Default, Debug)]
-pub struct AnyNodeTypesWithEngine<P = (), E = (), C = ()> {
+pub struct AnyNodeTypesWithEngine<P = (), E = (), C = (), S = ()> {
     /// Embedding the basic node types.
-    base: AnyNodeTypes<P, C>,
+    base: AnyNodeTypes<P, C, S>,
     /// Phantom data for the engine.
     _engine: PhantomData<E>,
 }
@@ -156,23 +157,31 @@ impl<P, E, C> AnyNodeTypesWithEngine<P, E, C> {
     pub const fn chain_spec<T>(self) -> AnyNodeTypesWithEngine<P, E, T> {
         AnyNodeTypesWithEngine { base: self.base.chain_spec::<T>(), _engine: PhantomData }
     }
+
+    /// Sets the `Storage` associated type.
+    pub const fn storage<T>(self) -> AnyNodeTypesWithEngine<P, E, C, T> {
+        AnyNodeTypesWithEngine { base: self.base.storage::<T>(), _engine: PhantomData }
+    }
 }
 
-impl<P, E, C> NodeTypes for AnyNodeTypesWithEngine<P, E, C>
+impl<P, E, C, S> NodeTypes for AnyNodeTypesWithEngine<P, E, C, S>
 where
     P: NodePrimitives + Send + Sync + Unpin + 'static,
     E: EngineTypes + Send + Sync + Unpin,
     C: EthChainSpec + 'static,
+    S: ChainStorageReader<Primitives = P> + 'static,
 {
     type Primitives = P;
     type ChainSpec = C;
+    type Storage = S;
 }
 
-impl<P, E, C> NodeTypesWithEngine for AnyNodeTypesWithEngine<P, E, C>
+impl<P, E, C, S> NodeTypesWithEngine for AnyNodeTypesWithEngine<P, E, C, S>
 where
     P: NodePrimitives + Send + Sync + Unpin + 'static,
     E: EngineTypes + Send + Sync + Unpin,
     C: EthChainSpec + 'static,
+    S: ChainStorageReader<Primitives = P> + 'static,
 {
     type Engine = E;
 }
diff --git a/crates/optimism/node/Cargo.toml b/crates/optimism/node/Cargo.toml
index 37cf4a328ea00..2374a29e0f0a8 100644
--- a/crates/optimism/node/Cargo.toml
+++ b/crates/optimism/node/Cargo.toml
@@ -28,6 +28,7 @@ reth-network.workspace = true
 reth-evm.workspace = true
 reth-revm = { workspace = true, features = ["std"] }
 reth-beacon-consensus.workspace = true
+reth-db.workspace = true
 
 # op-reth
 reth-optimism-payload-builder.workspace = true
diff --git a/crates/optimism/node/src/node.rs b/crates/optimism/node/src/node.rs
index 9492bb8c429a8..dff91e1342da7 100644
--- a/crates/optimism/node/src/node.rs
+++ b/crates/optimism/node/src/node.rs
@@ -2,8 +2,10 @@
 
 use std::sync::Arc;
 
+use alloy_eips::BlockHashOrNumber;
 use reth_basic_payload_builder::{BasicPayloadJobGenerator, BasicPayloadJobGeneratorConfig};
 use reth_chainspec::{EthChainSpec, Hardforks};
+use reth_db::transaction::{DbTx, DbTxMut};
 use reth_evm::{execute::BasicBlockExecutorProvider, ConfigureEvm};
 use reth_network::{NetworkConfig, NetworkHandle, NetworkManager, PeersInfo};
 use reth_node_api::{
@@ -23,8 +25,11 @@ use reth_optimism_consensus::OptimismBeaconConsensus;
 use reth_optimism_evm::{OpExecutionStrategyFactory, OptimismEvmConfig};
 use reth_optimism_rpc::OpEthApi;
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
-use reth_primitives::{Block, Header};
-use reth_provider::CanonStateSubscriptions;
+use reth_primitives::{Block, BlockBody, Header};
+use reth_provider::{
+    BlockNumReader, BlockReader, CanonStateSubscriptions, ChainStorageReader, DBProvider,
+    HeaderProvider, ProviderResult, TransactionsProvider, WithdrawalsProvider,
+};
 use reth_tracing::tracing::{debug, info};
 use reth_transaction_pool::{
     blobstore::DiskFileBlobStore, CoinbaseTipOrdering, TransactionPool,
@@ -122,12 +127,68 @@ where
 impl NodeTypes for OptimismNode {
     type Primitives = OpPrimitives;
     type ChainSpec = OpChainSpec;
+    type Storage = OpStorage;
 }
 
 impl NodeTypesWithEngine for OptimismNode {
     type Engine = OptimismEngineTypes;
 }
 
+/// Ethereum storage that implements [`ChainStorageReader`].
+#[derive(Debug, Default)]
+pub struct OpStorage;
+
+impl ChainStorageReader for OpStorage {
+    type Primitives = OpPrimitives;
+
+    fn read_block<P>(
+        &self,
+        provider: &P,
+        id: BlockHashOrNumber,
+    ) -> ProviderResult<Option<<Self::Primitives as NodePrimitives>::Block>>
+    where
+        P: DBProvider<Tx: DbTx>
+            + TransactionsProvider
+            + BlockReader
+            + WithdrawalsProvider
+            + HeaderProvider
+            + BlockNumReader,
+    {
+        if let Some(number) = provider.convert_hash_or_number(id)? {
+            if let Some(header) = provider.header_by_number(number)? {
+                let withdrawals = provider.withdrawals_by_block(number.into(), header.timestamp)?;
+                let ommers = provider.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 provider.transactions_by_block(number.into())? {
+                    Some(transactions) => transactions,
+                    None => return Ok(None),
+                };
+
+                return Ok(Some(Block {
+                    header,
+                    body: BlockBody { transactions, ommers, withdrawals },
+                }))
+            }
+        }
+
+        Ok(None)
+    }
+
+    fn write_block<P>(
+        &self,
+        _provider: &P,
+        _block: &<Self::Primitives as NodePrimitives>::Block,
+    ) -> ProviderResult<()>
+    where
+        P: DBProvider<Tx: DbTxMut>,
+    {
+        todo!()
+    }
+}
+
 /// Add-ons w.r.t. optimism.
 #[derive(Debug)]
 pub struct OptimismAddOns<N: FullNodeComponents>(
diff --git a/crates/primitives-traits/src/lib.rs b/crates/primitives-traits/src/lib.rs
index 57d1119b03515..23cd63d4a4270 100644
--- a/crates/primitives-traits/src/lib.rs
+++ b/crates/primitives-traits/src/lib.rs
@@ -44,6 +44,9 @@ pub use alloy_primitives::{logs_bloom, Log, LogData};
 mod storage;
 pub use storage::StorageEntry;
 
+mod node;
+pub use node::NodePrimitives;
+
 /// Common header types
 pub mod header;
 #[cfg(any(test, feature = "arbitrary", feature = "test-utils"))]
diff --git a/crates/primitives-traits/src/node.rs b/crates/primitives-traits/src/node.rs
new file mode 100644
index 0000000000000..d29a67ae1bf9c
--- /dev/null
+++ b/crates/primitives-traits/src/node.rs
@@ -0,0 +1,9 @@
+/// Configures all the primitive types of the node.
+pub trait NodePrimitives {
+    /// Block primitive.
+    type Block;
+}
+
+impl NodePrimitives for () {
+    type Block = ();
+}
diff --git a/crates/storage/provider/src/providers/database/mod.rs b/crates/storage/provider/src/providers/database/mod.rs
index 54186dca6f695..8f796ad856d70 100644
--- a/crates/storage/provider/src/providers/database/mod.rs
+++ b/crates/storage/provider/src/providers/database/mod.rs
@@ -10,6 +10,7 @@ use crate::{
 use alloy_eips::BlockHashOrNumber;
 use alloy_primitives::{Address, BlockHash, BlockNumber, TxHash, TxNumber, B256, U256};
 use core::fmt;
+use provider::DatabaseProvider2;
 use reth_chainspec::{ChainInfo, EthereumHardforks};
 use reth_db::{init_db, mdbx::DatabaseArguments, DatabaseEnv};
 use reth_db_api::{database::Database, models::StoredBlockBodyIndices};
@@ -53,19 +54,22 @@ pub struct ProviderFactory<N: NodeTypesWithDB> {
     static_file_provider: StaticFileProvider,
     /// Optional pruning configuration
     prune_modes: PruneModes,
+    /// Chain storage reader
+    chain_storage: Arc<N::Storage>,
 }
 
 impl<N> fmt::Debug for ProviderFactory<N>
 where
-    N: NodeTypesWithDB<DB: fmt::Debug, ChainSpec: fmt::Debug>,
+    N: NodeTypesWithDB<DB: fmt::Debug, ChainSpec: fmt::Debug, Storage: fmt::Debug>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { db, chain_spec, static_file_provider, prune_modes } = self;
+        let Self { db, chain_spec, static_file_provider, prune_modes, chain_storage } = self;
         f.debug_struct("ProviderFactory")
             .field("db", &db)
             .field("chain_spec", &chain_spec)
             .field("static_file_provider", &static_file_provider)
             .field("prune_modes", &prune_modes)
+            .field("chain_storage", &chain_storage)
             .finish()
     }
 }
@@ -77,7 +81,13 @@ impl<N: NodeTypesWithDB> ProviderFactory<N> {
         chain_spec: Arc<N::ChainSpec>,
         static_file_provider: StaticFileProvider,
     ) -> Self {
-        Self { db, chain_spec, static_file_provider, prune_modes: PruneModes::none() }
+        Self {
+            db,
+            chain_spec,
+            static_file_provider,
+            prune_modes: PruneModes::none(),
+            chain_storage: Default::default(),
+        }
     }
 
     /// Enables metrics on the static file provider.
@@ -118,6 +128,7 @@ impl<N: NodeTypesWithDB<DB = Arc<DatabaseEnv>>> ProviderFactory<N> {
             chain_spec,
             static_file_provider,
             prune_modes: PruneModes::none(),
+            chain_storage: Default::default(),
         })
     }
 }
@@ -131,12 +142,15 @@ impl<N: ProviderNodeTypes> ProviderFactory<N> {
     /// data.
     #[track_caller]
     pub fn provider(&self) -> ProviderResult<DatabaseProviderRO<N::DB, N::ChainSpec>> {
-        Ok(DatabaseProvider::new(
-            self.db.tx()?,
-            self.chain_spec.clone(),
-            self.static_file_provider.clone(),
-            self.prune_modes.clone(),
-        ))
+        let provider2: DatabaseProvider2<<<N as NodeTypesWithDB>::DB as Database>::TX, N> =
+            DatabaseProvider2::new(
+                self.db.tx()?,
+                self.chain_spec.clone(),
+                self.static_file_provider.clone(),
+                self.prune_modes.clone(),
+                self.chain_storage.clone(),
+            );
+        Ok(provider2.into_provider())
     }
 
     /// Returns a provider with a created `DbTxMut` inside, which allows fetching and updating
@@ -339,6 +353,7 @@ impl<N: ProviderNodeTypes> BlockReader for ProviderFactory<N> {
 
     fn block(&self, id: BlockHashOrNumber) -> ProviderResult<Option<Block>> {
         self.provider()?.block(id)
+        // self.chain_storage.block(&self.provider()?, id)
     }
 
     fn pending_block(&self) -> ProviderResult<Option<SealedBlock>> {
@@ -612,6 +627,7 @@ impl<N: NodeTypesWithDB> Clone for ProviderFactory<N> {
             chain_spec: self.chain_spec.clone(),
             static_file_provider: self.static_file_provider.clone(),
             prune_modes: self.prune_modes.clone(),
+            chain_storage: self.chain_storage.clone(),
         }
     }
 }
diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs
index 308fa364a3d3c..0380c6e68152c 100644
--- a/crates/storage/provider/src/providers/database/provider.rs
+++ b/crates/storage/provider/src/providers/database/provider.rs
@@ -39,6 +39,7 @@ 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;
 use reth_primitives::{
     Account, Block, BlockBody, BlockWithSenders, Bytecode, GotExpected, Header, Receipt,
     SealedBlock, SealedBlockWithSenders, SealedHeader, StaticFileSegment, StorageEntry,
@@ -124,6 +125,44 @@ impl<DB: Database, Spec> From<DatabaseProviderRW<DB, Spec>>
     }
 }
 
+/// A provider struct that fetches data from the database.
+/// Wrapper around [`DbTx`] and [`DbTxMut`]. Example: [`HeaderProvider`] [`BlockHashReader`]
+#[derive(Debug)]
+pub(crate) struct DatabaseProvider2<TX, N: NodeTypes> {
+    /// Database transaction.
+    tx: TX,
+    /// Chain spec
+    chain_spec: Arc<N::ChainSpec>,
+    /// Static File provider
+    static_file_provider: StaticFileProvider,
+    /// Pruning configuration
+    prune_modes: PruneModes,
+    /// Chain storage reader
+    #[allow(dead_code)]
+    chain_storage: Arc<N::Storage>,
+}
+
+impl<TX, N: NodeTypes> DatabaseProvider2<TX, N> {
+    pub(crate) const fn new(
+        tx: TX,
+        chain_spec: Arc<N::ChainSpec>,
+        static_file_provider: StaticFileProvider,
+        prune_modes: PruneModes,
+        chain_storage: Arc<N::Storage>,
+    ) -> Self {
+        Self { tx, chain_spec, static_file_provider, prune_modes, chain_storage }
+    }
+
+    pub(crate) fn into_provider(self) -> DatabaseProvider<TX, N::ChainSpec> {
+        DatabaseProvider {
+            tx: self.tx,
+            chain_spec: self.chain_spec,
+            static_file_provider: self.static_file_provider,
+            prune_modes: self.prune_modes,
+        }
+    }
+}
+
 /// A provider struct that fetches data from the database.
 /// Wrapper around [`DbTx`] and [`DbTxMut`]. Example: [`HeaderProvider`] [`BlockHashReader`]
 #[derive(Debug)]
diff --git a/crates/storage/storage-api/Cargo.toml b/crates/storage/storage-api/Cargo.toml
index 0ae8b284588e4..2da202cae8515 100644
--- a/crates/storage/storage-api/Cargo.toml
+++ b/crates/storage/storage-api/Cargo.toml
@@ -18,6 +18,7 @@ reth-db-models.workspace = true
 reth-db-api.workspace = true
 reth-execution-types.workspace = true
 reth-primitives.workspace = true
+reth-primitives-traits.workspace = true
 reth-prune-types.workspace = true
 reth-stages-types.workspace = true
 reth-storage-errors.workspace = true
diff --git a/crates/storage/storage-api/src/block.rs b/crates/storage/storage-api/src/block.rs
index 01238be745e28..db0bceeb0e66c 100644
--- a/crates/storage/storage-api/src/block.rs
+++ b/crates/storage/storage-api/src/block.rs
@@ -9,7 +9,7 @@ use reth_primitives::{
     Block, BlockWithSenders, Header, Receipt, SealedBlock, SealedBlockWithSenders, SealedHeader,
 };
 use reth_storage_errors::provider::ProviderResult;
-use std::ops::RangeInclusive;
+use std::{fmt::Debug, ops::RangeInclusive};
 
 /// A helper enum that represents the origin of the requested block.
 ///
diff --git a/crates/storage/storage-api/src/chain.rs b/crates/storage/storage-api/src/chain.rs
new file mode 100644
index 0000000000000..e4152259d568b
--- /dev/null
+++ b/crates/storage/storage-api/src/chain.rs
@@ -0,0 +1,71 @@
+use crate::{
+    BlockNumReader, BlockReader, DBProvider, HeaderProvider, TransactionsProvider,
+    WithdrawalsProvider,
+};
+use reth_db_api::transaction::{DbTx, DbTxMut};
+use reth_primitives::BlockHashOrNumber;
+use reth_primitives_traits::NodePrimitives;
+use reth_storage_errors::provider::ProviderResult;
+use std::fmt::Debug;
+
+/// Trait that implements how complex types (eg. Block) should be read or written to disk.
+pub trait ChainStorageReader: Send + Sync + Unpin + Default + Debug {
+    /// Primitive types of the node.
+    type Primitives: NodePrimitives;
+
+    /// Returns the block with given id from storage.
+    ///
+    /// Returns `None` if block is not found.
+    fn read_block<P>(
+        &self,
+        provider: &P,
+        id: BlockHashOrNumber,
+    ) -> ProviderResult<Option<<Self::Primitives as NodePrimitives>::Block>>
+    where
+        P: DBProvider<Tx: DbTx>
+            + TransactionsProvider
+            + BlockReader
+            + WithdrawalsProvider
+            + HeaderProvider
+            + BlockNumReader;
+
+    /// Writes block to storage.
+    fn write_block<P>(
+        &self,
+        provider: &P,
+        block: &<Self::Primitives as NodePrimitives>::Block,
+    ) -> ProviderResult<()>
+    where
+        P: DBProvider<Tx: DbTxMut>;
+}
+
+impl ChainStorageReader for () {
+    type Primitives = ();
+
+    fn read_block<P>(
+        &self,
+        _: &P,
+        _: BlockHashOrNumber,
+    ) -> ProviderResult<Option<<Self::Primitives as NodePrimitives>::Block>>
+    where
+        P: DBProvider<Tx: DbTx>
+            + TransactionsProvider
+            + BlockReader
+            + WithdrawalsProvider
+            + HeaderProvider
+            + BlockNumReader,
+    {
+        unimplemented!()
+    }
+
+    fn write_block<P>(
+        &self,
+        _: &P,
+        _: &<Self::Primitives as NodePrimitives>::Block,
+    ) -> ProviderResult<()>
+    where
+        P: DBProvider<Tx: DbTxMut>,
+    {
+        unimplemented!()
+    }
+}
diff --git a/crates/storage/storage-api/src/lib.rs b/crates/storage/storage-api/src/lib.rs
index 4e589242a91e0..b99150a91f81a 100644
--- a/crates/storage/storage-api/src/lib.rs
+++ b/crates/storage/storage-api/src/lib.rs
@@ -53,3 +53,6 @@ mod database_provider;
 pub use database_provider::*;
 
 pub mod noop;
+
+mod chain;
+pub use chain::*;
diff --git a/examples/custom-engine-types/src/main.rs b/examples/custom-engine-types/src/main.rs
index 46a7d7d9af93c..efcb83a948944 100644
--- a/examples/custom-engine-types/src/main.rs
+++ b/examples/custom-engine-types/src/main.rs
@@ -224,6 +224,7 @@ struct MyCustomNode;
 impl NodeTypes for MyCustomNode {
     type Primitives = ();
     type ChainSpec = ChainSpec;
+    type Storage = ();
 }
 
 /// Configure the node types with the custom engine types