feat: STARK to SNARK conversion with Bonsai

host/Cargo.toml

@@ -5,13 +5,21 @@ edition = "2021"
 default-run = "zeth"
 
 [dependencies]
+alloy-primitives = { version = "0.6.2", default-features = false, features = [
+    "rlp",
+    "serde",
+    "std",
+] }
+alloy-sol-types = "0.6"
 anyhow = "1.0"
 bincode = "1.3.3"
 bonsai-sdk = { workspace = true }
 bytemuck = "1.13"
 clap = { version = "4.0", features = ["derive"] }
 env_logger = "0.11"
+ethers-contract = { version = "2.0", features = ["optimism"] }
 ethers-core = { version = "2.0", features = ["optimism"] }
+ethers-providers = { version = "2.0", features = ["optimism"] }
 hex = "0.4.3"
 log = "0.4"
 risc0-zkvm = { workspace = true, features = ["prove"] }

host/src/cli.rs

@@ -54,6 +54,39 @@ impl Cli {
             Cli::Verify(..) => unimplemented!(),
         }
     }
+
+    pub fn submit_to_bonsai(&self) -> bool {
+        if let Cli::Prove(prove_args) = self {
+            prove_args.submit_to_bonsai
+        } else {
+            false
+        }
+    }
+
+    pub fn snark(&self) -> bool {
+        if let Cli::Prove(prove_args) = self {
+            prove_args.snark_args.snark
+        } else {
+            false
+        }
+    }
+
+    pub fn verifier_or_eth_rpc_url(&self) -> Option<String> {
+        let verifier_rpc_url = if let Cli::Prove(prove_args) = self {
+            prove_args.snark_args.verifier_rpc_url.clone()
+        } else {
+            None
+        };
+        verifier_rpc_url.or(self.build_args().eth_rpc_url.clone())
+    }
+
+    pub fn verifier_contract(&self) -> Option<String> {
+        if let Cli::Prove(prove_args) = self {
+            prove_args.snark_args.verifier_contract.clone()
+        } else {
+            None
+        }
+    }
 }
 
 #[derive(Debug, Clone, clap::ValueEnum)]
@@ -160,6 +193,25 @@ pub struct ProveArgs {
     #[clap(short, long, default_value_t = false)]
     /// Prove remotely using Bonsai
     pub submit_to_bonsai: bool,
+
+    #[clap(flatten)]
+    pub snark_args: SnarkArgs,
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct SnarkArgs {
+    /// Convert the resulting STARK receipt into a Groth-16 SNARK using Bonsai
+    #[clap(short, long, default_value_t = false)]
+    pub snark: bool,
+
+    #[clap(short, long, require_equals = true)]
+    /// URL of the Ethereum RPC node for SNARK verification.
+    pub verifier_rpc_url: Option<String>,
+
+    #[clap(short, long, require_equals = true)]
+    /// Address of the RiscZeroGroth16Verifier contract. Requires `eth_rpc_url` or
+    /// `verifier_rpc_url` to be set.
+    pub verifier_contract: Option<String>,
 }
 
 impl Tag for ProveArgs {

host/src/lib.rs

@@ -14,13 +14,15 @@
 
 use std::{fs, path::Path};
 
-use risc0_zkvm::{is_dev_mode, Receipt};
+use risc0_zkvm::is_dev_mode;
 use tracing::debug;
 
 pub mod cli;
 pub mod operations;
 
-pub fn load_receipt(file_name: &String) -> anyhow::Result<Option<(String, Receipt)>> {
+pub fn load_receipt<T: serde::de::DeserializeOwned>(
+    file_name: &String,
+) -> anyhow::Result<Option<(String, T)>> {
     if is_dev_mode() {
         // Nothing to load
         return Ok(None);
@@ -38,7 +40,7 @@ pub fn load_receipt(file_name: &String) -> anyhow::Result<Option<(String, Receip
     Ok(Some(bincode::deserialize(&receipt_serialized)?))
 }
 
-pub fn save_receipt(receipt_label: &String, receipt_data: &(String, Receipt)) {
+pub fn save_receipt<T: serde::Serialize>(receipt_label: &String, receipt_data: &(String, T)) {
     if !is_dev_mode() {
         fs::write(
             zkp_cache_path(receipt_label),

host/src/main.rs

@@ -20,7 +20,7 @@ use log::info;
 use risc0_zkvm::sha::Digest;
 use zeth::{
     cli::{Cli, Network},
-    operations::{build, rollups},
+    operations::{build, rollups, snarks::verify_groth16_snark, stark2snark},
 };
 use zeth_guests::*;
 use zeth_lib::{
@@ -41,33 +41,62 @@ async fn main() -> Result<()> {
 
     // execute the command
     let build_args = cli.build_args();
-    match build_args.network {
+    let (image_id, stark) = match build_args.network {
         Network::Ethereum => {
             let rpc_url = build_args.eth_rpc_url.clone();
-            build::build_block::<EthereumStrategy>(
-                cli,
-                rpc_url,
-                &ETH_MAINNET_CHAIN_SPEC,
-                ETH_BLOCK_ELF,
+            (
+                ETH_BLOCK_ID,
+                build::build_block::<EthereumStrategy>(
+                    &cli,
+                    rpc_url,
+                    &ETH_MAINNET_CHAIN_SPEC,
+                    ETH_BLOCK_ELF,
+                )
+                .await?,
             )
-            .await
         }
         Network::Optimism => {
             let rpc_url = build_args.op_rpc_url.clone();
-            build::build_block::<OptimismStrategy>(
-                cli,
-                rpc_url,
-                &OP_MAINNET_CHAIN_SPEC,
-                OP_BLOCK_ELF,
+            (
+                OP_BLOCK_ID,
+                build::build_block::<OptimismStrategy>(
+                    &cli,
+                    rpc_url,
+                    &OP_MAINNET_CHAIN_SPEC,
+                    OP_BLOCK_ELF,
+                )
+                .await?,
             )
-            .await
         }
         Network::OptimismDerived => {
             if let Some(composition_size) = build_args.composition {
-                rollups::compose_derived_rollup_blocks(cli, composition_size).await
+                (
+                    OP_COMPOSE_ID,
+                    rollups::compose_derived_rollup_blocks(&cli, composition_size).await?,
+                )
             } else {
-                rollups::derive_rollup_blocks(cli).await
+                (OP_DERIVE_ID, rollups::derive_rollup_blocks(&cli).await?)
             }
         }
+    };
+
+    // Create/verify Groth16 SNARK
+    if cli.snark() {
+        let Some((stark_uuid, stark_receipt)) = stark else {
+            panic!("No STARK data to snarkify!");
+        };
+
+        if !cli.submit_to_bonsai() {
+            panic!("Bonsai submission flag required to create a SNARK!");
+        }
+
+        let image_id = Digest::from(image_id);
+        let (snark_uuid, snark_receipt) = stark2snark(image_id, stark_uuid, stark_receipt).await?;
+
+        info!("Validating SNARK uuid: {}", snark_uuid);
+
+        verify_groth16_snark(&cli, image_id, snark_receipt).await?;
     }
+
+    Ok(())
 }

host/src/operations/build.rs

@@ -17,7 +17,7 @@ use std::fmt::Debug;
 use anyhow::Context;
 use ethers_core::types::Transaction as EthersTransaction;
 use log::{info, warn};
-use risc0_zkvm::compute_image_id;
+use risc0_zkvm::{compute_image_id, Receipt};
 use serde::{Deserialize, Serialize};
 use zeth_lib::{
     builder::BlockBuilderStrategy,
@@ -34,11 +34,11 @@ use crate::{
 
 /// Build a single block using the specified strategy.
 pub async fn build_block<N: BlockBuilderStrategy>(
-    cli: Cli,
+    cli: &Cli,
     rpc_url: Option<String>,
     chain_spec: &ChainSpec,
     guest_elf: &[u8],
-) -> anyhow::Result<()>
+) -> anyhow::Result<Option<(String, Receipt)>>
 where
     N::TxEssence: 'static + Send + TryFrom<EthersTransaction> + Serialize + Deserialize<'static>,
     <N::TxEssence as TryFrom<EthersTransaction>>::Error: Debug,
@@ -90,8 +90,8 @@ where
     }
 
     let compressed_output = output.with_state_hashed();
-    match &cli {
-        Cli::Build(..) => {}
+    let result = match cli {
+        Cli::Build(..) => None,
         Cli::Run(run_args) => {
             execute(
                 &input,
@@ -101,27 +101,28 @@ where
                 &compressed_output,
                 &cli.execution_tag(),
             );
+            None
         }
         Cli::Prove(..) => {
             maybe_prove(
-                &cli,
+                cli,
                 &input,
                 guest_elf,
                 &compressed_output,
                 Default::default(),
             )
-            .await;
+            .await
         }
-        Cli::Verify(verify_args) => {
+        Cli::Verify(verify_args) => Some(
             verify_bonsai_receipt(
                 compute_image_id(guest_elf)?,
                 &compressed_output,
                 verify_args.bonsai_receipt_uuid.clone(),
                 4,
             )
-            .await?;
-        }
-    }
+            .await?,
+        ),
+    };
 
-    Ok(())
+    Ok(result)
 }

host/src/operations/mod.rs

@@ -14,20 +14,92 @@
 
 pub mod build;
 pub mod rollups;
+pub mod snarks;
 
 use std::fmt::Debug;
 
+use bonsai_sdk::alpha::responses::SnarkReceipt;
 use log::{debug, error, info, warn};
 use risc0_zkvm::{
-    compute_image_id, default_prover, serde::to_vec, sha::Digest, Assumption, ExecutorEnv,
-    ExecutorImpl, FileSegmentRef, Receipt, Session,
+    compute_image_id, default_prover,
+    serde::to_vec,
+    sha::{Digest, Digestible},
+    Assumption, ExecutorEnv, ExecutorImpl, FileSegmentRef, Receipt, Session,
 };
 use serde::{de::DeserializeOwned, Serialize};
 use tempfile::tempdir;
 use zeth_primitives::keccak::keccak;
 
 use crate::{cli::Cli, load_receipt, save_receipt};
 
+pub async fn stark2snark(
+    image_id: Digest,
+    stark_uuid: String,
+    stark_receipt: Receipt,
+) -> anyhow::Result<(String, SnarkReceipt)> {
+    info!("Submitting SNARK workload");
+    // Label snark output as journal digest
+    let receipt_label = format!(
+        "{}-{}",
+        hex::encode_upper(image_id),
+        hex::encode(keccak(stark_receipt.journal.bytes.digest()))
+    );
+    // Load cached receipt if found
+    if let Ok(Some(cached_data)) = load_receipt(&receipt_label) {
+        info!("Loaded locally cached receipt");
+        return Ok(cached_data);
+    }
+    // Otherwise compute on Bonsai
+    let stark_uuid = if stark_uuid.is_empty() {
+        upload_receipt(&stark_receipt).await?
+    } else {
+        stark_uuid
+    };
+
+    let client = bonsai_sdk::alpha_async::get_client_from_env(risc0_zkvm::VERSION).await?;
+    let snark_uuid = client.create_snark(stark_uuid)?;
+
+    let snark_receipt = loop {
+        let res = snark_uuid.status(&client)?;
+
+        if res.status == "RUNNING" {
+            info!("Current status: {} - continue polling...", res.status,);
+            std::thread::sleep(std::time::Duration::from_secs(15));
+        } else if res.status == "SUCCEEDED" {
+            break res
+                .output
+                .expect("Bonsai response is missing SnarkReceipt.");
+        } else {
+            panic!(
+                "Workflow exited: {} - | err: {}",
+                res.status,
+                res.error_msg.unwrap_or_default()
+            );
+        }
+    };
+
+    let stark_psd = stark_receipt.get_claim()?.post.digest();
+    let snark_psd = Digest::try_from(snark_receipt.post_state_digest.as_slice())?;
+
+    if stark_psd != snark_psd {
+        error!("SNARK/STARK Post State Digest mismatch!");
+        error!("STARK: {}", hex::encode(stark_psd));
+        error!("SNARK: {}", hex::encode(snark_psd));
+    }
+
+    if snark_receipt.journal != stark_receipt.journal.bytes {
+        error!("SNARK/STARK Receipt Journal mismatch!");
+        error!("STARK: {}", hex::encode(&stark_receipt.journal.bytes));
+        error!("SNARK: {}", hex::encode(&snark_receipt.journal));
+    };
+
+    let snark_data = (snark_uuid.uuid, snark_receipt);
+
+    save_receipt(&receipt_label, &snark_data);
+
+    Ok(snark_data)
+}
+
 pub async fn verify_bonsai_receipt<O: Eq + Debug + DeserializeOwned>(
     image_id: Digest,
     expected_output: &O,