Struct Marshaled 

pub struct Marshaled<E, S, A, B, ES>
where
    E: Rng + Spawner + Metrics + Clock,
    S: Scheme,
    A: Application<E>,
    B: Block,
    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 during epoch transitions, and ensures all blocks have valid parent linkage and contiguous heights.

Ancestry Validation

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

• Parent commitment 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.

Implementations

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

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

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

Creates a new Marshaled wrapper.

Trait Implementations

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

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

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

Returns the genesis commitment for a given epoch.

For epoch 0, this returns the application’s genesis block commitment. For subsequent epochs, it returns the commitment 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 commitment when ready. The built block is cached for later broadcasting.

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

Verifies a proposed block within epoch boundaries.

This method validates that:

1. The block is within the current epoch (unless it’s a boundary block re-proposal)
2. Re-proposals are only allowed for the last block in an epoch
3. The block’s parent commitment matches the consensus context’s expected parent
4. The block’s height is exactly one greater than the parent’s height
5. The underlying application’s verification logic passes

Verification is spawned in a background task and returns a receiver that will contain the verification result. Valid blocks are reported to the marshal as verified.

type Digest = <B as Committable>::Commitment

Hash of an arbitrary payload.

type Context = Context<<Marshaled<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.

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

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

fn certify( &mut self, _payload: Self::Digest, ) -> impl Future<Output = Receiver<bool>> + Send

Determine whether a verified payload is safe to commit.

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

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

fn clone(&self) -> Marshaled<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 Marshaled<E, S, A, B, ES>

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

async fn broadcast(&mut self, commitment: 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 commitment does not match the cached block, the broadcast is skipped with a warning.

type Digest = <B as Committable>::Commitment

Hash of an arbitrary payload.

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

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

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

Relays a report to the underlying Application.

type Activity = <A as Reporter>::Activity

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