Trait NodeComponentsBuilder

pub trait NodeComponentsBuilder<Node: FullNodeTypes>: Send {
    type Components: NodeComponents<Node>;

    // Required method
    fn build_components(
        self,
        ctx: &BuilderContext<Node>,
    ) -> impl Future<Output = Result<Self::Components>> + 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>

The components for the node with the given types

Required Methods

fn build_components( self, ctx: &BuilderContext<Node>, ) -> impl Future<Output = Result<Self::Components>> + 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, N, F, Fut, Pool, EVM, Executor, Cons> NodeComponentsBuilder<Node> for F

where N: NetworkPrimitives<BlockHeader = HeaderTy<Node::Types>, BlockBody = BodyTy<Node::Types>, Block = BlockTy<Node::Types>>, Node: FullNodeTypes, F: FnOnce(&BuilderContext<Node>) -> Fut + Send, Fut: Future<Output = Result<Components<Node, N, Pool, EVM, Executor, Cons>>> + Send, Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>> + Unpin + 'static, EVM: ConfigureEvm<Primitives = PrimitivesTy<Node::Types>> + 'static, Executor: BlockExecutorProvider<Primitives = PrimitivesTy<Node::Types>>, Cons: FullConsensus<PrimitivesTy<Node::Types>, Error = ConsensusError> + Clone + Unpin + 'static,

type Components = Components<Node, N, 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, Pool: TransactionPool<Transaction: PoolTransaction<Pooled = <NetworkB::Primitives as NetworkPrimitives>::PooledTransaction>>>, NetworkB: NetworkBuilder<Node, PoolB::Pool, Primitives: NetworkPrimitives<BlockHeader = HeaderTy<Node::Types>, BlockBody = BodyTy<Node::Types>, Block = BlockTy<Node::Types>>>, PayloadB: PayloadServiceBuilder<Node, PoolB::Pool>, ExecB: ExecutorBuilder<Node>, ConsB: ConsensusBuilder<Node>,

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