Struct BatchQueue

pub struct BatchQueue<P, BF>
where
    P: NextBatchProvider + OriginAdvancer + OriginProvider + SignalReceiver + Debug,
    BF: L2ChainProvider + Debug,
{ /* private fields */ }

BatchQueue is responsible for o rdering unordered batches and gnerating empty batches when the sequence window has passed.

It receives batches that are tagged with the L1 Inclusion block of the batch. It only considers batches that are inside the sequencing window of a specific L1 Origin. It tries to eagerly pull batches based on the current L2 safe head. Otherwise it filters/creates an entire epoch’s worth of batches at once.

This stage tracks a range of L1 blocks with the assumption that all batches with an L1 inclusion block inside that range have been added to the stage by the time that it attempts to advance a full epoch.

It is internally responsible for making sure that batches with L1 inclusions block outside it’s working range are not considered or pruned.

Implementations

impl<P, BF> BatchQueue<P, BF>

where P: NextBatchProvider + OriginAdvancer + OriginProvider + SignalReceiver + Debug, BF: L2ChainProvider + Debug,

pub fn new(cfg: Arc<RollupConfig>, prev: P, fetcher: BF) -> Self

Creates a new BatchQueue stage.

pub fn pop_next_batch(&mut self, parent: L2BlockInfo) -> Option<SingleBatch>

Pops the next batch from the current queued up span-batch cache. The parent is used to set the parent hash of the batch. The parent is verified when the batch is later validated.

pub async fn derive_next_batch( &mut self, empty: bool, parent: L2BlockInfo, ) -> PipelineResult<Batch>

Derives the next batch to apply on top of the current L2 safe head. Follows the validity rules imposed on consecutive batches. Based on currently available buffered batch and L1 origin information. A PipelineError::Eof is returned if no batch can be derived yet.

pub async fn add_batch( &mut self, batch: Batch, parent: L2BlockInfo, ) -> PipelineResult<()>

Adds a batch to the queue.

Trait Implementations

impl<P, BF> AttributesProvider for BatchQueue<P, BF>

where P: NextBatchProvider + OriginAdvancer + OriginProvider + SignalReceiver + Send + Debug, BF: L2ChainProvider + Send + Debug,

fn next_batch<'life0, 'async_trait>( &'life0 mut self, parent: L2BlockInfo, ) -> Pin<Box<dyn Future<Output = PipelineResult<SingleBatch>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the next valid batch upon the given safe head. Also returns the boolean that indicates if the batch is the last block in the batch.

fn is_last_in_span(&self) -> bool

Returns if the previous batch was the last in the span.

impl<P, BF> Debug for BatchQueue<P, BF>

where P: NextBatchProvider + OriginAdvancer + OriginProvider + SignalReceiver + Debug + Debug, BF: L2ChainProvider + Debug + Debug,

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

Formats the value using the given formatter.

impl<P, BF> OriginAdvancer for BatchQueue<P, BF>

where P: NextBatchProvider + OriginAdvancer + OriginProvider + SignalReceiver + Send + Debug, BF: L2ChainProvider + Send + Debug,

fn advance_origin<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = PipelineResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Advances the internal state of the lowest stage to the next l1 origin. This method is the equivalent of the reference implementation advance_l1_block.

impl<P, BF> OriginProvider for BatchQueue<P, BF>

where P: NextBatchProvider + OriginAdvancer + OriginProvider + SignalReceiver + Debug, BF: L2ChainProvider + Debug,

fn origin(&self) -> Option<BlockInfo>

Returns the optional L1 BlockInfo origin.

impl<P, BF> SignalReceiver for BatchQueue<P, BF>

where P: NextBatchProvider + OriginAdvancer + OriginProvider + SignalReceiver + Send + Debug, BF: L2ChainProvider + Send + Debug,

fn signal<'life0, 'async_trait>( &'life0 mut self, signal: Signal, ) -> Pin<Box<dyn Future<Output = PipelineResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receives a signal from the driver.