feat: error handling + fetch risc0 proofs

Author: MarcosNicolau

aggregation_mode/aggregation_programs/risc0/src/lib.rs

@@ -3,7 +3,7 @@ use tiny_keccak::{Hasher, Keccak};
 
 #[derive(Serialize, Deserialize)]
 pub struct Risc0ImageIdAndPubInputs {
-    pub image_id: [u32; 8],
+    pub image_id: [u8; 32],
     pub public_inputs: Vec<u8>,
 }
 

aggregation_mode/src/aggregators/lib.rs

@@ -1,7 +1,5 @@
-use risc0_zkvm::Receipt;
-
 use super::{
-    risc0_aggregator::{self, Risc0AggregationInput},
+    risc0_aggregator::{self, Risc0AggregationInput, Risc0ProofReceiptAndImageId},
     sp1_aggregator::{self, SP1AggregationInput, SP1ProofWithPubValuesAndElf},
 };
 
@@ -12,7 +10,7 @@ pub enum ProgramInput {
 
 pub enum AggregatedProof {
     SP1(SP1ProofWithPubValuesAndElf),
-    Risc0(Receipt),
+    Risc0(Risc0ProofReceiptAndImageId),
 }
 
 pub struct ProgramOutput {
@@ -29,6 +27,7 @@ impl ProgramOutput {
 pub enum ProofAggregationError {
     SP1Verification(sp1_sdk::SP1VerificationError),
     SP1Proving,
+    Risc0Proving,
     UnsupportedProof,
 }
 

aggregation_mode/src/aggregators/mod.rs

@@ -2,7 +2,7 @@ pub mod lib;
 pub mod risc0_aggregator;
 pub mod sp1_aggregator;
 
-use risc0_aggregator::{AlignedRisc0VerificationError, Risc0ProofWithPubValuesAndImageId};
+use risc0_aggregator::{AlignedRisc0VerificationError, Risc0ProofReceiptAndImageId};
 use sp1_aggregator::{AlignedSP1VerificationError, SP1ProofWithPubValuesAndElf};
 pub enum ZKVMEngine {
     SP1,
@@ -11,7 +11,7 @@ pub enum ZKVMEngine {
 
 pub enum AlignedProof {
     SP1(SP1ProofWithPubValuesAndElf),
-    Risc0(Risc0ProofWithPubValuesAndImageId),
+    Risc0(Risc0ProofReceiptAndImageId),
 }
 
 impl AlignedProof {
@@ -38,7 +38,7 @@ impl AlignedProof {
                 },
             ),
             AlignedProof::Risc0(proof) => {
-                risc0_aggregator::verify(&proof.receipt).map_err(AlignedVerificationError::Risc0)
+                risc0_aggregator::verify(proof).map_err(AlignedVerificationError::Risc0)
             }
         }
     }

aggregation_mode/src/aggregators/risc0_aggregator.rs

@@ -1,23 +1,46 @@
 include!(concat!(env!("OUT_DIR"), "/methods.rs"));
 
 use risc0_zkvm::{default_prover, ExecutorEnv, ProverOpts, Receipt};
+use sha3::{Digest, Keccak256};
 
 use super::lib::{AggregatedProof, ProgramOutput, ProofAggregationError};
 
-pub struct Risc0ProofWithPubValuesAndImageId {
-    pub image_id: [u32; 8],
+const RISC0_AGGREGATOR_PROGRAM_ID_BYTES: [u8; 32] = {
+    let mut res = [0u8; 32];
+    let mut i = 0;
+    while i < 8 {
+        let bytes = RISC0_AGGREGATOR_PROGRAM_ID[i].to_be_bytes();
+        res[i * 4] = bytes[0];
+        res[i * 4 + 1] = bytes[1];
+        res[i * 4 + 2] = bytes[2];
+        res[i * 4 + 3] = bytes[3];
+        i += 1;
+    }
+    res
+};
+
+pub struct Risc0ProofReceiptAndImageId {
+    pub image_id: [u8; 32],
     pub receipt: Receipt,
-    pub public_values: Vec<u8>,
 }
 
-impl Risc0ProofWithPubValuesAndImageId {
+impl Risc0ProofReceiptAndImageId {
+    pub fn public_inputs(&self) -> &Vec<u8> {
+        &self.receipt.journal.bytes
+    }
+}
+
+impl Risc0ProofReceiptAndImageId {
     pub fn hash_image_id_and_public_inputs(&self) -> [u8; 32] {
-        [0u8; 32]
+        let mut hasher = Keccak256::new();
+        hasher.update(&self.image_id);
+        hasher.update(self.public_inputs());
+        hasher.finalize().into()
     }
 }
 
 pub struct Risc0AggregationInput {
-    pub receipts: Vec<Risc0ProofWithPubValuesAndImageId>,
+    pub receipts: Vec<Risc0ProofReceiptAndImageId>,
     pub merkle_root: [u8; 32],
 }
 
@@ -28,39 +51,57 @@ pub(crate) fn aggregate_proofs(
 
     // write assumptions and proof image id + pub inputs
     let mut proofs_image_id_and_pub_inputs = vec![];
-    for r in input.receipts {
+    for proof in input.receipts {
         proofs_image_id_and_pub_inputs.push(risc0_aggregation_program::Risc0ImageIdAndPubInputs {
-            image_id: r.image_id,
-            public_inputs: r.public_values,
+            image_id: proof.image_id,
+            public_inputs: proof.receipt.journal.bytes.clone(),
         });
-        env_builder.add_assumption(r.receipt);
+        env_builder.add_assumption(proof.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();
+    env_builder
+        .write(&input)
+        .map_err(|_| ProofAggregationError::Risc0Proving)?;
 
-    let env = env_builder.build().unwrap();
+    let env = env_builder
+        .build()
+        .map_err(|_| ProofAggregationError::Risc0Proving)?;
 
     let prover = default_prover();
     let receipt = prover
         .prove_with_opts(env, RISC0_AGGREGATOR_PROGRAM_ELF, &ProverOpts::groth16())
-        .unwrap()
+        .map_err(|_| ProofAggregationError::Risc0Proving)?
         .receipt;
 
-    Ok(ProgramOutput::new(AggregatedProof::Risc0(receipt)))
+    let output = Risc0ProofReceiptAndImageId {
+        image_id: RISC0_AGGREGATOR_PROGRAM_ID_BYTES,
+        receipt,
+    };
+
+    Ok(ProgramOutput::new(AggregatedProof::Risc0(output)))
 }
 
 #[derive(Debug)]
 pub enum AlignedRisc0VerificationError {
-    Verification,
+    Verification(String),
     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(())
+pub(crate) fn verify(
+    proof: &Risc0ProofReceiptAndImageId,
+) -> Result<(), AlignedRisc0VerificationError> {
+    // only composite proofs are supported for recursion
+    if proof.receipt.inner.composite().is_err() {
+        Err(AlignedRisc0VerificationError::UnsupportedProof)
+    } else {
+        proof
+            .receipt
+            .verify(proof.image_id)
+            .map_err(|e| AlignedRisc0VerificationError::Verification(e.to_string()))
+    }
 }

aggregation_mode/src/backend/fetcher.rs

@@ -5,14 +5,18 @@ use super::{
     types::{AlignedLayerServiceManager, AlignedLayerServiceManagerContract, RPCProvider},
 };
 use crate::{
-    aggregators::{sp1_aggregator::SP1ProofWithPubValuesAndElf, AlignedProof},
+    aggregators::{
+        risc0_aggregator::Risc0ProofReceiptAndImageId, sp1_aggregator::SP1ProofWithPubValuesAndElf,
+        AlignedProof,
+    },
     backend::s3::get_aligned_batch_from_s3,
 };
 use aligned_sdk::core::types::ProvingSystemId;
 use alloy::{
     primitives::Address,
     providers::{Provider, ProviderBuilder},
 };
+use risc0_zkvm::Receipt;
 use tracing::{error, info};
 
 #[derive(Debug)]
@@ -82,7 +86,7 @@ impl ProofsFetcher {
 
             info!("Data downloaded from S3, number of proofs {}", data.len());
 
-            // Filter SP1 compressed proofs to and push to queue to be aggregated
+            // Filter compatible proofs to be aggregated and push to queue
             let proofs_to_add: Vec<AlignedProof> = data
                 .into_iter()
                 .filter_map(|p| match p.proving_system {
@@ -96,12 +100,24 @@ impl ProofsFetcher {
 
                         Some(AlignedProof::SP1(sp1_proof))
                     }
+                    ProvingSystemId::Risc0 => {
+                        let mut image_id = [0u8; 32];
+                        image_id.copy_from_slice(p.vm_program_code?.as_slice());
+                        let public_inputs = p.pub_input?;
+                        let inner_receipt: risc0_zkvm::InnerReceipt =
+                            bincode::deserialize(&p.proof).ok()?;
+
+                        let receipt = Receipt::new(inner_receipt, public_inputs);
+                        let risc0_proof = Risc0ProofReceiptAndImageId { image_id, receipt };
+
+                        Some(AlignedProof::Risc0(risc0_proof))
+                    }
                     _ => None,
                 })
                 .collect();
 
             info!(
-                "SP1 proofs filtered, total proofs to add {}",
+                "Proofs filtered, total proofs to add {}",
                 proofs_to_add.len()
             );