use crate::{
components::{NodeComponents, NodeComponentsBuilder},
exex::BoxedLaunchExEx,
hooks::NodeHooks,
launch::LaunchNode,
rpc::{RethRpcServerHandles, RpcContext, RpcHooks},
FullNode,
};
use reth_exex::ExExContext;
use reth_network::NetworkHandle;
use reth_node_api::{FullNodeComponents, FullNodeTypes, NodeTypes};
use reth_node_core::node_config::NodeConfig;
use reth_payload_builder::PayloadBuilderHandle;
use reth_tasks::TaskExecutor;
use std::{fmt, future::Future};
pub struct NodeBuilderWithTypes<T: FullNodeTypes> {
config: NodeConfig,
adapter: NodeTypesAdapter<T>,
}
impl<T: FullNodeTypes> NodeBuilderWithTypes<T> {
pub const fn new(config: NodeConfig, database: T::DB) -> Self {
Self { config, adapter: NodeTypesAdapter::new(database) }
}
pub fn with_components<CB>(self, components_builder: CB) -> NodeBuilderWithComponents<T, CB>
where
CB: NodeComponentsBuilder<T>,
{
let Self { config, adapter } = self;
NodeBuilderWithComponents {
config,
adapter,
components_builder,
add_ons: NodeAddOns {
hooks: NodeHooks::default(),
rpc: RpcHooks::new(),
exexs: Vec::new(),
},
}
}
}
pub(crate) struct NodeTypesAdapter<T: FullNodeTypes> {
pub(crate) database: T::DB,
}
impl<T: FullNodeTypes> NodeTypesAdapter<T> {
pub(crate) const fn new(database: T::DB) -> Self {
Self { database }
}
}
impl<T: FullNodeTypes> fmt::Debug for NodeTypesAdapter<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("NodeTypesAdapter").field("db", &"...").field("types", &"...").finish()
}
}
pub struct NodeAdapter<T: FullNodeTypes, C: NodeComponents<T>> {
pub components: C,
pub task_executor: TaskExecutor,
pub provider: T::Provider,
}
impl<T: FullNodeTypes, C: NodeComponents<T>> NodeTypes for NodeAdapter<T, C> {
type Primitives = T::Primitives;
type Engine = T::Engine;
}
impl<T: FullNodeTypes, C: NodeComponents<T>> FullNodeTypes for NodeAdapter<T, C> {
type DB = T::DB;
type Provider = T::Provider;
}
impl<T: FullNodeTypes, C: NodeComponents<T>> FullNodeComponents for NodeAdapter<T, C> {
type Pool = C::Pool;
type Evm = C::Evm;
type Executor = C::Executor;
fn pool(&self) -> &Self::Pool {
self.components.pool()
}
fn evm_config(&self) -> &Self::Evm {
self.components.evm_config()
}
fn block_executor(&self) -> &Self::Executor {
self.components.block_executor()
}
fn provider(&self) -> &Self::Provider {
&self.provider
}
fn network(&self) -> &NetworkHandle {
self.components.network()
}
fn payload_builder(&self) -> &PayloadBuilderHandle<T::Engine> {
self.components.payload_builder()
}
fn task_executor(&self) -> &TaskExecutor {
&self.task_executor
}
}
impl<T: FullNodeTypes, C: NodeComponents<T>> Clone for NodeAdapter<T, C> {
fn clone(&self) -> Self {
Self {
components: self.components.clone(),
task_executor: self.task_executor.clone(),
provider: self.provider.clone(),
}
}
}
pub struct NodeBuilderWithComponents<T: FullNodeTypes, CB: NodeComponentsBuilder<T>> {
pub(crate) config: NodeConfig,
pub(crate) adapter: NodeTypesAdapter<T>,
pub(crate) components_builder: CB,
pub(crate) add_ons: NodeAddOns<NodeAdapter<T, CB::Components>>,
}
impl<T: FullNodeTypes, CB: NodeComponentsBuilder<T>> NodeBuilderWithComponents<T, CB> {
pub fn on_component_initialized<F>(mut self, hook: F) -> Self
where
F: FnOnce(NodeAdapter<T, CB::Components>) -> eyre::Result<()> + Send + 'static,
{
self.add_ons.hooks.set_on_component_initialized(hook);
self
}
pub fn on_node_started<F>(mut self, hook: F) -> Self
where
F: FnOnce(FullNode<NodeAdapter<T, CB::Components>>) -> eyre::Result<()> + Send + 'static,
{
self.add_ons.hooks.set_on_node_started(hook);
self
}
pub fn on_rpc_started<F>(mut self, hook: F) -> Self
where
F: FnOnce(
RpcContext<'_, NodeAdapter<T, CB::Components>>,
RethRpcServerHandles,
) -> eyre::Result<()>
+ Send
+ 'static,
{
self.add_ons.rpc.set_on_rpc_started(hook);
self
}
pub fn extend_rpc_modules<F>(mut self, hook: F) -> Self
where
F: FnOnce(RpcContext<'_, NodeAdapter<T, CB::Components>>) -> eyre::Result<()>
+ Send
+ 'static,
{
self.add_ons.rpc.set_extend_rpc_modules(hook);
self
}
pub fn install_exex<F, R, E>(mut self, exex_id: impl Into<String>, exex: F) -> Self
where
F: FnOnce(ExExContext<NodeAdapter<T, CB::Components>>) -> R + Send + 'static,
R: Future<Output = eyre::Result<E>> + Send,
E: Future<Output = eyre::Result<()>> + Send,
{
self.add_ons.exexs.push((exex_id.into(), Box::new(exex)));
self
}
pub async fn launch_with<L>(self, launcher: L) -> eyre::Result<L::Node>
where
L: LaunchNode<Self>,
{
launcher.launch_node(self).await
}
pub fn launch_with_fn<L, R>(self, launcher: L) -> R
where
L: FnOnce(Self) -> R,
{
launcher(self)
}
pub const fn check_launch(self) -> Self {
self
}
}
pub(crate) struct NodeAddOns<Node: FullNodeComponents> {
pub(crate) hooks: NodeHooks<Node>,
pub(crate) rpc: RpcHooks<Node>,
pub(crate) exexs: Vec<(String, Box<dyn BoxedLaunchExEx<Node>>)>,
}