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.

pub fn build_with_backfill<B: BackfillSync + Unpin, E>( self, backfill: impl FnOnce(Pipeline<N>, Runtime) -> Result<B, E>, ) -> Result<EngineOrchestrator<N::Payload, N::Primitives, Client, S, B>, E>

Like Self::build, backfilling through the BackfillSync backfill makes from the staged Pipeline and its runtime, instead of PipelineSync.

The backfill is built before any engine service is spawned, so its error aborts the build.

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.