Struct ConsensusState 

pub struct ConsensusState<Ctx>
where
    Ctx: Context,
{
    pub ctx: Ctx,
    pub params: Params<Ctx>,
    pub driver: Driver<Ctx>,
    pub input_queue: BoundedQueue<<Ctx as Context>::Height, Input<Ctx>>,
    pub full_proposal_keeper: FullProposalKeeper<Ctx>,
    pub last_signed_prevote: Option<SignedMessage<Ctx, <Ctx as Context>::Vote>>,
    pub last_signed_precommit: Option<SignedMessage<Ctx, <Ctx as Context>::Vote>>,
    pub target_time: Option<Duration>,
    pub height_start_time: Option<Instant>,
    pub finalization_period: bool,
}

The state maintained by consensus for processing a Input.

Fields

ctx: Ctx

The context for the consensus state machine

params: Params<Ctx>

The consensus parameters

driver: Driver<Ctx>

Driver for the per-round consensus state machine

input_queue: BoundedQueue<<Ctx as Context>::Height, Input<Ctx>>

A queue of inputs that were received before the driver started.

full_proposal_keeper: FullProposalKeeper<Ctx>

The proposals to decide on.

last_signed_prevote: Option<SignedMessage<Ctx, <Ctx as Context>::Vote>>

Last prevote broadcasted by this node

last_signed_precommit: Option<SignedMessage<Ctx, <Ctx as Context>::Vote>>

Last precommit broadcasted by this node

target_time: Option<Duration>

Target time for the current height

height_start_time: Option<Instant>

Start time of the current height

finalization_period: bool

Whether we are in the finalization period.

The finalization period is entered in decide, cleared in finalize_height, and only valid during the commit step.

It allows collecting additional precommits for the decided value after the decision is made in decide, which can be included in the commit certificate.

Implementations

impl<Ctx> State<Ctx>

where Ctx: Context,

pub fn new( ctx: Ctx, height: <Ctx as Context>::Height, validator_set: <Ctx as Context>::ValidatorSet, params: Params<Ctx>, queue_capacity: usize, ) -> State<Ctx>

pub fn height(&self) -> <Ctx as Context>::Height

pub fn round(&self) -> Round

pub fn address(&self) -> &<Ctx as Context>::Address

pub fn validator_set(&self) -> &<Ctx as Context>::ValidatorSet

pub fn get_proposer( &self, height: <Ctx as Context>::Height, round: Round, ) -> &<Ctx as Context>::Address

pub fn set_last_vote( &mut self, vote: SignedMessage<Ctx, <Ctx as Context>::Vote>, )

pub fn restore_precommits( &self, height: <Ctx as Context>::Height, round: Round, value: &<Ctx as Context>::Value, ) -> Vec<SignedMessage<Ctx, <Ctx as Context>::Vote>>

pub fn polka_certificate( &self, round: Round, value_id: &<<Ctx as Context>::Value as Value>::Id, ) -> Option<&PolkaCertificate<Ctx>>

Get the polka certificate at the current height for the specified round and value, if it exists

pub fn full_proposal_at_round_and_value( &self, height: &<Ctx as Context>::Height, round: Round, value: &<Ctx as Context>::Value, ) -> Option<&FullProposal<Ctx>>

pub fn full_proposal_at_round_and_proposer( &self, height: &<Ctx as Context>::Height, round: Round, address: &<Ctx as Context>::Address, ) -> Option<&FullProposal<Ctx>>

pub fn get_proposed_value_by_id( &self, height: <Ctx as Context>::Height, round: Round, value_id: &<<Ctx as Context>::Value as Value>::Id, ) -> Option<ProposedValue<Ctx>>

Get a proposed value by its ID at the specified height and round.

pub fn proposals_for_value( &self, proposed_value: &ProposedValue<Ctx>, ) -> Vec<SignedMessage<Ctx, <Ctx as Context>::Proposal>>

pub fn store_proposal( &mut self, new_proposal: SignedMessage<Ctx, <Ctx as Context>::Proposal>, )

pub fn store_value(&mut self, new_value: &ProposedValue<Ctx>) -> Validity

Store the proposed value and return its validity, which may be now be different from the one provided.

pub fn reset_and_start_height( &mut self, height: <Ctx as Context>::Height, validator_set: <Ctx as Context>::ValidatorSet, target_time: Option<Duration>, )

pub fn decided_value(&self) -> Option<(Round, <Ctx as Context>::Value)>

Return the round and value id of the decided value.

pub fn buffer_input( &mut self, height: <Ctx as Context>::Height, input: Input<Ctx>, _metrics: &Metrics, )

Queue an input for later processing, only keep inputs for the highest height seen so far.

pub fn take_pending_inputs(&mut self, _metrics: &Metrics) -> Vec<Input<Ctx>>

where Ctx: Context,

Take all inputs that are pending for the specified height and remove from the input queue.

pub fn print_state(&self)

pub fn is_active_validator(&self) -> bool

Check if this node is an active validator.

Returns true only if:

• Consensus is enabled in the configuration, AND
• This node is present in the current validator set

pub fn round_certificate(&self) -> Option<&EnterRoundCertificate<Ctx>>