Struct light_indexed_merkle_tree::copy::IndexedMerkleTreeCopy

pub struct IndexedMerkleTreeCopy<H, I, const HEIGHT: usize>(/* private fields */)
where
    H: Hasher,
    I: CheckedAdd + CheckedSub + Copy + Clone + Debug + PartialOrd + ToBytes + TryFrom<usize> + Unsigned,
    usize: From<I>;

Implementations

impl<H, I, const HEIGHT: usize> IndexedMerkleTreeCopy<H, I, HEIGHT>

where H: Hasher, I: CheckedAdd + CheckedSub + Copy + Clone + Debug + PartialOrd + ToBytes + TryFrom<usize> + Unsigned, usize: From<I>,

pub fn from_bytes_copy(bytes: &[u8]) -> Result<Self, IndexedMerkleTreeError>

Casts a byte slice into wrapped IndexedMerkleTree structure reference, including dynamic fields.

Purpose

This method is meant to be used mostly in Solana programs, where memory constraints are tight and we want to make sure no data is copied.

Methods from Deref<Target = IndexedMerkleTree<H, I, HEIGHT>>

pub fn indexed_changelog_index(&self) -> usize

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

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.

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 sequence_number(&self) -> usize

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.

pub fn get_changelog_event( &self, merkle_tree_account_pubkey: [u8; 32], first_changelog_index: usize, first_sequence_number: usize, num_changelog_entries: usize, ) -> Result<MerkleTreeEvent, ConcurrentMerkleTreeError>

Trait Implementations

impl<H, I, const HEIGHT: usize> Debug for IndexedMerkleTreeCopy<H, I, HEIGHT>

where H: Hasher + Debug, I: CheckedAdd + CheckedSub + Copy + Clone + Debug + PartialOrd + ToBytes + TryFrom<usize> + Unsigned + Debug, usize: From<I>,

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

Formats the value using the given formatter.

impl<H, I, const HEIGHT: usize> Deref for IndexedMerkleTreeCopy<H, I, HEIGHT>

where H: Hasher, I: CheckedAdd + CheckedSub + Copy + Clone + Debug + PartialOrd + ToBytes + TryFrom<usize> + Unsigned, usize: From<I>,

type Target = IndexedMerkleTree<H, I, HEIGHT>

The resulting type after dereferencing.

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

Dereferences the value.