chore: rename program names

ex proof_aggregator now is user_proots_aggregator and ex root_aggregator is now chunk_aggregator

Author: MarcosNicolau

aggregation_mode/aggregation_programs/risc0/Cargo.toml

@@ -16,9 +16,9 @@ lambdaworks-crypto = { git = "https://github.com/lambdaclass/lambdaworks.git", r
 path = "./src/lib.rs"
 
 [[bin]]
-name = "risc0_chunk_aggregator_program"
-path = "./src/chunk_aggregator_main.rs"
+name = "risc0_user_proofs_aggregator_program"
+path = "./src/user_proofs_aggregator_main.rs"
 
 [[bin]]
-name = "risc0_root_aggregator_program"
-path = "./src/root_aggregator_main.rs"
+name = "risc0_chunk_aggregator_program"
+path = "./src/chunk_aggregator_main.rs"

aggregation_mode/aggregation_programs/risc0/src/chunk_aggregator_main.rs

@@ -1,22 +1,50 @@
 #![no_main]
 
 use lambdaworks_crypto::merkle_tree::merkle::MerkleTree;
-use risc0_aggregation_program::{ChunkAggregatorInput, Risc0ImageIdAndPubInputs};
+use risc0_aggregation_program::{ChunkAggregatorInput, Hash32};
 use risc0_zkvm::guest::env;
 
 risc0_zkvm::guest::entry!(main);
 
+// Generated with `make agg_mode_write_program_ids` and copied from program_ids.json
+pub const USER_PROOFS_AGGREGATOR_PROGRAM_IMAGE_ID: [u8; 32] = [
+    83, 145, 39, 254, 127, 217, 146, 127, 63, 217, 69, 190, 11, 204, 170, 138, 215, 35, 175, 246,
+    209, 154, 52, 243, 85, 37, 177, 147, 22, 153, 155, 156,
+];
+
 fn main() {
     let input = env::read::<ChunkAggregatorInput>();
 
-    for proof in &input.proofs_image_id_and_pub_inputs {
-        env::verify(proof.image_id.clone(), &proof.public_inputs)
-            .expect("proof to be verified correctly");
+    let mut leaves: Vec<Hash32> = vec![];
+
+    for (proof, leaves_commitment) in input.proofs_and_leaves_commitment {
+        let image_id = proof.image_id;
+
+        // Ensure the aggregated chunk originates from the L1 aggregation program.
+        // This validation step guarantees that the proof was genuinely verified
+        // by this program. Without this check, a different program using the
+        // same public inputs could bypass verification.
+        assert!(image_id == USER_PROOFS_AGGREGATOR_PROGRAM_IMAGE_ID);
+
+        // Ensure the committed root matches the root of the provided leaves
+        let merkle_root: [u8; 32] = proof
+            .public_inputs
+            .clone()
+            .try_into()
+            .expect("Public input to be the chunk merkle root");
+
+        let leaves_commitment: Vec<Hash32> =
+            leaves_commitment.into_iter().map(|el| Hash32(el)).collect();
+        let merkle_tree = MerkleTree::<Hash32>::build(&leaves_commitment).unwrap();
+        assert!(merkle_root == merkle_tree.root);
+
+        leaves.extend(leaves_commitment);
+
+        // finally verify the proof
+        env::verify(image_id, &proof.public_inputs).expect("proof to be verified correctly");
     }
 
-    let merkle_tree =
-        MerkleTree::<Risc0ImageIdAndPubInputs>::build(&input.proofs_image_id_and_pub_inputs)
-            .unwrap();
+    let merkle_tree = MerkleTree::<Hash32>::build(&leaves).unwrap();
 
     env::commit_slice(&merkle_tree.root);
 }

aggregation_mode/aggregation_programs/risc0/src/lib.rs

@@ -114,11 +114,11 @@ impl IsMerkleTreeBackend for Hash32 {
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct ChunkAggregatorInput {
+pub struct UserProofsAggregatorInput {
     pub proofs_image_id_and_pub_inputs: Vec<Risc0ImageIdAndPubInputs>,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct RootAggregatorInput {
+pub struct ChunkAggregatorInput {
     pub proofs_and_leaves_commitment: Vec<(Risc0ImageIdAndPubInputs, Vec<[u8; 32]>)>,
 }

aggregation_mode/aggregation_programs/risc0/src/root_aggregator_main.rs

@@ -0,0 +1,22 @@
+#![no_main]
+
+use lambdaworks_crypto::merkle_tree::merkle::MerkleTree;
+use risc0_aggregation_program::{Risc0ImageIdAndPubInputs, UserProofsAggregatorInput};
+use risc0_zkvm::guest::env;
+
+risc0_zkvm::guest::entry!(main);
+
+fn main() {
+    let input = env::read::<UserProofsAggregatorInput>();
+
+    for proof in &input.proofs_image_id_and_pub_inputs {
+        env::verify(proof.image_id.clone(), &proof.public_inputs)
+            .expect("proof to be verified correctly");
+    }
+
+    let merkle_tree =
+        MerkleTree::<Risc0ImageIdAndPubInputs>::build(&input.proofs_image_id_and_pub_inputs)
+            .unwrap();
+
+    env::commit_slice(&merkle_tree.root);
+}

aggregation_mode/aggregation_programs/risc0/src/user_proofs_aggregator_main.rs

@@ -16,9 +16,9 @@ lambdaworks-crypto = { git = "https://github.com/lambdaclass/lambdaworks.git", r
 path = "./src/lib.rs"
 
 [[bin]]
-name = "sp1_chunk_aggregator_program"
-path = "./src/chunk_aggregator_main.rs"
+name = "sp1_user_proofs_aggregator_program"
+path = "./src/user_proofs_aggregator_main.rs"
 
 [[bin]]
-name = "sp1_root_aggregator_program"
-path = "./src/root_aggregator_main.rs"
+name = "sp1_chunk_aggregator_program"
+path = "./src/chunk_aggregator_main.rs"

aggregation_mode/aggregation_programs/sp1/Cargo.toml

@@ -3,22 +3,48 @@ sp1_zkvm::entrypoint!(main);
 
 use lambdaworks_crypto::merkle_tree::merkle::MerkleTree;
 use sha2::{Digest, Sha256};
-use sp1_aggregation_program::{ChunkAggregatorInput, SP1VkAndPubInputs};
+use sp1_aggregation_program::{ChunkAggregatorInput, Hash32};
+
+// Generated with `make agg_mode_write_program_ids` and copied from program_ids.json
+pub const USER_PROOFS_AGGREGATOR_PROGRAM_VK_HASH: [u32; 8] = [
+    1040333920, 1542570412, 411443120, 206151865, 190370181, 1775934843, 1568897572, 1219192306,
+];
 
 pub fn main() {
     let input = sp1_zkvm::io::read::<ChunkAggregatorInput>();
 
+    let mut leaves = vec![];
+
     // Verify the proofs.
-    for proof in input.proofs_vk_and_pub_inputs.iter() {
+    for (proof, leaves_commitment) in input.proofs_and_leaves_commitment {
         let vkey = proof.vk;
-        let public_values = &proof.public_inputs;
-        let public_values_digest = Sha256::digest(public_values);
+        let public_values_digest = Sha256::digest(&proof.public_inputs);
+
+        // Ensure the aggregated chunk originates from the L1 aggregation program.
+        // This validation step guarantees that the proof was genuinely verified
+        // by this program. Without this check, a different program using the
+        // same public inputs could bypass verification.
+        assert!(proof.vk == USER_PROOFS_AGGREGATOR_PROGRAM_VK_HASH);
+
+        let merkle_root: [u8; 32] = proof
+            .public_inputs
+            .clone()
+            .try_into()
+            .expect("Public input to be the hash of the chunk tree");
+
+        // Reconstruct the merkle tree and verify that the roots match
+        let leaves_commitment: Vec<Hash32> =
+            leaves_commitment.into_iter().map(|el| Hash32(el)).collect();
+        let merkle_tree: MerkleTree<Hash32> = MerkleTree::build(&leaves_commitment).unwrap();
+        assert!(merkle_tree.root == merkle_root);
+
+        leaves.extend(leaves_commitment);
 
         sp1_zkvm::lib::verify::verify_sp1_proof(&vkey, &public_values_digest.into());
     }
 
-    let merkle_tree =
-        MerkleTree::<SP1VkAndPubInputs>::build(&input.proofs_vk_and_pub_inputs).unwrap();
+    // Finally, compute the final merkle root with all the leaves
+    let merkle_tree: MerkleTree<Hash32> = MerkleTree::build(&leaves).unwrap();
 
     sp1_zkvm::io::commit_slice(&merkle_tree.root);
 }

aggregation_mode/aggregation_programs/sp1/src/chunk_aggregator_main.rs

@@ -107,11 +107,11 @@ impl IsMerkleTreeBackend for Hash32 {
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct ChunkAggregatorInput {
+pub struct UserProofsAggregatorInput {
     pub proofs_vk_and_pub_inputs: Vec<SP1VkAndPubInputs>,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct RootAggregatorInput {
+pub struct ChunkAggregatorInput {
     pub proofs_and_leaves_commitment: Vec<(SP1VkAndPubInputs, Vec<[u8; 32]>)>,
 }

aggregation_mode/aggregation_programs/sp1/src/lib.rs

@@ -0,0 +1,24 @@
+#![no_main]
+sp1_zkvm::entrypoint!(main);
+
+use lambdaworks_crypto::merkle_tree::merkle::MerkleTree;
+use sha2::{Digest, Sha256};
+use sp1_aggregation_program::{SP1VkAndPubInputs, UserProofsAggregatorInput};
+
+pub fn main() {
+    let input = sp1_zkvm::io::read::<UserProofsAggregatorInput>();
+
+    // Verify the proofs.
+    for proof in input.proofs_vk_and_pub_inputs.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_tree =
+        MerkleTree::<SP1VkAndPubInputs>::build(&input.proofs_vk_and_pub_inputs).unwrap();
+
+    sp1_zkvm::io::commit_slice(&merkle_tree.root);
+}