using sp1 proofs

Author: distractedm1nd

Cargo.lock

@@ -65,29 +65,26 @@ keystore-rs = "0.1.0"
 toml = "0.8.14"
 dirs = "5.0.1"
 anyhow = "1.0.44"
-jmt = { version = "0.10.0", features = ["mocks"] }
+jmt = { git = "https://github.com/deltadevsde/jmt", branch = "rehashing-circuit", features = [
+    "mocks",
+] }
 bellpepper-core = { version = "0.4.0", default-features = false }
 bellpepper = "0.4.1"
-itertools = "0.13.0"                                              # zip_eq
-arecibo = "0.2.0"
+itertools = "0.13.0" # zip_eq
+arecibo = { git = "https://github.com/deltadevsde/arecibo" }
 sha2 = "0.10.8"
 auto_impl = "1.2.0"
 bincode = "1.3.3"
-blake2 = "0.10.6"
 sp1-zkvm = { version = "1.2.0" }
+sp1-sdk = { version = "1.2.0" }
 prism-common = { path = "crates/common" }
 prism-nova = { path = "crates/nova" }
 prism-errors = { path = "crates/errors" }
 prism-main = { path = "crates/prism" }
 prism-groth16 = { path = "crates/groth16" }
-sp1-helper = "1.2.0"
 
 [patch.crates-io]
 sha2-v0-10-8 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", package = "sha2", branch = "patch-sha2-v0.10.8" }
-arecibo = { git = "https://github.com/deltadevsde/arecibo" }
-jmt = { git = "https://github.com/deltadevsde/jmt", branch = "rehashing-circuit", features = [
-    "mocks",
-] }
 
 # [workspace.dev-dependencies]
 # serial_test = "3.1.1"

Cargo.toml

@@ -14,5 +14,4 @@ jmt.workspace = true
 serde.workspace = true
 hex.workspace = true
 sha2.workspace = true
-blake2.workspace = true
 celestia-types.workspace = true

crates/common/Cargo.toml

@@ -14,7 +14,13 @@ use crate::hashchain::Hashchain;
 pub const SPARSE_MERKLE_PLACEHOLDER_HASH: Digest =
     Digest::new(*b"SPARSE_MERKLE_PLACEHOLDER_HASH__");
 
-pub type Hasher = blake2::Blake2s256;
+pub type Hasher = sha2::Sha256;
+
+pub fn hash(data: &[u8]) -> Digest {
+    let mut hasher = Hasher::new();
+    hasher.update(data);
+    Digest(hasher.finalize())
+}
 
 #[derive(
     Debug, Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Copy,
@@ -97,12 +103,6 @@ impl Digest {
     }
 }
 
-pub fn hash(data: &[u8]) -> Digest {
-    let mut hasher = blake2::Blake2s256::new();
-    hasher.update(data);
-    Digest(hasher.finalize())
-}
-
 #[derive(Serialize, Deserialize)]
 pub struct Batch {
     pub prev_root: Digest,
@@ -294,7 +294,6 @@ where
         let serialized_value = Self::serialize_value(&value)?;
 
         let old_root = self.get_current_root()?;
-        println!("key: {:?}", key);
         let (old_value, non_membership_merkle_proof) = self.jmt.get_with_proof(key, self.epoch)?;
 
         let non_membership_proof = NonMembershipProof {

crates/common/src/tree.rs

@@ -45,6 +45,7 @@ auto_impl = { workspace = true }
 prism-common = { workspace = true }
 prism-errors = { workspace = true }
 prism-groth16 = { workspace = true }
+sp1-sdk = { workspace = true }
 
 [dev-dependencies]
 serial_test = "3.1.1"

crates/prism/Cargo.toml

@@ -5,6 +5,8 @@ use borsh::{BorshDeserialize, BorshSerialize};
 use ed25519::Signature;
 use prism_common::{operation::Operation, tree::Digest};
 use prism_errors::GeneralError;
+use serde::{Deserialize, Serialize};
+use sp1_sdk::SP1ProofWithPublicValues;
 use std::{self, str::FromStr};
 
 pub mod celestia;
@@ -16,8 +18,7 @@ pub struct FinalizedEpoch {
     pub height: u64,
     pub prev_commitment: Digest,
     pub current_commitment: Digest,
-    // pub proof: Bls12Proof,
-    // pub verifying_key: VerifyingKey,
+    pub proof: SP1ProofWithPublicValues,
     pub signature: Option<String>,
 }
 

crates/prism/src/da/mod.rs

@@ -18,6 +18,8 @@ use storage::RedisConnection;
 #[macro_use]
 extern crate log;
 
+pub const PRISM_ELF: &[u8] = include_bytes!("../../../elf/riscv32im-succinct-zkvm-elf");
+
 /// The main function that initializes and runs a prism client.
 #[tokio::main()]
 async fn main() -> std::io::Result<()> {

crates/prism/src/main.rs

@@ -2,16 +2,20 @@ use crate::cfg::CelestiaConfig;
 use anyhow::{Context, Result};
 use async_trait::async_trait;
 use prism_errors::{DataAvailabilityError, GeneralError};
+use sp1_sdk::{ProverClient, SP1VerifyingKey};
 use std::{self, sync::Arc, time::Duration};
 use tokio::{task::spawn, time::interval};
 
 use crate::{da::DataAvailabilityLayer, node_types::NodeType, utils::verify_signature};
 
+pub const PRISM_ELF: &[u8] = include_bytes!("../../../../elf/riscv32im-succinct-zkvm-elf");
+
 pub struct LightClient {
     pub da: Arc<dyn DataAvailabilityLayer>,
-    // verifying_key is the [`VerifyingKey`] used to verify epochs from the prover/sequencer
-    pub verifying_key: Option<String>,
-    start_height: u64,
+    pub sequencer_pubkey: Option<String>,
+    pub client: ProverClient,
+    pub verifying_key: SP1VerifyingKey,
+    pub start_height: u64,
 }
 
 #[async_trait]
@@ -35,11 +39,15 @@ impl LightClient {
     pub fn new(
         da: Arc<dyn DataAvailabilityLayer>,
         cfg: CelestiaConfig,
-        sequencer_pub_key: Option<String>,
+        sequencer_pubkey: Option<String>,
     ) -> LightClient {
+        let client = ProverClient::new();
+        let (_, verifying_key) = client.setup(PRISM_ELF);
         LightClient {
             da,
-            verifying_key: sequencer_pub_key,
+            verifying_key,
+            client,
+            sequencer_pubkey,
             start_height: cfg.start_height,
         }
     }
@@ -71,33 +79,15 @@ impl LightClient {
 
                             // todo: verify adjacency to last heights, <- for this we need some sort of storage of epochs
                             for epoch_json in epoch_json_vec {
-                                // let prev_commitment = &epoch_json.prev_commitment;
-                                // let current_commitment = &epoch_json.current_commitment;
-
-                                // let proof = match epoch_json.proof.clone().try_into() {
-                                //     Ok(proof) => proof,
-                                //     Err(e) => {
-                                //         error!("failed to deserialize proof, skipping a blob at height {}: {:?}", i, e);
-                                //         continue;
-                                //     }
-                                // };
-
-                                // TODO(@distractedm1nd): i don't know rust yet but this seems like non-idiomatic rust -
-                                // is there not a Trait that can satisfy these properties for us?
-                                // let verifying_key = match epoch_json.verifying_key.clone().try_into() {
-                                //     Ok(vk) => vk,
-                                //     Err(e) => {
-                                //         error!("failed to deserialize verifying key, skipping a blob at height {}: {:?}", i, e);
-                                //         continue;
-                                //     }
-                                //  };
+                                let prev_commitment = &epoch_json.prev_commitment;
+                                let current_commitment = &epoch_json.current_commitment;
 
                                 // if the user does not add a verifying key, we will not verify the signature,
                                 // but only log a warning on startup
-                                if self.verifying_key.is_some() {
+                                if self.sequencer_pubkey.is_some() {
                                     match verify_signature(
                                         &epoch_json.clone(),
-                                        self.verifying_key.clone(),
+                                        self.sequencer_pubkey.clone(),
                                     ) {
                                         Ok(_) => trace!(
                                             "valid signature for epoch {}",
@@ -109,20 +99,20 @@ impl LightClient {
                                     }
                                 }
 
-                                // match validate_epoch(
-                                //     prev_commitment,
-                                //     current_commitment,
-                                //     proof,
-                                //     verifying_key,
-                                // ) {
-                                //     Ok(_) => {
-                                //         info!(
-                                //             "zkSNARK for epoch {} was validated successfully",
-                                //             epoch_json.height
-                                //         )
-                                //     }
-                                //     Err(err) => panic!("failed to validate epoch: {:?}", err),
-                                // }
+                                // TODO: compare commitment to epoch_json.proof.public_values
+
+                                match self.client.verify(&epoch_json.proof, &self.verifying_key) {
+                                    Ok(_) => {
+                                        info!(
+                                            "zkSNARK for epoch {} was validated successfully",
+                                            epoch_json.height
+                                        )
+                                    }
+                                    Err(err) => panic!(
+                                        "failed to validate epoch at height {}: {:?}",
+                                        epoch_json.height, err
+                                    ),
+                                }
                             }
                         }
                         Err(e) => {

crates/prism/src/node_types/lightclient.rs

@@ -3,7 +3,7 @@ use async_trait::async_trait;
 use ed25519::Signature;
 use ed25519_dalek::{Signer, SigningKey};
 use jmt::KeyHash;
-use prism_common::tree::{hash, Digest, Hasher, KeyDirectoryTree, Proof, SnarkableTree};
+use prism_common::tree::{hash, Batch, Digest, Hasher, KeyDirectoryTree, Proof, SnarkableTree};
 use std::{self, str::FromStr, sync::Arc};
 use tokio::{
     sync::{
@@ -14,6 +14,8 @@ use tokio::{
     time::interval,
 };
 
+use sp1_sdk::{ProverClient, SP1ProvingKey, SP1Stdin, SP1VerifyingKey};
+
 #[cfg(test)]
 use prism_errors::DataAvailabilityError;
 
@@ -31,6 +33,8 @@ use prism_common::{
 };
 use prism_errors::{DatabaseError, GeneralError};
 
+pub const PRISM_ELF: &[u8] = include_bytes!("../../../../elf/riscv32im-succinct-zkvm-elf");
+
 pub struct Sequencer {
     pub db: Arc<dyn Database>,
     pub da: Arc<dyn DataAvailabilityLayer>,
@@ -47,6 +51,10 @@ pub struct Sequencer {
     // posted to the DA layer.
     pending_operations: Arc<Mutex<Vec<Operation>>>,
     tree: Arc<Mutex<KeyDirectoryTree<Box<dyn Database>>>>,
+    prover_client: Arc<Mutex<ProverClient>>,
+
+    proving_key: SP1ProvingKey,
+    verifying_key: SP1VerifyingKey,
 
     epoch_buffer_tx: Arc<Sender<FinalizedEpoch>>,
     epoch_buffer_rx: Arc<Mutex<Receiver<FinalizedEpoch>>>,
@@ -86,13 +94,19 @@ impl Sequencer {
 
         // Create the KeyDirectory
         let tree = Arc::new(Mutex::new(KeyDirectoryTree::new(db.clone())));
+        let prover_client = ProverClient::new();
+
+        let (pk, vk) = prover_client.setup(PRISM_ELF);
 
         Ok(Sequencer {
             db: db.clone(),
             da,
             ws: WebServer::new(ws),
+            proving_key: pk,
+            verifying_key: vk,
             key,
             start_height,
+            prover_client: Arc::new(Mutex::new(prover_client)),
             tree,
             pending_operations: Arc::new(Mutex::new(Vec::new())),
             epoch_buffer_tx: Arc::new(tx),
@@ -305,19 +319,23 @@ impl Sequencer {
             .set_commitment(&epoch, &current_commitment)
             .context("Failed to add commitment for new epoch")?;
 
-        // let batch_circuit =
-        //     BatchMerkleProofCircuit::new(&prev_commitment, &current_commitment, proofs)
-        //         .context("Failed to create BatchMerkleProofCircuit")?;
-        // let (proof, verifying_key) = batch_circuit
-        //     .create_and_verify_snark()
-        //     .context("Failed to create and verify snark")?;
+        let batch = Batch {
+            prev_root: prev_commitment,
+            new_root: current_commitment,
+            proofs,
+        };
+
+        let mut stdin = SP1Stdin::new();
+        stdin.write(&batch);
+
+        let client = self.prover_client.lock().await;
+        let proof = client.prove(&self.proving_key, stdin).plonk().run()?;
 
         let epoch_json = FinalizedEpoch {
             height: epoch,
             prev_commitment,
             current_commitment,
-            // proof: proof.into(),
-            // verifying_key: verifying_key.into(),
+            proof,
             signature: None,
         };