diff --git a/crates/ethereum/node/src/node.rs b/crates/ethereum/node/src/node.rs
index 902b765ad4..037fe47351 100644
--- a/crates/ethereum/node/src/node.rs
+++ b/crates/ethereum/node/src/node.rs
@@ -435,13 +435,13 @@ where
         > + Unpin
         + 'static,
 {
-    type Primitives = EthNetworkPrimitives;
+    type Network = NetworkHandle<EthNetworkPrimitives>;
 
     async fn build_network(
         self,
         ctx: &BuilderContext<Node>,
         pool: Pool,
-    ) -> eyre::Result<NetworkHandle> {
+    ) -> eyre::Result<Self::Network> {
         let network = ctx.network_builder().await?;
         let handle = ctx.start_network(network, pool);
         info!(target: "reth::cli", enode=%handle.local_node_record(), "P2P networking initialized");
diff --git a/crates/net/eth-wire-types/src/primitives.rs b/crates/net/eth-wire-types/src/primitives.rs
index 4531e176ca..ea7813422e 100644
--- a/crates/net/eth-wire-types/src/primitives.rs
+++ b/crates/net/eth-wire-types/src/primitives.rs
@@ -7,9 +7,7 @@ use reth_primitives_traits::{Block, BlockBody, BlockHeader, NodePrimitives, Sign
 
 /// Abstraction over primitive types which might appear in network messages. See
 /// [`crate::EthMessage`] for more context.
-pub trait NetworkPrimitives:
-    Send + Sync + Unpin + Clone + Debug + PartialEq + Eq + 'static
-{
+pub trait NetworkPrimitives: Send + Sync + Unpin + Clone + Debug + 'static {
     /// The block header type.
     type BlockHeader: BlockHeader + 'static;
 
diff --git a/crates/net/network-api/src/lib.rs b/crates/net/network-api/src/lib.rs
index 1370f83ba1..662abc164c 100644
--- a/crates/net/network-api/src/lib.rs
+++ b/crates/net/network-api/src/lib.rs
@@ -24,7 +24,6 @@ pub mod test_utils;
 use test_utils::PeersHandleProvider;
 
 pub use alloy_rpc_types_admin::EthProtocolInfo;
-use reth_network_p2p::sync::NetworkSyncUpdater;
 pub use reth_network_p2p::{BlockClient, HeadersClient};
 pub use reth_network_types::{PeerKind, Reputation, ReputationChangeKind};
 
@@ -35,37 +34,41 @@ pub use events::{
     PeerRequestSender,
 };
 
-use std::{future::Future, net::SocketAddr, sync::Arc, time::Instant};
-
-use reth_eth_wire_types::{capability::Capabilities, DisconnectReason, EthVersion, Status};
+use reth_eth_wire_types::{
+    capability::Capabilities, DisconnectReason, EthVersion, NetworkPrimitives, Status,
+};
+use reth_network_p2p::sync::NetworkSyncUpdater;
 use reth_network_peers::NodeRecord;
+use std::{future::Future, net::SocketAddr, sync::Arc, time::Instant};
 
 /// The `PeerId` type.
 pub type PeerId = alloy_primitives::B512;
 
 /// Helper trait that unifies network API needed to launch node.
 pub trait FullNetwork:
-    BlockDownloaderProvider
-    + NetworkSyncUpdater
+    BlockDownloaderProvider<
+        Client: BlockClient<Block = <Self::Primitives as NetworkPrimitives>::Block>,
+    > + NetworkSyncUpdater
     + NetworkInfo
     + NetworkEventListenerProvider
-    + PeersInfo
     + Peers
     + PeersHandleProvider
     + Clone
+    + Unpin
     + 'static
 {
 }
 
 impl<T> FullNetwork for T where
-    T: BlockDownloaderProvider
-        + NetworkSyncUpdater
+    T: BlockDownloaderProvider<
+            Client: BlockClient<Block = <Self::Primitives as NetworkPrimitives>::Block>,
+        > + NetworkSyncUpdater
         + NetworkInfo
         + NetworkEventListenerProvider
-        + PeersInfo
         + Peers
         + PeersHandleProvider
         + Clone
+        + Unpin
         + 'static
 {
 }
diff --git a/crates/net/network/src/lib.rs b/crates/net/network/src/lib.rs
index 9122405e68..13352893a1 100644
--- a/crates/net/network/src/lib.rs
+++ b/crates/net/network/src/lib.rs
@@ -146,9 +146,9 @@ mod swarm;
 mod trusted_peers_resolver;
 
 pub use reth_eth_wire::{DisconnectReason, HelloMessageWithProtocols};
-pub use reth_eth_wire_types::{EthNetworkPrimitives, NetworkPrimitives};
+pub use reth_eth_wire_types::{primitives, EthNetworkPrimitives, NetworkPrimitives};
 pub use reth_network_api::{
-    BlockDownloaderProvider, DiscoveredEvent, DiscoveryEvent, NetworkEvent,
+    events, BlockDownloaderProvider, DiscoveredEvent, DiscoveryEvent, NetworkEvent,
     NetworkEventListenerProvider, NetworkInfo, PeerRequest, PeerRequestSender, Peers, PeersInfo,
 };
 pub use reth_network_p2p::sync::{NetworkSyncUpdater, SyncState};
diff --git a/crates/node/builder/src/components/builder.rs b/crates/node/builder/src/components/builder.rs
index bf60610623..57a200617d 100644
--- a/crates/node/builder/src/components/builder.rs
+++ b/crates/node/builder/src/components/builder.rs
@@ -8,9 +8,10 @@ use crate::{
     BuilderContext, ConfigureEvm, FullNodeTypes,
 };
 use reth_consensus::{ConsensusError, FullConsensus};
-use reth_network::NetworkPrimitives;
-use reth_node_api::{BlockTy, BodyTy, HeaderTy, PrimitivesTy, TxTy};
-use reth_transaction_pool::{PoolTransaction, TransactionPool};
+use reth_network::types::NetPrimitivesFor;
+use reth_network_api::FullNetwork;
+use reth_node_api::{PrimitivesTy, TxTy};
+use reth_transaction_pool::{PoolPooledTx, PoolTransaction, TransactionPool};
 use std::{future::Future, marker::PhantomData};
 
 /// A generic, general purpose and customizable [`NodeComponentsBuilder`] implementation.
@@ -295,21 +296,15 @@ impl<Node, PoolB, PayloadB, NetworkB, ExecB, ConsB> NodeComponentsBuilder<Node>
     for ComponentsBuilder<Node, PoolB, PayloadB, NetworkB, ExecB, ConsB>
 where
     Node: FullNodeTypes,
-    PoolB: PoolBuilder<
-        Node,
-        Pool: TransactionPool<
-            Transaction: PoolTransaction<
-                Pooled = <NetworkB::Primitives as NetworkPrimitives>::PooledTransaction,
-            >,
-        >,
-    >,
+    PoolB: PoolBuilder<Node, Pool: TransactionPool>,
     NetworkB: NetworkBuilder<
         Node,
         PoolB::Pool,
-        Primitives: NetworkPrimitives<
-            BlockHeader = HeaderTy<Node::Types>,
-            BlockBody = BodyTy<Node::Types>,
-            Block = BlockTy<Node::Types>,
+        Network: FullNetwork<
+            Primitives: NetPrimitivesFor<
+                PrimitivesTy<Node::Types>,
+                PooledTransaction = PoolPooledTx<PoolB::Pool>,
+            >,
         >,
     >,
     PayloadB: PayloadServiceBuilder<Node, PoolB::Pool, ExecB::EVM>,
@@ -317,7 +312,7 @@ where
     ConsB: ConsensusBuilder<Node>,
 {
     type Components =
-        Components<Node, NetworkB::Primitives, PoolB::Pool, ExecB::EVM, ConsB::Consensus>;
+        Components<Node, NetworkB::Network, PoolB::Pool, ExecB::EVM, ConsB::Consensus>;
 
     async fn build_components(
         self,
@@ -383,16 +378,17 @@ pub trait NodeComponentsBuilder<Node: FullNodeTypes>: Send {
     ) -> impl Future<Output = eyre::Result<Self::Components>> + Send;
 }
 
-impl<Node, N, F, Fut, Pool, EVM, Cons> NodeComponentsBuilder<Node> for F
+impl<Node, Net, F, Fut, Pool, EVM, Cons> NodeComponentsBuilder<Node> for F
 where
-    N: NetworkPrimitives<
-        BlockHeader = HeaderTy<Node::Types>,
-        BlockBody = BodyTy<Node::Types>,
-        Block = BlockTy<Node::Types>,
+    Net: FullNetwork<
+        Primitives: NetPrimitivesFor<
+            PrimitivesTy<Node::Types>,
+            PooledTransaction = PoolPooledTx<Pool>,
+        >,
     >,
     Node: FullNodeTypes,
     F: FnOnce(&BuilderContext<Node>) -> Fut + Send,
-    Fut: Future<Output = eyre::Result<Components<Node, N, Pool, EVM, Cons>>> + Send,
+    Fut: Future<Output = eyre::Result<Components<Node, Net, Pool, EVM, Cons>>> + Send,
     Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>>
         + Unpin
         + 'static,
@@ -400,7 +396,7 @@ where
     Cons:
         FullConsensus<PrimitivesTy<Node::Types>, Error = ConsensusError> + Clone + Unpin + 'static,
 {
-    type Components = Components<Node, N, Pool, EVM, Cons>;
+    type Components = Components<Node, Net, Pool, EVM, Cons>;
 
     fn build_components(
         self,
diff --git a/crates/node/builder/src/components/mod.rs b/crates/node/builder/src/components/mod.rs
index 28ea66d6ad..af823f9463 100644
--- a/crates/node/builder/src/components/mod.rs
+++ b/crates/node/builder/src/components/mod.rs
@@ -21,16 +21,14 @@ pub use network::*;
 pub use payload::*;
 pub use pool::*;
 
-use reth_network_p2p::BlockClient;
-use reth_payload_builder::PayloadBuilderHandle;
-use std::fmt::Debug;
-
 use crate::{ConfigureEvm, FullNodeTypes};
 use reth_consensus::{ConsensusError, FullConsensus};
-use reth_network::{NetworkHandle, NetworkPrimitives};
+use reth_network::types::NetPrimitivesFor;
 use reth_network_api::FullNetwork;
-use reth_node_api::{BlockTy, BodyTy, HeaderTy, NodeTypes, PrimitivesTy, TxTy};
-use reth_transaction_pool::{PoolTransaction, TransactionPool};
+use reth_node_api::{NodeTypes, PrimitivesTy, TxTy};
+use reth_payload_builder::PayloadBuilderHandle;
+use reth_transaction_pool::{PoolPooledTx, PoolTransaction, TransactionPool};
+use std::fmt::Debug;
 
 /// An abstraction over the components of a node, consisting of:
 ///  - evm and executor
@@ -51,7 +49,7 @@ pub trait NodeComponents<T: FullNodeTypes>: Clone + Debug + Unpin + Send + Sync
         + 'static;
 
     /// Network API.
-    type Network: FullNetwork<Client: BlockClient<Block = BlockTy<T::Types>>>;
+    type Network: FullNetwork<Primitives: NetPrimitivesFor<<T::Types as NodeTypes>::Primitives>>;
 
     /// Returns the transaction pool of the node.
     fn pool(&self) -> &Self::Pool;
@@ -74,7 +72,7 @@ pub trait NodeComponents<T: FullNodeTypes>: Clone + Debug + Unpin + Send + Sync
 ///
 /// This provides access to all the components of the node.
 #[derive(Debug)]
-pub struct Components<Node: FullNodeTypes, N: NetworkPrimitives, Pool, EVM, Consensus> {
+pub struct Components<Node: FullNodeTypes, Network, Pool, EVM, Consensus> {
     /// The transaction pool of the node.
     pub transaction_pool: Pool,
     /// The node's EVM configuration, defining settings for the Ethereum Virtual Machine.
@@ -82,18 +80,20 @@ pub struct Components<Node: FullNodeTypes, N: NetworkPrimitives, Pool, EVM, Cons
     /// The consensus implementation of the node.
     pub consensus: Consensus,
     /// The network implementation of the node.
-    pub network: NetworkHandle<N>,
+    pub network: Network,
     /// The handle to the payload builder service.
     pub payload_builder_handle: PayloadBuilderHandle<<Node::Types as NodeTypes>::Payload>,
 }
 
-impl<Node, Pool, EVM, Cons, N> NodeComponents<Node> for Components<Node, N, Pool, EVM, Cons>
+impl<Node, Pool, EVM, Cons, Network> NodeComponents<Node>
+    for Components<Node, Network, Pool, EVM, Cons>
 where
     Node: FullNodeTypes,
-    N: NetworkPrimitives<
-        BlockHeader = HeaderTy<Node::Types>,
-        BlockBody = BodyTy<Node::Types>,
-        Block = BlockTy<Node::Types>,
+    Network: FullNetwork<
+        Primitives: NetPrimitivesFor<
+            PrimitivesTy<Node::Types>,
+            PooledTransaction = PoolPooledTx<Pool>,
+        >,
     >,
     Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>>
         + Unpin
@@ -105,7 +105,7 @@ where
     type Pool = Pool;
     type Evm = EVM;
     type Consensus = Cons;
-    type Network = NetworkHandle<N>;
+    type Network = Network;
 
     fn pool(&self) -> &Self::Pool {
         &self.transaction_pool
@@ -130,7 +130,7 @@ where
 
 impl<Node, N, Pool, EVM, Cons> Clone for Components<Node, N, Pool, EVM, Cons>
 where
-    N: NetworkPrimitives,
+    N: Clone,
     Node: FullNodeTypes,
     Pool: TransactionPool,
     EVM: ConfigureEvm,
diff --git a/crates/node/builder/src/components/network.rs b/crates/node/builder/src/components/network.rs
index 33f128a697..c48048f8b5 100644
--- a/crates/node/builder/src/components/network.rs
+++ b/crates/node/builder/src/components/network.rs
@@ -1,40 +1,40 @@
 //! Network component for the node builder.
 
-use std::future::Future;
-
-use reth_network::{NetworkHandle, NetworkPrimitives};
-use reth_transaction_pool::TransactionPool;
-
 use crate::{BuilderContext, FullNodeTypes};
+use reth_network::types::NetPrimitivesFor;
+use reth_network_api::FullNetwork;
+use reth_node_api::PrimitivesTy;
+use reth_transaction_pool::TransactionPool;
+use std::future::Future;
 
 /// A type that knows how to build the network implementation.
 pub trait NetworkBuilder<Node: FullNodeTypes, Pool: TransactionPool>: Send {
-    /// The primitive types to use for the network.
-    type Primitives: NetworkPrimitives;
+    /// The network built.
+    type Network: FullNetwork<Primitives: NetPrimitivesFor<PrimitivesTy<Node::Types>>>;
 
     /// Launches the network implementation and returns the handle to it.
     fn build_network(
         self,
         ctx: &BuilderContext<Node>,
         pool: Pool,
-    ) -> impl Future<Output = eyre::Result<NetworkHandle<Self::Primitives>>> + Send;
+    ) -> impl Future<Output = eyre::Result<Self::Network>> + Send;
 }
 
-impl<Node, P, F, Fut, Pool> NetworkBuilder<Node, Pool> for F
+impl<Node, Net, F, Fut, Pool> NetworkBuilder<Node, Pool> for F
 where
     Node: FullNodeTypes,
-    P: NetworkPrimitives,
+    Net: FullNetwork<Primitives: NetPrimitivesFor<PrimitivesTy<Node::Types>>>,
     Pool: TransactionPool,
     F: Fn(&BuilderContext<Node>, Pool) -> Fut + Send,
-    Fut: Future<Output = eyre::Result<NetworkHandle<P>>> + Send,
+    Fut: Future<Output = eyre::Result<Net>> + Send,
 {
-    type Primitives = P;
+    type Network = Net;
 
     fn build_network(
         self,
         ctx: &BuilderContext<Node>,
         pool: Pool,
-    ) -> impl Future<Output = eyre::Result<NetworkHandle<P>>> + Send {
+    ) -> impl Future<Output = eyre::Result<Net>> + Send {
         self(ctx, pool)
     }
 }
diff --git a/crates/optimism/node/src/node.rs b/crates/optimism/node/src/node.rs
index 5d03d0ab7b..09e59c1493 100644
--- a/crates/optimism/node/src/node.rs
+++ b/crates/optimism/node/src/node.rs
@@ -819,13 +819,13 @@ where
         > + Unpin
         + 'static,
 {
-    type Primitives = OpNetworkPrimitives;
+    type Network = NetworkHandle<OpNetworkPrimitives>;
 
     async fn build_network(
         self,
         ctx: &BuilderContext<Node>,
         pool: Pool,
-    ) -> eyre::Result<NetworkHandle<Self::Primitives>> {
+    ) -> eyre::Result<Self::Network> {
         let network_config = self.network_config(ctx)?;
         let network = NetworkManager::builder(network_config).await?;
         let handle = ctx.start_network(network, pool);
diff --git a/examples/custom-node/src/network.rs b/examples/custom-node/src/network.rs
index d611d0f21e..b77018cf60 100644
--- a/examples/custom-node/src/network.rs
+++ b/examples/custom-node/src/network.rs
@@ -82,13 +82,9 @@ where
         > + Unpin
         + 'static,
 {
-    type Primitives = CustomNetworkPrimitives;
+    type Network = NetworkHandle<CustomNetworkPrimitives>;
 
-    async fn build_network(
-        self,
-        ctx: &BuilderContext<Node>,
-        pool: Pool,
-    ) -> Result<NetworkHandle<Self::Primitives>> {
+    async fn build_network(self, ctx: &BuilderContext<Node>, pool: Pool) -> Result<Self::Network> {
         let network_config = self.network_config(ctx)?;
         let network = NetworkManager::builder(network_config).await?;
         let handle = ctx.start_network(network, pool);