add batch kzg hint for peformance

crates/circuits/batch-circuit/batch_exe_commit.rs

@@ -1,4 +1,4 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 //! Generated by crates/build-guest. DO NOT EDIT!
 
-pub const COMMIT: [u32; 8] = [1977200712, 164000656, 1913155134, 1077030025, 605628646, 1253556162, 226927146, 637945472];
+pub const COMMIT: [u32; 8] = [657967860, 338391579, 1087457998, 461028412, 1974237338, 1280854135, 1944171188, 1779194533];

crates/circuits/bundle-circuit/bundle_exe_commit.rs

@@ -1,4 +1,4 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 //! Generated by crates/build-guest. DO NOT EDIT!
 
-pub const COMMIT: [u32; 8] = [1734773866, 471206981, 1116518272, 39106946, 1768537985, 1996057545, 820597863, 537872345];
+pub const COMMIT: [u32; 8] = [690310147, 1276634450, 1753208105, 1937432774, 721614211, 1763047938, 931414536, 1790218801];

crates/circuits/chunk-circuit/Cargo.toml

@@ -9,7 +9,6 @@ version = "0.6.0"
 bincode = { workspace = true }
 scroll-zkvm-types-circuit = { workspace = true }
 scroll-zkvm-types-chunk = { workspace = true }
-sbv-precompile = { workspace = true } 
 
 openvm = { workspace = true, features = ["std", "getrandom-unsupported"] }
 openvm-k256 = { workspace = true }
@@ -25,4 +24,4 @@ openvm-rv32im-guest= {  workspace = true }
 
 [features]
 default = ["openvm"]
-openvm = ["scroll-zkvm-types-chunk/openvm", "sbv-precompile/scroll-openvm"]
+openvm = ["scroll-zkvm-types-chunk/openvm"]

crates/circuits/chunk-circuit/chunk_exe_commit.rs

@@ -1,4 +1,4 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 //! Generated by crates/build-guest. DO NOT EDIT!
 
-pub const COMMIT: [u32; 8] = [1954389790, 1028875012, 1445798022, 1249823514, 895192610, 683282762, 201633599, 421015397];
+pub const COMMIT: [u32; 8] = [1966441800, 1340831655, 1437864809, 102476650, 1754583969, 453658462, 396733580, 912949452];

crates/integration/Cargo.toml

@@ -31,6 +31,7 @@ clap.workspace = true
 eyre.workspace = true
 rayon.workspace = true
 serde.workspace = true
+toml.workspace = true
 vm-zstd = { workspace = true, features = ["zstd"] }
 
 hex.workspace = true

crates/integration/src/testers/batch.rs

@@ -1,6 +1,6 @@
 use scroll_zkvm_prover::Prover;
 use scroll_zkvm_types::{
-    batch::{BatchHeader, BatchInfo, BatchWitness, ReferenceHeader},
+    batch::{BatchHeader, BatchInfo, BatchWitness, BatchWitnessLegacy, ReferenceHeader},
     chunk::ChunkInfo,
     proof::ProofEnum,
     public_inputs::ForkName,
@@ -24,7 +24,10 @@ impl PartialProvingTask for BatchWitness {
     }
 
     fn legacy_rkyv_archive(&self) -> eyre::Result<Vec<u8>> {
-        Ok(rkyv::to_bytes::<rkyv::rancor::Error>(self)?.to_vec())
+        Ok(
+            rkyv::to_bytes::<rkyv::rancor::Error>(&BatchWitnessLegacy::from(self.clone()))?
+                .to_vec(),
+        )
     }
 
     fn fork_name(&self) -> ForkName {
@@ -51,7 +54,7 @@ pub struct BatchTaskGenerator {
     witness: Option<BatchWitness>,
     chunk_generators: Vec<ChunkTaskGenerator>,
     last_witness: Option<BatchWitness>,
-    proof: Option<ProofEnum>,
+    pub proof: Option<ProofEnum>,
 }
 
 impl BatchTaskGenerator {
@@ -87,6 +90,7 @@ impl BatchTaskGenerator {
             let proof = chunk_gen.get_or_build_proof(child_prover)?;
             proofs.push(proof);
         }
+        child_prover.reset();
         Ok(proofs)
     }
 

crates/integration/src/testers/chunk.rs

@@ -158,7 +158,7 @@ pub fn preset_chunk() -> ChunkTaskGenerator {
     let block_range = match testing_hardfork() {
         ForkName::EuclidV1 => 12508460u64..=12508463u64,
         ForkName::EuclidV2 => 1u64..=4u64,
-        ForkName::Feynman => 16525000u64..=16525003u64,
+        ForkName::Feynman => 16525000u64..=16525019u64,
     };
 
     ChunkTaskGenerator {

crates/integration/src/utils/mod.rs

@@ -6,8 +6,8 @@ use sbv_primitives::{
 };
 use scroll_zkvm_types::{
     batch::{
-        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchInfo, BatchWitness, PointEvalWitness,
-        ReferenceHeader,
+        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchInfo, BatchWitness, Bytes48,
+        PointEvalWitness, PointEvalWitnessHints, ReferenceHeader,
     },
     bundle::{BundleInfo, BundleWitness},
     chunk::{ChunkInfo, ChunkWitness},
@@ -206,7 +206,7 @@ pub fn build_batch_witnesses(
     let kzg_commitment = point_eval::blob_to_kzg_commitment(&kzg_blob);
     let blob_versioned_hash = point_eval::get_versioned_hash(&kzg_commitment);
 
-    // primage = keccak(payload) + blob_versioned_hash
+    // preimage = keccak(payload) + blob_versioned_hash
     let challenge_preimage = if testing_hardfork() >= ForkName::EuclidV2 {
         let mut challenge_preimage = keccak256(&blob_bytes).to_vec();
         challenge_preimage.extend(blob_versioned_hash.0);
@@ -314,19 +314,58 @@ pub fn build_batch_witnesses(
         })
         .collect::<Vec<_>>();
 
+    let (point_eval_witness, point_eval_witness_hints) = build_point_eval_witness(
+        *kzg_commitment.to_bytes().as_ref(),
+        *kzg_proof.to_bytes().as_ref(),
+    );
     Ok(BatchWitness {
         chunk_proofs,
         chunk_infos,
         reference_header,
         blob_bytes,
-        point_eval_witness: PointEvalWitness {
-            kzg_commitment: *kzg_commitment.to_bytes().as_ref(),
-            kzg_proof: *kzg_proof.to_bytes().as_ref(),
-        },
+        point_eval_witness,
+        point_eval_witness_hints,
         fork_name,
     })
 }
 
+// TODO: move it to some correct place
+
+fn build_point_eval_witness(
+    kzg_commitment: Bytes48,
+    kzg_proof: Bytes48,
+) -> (PointEvalWitness, PointEvalWitnessHints) {
+    use snark_verifier_sdk::snark_verifier::halo2_base::halo2_proofs::halo2curves::bls12_381;
+    let commitment_point = bls12_381::G1Affine::from_compressed_be(&kzg_commitment).unwrap();
+    let mut kzg_commitment_hint_x = [0u8; 48];
+    let mut kzg_commitment_hint_y = [0u8; 48];
+    kzg_commitment_hint_x.copy_from_slice(&commitment_point.x.to_bytes_be());
+    kzg_commitment_hint_y.copy_from_slice(&commitment_point.y.to_bytes_be());
+    //[commitment_point_i.x().to_be_bytes(), commitment_point_i.y().to_be_bytes()].concat().try_into().unwrap();
+    //let commitment_point_i: G1Affine = commitment_point.convert();
+    //assert_eq!(kzg_commitment_hint.to_vec(), [commitment_point_i.x().to_be_bytes(), commitment_point_i.y().to_be_bytes()].concat());
+    println!("commitment encoded {:?}", kzg_commitment);
+    println!("commitment raw x {:?}", commitment_point.x.to_bytes_be());
+
+    let proof_point = bls12_381::G1Affine::from_compressed_be(&kzg_proof).unwrap();
+    let mut kzg_proof_hint_x = [0u8; 48];
+    let mut kzg_proof_hint_y = [0u8; 48];
+    kzg_proof_hint_x.copy_from_slice(&proof_point.x.to_bytes_be());
+    kzg_proof_hint_y.copy_from_slice(&proof_point.y.to_bytes_be());
+    (
+        PointEvalWitness {
+            kzg_commitment,
+            kzg_proof,
+        },
+        PointEvalWitnessHints {
+            kzg_commitment_hint_x,
+            kzg_commitment_hint_y,
+            kzg_proof_hint_x,
+            kzg_proof_hint_y,
+        },
+    )
+}
+
 #[test]
 fn test_build_and_parse_batch_task() -> eyre::Result<()> {
     use crate::testers::chunk::ChunkTaskGenerator;

crates/prover/src/prover/mod.rs

@@ -1,5 +1,6 @@
 use std::{
     path::PathBuf,
+    str::FromStr,
     sync::{Arc, OnceLock},
 };
 
@@ -22,7 +23,6 @@ use crate::setup::read_app_exe;
 use crate::{Error, setup::read_app_config, task::ProvingTask};
 
 use scroll_zkvm_types::proof::{EvmProof, ProofEnum, StarkProof, StarkProofStat};
-
 /// Generic prover.
 pub struct Prover {
     /// Prover name
@@ -101,6 +101,7 @@ impl Prover {
         }
         Ok(self.prover.get_mut().unwrap())
     }
+
     /// Pick up loaded app commit, to distinguish from which circuit the proof comes
     pub fn get_app_commitment(&mut self) -> ProgramCommitment {
         let prover = self.get_prover_mut().expect("Failed to initialize prover");
@@ -180,12 +181,40 @@ impl Prover {
             .map(|res| res.total_cycle)
     }
 
+    /*
+
+    */
     /// Generate a [root proof][root_proof].
     ///
     /// [root_proof][openvm_sdk::verifier::root::types::RootVmVerifierInput]
     pub fn gen_proof_stark(&mut self, stdin: StdIn) -> Result<StarkProof, Error> {
         // Here we always do an execution of the guest program to get the cycle count.
         // and do precheck before proving like ensure PI != 0
+        if true {
+            // dump stdin to file
+            let mut json: serde_json::Value = serde_json::from_str("{\"input\":[]}").unwrap();
+            let json_input = json["input"].as_array_mut().unwrap();
+            for item in &stdin.buffer {
+                use openvm_stark_sdk::openvm_stark_backend::p3_field::PrimeField32;
+                let mut bytes: Vec<u8> = vec![0x02];
+                for f in item {
+                    let u32_bytes = f.as_canonical_u32().to_le_bytes();
+                    bytes.extend_from_slice(&u32_bytes);
+                }
+                json_input.push(serde_json::Value::String(format!(
+                    "0x{}",
+                    hex::encode(bytes)
+                )));
+            }
+            // write the `json` to ${self.name}.json
+            let filename = format!("{}.json", self.prover_name);
+            if let Err(e) = std::fs::write(&filename, serde_json::to_string_pretty(&json).unwrap())
+            {
+                tracing::warn!("Failed to write stdin to {}: {}", filename, e);
+            } else {
+                tracing::info!("Wrote stdin to {}", filename);
+            }
+        }
         let t = std::time::Instant::now();
         let total_cycles = self.execute_and_check(&stdin)?;
         let execution_time_mills = t.elapsed().as_millis() as u64;

crates/types/base/src/public_inputs/chunk.rs

@@ -127,6 +127,33 @@ pub struct ChunkInfo {
     #[rkyv()]
     pub block_ctxs: Vec<BlockContextV2>,
 }
+impl std::fmt::Display for ChunkInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // Create a wrapper struct that implements Debug
+        struct DisplayWrapper<'a>(&'a ChunkInfo);
+
+        impl<'a> std::fmt::Debug for DisplayWrapper<'a> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                f.debug_struct("ChunkInfo")
+                    .field("chain_id", &self.0.chain_id)
+                    .field("prev_state_root", &self.0.prev_state_root)
+                    .field("post_state_root", &self.0.post_state_root)
+                    .field("withdraw_root", &self.0.withdraw_root)
+                    .field("data_hash", &self.0.data_hash)
+                    .field("tx_data_digest", &self.0.tx_data_digest)
+                    .field("prev_msg_queue_hash", &self.0.prev_msg_queue_hash)
+                    .field("post_msg_queue_hash", &self.0.post_msg_queue_hash)
+                    .field("tx_data_length", &self.0.tx_data_length)
+                    .field("initial_block_number", &self.0.initial_block_number)
+                    .field("block_ctxs", &"<omitted>")
+                    .finish()
+            }
+        }
+
+        // Use the Debug implementation with pretty formatting
+        write!(f, "{:#?}", DisplayWrapper(self))
+    }
+}
 
 impl ChunkInfo {
     /// Public input hash for a given chunk (euclidv1 or da-codec@v6) is defined as

crates/types/batch/Cargo.toml

@@ -9,19 +9,18 @@ version.workspace = true
 
 [dependencies]
 alloy-primitives = { workspace = true }
-bincode = { workspace = true }
 rkyv.workspace = true
 serde.workspace = true
 itertools.workspace = true
 vm-zstd = { workspace = true }
 
 types-base = { path = "../base", package = "scroll-zkvm-types-base" }
 openvm = { workspace = true, features = ["std"] }
+openvm-algebra-guest = { workspace = true }
 openvm-ecc-guest = { workspace = true, features = ["halo2curves"] }
 openvm-pairing-guest = { workspace = true, features = ["halo2curves"] }
 openvm-pairing = { workspace = true, features = ["bls12_381", "halo2curves"] }
 openvm-sha2.workspace = true
-openvm-sha256-guest.workspace = true
 halo2curves-axiom = "0.7.0"
 
 [features]

crates/types/batch/src/blob_consistency/mod.rs

@@ -4,9 +4,11 @@ use openvm_pairing::bls12_381::Scalar;
 
 mod constants;
 mod openvm;
+mod types;
 pub use openvm::point_evaluation;
+pub use types::{ToIntrinsic, from_intrinsic_g1};
 
-pub use openvm::{ToIntrinsic, kzg_to_versioned_hash, verify_kzg_proof};
+pub use openvm::{kzg_to_versioned_hash, verify_kzg_proof};
 
 // Number of bytes in a u256.
 pub const N_BYTES_U256: usize = 32;