Struct NodeBuilderWithComponents 

pub struct NodeBuilderWithComponents<T, CB, AO>
where
    T: FullNodeTypes,
    CB: NodeComponentsBuilder<T>,
    AO: NodeAddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>>,
{
    pub config: NodeConfig<<<T as FullNodeTypes>::Types as NodeTypes>::ChainSpec>,
    pub adapter: NodeTypesAdapter<T>,
    pub rocksdb_provider: Option<RocksDBProvider>,
    pub components_builder: CB,
    pub add_ons: AddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>, AO>,
}

A fully type configured node builder.

Supports adding additional addons to the node.

Fields

config: NodeConfig<<<T as FullNodeTypes>::Types as NodeTypes>::ChainSpec>

All settings for how the node should be configured.

adapter: NodeTypesAdapter<T>

Adapter for the underlying node types and database

rocksdb_provider: Option<RocksDBProvider>

An optional RocksDBProvider to use instead of creating one during launch.

components_builder: CB

container for type specific components

add_ons: AddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>, AO>

Additional node extensions.

Implementations

impl<T, CB> NodeBuilderWithComponents<T, CB, ()>

where T: FullNodeTypes, CB: NodeComponentsBuilder<T>,

pub fn with_add_ons<AO>( self, add_ons: AO, ) -> NodeBuilderWithComponents<T, CB, AO>

where AO: NodeAddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>>,

Advances the state of the node builder to the next state where all customizable NodeAddOns types are configured.

impl<T, CB, AO> NodeBuilderWithComponents<T, CB, AO>

where T: FullNodeTypes, CB: NodeComponentsBuilder<T>, AO: NodeAddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>>,

pub fn on_component_initialized<F>( self, hook: F, ) -> NodeBuilderWithComponents<T, CB, AO>

where F: FnOnce(NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>) -> Result<(), Report> + Send + 'static,

Sets the hook that is run once the node’s components are initialized.

pub fn on_node_started<F>(self, hook: F) -> NodeBuilderWithComponents<T, CB, AO>

where F: FnOnce(FullNode<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>, AO>) -> Result<(), Report> + Send + 'static,

Sets the hook that is run once the node has started.

pub fn install_exex<F, R, E>( self, exex_id: impl Into<String>, exex: F, ) -> NodeBuilderWithComponents<T, CB, AO>

where F: FnOnce(ExExContext<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>>) -> R + Send + 'static, R: Future<Output = Result<E, Report>> + Send, E: Future<Output = Result<(), Report>> + Send,

Installs an ExEx (Execution Extension) in the node.

Note

The ExEx ID must be unique.

pub fn launch_with_fn<L, R>(self, launcher: L) -> R

where L: FnOnce(NodeBuilderWithComponents<T, CB, AO>) -> R,

Launches the node with the given closure.

pub const fn check_launch(self) -> NodeBuilderWithComponents<T, CB, AO>

Check that the builder can be launched

This is useful when writing tests to ensure that the builder is configured correctly.

pub fn map_add_ons<F>(self, f: F) -> NodeBuilderWithComponents<T, CB, AO>

where F: FnOnce(AO) -> AO,

Modifies the addons with the given closure.

This method provides access to methods on the addons type that don’t have direct builder methods. It’s useful for advanced configuration scenarios where you need to call addon-specific methods.

Examples

use tower::layer::util::Identity;

let builder = NodeBuilder::new(config)
    .with_types::<EthereumNode>()
    .with_components(EthereumNode::components())
    .with_add_ons(EthereumAddOns::default())
    .map_add_ons(|addons| addons.with_rpc_middleware(Identity::default()));

See also

• NodeAddOns trait for available addon types
• crate::NodeBuilderWithComponents::extend_rpc_modules for RPC module configuration

impl<T, CB, AO> NodeBuilderWithComponents<T, CB, AO>

where T: FullNodeTypes, CB: NodeComponentsBuilder<T>, AO: RethRpcAddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>>,

pub fn launch_with<L>( self, launcher: L, ) -> <L as LaunchNode<NodeBuilderWithComponents<T, CB, AO>>>::Future

where L: LaunchNode<NodeBuilderWithComponents<T, CB, AO>>,

Launches the node with the given launcher.

pub fn on_rpc_started<F>(self, hook: F) -> NodeBuilderWithComponents<T, CB, AO>

where F: FnOnce(RpcContext<'_, NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>, <AO as RethRpcAddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>>>::EthApi>, RethRpcServerHandles) -> Result<(), Report> + Send + 'static,

Sets the hook that is run once the rpc server is started.

pub fn extend_rpc_modules<F>( self, hook: F, ) -> NodeBuilderWithComponents<T, CB, AO>

where F: FnOnce(RpcContext<'_, NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>, <AO as RethRpcAddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>>>::EthApi>) -> Result<(), Report> + Send + 'static,

Sets the hook that is run to configure the rpc modules.

Trait Implementations

impl<N, DB, T, CB, AO, B> LaunchNode<NodeBuilderWithComponents<T, CB, AO>> for EngineNodeLauncher<B>

where T: FullNodeTypes<Types = N, DB = DB, Provider = BlockchainProvider<NodeTypesWithDBAdapter<N, DB>>>, N: Node<FullNodeTypesAdapter<N, DB, BlockchainProvider<NodeTypesWithDBAdapter<N, DB>>>> + NodeTypesForProvider, DB: Database + DatabaseMetrics + Clone + Unpin + 'static, CB: NodeComponentsBuilder<T> + 'static, AO: RethRpcAddOns<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>> + EngineValidatorAddOn<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>> + 'static, B: BackfillSyncBuilder<NodeTypesWithDBAdapter<N, DB>, <<<CB as NodeComponentsBuilder<T>>::Components as NodeComponents<T>>::Network as BlockDownloaderProvider>::Client> + 'static,

type Node = NodeHandle<NodeAdapter<T, <CB as NodeComponentsBuilder<T>>::Components>, AO>

The node type that is created.

type Future = Pin<Box<dyn Future<Output = Result<<EngineNodeLauncher<B> as LaunchNode<NodeBuilderWithComponents<T, CB, AO>>>::Node, Report>> + Send>>

The future type that is returned.

fn launch_node( self, target: NodeBuilderWithComponents<T, CB, AO>, ) -> <EngineNodeLauncher<B> as LaunchNode<NodeBuilderWithComponents<T, CB, AO>>>::Future

Create and return a new node asynchronously.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.