feat: sp1 aggregation program

Author: MarcosNicolau

aggregation-mode/Cargo.lock

@@ -5,9 +5,17 @@ edition = "2021"
 resolver = "2"
 
 [dependencies]
-sp1-zkvm = "4.1.3"
+sp1-zkvm = { version = "4.1.3", features = ["verify"] }
+sha2 = "0.10.8"
 serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.117"
 
+[patch.crates-io]
+sha2 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", tag = "sha2-v0.10.8-patch-v1" }
+
 [lib]
 path = "./src/lib.rs"
+
+[[bin]]
+name = "sp1_verifier_program"
+path = "src/main.rs"

aggregation-mode/zkvm/Cargo.lock

@@ -1,7 +1,29 @@
 use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
 
 #[derive(Serialize, Deserialize)]
 pub struct SP1CompressedProof {
     vk: Vec<u8>,
-    public_inputs: Vec<Vec<u8>>,
+    pub public_inputs: Vec<u8>,
+}
+
+impl SP1CompressedProof {
+    pub fn vk(&self) -> [u32; 8] {
+        assert!(self.vk.len() >= 32, "vk must be at least 32 bytes long");
+
+        let mut bytes = [0_32; 8];
+
+        for (i, chunk) in self.vk.chunks_exact(4).enumerate() {
+            bytes[i] = u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
+        }
+
+        bytes
+    }
+
+    pub fn hash(&self) -> [u8; 32] {
+        let mut hasher = Sha256::new();
+        hasher.update(&self.vk);
+        hasher.update(&self.public_inputs);
+        hasher.finalize().into()
+    }
 }

aggregation-mode/zkvm/sp1/Cargo.toml

@@ -1,15 +1,53 @@
 #![no_main]
 sp1_zkvm::entrypoint!(main);
 
+use sha2::{Digest, Sha256};
 use sp1_verifier_program::SP1CompressedProof;
 
-/// TODO: write proof aggregation program
-///
-/// For now we are only receiving the inputs and committing a silly output
-/// Future iteration will include the aggregation of proofs and will return the
-/// proof of the verification of proofs + merkle tree leaves
+fn combine_hashes(hash_a: &[u8; 32], hash_b: &[u8; 32]) -> [u8; 32] {
+    let mut hasher = Sha256::new();
+    hasher.update(hash_a);
+    hasher.update(hash_b);
+    hasher.finalize().into()
+}
+
+/// Computes the merkle root for the given proofs using the vk
+fn compute_merkle_root(proofs: &[SP1CompressedProof]) -> [u8; 32] {
+    let mut leaves: Vec<[u8; 32]> = proofs
+        .chunks(2)
+        .map(|chunk| match chunk {
+            [a, b] => combine_hashes(&a.hash(), &b.hash()),
+            [a] => combine_hashes(&a.hash(), &a.hash()),
+            _ => panic!("Unexpected chunk size in get_parent_nodes"),
+        })
+        .collect();
+
+    while leaves.len() > 1 {
+        leaves = leaves
+            .chunks(2)
+            .map(|chunk| match chunk {
+                [a, b] => combine_hashes(&a, &b),
+                [a] => combine_hashes(&a, &a),
+                _ => panic!("Unexpected chunk size in get_parent_nodes"),
+            })
+            .collect()
+    }
+
+    leaves[0]
+}
+
+// TODO: Update input and use AlignedVerificationData
 pub fn main() {
     let input = sp1_zkvm::io::read::<Vec<SP1CompressedProof>>();
-    let result = input.len() + 1;
-    sp1_zkvm::io::commit(&result);
+
+    // Verify the proofs.
+    for proof in input.iter() {
+        let vkey = proof.vk();
+        let public_values = &proof.public_inputs;
+        let public_values_digest = Sha256::digest(public_values);
+        sp1_zkvm::lib::verify::verify_sp1_proof(&vkey, &public_values_digest.into());
+    }
+
+    let merkle_root = compute_merkle_root(&input);
+    sp1_zkvm::io::commit_slice(&merkle_root);
 }