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")]
@@ -100,11 +111,18 @@ pub async fn fetch_commit_chain(
     };
     let commit_txn = btc_client.get_tx(&txid).await?.unwrap();
 
-    let op_return_data = extract_op_return_data(&commit_txn.output);
-    let commitment = parse_commit_chain_commitment(&op_return_data);
-
-    if let tendermint::Hash::Sha256(expected_hash) = sequencer_hash(&ci.sequencers) {
-        assert_eq!(expected_hash, commitment.sequencer_set_hash);
+    let commitment =
+        extract_commit_chain_commitment(&commit_txn.output).map_err(anyhow::Error::msg)?;
+    if let tendermint::Hash::Sha256(sequencer_set_hash) = sequencer_hash(&ci.sequencers) {
+        anyhow::ensure!(
+            commitment
+                == commit_chain_commitment_digest(
+                    sequencer_set_hash,
+                    ci.genesis_evm_block_hash,
+                    ci.program_history_root,
+                ),
+            "commit transaction digest does not match commit info"
+        );
     } else {
         panic!("Invalid sequencer set hash");
     }
@@ -128,6 +146,8 @@ pub async fn fetch_commit_chain(
         next_publisher_public_keys,
         next_threshold: ci.next_threshold,
         genesis_txid: Txid::from_str(&ci.genesis_txid)?.as_raw_hash().to_byte_array(),
+        genesis_evm_block_hash: ci.genesis_evm_block_hash,
+        program_history_root: ci.program_history_root,
         block_height,
     };
     commits.push(commit);
@@ -189,6 +209,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) => {
@@ -206,21 +227,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(),
                 ),
             };
 
@@ -229,6 +245,7 @@ impl ProofBuilder for CommitChainProofBuilder {
             zkm_version,
             zkm_proof,
             prev_proof,
+            self_program_id,
             commits: commits.to_vec(),
             zkm_public_values,
         };
@@ -264,10 +281,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,
 
@@ -206,6 +216,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) => {
@@ -222,21 +233,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(),
                 ),
             };
 
@@ -254,6 +260,7 @@ impl ProofBuilder for HeaderChainProofBuilder {
             zkm_public_values,
             zkm_vk_hash,
             zkm_version,
+            self_program_id,
             block_headers,
         };
 
@@ -285,9 +292,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))