feat: [wip] risc0 aggregator backend

Author: MarcosNicolau

aggregation_mode/src/aggregators/lib.rs

@@ -1,11 +1,18 @@
-use super::sp1_aggregator::{self, SP1AggregationInput, SP1ProofWithPubValuesAndElf};
+use risc0_zkvm::Receipt;
+
+use super::{
+    risc0_aggregator::{self, Risc0AggregationInput},
+    sp1_aggregator::{self, SP1AggregationInput, SP1ProofWithPubValuesAndElf},
+};
 
 pub enum ProgramInput {
     SP1(SP1AggregationInput),
+    Risc0(Risc0AggregationInput),
 }
 
 pub enum AggregatedProof {
     SP1(SP1ProofWithPubValuesAndElf),
+    Risc0(Receipt),
 }
 
 pub struct ProgramOutput {
@@ -28,5 +35,6 @@ pub enum ProofAggregationError {
 pub fn aggregate_proofs(input: ProgramInput) -> Result<ProgramOutput, ProofAggregationError> {
     match input {
         ProgramInput::SP1(input) => sp1_aggregator::aggregate_proofs(input),
+        ProgramInput::Risc0(input) => risc0_aggregator::aggregate_proofs(input),
     }
 }

aggregation_mode/src/aggregators/mod.rs

@@ -1,26 +1,32 @@
 pub mod lib;
+pub mod risc0_aggregator;
 pub mod sp1_aggregator;
 
+use risc0_aggregator::{AlignedRisc0VerificationError, Risc0ProofWithPubValuesAndImageId};
 use sp1_aggregator::{AlignedSP1VerificationError, SP1ProofWithPubValuesAndElf};
 pub enum ZKVMEngine {
     SP1,
+    RISC0,
 }
 
 pub enum AlignedProof {
     SP1(SP1ProofWithPubValuesAndElf),
+    Risc0(Risc0ProofWithPubValuesAndImageId),
 }
 
 impl AlignedProof {
     pub fn hash(&self) -> [u8; 32] {
         match self {
             AlignedProof::SP1(proof) => proof.hash_vk_and_pub_inputs(),
+            AlignedProof::Risc0(proof) => proof.hash_image_id_and_public_inputs(),
         }
     }
 }
 
 #[derive(Debug)]
 pub enum AlignedVerificationError {
     Sp1(AlignedSP1VerificationError),
+    Risc0(AlignedRisc0VerificationError),
 }
 
 impl AlignedProof {
@@ -31,6 +37,9 @@ impl AlignedProof {
                     AlignedVerificationError::Sp1(arg0)
                 },
             ),
+            AlignedProof::Risc0(proof) => {
+                risc0_aggregator::verify(&proof.receipt).map_err(AlignedVerificationError::Risc0)
+            }
         }
     }
 }

aggregation_mode/src/aggregators/risc0_aggregator.rs

@@ -0,0 +1,66 @@
+include!(concat!(env!("OUT_DIR"), "/methods.rs"));
+
+use risc0_zkvm::{default_prover, ExecutorEnv, ProverOpts, Receipt};
+
+use super::lib::{AggregatedProof, ProgramOutput, ProofAggregationError};
+
+pub struct Risc0ProofWithPubValuesAndImageId {
+    pub image_id: [u32; 8],
+    pub receipt: Receipt,
+    pub public_values: Vec<u8>,
+}
+
+impl Risc0ProofWithPubValuesAndImageId {
+    pub fn hash_image_id_and_public_inputs(&self) -> [u8; 32] {
+        [0u8; 32]
+    }
+}
+
+pub struct Risc0AggregationInput {
+    pub receipts: Vec<Risc0ProofWithPubValuesAndImageId>,
+    pub merkle_root: [u8; 32],
+}
+
+pub(crate) fn aggregate_proofs(
+    input: Risc0AggregationInput,
+) -> Result<ProgramOutput, ProofAggregationError> {
+    let mut env_builder = ExecutorEnv::builder();
+
+    // write assumptions and proof image id + pub inputs
+    let mut proofs_image_id_and_pub_inputs = vec![];
+    for r in input.receipts {
+        proofs_image_id_and_pub_inputs.push(risc0_aggregation_program::Risc0ImageIdAndPubInputs {
+            image_id: r.image_id,
+            public_inputs: r.public_values,
+        });
+        env_builder.add_assumption(r.receipt);
+    }
+
+    // write input data
+    let input = risc0_aggregation_program::Input {
+        merkle_root: input.merkle_root,
+        proofs_image_id_and_pub_inputs,
+    };
+    env_builder.write(&input).unwrap();
+
+    let env = env_builder.build().unwrap();
+
+    let prover = default_prover();
+    let receipt = prover
+        .prove_with_opts(env, RISC0_AGGREGATOR_PROGRAM_ELF, &ProverOpts::groth16())
+        .unwrap()
+        .receipt;
+
+    Ok(ProgramOutput::new(AggregatedProof::Risc0(receipt)))
+}
+
+#[derive(Debug)]
+pub enum AlignedRisc0VerificationError {
+    Verification,
+    UnsupportedProof,
+}
+
+pub(crate) fn verify(receipt: &Receipt) -> Result<(), AlignedRisc0VerificationError> {
+    // TODO validate and verify receipt is of type Compressed, as only they can be aggregated recursively
+    Ok(())
+}

aggregation_mode/src/backend/mod.rs

@@ -6,7 +6,8 @@ mod types;
 
 use crate::aggregators::{
     lib::{AggregatedProof, ProofAggregationError},
-    sp1_aggregator::{aggregate_proofs, SP1AggregationInput},
+    risc0_aggregator::{self, Risc0AggregationInput},
+    sp1_aggregator::{self, SP1AggregationInput},
     AlignedProof, ZKVMEngine,
 };
 
@@ -101,16 +102,17 @@ impl ProofAggregator {
 
         info!("Proofs fetched, constructing merkle root...");
         let (merkle_root, leaves) = compute_proofs_merkle_root(&proofs);
-        info!("Merkle root constructed: {}", hex::encode(merkle_root));
+        info!("Merkle root constructed: 0x{}", hex::encode(merkle_root));
 
         info!("Starting proof aggregation program...");
         let output = match self.engine {
             ZKVMEngine::SP1 => {
                 // only SP1 compressed proofs are supported
                 let proofs = proofs
                     .into_iter()
-                    .map(|proof| match proof {
-                        AlignedProof::SP1(proof) => proof,
+                    .filter_map(|proof| match proof {
+                        AlignedProof::SP1(proof) => Some(proof),
+                        _ => None,
                     })
                     .collect();
 
@@ -119,7 +121,25 @@ impl ProofAggregator {
                     merkle_root,
                 };
 
-                aggregate_proofs(input).map_err(AggregatedProofSubmissionError::Aggregation)?
+                sp1_aggregator::aggregate_proofs(input)
+                    .map_err(AggregatedProofSubmissionError::Aggregation)?
+            }
+            ZKVMEngine::RISC0 => {
+                let receipts = proofs
+                    .into_iter()
+                    .filter_map(|proof| match proof {
+                        AlignedProof::Risc0(proof) => Some(proof),
+                        _ => None,
+                    })
+                    .collect();
+
+                let input = Risc0AggregationInput {
+                    receipts,
+                    merkle_root,
+                };
+
+                risc0_aggregator::aggregate_proofs(input)
+                    .map_err(AggregatedProofSubmissionError::Aggregation)?
             }
         };
         info!("Proof aggregation program finished");
@@ -170,6 +190,9 @@ impl ProofAggregator {
                     .await
                     .map_err(AggregatedProofSubmissionError::ReceiptError)
             }
+            AggregatedProof::Risc0(proof) => {
+                todo!()
+            }
         }
     }