[Feat] Galileo forking

Cargo.toml

@@ -14,53 +14,52 @@ edition = "2021"
 homepage = "https://scroll.io"
 readme = "README.md"
 repository = "https://github.com/scroll-tech/scroll"
-version = "4.6.3"
+version = "4.7.1"
 
 [workspace.dependencies]
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "360f364" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "360f364" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "360f364" }
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.0-rc.5" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.0-rc.5" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.7.0-rc.5" }
 
-sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master", features = ["scroll", "rkyv"] }
-sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master" }
-sbv-core = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "master", features = ["scroll"] }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91", features = ["scroll", "rkyv"] }
+sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91" }
+sbv-core = { git = "https://github.com/scroll-tech/stateless-block-verifier", tag = "scroll-v91", features = ["scroll"] }
 
 metrics = "0.23.0"
 metrics-util = "0.17"
 metrics-tracing-context = "0.16.0"
 
 anyhow = "1.0"
 alloy = { version = "1", default-features = false }
-alloy-primitives = { version = "1.3", default-features = false, features = ["tiny-keccak"] }
+alloy-primitives = { version = "1.4.1", default-features = false, features = ["tiny-keccak"] }
 # also use this to trigger "serde" feature for primitives
 alloy-serde = { version = "1", default-features = false }
 
 serde = { version = "1", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0" }
 serde_derive = "1.0"
-serde_with = "3.11.0"
+serde_with = "3"
 itertools = "0.14"
 tiny-keccak = "2.0"
 tracing = "0.1"
 eyre = "0.6"
 once_cell = "1.20"
 base64 = "0.22"
 
-[patch.crates-io]
-revm = { git = "https://github.com/scroll-tech/revm" }
-revm-bytecode = { git = "https://github.com/scroll-tech/revm" }
-revm-context = { git = "https://github.com/scroll-tech/revm" }
-revm-context-interface = { git = "https://github.com/scroll-tech/revm" }
-revm-database = { git = "https://github.com/scroll-tech/revm" }
-revm-database-interface = { git = "https://github.com/scroll-tech/revm" }
-revm-handler = { git = "https://github.com/scroll-tech/revm" }
-revm-inspector = { git = "https://github.com/scroll-tech/revm" }
-revm-interpreter = { git = "https://github.com/scroll-tech/revm" }
-revm-precompile = { git = "https://github.com/scroll-tech/revm" }
-revm-primitives = { git = "https://github.com/scroll-tech/revm" }
-revm-state = { git = "https://github.com/scroll-tech/revm" }
 
-alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "feat/rkyv" }
+[patch.crates-io]
+revm = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-bytecode = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-context = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-context-interface = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-database = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-database-interface = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-handler = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-inspector = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-interpreter = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-precompile = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-primitives = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
+revm-state = { git = "https://github.com/scroll-tech/revm", tag = "scroll-v91" }
 
 [profile.maxperf]
 inherits = "release"

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.6.3"
+var tag = "v4.7.1"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

coordinator/conf/config.json

@@ -10,6 +10,7 @@
       "min_prover_version": "v4.4.45",
       "verifiers": [
         {
+          "features": "legacy_witness:openvm_13",
           "assets_path": "assets",
           "fork_name": "feynman"
         },        

coordinator/internal/config/config.go

@@ -69,12 +69,12 @@ type AssetConfig struct {
 	ForkName         string `json:"fork_name"`
 	Vkfile           string `json:"vk_file,omitempty"`
 	MinProverVersion string `json:"min_prover_version,omitempty"`
+	Features         string `json:"features,omitempty"`
 }
 
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
 	MinProverVersion string        `json:"min_prover_version"`
-	Features         string        `json:"features,omitempty"`
 	Verifiers        []AssetConfig `json:"verifiers"`
 }
 

coordinator/internal/logic/libzkp/lib.go

@@ -141,13 +141,6 @@ func DumpVk(forkName, filePath string) error {
 	return nil
 }
 
-// Set dynamic feature flags that control libzkp runtime behavior
-func SetDynamicFeature(feats string) {
-	cFeats := goToCString(feats)
-	defer freeCString(cFeats)
-	C.set_dynamic_feature(cFeats)
-}
-
 // UnivTaskCompatibilityFix calls the universal task compatibility fix function
 func UniversalTaskCompatibilityFix(taskJSON string) (string, error) {
 	cTaskJSON := goToCString(taskJSON)

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -313,7 +313,7 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkProofs []
 		switch dbBatchCodecVersion {
 		case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7, encoding.CodecV8, encoding.CodecV9:
 		default:
-			return taskDetail, nil
+			return nil, fmt.Errorf("Unsupported codec version <%d>", dbBatchCodecVersion)
 		}
 
 		codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
@@ -325,6 +325,7 @@ 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)
@@ -335,7 +336,7 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkProofs []
 		taskDetail.KzgProof = &message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[112:160]))}
 		taskDetail.KzgCommitment = &message.Byte48{Big: hexutil.Big(*new(big.Int).SetBytes(dbBatch.BlobDataProof[64:112]))}
 	} else {
-		log.Debug("Apply validium mode for batch proving task")
+		log.Info("Apply validium mode for batch proving task")
 		codec := cutils.FromVersion(version)
 		batchHeader, decodeErr := codec.DABatchForTaskFromBytes(dbBatch.BatchHeader)
 		if decodeErr != nil {

coordinator/internal/logic/verifier/verifier.go

@@ -29,6 +29,7 @@ type rustCircuitConfig struct {
 	Version    uint   `json:"version"`
 	ForkName   string `json:"fork_name"`
 	AssetsPath string `json:"assets_path"`
+	Features   string `json:"features,omitempty"`
 }
 
 var validiumMode bool
@@ -47,6 +48,7 @@ func newRustCircuitConfig(cfg config.AssetConfig) *rustCircuitConfig {
 		Version:    uint(ver),
 		AssetsPath: cfg.AssetsPath,
 		ForkName:   cfg.ForkName,
+		Features:   cfg.Features,
 	}
 }
 
@@ -82,9 +84,6 @@ func NewVerifier(cfg *config.VerifierConfig, useValidiumMode bool) (*Verifier, e
 		return nil, err
 	}
 
-	if cfg.Features != "" {
-		libzkp.SetDynamicFeature(cfg.Features)
-	}
 	libzkp.InitVerifier(string(configBytes))
 
 	v := &Verifier{

crates/libzkp/Cargo.toml

@@ -9,7 +9,7 @@ scroll-zkvm-types = { workspace = true, features = ["scroll"] }
 scroll-zkvm-verifier.workspace = true
 
 alloy-primitives.workspace = true #depress the effect of "native-keccak"
-sbv-primitives = {workspace = true, features = ["scroll-compress-ratio", "scroll"]}
+sbv-primitives = {workspace = true, features = ["scroll-compress-info", "scroll"]}
 sbv-core = { workspace = true, features = ["scroll"] }
 base64.workspace = true
 serde.workspace = true

crates/libzkp/src/lib.rs

@@ -1,38 +1,64 @@
 pub mod proofs;
 pub mod tasks;
+pub use tasks::ProvintTaskExt;
 pub mod verifier;
+use verifier::HardForkName;
 pub use verifier::{TaskType, VerifierConfig};
 mod utils;
 
 use sbv_primitives::B256;
-use scroll_zkvm_types::utils::vec_as_base64;
+use scroll_zkvm_types::{utils::vec_as_base64, version::Version};
 use serde::{Deserialize, Serialize};
 use serde_json::value::RawValue;
-use std::path::Path;
+use std::{collections::HashMap, path::Path, sync::OnceLock};
 use tasks::chunk_interpreter::{ChunkInterpreter, TryFromWithInterpreter};
 
-/// global features: use legacy encoding for witness
-static mut LEGACY_WITNESS_ENCODING: bool = false;
+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 found features setting for unrecognized fork {}",
+                fork_name
+            )
+        })
+}
 
-pub(crate) fn witness_use_legacy_mode() -> bool {
-    unsafe { LEGACY_WITNESS_ENCODING }
+#[derive(Debug, Default, Clone)]
+struct FeatureOptions {
+    legacy_witness_encoding: bool,
+    for_openvm_13_prover: bool,
 }
 
-pub fn set_dynamic_feature(feats: &str) {
-    for feat_s in feats.split(':') {
-        match feat_s.trim().to_lowercase().as_str() {
-            "legacy_witness" => {
-                tracing::info!("set witness encoding for legacy mode");
-                unsafe {
-                    // the function is only called while initialize step
-                    LEGACY_WITNESS_ENCODING = true;
+static ADDITIONAL_FEATURES: OnceLock<HashMap<HardForkName, FeatureOptions>> = OnceLock::new();
+
+impl FeatureOptions {
+    pub fn new(feats: &str) -> Self {
+        let mut ret: Self = Default::default();
+
+        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;
                 }
+                "openvm_13" => {
+                    tracing::info!("set prover should use openvm 13");
+                    ret.for_openvm_13_prover = true;
+                }
+                s => tracing::warn!("unrecognized dynamic feature: {s}"),
             }
-            s => tracing::warn!("unrecognized dynamic feature: {s}"),
         }
+        ret
     }
 }
 
+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(
@@ -112,47 +138,83 @@ pub fn gen_universal_task(
             let mut task = serde_json::from_str::<ChunkProvingTask>(task_json)?;
             // normailze fork name field in task
             task.fork_name = task.fork_name.to_lowercase();
+            let version = Version::from(task.version);
             // always respect the fork_name_str (which has been normalized) being passed
             // if the fork_name wrapped in task is not match, consider it a malformed task
             if fork_name_str != task.fork_name.as_str() {
                 eyre::bail!("fork name in chunk task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
             }
+            if fork_name_str != version.fork.as_str() {
+                eyre::bail!(
+                    "given task version, expected fork={fork_name_str}, got={version_fork}",
+                    version_fork = version.fork.as_str()
+                );
+            }
             let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_chunk_task(task, fork_name_str.into()))
+                utils::panic_catch(move || gen_universal_chunk_task(task))
                     .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
             (pi_hash, AnyMetaData::Chunk(metadata), u_task)
         }
         x if x == TaskType::Batch as i32 => {
             let mut task = serde_json::from_str::<BatchProvingTask>(task_json)?;
             task.fork_name = task.fork_name.to_lowercase();
+            let version = Version::from(task.version);
             if fork_name_str != task.fork_name.as_str() {
                 eyre::bail!("fork name in batch task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
             }
+            if fork_name_str != version.fork.as_str() {
+                eyre::bail!(
+                    "given task version, expected fork={fork_name_str}, got={version_fork}",
+                    version_fork = version.fork.as_str()
+                );
+            }
             let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_batch_task(task, fork_name_str.into()))
+                utils::panic_catch(move || gen_universal_batch_task(task))
                     .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
             (pi_hash, AnyMetaData::Batch(metadata), u_task)
         }
         x if x == TaskType::Bundle as i32 => {
             let mut task = serde_json::from_str::<BundleProvingTask>(task_json)?;
             task.fork_name = task.fork_name.to_lowercase();
+            let version = Version::from(task.version);
             if fork_name_str != task.fork_name.as_str() {
                 eyre::bail!("fork name in bundle task not match the calling arg, expected {fork_name_str}, get {}", task.fork_name);
             }
+            if fork_name_str != version.fork.as_str() {
+                eyre::bail!(
+                    "given task version, expected fork={fork_name_str}, got={version_fork}",
+                    version_fork = version.fork.as_str()
+                );
+            }
             let (pi_hash, metadata, u_task) =
-                utils::panic_catch(move || gen_universal_bundle_task(task, fork_name_str.into()))
+                utils::panic_catch(move || gen_universal_bundle_task(task))
                     .map_err(|e| eyre::eyre!("caught panic in chunk task{e}"))??;
             (pi_hash, AnyMetaData::Bundle(metadata), u_task)
         }
         _ => return Err(eyre::eyre!("unrecognized task type {task_type}")),
     };
 
     u_task.vk = Vec::from(expected_vk);
+    let fork_name = u_task.fork_name.clone();
+    let mut u_task_ext = ProvintTaskExt::new(u_task);
+
+    // set additional settings from global features
+    if let Some(cfg) = ADDITIONAL_FEATURES
+        .get()
+        .and_then(|features| features.get(&fork_name))
+    {
+        u_task_ext.use_openvm_13 = cfg.for_openvm_13_prover;
+    } else {
+        tracing::warn!(
+            "can not found features setting for unrecognized fork {}",
+            fork_name
+        );
+    }
 
     Ok((
         pi_hash,
         serde_json::to_string(&metadata)?,
-        serde_json::to_string(&u_task)?,
+        serde_json::to_string(&u_task_ext)?,
     ))
 }
 
@@ -183,7 +245,26 @@ pub fn gen_wrapped_proof(proof_json: &str, metadata: &str, vk: &[u8]) -> eyre::R
 /// init verifier
 pub fn verifier_init(config: &str) -> eyre::Result<()> {
     let cfg: VerifierConfig = serde_json::from_str(config)?;
+    ADDITIONAL_FEATURES
+        .set(HashMap::from_iter(cfg.circuits.iter().map(|config| {
+            tracing::info!(
+                "start setting features [{:?}] for fork {}",
+                config.features,
+                config.fork_name
+            );
+            (
+                config.fork_name.to_lowercase(),
+                config
+                    .features
+                    .as_ref()
+                    .map(|features| FeatureOptions::new(features.as_str()))
+                    .unwrap_or_default(),
+            )
+        })))
+        .map_err(|c| eyre::eyre!("Fail to init additional features: {c:?}"))?;
+
     verifier::init(cfg);
+
     Ok(())
 }