Struct MerkleVerifyCols 

#[repr(C)]
pub struct MerkleVerifyCols<T> {

    pub proof_idx: T,
    pub is_valid: T,
    pub is_last_merkle: T,
    pub is_combining_leaves: T,
    pub is_last_leaf: T,
    pub leaf_sub_idx: T,
    pub merkle_idx_bit_src: T,
    pub current_idx_bit_src: T,
    pub total_depth: T,
    pub height: T,
    pub left: [T; 8],
    pub right: [T; 8],
    pub recv_flag: T,
    pub commit_major: T,
    pub commit_minor: T,
    pub compression_output: [T; 8],
}

There are two parts in the merkle proof: hashing leaves and the (standard) merkle proof.

Example: (k = 2), going from left to right leaf0
leaf1 -> a leaf2 \
leaf3 -> b -> c \ will start hashing with merkle proof siblings merkle_sibing -> …

(First part) Hashing leaves: there are 2^k leaves, each is [T; DIGEST_SIZE]. Each row in MerkleVerify AIR represents a Poseidon2 compression (of two leaves, or two intermediate values). So there are 2^k - 1 rows for this part. At height 0, the leaves are at the bottom (leaf0 ~ leaf3) in the diagram above. At height 1 are the intermediate hashes (a, b) in the diagram above. The first row in the AIR will be Poseidon2 compression of leaf0 and leaf1, and the second row will be Poseidon2 compression of leaf2 and leaf3. And the third row will be Poseidon2 compression of a and b.

(Second part) Standard merkle proof, the next row will be Poseidon2 compression of c and the sibling of c.

Fields

proof_idx: T

Index of the proof this row is for

is_valid: T

Indicator: whether this row is valid

is_last_merkle: T

Indicator: whether this is the last row of a merkle proof

is_combining_leaves: T

Indicator: whether this row hashes two leaves or is part of the Merkle path proof

is_last_leaf: T

Indicator: whether this row is the root of the hashed leaves

leaf_sub_idx: T

Row node index of this node in the leaf hash tree, 0 if is_combining_leaves is false

merkle_idx_bit_src: T

The merkle idx of the leaf hash root

current_idx_bit_src: T

Merkle idx suffix after shifting right max(0, height - k) bits

total_depth: T

Total depth of the merkle proof including the leaves part = merkle_proof.len() + 1 + k

height: T

0 -> total_depth - 1, where leaves are at height 0, combined leaf hash is at height k

left: [T; 8]

right: [T; 8]

recv_flag: T

Flag that indicates what to receive; 0 for left, 1 for right, 2 for both

commit_major: T

commit_minor: T

compression_output: [T; 8]

Implementations

impl<T> MerkleVerifyCols<T>

pub const fn width() -> usize

pub fn as_slice(&self) -> &[T]

pub fn as_slice_mut(&mut self) -> &mut [T]

Mutable view of the whole struct as a contiguous slice of T.

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

Copy out the contents as a Vec. Requires T: Clone for the slice .to_vec().

Trait Implementations

impl<T> Borrow<MerkleVerifyCols<T>> for [T]

fn borrow(&self) -> &MerkleVerifyCols<T>

Immutably borrows from an owned value.

impl<T> BorrowMut<MerkleVerifyCols<T>> for [T]

fn borrow_mut(&mut self) -> &mut MerkleVerifyCols<T>

Mutably borrows from an owned value.

impl<T> StructReflectionHelper for MerkleVerifyCols<T>

fn struct_reflection() -> Option<Vec<String>>