feat: use ComponentsBuilder as associated type in Node trait (#7957)

crates/e2e-test-utils/src/lib.rs

@@ -6,8 +6,7 @@ use reth::{
 };
 use reth_db::{test_utils::TempDatabase, DatabaseEnv};
 use reth_node_builder::{
-    components::{Components, NetworkBuilder, PayloadServiceBuilder, PoolBuilder},
-    FullNodeTypesAdapter, NodeAdapter,
+    components::NodeComponentsBuilder, FullNodeTypesAdapter, Node, NodeAdapter, RethFullAdapter,
 };
 use reth_primitives::ChainSpec;
 use reth_provider::providers::BlockchainProvider;
@@ -45,10 +44,7 @@ pub async fn setup<N>(
     is_dev: bool,
 ) -> eyre::Result<(Vec<NodeHelperType<N>>, TaskManager, Wallet)>
 where
-    N: Default + reth_node_builder::Node<TmpNodeAdapter<N>>,
-    N::PoolBuilder: PoolBuilder<TmpNodeAdapter<N>>,
-    N::NetworkBuilder: NetworkBuilder<TmpNodeAdapter<N>, TmpPool<N>>,
-    N::PayloadBuilder: PayloadServiceBuilder<TmpNodeAdapter<N>, TmpPool<N>>,
+    N: Default + Node<TmpNodeAdapter<N>>,
 {
     let tasks = TaskManager::current();
     let exec = tasks.executor();
@@ -103,11 +99,14 @@ where
 // Type aliases
 
 type TmpDB = Arc<TempDatabase<DatabaseEnv>>;
-type TmpPool<N> = <<N as reth_node_builder::Node<TmpNodeAdapter<N>>>::PoolBuilder as PoolBuilder<
-    TmpNodeAdapter<N>,
->>::Pool;
 type TmpNodeAdapter<N> = FullNodeTypesAdapter<N, TmpDB, BlockchainProvider<TmpDB>>;
 
+type Adapter<N> = NodeAdapter<
+    RethFullAdapter<TmpDB, N>,
+    <<N as Node<TmpNodeAdapter<N>>>::ComponentsBuilder as NodeComponentsBuilder<
+        RethFullAdapter<TmpDB, N>,
+    >>::Components,
+>;
+
 /// Type alias for a type of NodeHelper
-pub type NodeHelperType<N> =
-    NodeTestContext<NodeAdapter<TmpNodeAdapter<N>, Components<TmpNodeAdapter<N>, TmpPool<N>>>>;
+pub type NodeHelperType<N> = NodeTestContext<Adapter<N>>;

crates/node-ethereum/src/node.rs

@@ -5,8 +5,8 @@ use reth_basic_payload_builder::{BasicPayloadJobGenerator, BasicPayloadJobGenera
 use reth_network::NetworkHandle;
 use reth_node_builder::{
     components::{ComponentsBuilder, NetworkBuilder, PayloadServiceBuilder, PoolBuilder},
-    node::{FullNodeTypes, Node, NodeTypes},
-    BuilderContext, PayloadBuilderConfig,
+    node::{FullNodeTypes, NodeTypes},
+    BuilderContext, Node, PayloadBuilderConfig,
 };
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
 use reth_provider::CanonStateSubscriptions;
@@ -50,18 +50,11 @@ impl<N> Node<N> for EthereumNode
 where
     N: FullNodeTypes<Engine = EthEngineTypes>,
 {
-    type PoolBuilder = EthereumPoolBuilder;
-    type NetworkBuilder = EthereumNetworkBuilder;
-    type PayloadBuilder = EthereumPayloadBuilder;
+    type ComponentsBuilder =
+        ComponentsBuilder<N, EthereumPoolBuilder, EthereumPayloadBuilder, EthereumNetworkBuilder>;
 
-    fn components(
-        self,
-    ) -> ComponentsBuilder<N, Self::PoolBuilder, Self::PayloadBuilder, Self::NetworkBuilder> {
-        ComponentsBuilder::default()
-            .node_types::<N>()
-            .pool(EthereumPoolBuilder::default())
-            .payload(EthereumPayloadBuilder::default())
-            .network(EthereumNetworkBuilder::default())
+    fn components_builder(self) -> Self::ComponentsBuilder {
+        Self::components()
     }
 }
 

crates/node-ethereum/tests/it/builder.rs

@@ -33,3 +33,11 @@ fn test_basic_setup() {
         })
         .check_launch();
 }
+
+#[test]
+fn test_node_setup() {
+    let config = NodeConfig::test();
+    let db = create_test_rw_db();
+    let _builder =
+        NodeBuilder::new(config).with_database(db).node(EthereumNode::default()).check_launch();
+}

crates/node/builder/src/builder/mod.rs

@@ -3,7 +3,7 @@
 #![allow(clippy::type_complexity, missing_debug_implementations)]
 
 use crate::{
-    components::{Components, ComponentsBuilder, NodeComponentsBuilder, PoolBuilder},
+    components::NodeComponentsBuilder,
     node::FullNode,
     rpc::{RethRpcServerHandles, RpcContext},
     DefaultNodeLauncher, Node, NodeHandle,
@@ -204,28 +204,11 @@ where
     pub fn node<N>(
         self,
         node: N,
-    ) -> NodeBuilderWithComponents<
-        RethFullAdapter<DB, N>,
-        ComponentsBuilder<
-            RethFullAdapter<DB, N>,
-            N::PoolBuilder,
-            N::PayloadBuilder,
-            N::NetworkBuilder,
-        >,
-    >
+    ) -> NodeBuilderWithComponents<RethFullAdapter<DB, N>, N::ComponentsBuilder>
     where
         N: Node<RethFullAdapter<DB, N>>,
-        N::PoolBuilder: PoolBuilder<RethFullAdapter<DB, N>>,
-        N::NetworkBuilder: crate::components::NetworkBuilder<
-            RethFullAdapter<DB, N>,
-            <N::PoolBuilder as PoolBuilder<RethFullAdapter<DB, N>>>::Pool,
-        >,
-        N::PayloadBuilder: crate::components::PayloadServiceBuilder<
-            RethFullAdapter<DB, N>,
-            <N::PoolBuilder as PoolBuilder<RethFullAdapter<DB, N>>>::Pool,
-        >,
     {
-        self.with_types(node.clone()).with_components(node.components())
+        self.with_types(node.clone()).with_components(node.components_builder())
     }
 }
 
@@ -271,33 +254,16 @@ where
     }
 
     /// Preconfigures the node with a specific node implementation.
+    ///
+    /// This is a convenience method that sets the node's types and components in one call.
     pub fn node<N>(
         self,
         node: N,
-    ) -> WithLaunchContext<
-        NodeBuilderWithComponents<
-            RethFullAdapter<DB, N>,
-            ComponentsBuilder<
-                RethFullAdapter<DB, N>,
-                N::PoolBuilder,
-                N::PayloadBuilder,
-                N::NetworkBuilder,
-            >,
-        >,
-    >
+    ) -> WithLaunchContext<NodeBuilderWithComponents<RethFullAdapter<DB, N>, N::ComponentsBuilder>>
     where
         N: Node<RethFullAdapter<DB, N>>,
-        N::PoolBuilder: PoolBuilder<RethFullAdapter<DB, N>>,
-        N::NetworkBuilder: crate::components::NetworkBuilder<
-            RethFullAdapter<DB, N>,
-            <N::PoolBuilder as PoolBuilder<RethFullAdapter<DB, N>>>::Pool,
-        >,
-        N::PayloadBuilder: crate::components::PayloadServiceBuilder<
-            RethFullAdapter<DB, N>,
-            <N::PoolBuilder as PoolBuilder<RethFullAdapter<DB, N>>>::Pool,
-        >,
     {
-        self.with_types(node.clone()).with_components(node.components())
+        self.with_types(node.clone()).with_components(node.components_builder())
     }
 
     /// Launches a preconfigured [Node]
@@ -312,24 +278,12 @@ where
         NodeHandle<
             NodeAdapter<
                 RethFullAdapter<DB, N>,
-                Components<
-                    RethFullAdapter<DB, N>,
-                    <N::PoolBuilder as PoolBuilder<RethFullAdapter<DB, N>>>::Pool,
-                >,
+                <N::ComponentsBuilder as NodeComponentsBuilder<RethFullAdapter<DB, N>>>::Components,
             >,
         >,
     >
     where
         N: Node<RethFullAdapter<DB, N>>,
-        N::PoolBuilder: PoolBuilder<RethFullAdapter<DB, N>>,
-        N::NetworkBuilder: crate::components::NetworkBuilder<
-            RethFullAdapter<DB, N>,
-            <N::PoolBuilder as PoolBuilder<RethFullAdapter<DB, N>>>::Pool,
-        >,
-        N::PayloadBuilder: crate::components::PayloadServiceBuilder<
-            RethFullAdapter<DB, N>,
-            <N::PoolBuilder as PoolBuilder<RethFullAdapter<DB, N>>>::Pool,
-        >,
     {
         self.node(node).launch().await
     }

crates/node/builder/src/node.rs

@@ -1,7 +1,4 @@
-use crate::{
-    components::ComponentsBuilder,
-    rpc::{RethRpcServerHandles, RpcRegistry},
-};
+use crate::rpc::{RethRpcServerHandles, RpcRegistry};
 use reth_network::NetworkHandle;
 use reth_node_api::FullNodeComponents;
 use reth_node_core::{
@@ -19,23 +16,18 @@ use reth_tasks::TaskExecutor;
 use std::sync::Arc;
 
 // re-export the node api types
+use crate::components::NodeComponentsBuilder;
 pub use reth_node_api::{FullNodeTypes, NodeTypes};
 
-/// A [Node] is a [NodeTypes] that comes with preconfigured components.
+/// A [crate::Node] is a [NodeTypes] that comes with preconfigured components.
 ///
 /// This can be used to configure the builder with a preset of components.
-pub trait Node<N>: NodeTypes + Clone {
-    /// The type that builds the node's pool.
-    type PoolBuilder;
-    /// The type that builds the node's network.
-    type NetworkBuilder;
-    /// The type that builds the node's payload service.
-    type PayloadBuilder;
+pub trait Node<N: FullNodeTypes>: NodeTypes + Clone {
+    /// The type that builds the node's components.
+    type ComponentsBuilder: NodeComponentsBuilder<N>;
 
-    /// Returns the [ComponentsBuilder] for the node.
-    fn components(
-        self,
-    ) -> ComponentsBuilder<N, Self::PoolBuilder, Self::PayloadBuilder, Self::NetworkBuilder>;
+    /// Returns a [NodeComponentsBuilder] for the node.
+    fn components_builder(self) -> Self::ComponentsBuilder;
 }
 
 /// The launched node with all components including RPC handlers.

crates/optimism/node/src/node.rs

@@ -55,13 +55,10 @@ impl<N> Node<N> for OptimismNode
 where
     N: FullNodeTypes<Engine = OptimismEngineTypes>,
 {
-    type PoolBuilder = OptimismPoolBuilder;
-    type NetworkBuilder = OptimismNetworkBuilder;
-    type PayloadBuilder = OptimismPayloadBuilder;
+    type ComponentsBuilder =
+        ComponentsBuilder<N, OptimismPoolBuilder, OptimismPayloadBuilder, OptimismNetworkBuilder>;
 
-    fn components(
-        self,
-    ) -> ComponentsBuilder<N, Self::PoolBuilder, Self::PayloadBuilder, Self::NetworkBuilder> {
+    fn components_builder(self) -> Self::ComponentsBuilder {
         let Self { args } = self;
         Self::components(args)
     }