chore: openvm 1.6

Cargo.toml

@@ -14,12 +14,13 @@ edition = "2021"
 homepage = "https://scroll.io"
 readme = "README.md"
 repository = "https://github.com/scroll-tech/scroll"
-version = "4.7.1"
+version = "4.7.11"
 
 [workspace.dependencies]
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.1" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.1" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.1" }
+# with openvm 1.4.2
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "4a78ca9" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "4a78ca9" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "4a78ca9" }
 
 sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91.2", features = ["scroll", "rkyv"] }
 sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91.2" }

crates/libzkp/src/lib.rs

@@ -13,22 +13,8 @@ use serde_json::value::RawValue;
 use std::{collections::HashMap, path::Path, sync::OnceLock};
 use tasks::chunk_interpreter::{ChunkInterpreter, TryFromWithInterpreter};
 
-pub(crate) fn witness_use_legacy_mode(fork_name: &str) -> eyre::Result<bool> {
-    ADDITIONAL_FEATURES
-        .get()
-        .and_then(|features| features.get(fork_name))
-        .map(|cfg| cfg.legacy_witness_encoding)
-        .ok_or_else(|| {
-            eyre::eyre!(
-                "can not find features setting for unrecognized fork {}",
-                fork_name
-            )
-        })
-}
-
 #[derive(Debug, Default, Clone)]
 struct FeatureOptions {
-    legacy_witness_encoding: bool,
     for_openvm_13_prover: bool,
 }
 
@@ -41,11 +27,10 @@ impl FeatureOptions {
         for feat_s in feats.split(':') {
             match feat_s.trim().to_lowercase().as_str() {
                 "legacy_witness" => {
-                    tracing::info!("set witness encoding for legacy mode");
-                    ret.legacy_witness_encoding = true;
+                    tracing::warn!("legacy witness is no longer supported");
                 }
                 "openvm_13" => {
-                    tracing::info!("set prover should use openvm 13");
+                    tracing::warn!("set prover should use openvm 13");
                     ret.for_openvm_13_prover = true;
                 }
                 s => tracing::warn!("unrecognized dynamic feature: {s}"),

crates/libzkp/src/proofs.rs

@@ -4,11 +4,9 @@ use crate::utils::short_git_version;
 use eyre::Result;
 use sbv_primitives::B256;
 use scroll_zkvm_types::{
-    batch::BatchInfo,
-    bundle::BundleInfo,
-    chunk::ChunkInfo,
     proof::{EvmProof, OpenVmEvmProof, ProofEnum, StarkProof},
     public_inputs::MultiVersionPublicInputs,
+    scroll::{batch::BatchInfo, bundle::BundleInfo, chunk::ChunkInfo},
     types_agg::AggregationInput,
     utils::{serialize_vk, vec_as_base64},
     version,
@@ -215,7 +213,7 @@ impl<Metadata: ProofMetadata> PersistableProof for WrappedProof<Metadata> {
 mod tests {
     use base64::{prelude::BASE64_STANDARD, Engine};
     use sbv_primitives::B256;
-    use scroll_zkvm_types::{bundle::BundleInfo, proof::EvmProof};
+    use scroll_zkvm_types::{proof::EvmProof, scroll::bundle::BundleInfo};
 
     use super::*;
 
@@ -253,7 +251,7 @@ mod tests {
                 msg_queue_hash: B256::repeat_byte(6),
                 encryption_key: None,
             };
-            let bundle_pi_hash = bundle_info.pi_hash_euclidv1();
+            let bundle_pi_hash = bundle_info.pi_hash_by_version(version::Version::euclid_v1());
             BundleProofMetadata {
                 bundle_info,
                 bundle_pi_hash,

crates/libzkp/src/tasks/batch.rs

@@ -2,15 +2,16 @@ use c_kzg::Bytes48;
 use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
-    batch::{
-        build_point_eval_witness, BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderValidium,
-        BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, LegacyBatchWitness,
-        ReferenceHeader, N_BLOB_BYTES,
-    },
-    chunk::ChunkInfo,
     public_inputs::{ForkName, MultiVersionPublicInputs, Version},
+    scroll::{
+        batch::{
+            build_point_eval_witness, BatchHeader, BatchHeaderV6, BatchHeaderV7,
+            BatchHeaderValidium, BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7,
+            ReferenceHeader, N_BLOB_BYTES,
+        },
+        chunk::ChunkInfo,
+    },
     task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
     version::{Codec, Domain, STFVersion},
 };
 
@@ -118,12 +119,7 @@ pub struct BatchProvingTask {
 impl BatchProvingTask {
     pub fn into_proving_task_with_precheck(self) -> Result<(ProvingTask, BatchInfo, B256)> {
         let (witness, metadata, batch_pi_hash) = self.precheck()?;
-        let serialized_witness = if crate::witness_use_legacy_mode(&self.fork_name)? {
-            let legacy_witness = LegacyBatchWitness::from(witness);
-            to_rkyv_bytes::<RancorError>(&legacy_witness)?.into_vec()
-        } else {
-            super::encode_task_to_witness(&witness)?
-        };
+        let serialized_witness = super::encode_task_to_witness(&witness)?;
 
         let proving_task = ProvingTask {
             identifier: self.batch_header.batch_hash().to_string(),

crates/libzkp/src/tasks/bundle.rs

@@ -1,10 +1,9 @@
 use eyre::Result;
 use sbv_primitives::B256;
 use scroll_zkvm_types::{
-    bundle::{BundleInfo, BundleWitness, LegacyBundleWitness},
     public_inputs::{MultiVersionPublicInputs, Version},
+    scroll::bundle::{BundleInfo, BundleWitness},
     task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
 };
 
 use crate::proofs::BatchProof;
@@ -27,12 +26,7 @@ pub struct BundleProvingTask {
 impl BundleProvingTask {
     pub fn into_proving_task_with_precheck(self) -> Result<(ProvingTask, BundleInfo, B256)> {
         let (witness, bundle_info, bundle_pi_hash) = self.precheck()?;
-        let serialized_witness = if crate::witness_use_legacy_mode(&self.fork_name)? {
-            let legacy = LegacyBundleWitness::from(witness);
-            to_rkyv_bytes::<RancorError>(&legacy)?.into_vec()
-        } else {
-            super::encode_task_to_witness(&witness)?
-        };
+        let serialized_witness = super::encode_task_to_witness(&witness)?;
 
         let proving_task = ProvingTask {
             identifier: self.identifier(),

crates/libzkp/src/tasks/chunk.rs

@@ -2,10 +2,9 @@ use eyre::Result;
 use sbv_core::BlockWitness;
 use sbv_primitives::{types::consensus::BlockHeader, B256};
 use scroll_zkvm_types::{
-    chunk::{execute, ChunkInfo, ChunkWitness, LegacyChunkWitness, ValidiumInputs},
     public_inputs::{MultiVersionPublicInputs, Version},
+    scroll::chunk::{execute, ChunkInfo, ChunkWitness, ValidiumInputs},
     task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
 };
 
 use super::chunk_interpreter::*;
@@ -117,12 +116,7 @@ impl ChunkProvingTask {
 
     pub fn into_proving_task_with_precheck(self) -> Result<(ProvingTask, ChunkInfo, B256)> {
         let (witness, chunk_info, chunk_pi_hash) = self.precheck()?;
-        let serialized_witness = if crate::witness_use_legacy_mode(&self.fork_name)? {
-            let legacy_witness = LegacyChunkWitness::from(witness);
-            to_rkyv_bytes::<RancorError>(&legacy_witness)?.into_vec()
-        } else {
-            super::encode_task_to_witness(&witness)?
-        };
+        let serialized_witness = super::encode_task_to_witness(&witness)?;
 
         let proving_task = ProvingTask {
             identifier: self.identifier(),

crates/prover-bin/Cargo.toml

@@ -9,7 +9,7 @@ edition.workspace = true
 scroll-zkvm-types.workspace = true
 scroll-zkvm-prover.workspace = true
 libzkp = { path = "../libzkp"}
-scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "05648db" }
+scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", rev = "22ad34e" }
 serde.workspace = true
 serde_json.workspace = true
 once_cell.workspace =true
@@ -34,6 +34,7 @@ clap = { version = "4.5", features = ["derive"] }
 ctor = "0.2.8"
 url = { version = "2.5.4", features = ["serde",] }
 serde_bytes = "0.11.15"
+bincode = { version = "2.0", features = ["serde",] }
 
 [features]
 default = []

crates/prover-bin/src/dumper.rs

@@ -0,0 +1,88 @@
+use async_trait::async_trait;
+use libzkp::ProvingTaskExt;
+use scroll_proving_sdk::prover::{
+    proving_service::{
+        GetVkRequest, GetVkResponse, ProveRequest, ProveResponse, QueryTaskRequest,
+        QueryTaskResponse, TaskStatus,
+    },
+    ProvingService,
+};
+use scroll_zkvm_types::ProvingTask;
+
+#[derive(Default)]
+pub struct Dumper {
+    #[allow(dead_code)]
+    pub target_path: String,
+    pub json_mode: bool,
+}
+
+impl Dumper {
+    fn dump(&self, input_string: &str) -> eyre::Result<()> {
+        let task: ProvingTaskExt = serde_json::from_str(input_string)?;
+        let task = ProvingTask::from(task);
+
+        if self.json_mode {
+            let file = std::fs::File::create("input_task.json")?;
+            serde_json::to_writer(std::io::BufWriter::new(file), &task)?;
+        } else {
+            // stream-encode serialized_witness to input_task.bin using bincode 2.0
+            let input_file = std::fs::File::create("input_task.bin")?;
+            let mut input_writer = std::io::BufWriter::new(input_file);
+            bincode::encode_into_std_write(
+                &task.serialized_witness,
+                &mut input_writer,
+                bincode::config::standard(),
+            )?;
+
+            // stream-encode aggregated_proofs to agg_proofs.bin using bincode 2.0
+            let agg_file = std::fs::File::create("agg_proofs.bin")?;
+            let mut agg_writer = std::io::BufWriter::new(agg_file);
+            for proof in &task.aggregated_proofs {
+                let sz = bincode::serde::encode_into_std_write(
+                    &proof.proofs,
+                    &mut agg_writer,
+                    bincode::config::standard(),
+                )?;
+                println!("written {sz} bytes for proof");
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl ProvingService for Dumper {
+    fn is_local(&self) -> bool {
+        true
+    }
+    async fn get_vks(&self, _: GetVkRequest) -> GetVkResponse {
+        // get vk has been deprecated in new prover with dynamic asset loading scheme
+        GetVkResponse {
+            vks: vec![],
+            error: None,
+        }
+    }
+    async fn prove(&mut self, req: ProveRequest) -> ProveResponse {
+        let error = if let Err(e) = self.dump(&req.input) {
+            Some(format!("failed to dump: {}", e))
+        } else {
+            None
+        };
+
+        ProveResponse {
+            status: TaskStatus::Failed,
+            error,
+            ..Default::default()
+        }
+    }
+
+    async fn query_task(&mut self, req: QueryTaskRequest) -> QueryTaskResponse {
+        QueryTaskResponse {
+            task_id: req.task_id,
+            status: TaskStatus::Failed,
+            error: Some("dump file finished but need a fail return to exit".to_string()),
+            ..Default::default()
+        }
+    }
+}

crates/prover-bin/src/main.rs

@@ -1,8 +1,9 @@
+mod dumper;
 mod prover;
 mod types;
 mod zk_circuits_handler;
 
-use clap::{ArgAction, Parser, Subcommand};
+use clap::{ArgAction, Parser, Subcommand, ValueEnum};
 use prover::{LocalProver, LocalProverConfig};
 use scroll_proving_sdk::{
     prover::{types::ProofType, ProverBuilder},
@@ -32,12 +33,35 @@ struct Args {
     command: Option<Commands>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, ValueEnum)]
+enum TaskType {
+    Chunk,
+    Batch,
+    Bundle,
+}
+
+impl From<TaskType> for ProofType {
+    fn from(value: TaskType) -> Self {
+        match value {
+            TaskType::Chunk => ProofType::Chunk,
+            TaskType::Batch => ProofType::Batch,
+            TaskType::Bundle => ProofType::Bundle,
+        }
+    }
+}
+
 #[derive(Subcommand, Debug)]
 enum Commands {
     Handle {
         /// path to save the verifier's asset
         task_path: String,
     },
+    Dump {
+        #[arg(long = "json", default_value = "false")]
+        json_mode: bool,
+        task_type: TaskType,
+        task_id: String,
+    },
 }
 
 #[derive(Debug, serde::Deserialize)]
@@ -63,6 +87,26 @@ async fn main() -> eyre::Result<()> {
     let local_prover = LocalProver::new(cfg.clone());
 
     match args.command {
+        Some(Commands::Dump {
+            json_mode,
+            task_type,
+            task_id,
+        }) => {
+            let prover = ProverBuilder::new(
+                sdk_config,
+                dumper::Dumper {
+                    json_mode,
+                    ..Default::default()
+                },
+            )
+            .build()
+            .await
+            .map_err(|e| eyre::eyre!("build prover fail: {e}"))?;
+
+            std::sync::Arc::new(prover)
+                .one_shot(&[task_id], task_type.into())
+                .await;
+        }
         Some(Commands::Handle { task_path }) => {
             let file = File::open(Path::new(&task_path))?;
             let reader = BufReader::new(file);