From f624415a3c6c1066a35f030c48b6f33b6498abeb Mon Sep 17 00:00:00 2001
From: wborgeaud <williamborgeaud@gmail.com>
Date: Wed, 28 Apr 2021 18:41:59 +0200
Subject: [PATCH] Clippy

---
 src/fri.rs           |  2 +-
 src/merkle_proofs.rs | 28 ------------------
 src/merkle_tree.rs   | 67 +-------------------------------------------
 3 files changed, 2 insertions(+), 95 deletions(-)

diff --git a/src/fri.rs b/src/fri.rs
index ce4178d3..02d508a3 100644
--- a/src/fri.rs
+++ b/src/fri.rs
@@ -2,7 +2,7 @@ use crate::field::fft::fft;
 use crate::field::field::Field;
 use crate::field::lagrange::{barycentric_weights, interpolate};
 use crate::hash::hash_n_to_1;
-use crate::merkle_proofs::{verify_merkle_proof, verify_merkle_proof_subtree};
+use crate::merkle_proofs::verify_merkle_proof;
 use crate::merkle_tree::MerkleTree;
 use crate::plonk_challenger::Challenger;
 use crate::plonk_common::reduce_with_powers;
diff --git a/src/merkle_proofs.rs b/src/merkle_proofs.rs
index 6209d9ab..8434ae49 100644
--- a/src/merkle_proofs.rs
+++ b/src/merkle_proofs.rs
@@ -48,34 +48,6 @@ pub(crate) fn verify_merkle_proof<F: Field>(
     Ok(())
 }
 
-/// 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>(
-    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 {
-        crate::util::reverse_bits(subtree_index, proof.siblings.len())
-    } else {
-        subtree_index
-    };
-    let mut current_digest = MerkleTree::new(subtree_leaves_data, false).root;
-    for (i, &sibling_digest) in proof.siblings.iter().enumerate() {
-        let bit = (index >> i & 1) == 1;
-        current_digest = if bit {
-            compress(sibling_digest, current_digest)
-        } else {
-            compress(current_digest, sibling_digest)
-        }
-    }
-    ensure!(current_digest == merkle_root, "Invalid Merkle proof.");
-
-    Ok(())
-}
-
 impl<F: Field> CircuitBuilder<F> {
     /// Verifies that the given leaf data is present at the given index in the Merkle tree with the
     /// given root.
diff --git a/src/merkle_tree.rs b/src/merkle_tree.rs
index a74415a7..e7d535e0 100644
--- a/src/merkle_tree.rs
+++ b/src/merkle_tree.rs
@@ -78,42 +78,6 @@ impl<F: Field> MerkleTree<F> {
                 .collect(),
         }
     }
-
-    /// Create a Merkle proof for an entire subtree.
-    /// Example:
-    /// ```tree
-    ///         G
-    ///        / \
-    ///       /   \
-    ///      /     \
-    ///     E       F
-    ///    / \     / \
-    ///   A   B   C   D
-    /// ```
-    /// `self.prove_subtree(0, 1)` gives a Merkle proof for the subtree E->(A,B), i.e., the
-    /// path (F,).
-    pub fn prove_subtree(&self, subtree_index: usize, subtree_height: usize) -> MerkleProof<F> {
-        let index = if self.reverse_bits {
-            reverse_bits(
-                subtree_index,
-                log2_strict(self.leaves.len()) - subtree_height,
-            )
-        } else {
-            subtree_index
-        };
-        MerkleProof {
-            siblings: self
-                .layers
-                .iter()
-                .skip(subtree_height)
-                .scan(index, |acc, layer| {
-                    let index = *acc ^ 1;
-                    *acc >>= 1;
-                    Some(layer[index])
-                })
-                .collect(),
-        }
-    }
 }
 
 #[cfg(test)]
@@ -121,7 +85,7 @@ mod tests {
     use anyhow::Result;
 
     use crate::field::crandall_field::CrandallField;
-    use crate::merkle_proofs::{verify_merkle_proof, verify_merkle_proof_subtree};
+    use crate::merkle_proofs::verify_merkle_proof;
 
     use super::*;
 
@@ -143,32 +107,6 @@ mod tests {
         }
         Ok(())
     }
-    fn verify_all_subtrees<F: Field>(
-        leaves: Vec<Vec<F>>,
-        n: usize,
-        log_n: usize,
-        reverse_bits: bool,
-    ) -> Result<()> {
-        let tree = MerkleTree::new(leaves.clone(), reverse_bits);
-        for height in 0..=log_n {
-            for i in 0..(n >> height) {
-                let index = if reverse_bits {
-                    crate::util::reverse_bits(i, log_n - height)
-                } else {
-                    i
-                };
-                let subtree_proof = tree.prove_subtree(i, height);
-                verify_merkle_proof_subtree(
-                    tree.leaves[index << height..(index + 1) << height].to_vec(),
-                    i,
-                    tree.root,
-                    &subtree_proof,
-                    reverse_bits,
-                )?;
-            }
-        }
-        Ok(())
-    }
 
     #[test]
     fn test_merkle_trees() -> Result<()> {
@@ -179,10 +117,7 @@ mod tests {
         let leaves = random_data::<F>(n, 7);
 
         verify_all_leaves(leaves.clone(), n, false)?;
-        verify_all_subtrees(leaves.clone(), n, log_n, false)?;
-
         verify_all_leaves(leaves.clone(), n, true)?;
-        verify_all_subtrees(leaves, n, log_n, true)?;
 
         Ok(())
     }