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: Application<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: Application<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 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 commitment when ready. The built block is persisted via core::Mailbox::verified before the commitment is delivered, so consensus can rely on the block surviving restart.

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

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

type Digest = Commitment

Hash of an arbitrary payload.

type PublicKey = <<Z as Provider>::Scheme as Scheme>::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 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,

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

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.