Struct ExExManager 

pub struct ExExManager<P, N: NodePrimitives> { /* private fields */ }

The execution extension manager.

The manager is responsible for:

• Receiving relevant events from the rest of the node, and sending these to the execution extensions
• Backpressure
• Error handling
• Monitoring

Implementations

impl<P, N> ExExManager<P, N>

where N: NodePrimitives,

pub fn new( provider: P, handles: Vec<ExExHandle<N>>, max_capacity: usize, wal: Wal<N>, finalized_header_stream: ForkChoiceStream<SealedHeader<N::BlockHeader>>, ) -> Self

Create a new ExExManager.

You must provide an ExExHandle for each ExEx and the maximum capacity of the notification buffer in the manager.

When the capacity is exceeded (which can happen if an ExEx is slow) no one can send notifications over ExExManagerHandles until there is capacity again.

pub fn handle(&self) -> ExExManagerHandle<N>

Returns the handle to the manager.

pub const fn with_wal_blocks_warning(self, threshold: usize) -> Self

Sets the threshold for the number of blocks in the WAL before emitting a warning.

For L2 chains with faster block times, this value should be increased proportionally to avoid excessive warnings. For example, a chain with 2-second block times might use a value 6x higher than the default.

Trait Implementations

impl<P: Debug, N: Debug + NodePrimitives> Debug for ExExManager<P, N>

where N::BlockHeader: Debug,

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

Formats the value using the given formatter.

impl<P, N> Future for ExExManager<P, N>

where P: HeaderProvider + Unpin + 'static, N: NodePrimitives,

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Main loop of the ExExManager. The order of operations is as follows:

1. Handle incoming ExEx events. We do it before finalizing the WAL, because it depends on the latest state of ExExEvent::FinishedHeight events.
2. Finalize the WAL with the finalized header, if necessary.
3. Drain ExExManagerHandle notifications, push them to the internal buffer and update the internal buffer capacity.
4. Send notifications from the internal buffer to those ExExes that are ready to receive new notifications.
5. Remove notifications from the internal buffer that have been sent to all ExExes and update the internal buffer capacity.
6. Update the channel with the lowest FinishedExExHeight among all ExExes.

type Output = Result<(), Report>

The type of value produced on completion.

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.