feat: add Zisk aggregator support to proof aggregation system

Author: MarcosNicolau

aggregation_mode/Cargo.lock

@@ -29,6 +29,7 @@ sp1_aggregation_program = { path = "./aggregation_programs/sp1" }
 risc0-zkvm = { workspace = true }
 risc0_aggregation_program = { path = "./aggregation_programs/risc0" }
 risc0-ethereum-contracts = { git = "https://github.com/risc0/risc0-ethereum/", tag = "v3.0.0" }
+zisk_aggregation_program = { path = "./aggregation_programs/zisk" }
 
 [build-dependencies]
 sp1-build = { version = "5.0.0" }

aggregation_mode/proof_aggregator/Cargo.toml

@@ -63,7 +63,7 @@ pub fn main() {
 
         leaves.extend(leaves_commitment);
 
-        proofman_verifier::verify(&proof.proof, &proof.vk);
+        proofman_verifier::verify(&proof.proof, &input.vk);
     }
 
     // Finally, compute the final merkle root with all the leaves

aggregation_mode/proof_aggregator/abi/AlignedProofAggregationService.json

@@ -3,27 +3,41 @@ use serde::{Deserialize, Serialize};
 use sha2::Digest;
 use sha3::Keccak256;
 
+const ZISK_PROVING_SYSTEM_ID: u16 = 1;
+
 #[derive(Serialize, Deserialize)]
 pub struct ChunkAggregatorInput {
-    pub proofs_and_leaves_commitment: Vec<(ZiskProofAndVk, Vec<[u8; 32]>)>,
+    pub proofs_and_leaves_commitment: Vec<(ZiskProof, Vec<[u8; 32]>)>,
+    pub vk: Vec<u8>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct UserProofsAggregatorInput {
-    pub proofs_and_vk: Vec<ZiskProofAndVk>,
+    pub proofs_and_vk: Vec<ZiskProof>,
+    pub vk: Vec<u8>,
+}
+
+impl UserProofsAggregatorInput {
+    pub fn new(proofs_and_vk: Vec<ZiskProof>, vk: Vec<u8>) -> Self {
+        Self { proofs_and_vk, vk }
+    }
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct ZiskProofAndVk {
+pub struct ZiskProof {
     pub proof: Vec<u8>,
-    pub vk: Vec<u8>,
 }
 
-impl ZiskProofAndVk {
-    pub fn commitment(&self) -> [u8; 32] {
-        let hash = [0u8; 32];
+impl ZiskProof {
+    pub fn new(proof: Vec<u8>) -> Self {
+        Self { proof }
+    }
 
-        hash
+    pub fn commitment(&self) -> [u8; 32] {
+        let mut hasher = Keccak256::new();
+        hasher.update(ZISK_PROVING_SYSTEM_ID.to_be_bytes());
+        hasher.update(&self.proof);
+        hasher.finalize().into()
     }
 }
 
@@ -37,8 +51,8 @@ impl ZiskProofAndVk {
 // - crates/sdk/src/aggregation_layer/types.rs
 // This one is used in the SDK since
 // the user may not have access to the proofs that they didn't submit
-impl IsMerkleTreeBackend for ZiskProofAndVk {
-    type Data = ZiskProofAndVk;
+impl IsMerkleTreeBackend for ZiskProof {
+    type Data = ZiskProof;
     type Node = [u8; 32];
 
     fn hash_data(leaf: &Self::Data) -> Self::Node {

aggregation_mode/proof_aggregator/aggregation_programs/zisk/src/chunk_aggregator_main.rs

@@ -2,18 +2,18 @@
 ziskos::entrypoint!(main);
 
 use lambdaworks_crypto::merkle_tree::merkle::MerkleTree;
-use zisk_aggregation_program::{UserProofsAggregatorInput, ZiskProofAndVk};
+use zisk_aggregation_program::{UserProofsAggregatorInput, ZiskProof};
 
 fn main() {
     let input = ziskos::read_input_slice();
     let input =
         bincode::deserialize::<UserProofsAggregatorInput>(&input).expect("correct serialization");
 
     for entry in input.proofs_and_vk.iter() {
-        proofman_verifier::verify(&entry.proof, &entry.vk);
+        proofman_verifier::verify(&entry.proof, &input.vk);
     }
 
-    let merkle_tree = MerkleTree::<ZiskProofAndVk>::build(&input.proofs_and_vk).unwrap();
+    let merkle_tree = MerkleTree::<ZiskProof>::build(&input.proofs_and_vk).unwrap();
 
     merkle_tree
         .root

aggregation_mode/proof_aggregator/aggregation_programs/zisk/src/lib.rs

@@ -0,0 +1,2 @@
+t����
+a���_���qM�����ɌESS