fix acoording to reviews

Author: noel2004

coordinator/internal/logic/libzkp/libzkp.h

@@ -56,8 +56,6 @@ char* gen_wrapped_proof(char* proof_json, char* metadata, char* vk, size_t vk_le
 // Release memory allocated for a string returned by gen_wrapped_proof
 void release_string(char* string_ptr);
 
-void set_dynamic_feature(const char* feats);
-
 // Universal task compatibility fix function
 char* univ_task_compatibility_fix(char* task_json);
 

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -328,7 +328,6 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkProofs []
 		if decodeErr != nil {
 			return nil, fmt.Errorf("failed to decode batch header version %d: %w", dbBatch.CodecVersion, decodeErr)
 		}
-		log.Info("Decode batchheader bytes to canonical header", "version", batchHeader.Version())
 		taskDetail.BatchHeader = batchHeader
 
 		taskDetail.ChallengeDigest = common.HexToHash(dbBatch.ChallengeDigest)

crates/libzkp/src/lib.rs

@@ -1,6 +1,6 @@
 pub mod proofs;
 pub mod tasks;
-pub use tasks::ProvintTaskExt;
+pub use tasks::ProvingTaskExt;
 pub mod verifier;
 use verifier::HardForkName;
 pub use verifier::{TaskType, VerifierConfig};
@@ -20,7 +20,7 @@ pub(crate) fn witness_use_legacy_mode(fork_name: &str) -> eyre::Result<bool> {
         .map(|cfg| cfg.legacy_witness_encoding)
         .ok_or_else(|| {
             eyre::eyre!(
-                "can not found features setting for unrecognized fork {}",
+                "can not find features setting for unrecognized fork {}",
                 fork_name
             )
         })
@@ -55,10 +55,6 @@ impl FeatureOptions {
     }
 }
 
-pub fn set_dynamic_feature(_: &str) {
-    tracing::error!("call deprecated method");
-}
-
 /// Turn the coordinator's chunk task into a json string for formal chunk proving
 /// task (with full witnesses)
 pub fn checkout_chunk_task(
@@ -196,7 +192,7 @@ pub fn gen_universal_task(
 
     u_task.vk = Vec::from(expected_vk);
     let fork_name = u_task.fork_name.clone();
-    let mut u_task_ext = ProvintTaskExt::new(u_task);
+    let mut u_task_ext = ProvingTaskExt::new(u_task);
 
     // set additional settings from global features
     if let Some(cfg) = ADDITIONAL_FEATURES

crates/libzkp/src/tasks.rs

@@ -36,20 +36,20 @@ fn check_aggregation_proofs<Metadata: MultiVersionPublicInputs>(
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
-pub struct ProvintTaskExt {
+pub struct ProvingTaskExt {
     #[serde(flatten)]
     task: ProvingTask,
     #[serde(default)]
     pub use_openvm_13: bool,
 }
 
-impl From<ProvintTaskExt> for ProvingTask {
-    fn from(wrap_t: ProvintTaskExt) -> Self {
+impl From<ProvingTaskExt> for ProvingTask {
+    fn from(wrap_t: ProvingTaskExt) -> Self {
         wrap_t.task
     }
 }
 
-impl ProvintTaskExt {
+impl ProvingTaskExt {
     pub fn new(task: ProvingTask) -> Self {
         Self {
             task,

crates/libzkp/src/tasks/batch.rs

@@ -27,11 +27,11 @@ pub struct BatchHeaderValidiumWithHash {
 }
 
 /// Parse header types passed from golang side and adapt to the
-/// defination in zkvm-prover's types
+/// definition in zkvm-prover's types
 /// We distinguish the header type in golang side according to the codec
-/// version, i.e. v6 - v9 (current), and validium
-/// And adapt it to different header version used in zkvm-prover's witness
-/// defination, i.e. v6- v8 (current), and validium
+/// version, i.e. v7 - v9 (current), and validium
+/// And adapt it to the corresponding header version used in zkvm-prover's witness
+/// definition, i.e. v7- v8 (current), and validium
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 #[serde(untagged)]
 #[allow(non_camel_case_types)]

crates/libzkp_c/src/lib.rs

@@ -275,10 +275,3 @@ pub unsafe extern "C" fn release_string(ptr: *mut c_char) {
         let _ = CString::from_raw(ptr);
     }
 }
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn set_dynamic_feature(feats: *const c_char) {
-    let feats_str = c_char_to_str(feats);
-    libzkp::set_dynamic_feature(feats_str);
-}

crates/prover-bin/src/prover.rs

@@ -12,6 +12,7 @@ use scroll_proving_sdk::{
         ProvingService,
     },
 };
+use scroll_zkvm_types::ProvingTask;
 use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
@@ -272,7 +273,9 @@ impl LocalProver {
         let duration = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
         let created_at = duration.as_secs() as f64 + duration.subsec_nanos() as f64 * 1e-9;
 
-        let (prover_task, task_cfg) = UniversalHandler::get_task_from_input(&req.input)?;
+        let prover_task = UniversalHandler::get_task_from_input(&req.input)?;
+        let is_openvm_13 = prover_task.use_openvm_13;
+        let prover_task: ProvingTask = prover_task.into();
         let vk = hex::encode(&prover_task.vk);
         let handler = if let Some(handler) = self.handlers.get(&vk) {
             handler.clone()
@@ -298,8 +301,10 @@ impl LocalProver {
                 .location_data
                 .get_asset(&vk, &url_base, &base_config.workspace_path)
                 .await?;
-            let circuits_handler =
-                Arc::new(Mutex::new(UniversalHandler::new(&asset_path, &task_cfg)?));
+            let circuits_handler = Arc::new(Mutex::new(UniversalHandler::new(
+                &asset_path,
+                is_openvm_13,
+            )?));
             self.handlers.insert(vk, circuits_handler.clone());
             circuits_handler
         };

crates/prover-bin/src/zk_circuits_handler/universal.rs

@@ -3,34 +3,28 @@ use std::path::Path;
 use super::CircuitsHandler;
 use async_trait::async_trait;
 use eyre::Result;
-use libzkp::ProvintTaskExt;
+use libzkp::ProvingTaskExt;
 use scroll_zkvm_prover::{Prover, ProverConfig};
 use scroll_zkvm_types::ProvingTask;
 use tokio::sync::Mutex;
 pub struct UniversalHandler {
     prover: Prover,
 }
 
-// additional config dispatched with proving task
-#[derive(Debug, Default)]
-pub(crate) struct TaskConfig {
-    pub is_openvm_v13: bool,
-}
-
 /// Safe for current usage as `CircuitsHandler` trait (protected inside of Mutex and NEVER extract
 /// the instance out by `into_inner`)
 unsafe impl Send for UniversalHandler {}
 
 impl UniversalHandler {
-    pub fn new(workspace_path: impl AsRef<Path>, cfg: &TaskConfig) -> Result<Self> {
+    pub fn new(workspace_path: impl AsRef<Path>, is_openvm_v13: bool) -> Result<Self> {
         let path_app_exe = workspace_path.as_ref().join("app.vmexe");
         let path_app_config = workspace_path.as_ref().join("openvm.toml");
-        let segment_len = Some((1 << 22) - 100);
+        let segment_len = Some((1 << 21) - 100);
         let config = ProverConfig {
             path_app_config,
             path_app_exe,
             segment_len,
-            is_openvm_v13: cfg.is_openvm_v13,
+            is_openvm_v13,
         };
 
         let prover = Prover::setup(config, None)?;
@@ -43,13 +37,8 @@ impl UniversalHandler {
         &mut self.prover
     }
 
-    pub fn get_task_from_input(input: &str) -> Result<(ProvingTask, TaskConfig)> {
-        let task_ext: ProvintTaskExt = serde_json::from_str(input)?;
-        let cfg = TaskConfig {
-            is_openvm_v13: task_ext.use_openvm_13,
-        };
-
-        Ok((task_ext.into(), cfg))
+    pub fn get_task_from_input(input: &str) -> Result<ProvingTaskExt> {
+        Ok(serde_json::from_str(input)?)
     }
 }
 

tests/prover-e2e/cloak-xen/config.template.json

@@ -35,6 +35,6 @@
     "login_expire_duration_sec": 3600
   },
   "sequencer": {
-    "decryption_key": "ad25ba5de9f03fd9e3c81a1ad731c5c7e94ae2641f75ed7d3275312053b40f75"
+    "decryption_key": "<decryption key>"
   }
 }