feat: move RPC launch to add-ons (paradigmxyz#11532)

Author: klkvr

Cargo.lock

@@ -7,15 +7,13 @@ use reth::{
     args::{DiscoveryArgs, NetworkArgs, RpcServerArgs},
     builder::{NodeBuilder, NodeConfig, NodeHandle},
     network::PeersHandleProvider,
-    rpc::api::eth::{helpers::AddDevSigners, FullEthApiServer},
     tasks::TaskManager,
 };
 use reth_chainspec::{EthChainSpec, EthereumHardforks};
 use reth_db::{test_utils::TempDatabase, DatabaseEnv};
 use reth_node_builder::{
-    components::NodeComponentsBuilder, rpc::EthApiBuilderProvider, FullNodeTypesAdapter, Node,
-    NodeAdapter, NodeAddOns, NodeComponents, NodeTypesWithDBAdapter, NodeTypesWithEngine,
-    RethFullAdapter,
+    components::NodeComponentsBuilder, rpc::RethRpcAddOns, FullNodeTypesAdapter, Node, NodeAdapter,
+    NodeComponents, NodeTypesWithDBAdapter, NodeTypesWithEngine, RethFullAdapter,
 };
 use reth_provider::providers::BlockchainProvider;
 use tracing::{span, Level};
@@ -56,10 +54,7 @@ where
         TmpNodeAdapter<N>,
         Components: NodeComponents<TmpNodeAdapter<N>, Network: PeersHandleProvider>,
     >,
-    N::AddOns: NodeAddOns<
-        Adapter<N>,
-        EthApi: FullEthApiServer + AddDevSigners + EthApiBuilderProvider<Adapter<N>>,
-    >,
+    N::AddOns: RethRpcAddOns<Adapter<N>>,
 {
     let tasks = TaskManager::current();
     let exec = tasks.executor();
@@ -115,7 +110,8 @@ type TmpNodeAdapter<N> = FullNodeTypesAdapter<
     BlockchainProvider<NodeTypesWithDBAdapter<N, TmpDB>>,
 >;
 
-type Adapter<N> = NodeAdapter<
+/// Type alias for a `NodeAdapter`
+pub type Adapter<N> = NodeAdapter<
     RethFullAdapter<TmpDB, N>,
     <<N as Node<TmpNodeAdapter<N>>>::ComponentsBuilder as NodeComponentsBuilder<
         RethFullAdapter<TmpDB, N>,

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

@@ -18,7 +18,7 @@ use reth::{
     },
 };
 use reth_chainspec::EthereumHardforks;
-use reth_node_builder::{NodeAddOns, NodeTypesWithEngine};
+use reth_node_builder::{rpc::RethRpcAddOns, NodeTypesWithEngine};
 use reth_stages_types::StageId;
 use tokio_stream::StreamExt;
 
@@ -32,7 +32,7 @@ use crate::{
 pub struct NodeTestContext<Node, AddOns>
 where
     Node: FullNodeComponents,
-    AddOns: NodeAddOns<Node>,
+    AddOns: RethRpcAddOns<Node>,
 {
     /// The core structure representing the full node.
     pub inner: FullNode<Node, AddOns>,
@@ -52,7 +52,7 @@ where
     Node: FullNodeComponents,
     Node::Types: NodeTypesWithEngine<ChainSpec: EthereumHardforks, Engine = Engine>,
     Node::Network: PeersHandleProvider,
-    AddOns: NodeAddOns<Node>,
+    AddOns: RethRpcAddOns<Node>,
 {
     /// Creates a new test node
     pub async fn new(node: FullNode<Node, AddOns>) -> eyre::Result<Self> {
@@ -67,7 +67,7 @@ where
                 canonical_stream: node.provider.canonical_state_stream(),
                 _marker: PhantomData::<Engine>,
             },
-            rpc: RpcTestContext { inner: node.rpc_registry },
+            rpc: RpcTestContext { inner: node.add_ons_handle.rpc_registry },
         })
     }
 

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

@@ -11,14 +11,15 @@ use reth_ethereum_engine_primitives::{
 };
 use reth_evm_ethereum::execute::EthExecutorProvider;
 use reth_network::NetworkHandle;
-use reth_node_api::{ConfigureEvm, EngineValidator, FullNodeComponents, NodeAddOns};
+use reth_node_api::{ConfigureEvm, EngineValidator, FullNodeComponents, NodeTypesWithDB};
 use reth_node_builder::{
     components::{
         ComponentsBuilder, ConsensusBuilder, EngineValidatorBuilder, ExecutorBuilder,
         NetworkBuilder, PayloadServiceBuilder, PoolBuilder,
     },
     node::{FullNodeTypes, NodeTypes, NodeTypesWithEngine},
-    BuilderContext, Node, PayloadBuilderConfig, PayloadTypes,
+    rpc::RpcAddOns,
+    BuilderContext, Node, NodeAdapter, NodeComponentsBuilder, PayloadBuilderConfig, PayloadTypes,
 };
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
 use reth_primitives::Header;
@@ -77,17 +78,19 @@ impl NodeTypesWithEngine for EthereumNode {
 }
 
 /// Add-ons w.r.t. l1 ethereum.
-#[derive(Debug, Clone, Default)]
-#[non_exhaustive]
-pub struct EthereumAddOns;
-
-impl<N: FullNodeComponents> NodeAddOns<N> for EthereumAddOns {
-    type EthApi = EthApi<N::Provider, N::Pool, NetworkHandle, N::Evm>;
-}
+pub type EthereumAddOns<N> = RpcAddOns<
+    N,
+    EthApi<
+        <N as FullNodeTypes>::Provider,
+        <N as FullNodeComponents>::Pool,
+        NetworkHandle,
+        <N as FullNodeComponents>::Evm,
+    >,
+>;
 
 impl<Types, N> Node<N> for EthereumNode
 where
-    Types: NodeTypesWithEngine<Engine = EthEngineTypes, ChainSpec = ChainSpec>,
+    Types: NodeTypesWithDB + NodeTypesWithEngine<Engine = EthEngineTypes, ChainSpec = ChainSpec>,
     N: FullNodeTypes<Types = Types>,
 {
     type ComponentsBuilder = ComponentsBuilder<
@@ -100,7 +103,9 @@ where
         EthereumEngineValidatorBuilder,
     >;
 
-    type AddOns = EthereumAddOns;
+    type AddOns = EthereumAddOns<
+        NodeAdapter<N, <Self::ComponentsBuilder as NodeComponentsBuilder<N>>::Components>,
+    >;
 
     fn components_builder(&self) -> Self::ComponentsBuilder {
         Self::components()

crates/ethereum/node/src/node.rs

@@ -6,8 +6,10 @@ use futures::StreamExt;
 use reth::{args::DevArgs, core::rpc::eth::helpers::EthTransactions};
 use reth_chainspec::ChainSpec;
 use reth_e2e_test_utils::setup;
-use reth_node_api::{FullNodeComponents, NodeAddOns};
-use reth_node_builder::{EngineNodeLauncher, FullNode, NodeBuilder, NodeConfig, NodeHandle};
+use reth_node_api::FullNodeComponents;
+use reth_node_builder::{
+    rpc::RethRpcAddOns, EngineNodeLauncher, FullNode, NodeBuilder, NodeConfig, NodeHandle,
+};
 use reth_node_ethereum::{node::EthereumAddOns, EthereumNode};
 use reth_provider::{providers::BlockchainProvider2, CanonStateSubscriptions};
 use reth_tasks::TaskManager;
@@ -53,7 +55,7 @@ async fn can_run_dev_node_new_engine() -> eyre::Result<()> {
 async fn assert_chain_advances<N, AddOns>(node: FullNode<N, AddOns>)
 where
     N: FullNodeComponents<Provider: CanonStateSubscriptions>,
-    AddOns: NodeAddOns<N, EthApi: EthTransactions>,
+    AddOns: RethRpcAddOns<N, EthApi: EthTransactions>,
 {
     let mut notifications = node.provider.canonical_state_stream();
 

crates/ethereum/node/tests/e2e/dev.rs

@@ -142,7 +142,9 @@ where
         TestConsensusBuilder,
         EthereumEngineValidatorBuilder,
     >;
-    type AddOns = EthereumAddOns;
+    type AddOns = EthereumAddOns<
+        NodeAdapter<N, <Self::ComponentsBuilder as NodeComponentsBuilder<N>>::Components>,
+    >;
 
     fn components_builder(&self) -> Self::ComponentsBuilder {
         ComponentsBuilder::default()

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

@@ -12,6 +12,8 @@ workspace = true
 
 [dependencies]
 # reth
+reth-beacon-consensus.workspace = true
+reth-consensus.workspace = true
 reth-evm.workspace = true
 reth-provider.workspace = true
 reth-engine-primitives.workspace = true
@@ -23,3 +25,8 @@ reth-rpc-eth-api.workspace = true
 reth-network-api.workspace = true
 reth-node-types.workspace = true
 reth-primitives.workspace = true
+reth-node-core.workspace = true
+
+alloy-rpc-types-engine.workspace = true
+
+eyre.workspace = true

crates/node/api/Cargo.toml

@@ -1,14 +1,18 @@
 //! Traits for configuring a node.
 
-use std::marker::PhantomData;
+use std::{future::Future, marker::PhantomData};
 
+use alloy_rpc_types_engine::JwtSecret;
+use reth_beacon_consensus::BeaconConsensusEngineHandle;
+use reth_consensus::Consensus;
+use reth_engine_primitives::EngineValidator;
 use reth_evm::execute::BlockExecutorProvider;
 use reth_network_api::FullNetwork;
-use reth_node_types::{NodeTypesWithDB, NodeTypesWithEngine};
+use reth_node_core::node_config::NodeConfig;
+use reth_node_types::{NodeTypes, NodeTypesWithDB, NodeTypesWithEngine};
 use reth_payload_builder::PayloadBuilderHandle;
 use reth_primitives::Header;
 use reth_provider::FullProvider;
-use reth_rpc_eth_api::EthApiTypes;
 use reth_tasks::TaskExecutor;
 use reth_transaction_pool::TransactionPool;
 
@@ -54,9 +58,15 @@ pub trait FullNodeComponents: FullNodeTypes + Clone + 'static {
     /// The type that knows how to execute blocks.
     type Executor: BlockExecutorProvider;
 
+    /// The consensus type of the node.
+    type Consensus: Consensus + Clone + Unpin + 'static;
+
     /// Network API.
     type Network: FullNetwork;
 
+    /// Validator for the engine API.
+    type EngineValidator: EngineValidator<<Self::Types as NodeTypesWithEngine>::Engine>;
+
     /// Returns the transaction pool of the node.
     fn pool(&self) -> &Self::Pool;
 
@@ -66,8 +76,8 @@ pub trait FullNodeComponents: FullNodeTypes + Clone + 'static {
     /// Returns the node's executor type.
     fn block_executor(&self) -> &Self::Executor;
 
-    /// Returns the provider of the node.
-    fn provider(&self) -> &Self::Provider;
+    /// Returns the node's consensus type.
+    fn consensus(&self) -> &Self::Consensus;
 
     /// Returns the handle to the network
     fn network(&self) -> &Self::Network;
@@ -77,37 +87,46 @@ pub trait FullNodeComponents: FullNodeTypes + Clone + 'static {
         &self,
     ) -> &PayloadBuilderHandle<<Self::Types as NodeTypesWithEngine>::Engine>;
 
+    /// Returns the engine validator.
+    fn engine_validator(&self) -> &Self::EngineValidator;
+
+    /// Returns the provider of the node.
+    fn provider(&self) -> &Self::Provider;
+
     /// Returns handle to runtime.
     fn task_executor(&self) -> &TaskExecutor;
 }
 
-/// Customizable node add-on types.
-pub trait NodeAddOns<N: FullNodeComponents>: Send + Sync + Unpin + Clone + 'static {
-    /// The core `eth` namespace API type to install on the RPC server (see
-    /// `reth_rpc_eth_api::EthApiServer`).
-    type EthApi: EthApiTypes + Send + Clone;
-}
-
-impl<N: FullNodeComponents> NodeAddOns<N> for () {
-    type EthApi = ();
+/// Context passed to [`NodeAddOns::launch_add_ons`],
+#[derive(Debug)]
+pub struct AddOnsContext<'a, N: FullNodeComponents> {
+    /// Node with all configured components.
+    pub node: &'a N,
+    /// Node configuration.
+    pub config: &'a NodeConfig<<N::Types as NodeTypes>::ChainSpec>,
+    /// Handle to the beacon consensus engine.
+    pub beacon_engine_handle:
+        &'a BeaconConsensusEngineHandle<<N::Types as NodeTypesWithEngine>::Engine>,
+    /// JWT secret for the node.
+    pub jwt_secret: &'a JwtSecret,
 }
 
-/// Returns the builder for type.
-pub trait BuilderProvider<N: FullNodeComponents>: Send {
-    /// Context required to build type.
-    type Ctx<'a>;
-
-    /// Returns builder for type.
-    #[allow(clippy::type_complexity)]
-    fn builder() -> Box<dyn for<'a> Fn(Self::Ctx<'a>) -> Self + Send>;
+/// Customizable node add-on types.
+pub trait NodeAddOns<N: FullNodeComponents>: Send {
+    /// Handle to add-ons.
+    type Handle: Send + Sync + Clone;
+
+    /// Configures and launches the add-ons.
+    fn launch_add_ons(
+        self,
+        ctx: AddOnsContext<'_, N>,
+    ) -> impl Future<Output = eyre::Result<Self::Handle>> + Send;
 }
 
-impl<N: FullNodeComponents> BuilderProvider<N> for () {
-    type Ctx<'a> = ();
+impl<N: FullNodeComponents> NodeAddOns<N> for () {
+    type Handle = ();
 
-    fn builder() -> Box<dyn for<'a> Fn(Self::Ctx<'a>) -> Self + Send> {
-        Box::new(noop_builder)
+    async fn launch_add_ons(self, _components: AddOnsContext<'_, N>) -> eyre::Result<Self::Handle> {
+        Ok(())
     }
 }
-
-const fn noop_builder(_: ()) {}