Struct darkfi::validator::consensus::Consensus

pub struct Consensus {
    pub blockchain: Blockchain,
    pub finalization_threshold: usize,
    pub forks: RwLock<Vec<Fork>>,
    pub module: RwLock<PoWModule>,
    pub append_lock: RwLock<()>,
}

This struct represents the information required by the consensus algorithm

Fields

blockchain: Blockchain

Canonical (finalized) blockchain

finalization_threshold: usize

Fork size(length) after which it can be finalized

forks: RwLock<Vec<Fork>>

Fork chains containing block proposals

module: RwLock<PoWModule>

Canonical blockchain PoW module state

append_lock: RwLock<()>

Lock to restrict when proposals appends can happen

Implementations

impl Consensus

pub fn new( blockchain: Blockchain, finalization_threshold: usize, pow_target: u32, pow_fixed_difficulty: Option<BigUint>, ) -> Result<Self>

Generate a new Consensus state.

pub async fn generate_empty_fork(&self) -> Result<()>

Generate a new empty fork.

pub async fn append_proposal( &self, proposal: &Proposal, verify_fees: bool, ) -> Result<()>

Given a proposal, the node verifys it and finds which fork it extends. If the proposal extends the canonical blockchain, a new fork chain is created.

pub async fn find_extended_fork( &self, proposal: &Proposal, ) -> Result<(Fork, Option<usize>)>

Given a proposal, find the fork chain it extends, and return its full clone. If the proposal extends the fork not on its tail, a new fork is created and we re-apply the proposals up to the extending one. If proposal extends canonical, a new fork is created. Additionally, we return the fork index if a new fork was not created, so caller can replace the fork.

pub async fn finalization(&self) -> Result<Option<usize>>

Check if best fork proposals can be finalized. Consensus finalization logic:

• If the current best fork has reached greater length than the security threshold, and no other fork exist with same rank, first proposal(s) in that fork can be appended to canonical blockchain (finalize).

When best fork can be finalized, first block(s) should be appended to canonical, and forks should be rebuilt.

pub async fn get_fork_proposals( &self, tip: HeaderHash, fork_tip: HeaderHash, limit: u32, ) -> Result<Vec<Proposal>>

Auxiliary function to retrieve a fork proposals, starting from provided tip. If provided tip is too far behind, or fork doesn’t exists, an empty vector is returned.

pub async fn best_fork_last_header(&self) -> Result<(u32, HeaderHash)>

Auxiliary function to retrieve current best fork last header. If no forks exist, grab the last header from canonical.

pub async fn get_best_fork_proposals( &self, tip: HeaderHash, limit: u32, ) -> Result<Vec<Proposal>>

Auxiliary function to retrieve current best fork proposals, starting from provided tip. If provided tip is too far behind, or fork doesn’t exists, an empty vector is returned.

pub async fn reset_forks( &self, prefix: &[HeaderHash], finalized_fork_index: &usize, finalized_txs: &[Transaction], ) -> Result<()>

Auxiliary function to purge current forks and reset the ones starting with the provided prefix, excluding provided finalized fork. Additionally, remove finalized transactions from the forks mempools, along with the unporposed transactions sled trees. This function assumes that the prefix blocks have already been appended to canonical chain from the finalized fork.

pub async fn purge_forks(&self) -> Result<()>

Auxiliary function to fully purge current forks and leave only a new empty fork.