Struct Consensus

pub struct Consensus {
    pub blockchain: Blockchain,
    pub confirmation_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 (confirmed) blockchain

confirmation_threshold: usize

Fork size(length) after which it can be confirmed

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, confirmation_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 confirmation(&self) -> Result<Option<usize>>

Check if best fork proposals can be confirmed. Consensus confirmation 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 (confirme).

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

pub async fn get_fork_header_hash( &self, height: u32, fork_header: &HeaderHash, ) -> Result<Option<HeaderHash>>

Auxiliary function to retrieve the fork header hash of provided height. The fork is identified by the provided header hash.

pub async fn get_fork_headers( &self, headers: &[HeaderHash], fork_header: &HeaderHash, ) -> Result<Vec<Header>>

Auxiliary function to retrieve the fork headers of provided hashes. The fork is identified by the provided header hash. If fork doesn’t exists, an empty vector is returned.

pub async fn get_fork_proposals( &self, headers: &[HeaderHash], fork_header: &HeaderHash, ) -> Result<Vec<Proposal>>

Auxiliary function to retrieve the fork proposals of provided hashes. The fork is identified by the provided header hash. If fork doesn’t exists, an empty vector is returned.

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

Auxiliary function to retrieve a fork proposals, starting from provided tip. If provided tip is too far behind, unknown, or fork doesn’t exists, an empty vector is returned. The fork is identified by the optional provided header hash. If its None, we use our best fork.

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 reset_forks( &self, prefix: &[HeaderHash], confirmed_fork_index: &usize, confirmed_txs: &[Transaction], ) -> Result<()>

Auxiliary function to purge current forks and reset the ones starting with the provided prefix, excluding provided confirmed fork. Additionally, remove confirmed 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 confirmed fork.

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

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

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

Auxiliary function to reset PoW module.