Struct massa_consensus_worker::state::ConsensusState

pub struct ConsensusState {

    pub config: ConsensusConfig,
    pub channels: ConsensusChannels,
    pub storage: Storage,
    pub genesis_hashes: Vec<BlockId>,
    pub gi_head: PreHashMap<BlockId, PreHashSet<BlockId>>,
    pub max_cliques: Vec<Clique>,
    pub active_index_without_ops: PreHashSet<BlockId>,
    pub save_final_periods: Vec<u64>,
    pub latest_final_blocks_periods: Vec<(BlockId, u64)>,
    pub blocks_state: BlocksState,
    pub best_parents: Vec<(BlockId, u64)>,
    pub to_propagate: PreHashMap<BlockId, Storage>,
    pub attack_attempts: Vec<BlockId>,
    pub new_final_blocks: PreHashSet<BlockId>,
    pub new_stale_blocks: PreHashMap<BlockId, (Address, Slot)>,
    pub launch_time: MassaTime,
    pub final_block_stats: VecDeque<(MassaTime, Address, bool)>,
    pub protocol_blocks: VecDeque<(MassaTime, BlockId)>,
    pub stale_block_stats: VecDeque<MassaTime>,
    pub stats_history_timespan: MassaTime,
    pub stats_desync_detection_timespan: MassaTime,
    pub wishlist: PreHashMap<BlockId, Option<SecuredHeader>>,
    pub prev_blockclique: PreHashMap<BlockId, Slot>,
    pub nonfinal_active_blocks_per_slot: HashMap<Slot, PreHashSet<BlockId>>,
    pub(crate) massa_metrics: MassaMetrics,
}

Fields

config: ConsensusConfig

Configuration

channels: ConsensusChannels

Channels to communicate with other modules

storage: Storage

Storage

genesis_hashes: Vec<BlockId>

Block ids of genesis blocks

gi_head: PreHashMap<BlockId, PreHashSet<BlockId>>

Incompatibility graph: maps a block id to the block ids it is incompatible with One entry per Active Block

max_cliques: Vec<Clique>

All the cliques

active_index_without_ops: PreHashSet<BlockId>

ids of active blocks without ops

save_final_periods: Vec<u64>

Save of latest periods

latest_final_blocks_periods: Vec<(BlockId, u64)>

One (block id, period) per thread

blocks_state: BlocksState

All the blocks we know about and their status

best_parents: Vec<(BlockId, u64)>

One (block id, period) per thread TODO not sure I understand the difference with latest_final_blocks_periods

to_propagate: PreHashMap<BlockId, Storage>

Blocks that need to be propagated

attack_attempts: Vec<BlockId>

List of block ids we think are attack attempts

new_final_blocks: PreHashSet<BlockId>

Newly final blocks

new_stale_blocks: PreHashMap<BlockId, (Address, Slot)>

Newly stale block mapped to creator and slot

launch_time: MassaTime

time at which the node was launched (used for de-synchronization detection)

final_block_stats: VecDeque<(MassaTime, Address, bool)>

Final block stats (time, creator, is_from_protocol)

protocol_blocks: VecDeque<(MassaTime, BlockId)>

Blocks that come from protocol used for stats and ids are removed when inserted in final_block_stats

stale_block_stats: VecDeque<MassaTime>

Stale block timestamp

stats_history_timespan: MassaTime

the time span considered for stats

stats_desync_detection_timespan: MassaTime

the time span considered for de-synchronization detection

wishlist: PreHashMap<BlockId, Option<SecuredHeader>>

blocks we want

prev_blockclique: PreHashMap<BlockId, Slot>

previous blockclique notified to Execution

nonfinal_active_blocks_per_slot: HashMap<Slot, PreHashSet<BlockId>>

Blocks indexed by slot (used for multi-stake limiting). Blocks should be saved in this map when we receive the header or the full block directly.

massa_metrics: MassaMetrics

massa metrics

Implementations

impl ConsensusState

pub fn insert_parents_descendants( &mut self, add_block_id: BlockId, add_block_slot: Slot, parents_hash: Vec<BlockId>, )

pub fn compute_fitness_find_blockclique( &mut self, add_block_id: &BlockId, ) -> Result<usize, ConsensusError>

pub fn list_stale_blocks(&self, fitness_threshold: u64) -> PreHashSet<BlockId>

pub fn remove_block(&mut self, add_block_id: &BlockId, block_id: &BlockId)

pub fn list_final_blocks(&self) -> Result<PreHashSet<BlockId>, ConsensusError>

pub fn get_blockclique(&self) -> PreHashSet<BlockId>

get the clique of higher fitness

pub fn mark_final_blocks( &mut self, add_block_id: &BlockId, final_blocks: PreHashSet<BlockId>, ) -> Result<(), ConsensusError>

impl ConsensusState

pub fn rec_process( &mut self, to_ack: BTreeSet<(Slot, BlockId)>, current_slot: Option<Slot>, ) -> Result<(), ConsensusError>

Acknowledge a set of items recursively and process them

Arguments:

• to_ack: the set of items to acknowledge and process
• current_slot: the current slot when this function is called

Returns:

Success or error if an error happened during the processing of items

fn process( &mut self, block_id: BlockId, current_slot: Option<Slot>, ) -> Result<BTreeSet<(Slot, BlockId)>, ConsensusError>

Acknowledge a single item, return a set of items to re-ack

Arguments:

• block_id: the id of the block to acknowledge
• current_slot: the current slot when this function is called

Returns:

A list of items to re-ack and process or an error if the process of an item failed

fn add_block_to_graph( &mut self, add_block_id: BlockId, parents_hash_period: Vec<(BlockId, u64)>, add_block_slot: Slot, incomp: PreHashSet<BlockId>, inherited_incomp_count: usize, ) -> Result<(), ConsensusError>

Add a block to the graph and update the cliques, the graph dependencies and incompatibilities

Arguments:

• add_block_id: Block id of the block to add
• parents_hash_period: Ids and periods of the parents of the block to add
• add_block_creator: Creator of the block to add
• add_block_slot: Slot of the block to add
• incomp: Block ids of the blocks incompatible with the block to add
• fitness: Fitness of the block to add
• storage: Storage containing all the data of the block to add

Returns:

Success or error if any steps failed

pub fn maybe_note_attack_attempt( &mut self, reason: &DiscardReason, hash: &BlockId, )

Note an attack attempt if the discard reason indicates one.

fn notify_execution(&mut self, finalized_blocks: HashMap<Slot, BlockId>)

Notify execution about blockclique changes and finalized blocks.

Arguments:

• finalized_blocks: Block that became final and need to be send to execution

pub fn block_db_changed(&mut self) -> Result<(), ConsensusError>

call me if the block database changed Processing of final blocks, pruning.

1. propagate blocks
2. Notify of attack attempts
3. get new final blocks
4. get blockclique
5. notify Execution
6. Process new final blocks
7. Notify pool of new final ops
8. Notify PoS of final blocks
9. notify protocol of block wish list
10. note new latest final periods (prune graph if changed)
11. add stale blocks to stats

impl ConsensusState

pub fn register_block_header( &mut self, block_id: BlockId, header: SecuredHeader, current_slot: Option<Slot>, ) -> Result<(), ConsensusError>

Register a block header in the graph. Ignore genesis hashes.

Arguments:

• block_id: the block id
• header: the header to register
• current_slot: the slot when this function is called

Returns:

Success or error if the header is invalid or too old

pub fn register_block( &mut self, block_id: BlockId, slot: Slot, current_slot: Option<Slot>, storage: Storage, created: bool, ) -> Result<(), ConsensusError>

Register a new full block in the graph. Ignore genesis hashes.

Arguments:

• block_id: the block id
• slot: the slot of the block
• current_slot: the slot when this function is called
• storage: Storage containing the whole content of the block
• created: is the block created by the node or received from the network

Returns:

Success or error if the block is invalid or too old

pub fn mark_invalid_block(&mut self, block_id: &BlockId, header: SecuredHeader)

Mark a block that is in the graph as invalid.

Arguments:

• block_id: Block id of the block to mark as invalid
• header: Header of the block to mark as invalid

impl ConsensusState

fn prune_active( &mut self, ) -> Result<PreHashMap<BlockId, ActiveBlock>, ConsensusError>

prune active blocks and return final blocks, return discarded final blocks

fn prune_slot_waiting(&mut self)

fn prune_discarded(&mut self) -> Result<(), ConsensusError>

fn prune_waiting_for_dependencies(&mut self) -> Result<(), ConsensusError>

fn prune_nonfinal_blocks_per_slot(&mut self)

Clear the cache of blocks indexed by slot. Slot are not saved anymore, when the block in the same thread with a equal or greater period is finalized.

pub fn prune(&mut self) -> Result<(), ConsensusError>

Clear all the caches and blocks waiting to be processed to avoid too much memory usage.

impl ConsensusState

pub fn get_stats(&self) -> Result<ConsensusStats, ConsensusError>

Calculate and return stats about consensus

pub fn stats_tick(&mut self) -> Result<(), ConsensusError>

Must be called each tick to update stats. Will detect if a desynchronization happened

fn check_desync(&mut self) -> Result<(), ConsensusError>

Helper function for stats_tick. Checks if there are any final blocks is coming from protocol if none => we are probably desync Ignore if we are before the last_start_period

fn prune_stats(&mut self) -> Result<(), ConsensusError>

Remove old stats from consensus storage

impl ConsensusState

pub fn slot_tick(&mut self, current_slot: Slot) -> Result<(), ConsensusError>

This function should be called each tick and will check if there is a block in the graph that should be processed at this slot, and if so, process it.

Arguments:

• current_slot: the current slot

Returns:

Error if the process of a block returned an error.

impl ConsensusState

pub(crate) fn detect_multistake(&mut self, header: &SecuredHeader) -> bool

pub(crate) fn convert_block_header( &mut self, block_id: BlockId, header: SecuredHeader, current_slot: Option<Slot>, ) -> Option<BlockStatus>

Check if the header is valid and if it could be processed when we will receive the full block

fn convert_to_discard_block_header( &mut self, reason: DiscardReason, block_id: BlockId, header: SecuredHeader, ) -> BlockStatus

Store in our indexes that we discarded this block or block header

Arguments:

reason: Read of the discard block_id: ID of the block header: header to save

pub(crate) fn check_header( &self, block_id: &BlockId, header: &SecuredHeader, current_slot: Option<Slot>, ) -> HeaderCheckOutcome

Process an incoming header.

Checks performed:

• Number of parents matches thread count.
• Slot above 0.
• Valid thread.
• Check that the block is older than the latest final one in thread.
• Check if it was the creator’s turn to create this block.
• Check parents are present.
• Check the topological consistency of the parents.
• Check endorsements.
• Check thread incompatibility test.
• Check grandpa incompatibility test.
• Check if the block is incompatible with a parent.
• Check if the block is incompatible with a final block.

pub fn check_endorsements( &self, header: &SecuredHeader, ) -> EndorsementsCheckOutcome

check endorsements:

• endorser was selected for that (slot, index)
• endorsed slot is parent_in_own_thread slot

impl ConsensusState

pub fn get_full_active_block( &self, block_id: &BlockId, ) -> Option<(&ActiveBlock, &StorageOrBlock)>

Get a full active block

fn try_get_full_active_block( &self, block_id: &BlockId, ) -> Result<(&ActiveBlock, &StorageOrBlock), ConsensusError>

Get a full active block

Returns an error if it was not found

pub fn get_clique_count(&self) -> usize

pub fn get_blockclique_block_at_slot(&self, slot: &Slot) -> Option<BlockId>

get the blockclique (or final) block ID at a given slot, if any

pub fn get_latest_blockclique_block_at_slot(&self, slot: &Slot) -> BlockId

get the latest blockclique (or final) block ID at a given slot, if any

pub fn get_block_status(&self, block_id: &BlockId) -> BlockGraphStatus

fn list_latest_final_blocks_at( &self, slot: Slot, ) -> Result<Vec<(BlockId, u64)>, ConsensusError>

list the latest final blocks at the given slot

exclusively used by list_required_active_blocks

fn list_earliest_blocks_of( &self, block_ids: &PreHashSet<BlockId>, end_slot: Option<Slot>, ) -> Result<Vec<(BlockId, u64)>, ConsensusError>

list the earliest blocks of the given block id list

exclusively used by list_required_active_blocks

fn add_active_blocks_after( &self, kept_blocks: &mut PreHashSet<BlockId>, lower_bound: &[(BlockId, u64)], end_slot: Option<Slot>, )

adds to the given container every active block coming after the lower bound

exclusively used by list_required_active_blocks

pub fn list_required_active_blocks( &self, end_slot: Option<Slot>, ) -> Result<PreHashSet<BlockId>, ConsensusError>

list_required_active_blocks algo:

if end_slot is None: set effective_latest_finals to be the IDs of the self.latest_final_blocks else set effective_latest_finals to be the IDs of the Active Final blocks that have the highest period in each thread but are before end_slot (included)

create a kept_blocks list of block IDs to keep initialize it with effective_latest_finals as well as all the active blocks that are after the effective_latest_finals of their thread (included) (but before end_slot (included) if it is Some)

do the following 2 times: extend kept_blocks with the parents of the current kept_blocks fill holes by adding to kept_blocks all the active block IDs whose slot is after the earliest kept_blocks of their thread (included) (but before end_slot (included) if it is Some)

return kept_blocks

pub fn extract_block_graph_part( &self, slot_start: Option<Slot>, slot_end: Option<Slot>, ) -> Result<BlockGraphExport, ConsensusError>

pub fn get_all_final_blocks( &self, ) -> HashMap<BlockId, (Slot, ExecutionBlockMetadata)>

Gets all stored final blocks, not only the still-useful ones This is used when initializing Execution from Consensus. Since the Execution bootstrap snapshot is older than the Consensus snapshot, we might need to signal older final blocks for Execution to catch up.

pub fn get_block_wishlist( &self, ) -> Result<PreHashMap<BlockId, Option<SecuredHeader>>, ConsensusError>

get the current block wish list, including the operations hash.

pub fn get_active_block_and_descendants( &self, block_id: &BlockId, ) -> PreHashSet<BlockId>

Gets a block and all its descendants

Argument

• hash : hash of the given block

Trait Implementations

impl Clone for ConsensusState

fn clone(&self) -> ConsensusState

Returns a copy of the value.

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

Performs copy-assignment from source.