Struct Inline 

pub struct Inline<E, S, A, B, ES>
where
    E: Rng + Spawner + Metrics + Clock,
    S: Scheme,
    A: Application<E>,
    B: Block + Clone,
    ES: Epocher,
{ /* private fields */ }

Standard marshal wrapper that verifies blocks inline in verify.

Ancestry Validation

Inline always validates immediate ancestry before invoking application verification:

• Parent digest matches consensus context’s expected parent
• Child height is exactly parent height plus one

This is sufficient because the parent must have already been accepted by consensus.

Certifiability

This wrapper requires only crate::Block for B, not crate::CertifiableBlock. It is designed for applications that cannot recover consensus context directly from block payloads.

Implementations

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

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

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

Creates a new inline-verification wrapper.

Registers a build_duration histogram for proposal latency and initializes the shared “last built block” cache used by Relay::broadcast.

Trait Implementations

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

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

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

Returns the genesis digest for epoch.

For epoch zero, returns the application genesis digest. For later epochs, uses the previous epoch’s terminal block from marshal storage.

async fn propose( &mut self, consensus_context: Context<Self::Digest, S::PublicKey>, ) -> Receiver<Self::Digest>

Proposes a new block or re-proposes an epoch boundary block.

Proposal runs in a spawned task and returns a receiver for the resulting digest. Built/re-proposed blocks are cached in last_built so relay can broadcast exactly what was proposed.

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

Performs complete verification inline.

This method:

1. Fetches the block by digest
2. Enforces epoch/re-proposal rules
3. Fetches and validates the parent relationship
4. Runs application verification over ancestry

It reports true only after all verification steps finish. Successful verification marks the block as verified in marshal immediately.

type Digest = <B as Digestible>::Digest

Hash of an arbitrary payload.

type Context = Context<<Inline<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 Inline<E, S, A, B, ES>

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

Inline mode only waits for block availability during certification.

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

Determine whether a verified payload is safe to commit.

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

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

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

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

type Digest = <B as Digestible>::Digest

Hash of an arbitrary payload.

type PublicKey = <S as Scheme>::PublicKey

Identity key of a network participant.

type Plan = Plan<<S as Scheme>::PublicKey>

Directive for how a payload should be broadcast.

async fn broadcast(&mut self, digest: Self::Digest, plan: Plan<S::PublicKey>)

Broadcast a payload to the given recipients.

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

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

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

Forwards consensus activity to the wrapped application reporter.

type Activity = <A as Reporter>::Activity

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