Struct Application 

pub struct Application<A, B, V, C>
where
    B: ReshareBlock<Variant = V, Signer = C>,
    V: Variant,
    C: Signer,
{ /* private fields */ }

An Application wrapper that enforces the reshare block-validity contract and drives the reshare payload for proposals.

When the reshare actor tracks an epoch’s ceremony, the wrapper rejects a final block whose payload differs from the independently reconstructed EpochInfo. An actor that starts following mid-epoch lacks the protocol history required for that comparison, so its final-block verification remains pending. The wrapper always rejects stray payloads carried by non-final blocks in the early dealing window.

For proposals, the wrapper selects and fetches the payload for the block being built (a dealer log from the midpoint onward, the epoch info on the final block) and hands it to the inner application through Input, so the inner application neither talks to the reshare mailbox nor tracks epoch boundaries. It only attaches the handed-over payload to the block it builds, because the wrapper cannot build the application’s block type itself.

The wrapper is a plain Application, so it composes with any consensus application, including one adapted through stateful. It forwards its own upstream input to the inner application as Input::upstream, so nesting under another input-providing application still works.

Implementations

impl<A, B, V, C> Application<A, B, V, C>

where B: ReshareBlock<Variant = V, Signer = C>, V: Variant, C: Signer,

pub const fn new( inner: A, reshare: Mailbox<B, V, C>, blocks_per_epoch: NonZeroU64, ) -> Self

Wraps inner, using reshare to select final-block epoch info and dealer logs and blocks_per_epoch to locate epoch boundaries and phases.

Trait Implementations

impl<A, E, B, V, C, I> Application<E> for Application<A, B, V, C>

where E: Rng + Spawner + Metrics + Clock, A: ConsensusApplication<E, Block = B, Input = Input<I, V, C, B::Directory>>, A::Context: Send, B: ReshareBlock<Variant = V, Signer = C> + CertifiableBlock + Clone, V: Variant, C: Signer, I: Send,

type SigningScheme = <A as Application<E>>::SigningScheme

The signing scheme used by the application.

type Context = <A as Application<E>>::Context

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

type Block = <A as Application<E>>::Block

The block type produced by the application’s builder.

type Input = I

Per-proposal input handed to propose. Applications that need no input set this to ().

async fn propose( &mut self, context: (E, Self::Context), ancestry: impl Ancestry<Self::Block>, input: Self::Input, ) -> Option<Self::Block>

Build a new block on top of the provided parent ancestry. If the build job fails, or the proposer’s slot should be skipped, the implementor should return None.

async fn verify( &mut self, context: (E, Self::Context), ancestry: impl Ancestry<Self::Block>, ) -> bool

Verify a block produced by the application’s proposer, relative to its ancestry.

impl<A, B, V, C> Clone for Application<A, B, V, C>

where A: Clone, B: ReshareBlock<Variant = V, Signer = C>, V: Variant, C: Signer,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.