Struct BatchedQueueAccount

pub struct BatchedQueueAccount<'a> {
    pub value_vecs: [ZeroCopyVecU64<'a, [u8; 32]>; 2],
    pub hash_chain_stores: [ZeroCopyVecU64<'a, [u8; 32]>; 2],
    /* private fields */
}

Batched queue zero copy account. Used for output queues in light protocol. Output queues store compressed account hashes, to be appended to the associated batched Merkle tree in batches with a zero-knowledge proof (zkp), ie. it stores hashes and commits these to hash chains. Each hash chain is used as public input for a batch append zkp.

An output queue is configured with:

1. 2 batches
2. 2 value vecs (one for each batch) value vec length = batch size
3. 2 hash chain vecs (one for each batch) hash chain store length = batch size /zkp batch size

Default config:

• 50,000 batch size
• 500 zkp batch size

Initialization:

• an output queue is initialized in combination with a state Merkle tree
• init_batched_state_merkle_tree_from_account_info

For deserialization use:

• in program: output_from_account_info
• in client: output_from_bytes

To insert a value the account compression program uses:

• insert_into_current_batch

A compressed account can be spent or read while in the output queue.

To spend, the account compression program uses:

• check_leaf_index_could_exist_in_batches in combination with prove_inclusion_by_index_and_zero_out_leaf

To read, light the system program uses:

• prove_inclusion_by_index

Fields

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

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

Implementations

impl<'a> BatchedQueueAccount<'a>

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

Deserialize an output BatchedQueueAccount from account info. Should be used in solana programs. Checks that:

1. the program owner is the light account compression program,
2. discriminator,
3. queue type is output queue type.

pub fn output_from_bytes( account_data: &'a mut [u8], ) -> Result<BatchedQueueAccount<'a>, BatchedMerkleTreeError>

Deserialize a BatchedQueueAccount from bytes. Should only be used in client. Checks the discriminator and queue type.

pub fn init( account_data: &'a mut [u8], metadata: QueueMetadata, output_queue_batch_size: u64, output_queue_zkp_batch_size: u64, num_iters: u64, bloom_filter_capacity: u64, pubkey: Pubkey, ) -> Result<BatchedQueueAccount<'a>, BatchedMerkleTreeError>

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

Insert a value into the current batch of this output queue account.

1. insert value into a value vec and hash chain store.
2. Increment next_index.

pub fn prove_inclusion_by_index( &mut self, leaf_index: u64, hash_chain_value: &[u8; 32], ) -> Result<bool, BatchedMerkleTreeError>

Proves inclusion of leaf index if it exists in one of the batches.

1. Iterate over all batches
2. Check if leaf index could exist in the batch. 2.1 If yes, check whether value at index is equal to hash_chain_value. Throw error if not.
3. Return true if leaf index exists in one of the batches.

Note, this method does not fail but returns false if the leaf index is out of range for any batch.

pub fn prove_inclusion_by_index_and_zero_out_leaf( &mut self, leaf_index: u64, hash_chain_value: &[u8; 32], prove_by_index: bool, ) -> Result<(), BatchedMerkleTreeError>

Zero out a leaf by index if it exists in the queues hash_chain_value vec. If prove_by_index is true fail if leaf is not found.

pub fn get_metadata(&self) -> &BatchedQueueMetadata

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

pub fn get_num_inserted_in_current_batch(&self) -> u64

Returns the number of elements inserted in the current batch. If current batch state is inserted, returns 0.

pub fn is_associated(&self, pubkey: &Pubkey) -> bool

Returns true if the pubkey is the associated Merkle tree of the queue.

pub fn check_is_associated( &self, pubkey: &Pubkey, ) -> Result<(), BatchedMerkleTreeError>

Check if the pubkey is the associated Merkle tree of the queue.

pub fn tree_is_full(&self) -> bool

Returns true if the tree is full.

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

Check if the tree is full.

pub fn pubkey(&self) -> &Pubkey

Methods from Deref<Target = BatchedQueueMetadata>

pub const LEN: usize = 552usize

pub fn init( &mut self, meta_data: QueueMetadata, batch_size: u64, zkp_batch_size: u64, bloom_filter_capacity: u64, num_iters: u64, queue_pubkey: &Pubkey, ) -> Result<(), BatchedMerkleTreeError>

Trait Implementations

impl<'a> Debug for BatchedQueueAccount<'a>

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

Formats the value using the given formatter.

impl Deref for BatchedQueueAccount<'_>

type Target = BatchedQueueMetadata

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for BatchedQueueAccount<'_>

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

Mutably dereferences the value.

impl Discriminator for BatchedQueueAccount<'_>

const LIGHT_DISCRIMINATOR: [u8; 8]

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

fn discriminator() -> [u8; 8]

impl<'a> PartialEq for BatchedQueueAccount<'a>

fn eq(&self, other: &BatchedQueueAccount<'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 BatchedQueueAccount<'a>