Struct accumulator::MerkleAccumulator

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

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).