Struct grin_chain::txhashset::Extension

pub struct Extension<'a> { /* fields omitted */ }

Allows the application of new blocks on top of the txhashset in a reversible manner within a unit of work provided by the extending function.

Methods

impl<'a> Extension<'a>

pub fn head(&self) -> Tip

The head representing the furthest extent of the current extension.

pub fn utxo_view(&'a self, header_ext: &'a HeaderExtension<'a>) -> UTXOView<'a>

Build a view of the current UTXO set based on the output PMMR and the provided header extension.

pub fn apply_block(
    &mut self,
    b: &Block,
    batch: &Batch
) -> Result<Vec<CommitPos>, Error>

Apply a new block to the current txhashet extension (output, rangeproof, kernel MMRs). Returns a vec of commit_pos representing the pos and height of the outputs spent by this block.

pub fn merkle_proof(
    &self,
    output: &OutputIdentifier,
    batch: &Batch
) -> Result<MerkleProof, Error>

Build a Merkle proof for the given output and the block this extension is currently referencing. Note: this relies on the MMR being stable even after pruning/compaction. We need the hash of each sibling pos from the pos up to the peak including the sibling leaf node which may have been removed.

pub fn snapshot(&mut self, batch: &Batch) -> Result<(), Error>

Saves a snapshot of the output and rangeproof MMRs to disk. Specifically - saves a snapshot of the utxo file, tagged with the block hash as filename suffix. Needed for fast-sync (utxo file needs to be rewound before sending across).

pub fn rewind(
    &mut self,
    header: &BlockHeader,
    batch: &Batch
) -> Result<(), Error>

Rewinds the MMRs to the provided block, rewinding to the last output pos and last kernel pos of that block.

pub fn roots(&self) -> Result<TxHashSetRoots, Error>

Current root hashes and sums (if applicable) for the Output, range proof and kernel MMRs.

pub fn validate_roots(&self, header: &BlockHeader) -> Result<(), Error>

Validate the MMR (output, rangeproof, kernel) roots against the latest header.

pub fn validate_sizes(&self, header: &BlockHeader) -> Result<(), Error>

Validate the header, output and kernel MMR sizes against the block header.

pub fn validate_kernel_sums(
    &self,
    genesis: &BlockHeader,
    header: &BlockHeader
) -> Result<(Commitment, Commitment), Error>

Validate full kernel sums against the provided header (for overage and kernel_offset). This is an expensive operation as we need to retrieve all the UTXOs and kernels from the respective MMRs. For a significantly faster way of validating full kernel sums see BlockSums.

pub fn validate(
    &self,
    genesis: &BlockHeader,
    fast_validation: bool,
    status: &dyn TxHashsetWriteStatus,
    header: &BlockHeader
) -> Result<(Commitment, Commitment), Error>

Validate the txhashset state against the provided block header. A "fast validation" will skip rangeproof verification and kernel signature verification.

pub fn force_rollback(&mut self)

Force the rollback of this extension, no matter the result

pub fn dump_output_pmmr(&self)

Dumps the output MMR. We use this after compacting for visual confirmation that it worked.

pub fn dump(&self, short: bool)

Dumps the state of the 3 MMRs to stdout for debugging. Short version only prints the Output tree.

pub fn sizes(&self) -> (u64, u64, u64)

Sizes of each of the MMRs

Trait Implementations

impl<'a> Committed for Extension<'a>

fn inputs_committed(&self) -> Vec<Commitment>

Vector of input commitments to verify.

fn outputs_committed(&self) -> Vec<Commitment>

Vector of output commitments to verify.

fn kernels_committed(&self) -> Vec<Commitment>

Vector of kernel excesses to verify.

fn sum_kernel_excesses(
    &self,
    offset: &BlindingFactor
) -> Result<(Commitment, Commitment), Error>

Gather the kernel excesses and sum them.

fn sum_commitments(&self, overage: i64) -> Result<Commitment, Error>

Gathers commitments and sum them.

fn verify_kernel_sums(
    &self,
    overage: i64,
    kernel_offset: BlindingFactor
) -> Result<(Commitment, Commitment), Error>

Verify the sum of the kernel excesses equals the sum of the outputs, taking into account both the kernel_offset and overage.