feat: interfaces + basic service to run sp1

Author: MarcosNicolau

aggregation-mode/src/lib.rs

@@ -0,0 +1,11 @@
+mod verifiers;
+
+use verifiers::interface::{
+    verify_proofs, AggregatedVerificationError, InputProofs, ProgramInput, ProgramOutput,
+};
+
+pub fn verify_aggregated_proofs() -> Result<ProgramOutput, AggregatedVerificationError> {
+    let sp1_compressed_proofs = vec![];
+    let input = ProgramInput::new(InputProofs::SP1Compressed(sp1_compressed_proofs));
+    verify_proofs(input)
+}

aggregation-mode/src/main.rs

@@ -0,0 +1,29 @@
+use std::time::Duration;
+
+use proof_aggregator::verify_aggregated_proofs;
+use tracing::{error, info};
+use tracing_subscriber::FmtSubscriber;
+
+fn main() {
+    let subscriber = FmtSubscriber::builder().finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    // simulate a service that sends proofs every n seconds after some processing
+    loop {
+        info!("Waiting 2 seconds before aggregating proofs...");
+        std::thread::sleep(Duration::from_secs(2));
+
+        let Ok(output) = verify_aggregated_proofs() else {
+            error!("Error while aggregating and verifying proofs");
+            return;
+        };
+        info!("Proof aggregated, sending to aligned verification contract...");
+
+        // TODO: send a blob transaction to with the merkle leaves
+        let _leaves = &output.leaves;
+
+        // TODO: call contract to verify proof + attach blob transaction
+        // the contract should emit a log with the verification and the path to the blob
+        let _calldata = output.calldata();
+    }
+}

aggregation-mode/src/verifiers/interface.rs

@@ -0,0 +1,53 @@
+use super::sp1::{self, SP1AggregatedProof};
+use serde::{Deserialize, Serialize};
+use zkvm_sp1_interface::SP1CompressedProof;
+
+#[derive(Serialize, Deserialize)]
+pub enum InputProofs {
+    SP1Compressed(Vec<SP1CompressedProof>),
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct ProgramInput {
+    proofs: InputProofs,
+}
+
+impl ProgramInput {
+    pub fn new(input_proofs: InputProofs) -> Self {
+        ProgramInput {
+            proofs: input_proofs,
+        }
+    }
+}
+
+pub enum AggregatedProof {
+    SP1(SP1AggregatedProof),
+}
+
+pub struct ProgramOutput {
+    pub proof: AggregatedProof,
+    pub leaves: Vec<Vec<u8>>,
+}
+
+impl ProgramOutput {
+    pub fn new(proof: AggregatedProof, leaves: Vec<Vec<u8>>) -> Self {
+        Self { proof, leaves }
+    }
+
+    /// TODO: return the contract calldata to verify proof
+    pub fn calldata(&self) -> Vec<u8> {
+        vec![]
+    }
+}
+
+#[derive(Debug)]
+pub enum AggregatedVerificationError {
+    SP1Verification(sp1_sdk::SP1VerificationError),
+    SP1Proving,
+}
+
+pub fn verify_proofs(input: ProgramInput) -> Result<ProgramOutput, AggregatedVerificationError> {
+    match input.proofs {
+        InputProofs::SP1Compressed(proofs) => sp1::verify_proof_aggregation(proofs),
+    }
+}

aggregation-mode/src/verifiers/mod.rs

@@ -0,0 +1,2 @@
+pub mod interface;
+pub mod sp1;

aggregation-mode/src/verifiers/sp1.rs

@@ -0,0 +1,38 @@
+use sp1_sdk::{ProverClient, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey};
+use zkvm_sp1_interface::SP1CompressedProof;
+
+use super::interface::{AggregatedProof, AggregatedVerificationError, ProgramOutput};
+
+const PROGRAM_ELF: &[u8] = include_bytes!("../../zkvm/sp1/elf/sp1_verifier_program");
+
+pub struct SP1AggregatedProof {
+    proof: SP1ProofWithPublicValues,
+    vk: SP1VerifyingKey,
+}
+
+pub(crate) fn verify_proof_aggregation(
+    proofs: Vec<SP1CompressedProof>,
+) -> Result<ProgramOutput, AggregatedVerificationError> {
+    let mut stdin = SP1Stdin::new();
+    stdin.write(&proofs);
+
+    let client = ProverClient::from_env();
+    let (pk, vk) = client.setup(PROGRAM_ELF);
+    let proof = client
+        .prove(&pk, &stdin)
+        .groth16()
+        .run()
+        .map_err(|_| AggregatedVerificationError::SP1Proving)?;
+
+    // a sanity check, vm already performs it
+    client
+        .verify(&proof, &vk)
+        .map_err(AggregatedVerificationError::SP1Verification)?;
+
+    let output = ProgramOutput::new(
+        AggregatedProof::SP1(SP1AggregatedProof { proof, vk }),
+        vec![],
+    );
+
+    Ok(output)
+}