Struct NodeBuilderWithComponents

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

A fully type configured node builder.

Supports adding additional addons to the node.

Fields

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

All settings for how the node should be configured.

adapter: NodeTypesAdapter<T>

Adapter for the underlying node types and database

components_builder: CB

container for type specific components

add_ons: AddOns<NodeAdapter<T, CB::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::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::Components>>,

pub fn on_component_initialized<F>(self, hook: F) -> Self

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

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

pub fn on_node_started<F>(self, hook: F) -> Self

where F: FnOnce(FullNode<NodeAdapter<T, CB::Components>, AO>) -> Result<()> + 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) -> Self

where F: FnOnce(ExExContext<NodeAdapter<T, CB::Components>>) -> R + Send + 'static, R: Future<Output = Result<E>> + Send, E: Future<Output = Result<()>> + 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(Self) -> R,

Launches the node with the given closure.

pub const fn check_launch(self) -> Self

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) -> Self

where F: FnOnce(AO) -> AO,

Modifies the addons with the given closure.

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

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

pub async fn launch_with<L>(self, launcher: L) -> Result<L::Node>

where L: LaunchNode<Self>,

Launches the node with the given launcher.

pub fn on_rpc_started<F>(self, hook: F) -> Self

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

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

pub fn extend_rpc_modules<F>(self, hook: F) -> Self

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

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

Trait Implementations

impl<Types, T, CB, AO> LaunchNode<NodeBuilderWithComponents<T, CB, AO>> for DefaultNodeLauncher

where Types: NodeTypesWithDB<ChainSpec: EthereumHardforks + EthChainSpec> + NodeTypesWithEngine, T: FullNodeTypes<Provider = BlockchainProvider<Types>, Types = Types>, CB: NodeComponentsBuilder<T>, AO: RethRpcAddOns<NodeAdapter<T, CB::Components>>,

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

The node type that is created.

async fn launch_node( self, target: NodeBuilderWithComponents<T, CB, AO>, ) -> Result<Self::Node>

Create and return a new node asynchronously.

impl<Types, T, CB, AO> LaunchNode<NodeBuilderWithComponents<T, CB, AO>> for EngineNodeLauncher

where Types: ProviderNodeTypes + NodeTypesWithEngine, T: FullNodeTypes<Types = Types, Provider = BlockchainProvider2<Types>>, CB: NodeComponentsBuilder<T>, AO: RethRpcAddOns<NodeAdapter<T, CB::Components>>, LocalPayloadAttributesBuilder<Types::ChainSpec>: PayloadAttributesBuilder<<<Types as NodeTypesWithEngine>::Engine as PayloadTypes>::PayloadAttributes>,

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

The node type that is created.

async fn launch_node( self, target: NodeBuilderWithComponents<T, CB, AO>, ) -> Result<Self::Node>

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.