Struct Config 

pub struct Config<S, L, B, D, A, R, F, T>
where
    S: Scheme,
    L: Config<S>,
    B: Blocker<PublicKey = S::PublicKey>,
    D: Digest,
    A: CertifiableAutomaton<Context = Context<D, S::PublicKey>>,
    R: Relay,
    F: Reporter<Activity = Activity<S, D>>,
    T: Strategy,
{

    pub scheme: S,
    pub elector: L,
    pub blocker: B,
    pub automaton: A,
    pub relay: R,
    pub reporter: F,
    pub track_historical_votes: bool,
    pub strategy: T,
    pub partition: String,
    pub mailbox_size: NonZeroUsize,
    pub epoch: Epoch,
    pub floor: Floor<S, D>,
    pub replay_buffer: NonZeroUsize,
    pub write_buffer: NonZeroUsize,
    pub page_cache: CacheRef,
    pub leader_timeout: Duration,
    pub certification_timeout: Duration,
    pub timeout_retry: Duration,
    pub view_retention: ViewDelta,
    pub skip: SkipPolicy,
    pub fetch_timeout: Duration,
    pub forward: ForwardPolicy,
}

Configuration for the consensus engine.

Fields

scheme: S

Signing scheme for the consensus engine.

Consensus messages can be signed with a cryptosystem that differs from the static participant identity keys exposed in participants. For example, we can authenticate peers on the network with commonware_cryptography::ed25519 keys while signing votes with shares distributed via commonware_cryptography::bls12381::dkg (which change each epoch). The scheme implementation is responsible for reusing the exact participant ordering carried by participants so that signer indices remain stable across both key spaces; if the order diverges, validators will reject votes as coming from the wrong validator.

Schemes must provide deterministic signatures (a participant must produce the same signature encoding every time it signs the same subject) because Simplex compares encoded votes when detecting equivocation.

elector: L

Leader election configuration.

Determines how leaders are selected for each view. Built-in options include RoundRobin for deterministic rotation and Random for unpredictable selection using BLS threshold signatures.

blocker: B

Blocker for the network.

Blocking is handled by commonware_p2p.

automaton: A

Automaton for the consensus engine.

relay: R

Relay for the consensus engine.

reporter: F

Reporter for the consensus engine.

Activity is exported for every tracked view, including votes that arrive up to view_retention views below the highest finalized view; votes below that window are dropped without being reported. Reported votes are not guaranteed to be verified (see crate::simplex::types::Activity). Consider wrapping with crate::simplex::scheme::reporter::AttributableReporter to automatically filter and verify activities based on scheme attributability.

Locally constructed votes are exported only after their journal entries are durable. Network votes are not persisted, so an equivocating sender may have different votes exported before and after a restart.

track_historical_votes: bool

Track individual votes after certification.

By default, full vote evidence is released when the corresponding certificate is constructed or received, making later conflict reporting and peer blocking best effort. Enabling this retains each recorded vote until its round is pruned, increasing memory usage.

strategy: T

Strategy for parallel operations.

partition: String

Partition for the consensus engine.

mailbox_size: NonZeroUsize

Maximum number of messages to buffer on channels inside the consensus engine before blocking.

epoch: Epoch

Epoch for the consensus engine. Each running engine should have a unique epoch.

floor: Floor<S, D>

Certified root for the consensus engine.

replay_buffer: NonZeroUsize

Number of bytes to buffer when replaying during startup.

write_buffer: NonZeroUsize

The size of the write buffer to use for each blob in the journal.

page_cache: CacheRef

Page cache for the journal.

leader_timeout: Duration

Amount of time to wait for a leader to propose a payload in a view.

certification_timeout: Duration

Amount of time to wait for certification progress in a view before attempting to skip the view.

This timeout must be greater than the leader timeout.

timeout_retry: Duration

Amount of time to wait before retrying a nullify broadcast if stuck in a view.

view_retention: ViewDelta

Number of views behind the finalized tip to track (in memory and in the journal) for recent activity.

skip: SkipPolicy

Policy governing whether nullify(v) may be broadcast before the normal round deadlines.

fetch_timeout: Duration

Timeout to wait for a peer to respond to a request.

forward: ForwardPolicy

Policy for proactively forwarding blocks when entering the next view.

Implementations

impl<S: Scheme, L: Config<S>, B: Blocker<PublicKey = S::PublicKey>, D: Digest, A: CertifiableAutomaton<Context = Context<D, S::PublicKey>>, R: Relay, F: Reporter<Activity = Activity<S, D>>, T: Strategy> Config<S, L, B, D, A, R, F, T>

pub fn assert<Rng>(&self, rng: &mut Rng)

where Rng: CryptoRng, S: Scheme<D>,

Assert enforces that all configuration values are valid.

The RNG is used to verify finalized floor certificates.