Fix/flounder audit circuit

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

@@ -205,9 +205,8 @@ 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),
+                        CommitChainPrevProofType::PrevProof,
                         proof_bytes,
                         public_inputs,
                         zkm_vk_hash.to_vec(),
@@ -263,10 +262,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/header-chain-proof/host/src/lib.rs

@@ -219,9 +219,8 @@ 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),
+                        HeaderChainPrevProofType::PrevProof,
                         proof_bytes,
                         public_inputs,
                         zkm_vk_hash.to_vec(),
@@ -282,9 +281,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/state-chain-proof/host/src/lib.rs

@@ -335,10 +335,8 @@ impl ProofBuilder for StateChainProofBuilder {
                                 format!("invalid UTF-8 in zkm_version file '{version_path}'")
                             })
                         })?;
-                    let prev_output: StateChainCircuitOutput =
-                        zkm_sdk::ZKMPublicValues::from(&public_inputs).read();
                     (
-                        StateChainPrevProofType::PrevProof(prev_output),
+                        StateChainPrevProofType::PrevProof,
                         proof_bytes,
                         public_inputs,
                         zkm_vk_hash.to_vec(),
@@ -389,9 +387,10 @@ impl ProofBuilder for StateChainProofBuilder {
             },
         )?;
         tracing::info!("State 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 state chain proof")?;
 
         let input = bincode::serialize(&input)?;
         Ok((input, proof, cycles, proving_time))

circuits/watchtower-proof/guest/src/main.rs

@@ -8,15 +8,13 @@ use state_chain::StateChainCircuitInput;
 
 pub fn main() {
     let genesis_sequencer_commit_txid = zkm_zkvm::io::read::<[u8; 32]>();
-    let latest_sequencer_commit_txid = zkm_zkvm::io::read::<[u8; 32]>();
     let header_chain: HeaderChainCircuitInput = zkm_zkvm::io::read(); // private inputs
     let commit_chain: CommitChainCircuitInput = zkm_zkvm::io::read();
     let state_chain: StateChainCircuitInput = zkm_zkvm::io::read();
     let spv: SPV = zkm_zkvm::io::read();
 
     let (total_work, btc_best_block_height) = bitcoin_light_client_circuit::watch_longest_chain(
         genesis_sequencer_commit_txid,
-        latest_sequencer_commit_txid,
         header_chain,
         commit_chain,
         state_chain,

circuits/watchtower-proof/host/src/lib.rs

@@ -121,7 +121,6 @@ impl ProofBuilder for WatchtowerProofBuilder {
             header_chain_input_proof,
             commit_chain_input_proof,
             state_chain_input_proof,
-            latest_sequencer_commit_txid,
             genesis_sequencer_commit_txid,
             target_block,
             block_pos,
@@ -215,7 +214,6 @@ impl ProofBuilder for WatchtowerProofBuilder {
         };
         // --- spv --- //
         let genesis_sequencer_commit_txid = Txid::from_str(&genesis_sequencer_commit_txid)?;
-        let latest_sequencer_commit_txid = Txid::from_str(&latest_sequencer_commit_txid)?;
         let bitcoin_block_headers = {
             let headers: Vec<u8> = std::fs::read(&format!("{header_chain_input_proof}.blocks"))?;
             headers
@@ -247,7 +245,6 @@ impl ProofBuilder for WatchtowerProofBuilder {
             || -> anyhow::Result<(ZKMProofWithPublicValues, u64, f32)> {
                 let mut stdin = ZKMStdin::new();
                 stdin.write(&genesis_sequencer_commit_txid.to_byte_array());
-                stdin.write(&latest_sequencer_commit_txid.to_byte_array());
                 stdin.write(&header_chain_input);
                 stdin.write(&commit_chain_input);
                 stdin.write(&state_chain_input);

crates/bitcoin-light-client-circuit/src/lib.rs

@@ -2,25 +2,24 @@ mod signature;
 mod utils;
 use alloy_primitives::U32;
 pub use signature::*;
-use state_chain::verify_sequencer_commit;
 pub use utils::*;
 
 use alloy_primitives::U256;
 use bitcoin::Block;
 use bitcoin::hashes::{Hash, HashEngine, sha256};
 use commit_chain::{
-    CommitChainCircuitInput, CommitChainPrevProofType, decode_commit_chain_circuit_output,
+    CommitChainCircuitInput, decode_commit_chain_circuit_output,
     extract_data_from_commitment_outputs, parse_commit_chain_commitment, sequencer_hash,
 };
 use header_chain::{
-    BitcoinMerkleTree, CircuitBlockHeader, CircuitTransaction, HeaderChainCircuitInput,
-    HeaderChainPrevProofType, MMRHost, SPV, verify_merkle_proof,
+    BitcoinMerkleTree, BlockHeaderCircuitOutput, CircuitBlockHeader, CircuitTransaction,
+    HeaderChainCircuitInput, MMRHost, SPV, verify_merkle_proof,
 };
-use state_chain::{StateChainCircuitInput, StateChainPrevProofType};
+use state_chain::{StateChainCircuitInput, StateChainCircuitOutput, verify_sequencer_commit};
 use zkm_primitives::io::ZKMPublicValues;
 
 use bitcoin::{
-    ScriptBuf, Transaction, TxOut, Txid,
+    ScriptBuf, Transaction, TxOut,
     secp256k1::{PublicKey, XOnlyPublicKey},
 };
 pub use guest_executor::io::EthClientExecutorInput;
@@ -64,7 +63,6 @@ pub fn decode_operator_public_outputs(
 
 pub fn watch_longest_chain(
     genesis_sequencer_commit_txid: [u8; 32],
-    latest_sequencer_commit_txid: [u8; 32],
     header_chain: HeaderChainCircuitInput,
     commit_chain: CommitChainCircuitInput,
     state_chain: StateChainCircuitInput,
@@ -83,15 +81,10 @@ pub fn watch_longest_chain(
     )
     .expect("Failed to verify commit chain proof");
 
-    let prev_output = decode_commit_chain_circuit_output(&commit_chain.zkm_public_values);
-    let prev_proof = CommitChainPrevProofType::PrevProof(prev_output);
-    let CommitChainPrevProofType::PrevProof(commit_chain_output) = &prev_proof else {
-        panic!("Only PrevProof is supported in watch_longest_chain");
-    };
-
+    let commit_chain_output = decode_commit_chain_circuit_output(&commit_chain.zkm_public_values);
     assert_eq!(
         commit_chain_output.chain_state.commit_txn.compute_txid(),
-        Txid::from_byte_array(latest_sequencer_commit_txid)
+        spv.transaction.0.compute_txid()
     );
     assert_eq!(genesis_sequencer_commit_txid, commit_chain_output.chain_state.genesis_txid);
 
@@ -105,11 +98,8 @@ pub fn watch_longest_chain(
     )
     .expect("Failed to verify header chain proof");
 
-    let prev_output = ZKMPublicValues::from(&header_chain.zkm_public_values).read();
-    let prev_proof = HeaderChainPrevProofType::PrevProof(prev_output);
-    let HeaderChainPrevProofType::PrevProof(btc_header_chain_output) = &prev_proof else {
-        panic!("Only PrevProof is supported in watch_longest_chain");
-    };
+    let btc_header_chain_output: BlockHeaderCircuitOutput =
+        ZKMPublicValues::from(&header_chain.zkm_public_values).read();
     // verify that the latest_sequecner_commit_tx is in the header chain
     println!("SPV");
     assert!(spv.verify(&btc_header_chain_output.chain_state.block_hashes_mmr));
@@ -121,11 +111,8 @@ pub fn watch_longest_chain(
         &state_chain.zkm_version,
     )
     .expect("Failed to verify state chain proof");
-    let prev_output = ZKMPublicValues::from(&state_chain.zkm_public_values).read();
-    let prev_proof = StateChainPrevProofType::PrevProof(prev_output);
-    let StateChainPrevProofType::PrevProof(state_chain_output) = &prev_proof else {
-        panic!("Only PrevProof is supported in watch_longest_chain");
-    };
+    let state_chain_output: StateChainCircuitOutput =
+        ZKMPublicValues::from(&state_chain.zkm_public_values).read();
     // check the signature.
     let cosmos_block_bytes = &state_chain_output.chain_state.latest_cosmos_block;
     let cosmos_block: LightBlock =
@@ -255,11 +242,7 @@ pub fn propose_longest_chain(
         &commit_chain.zkm_version,
     )
     .expect("Failed to verify commit chain proof");
-    let prev_output = decode_commit_chain_circuit_output(&commit_chain.zkm_public_values);
-    let prev_proof = CommitChainPrevProofType::PrevProof(prev_output);
-    let CommitChainPrevProofType::PrevProof(commit_chain_output) = &prev_proof else {
-        panic!("Only PrevProof is supported in propose_longest_chain");
-    };
+    let commit_chain_output = decode_commit_chain_circuit_output(&commit_chain.zkm_public_values);
     assert_eq!(
         commit_chain_output.chain_state.commit_txn.compute_txid(),
         spv_ss_commit.transaction.0.compute_txid()
@@ -278,11 +261,8 @@ pub fn propose_longest_chain(
         &operator_header_chain.zkm_version,
     )
     .expect("Failed to verify header chain proof");
-    let prev_output = ZKMPublicValues::from(&operator_header_chain.zkm_public_values).read();
-    let prev_proof = HeaderChainPrevProofType::PrevProof(prev_output);
-    let HeaderChainPrevProofType::PrevProof(btc_header_chain_output) = &prev_proof else {
-        panic!("Only PrevProof is supported in propose_longest_chain");
-    };
+    let btc_header_chain_output: BlockHeaderCircuitOutput =
+        ZKMPublicValues::from(&operator_header_chain.zkm_public_values).read();
     let operator_total_work = btc_header_chain_output.chain_state.total_work;
     let operator_consensus_block_height = U32::from(commit_chain_output.chain_state.block_height);
     // commit header chain best block hash as pis
@@ -429,11 +409,9 @@ pub fn propose_longest_chain(
     )
     .expect("Failed to verify state chain proof");
 
-    let prev_output = ZKMPublicValues::from(&state_chain.zkm_public_values).read();
-    let prev_proof = StateChainPrevProofType::PrevProof(prev_output);
-    let StateChainPrevProofType::PrevProof(state_chain_output) = &prev_proof else {
-        panic!("Only PrevProof is supported in propose_longest_chain");
-    };
+    let state_chain_output: StateChainCircuitOutput =
+        ZKMPublicValues::from(&state_chain.zkm_public_values).read();
+
     // check the signature.
     let cosmos_block_bytes = &state_chain_output.chain_state.latest_cosmos_block;
     let cosmos_block: LightBlock =

crates/commit-chain/src/commit_chain.rs

@@ -29,7 +29,7 @@ pub struct CommitInfo {
 #[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
 pub enum CommitChainPrevProofType {
     GenesisBlock,
-    PrevProof(CommitChainCircuitOutput),
+    PrevProof,
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]

crates/commit-chain/src/lib.rs

@@ -8,7 +8,7 @@ pub fn commit_chain_circuit(input: CommitChainCircuitInput) -> CommitChainCircui
         CommitChainPrevProofType::GenesisBlock => {
             CommitChainState::new(input.commits[0].genesis_txid)
         }
-        CommitChainPrevProofType::PrevProof(prev_proof) => {
+        CommitChainPrevProofType::PrevProof => {
             println!("verify commit chain of prev proof");
             verifier::verify_groth16_proof(
                 &input.zkm_proof,
@@ -18,8 +18,7 @@ pub fn commit_chain_circuit(input: CommitChainCircuitInput) -> CommitChainCircui
             )
             .unwrap();
 
-            // todo: read from input.zkm_public_values
-            prev_proof.chain_state
+            decode_commit_chain_circuit_output(&input.zkm_public_values).chain_state
         }
     };
 

crates/header-chain/Cargo.toml

@@ -12,6 +12,7 @@ serde = { workspace = true, default-features = false }
 crypto-bigint = { version = "0.5.5", default-features = false }
 zkm-zkvm = { workspace = true }
 verifier = { workspace = true }
+zkm-primitives = { workspace = true }
 
 [dev-dependencies]
 hex-literal = "1.0.0"

crates/header-chain/src/header_chain.rs

@@ -370,7 +370,7 @@ pub struct BlockHeaderCircuitOutput {
 #[derive(Serialize, Deserialize, Eq, PartialEq, Clone, Debug, BorshDeserialize, BorshSerialize)]
 pub enum HeaderChainPrevProofType {
     GenesisBlock,
-    PrevProof(BlockHeaderCircuitOutput),
+    PrevProof,
 }
 
 /// The input of the header chain circuit.

crates/header-chain/src/lib.rs

@@ -10,6 +10,8 @@ pub use merkle_tree::*;
 pub use mmr::*;
 pub use transaction::*;
 
+use zkm_primitives::io::ZKMPublicValues;
+
 pub mod spv;
 pub use spv::SPV;
 
@@ -19,7 +21,7 @@ pub fn header_chain_circuit(input: HeaderChainCircuitInput) -> BlockHeaderCircui
     // println!("NETWORK_CONSTANTS: {:?}", NETWORK_CONSTANTS);
     let mut chain_state = match input.prev_proof {
         HeaderChainPrevProofType::GenesisBlock => ChainState::new(),
-        HeaderChainPrevProofType::PrevProof(prev_proof) => {
+        HeaderChainPrevProofType::PrevProof => {
             println!("verify header chain of prev proof");
             verifier::verify_groth16_proof(
                 &input.zkm_proof,
@@ -29,7 +31,9 @@ pub fn header_chain_circuit(input: HeaderChainCircuitInput) -> BlockHeaderCircui
             )
             .unwrap();
 
-            prev_proof.chain_state
+            let btc_header_chain_output: BlockHeaderCircuitOutput =
+                ZKMPublicValues::from(&input.zkm_public_values).read();
+            btc_header_chain_output.chain_state
         }
     };
 

crates/state-chain/Cargo.toml

@@ -15,6 +15,7 @@ header-chain = { path = "../header-chain" }
 # Ziren
 verifier = { workspace = true }
 zkm-zkvm = { workspace = true }
+zkm-primitives = { workspace = true }
 #zkm-verifier = { path = "../../../Ziren/crates/verifier" }
 #zkm-zkvm = { path = "../../../Ziren/crates/zkvm/entrypoint", features = ["verify"] }