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 Verifier>::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: Application<E, Block = B, SigningScheme = Z::Scheme, Context = Context<Commitment, <Z::Scheme as Verifier>::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: Application<E, Block = B, SigningScheme = Z::Scheme, Context = Context<Commitment, <Z::Scheme as Verifier>::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 propose( &mut self, consensus_context: Context<Commitment, <Z::Scheme as Verifier>::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 block is staged before the commitment is delivered and handed to marshal when consensus requests the relay broadcast, which persists it after the shards are sent. The resulting sync handle is awaited only at certification so it overlaps consensus voting. The commitment does not imply durability on its own. CertifiableAutomaton::certify awaits the registered certification gate before the finalize vote.

async fn verify( &mut self, consensus_context: Context<Self::Digest, <Z::Scheme as Verifier>::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 Verifier>::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: Application<E, Block = B, SigningScheme = Z::Scheme, Context = Context<Commitment, <Z::Scheme as Verifier>::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, A: Application<E>, B: CertifiableBlock<Context = Context<Commitment, <Z::Scheme as Verifier>::PublicKey>>, C: CodingScheme, H: Hasher, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>, S: Strategy, ES: Epocher,

fn clone(&self) -> Self

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 Verifier>::PublicKey>>, B: CertifiableBlock<Context = <A as Application<E>>::Context>, C: CodingScheme, H: Hasher, Z: Provider<Scope = Epoch, Scheme: Scheme<Commitment>>, S: Strategy, ES: Epocher,

type Digest = Commitment

Hash of an arbitrary payload.

type PublicKey = <<Z as Provider>::Scheme as Verifier>::PublicKey

Identity key of a network participant.

type Plan = Plan<<Marshaled<E, A, B, C, H, Z, S, ES> as Relay>::PublicKey>

Directive for how a payload should be broadcast.

fn broadcast(&mut self, commitment: Self::Digest, plan: Self::Plan) -> Feedback

Broadcast a payload according to the given plan.

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 Verifier>::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,

fn report(&mut self, update: Self::Activity) -> Feedback

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

type Activity = <A as Reporter>::Activity

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