feat: migrate to lambdaworks merkle tree in sdk

Author: MarcosNicolau

batcher/aligned-sdk/src/sdk/aggregation.rs

@@ -6,6 +6,7 @@ use ethers::{
     providers::{Http, Middleware, Provider},
     types::Filter,
 };
+use lambdaworks_crypto::merkle_tree::{merkle::MerkleTree, traits::IsMerkleTreeBackend};
 use sha3::{Digest, Keccak256};
 
 /// How much to go back from current block if from_block is not provided
@@ -24,6 +25,12 @@ pub enum AggregationModeVerificationData {
     },
 }
 
+impl Default for AggregationModeVerificationData {
+    fn default() -> Self {
+        todo!()
+    }
+}
+
 impl AggregationModeVerificationData {
     fn commitment(&self) -> [u8; 32] {
         match self {
@@ -46,6 +53,33 @@ impl AggregationModeVerificationData {
     }
 }
 
+// We use a newtype wrapper around `[u8; 32]` because Rust's orphan rule
+// prevents implementing a foreign trait (`IsMerkleTreeBackend`) for a foreign type (`[u8; 32]`).
+#[derive(Default, PartialEq, Eq)]
+struct Hash32([u8; 32]);
+
+impl IsMerkleTreeBackend for Hash32 {
+    type Data = Hash32;
+    type Node = [u8; 32];
+
+    fn hash_data(leaf: &Self::Data) -> Self::Node {
+        let mut hasher = Keccak256::new();
+        hasher.update(leaf.0);
+        hasher.finalize().into()
+    }
+
+    fn hash_leaves(leaves: &[Self::Data]) -> Vec<Self::Node> {
+        leaves.iter().map(|l| l.0).collect()
+    }
+
+    fn hash_new_parent(child_1: &Self::Node, child_2: &Self::Node) -> Self::Node {
+        let mut hasher = Keccak256::new();
+        hasher.update(child_1);
+        hasher.update(child_2);
+        hasher.finalize().into()
+    }
+}
+
 #[derive(Debug)]
 pub enum ProofVerificationAggModeError {
     ProvingSystemNotSupportedInAggMode,
@@ -158,10 +192,14 @@ pub async fn is_proof_verified_in_aggregation_mode(
 
         let blob_bytes =
             hex::decode(blob_data.blob.replace("0x", "")).expect("A valid hex encoded data");
-        let proof_commitments = decoded_blob(blob_bytes);
-
-        if proof_commitments.contains(&verification_data.commitment()) {
-            return if verify_blob_merkle_root(proof_commitments, merkle_root) {
+        let proof_commitments: Vec<Hash32> = decoded_blob(blob_bytes)
+            .iter()
+            .map(|p| Hash32(*p))
+            .collect();
+        let merkle_tree: MerkleTree<Hash32> = MerkleTree::build(&proof_commitments).unwrap();
+
+        if proof_commitments.contains(&Hash32(verification_data.commitment())) {
+            return if merkle_tree.root == merkle_root {
                 Ok(merkle_root)
             } else {
                 Err(ProofVerificationAggModeError::UnmatchedBlobAndEventMerkleRoot)
@@ -206,25 +244,3 @@ fn decoded_blob(blob_data: Vec<u8>) -> Vec<[u8; 32]> {
 
     proof_hashes
 }
-
-pub fn combine_hashes(hash_a: &[u8; 32], hash_b: &[u8; 32]) -> [u8; 32] {
-    let mut hasher = Keccak256::new();
-    hasher.update(hash_a);
-    hasher.update(hash_b);
-    hasher.finalize().into()
-}
-
-fn verify_blob_merkle_root(mut commitments: Vec<[u8; 32]>, merkle_root: [u8; 32]) -> bool {
-    while commitments.len() > 1 {
-        commitments = commitments
-            .chunks(2)
-            .map(|chunk| match chunk {
-                [a, b] => combine_hashes(a, b),
-                [a] => combine_hashes(a, a),
-                _ => panic!("Unexpected chunk size in leaves"),
-            })
-            .collect()
-    }
-
-    commitments[0] == merkle_root
-}