Struct ConcurrentMerkleTreeZeroCopyMut

pub struct ConcurrentMerkleTreeZeroCopyMut<'a, H, const HEIGHT: usize>(/* private fields */)
where
    H: Hasher;

Implementations

impl<'a, H, const HEIGHT: usize> ConcurrentMerkleTreeZeroCopyMut<'a, H, HEIGHT>

where H: Hasher,

pub fn from_bytes_zero_copy_mut( bytes: &'a mut [u8], ) -> Result<Self, ConcurrentMerkleTreeError>

pub fn fill_non_dyn_fields_in_buffer( bytes: &mut [u8], height: usize, canopy_depth: usize, changelog_capacity: usize, roots_capacity: usize, ) -> Result<usize, ConcurrentMerkleTreeError>

pub fn from_bytes_zero_copy_init( bytes: &'a mut [u8], height: usize, canopy_depth: usize, changelog_capacity: usize, roots_capacity: usize, ) -> Result<Self, ConcurrentMerkleTreeError>

Methods from Deref<Target = ConcurrentMerkleTree<H, HEIGHT>>

pub fn init(&mut self) -> Result<(), ConcurrentMerkleTreeError>

Initializes the Merkle tree.

pub fn changelog_index(&self) -> usize

Returns the index of the current changelog entry.

pub fn root_index(&self) -> usize

Returns the index of the current root in the tree’s root buffer.

pub fn root(&self) -> [u8; 32]

Returns the current root.

pub fn current_index(&self) -> usize

pub fn next_index(&self) -> usize

pub fn inc_next_index(&mut self) -> Result<(), ConcurrentMerkleTreeError>

pub fn sequence_number(&self) -> usize

pub fn inc_sequence_number(&mut self) -> Result<(), ConcurrentMerkleTreeError>

pub fn rightmost_leaf(&self) -> [u8; 32]

pub fn update_proof_from_canopy( &self, leaf_index: usize, proof: &mut BoundedVec<[u8; 32]>, ) -> Result<(), ConcurrentMerkleTreeError>

pub fn changelog_entries( &self, changelog_index: usize, ) -> Result<Skip<CyclicBoundedVecIterator<'_, ChangelogEntry<HEIGHT>>>, ConcurrentMerkleTreeError>

Returns an iterator with changelog entries newer than the requested changelog_index.

pub fn update_proof_from_changelog( &self, changelog_index: usize, leaf_index: usize, proof: &mut BoundedVec<[u8; 32]>, ) -> Result<(), ConcurrentMerkleTreeError>

Updates the given Merkle proof.

The update is performed by checking whether there are any new changelog entries and whether they contain changes which affect the current proof. To be precise, for each changelog entry, it’s done in the following steps:

• Check if the changelog entry was directly updating the leaf_index we are trying to update.
  • If no (we check that condition first, since it’s more likely), it means that there is a change affecting the proof, but not the leaf. Check which element from our proof was affected by the change (using the critbit_index method) and update it (copy the new element from the changelog to our updated proof).
  • If yes, it means that the same leaf we want to update was already updated. In such case, updating the proof is not possible.

pub fn validate_proof( &self, leaf: &[u8; 32], leaf_index: usize, proof: &BoundedVec<[u8; 32]>, ) -> Result<(), ConcurrentMerkleTreeError>

Checks whether the given Merkle proof for the given node (with index i) is valid. The proof is valid when computing parent node hashes using the whole path of the proof gives the same result as the given root.

pub fn update( &mut self, changelog_index: usize, old_leaf: &[u8; 32], new_leaf: &[u8; 32], leaf_index: usize, proof: &mut BoundedVec<[u8; 32]>, ) -> Result<(usize, usize), ConcurrentMerkleTreeError>

Replaces the old_leaf under the leaf_index with a new_leaf, using the given proof and changelog_index (pointing to the changelog entry which was the newest at the time of preparing the proof).

pub fn append( &mut self, leaf: &[u8; 32], ) -> Result<(usize, usize), ConcurrentMerkleTreeError>

Appends a new leaf to the tree.

pub fn append_with_proof( &mut self, leaf: &[u8; 32], proof: &mut BoundedVec<[u8; 32]>, ) -> Result<(usize, usize), ConcurrentMerkleTreeError>

Appends a new leaf to the tree. Saves Merkle proof to the provided proof reference.

pub fn append_batch( &mut self, leaves: &[&[u8; 32]], ) -> Result<(usize, usize), ConcurrentMerkleTreeError>

Appends a batch of new leaves to the tree.

pub fn append_batch_with_proofs( &mut self, leaves: &[&[u8; 32]], proofs: &mut [&mut BoundedVec<[u8; 32]>], ) -> Result<(usize, usize), ConcurrentMerkleTreeError>

Appends a batch of new leaves to the tree. Saves Merkle proofs to the provided proofs slice.

Trait Implementations

impl<'a, H, const HEIGHT: usize> Debug for ConcurrentMerkleTreeZeroCopyMut<'a, H, HEIGHT>

where H: Hasher + Debug,

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

Formats the value using the given formatter.

impl<H, const HEIGHT: usize> Deref for ConcurrentMerkleTreeZeroCopyMut<'_, H, HEIGHT>

where H: Hasher,

type Target = ConcurrentMerkleTree<H, HEIGHT>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<H, const HEIGHT: usize> DerefMut for ConcurrentMerkleTreeZeroCopyMut<'_, H, HEIGHT>

where H: Hasher,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.