Struct accumulator::MerkleAccumulator

pub struct MerkleAccumulator<R, H> { /* fields omitted */ }

In this live Merkle Accumulator algorithms.

Implementations

impl<R, H> MerkleAccumulator<R, H> where
    R: HashReader,
    H: CryptoHasher, 

pub fn append(
    reader: &R,
    num_existing_leaves: LeafCount,
    new_leaves: &[HashValue]
) -> Result<(HashValue, Vec<(Position, HashValue)>)>

Given an existing Merkle Accumulator (represented by num_existing_leaves and a reader that is able to fetch all existing frozen nodes), and a list of leaves to be appended, returns the result root hash and new nodes to be frozen.

pub fn get_proof(
    reader: &R,
    num_leaves: LeafCount,
    leaf_index: u64
) -> Result<AccumulatorProof<H>>

Get proof of inclusion of the leaf at leaf_index in this Merkle Accumulator of num_leaves leaves in total. Siblings are read via reader (or generated dynamically if they are non-frozen).

See diem_types::proof::AccumulatorProof for proof format.

pub fn get_consistency_proof(
    reader: &R,
    full_acc_leaves: LeafCount,
    sub_acc_leaves: LeafCount
) -> Result<AccumulatorConsistencyProof>

Gets a proof that shows the full accumulator is consistent with a smaller accumulator.

See diem_types::proof::AccumulatorConsistencyProof for proof format.

pub fn get_range_proof(
    reader: &R,
    full_acc_leaves: LeafCount,
    first_leaf_index: Option<u64>,
    num_leaves: LeafCount
) -> Result<AccumulatorRangeProof<H>>

Gets a proof that shows a range of leaves are part of the accumulator.

See diem_types::proof::AccumulatorRangeProof for proof format.

pub fn get_range_proof_positions(
    reader: &R,
    full_acc_leaves: LeafCount,
    first_leaf_index: Option<u64>,
    num_leaves: LeafCount
) -> Result<(Vec<Position>, Vec<Position>)>

See get_range_proof. This is the version of it that returns Positions only.

pub fn get_frozen_subtree_hashes(
    reader: &R,
    num_leaves: LeafCount
) -> Result<Vec<HashValue>>

From left to right, gets frozen subtree root hashes of the accumulator. For example, if the accumulator has 5 leaves, x and e are returned.

                root
               /    \
             /        \
           /            \
          x              o
        /   \           / \
       /     \         /   \
      o       o       o     placeholder
     / \     / \     / \
    a   b   c   d   e   placeholder

pub fn get_root_hash(reader: &R, num_leaves: LeafCount) -> Result<HashValue>

Get root hash at a specific version (hence num_leaves).