Method handle_block_processed

syncer/src/actor.rs:1227–1261

Handle acknowledgement from the application that a block has been processed. Buffers the processed height update but does NOT sync to durable storage. The caller must sync metadata after processing all ready acks.

(
        &mut self,
        height: Height,
        commitment: B::Digest,
        resolver: &mut impl Resolver<Key = Request<B::Digest>>,
    )

            for subscriber in bs.subscribers.drain(..) {
                subscriber.send_lossy(block.clone());
            }
        }
    }

    // -------------------- Application Dispatch --------------------

    /// 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` always
    /// advances sequentially.
    async fn try_dispatch_blocks(
        &mut self,
        application: &mut impl Reporter<Activity = Update<B, P::Scheme, A>>,
        resolver: &mut impl Resolver<Key = Request<B::Digest>>,
    ) {
        while self.pending_acks.has_capacity() {
            let next_height = self
                .pending_acks
                .next_dispatch_height(self.last_processed_height);
            let Some(block) = self.get_finalized_block(next_height).await else {
                return;
            };
            assert_eq!(
                block.height(),
                next_height,
                "finalized block height mismatch"
            );

            let (height, commitment) = (block.height(), block.digest());
            let (ack, ack_waiter) = A::handle();

            if is_last_block_of_epoch(&self.epocher, next_height.get()) {
                let Some(finalization) = self.get_finalization_by_height(next_height).await else {