Struct Marshaled 

pub struct Marshaled<E, A, B, C, H, Z, S, ES>
where
    E: Rng + Storage + Spawner + Metrics + Clock,
    A: Application<E>,
    B: CertifiableBlock<Context = Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>>,
    C: CodingScheme,
    H: Hasher,
    Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>,
    S: Strategy,
    ES: Epocher,
{ /* private fields */ }

An Application adapter that handles epoch transitions and erasure coded broadcast.

This wrapper intercepts consensus operations to enforce epoch boundaries. It prevents blocks from being produced outside their valid epoch and handles the special case of re-proposing boundary blocks during epoch transitions.

Implementations

impl<E, A, B, C, H, Z, S, ES> Marshaled<E, A, B, C, H, Z, S, ES>

where E: Rng + Storage + Spawner + Metrics + Clock, A: VerifyingApplication<E, Block = B, SigningScheme = Z::Scheme, Context = Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, C: CodingScheme, H: Hasher, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>, S: Strategy, ES: Epocher,

pub fn new(context: E, cfg: MarshaledConfig<A, B, C, H, Z, S, ES>) -> Self

Creates a new Marshaled wrapper.

Panics

Panics if the marshal metadata store cannot be initialized.

Trait Implementations

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

where E: Rng + Storage + Spawner + Metrics + Clock, A: VerifyingApplication<E, Block = B, SigningScheme = Z::Scheme, Context = Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, C: CodingScheme, H: Hasher, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>, S: Strategy, 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<Commitment, <Z::Scheme as CertificateScheme>::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.

async fn verify( &mut self, consensus_context: Context<Self::Digest, <Z::Scheme as CertificateScheme>::PublicKey>, payload: Self::Digest, ) -> Receiver<bool>

Verifies a received shard for a given round.

This method validates that:

1. The coding configuration matches the expected configuration for the current scheme.
2. The commitment’s context digest matches the consensus context (unless this is a re-proposal).
3. The shard is contained within the consensus commitment.

Verification is spawned in a background task and returns a receiver that will contain the verification result. Additionally, this method kicks off deferred verification to start block verification early (hidden behind shard validity and network latency).

type Digest = Commitment

Hash of an arbitrary payload.

type Context = Context<<Marshaled<E, A, B, C, H, Z, S, ES> as Automaton>::Digest, <<Z as Provider>::Scheme as Scheme>::PublicKey>

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

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

where E: Rng + Storage + Spawner + Metrics + Clock, A: VerifyingApplication<E, Block = B, SigningScheme = Z::Scheme, Context = Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, C: CodingScheme, H: Hasher, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>, S: Strategy, ES: Epocher,

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

Determine whether a verified payload is safe to commit.

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

where E: Rng + Storage + Spawner + Metrics + Clock + Clone, A: Application<E> + Clone, B: CertifiableBlock<Context = Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>> + Clone, C: CodingScheme + Clone, H: Hasher + Clone, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>> + Clone, S: Strategy + Clone, ES: Epocher + Clone, Z::Scheme: Clone,

fn clone(&self) -> Marshaled<E, A, B, C, H, Z, S, ES>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, A, B, C, H, Z, S, ES> Relay for Marshaled<E, A, B, C, H, Z, S, ES>

where E: Rng + Storage + Spawner + Metrics + Clock, A: Application<E, Block = B, Context = Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, C: CodingScheme, H: Hasher, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>, S: Strategy, 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 digest does not match the cached block, the broadcast is skipped with a warning.

type Digest = Commitment

Hash of an arbitrary payload.

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

where E: Rng + Storage + Spawner + Metrics + Clock, A: Application<E, Block = B, Context = Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>> + Reporter<Activity = Update<B>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, C: CodingScheme, H: Hasher, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>, S: Strategy, ES: Epocher,

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

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

type Activity = <A as Reporter>::Activity

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