Fix/flounder audit circuit

circuits/commit-chain-proof/host/Cargo.toml

@@ -25,6 +25,7 @@ tendermint-light-client-verifier = { workspace = true, default-features = false,
 ] }
 
 proof-builder.workspace = true
+verifier.workspace = true
 
 # Ziren
 zkm-sdk.workspace = true

circuits/commit-chain-proof/host/src/lib.rs

@@ -4,8 +4,8 @@ use commit_chain::*;
 use proof_builder::{LongRunning, ProofBuilder, ProofRequest};
 use std::str::FromStr;
 use zkm_sdk::{
-    HashableKey, Prover, ProverClient, ZKMProofKind, ZKMProofWithPublicValues, ZKMStdin,
-    include_elf,
+    HashableKey, Prover, ProverClient, ZKM_CIRCUIT_VERSION, ZKMProofKind, ZKMProofWithPublicValues,
+    ZKMStdin, include_elf,
 };
 
 use sha2::{Digest, Sha256};
@@ -23,6 +23,10 @@ use clap::Parser;
 /// The arguments for the cli.
 #[derive(Debug, Clone, Parser, serde::Deserialize, serde::Serialize)]
 pub struct Args {
+    #[arg(long, default_value_t = false)]
+    #[serde(default)]
+    pub print_program_id: bool,
+
     #[arg(long, default_value_t = true)]
     pub enable: bool,
 
@@ -32,7 +36,14 @@ pub struct Args {
     #[arg(long, env, default_value = "http://127.0.0.1:3002")]
     pub esplora_url: String,
 
-    #[arg(long, env)]
+    // Print-only mode skips runtime inputs but keeps them required otherwise.
+    #[arg(
+        long,
+        env,
+        required = false,
+        required_unless_present = "print_program_id",
+        default_value_if("print_program_id", "true", Some(""))
+    )]
     pub commit_info: String,
 
     #[arg(long, default_value = "commits.bin")]
@@ -149,6 +160,11 @@ impl CommitChainProofBuilder {
         let (proving_key, verifying_key) = client.setup(COMMIT_CHAIN);
         Self { client, proving_key, verifying_key }
     }
+
+    pub fn program_id(&self) -> anyhow::Result<verifier::ProgramId> {
+        verifier::program_id(self.verifying_key.bytes32().as_bytes(), ZKM_CIRCUIT_VERSION)
+            .map_err(anyhow::Error::msg)
+    }
 }
 
 impl ProofBuilder for CommitChainProofBuilder {
@@ -188,6 +204,7 @@ impl ProofBuilder for CommitChainProofBuilder {
             //let prev: CommitChainCircuitOutput = serde_json::from_slice(&public_inputs).unwrap();
             Some(public_inputs)
         };
+        let self_program_id = self.program_id()?;
         let (prev_proof, zkm_proof, zkm_public_values, zkm_vk_hash, zkm_version) =
             match prev_receipt.clone() {
                 Some(public_inputs) => {
@@ -205,21 +222,16 @@ impl ProofBuilder for CommitChainProofBuilder {
                                 format!("invalid UTF-8 in zkm_version file '{version_path}'")
                             })
                         })?;
-                    let prev_output = decode_commit_chain_circuit_output(&public_inputs);
-                    (
-                        CommitChainPrevProofType::PrevProof(prev_output),
-                        proof_bytes,
-                        public_inputs,
-                        zkm_vk_hash.to_vec(),
-                        zkm_version,
-                    )
+                    let prev_proof =
+                        classify_commit_chain_output(&public_inputs).map_err(anyhow::Error::msg)?;
+                    (prev_proof, proof_bytes, public_inputs, zkm_vk_hash.to_vec(), zkm_version)
                 }
                 None => (
                     CommitChainPrevProofType::GenesisBlock,
                     Vec::new(),
                     Vec::new(),
                     Vec::new(),
-                    "v1.2.5".into(),
+                    ZKM_CIRCUIT_VERSION.into(),
                 ),
             };
 
@@ -228,6 +240,7 @@ impl ProofBuilder for CommitChainProofBuilder {
             zkm_version,
             zkm_proof,
             prev_proof,
+            self_program_id,
             commits: commits.to_vec(),
             zkm_public_values,
         };
@@ -263,10 +276,9 @@ impl ProofBuilder for CommitChainProofBuilder {
 
         tracing::info!("Commit chain proof cycles: {}", cycles);
 
-        // todo: verify the proof laterr
-        // if let Err(e) = self.client.verify(&proof, &self.verifying_key) {
-        //     panic!("{}", e);
-        // }
+        self.client
+            .verify(&proof, &self.verifying_key)
+            .context("Failed to verify generated commit chain proof")?;
 
         let input = bincode::serialize(&input)?;
         Ok((input, proof, cycles, proving_time))

circuits/commit-chain-proof/host/src/main.rs

@@ -11,6 +11,12 @@ async fn main() {
     zkm_sdk::utils::setup_logger();
     tracing::info!("args: {:?}", args);
 
+    let builder = CommitChainProofBuilder::new();
+    if args.print_program_id {
+        println!("{}", hex::encode(builder.program_id().unwrap()));
+        return;
+    }
+
     let commits = fetch_commit_chain(
         &args.esplora_url,
         &args.commit_info,
@@ -19,8 +25,6 @@ async fn main() {
     )
     .await
     .unwrap();
-    let builder = CommitChainProofBuilder::new();
-
     let ctx = ProofRequest::CommitChainProofRequest {
         init_input: args.init_input,
         input_proof: args.input_proof.clone(),

circuits/header-chain-proof/host/Cargo.toml

@@ -29,6 +29,7 @@ bitcoin = { workspace = true }
 client = { workspace = true }
 proof-builder = { workspace = true }
 util = { workspace = true }
+verifier = { workspace = true }
 
 # Ziren
 zkm-sdk.workspace = true

circuits/header-chain-proof/host/src/lib.rs

@@ -1,7 +1,10 @@
 use bitcoin::Network;
 use borsh::{BorshDeserialize, BorshSerialize};
 use client::btc_chain::BTCClient;
-use header_chain::{CircuitBlockHeader, HeaderChainCircuitInput, HeaderChainPrevProofType};
+use header_chain::{
+    CircuitBlockHeader, HeaderChainCircuitInput, HeaderChainPrevProofType,
+    classify_header_chain_output,
+};
 use proof_builder::{LongRunning, ProofBuilder, ProofRequest};
 use sha2::{Digest, Sha256};
 use std::{
@@ -10,7 +13,10 @@ use std::{
 };
 use util::get_btc_block_confirms;
 use zkm_sdk::ZKMProofKind;
-use zkm_sdk::{HashableKey, Prover, ProverClient, ZKMProofWithPublicValues, ZKMStdin, include_elf};
+use zkm_sdk::{
+    HashableKey, Prover, ProverClient, ZKM_CIRCUIT_VERSION, ZKMProofWithPublicValues, ZKMStdin,
+    include_elf,
+};
 static ELF_ID: OnceLock<String> = OnceLock::new();
 use anyhow::Context;
 use clap::Parser;
@@ -19,6 +25,10 @@ use std::sync::OnceLock;
 /// The arguments for the cli.
 #[derive(Debug, Clone, Parser, serde::Deserialize, serde::Serialize)]
 pub struct Args {
+    #[arg(long, default_value_t = false)]
+    #[serde(default)]
+    pub print_program_id: bool,
+
     #[arg(long, default_value_t = true)]
     pub enable: bool,
 
@@ -156,6 +166,11 @@ impl HeaderChainProofBuilder {
         let (proving_key, verifying_key) = client.setup(HEADER_CHAIN);
         Self { client, proving_key, verifying_key }
     }
+
+    pub fn program_id(&self) -> anyhow::Result<verifier::ProgramId> {
+        verifier::program_id(self.verifying_key.bytes32().as_bytes(), ZKM_CIRCUIT_VERSION)
+            .map_err(anyhow::Error::msg)
+    }
 }
 
 impl ProofBuilder for HeaderChainProofBuilder {
@@ -203,6 +218,7 @@ impl ProofBuilder for HeaderChainProofBuilder {
             Some(public_inputs)
         };
 
+        let self_program_id = self.program_id()?;
         let (prev_proof, zkm_proof, zkm_public_values, zkm_vk_hash, zkm_version) =
             match prev_receipt.clone() {
                 Some(public_inputs) => {
@@ -219,21 +235,16 @@ impl ProofBuilder for HeaderChainProofBuilder {
                                 format!("invalid UTF-8 in zkm_version file '{version_path}'")
                             })
                         })?;
-                    let prev_output = zkm_sdk::ZKMPublicValues::from(&public_inputs).read();
-                    (
-                        HeaderChainPrevProofType::PrevProof(prev_output),
-                        proof_bytes,
-                        public_inputs,
-                        zkm_vk_hash.to_vec(),
-                        zkm_version,
-                    )
+                    let prev_proof =
+                        classify_header_chain_output(&public_inputs).map_err(anyhow::Error::msg)?;
+                    (prev_proof, proof_bytes, public_inputs, zkm_vk_hash.to_vec(), zkm_version)
                 }
                 None => (
                     HeaderChainPrevProofType::GenesisBlock,
                     Vec::new(),
                     Vec::new(),
                     Vec::new(),
-                    "v1.2.5".into(),
+                    ZKM_CIRCUIT_VERSION.into(),
                 ),
             };
 
@@ -251,6 +262,7 @@ impl ProofBuilder for HeaderChainProofBuilder {
             zkm_public_values,
             zkm_vk_hash,
             zkm_version,
+            self_program_id,
             block_headers,
         };
 
@@ -282,9 +294,9 @@ impl ProofBuilder for HeaderChainProofBuilder {
 
         tracing::info!("Header chain proof cycles: {}", cycles);
 
-        if let Err(e) = self.client.verify(&proof, &self.verifying_key) {
-            panic!("{}", e);
-        }
+        self.client
+            .verify(&proof, &self.verifying_key)
+            .context("Failed to verify generated header chain proof")?;
 
         let input = bincode::serialize(&input)?;
         Ok((input, proof, cycles, proving_time))

circuits/header-chain-proof/host/src/main.rs

@@ -12,6 +12,12 @@ async fn main() {
     zkm_sdk::utils::setup_logger();
     tracing::info!("args: {args:?}");
 
+    let builder = HeaderChainProofBuilder::new();
+    if args.print_program_id {
+        println!("{}", hex::encode(builder.program_id().unwrap()));
+        return;
+    }
+
     let total_block_headers = fetch_header_chain(
         &args.esplora_url,
         args.start,
@@ -23,8 +29,6 @@ async fn main() {
     .await
     .unwrap();
 
-    let builder = HeaderChainProofBuilder::new();
-
     let ctx = ProofRequest::HeaderChainProofRequest {
         init_input: args.init_input,
         input_proof: args.input_proof.clone(),