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.

Implementations

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,
    header_ext: &HeaderExtension<'_>,
    batch: &Batch<'_>
) -> Result<(), 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 apply_kernels(
    &mut self,
    kernels: &[TxKernel],
    height: u64,
    batch: &Batch<'_>
) -> Result<(), Error>

Apply kernels to the kernel MMR. Validate any NRD relative height locks via the "recent" kernel index. Note: This is used for both block processing and tx validation. In the block processing case we use the block height. In the tx validation case we use the "next" block height based on current chain head.

pub fn merkle_proof<T: AsRef<OutputIdentifier>>(
    &self,
    out_id: T,
    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.