Method try_dispatch_blocks

syncer/src/actor.rs:1174–1221

Attempt to dispatch finalized blocks to the application until the pipeline is full or no more blocks are available. This does NOT advance `last_processed_height` or sync metadata. It only sends blocks to the application and enqueues pending acks. Metadata is updated later when acks arrive and [`Self::handle_block_processed`] runs. Acks are processed in FIFO order so `last_processed_height` alway

(
        &mut self,
        application: &mut impl Reporter<Activity = Update<B, P::Scheme, A>>,
        resolver: &mut impl Resolver<Key = Request<B::Digest>>,
    )

                    block,
                    response,
                } => {
                    response.send_lossy(true);
                    let round = notarization.round();
                    let commitment = block.digest();
                    debug!(?round, ?commitment, "received notarization");

                    // If there exists a finalization certificate for this block, we
                    // should finalize it.
                    let height = block.height();
                    if let Some(finalization) = self.cache.get_finalization_for(commitment).await {
                        wrote |= self
                            .store_finalization(
                                height,
                                commitment,
                                block.clone(),
                                Some(finalization),
                                application,
                                buffer,
                            )
                            .await;
                    }

                    // Cache the notarization and block.
                    self.cache_block(round, commitment, block.clone()).await;
                    self.cache
                        .put_notarization(round, commitment, notarization)
                        .await;
                    application
                        .report(Update::NotarizedBlock(block.clone()))
                        .await;
                    self.notify_subscribers(commitment, &block).await;
                }
            }
        }

        wrote
    }

    /// Returns a scheme suitable for verifying certificates at the given epoch.
    ///
    /// Prefers a certificate verifier if available, otherwise falls back
    /// to the scheme for the given epoch.
    fn get_scheme_certificate_verifier(&self, epoch: Epoch) -> Option<Arc<P::Scheme>> {
        self.provider.all().or_else(|| self.provider.scoped(epoch))
    }

    // -------------------- Waiters --------------------

    /// Notify any subscribers for the given commitment with the provided block.
    async fn notify_subscribers(&mut self, commitment: B::Digest, block: &B) {
        if let Some(mut bs) = self.block_subscriptions.remove(&commitment) {