Struct exonum::blockchain::config::ConsensusConfig

#[non_exhaustive]pub struct ConsensusConfig {
    pub validator_keys: Vec<ValidatorKeys>,
    pub first_round_timeout: Milliseconds,
    pub status_timeout: Milliseconds,
    pub peers_timeout: Milliseconds,
    pub txs_block_limit: u32,
    pub max_message_len: u32,
    pub min_propose_timeout: Milliseconds,
    pub max_propose_timeout: Milliseconds,
    pub propose_timeout_threshold: u32,
}

Consensus algorithm parameters.

This configuration is initially created with default recommended values, which can later be edited as required. The parameters in this configuration should be the same for all nodes in the network and can be changed using the configuration update service.

Default propose timeout value, along with the threshold, is chosen for maximal performance. In order to slow down block generation,hence consume less disk space, these values can be increased.

For additional information on the Exonum consensus algorithm, refer to Consensus in Exonum.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

validator_keys: Vec<ValidatorKeys>

List of validators public keys.

first_round_timeout: Milliseconds

Interval between first two rounds. This interval defines the time that passes between the moment a new block is committed to the blockchain and the time when second round starts, regardless of whether a new block has been committed during this period or not. Each consecutive round will be longer then previous by a constant factor, 10%.

Note that rounds in Exonum do not have a defined end time. Nodes in a new round can continue to vote for proposals and process messages related to previous rounds.

status_timeout: Milliseconds

Period of sending a Status message. This parameter defines the frequency with which a node broadcasts its status message to the network.

peers_timeout: Milliseconds

Peer exchange timeout. This parameter defines the frequency with which a node requests collected Connect messages from a random peer node in the network.

txs_block_limit: u32

Maximum number of transactions per block.

max_message_len: u32

Maximum message length (in bytes). This parameter determines the maximum size of both consensus messages and transactions. The default value of the parameter is 1 MB (1024 * 1024 bytes). The range of possible values for this parameter is between 1MB and 2^32-1 bytes.

min_propose_timeout: Milliseconds

Minimal propose timeout.

max_propose_timeout: Milliseconds

Maximal propose timeout.

propose_timeout_threshold: u32

Amount of transactions in pool to start use min_propose_timeout.

Default value is equal to half of the txs_block_limit in order to gather more transactions in a block if the transaction pool is almost empty, and create blocks faster when there are enough transactions in the pool.

Methods

impl ConsensusConfig

pub const DEFAULT_MAX_MESSAGE_LEN: u32

Default value for max_message_len.

pub const TIMEOUT_LINEAR_INCREASE_PERCENT: u64

Time that will be added to round timeout for each next round in terms of percent of first_round_timeout.

pub fn with_validator_keys(self, validator_keys: Vec<ValidatorKeys>) -> Self

Replaces validator keys in existing object with provided ones.

pub fn for_tests(validator_count: u16) -> (Self, Keys)

Generates a consensus configuration for testing and returns it together with the keys for the first validator.

pub fn find_validator(
    &self,
    predicate: impl Fn(&ValidatorKeys) -> bool
) -> Option<ValidatorId>

Search for identifier of the validator which satisfies the condition in predicate.

Examples

use exonum::{
    blockchain::{ConsensusConfig, ValidatorKeys},
    crypto,
    helpers::ValidatorId,
};

let config = ConsensusConfig::default()
    .with_validator_keys(
        (0..4)
            .map(|_| ValidatorKeys::new(
                crypto::gen_keypair().0,
                crypto::gen_keypair().0,
            ))
            .collect(),
    );

let some_validator_consensus_key = config.validator_keys[2].consensus_key;
// Try to find validator ID for this key.
assert_eq!(
    config.find_validator(|validator_keys| {
        validator_keys.consensus_key == some_validator_consensus_key
    }),
    Some(ValidatorId(2)),
);

Trait Implementations

impl BinaryValue for ConsensusConfig

fn to_bytes(&self) -> Vec<u8>

Serializes the given value to the vector of bytes.

fn from_bytes(value: Cow<[u8]>) -> Result<Self, Error>

Deserializes the value from the given bytes array.

fn into_bytes(self) -> Vec<u8>

Consumes and serializes the given value to the vector of bytes. This method is faster with the wrapped values, thus if you wouldn't use value after serialization use it.

impl Clone for ConsensusConfig

fn clone(&self) -> ConsensusConfig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ConsensusConfig

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

Formats the value using the given formatter.

impl Default for ConsensusConfig

fn default() -> Self

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for ConsensusConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Eq for ConsensusConfig

impl Hash for ConsensusConfig

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl ObjectHash for ConsensusConfig

fn object_hash(&self) -> Hash

Returns a hash of the value.

impl PartialEq<ConsensusConfig> for ConsensusConfig

fn eq(&self, other: &ConsensusConfig) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ConsensusConfig) -> bool

This method tests for !=.

impl ProtobufConvert for ConsensusConfig

type ProtoStruct = Config

Type generated from the Protobuf definition.

fn from_pb(pb: Self::ProtoStruct) -> Result<Self, Error>

Performs conversion from the type generated from Protobuf.

fn to_pb(&self) -> Self::ProtoStruct

Performs conversion to the type generated from Protobuf.

impl Serialize for ConsensusConfig

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

Serialize this value into the given Serde serializer.

impl StructuralEq for ConsensusConfig

impl StructuralPartialEq for ConsensusConfig

impl ValidateInput for ConsensusConfig

type Error = Error

The type returned in the event of a validate error.

fn validate(&self) -> Result<(), Self::Error>

Perform parameters validation for this configuration and return error if value is inconsistent.

fn into_validated(self) -> Result<Self, Self::Error>

The same as validate method, but returns the value itself as a successful result.