Working Merkle subtree proofs

src/hash.rs

@@ -273,7 +273,6 @@ pub(crate) fn merkle_root_inner<F: Field>(vecs: Vec<Vec<F>>) -> Hash<F> {
         .map(|leaf_set| hash_or_noop(leaf_set))
         .collect::<Vec<_>>();
     while hashes.len() > 1 {
-        dbg!(&hashes);
         hashes = hashes
             .chunks(2)
             .map(|pair| compress(pair[0], pair[1]))

src/merkle_proofs.rs

@@ -5,7 +5,6 @@ use crate::hash::{compress, hash_or_noop};
 use crate::hash::{merkle_root_inner, GMIMC_ROUNDS};
 use crate::proof::{Hash, HashTarget};
 use crate::target::Target;
-use crate::util::reverse_index_bits_in_place;
 use crate::wire::Wire;
 use anyhow::{ensure, Result};
 
@@ -51,21 +50,18 @@ pub(crate) fn verify_merkle_proof<F: Field>(
 /// Verifies that the given subtree is present at the given index in the Merkle tree with the
 /// given root.
 pub(crate) fn verify_merkle_proof_subtree<F: Field>(
-    mut subtree_leaves_data: Vec<Vec<F>>,
+    subtree_leaves_data: Vec<Vec<F>>,
     subtree_index: usize,
     merkle_root: Hash<F>,
     proof: &MerkleProof<F>,
     reverse_bits: bool,
 ) -> Result<()> {
     let index = if reverse_bits {
-        // reverse_index_bits_in_place(&mut subtree_leaves_data);
         crate::util::reverse_bits(subtree_index, proof.siblings.len())
     } else {
         subtree_index
     };
-    dbg!(&subtree_leaves_data);
     let mut current_digest = merkle_root_inner(subtree_leaves_data);
-    dbg!(current_digest);
     for (i, &sibling_digest) in proof.siblings.iter().enumerate() {
         let bit = (index >> i & 1) == 1;
         current_digest = if bit {

src/merkle_tree.rs

@@ -79,7 +79,7 @@ impl<F: Field> MerkleTree<F> {
 
     /// Create a Merkle proof for an entire subtree.
     /// Example:
-    /// ```
+    /// ```tree
     ///         G
     ///        / \
     ///       /   \
@@ -132,7 +132,7 @@ mod tests {
     fn test_merkle_trees() -> Result<()> {
         type F = CrandallField;
 
-        let log_n = 3;
+        let log_n = 8;
         let n = 1 << log_n;
         let leaves = random_data::<F>(n, 7);
 
@@ -162,25 +162,25 @@ mod tests {
         }
 
         let (height, i) = (1, 0);
-        dbg!(height, i);
         let subtree_proof = tree_reversed_bits.prove_subtree(i, height);
-        dbg!(&tree_reversed_bits, &subtree_proof);
+        let reversed_index = reverse_bits(i, log_n - height);
         verify_merkle_proof_subtree(
-            (i << height..(i + 1) << height)
-                .map(|j| tree_reversed_bits.leaves[j].to_vec())
+            (reversed_index << height..(reversed_index + 1) << height)
+                .map(|j| tree_reversed_bits.leaves[j].clone())
                 .collect(),
             i,
             tree_reversed_bits.root,
             &subtree_proof,
             true,
         )?;
-        for height in 1..=log_n {
+
+        for height in 0..=log_n {
             for i in 0..(n >> height) {
-                dbg!(height, i);
+                let reversed_index = reverse_bits(i, log_n - height);
                 let subtree_proof = tree_reversed_bits.prove_subtree(i, height);
                 verify_merkle_proof_subtree(
-                    (i << height..(i + 1) << height)
-                        .map(|j| tree_reversed_bits.leaves[j].to_vec())
+                    (reversed_index << height..(reversed_index + 1) << height)
+                        .map(|j| tree_reversed_bits.leaves[j].clone())
                         .collect(),
                     i,
                     tree_reversed_bits.root,