Struct Consensus

pub struct Consensus {
    pub parameters: ChainParams,
}

This struct contains all the information and methods needed to validate a block, it is used by the ChainState to validate blocks and transactions.

Fields

parameters: ChainParams

The parameters of the chain we are validating, it is usually hardcoded constants. See ChainParams for more information.

Implementations

impl Consensus

pub fn get_subsidy(&self, height: u32) -> u64

Returns the amount of block subsidy to be paid in a block, given it’s height.

The Bitcoin Core source can be found here.

pub fn verify_block_transactions( height: u32, utxos: HashMap<OutPoint, UtxoData>, transactions: &[Transaction], subsidy: u64, verify_script: bool, flags: c_uint, ) -> Result<(), BlockchainError>

Verify if all transactions in a block are valid. Here we check the following:

• The block must contain at least one transaction, and this transaction must be coinbase
• The first transaction in the block must be coinbase
• The coinbase transaction must have the correct value (subsidy + fees)
• The block must not create more coins than allowed
• All transactions must be valid, as verified by Consensus::verify_transaction

pub fn verify_transaction( transaction: &Transaction, utxos: &mut HashMap<OutPoint, UtxoData>, height: u32, _verify_script: bool, _flags: c_uint, ) -> Result<(Amount, Amount), BlockchainError>

Verifies a single, non-coinbase transaction. To verify (the structure of) a coinbase transaction, use Consensus::verify_coinbase.

This function checks that the transaction:

• Has at least one input and one output
• Doesn’t have null PrevOuts (reserved only for coinbase transactions)
• Doesn’t spend more coins than it claims in the inputs
• Doesn’t “move” more coins than allowed (at most 21 million)
• Spends mature coins, in case any input refers to a coinbase transaction
• Has valid scripts (if we don’t assume them), and within the allowed size

fn verify_input_scripts( transaction: &Transaction, utxos: &mut HashMap<OutPoint, UtxoData>, flags: c_uint, ) -> Result<(), BlockchainError>

pub fn check_transaction_context_free( transaction: &Transaction, ) -> Result<Amount, BlockchainError>

Performs consensus checks that are independent of the spent outputs (non-coinbase only). Returns the total output value as an [Amount].

pub fn check_block( &self, block: &Block, height: u32, ) -> Result<Vec<Txid>, BlockchainError>

Runs inexpensive, consensus-critical block checks that don’t require script execution. If successful, returns the list of [Txid]s computed for the merkle root check.

This verifies:

• the header merkle root matches the block’s txids
• BIP34 coinbase-encoded height once activated (at bip34_height)
• if there are SegWit transactions, the witness commitment is present and correct
• total block weight is within the 4,000,000 WU limit

pub fn check_merkle_root(block: &Block) -> Option<Vec<Txid>>

Checks if the merkle root of the header matches the merkle root of the transaction list.

Unlike [Block::check_merkle_root], this function returns the list of computed [Txid]s if the merkle roots matched, or None otherwise.

The merkle root is computed in the same way as [Block::compute_merkle_root].

fn get_utxo<'a, F: Fn() -> Txid>( input: &TxIn, utxos: &'a HashMap<OutPoint, UtxoData>, txid: F, ) -> Result<&'a UtxoData, TransactionError>

Returns the TxOut being spent by the given input.

Fails if the UTXO is not present in the given hashmap.

fn validate_locktime( input: &TxIn, transaction: &Transaction, height: u32, ) -> Result<(), BlockValidationErrors>

fn validate_script_size<F: Fn() -> Txid>( script: &ScriptBuf, txid: F, ) -> Result<(), TransactionError>

Validates the script size and the number of sigops in a scriptpubkey or scriptsig.

pub fn verify_coinbase(tx: &Transaction) -> Result<(), TransactionError>

Validates the coinbase transaction’s input. The checks on the outputs require context about the block and are performed by Consensus::verify_block_transactions.

pub fn get_bip34_height(block: &Block) -> Option<u32>

pub fn check_bip94_time( block: &BlockHeader, prev_block: &BlockHeader, ) -> Result<(), BlockValidationErrors>

Checks if a testnet4 block is compliant with the anti-timewarp rules of BIP94.

a. The block’s nTime field MUST be greater than or equal to the nTime field of the immediately prior block minus 600 seconds

pub fn calc_next_work_required( last_block: &BlockHeader, first_block: &BlockHeader, params: ChainParams, ) -> Target

Calculates the next target for the proof of work algorithm, given the first and last block headers inside a difficulty adjustment period.

pub fn update_acc( acc: &Stump, block: &Block, height: u32, proof: Proof, del_hashes: Vec<Hash>, ) -> Result<Stump, BlockchainError>

Updates our accumulator with the new block. This is done by calculating the new root hash of the accumulator, and then verifying the proof of inclusion of the deleted nodes. If the proof is valid, we return the new accumulator. Otherwise, we return an error. This function is pure, it doesn’t modify the accumulator, but returns a new one.

fn contains_unspendable_utxo(del_hashes: &[Hash]) -> bool

Trait Implementations

impl Clone for Consensus

fn clone(&self) -> Consensus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Consensus

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

Formats the value using the given formatter.

impl From<Network> for Consensus

fn from(network: Network) -> Self

Converts to this type from the input type.