Trait Relay 

pub trait Relay:
    Clone
    + Send
    + 'static {
    type Digest: Digest;
    type PublicKey: PublicKey;
    type Plan: Send;

    // Required method
    fn broadcast(&mut self, payload: Self::Digest, plan: Self::Plan) -> Feedback;
}

Relay is the interface responsible for broadcasting payloads to the network.

The consensus engine is only aware of a payload’s digest, not its contents. It is up to the relay to efficiently broadcast the full payload to other participants.

Required Associated Types

type Digest: Digest

Hash of an arbitrary payload.

type PublicKey: PublicKey

Identity key of a network participant.

type Plan: Send

Directive for how a payload should be broadcast.

Consensus mechanisms that need broadcast control (e.g. distinguishing initial broadcast from rebroadcasts) define a custom enum here. Mechanisms that treat every broadcast identically can set this to ().

Required Methods

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

Broadcast a payload according to the given plan.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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

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

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

impl<E, S, A, B, ES> Relay for Deferred<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: CertifiableBlock<Context = <A as Application<E>>::Context>, ES: Epocher,

type Digest = <B as Digestible>::Digest

type PublicKey = <S as Scheme>::PublicKey

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

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

type PublicKey = <S as Scheme>::PublicKey

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