Struct Deferred 

pub struct Deferred<E, S, A, B, ES>
where
    E: Rng + Spawner + Metrics + Clock,
    S: Scheme,
    A: Application<E>,
    B: CertifiableBlock,
    ES: Epocher,
{ /* private fields */ }

An Application adapter that handles epoch transitions and validates block ancestry.

This wrapper intercepts consensus operations to enforce epoch boundaries and validate block ancestry. It prevents blocks from being produced outside their valid epoch, handles the special case of re-proposing boundary blocks at epoch boundaries, and ensures all blocks have valid parent linkage and contiguous heights.

Ancestry Validation

Applications wrapped by Deferred can rely on the following ancestry checks being performed automatically during verification:

• Parent digest matches the consensus context’s expected parent
• Block height is exactly one greater than the parent’s height

Verifying only the immediate parent is sufficient since the parent itself must have been notarized by consensus, which guarantees it was verified and accepted by a quorum. This means the entire ancestry chain back to genesis is transitively validated.

Applications do not need to re-implement these checks in their own verification logic.

Context Recovery

With deferred verification, validators wait for data availability (DA) and verify the context before voting. If a validator crashes after voting but before certification, they lose their in-memory verification task. When recovering, validators extract context from a CertifiableBlock.

This embedded context is trustworthy because the notarizing quorum (which contains at least f+1 honest validators) verified that the block’s context matched the consensus context before voting.

Implementations

impl<E, S, A, B, ES> Deferred<E, S, A, B, ES>

where E: Rng + Spawner + Metrics + Clock, S: Scheme, A: VerifyingApplication<E, Block = B, SigningScheme = S, Context = Context<B::Digest, S::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, ES: Epocher,

pub fn new( context: E, application: A, marshal: Mailbox<S, Standard<B>>, epocher: ES, ) -> Self

Creates a new Deferred wrapper.

Trait Implementations

impl<E, S, A, B, ES> Automaton for Deferred<E, S, A, B, ES>

where E: Rng + Spawner + Metrics + Clock, S: Scheme, A: VerifyingApplication<E, Block = B, SigningScheme = S, Context = Context<B::Digest, S::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, ES: Epocher,

async fn genesis(&mut self, epoch: Epoch) -> Self::Digest

Returns the genesis digest for a given epoch.

For epoch 0, this returns the application’s genesis block digest. For subsequent epochs, it returns the digest of the last block from the previous epoch, which serves as the genesis block for the new epoch.

Panics

Panics if a non-zero epoch is requested but the previous epoch’s final block is not available in storage. This indicates a critical error in the consensus engine startup sequence, as engines must always have the genesis block before starting.

async fn propose( &mut self, consensus_context: Context<Self::Digest, S::PublicKey>, ) -> Receiver<Self::Digest>

Proposes a new block or re-proposes the epoch boundary block.

This method builds a new block from the underlying application unless the parent block is the last block in the current epoch. When at an epoch boundary, it re-proposes the boundary block to avoid creating blocks that would be invalidated by the epoch transition.

The proposal operation is spawned in a background task and returns a receiver that will contain the proposed block’s digest when ready. The built block is cached for later broadcasting.

type Digest = <B as Digestible>::Digest

Hash of an arbitrary payload.

type Context = Context<<Deferred<E, S, A, B, ES> as Automaton>::Digest, <S as Scheme>::PublicKey>

Context is metadata provided by the consensus engine associated with a given payload.

async fn verify( &mut self, context: Context<Self::Digest, S::PublicKey>, digest: Self::Digest, ) -> Receiver<bool>

Verify the payload is valid.

impl<E, S, A, B, ES> CertifiableAutomaton for Deferred<E, S, A, B, ES>

where E: Rng + Spawner + Metrics + Clock, S: Scheme, A: VerifyingApplication<E, Block = B, SigningScheme = S, Context = Context<B::Digest, S::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, ES: Epocher,

async fn certify( &mut self, round: Round, digest: Self::Digest, ) -> Receiver<bool>

Determine whether a verified payload is safe to commit.

impl<E, S, A, B, ES> Clone for Deferred<E, S, A, B, ES>

where E: Rng + Spawner + Metrics + Clock + Clone, S: Scheme + Clone, A: Application<E> + Clone, B: CertifiableBlock + Clone, ES: Epocher + Clone,

fn clone(&self) -> Deferred<E, S, A, B, ES>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E, S, A, B, ES> Relay for Deferred<E, S, A, B, ES>

where E: Rng + Spawner + Metrics + Clock, S: Scheme, A: Application<E, Block = B, Context = Context<B::Digest, S::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, ES: Epocher,

async fn broadcast(&mut self, digest: Self::Digest)

Broadcasts a previously built block to the network.

This uses the cached block from the last proposal operation. If no block was built or the digest does not match the cached block, the broadcast is skipped with a warning.

type Digest = <B as Digestible>::Digest

Hash of an arbitrary payload.

impl<E, S, A, B, ES> Reporter for Deferred<E, S, A, B, ES>

where E: Rng + Spawner + Metrics + Clock, S: Scheme, A: Application<E, Block = B, Context = Context<B::Digest, S::PublicKey>> + Reporter<Activity = Update<B>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, ES: Epocher,

async fn report(&mut self, update: Self::Activity)

Relays a report to the underlying Application and cleans up old verification tasks.

type Activity = <A as Reporter>::Activity

Activity is specified by the underlying consensus implementation and can be interpreted if desired.