fix: use right program id for the saved proof

Author: prajwolrg

Cargo.lock

@@ -152,6 +152,7 @@ borsh = { version = "1.5.0", features = ["derive"] }
 clap = { version = "4.5.20", features = ["cargo", "derive", "env"] }
 corepc-node = { version = "0.10.0", features = ["29_0"] }
 futures = "0.3.31"
+hex = "0.4"
 hex-literal = "1.1"
 jsonrpsee = "0.26.0"
 k256 = "0.13.4"

Cargo.toml

@@ -26,6 +26,7 @@ strata-predicate.workspace = true
 
 anyhow.workspace = true
 clap.workspace = true
+hex.workspace = true
 num-format = "0.4.4"
 reqwest = { version = "0.12.28", default-features = false, features = [
   "blocking",

bin/prover-perf/Cargo.toml

@@ -23,9 +23,9 @@ fn main() -> Result<()> {
 
     if args.generate_proof {
         let sp1_proofs = programs::gen_sp1_proof(&programs);
-        for (program, proof) in programs.iter().zip(sp1_proofs) {
+        for (program, (program_id, proof)) in programs.iter().zip(sp1_proofs) {
             proof
-                .save(program.as_str())
+                .save(format!("{}_{}", program.as_str(), program_id))
                 .unwrap_or_else(|e| panic!("failed to save proof for {}: {e}", program.as_str()));
         }
         return Ok(());

bin/prover-perf/asm-stf_0x00d0c2a2a163035da6766fd1fdb1cd044425e8b26faa69282fc8d8851452e6fc_SP1_v5.0.0.proof.bin

@@ -26,7 +26,7 @@ static ASM_HOST: LazyLock<SP1Host> = LazyLock::new(|| {
 pub(crate) fn create_runtime_input() -> RuntimeInput {
     let step_input = create_asm_step_input();
     let inner_pre_state = create_deterministic_genesis_anchor_state(step_input.block());
-    let moho_pre_state = create_moho_state(&inner_pre_state, asm_predicate_key());
+    let moho_pre_state = create_moho_state(&inner_pre_state, compute_asm_predicate_key());
     RuntimeInput::new(
         moho_pre_state,
         inner_pre_state.as_ssz_bytes(),
@@ -40,12 +40,13 @@ pub(crate) fn gen_perf_report() -> PerformanceReport {
         .expect("failed to generate performance report")
 }
 
-pub(crate) fn gen_proof() -> ProofReceiptWithMetadata {
+pub(crate) fn gen_proof() -> (String, ProofReceiptWithMetadata) {
     let input = create_runtime_input();
-    AsmStfProofProgram::prove(&input, &*ASM_HOST).expect("failed to generate proof")
+    let proof = AsmStfProofProgram::prove(&input, &*ASM_HOST).expect("failed to generate proof");
+    (ASM_HOST.proving_key.vk.bytes32(), proof)
 }
 
-pub(crate) fn asm_predicate_key() -> PredicateKey {
+pub(crate) fn compute_asm_predicate_key() -> PredicateKey {
     let vk = ASM_HOST.proving_key.vk.bytes32_raw();
     compute_sp1_predicate_key(vk)
 }

bin/prover-perf/asm-stf_SP1_v5.0.0.proof.bin

@@ -48,7 +48,7 @@ pub(crate) fn gen_sp1_perf_report(programs: &[GuestProgram]) -> Vec<PerformanceR
 }
 
 /// Runs SP1 programs to generate reports.
-pub(crate) fn gen_sp1_proof(programs: &[GuestProgram]) -> Vec<ProofReceiptWithMetadata> {
+pub(crate) fn gen_sp1_proof(programs: &[GuestProgram]) -> Vec<(String, ProofReceiptWithMetadata)> {
     programs
         .iter()
         .map(|program| match program {

bin/prover-perf/src/main.rs

@@ -22,7 +22,7 @@ use zkaleido::{PerformanceReport, ProofReceiptWithMetadata, ZkVmProgram, ZkVmPro
 use zkaleido_sp1_groth16_verifier::VK_HASH_PREFIX_LENGTH;
 use zkaleido_sp1_host::SP1Host;
 
-use crate::programs::{asm_stf::asm_predicate_key, compute_sp1_predicate_key};
+use crate::programs::asm_stf::compute_sp1_predicate_key;
 
 static MOHO_HOST: LazyLock<SP1Host> = LazyLock::new(|| {
     let elf = fs::read(MOHO_ELF_PATH)
@@ -36,20 +36,46 @@ pub(crate) fn gen_perf_report() -> PerformanceReport {
         .expect("failed to generate performance report")
 }
 
-pub(crate) fn gen_proof() -> ProofReceiptWithMetadata {
+pub(crate) fn gen_proof() -> (String, ProofReceiptWithMetadata) {
     let input = create_moho_recursive_input();
-    MohoRecursiveProgram::prove(&input, &*MOHO_HOST).expect("failed to generate performance report")
+    let proof = MohoRecursiveProgram::prove(&input, &*MOHO_HOST)
+        .expect("failed to generate performance report");
+    (MOHO_HOST.proving_key.vk.bytes32(), proof)
 }
 
-pub(crate) fn moho_predicate_key() -> PredicateKey {
+pub(crate) fn compute_moho_predicate_key() -> PredicateKey {
     let vk = MOHO_HOST.proving_key.vk.bytes32_raw();
     compute_sp1_predicate_key(vk)
 }
 
+pub(crate) fn load_asm_stf_predicate_and_proof() -> (PredicateKey, MohoTransitionWithProof) {
+    const ASM_PROGRAM_ID_STR: &str =
+        "00d0c2a2a163035da6766fd1fdb1cd044425e8b26faa69282fc8d8851452e6fc";
+    let asm_program_id: [u8; 32] = hex::decode(ASM_PROGRAM_ID_STR).unwrap().try_into().unwrap();
+    let asm_predicate = compute_sp1_predicate_key(asm_program_id);
+
+    let proof_path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!(
+        "asm-stf_0x{}_SP1_v5.0.0.proof.bin",
+        ASM_PROGRAM_ID_STR
+    ));
+    let asm_stf_proof = ProofReceiptWithMetadata::load(proof_path).expect("failed to open proof");
+    let proven_moho_transition =
+        MohoStateTransition::from_ssz_bytes(asm_stf_proof.receipt().public_values().as_bytes())
+            .unwrap();
+
+    let proof = &asm_stf_proof.receipt().proof().as_bytes()[VK_HASH_PREFIX_LENGTH..];
+    let incremental_step_proof =
+        MohoTransitionWithProof::new(proven_moho_transition, proof.to_vec());
+
+    (asm_predicate, incremental_step_proof)
+}
+
 pub(crate) fn create_moho_recursive_input() -> MohoRecursiveInput {
     let input = create_asm_step_input();
     let asm_pre_state = create_deterministic_genesis_anchor_state(input.block());
-    let moho_pre_state = create_moho_state(&asm_pre_state, asm_predicate_key());
+    let (asm_predicate, incremental_step_proof) = load_asm_stf_predicate_and_proof();
+
+    let moho_pre_state = create_moho_state(&asm_pre_state, asm_predicate);
 
     let moho_pre_state_ref = StateRefAttestation::new(
         AsmStfProgram::extract_prev_reference(&input),
@@ -66,7 +92,7 @@ pub(crate) fn create_moho_recursive_input() -> MohoRecursiveInput {
     .unwrap()
     .state;
 
-    let moho_post_state = create_moho_state(&asm_post_state, asm_predicate_key());
+    let moho_post_state = create_moho_state(&asm_post_state, asm_predicate);
 
     let moho_post_state_ref = StateRefAttestation::new(
         AsmStfProgram::compute_input_reference(&input),
@@ -76,24 +102,18 @@ pub(crate) fn create_moho_recursive_input() -> MohoRecursiveInput {
     let expected_moho_transition =
         MohoStateTransition::new(moho_pre_state_ref, moho_post_state_ref);
 
-    let proof_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("asm-stf_SP1_v5.0.0.proof.bin");
-    let asm_stf_proof = ProofReceiptWithMetadata::load(proof_path).expect("failed to open proof");
-    let proven_moho_transition =
-        MohoStateTransition::from_ssz_bytes(asm_stf_proof.receipt().public_values().as_bytes())
-            .unwrap();
-    assert_eq!(expected_moho_transition, proven_moho_transition);
-
-    let proof = &asm_stf_proof.receipt().proof().as_bytes()[VK_HASH_PREFIX_LENGTH..];
-    let incremental_step_proof =
-        MohoTransitionWithProof::new(expected_moho_transition, proof.to_vec());
+    assert_eq!(
+        &expected_moho_transition,
+        incremental_step_proof.transition()
+    );
 
     let step_predicate_merkle_proof = create_predicate_inclusion_proof(&moho_pre_state);
 
     MohoRecursiveInput::new(
-        moho_predicate_key(),
+        compute_moho_predicate_key(),
         None,
         incremental_step_proof,
-        asm_predicate_key(),
+        asm_predicate,
         step_predicate_merkle_proof,
     )
 }