Struct BatchedMerkleTreeAccount

pub struct BatchedMerkleTreeAccount<'a> {
    pub root_history: ZeroCopyCyclicVecU64<'a, [u8; 32]>,
    pub bloom_filter_stores: [&'a mut [u8]; 2],
    pub hash_chain_stores: [ZeroCopyVecU64<'a, [u8; 32]>; 2],
    /* private fields */
}

Batched Merkle tree zero copy account. The account is used to batched state and address Merkle trees, plus the input and address queues, in the Light Protocol account compression program.

Tree roots can be used in zk proofs outside of Light Protocol programs.

To access a tree root by index use:

• get_state_root_by_index
• get_address_root_by_index

Fields

root_history: ZeroCopyCyclicVecU64<'a, [u8; 32]>

bloom_filter_stores: [&'a mut [u8]; 2]

hash_chain_stores: [ZeroCopyVecU64<'a, [u8; 32]>; 2]

Implementations

impl<'a> BatchedMerkleTreeAccount<'a>

pub fn get_state_root_by_index<A: AccountInfoTrait>( account_info: &A, index: usize, ) -> Result<[u8; 32], BatchedMerkleTreeError>

Checks state Merkle tree account and returns the root.

pub fn get_address_root_by_index<A: AccountInfoTrait>( account_info: &A, index: usize, ) -> Result<[u8; 32], BatchedMerkleTreeError>

Checks address Merkle tree account and returns the root.

pub fn state_from_account_info<A: AccountInfoTrait>( account_info: &A, ) -> Result<BatchedMerkleTreeAccount<'a>, BatchedMerkleTreeError>

Deserialize a batched state Merkle tree from account info. Should be used in solana programs. Checks that:

1. the program owner is the light account compression program,
2. discriminator,
3. tree type is batched state tree type.

pub fn state_from_bytes( account_data: &'a mut [u8], pubkey: &Pubkey, ) -> Result<BatchedMerkleTreeAccount<'a>, BatchedMerkleTreeError>

Deserialize a state BatchedMerkleTreeAccount from bytes. Should only be used in client. Checks the discriminator and tree type.

pub fn address_from_account_info<A: AccountInfoTrait>( account_info: &A, ) -> Result<BatchedMerkleTreeAccount<'a>, BatchedMerkleTreeError>

Deserialize a batched address Merkle tree from account info. Should be used in solana programs. Checks that:

1. the program owner is the light account compression program,
2. discriminator,
3. tree type is batched address tree type.

pub fn address_from_bytes( account_data: &'a mut [u8], pubkey: &Pubkey, ) -> Result<BatchedMerkleTreeAccount<'a>, BatchedMerkleTreeError>

Deserialize a state BatchedMerkleTreeAccount from bytes. Should only be used in client. Checks the discriminator and tree type.

pub fn init( account_data: &'a mut [u8], pubkey: &Pubkey, metadata: MerkleTreeMetadata, root_history_capacity: u32, input_queue_batch_size: u64, input_queue_zkp_batch_size: u64, height: u32, num_iters: u64, bloom_filter_capacity: u64, tree_type: TreeType, ) -> Result<BatchedMerkleTreeAccount<'a>, BatchedMerkleTreeError>

pub fn update_tree_from_output_queue_account_info<A: AccountInfoTrait>( &mut self, queue_account_info: &A, instruction_data: InstructionDataBatchAppendInputs, ) -> Result<MerkleTreeEvent, BatchedMerkleTreeError>

Update the tree from the output queue account.

1. Checks that the tree and queue are associated.
2. Updates the tree with the output queue account.
3. Returns the batch append event.

pub fn update_tree_from_output_queue_account( &mut self, queue_account: &mut BatchedQueueAccount<'_>, instruction_data: InstructionDataBatchAppendInputs, ) -> Result<MerkleTreeEvent, BatchedMerkleTreeError>

Update the tree from the output queue account.

1. Create public inputs hash.
2. Verify update proof and update tree account. 2.1. Verify proof. 2.2. Increment sequence number. 2.3. Increment next index. 2.4. Append new root to root history.
3. Mark zkp batch as inserted in the merkle tree. 3.1. Checks that the batch is ready. 3.2. Increment the number of inserted zkps. 3.3. If all zkps are inserted, set batch state to inserted.
4. Increment next full batch index if inserted.
5. Zero out previous batch bloom filter of input queue if current batch is 50% inserted.
6. Return the batch append event.

Note: when proving inclusion by index in value array we need to insert the value into a bloom_filter once it is inserted into the tree. Check this with get_num_inserted_zkps

pub fn update_tree_from_input_queue( &mut self, instruction_data: InstructionDataBatchNullifyInputs, ) -> Result<MerkleTreeEvent, BatchedMerkleTreeError>

Update the tree from the input queue account.

pub fn update_tree_from_address_queue( &mut self, instruction_data: InstructionDataAddressAppendInputs, ) -> Result<MerkleTreeEvent, BatchedMerkleTreeError>

Update the tree from the address queue account.

pub fn insert_nullifier_into_queue( &mut self, compressed_account_hash: &[u8; 32], leaf_index: u64, tx_hash: &[u8; 32], current_slot: &u64, ) -> Result<(), BatchedMerkleTreeError>

Insert nullifier into current batch.

1. Check that the tree is a state tree.
2. Create nullifier Hash(value,leaf_index, tx_hash).
3. Insert nullifier into current batch. 3.1. Insert compressed_account_hash into bloom filter. (bloom filter enables non-inclusion proofs in later txs) 3.2. Add nullifier to leaves hash chain. (Nullification means, the compressed_account_hash in the tree, is overwritten with a nullifier hash) 3.3. Check that compressed_account_hash does not exist in any other bloom filter.

pub fn insert_address_into_queue( &mut self, address: &[u8; 32], current_slot: &u64, ) -> Result<(), BatchedMerkleTreeError>

pub fn get_root_index(&self) -> u32

Return the latest root index.

pub fn get_root(&self) -> Option<[u8; 32]>

Return the latest root of the tree.

pub fn get_root_by_index(&self, index: usize) -> Option<&[u8; 32]>

Return root from the root history by index.

pub fn get_metadata(&self) -> &BatchedMerkleTreeMetadata

Return a reference to the metadata of the tree.

pub fn get_metadata_mut(&mut self) -> &mut BatchedMerkleTreeMetadata

Return a mutable reference to the metadata of the tree.

pub fn check_input_queue_non_inclusion( &mut self, value: &[u8; 32], ) -> Result<(), BatchedMerkleTreeError>

Check non-inclusion in all bloom filters which are not zeroed.

pub fn tree_is_full(&self) -> bool

pub fn check_queue_next_index_reached_tree_capacity( &self, ) -> Result<(), BatchedMerkleTreeError>

pub fn check_tree_is_full(&self) -> Result<(), BatchedMerkleTreeError>

pub fn get_associated_queue(&self) -> &Pubkey

pub fn pubkey(&self) -> &Pubkey

Methods from Deref<Target = BatchedMerkleTreeMetadata>

pub const LEN: usize = 680usize

pub fn get_account_size(&self) -> Result<usize, BatchedMerkleTreeError>

Trait Implementations

impl<'a> Debug for BatchedMerkleTreeAccount<'a>

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

Formats the value using the given formatter.

impl Deref for BatchedMerkleTreeAccount<'_>

type Target = BatchedMerkleTreeMetadata

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for BatchedMerkleTreeAccount<'_>

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

Mutably dereferences the value.

impl Discriminator for BatchedMerkleTreeAccount<'_>

const LIGHT_DISCRIMINATOR: [u8; 8]

const LIGHT_DISCRIMINATOR_SLICE: &'static [u8] = b"BatchMta"

fn discriminator() -> [u8; 8]

impl<'a> PartialEq for BatchedMerkleTreeAccount<'a>

fn eq(&self, other: &BatchedMerkleTreeAccount<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for BatchedMerkleTreeAccount<'a>