feat: verify proofs

Author: MarcosNicolau

aggregation-mode/src/aggregator/interface.rs

@@ -1,21 +1,9 @@
-use super::sp1::{self, SP1AggregatedProof};
+use super::sp1::{self, SP1AggregatedProof, SP1Proof, SP1VerificationError};
 use serde::{Deserialize, Serialize};
-use sp1_aggregator::SP1CompressedProof;
 
 #[derive(Serialize, Deserialize)]
-pub enum InputProofs {
-    SP1Compressed(Vec<SP1CompressedProof>),
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct ProgramInput {
-    proofs: InputProofs,
-}
-
-impl ProgramInput {
-    pub fn new(proofs: InputProofs) -> Self {
-        ProgramInput { proofs }
-    }
+pub enum ProgramInput {
+    SP1(sp1_aggregator::Input),
 }
 
 pub enum AggregatedProof {
@@ -44,7 +32,21 @@ pub enum AggregatedVerificationError {
 }
 
 pub fn aggregate_proofs(input: ProgramInput) -> Result<ProgramOutput, AggregatedVerificationError> {
-    match input.proofs {
-        InputProofs::SP1Compressed(proofs) => sp1::aggregate_proofs(proofs),
+    match input {
+        ProgramInput::SP1(input) => sp1::aggregate_proofs(input),
+    }
+}
+
+enum Proof {
+    SP1(SP1Proof),
+}
+
+enum VerificationError {
+    SP1(SP1VerificationError),
+}
+
+pub fn verify_proof(proof: &Proof) -> Result<(), VerificationError> {
+    match proof {
+        Proof::SP1(proof) => sp1::verify(proof).map_err(VerificationError::SP1),
     }
 }

aggregation-mode/src/aggregator/sp1.rs

@@ -1,20 +1,26 @@
-use sp1_aggregator::SP1CompressedProof;
 use sp1_sdk::{Prover, ProverClient, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey};
 
 use super::interface::{AggregatedProof, AggregatedVerificationError, ProgramOutput};
 
 const PROGRAM_ELF: &[u8] = include_bytes!("../../zkvm/sp1/elf/sp1_aggregator_program");
 
+// TODO lock prover
+
+pub struct SP1Proof {
+    pub elf: Vec<u8>,
+    pub proof: Vec<u8>,
+}
+
 pub struct SP1AggregatedProof {
     pub proof: SP1ProofWithPublicValues,
     pub vk: SP1VerifyingKey,
 }
 
 pub(crate) fn aggregate_proofs(
-    proofs: Vec<SP1CompressedProof>,
+    input: sp1_aggregator::Input,
 ) -> Result<ProgramOutput, AggregatedVerificationError> {
     let mut stdin = SP1Stdin::new();
-    stdin.write(&proofs);
+    stdin.write(&input);
 
     #[cfg(feature = "prove")]
     let client = ProverClient::from_env();
@@ -34,7 +40,28 @@ pub(crate) fn aggregate_proofs(
         .verify(&proof, &vk)
         .map_err(AggregatedVerificationError::SP1Verification)?;
 
-    let output = ProgramOutput::new(AggregatedProof::SP1(SP1AggregatedProof { proof, vk }));
+    let proof = SP1AggregatedProof { proof, vk };
+
+    let output = ProgramOutput::new(AggregatedProof::SP1(proof));
 
     Ok(output)
 }
+
+pub enum SP1VerificationError {
+    Verification(sp1_sdk::SP1VerificationError),
+    DecodeProofBinary,
+}
+
+pub(crate) fn verify(proof: &SP1Proof) -> Result<(), SP1VerificationError> {
+    let client = ProverClient::from_env();
+
+    let (_pk, vk) = client.setup(&proof.elf);
+
+    if let Ok(proof) = bincode::deserialize(&proof.proof) {
+        client
+            .verify(&proof, &vk)
+            .map_err(SP1VerificationError::Verification)
+    } else {
+        Err(SP1VerificationError::DecodeProofBinary)
+    }
+}

aggregation-mode/zkvm/sp1/src/lib.rs

@@ -27,3 +27,21 @@ impl SP1CompressedProof {
         hasher.finalize().into()
     }
 }
+
+#[derive(Serialize, Deserialize)]
+pub enum Proof {
+    SP1Compressed(SP1CompressedProof),
+}
+
+impl Proof {
+    pub fn hash(&self) -> [u8; 32] {
+        match self {
+            Proof::SP1Compressed(proof) => proof.hash(),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Input {
+    pub proofs: Vec<Proof>,
+}

aggregation-mode/zkvm/sp1/src/main.rs

@@ -2,7 +2,7 @@
 sp1_zkvm::entrypoint!(main);
 
 use sha2::{Digest, Sha256};
-use sp1_aggregator::SP1CompressedProof;
+use sp1_aggregator::{Input, Proof};
 
 fn combine_hashes(hash_a: &[u8; 32], hash_b: &[u8; 32]) -> [u8; 32] {
     let mut hasher = Sha256::new();
@@ -12,7 +12,7 @@ fn combine_hashes(hash_a: &[u8; 32], hash_b: &[u8; 32]) -> [u8; 32] {
 }
 
 /// Computes the merkle root for the given proofs using the vk
-fn compute_merkle_root(proofs: &[SP1CompressedProof]) -> [u8; 32] {
+fn compute_merkle_root(proofs: &[Proof]) -> [u8; 32] {
     let mut leaves: Vec<[u8; 32]> = proofs
         .chunks(2)
         .map(|chunk| match chunk {
@@ -38,16 +38,20 @@ fn compute_merkle_root(proofs: &[SP1CompressedProof]) -> [u8; 32] {
 
 // TODO: Update input and use AlignedVerificationData
 pub fn main() {
-    let input = sp1_zkvm::io::read::<Vec<SP1CompressedProof>>();
+    let input = sp1_zkvm::io::read::<Input>();
 
     // 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());
+    for proof in input.proofs.iter() {
+        match proof {
+            Proof::SP1Compressed(proof) => {
+                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);
+    let merkle_root = compute_merkle_root(&input.proofs);
     sp1_zkvm::io::commit_slice(&merkle_root);
 }