Struct Parameters

pub struct Parameters {

    pub db_path: PathBuf,
    pub leader_timeout: Duration,
    pub min_round_delay: Duration,
    pub max_forward_time_drift: Duration,
    pub max_blocks_per_sync: usize,
    pub max_blocks_per_fetch: usize,
    pub sync_last_known_own_block_timeout: Duration,
    pub round_prober_interval_ms: u64,
    pub round_prober_request_timeout_ms: u64,
    pub propagation_delay_stop_proposal_threshold: u32,
    pub dag_state_cached_rounds: u32,
    pub commit_sync_parallel_fetches: usize,
    pub commit_sync_batch_size: u32,
    pub commit_sync_batches_ahead: usize,
    pub anemo: AnemoParameters,
    pub tonic: TonicParameters,
}

Operational configurations of a consensus authority.

All fields should tolerate inconsistencies among authorities, without affecting safety of the protocol. Otherwise, they need to be part of Sui protocol config or epoch state on-chain.

NOTE: fields with default values are specified in the serde default functions. Most operators should not need to specify any field, except db_path.

Fields

db_path: PathBuf

Path to consensus DB for this epoch. Required when initializing consensus. This is calculated based on user configuration for base directory.

leader_timeout: Duration

Time to wait for parent round leader before sealing a block, from when parent round has a quorum.

min_round_delay: Duration

Minimum delay between rounds, to avoid generating too many rounds when latency is low. This is especially necessary for tests running locally. If setting a non-default value, it should be set low enough to avoid reducing round rate and increasing latency in realistic and distributed configurations.

max_forward_time_drift: Duration

Maximum forward time drift (how far in future) allowed for received blocks.

max_blocks_per_sync: usize

Max number of blocks to fetch per block sync request. Block sync requests have very short (~2s) timeouts. So this value should be limited to allow the requests to finish on hosts with good network with this timeout. Usually a host sends 14-16 blocks per sec to a peer, so sending 32 blocks in 2 seconds should be reasonable.

max_blocks_per_fetch: usize

Max number of blocks to fetch per commit sync request.

sync_last_known_own_block_timeout: Duration

Time to wait during node start up until the node has synced the last proposed block via the network peers. When set to 0 the sync mechanism is disabled. This property is meant to be used for amnesia recovery.

round_prober_interval_ms: u64

Interval in milliseconds to probe highest received rounds of peers.

round_prober_request_timeout_ms: u64

Timeout in milliseconds for a round prober request.

propagation_delay_stop_proposal_threshold: u32

Proposing new block is stopped when the propagation delay is greater than this threshold. Propagation delay is the difference between the round of the last proposed block and the the highest round from this authority that is received by all validators in a quorum.

dag_state_cached_rounds: u32

The number of rounds of blocks to be kept in the Dag state cache per authority. The larger the number the more the blocks that will be kept in memory allowing minimising any potential disk access. Value should be at minimum 50 rounds to ensure node performance, but being too large can be expensive in memory usage.

commit_sync_parallel_fetches: usize

commit_sync_batch_size: u32

commit_sync_batches_ahead: usize

anemo: AnemoParameters

Anemo network settings.

tonic: TonicParameters

Tonic network settings.

Trait Implementations

impl Clone for Parameters

fn clone(&self) -> Parameters

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Parameters

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Parameters

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Parameters

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Parameters

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.