Struct EngineOrchestratorBuilder 

pub struct EngineOrchestratorBuilder<N, Client, S, V, C>
where
    N: ProviderNodeTypes,
{

    pub engine_kind: EngineApiKind,
    pub consensus: Arc<dyn FullConsensus<N::Primitives>>,
    pub client: Client,
    pub incoming_requests: S,
    pub pipeline: Pipeline<N>,
    pub pipeline_task_spawner: Runtime,
    pub provider: ProviderFactory<N>,
    pub blockchain_db: BlockchainProvider<N>,
    pub pruner: PrunerWithFactory<ProviderFactory<N>>,
    pub payload_builder: PayloadBuilderHandle<N::Payload>,
    pub payload_validator: V,
    pub overlay_manager: OverlayManager<N::Primitives>,
    pub tree_config: TreeConfig,
    pub sync_metrics_tx: MetricEventsSender,
    pub evm_config: C,
    pub runtime: Runtime,
}

Components needed to build the engine ChainOrchestrator that drives the chain forward.

build spawns and wires together the following components:

• BasicBlockDownloader — downloads blocks on demand from the network during live sync.
• PersistenceHandle — spawns the persistence service on a background thread for writing blocks and performing pruning outside the critical consensus path.
• EngineApiTreeHandler — spawns the tree handler that processes engine API requests (newPayload, forkchoiceUpdated) and maintains the in-memory chain state.
• EngineApiRequestHandler + EngineHandler — glue that routes incoming CL messages to the tree handler and manages download requests.
• PipelineSync — wraps the staged sync [Pipeline] for backfill sync when the node needs to catch up over large block ranges.

The returned orchestrator implements [Stream] and yields ChainEvents.

Fields

engine_kind: EngineApiKind

The engine API flavor to run.

consensus: Arc<dyn FullConsensus<N::Primitives>>

Consensus used to validate downloaded and incoming blocks.

client: Client

Network client used to download blocks during live sync.

incoming_requests: S

Incoming consensus layer messages.

pipeline: Pipeline<N>

Staged sync pipeline used for backfill.

pipeline_task_spawner: Runtime

Runtime the pipeline runs on.

provider: ProviderFactory<N>

Provider factory handed to the persistence service.

blockchain_db: BlockchainProvider<N>

Blockchain provider backing the engine tree.

pruner: PrunerWithFactory<ProviderFactory<N>>

Pruner run by the persistence service.

payload_builder: PayloadBuilderHandle<N::Payload>

Handle to the payload builder service.

payload_validator: V

Validator for incoming payloads.

overlay_manager: OverlayManager<N::Primitives>

Overlay manager for state on top of the database.

tree_config: TreeConfig

Engine tree configuration.

sync_metrics_tx: MetricEventsSender

Sender for sync metric events.

evm_config: C

EVM configuration used to execute payloads.

runtime: Runtime

Runtime used to spawn engine tree tasks.

Implementations

impl<N, Client, S, V, C> EngineOrchestratorBuilder<N, Client, S, V, C>

where N: ProviderNodeTypes, Client: BlockClient<Block = <N::Primitives as NodePrimitives>::Block> + BlockAccessListsClient + 'static, S: Stream<Item = BeaconEngineMessage<N::Payload>> + Send + Sync + Unpin + 'static, V: EngineValidator<N::Payload> + WaitForCaches, C: ConfigureEvm<Primitives = N::Primitives> + 'static,

pub fn build( self, ) -> EngineOrchestrator<N::Payload, N::Primitives, Client, S, PipelineSync<N>>

Spawns the engine services and returns the ChainOrchestrator driving them.

Trait Implementations

impl<N, Client: Debug, S: Debug, V: Debug, C: Debug> Debug for EngineOrchestratorBuilder<N, Client, S, V, C>

where N: ProviderNodeTypes + Debug, N::Primitives: Debug, N::Payload: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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.