Trait NodeComponentsBuilder

pub trait NodeComponentsBuilder<Node>: Send
where
    Node: FullNodeTypes,
{
    type Components: NodeComponents<Node, PayloadBuilder = PayloadBuilderHandle<<<Node as FullNodeTypes>::Types as NodeTypesWithEngine>::Engine>>;

    // Required method
    fn build_components(
        self,
        ctx: &BuilderContext<Node>,
    ) -> impl Future<Output = Result<Self::Components, Report>> + Send;
}

A type that configures all the customizable components of the node and knows how to build them.

Implementers of this trait are responsible for building all the components of the node: See NodeComponents.

The ComponentsBuilder is a generic, general purpose implementation of this trait that can be used to customize certain components of the node using the builder pattern and defaults, e.g. Ethereum and Optimism. A type that’s responsible for building the components of the node.

Required Associated Types

type Components: NodeComponents<Node, PayloadBuilder = PayloadBuilderHandle<<<Node as FullNodeTypes>::Types as NodeTypesWithEngine>::Engine>>

The components for the node with the given types

Required Methods

fn build_components( self, ctx: &BuilderContext<Node>, ) -> impl Future<Output = Result<Self::Components, Report>> + Send

Consumes the type and returns the created components.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Node, F, Fut, Pool, EVM, Executor, Cons> NodeComponentsBuilder<Node> for F

where Node: FullNodeTypes, F: FnOnce(&BuilderContext<Node>) -> Fut + Send, Fut: Future<Output = Result<Components<Node, Pool, EVM, Executor, Cons>, Report>> + Send, Pool: TransactionPool + Unpin + 'static, EVM: ConfigureEvm<Header = Header>, Executor: BlockExecutorProvider, Cons: Consensus + Clone + Unpin + 'static,

type Components = Components<Node, Pool, EVM, Executor, Cons>

impl<Node, PoolB, PayloadB, NetworkB, ExecB, ConsB> NodeComponentsBuilder<Node> for ComponentsBuilder<Node, PoolB, PayloadB, NetworkB, ExecB, ConsB>

where Node: FullNodeTypes, PoolB: PoolBuilder<Node>, NetworkB: NetworkBuilder<Node, <PoolB as PoolBuilder<Node>>::Pool>, PayloadB: PayloadServiceBuilder<Node, <PoolB as PoolBuilder<Node>>::Pool>, ExecB: ExecutorBuilder<Node>, ConsB: ConsensusBuilder<Node>,

type Components = Components<Node, <PoolB as PoolBuilder<Node>>::Pool, <ExecB as ExecutorBuilder<Node>>::EVM, <ExecB as ExecutorBuilder<Node>>::Executor, <ConsB as ConsensusBuilder<Node>>::Consensus>