integration tests for chunk

Author: noel2004

common/libzkp/integration_test/src/lib.rs

@@ -1,20 +1,18 @@
-use std::path::{Path, PathBuf};
-use scroll_zkvm_prover_euclid::{
-    ProverConfig, Prover, ProverType,
-};
-use scroll_zkvm_types::task::ProvingTask;
 use libzkp::{
-    TaskType,
+    proofs::{PersistableProof, ProofMetadata, WrappedProof},
     tasks::ChunkInterpreter,
-    proofs::{WrappedProof, ProofMetadata, PersistableProof},
+    TaskType,
 };
+use scroll_zkvm_prover_euclid::{Prover, ProverConfig, ProverType};
+use scroll_zkvm_types::task::ProvingTask;
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
 use tracing::instrument;
 use tracing_subscriber::{fmt::format::FmtSpan, layer::SubscriberExt, util::SubscriberInitExt};
-use std::sync::OnceLock;
-use serde::{Deserialize, Serialize};
 
 struct DummyInterpreter {}
-impl ChunkInterpreter for DummyInterpreter{}
+impl ChunkInterpreter for DummyInterpreter {}
 
 pub mod specs;
 // pub mod testers;
@@ -41,7 +39,6 @@ const TEST_PHASE: &str = "euclidv2";
 
 static LOGGER_INIT: OnceLock<eyre::Result<()>> = OnceLock::new();
 
-
 /// Every test run will write assets to a new directory.
 ///
 /// Possibly one of the following:
@@ -56,7 +53,6 @@ pub struct ProverTester {
 }
 
 impl ProverTester {
-
     /// Setup test environment
     fn setup_logger() -> eyre::Result<()> {
         let fmt_layer = tracing_subscriber::fmt::layer()
@@ -89,7 +85,7 @@ impl ProverTester {
 
     /// Setup directory structure for the test suite.
     pub fn setup(spec: &str) -> eyre::Result<Self> {
-        if let Err(e) = LOGGER_INIT.get_or_init(||Self::setup_logger()){
+        if let Err(e) = LOGGER_INIT.get_or_init(Self::setup_logger) {
             eyre::bail!("logger init fail: {e}");
         }
         let manifest_dir_str = std::env::var("CARGO_MANIFEST_DIR")?;
@@ -115,7 +111,7 @@ impl ProverTester {
         // TODO: enable setting from env
         let dir_workspace = manifest_dir.join("../../../zkvm-prover/.work");
 
-        Ok(ProverTester{
+        Ok(ProverTester {
             dir_testrun,
             dir_workspace,
             dir_testdata: manifest_dir.join("testdata"),
@@ -146,11 +142,35 @@ impl ProverTester {
         })
     }
 
+    /// Simple test for executing task
+    #[instrument(name = "execute_single", skip_all)]
+    pub fn execute_single<Spec: ProvingTestSpec>(
+        &self,
+        task: Spec::ProvingTaskType,
+    ) -> eyre::Result<u64> {
+        use scroll_zkvm_prover_euclid::task::ProvingTask as ProvingTaskT;
+
+        let cfg = self.config(&Spec::PHASE_SPEC.to_string())?;
+        let prover = Prover::<Spec::ProverType>::setup(cfg)?;
+
+        let (_, _, utask_json) = libzkp::gen_universal_task(
+            Spec::PHASE_SPEC as i32,
+            &serde_json::to_string(&task)?,
+            TEST_PHASE,
+            None::<DummyInterpreter>,
+        )?;
+
+        let u_task: ProvingTask = serde_json::from_str(&utask_json)?;
+        let stdin = u_task.build_guest_input()?;
+
+        let cycles = prover.execute_and_check(&stdin, true)?;
+        Ok(cycles)
+    }
 
     /// File descriptor for the proof saved to disc.
     #[instrument("fd_proof", skip_all, fields(task_id = task.identifier, path_proof))]
     fn fd_proof<Spec: ProvingTestSpec>(task: &ProvingTask) -> String {
-        let path_proof = format!("{}-{}.json", Spec::PHASE_SPEC.to_string(), task.identifier);
+        let path_proof = format!("{}-{}.json", Spec::PHASE_SPEC, task.identifier);
         path_proof
     }
 
@@ -163,21 +183,27 @@ impl ProverTester {
     ) -> eyre::Result<WrappedProof<Spec::MetadataType>>
     where
         WrappedProof<Spec::MetadataType>: for<'de> Deserialize<'de>,
-    {        
+    {
         let (_, metadata_json, utask_json) = libzkp::gen_universal_task(
-            Spec::PHASE_SPEC as i32, 
-            &serde_json::to_string(&task)?, 
-            TEST_PHASE, 
+            Spec::PHASE_SPEC as i32,
+            &serde_json::to_string(&task)?,
+            TEST_PHASE,
             None::<DummyInterpreter>,
         )?;
 
-        let u_task : ProvingTask = serde_json::from_str(&utask_json)?;
+        let u_task: ProvingTask = serde_json::from_str(&utask_json)?;
 
         // Try reading proof from cache if available, and early return in that case.
-        let path_proof = prover.cache_dir.as_ref().expect("set in config").join(Self::fd_proof::<Spec>(&u_task));
+        let path_proof = prover
+            .cache_dir
+            .as_ref()
+            .expect("set in config")
+            .join(Self::fd_proof::<Spec>(&u_task));
         tracing::debug!(name: "try_read_proof", ?path_proof);
 
-        if let Ok(proof) = <WrappedProof<Spec::MetadataType> as PersistableProof>::from_json(&path_proof){
+        if let Ok(proof) =
+            <WrappedProof<Spec::MetadataType> as PersistableProof>::from_json(&path_proof)
+        {
             tracing::info!(name: "early_return_proof", ?path_proof);
             return Ok(proof);
         }
@@ -186,13 +212,11 @@ impl ProverTester {
         let proof = prover.gen_proof_universal(&u_task, with_snark)?;
         let vk = prover.get_app_vk();
 
-        let wrapped_proof_json = libzkp::gen_wrapped_proof(
-            &serde_json::to_string(&proof)?,
-            &metadata_json,
-            &vk,
-        )?;
+        let wrapped_proof_json =
+            libzkp::gen_wrapped_proof(&serde_json::to_string(&proof)?, &metadata_json, &vk)?;
 
-        let wrapped_proof : WrappedProof<Spec::MetadataType> = serde_json::from_str(&wrapped_proof_json)?;
+        let wrapped_proof: WrappedProof<Spec::MetadataType> =
+            serde_json::from_str(&wrapped_proof_json)?;
 
         // dump proof
         tracing::debug!(name: "try_write_proof", ?path_proof);
@@ -202,7 +226,7 @@ impl ProverTester {
     }
 
     /// Dump verifier staff to disk
-    pub fn dump_verifier_staff<P: ProverType>(&self, spec: &str) -> eyre::Result<()>{
+    pub fn dump_verifier_staff<P: ProverType>(&self, spec: &str) -> eyre::Result<()> {
         let cfg = self.config(spec)?;
         let prover = Prover::<P>::setup(cfg)?;
         prover.dump_universal_verifier(Some(self.dir_testrun.clone()))?;
@@ -213,7 +237,7 @@ impl ProverTester {
     /// End-to-end test for one or more proving tasks.
     pub fn prove_verify<Spec: ProvingTestSpec>(
         &self,
-        tasks: impl Iterator<Item = Spec::ProvingTaskType>,
+        tasks: impl IntoIterator<Item = Spec::ProvingTaskType>,
     ) -> eyre::Result<Vec<WrappedProof<Spec::MetadataType>>>
     where
         WrappedProof<Spec::MetadataType>: for<'de> Deserialize<'de>,
@@ -237,7 +261,6 @@ impl ProverTester {
         Ok(out)
     }
 
-
     /// End-to-end test for a single proving task to generate an EVM-verifiable SNARK proof.
     pub fn prove_verify_single_evm<Spec: ProvingTestSpec>(
         &self,
@@ -251,16 +274,15 @@ impl ProverTester {
         let prover = Prover::<Spec::ProverType>::setup(cfg)?;
         let wrapped_proof = Self::prove_verify_single::<Spec>(&prover, task, true)?;
 
-        prover.dump_universal_verifier(None::<String>)?
+        prover
+            .dump_universal_verifier(None::<String>)?
             .verify_proof_evm(
-            &wrapped_proof.proof.as_evm_proof().unwrap().clone().into(),
-            &wrapped_proof.vk,
-        )?;
+                &wrapped_proof.proof.as_evm_proof().unwrap().clone().into(),
+                &wrapped_proof.vk,
+            )?;
 
         Ok(wrapped_proof)
     }
-
-
 }
 
 /// Spec for test phase (chunk/batch/bundle)
@@ -272,6 +294,4 @@ pub trait ProvingTestSpec {
 
     //TODO: deprecated this spec later when the universal prover type is ready
     type ProverType: ProverType;
-
 }
-

common/libzkp/integration_test/src/specs.rs

@@ -1,34 +1,30 @@
 use crate::ProvingTestSpec;
 use libzkp::{
+    proofs::{BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata},
+    tasks::{BatchProvingTask, BundleProvingTask, ChunkProvingTask},
     TaskType,
-    proofs::{ChunkProofMetadata, BatchProofMetadata, BundleProofMetadata},
-    tasks::{ChunkProvingTask, BatchProvingTask, BundleProvingTask},
 };
-use scroll_zkvm_prover_euclid::{ChunkProverType, BatchProverType, BundleProverTypeEuclidV2};
+use scroll_zkvm_prover_euclid::{BatchProverType, BundleProverTypeEuclidV2, ChunkProverType};
 
 pub struct ChunkProverSpec;
 pub struct BatchProverSpec;
 pub struct BundleProverSpec;
 
 impl ProvingTestSpec for ChunkProverSpec {
-
     const PHASE_SPEC: TaskType = TaskType::Chunk;
     type MetadataType = ChunkProofMetadata;
     type ProvingTaskType = ChunkProvingTask;
     type ProverType = ChunkProverType;
 }
 
-
 impl ProvingTestSpec for BatchProverSpec {
-
     const PHASE_SPEC: TaskType = TaskType::Batch;
     type MetadataType = BatchProofMetadata;
     type ProvingTaskType = BatchProvingTask;
     type ProverType = BatchProverType;
 }
 
 impl ProvingTestSpec for BundleProverSpec {
-
     const PHASE_SPEC: TaskType = TaskType::Bundle;
     type MetadataType = BundleProofMetadata;
     type ProvingTaskType = BundleProvingTask;

common/libzkp/integration_test/src/utils/mod.rs

@@ -1,21 +1,35 @@
 use sbv_primitives::{
+    types::{eips::Encodable2718, reth::TransactionSigned, BlockWitness, Transaction},
     B256, U256,
-    types::{BlockWitness, Transaction, eips::Encodable2718, reth::TransactionSigned},
 };
 use scroll_zkvm_prover_euclid::{
-    ChunkProof,
     task::{
         batch::{BatchHeaderV, BatchProvingTask},
         chunk::ChunkProvingTask,
     },
     utils::point_eval,
+    ChunkProof,
 };
 use scroll_zkvm_types::{
     batch::{BatchHeader, BatchHeaderV6, BatchHeaderV7},
     utils::keccak256,
 };
+use std::{fs::File, path::Path};
 use vm_zstd::zstd_encode;
 
+/// Utility function to read and deserialize block witness given the block number.
+pub fn read_block_witness<P>(path_witness: P) -> eyre::Result<BlockWitness>
+where
+    P: AsRef<Path>,
+{
+    if !path_witness.as_ref().exists() {
+        println!("File not found: {:?}", path_witness.as_ref());
+        return Err(eyre::eyre!("File not found: {:?}", path_witness.as_ref()));
+    }
+    let witness = File::open(path_witness)?;
+    Ok(serde_json::from_reader::<_, BlockWitness>(witness)?)
+}
+
 fn is_l1_tx(tx: &Transaction) -> bool {
     // 0x7e is l1 tx
     tx.transaction_type == 0x7e
@@ -216,7 +230,6 @@ pub fn build_batch_task(
     let x = point_eval::get_x_from_challenge(challenge_digest);
     let (kzg_proof, z) = point_eval::get_kzg_proof(&kzg_blob, challenge_digest);
 
-
     let batch_header = {
         // avoid unused variant warning
         let _ = x + z;
@@ -248,13 +261,12 @@ fn test_build_and_parse_batch_task() -> eyre::Result<()> {
     let path_testdata = std::path::Path::new("testdata");
 
     // read block witnesses.
-    let paths_block_witnesses = 
-        [
-            path_testdata.join("1.json"),
-            path_testdata.join("2.json"),
-            path_testdata.join("3.json"),
-            path_testdata.join("4.json"),
-        ];
+    let paths_block_witnesses = [
+        path_testdata.join("1.json"),
+        path_testdata.join("2.json"),
+        path_testdata.join("3.json"),
+        path_testdata.join("4.json"),
+    ];
     let read_block_witness = |path| Ok(read_json::<_, BlockWitness>(path)?);
     let chunk_task = ChunkProvingTask {
         block_witnesses: paths_block_witnesses
@@ -266,11 +278,7 @@ fn test_build_and_parse_batch_task() -> eyre::Result<()> {
     };
 
     // read chunk proof.
-    let path_chunk_proof = path_testdata
-        .join("proofs")
-        .join(
-            "chunk-1-4.json"
-        );
+    let path_chunk_proof = path_testdata.join("proofs").join("chunk-1-4.json");
     let chunk_proof = read_json_deep::<_, ChunkProof>(&path_chunk_proof)?;
 
     let task = build_batch_task(&[chunk_task], &[chunk_proof], Default::default());
@@ -283,7 +291,6 @@ fn test_build_and_parse_batch_task() -> eyre::Result<()> {
 
     let enveloped = Envelope::from(task.blob_bytes.as_slice());
 
-    
     let header = task.batch_header.must_v7_header();
     Payload::from(&enveloped).validate(header, &chunk_infos);