Struct Batch

#[repr(C)]
pub struct Batch {
    pub num_iters: u64,
    pub bloom_filter_capacity: u64,
    pub batch_size: u64,
    pub zkp_batch_size: u64,
    pub sequence_number: u64,
    pub start_index: u64,
    pub start_slot: u64,
    pub root_index: u32,
    /* private fields */
}

Batch structure that holds the metadata and state of a batch.

A batch:

• has a size and a number of zkp batches.
• size must be divisible by zkp batch size.
• is part of a queue, each queue has two batches.
• is inserted into the tree by zkp batch.

Fields

num_iters: u64

Number of iterations for the bloom_filter.

bloom_filter_capacity: u64

Theoretical capacity of the bloom_filter in bits. We want to make it much larger than batch_size to avoid false positives.

batch_size: u64

Number of elements in a batch.

zkp_batch_size: u64

Number of elements in a zkp batch. A batch consists out of one or more zkp batches.

sequence_number: u64

Sequence number when it is save to clear the batch without advancing to the saved root index.

start_index: u64

Start leaf index of the first

start_slot: u64

Slot of the first insertion into the batch. Indexers can use this slot to reindex inserted elements. Is not used for the batch itself.

root_index: u32

Implementations

impl Batch

pub fn new( num_iters: u64, bloom_filter_capacity: u64, batch_size: u64, zkp_batch_size: u64, start_index: u64, ) -> Self

pub fn get_state(&self) -> BatchState

Returns the state of the batch.

pub fn bloom_filter_is_zeroed(&self) -> bool

pub fn set_bloom_filter_to_zeroed(&mut self)

pub fn set_bloom_filter_to_not_zeroed(&mut self)

pub fn start_slot_is_set(&self) -> bool

pub fn set_start_slot(&mut self, start_slot: &u64)

pub fn advance_state_to_fill( &mut self, start_index: Option<u64>, ) -> Result<(), BatchedMerkleTreeError>

fill -> full -> inserted -> fill (from tree insertion perspective is pending if fill or full)

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

fill -> full -> inserted -> fill (from tree insertion perspective is pending if fill or full)

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

fill -> full -> inserted -> fill (from tree insertion perspective is pending if fill or full)

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

pub fn batch_is_ready_to_insert(&self) -> bool

pub fn get_num_ready_zkp_updates(&self) -> u64

Returns the number of zkp batch updates that are ready to be inserted into the tree.

pub fn get_num_inserted_zkp_batch(&self) -> u64

Returns the number of inserted elements in the current zkp batch.

pub fn get_current_zkp_batch_index(&self) -> u64

Returns the current zkp batch index. New values are inserted into the current zkp batch.

pub fn get_num_inserted_zkps(&self) -> u64

Returns the number of inserted zkps.

pub fn get_num_elements_inserted_into_tree(&self) -> u64

Returns the number of elements inserted into the tree.

pub fn get_num_inserted_elements(&self) -> u64

Returns the number of inserted elements in the batch.

pub fn get_num_zkp_batches(&self) -> u64

Returns the number of zkp batches in the batch.

pub fn get_num_hash_chain_store(&self) -> usize

Returns the number of the hash_chain stores.

pub fn get_value_index_in_batch( &self, leaf_index: u64, ) -> Result<u64, BatchedMerkleTreeError>

Returns the index of a value by leaf index in the value store, provided it does exist in the batch.

pub fn store_and_hash_value( &mut self, value: &[u8; 32], value_store: &mut ZeroCopyVecU64<'_, [u8; 32]>, hash_chain_store: &mut ZeroCopyVecU64<'_, [u8; 32]>, start_slot: &u64, ) -> Result<(), BatchedMerkleTreeError>

Stores the value in a value store, and adds the value to the current hash chain.

pub fn insert( &mut self, bloom_filter_value: &[u8; 32], hash_chain_value: &[u8; 32], bloom_filter_stores: &mut [&mut [u8]], hash_chain_store: &mut ZeroCopyVecU64<'_, [u8; 32]>, bloom_filter_index: usize, start_slot: &u64, ) -> Result<(), BatchedMerkleTreeError>

Insert into the bloom filter and add value to current hash chain. (used by nullifier & address queues)

1. set start slot
2. Add value to hash chain.
3. Insert value into the bloom filter at bloom_filter_index.
4. Check that value is not in any other bloom filter.

pub fn add_to_hash_chain( &mut self, value: &[u8; 32], hash_chain_store: &mut ZeroCopyVecU64<'_, [u8; 32]>, ) -> Result<(), BatchedMerkleTreeError>

Add a value to the current hash chain, and advance batch state.

1. Check that the batch is ready.
2. If the zkp batch is empty, start a new hash chain.
3. If the zkp batch is not empty, add value to last hash chain.
4. If the zkp batch is full, increment the zkp batch index.
5. If all zkp batches are full, set batch state to full.

pub fn check_non_inclusion( num_iters: usize, bloom_filter_capacity: u64, value: &[u8; 32], store: &mut [u8], ) -> Result<(), BatchedMerkleTreeError>

Checks that value is not in the bloom filter.

pub fn mark_as_inserted_in_merkle_tree( &mut self, sequence_number: u64, root_index: u32, root_history_length: u32, ) -> Result<BatchState, BatchedMerkleTreeError>

Marks the batch as inserted in the merkle tree.

1. Checks that the batch is ready.
2. increments the number of inserted zkps.
3. If all zkps are inserted, sets the state to inserted.
4. Returns the updated state of the batch.

pub fn check_leaf_index_exists( &self, leaf_index: u64, ) -> Result<(), BatchedMerkleTreeError>

pub fn leaf_index_exists(&self, leaf_index: u64) -> bool

Returns true if value of leaf index could exist in batch. True doesn’t mean that the value exists in the batch, just that it is possible. The value might already be spent or never have been inserted in case an invalid index was provided.

Trait Implementations

impl BorshDeserialize for Batch

where u64: BorshDeserialize, u32: BorshDeserialize, u8: BorshDeserialize, [u8; 2]: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Batch

where u64: BorshSerialize, u32: BorshSerialize, u8: BorshSerialize, [u8; 2]: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for Batch

fn clone(&self) -> Batch

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Batch

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

Formats the value using the given formatter.

impl Default for Batch

fn default() -> Batch

Returns the “default value” for a type.

impl FromBytes for Batch

where u64: FromBytes, u32: FromBytes, u8: FromBytes, [u8; 2]: FromBytes,

fn ref_from_bytes( source: &[u8], ) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>

where Self: KnownLayout + Immutable,

Interprets the given source as a &Self.

fn ref_from_prefix( source: &[u8], ) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>

where Self: KnownLayout + Immutable,

Interprets the prefix of the given source as a &Self without copying.

fn ref_from_suffix( source: &[u8], ) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>

where Self: Immutable + KnownLayout,

Interprets the suffix of the given bytes as a &Self.

fn mut_from_bytes( source: &mut [u8], ) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>

where Self: IntoBytes + KnownLayout,

Interprets the given source as a &mut Self.

fn mut_from_prefix( source: &mut [u8], ) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>

where Self: IntoBytes + KnownLayout,

Interprets the prefix of the given source as a &mut Self without copying.

fn mut_from_suffix( source: &mut [u8], ) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>

where Self: IntoBytes + KnownLayout,

Interprets the suffix of the given source as a &mut Self without copying.

fn ref_from_bytes_with_elems( source: &[u8], count: usize, ) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>

where Self: KnownLayout<PointerMetadata = usize> + Immutable,

Interprets the given source as a &Self with a DST length equal to count.

fn ref_from_prefix_with_elems( source: &[u8], count: usize, ) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>

where Self: KnownLayout<PointerMetadata = usize> + Immutable,

Interprets the prefix of the given source as a DST &Self with length equal to count.

fn ref_from_suffix_with_elems( source: &[u8], count: usize, ) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, Infallible>>

where Self: KnownLayout<PointerMetadata = usize> + Immutable,

Interprets the suffix of the given source as a DST &Self with length equal to count.

fn mut_from_bytes_with_elems( source: &mut [u8], count: usize, ) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>

where Self: IntoBytes + KnownLayout<PointerMetadata = usize> + Immutable,

Interprets the given source as a &mut Self with a DST length equal to count.

fn mut_from_prefix_with_elems( source: &mut [u8], count: usize, ) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>

where Self: IntoBytes + KnownLayout<PointerMetadata = usize>,

Interprets the prefix of the given source as a &mut Self with DST length equal to count.

fn mut_from_suffix_with_elems( source: &mut [u8], count: usize, ) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, Infallible>>

where Self: IntoBytes + KnownLayout<PointerMetadata = usize>,

Interprets the suffix of the given source as a &mut Self with DST length equal to count.

fn read_from_bytes(source: &[u8]) -> Result<Self, SizeError<&[u8], Self>>

where Self: Sized,

Reads a copy of Self from the given source.

fn read_from_prefix( source: &[u8], ) -> Result<(Self, &[u8]), SizeError<&[u8], Self>>

where Self: Sized,

Reads a copy of Self from the prefix of the given source.

fn read_from_suffix( source: &[u8], ) -> Result<(&[u8], Self), SizeError<&[u8], Self>>

where Self: Sized,

Reads a copy of Self from the suffix of the given source.

impl FromZeros for Batch

where u64: FromZeros, u32: FromZeros, u8: FromZeros, [u8; 2]: FromZeros,

fn zero(&mut self)

Overwrites self with zeros.

fn new_zeroed() -> Self

where Self: Sized,

Creates an instance of Self from zeroed bytes.

impl IntoBytes for Batch

where u64: IntoBytes, u32: IntoBytes, u8: IntoBytes, [u8; 2]: IntoBytes, (): PaddingFree<Self, { _ }>,

fn as_bytes(&self) -> &[u8]

where Self: Immutable,

Gets the bytes of this value.

fn as_mut_bytes(&mut self) -> &mut [u8]

where Self: FromBytes,

Gets the bytes of this value mutably.

fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to dst.

fn write_to_prefix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the prefix of dst.

fn write_to_suffix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the suffix of dst.

impl KnownLayout for Batch

where [u8; 2]: KnownLayout,

type PointerMetadata = <[u8; 2] as KnownLayout>::PointerMetadata

The type of metadata stored in a pointer to Self.

impl PartialEq for Batch

fn eq(&self, other: &Batch) -> 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 TryFromBytes for Batch

where u64: TryFromBytes, u32: TryFromBytes, u8: TryFromBytes, [u8; 2]: TryFromBytes,

fn try_ref_from_bytes( source: &[u8], ) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout + Immutable,

Attempts to interpret the given source as a &Self.

fn try_ref_from_prefix( source: &[u8], ) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout + Immutable,

Attempts to interpret the prefix of the given source as a &Self.

fn try_ref_from_suffix( source: &[u8], ) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout + Immutable,

Attempts to interpret the suffix of the given source as a &Self.

fn try_mut_from_bytes( bytes: &mut [u8], ) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout + IntoBytes,

Attempts to interpret the given source as a &mut Self without copying.

fn try_mut_from_prefix( source: &mut [u8], ) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout + IntoBytes,

Attempts to interpret the prefix of the given source as a &mut Self.

fn try_mut_from_suffix( source: &mut [u8], ) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout + IntoBytes,

Attempts to interpret the suffix of the given source as a &mut Self.

fn try_ref_from_bytes_with_elems( source: &[u8], count: usize, ) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout<PointerMetadata = usize> + Immutable,

Attempts to interpret the given source as a &Self with a DST length equal to count.

fn try_ref_from_prefix_with_elems( source: &[u8], count: usize, ) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout<PointerMetadata = usize> + Immutable,

Attempts to interpret the prefix of the given source as a &Self with a DST length equal to count.

fn try_ref_from_suffix_with_elems( source: &[u8], count: usize, ) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout<PointerMetadata = usize> + Immutable,

Attempts to interpret the suffix of the given source as a &Self with a DST length equal to count.

fn try_mut_from_bytes_with_elems( source: &mut [u8], count: usize, ) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout<PointerMetadata = usize> + IntoBytes,

Attempts to interpret the given source as a &mut Self with a DST length equal to count.

fn try_mut_from_prefix_with_elems( source: &mut [u8], count: usize, ) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout<PointerMetadata = usize> + IntoBytes,

Attempts to interpret the prefix of the given source as a &mut Self with a DST length equal to count.

fn try_mut_from_suffix_with_elems( source: &mut [u8], count: usize, ) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout<PointerMetadata = usize> + IntoBytes,

Attempts to interpret the suffix of the given source as a &mut Self with a DST length equal to count.

fn try_read_from_bytes( source: &[u8], ) -> Result<Self, ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read the given source as a Self.

fn try_read_from_prefix( source: &[u8], ) -> Result<(Self, &[u8]), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the prefix of the given source.

fn try_read_from_suffix( source: &[u8], ) -> Result<(&[u8], Self), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the suffix of the given source.

impl Copy for Batch

impl Eq for Batch

impl Immutable for Batch

where u64: Immutable, u32: Immutable, u8: Immutable, [u8; 2]: Immutable,

impl StructuralPartialEq for Batch