fix: genesis state root commit workaround

update dep
lint
2026-04-23 03:00:50 -04:00 · 2025-10-02 14:20:56 +02:00 · 2025-10-01 19:05:54 +09:00 · 2025-09-29 21:17:57 +09:00 · 2025-09-29 21:17:26 +09:00 · 2025-09-29 21:16:31 +09:00
49 changed files with 1044 additions and 262 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -28,6 +28,41 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"

+[[package]]
+name = "aead"
+version = "0.6.0-rc.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac8202ab55fcbf46ca829833f347a82a2a4ce0596f0304ac322c2d100030cd56"
+dependencies = [
+ "crypto-common 0.2.0-rc.4",
+ "inout",
+]
+
+[[package]]
+name = "aes"
+version = "0.9.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e713c57c2a2b19159e7be83b9194600d7e8eb3b7c2cd67e671adf47ce189a05"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.11.0-rc.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2be322be4a73a3a55ad74b9833238e76bfd6034ce69a05c1b41c879f6a3bdca6"
+dependencies = [
+ "aead",
+ "aes",
+ "cipher",
+ "ctr",
+ "ghash",
+ "subtle",
+]
+
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -263,9 +298,9 @@ dependencies = [

 [[package]]
 name = "alloy-json-abi"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b26fdd571915bafe857fccba4ee1a4f352965800e46a53e4a5f50187b7776fa"
+checksum = "459f98c6843f208856f338bfb25e65325467f7aff35dfeb0484d0a76e059134b"
 dependencies = [
 "alloy-primitives",
 "alloy-sol-type-parser",
@@ -535,9 +570,9 @@ dependencies = [

 [[package]]
 name = "alloy-sol-macro"
-version = "1.2.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a14f21d053aea4c6630687c2f4ad614bed4c81e14737a9b904798b24f30ea849"
+checksum = "d20d867dcf42019d4779519a1ceb55eba8d7f3d0e4f0a89bcba82b8f9eb01e48"
 dependencies = [
 "alloy-sol-macro-expander",
 "alloy-sol-macro-input",
@@ -549,9 +584,9 @@ dependencies = [

 [[package]]
 name = "alloy-sol-macro-expander"
-version = "1.2.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34d99282e7c9ef14eb62727981a985a01869e586d1dec729d3bb33679094c100"
+checksum = "b74e91b0b553c115d14bd0ed41898309356dc85d0e3d4b9014c4e7715e48c8ad"
 dependencies = [
 "alloy-sol-macro-input",
 "const-hex",
@@ -567,9 +602,9 @@ dependencies = [

 [[package]]
 name = "alloy-sol-macro-input"
-version = "1.2.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eda029f955b78e493360ee1d7bd11e1ab9f2a220a5715449babc79d6d0a01105"
+checksum = "84194d31220803f5f62d0a00f583fd3a062b36382e2bea446f1af96727754565"
 dependencies = [
 "const-hex",
 "dunce",
@@ -583,9 +618,9 @@ dependencies = [

 [[package]]
 name = "alloy-sol-type-parser"
-version = "1.2.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10db1bd7baa35bc8d4a1b07efbf734e73e5ba09f2580fb8cee3483a36087ceb2"
+checksum = "fe8c27b3cf6b2bb8361904732f955bc7c05e00be5f469cec7e2280b6167f3ff0"
 dependencies = [
 "serde",
 "winnow 0.7.10",
@@ -593,9 +628,9 @@ dependencies = [

 [[package]]
 name = "alloy-sol-types"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6185e98a79cf19010722f48a74b5a65d153631d2f038cabd250f4b9e9813b8ad"
+checksum = "a285b46e3e0c177887028278f04cc8262b76fd3b8e0e20e93cea0a58c35f5ac5"
 dependencies = [
 "alloy-json-abi",
 "alloy-primitives",
@@ -1455,6 +1490,15 @@ dependencies = [
 "generic-array",
 ]

+[[package]]
+name = "block-buffer"
+version = "0.11.0-rc.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9ef36a6fcdb072aa548f3da057640ec10859eb4e91ddf526ee648d50c76a949"
+dependencies = [
+ "hybrid-array",
+]
+
 [[package]]
 name = "bls12_381"
 version = "0.7.1"
@@ -1669,6 +1713,17 @@ dependencies = [
 "windows-link",
 ]

+[[package]]
+name = "cipher"
+version = "0.5.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e12a13eb01ded5d32ee9658d94f553a19e804204f2dc811df69ab4d9e0cb8c7"
+dependencies = [
+ "block-buffer 0.11.0-rc.5",
+ "crypto-common 0.2.0-rc.4",
+ "inout",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.8.1"
@@ -1733,7 +1788,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
 "lazy_static",
- "windows-sys 0.59.0",
+ "windows-sys 0.48.0",
 ]

 [[package]]
@@ -1935,6 +1990,16 @@ dependencies = [
 "typenum",
 ]

+[[package]]
+name = "crypto-common"
+version = "0.2.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8235645834fbc6832939736ce2f2d08192652269e11010a6240f61b908a1c6"
+dependencies = [
+ "hybrid-array",
+ "rand_core 0.9.3",
+]
+
 [[package]]
 name = "ctor"
 version = "0.2.9"
@@ -1945,6 +2010,15 @@ dependencies = [
 "syn 2.0.101",
 ]

+[[package]]
+name = "ctr"
+version = "0.10.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27e41d01c6f73b9330177f5cf782ae5b581b5f2c7840e298e0275ceee5001434"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "cuda-config"
 version = "0.1.0"
@@ -2198,7 +2272,7 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
 "block-buffer 0.10.4",
 "const-oid",
- "crypto-common",
+ "crypto-common 0.1.6",
 "subtle",
 ]

@@ -2252,6 +2326,19 @@ dependencies = [
 "spki",
 ]

+[[package]]
+name = "ecies"
+version = "0.1.0"
+source = "git+https://github.com/scroll-tech/ecies-rs#e32a93f736aac2158bf5982b8e4786b82be8b854"
+dependencies = [
+ "aes-gcm",
+ "digest 0.10.7",
+ "hkdf",
+ "k256",
+ "sha2 0.10.9",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "educe"
 version = "0.6.0"
@@ -2396,7 +2483,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
 dependencies = [
 "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -2830,6 +2917,15 @@ dependencies = [
 "syn 2.0.101",
 ]

+[[package]]
+name = "ghash"
+version = "0.6.0-rc.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f88107cb02ed63adcc4282942e60c4d09d80208d33b360ce7c729ce6dae1739"
+dependencies = [
+ "polyval",
+]
+
 [[package]]
 name = "gimli"
 version = "0.31.1"
@@ -3187,6 +3283,15 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"

+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -3264,6 +3369,15 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"

+[[package]]
+name = "hybrid-array"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7116c472cf19838450b1d421b4e842569f52b519d640aee9ace1ebcf5b21051"
+dependencies = [
+ "typenum",
+]
+
 [[package]]
 name = "hyper"
 version = "0.14.32"
@@ -3584,6 +3698,15 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "inout"
+version = "0.2.0-rc.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1603f76010ff924b616c8f44815a42eb10fb0b93d308b41deaa8da6d4251fd4b"
+dependencies = [
+ "hybrid-array",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.13"
@@ -3785,7 +3908,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
 "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]

 [[package]]
@@ -4354,7 +4477,7 @@ version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
 dependencies = [
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 1.3.1",
 "proc-macro2",
 "quote",
 "syn 2.0.101",
@@ -6116,6 +6239,17 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"

+[[package]]
+name = "polyval"
+version = "0.7.0-rc.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffd40cc99d0fbb02b4b3771346b811df94194bc103983efa0203c8893755085"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "universal-hash",
+]
+
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"
@@ -6396,7 +6530,7 @@ dependencies = [
 "once_cell",
 "socket2",
 "tracing",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -7787,7 +7921,7 @@ dependencies = [
 "errno",
 "libc",
 "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -8178,7 +8312,7 @@ dependencies = [
 [[package]]
 name = "scroll-zkvm-prover"
 version = "0.6.0"
-source = "git+https://github.com/scroll-tech/zkvm-prover?rev=060be4c#060be4c0461b0a197c5be47fc74415165a0abe25"
+source = "git+https://github.com/scroll-tech/zkvm-prover?rev=894441f#894441f56fceb9d8b7acff28822cca0cccc3e38e"
 dependencies = [
 "base64 0.22.1",
 "bincode 1.3.3",
@@ -8205,7 +8339,7 @@ dependencies = [
 [[package]]
 name = "scroll-zkvm-types"
 version = "0.6.0"
-source = "git+https://github.com/scroll-tech/zkvm-prover?rev=060be4c#060be4c0461b0a197c5be47fc74415165a0abe25"
+source = "git+https://github.com/scroll-tech/zkvm-prover?rev=894441f#894441f56fceb9d8b7acff28822cca0cccc3e38e"
 dependencies = [
 "alloy-primitives",
 "base64 0.22.1",
@@ -8225,7 +8359,7 @@ dependencies = [
 [[package]]
 name = "scroll-zkvm-types-base"
 version = "0.6.0"
-source = "git+https://github.com/scroll-tech/zkvm-prover?rev=060be4c#060be4c0461b0a197c5be47fc74415165a0abe25"
+source = "git+https://github.com/scroll-tech/zkvm-prover?rev=894441f#894441f56fceb9d8b7acff28822cca0cccc3e38e"
 dependencies = [
 "alloy-primitives",
 "alloy-serde 1.0.30",
@@ -8238,7 +8372,7 @@ dependencies = [
 [[package]]
 name = "scroll-zkvm-types-batch"
 version = "0.6.0"
-source = "git+https://github.com/scroll-tech/zkvm-prover?rev=060be4c#060be4c0461b0a197c5be47fc74415165a0abe25"
+source = "git+https://github.com/scroll-tech/zkvm-prover?rev=894441f#894441f56fceb9d8b7acff28822cca0cccc3e38e"
 dependencies = [
 "alloy-primitives",
 "c-kzg",
@@ -8260,7 +8394,7 @@ dependencies = [
 [[package]]
 name = "scroll-zkvm-types-bundle"
 version = "0.6.0"
-source = "git+https://github.com/scroll-tech/zkvm-prover?rev=060be4c#060be4c0461b0a197c5be47fc74415165a0abe25"
+source = "git+https://github.com/scroll-tech/zkvm-prover?rev=894441f#894441f56fceb9d8b7acff28822cca0cccc3e38e"
 dependencies = [
 "rkyv",
 "scroll-zkvm-types-base",
@@ -8270,9 +8404,12 @@ dependencies = [
 [[package]]
 name = "scroll-zkvm-types-chunk"
 version = "0.6.0"
-source = "git+https://github.com/scroll-tech/zkvm-prover?rev=060be4c#060be4c0461b0a197c5be47fc74415165a0abe25"
+source = "git+https://github.com/scroll-tech/zkvm-prover?rev=894441f#894441f56fceb9d8b7acff28822cca0cccc3e38e"
 dependencies = [
 "alloy-primitives",
+ "alloy-sol-types",
+ "ecies",
+ "itertools 0.14.0",
 "rkyv",
 "sbv-core",
 "sbv-helpers",
@@ -8280,12 +8417,13 @@ dependencies = [
 "sbv-trie",
 "scroll-zkvm-types-base",
 "serde",
+ "thiserror 2.0.12",
 ]

 [[package]]
 name = "scroll-zkvm-verifier"
 version = "0.6.0"
-source = "git+https://github.com/scroll-tech/zkvm-prover?rev=060be4c#060be4c0461b0a197c5be47fc74415165a0abe25"
+source = "git+https://github.com/scroll-tech/zkvm-prover?rev=894441f#894441f56fceb9d8b7acff28822cca0cccc3e38e"
 dependencies = [
 "bincode 1.3.3",
 "eyre",
@@ -8806,7 +8944,7 @@ dependencies = [
 "cfg-if",
 "libc",
 "psm",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -8942,9 +9080,9 @@ dependencies = [

 [[package]]
 name = "syn-solidity"
-version = "1.2.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9ac494e7266fcdd2ad80bf4375d55d27a117ea5c866c26d0e97fe5b3caeeb75"
+checksum = "a0b198d366dbec045acfcd97295eb653a7a2b40e4dc764ef1e79aafcad439d3c"
 dependencies = [
 "paste",
 "proc-macro2",
@@ -9036,7 +9174,7 @@ dependencies = [
 "getrandom 0.3.3",
 "once_cell",
 "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -9607,6 +9745,16 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

+[[package]]
+name = "universal-hash"
+version = "0.6.0-rc.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a55be643b40a21558f44806b53ee9319595bc7ca6896372e4e08e5d7d83c9cd6"
+dependencies = [
+ "crypto-common 0.2.0-rc.4",
+ "subtle",
+]
+
 [[package]]
 name = "unroll"
 version = "0.1.5"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,9 +17,9 @@ repository = "https://github.com/scroll-tech/scroll"
 version = "4.5.47"

 [workspace.dependencies]
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "060be4c" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "060be4c" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "060be4c" }
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "894441f" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "894441f" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "894441f" }

 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" }
--- a/common/types/message/message.go
+++ b/common/types/message/message.go
@@ -39,10 +39,12 @@ const (

 // ChunkTaskDetail is a type containing ChunkTask detail for chunk task.
 type ChunkTaskDetail struct {
+	Version uint8 `json:"version"`
 	// use one of the string of "euclidv1" / "euclidv2"
 	ForkName         string        `json:"fork_name"`
 	BlockHashes      []common.Hash `json:"block_hashes"`
 	PrevMsgQueueHash common.Hash   `json:"prev_msg_queue_hash"`
+	PostMsgQueueHash common.Hash   `json:"post_msg_queue_hash"`
 }

 // it is a hex encoded big with fixed length on 48 bytes
@@ -90,40 +92,60 @@ func (e *Byte48) UnmarshalJSON(input []byte) error {

 // BatchTaskDetail is a type containing BatchTask detail.
 type BatchTaskDetail struct {
+	Version uint8 `json:"version"`
 	// use one of the string of "euclidv1" / "euclidv2"
-	ForkName        string              `json:"fork_name"`
-	ChunkInfos      []*ChunkInfo        `json:"chunk_infos"`
-	ChunkProofs     []*OpenVMChunkProof `json:"chunk_proofs"`
-	BatchHeader     interface{}         `json:"batch_header"`
-	BlobBytes       []byte              `json:"blob_bytes"`
-	KzgProof        Byte48              `json:"kzg_proof,omitempty"`
-	KzgCommitment   Byte48              `json:"kzg_commitment,omitempty"`
-	ChallengeDigest common.Hash         `json:"challenge_digest,omitempty"`
+	ForkName      string              `json:"fork_name"`
+	ChunkInfos    []*ChunkInfo        `json:"chunk_infos"`
+	ChunkProofs   []*OpenVMChunkProof `json:"chunk_proofs"`
+	BatchHeader   interface{}         `json:"batch_header"`
+	BlobBytes     []byte              `json:"blob_bytes"`
+	KzgProof      *Byte48             `json:"kzg_proof,omitempty"`
+	KzgCommitment *Byte48             `json:"kzg_commitment,omitempty"`
+	// ChallengeDigest should be a common.Hash type if it is not nil
+	ChallengeDigest interface{} `json:"challenge_digest,omitempty"`
 }

 // BundleTaskDetail consists of all the information required to describe the task to generate a proof for a bundle of batches.
 type BundleTaskDetail struct {
+	Version uint8 `json:"version"`
 	// use one of the string of "euclidv1" / "euclidv2"
 	ForkName    string              `json:"fork_name"`
 	BatchProofs []*OpenVMBatchProof `json:"batch_proofs"`
 	BundleInfo  *OpenVMBundleInfo   `json:"bundle_info,omitempty"`
 }

+type RawBytes []byte
+
+func (r RawBytes) MarshalJSON() ([]byte, error) {
+	if r == nil {
+		return []byte("null"), nil
+	}
+	// Marshal the []byte as a JSON array of numbers
+	rn := make([]uint16, len(r))
+	for i := range r {
+		rn[i] = uint16(r[i])
+	}
+	return json.Marshal(rn)
+}
+
 // ChunkInfo is for calculating pi_hash for chunk
 type ChunkInfo struct {
-	ChainID            uint64           `json:"chain_id"`
-	PrevStateRoot      common.Hash      `json:"prev_state_root"`
-	PostStateRoot      common.Hash      `json:"post_state_root"`
-	WithdrawRoot       common.Hash      `json:"withdraw_root"`
-	DataHash           common.Hash      `json:"data_hash"`
-	IsPadding          bool             `json:"is_padding"`
-	TxBytes            []byte           `json:"tx_bytes"`
+	ChainID       uint64      `json:"chain_id"`
+	PrevStateRoot common.Hash `json:"prev_state_root"`
+	PostStateRoot common.Hash `json:"post_state_root"`
+	WithdrawRoot  common.Hash `json:"withdraw_root"`
+	DataHash      common.Hash `json:"data_hash"`
+	IsPadding     bool        `json:"is_padding"`
+	//	TxBytes            []byte           `json:"tx_bytes"`
 	TxBytesHash        common.Hash      `json:"tx_data_digest"`
 	PrevMsgQueueHash   common.Hash      `json:"prev_msg_queue_hash"`
 	PostMsgQueueHash   common.Hash      `json:"post_msg_queue_hash"`
 	TxDataLength       uint64           `json:"tx_data_length"`
 	InitialBlockNumber uint64           `json:"initial_block_number"`
 	BlockCtxs          []BlockContextV2 `json:"block_ctxs"`
+	PrevBlockhash      common.Hash      `json:"prev_blockhash"`
+	PostBlockhash      common.Hash      `json:"post_blockhash"`
+	EncryptionKey      RawBytes         `json:"encryption_key"`
 }

 // BlockContextV2 is the block context for euclid v2
@@ -186,6 +208,7 @@ type OpenVMBatchInfo struct {
 	ChainID          uint64      `json:"chain_id"`
 	PrevMsgQueueHash common.Hash `json:"prev_msg_queue_hash"`
 	PostMsgQueueHash common.Hash `json:"post_msg_queue_hash"`
+	EncryptionKey    RawBytes    `json:"encryption_key"`
 }

 // BatchProof includes the proof info that are required for batch verification and rollup.
@@ -246,6 +269,7 @@ type OpenVMBundleInfo struct {
 	PrevBatchHash common.Hash `json:"prev_batch_hash"`
 	BatchHash     common.Hash `json:"batch_hash"`
 	MsgQueueHash  common.Hash `json:"msg_queue_hash"`
+	EncryptionKey RawBytes    `json:"encryption_key"`
 }

 // OpenVMBundleProof includes the proof info that are required for verification of a bundle of batch proofs.
--- a/common/version/version.go
+++ b/common/version/version.go
@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )

-var tag = "v4.5.47"
+var tag = "v4.6.3"

 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {
--- a/coordinator/Makefile
+++ b/coordinator/Makefile
@@ -36,7 +36,7 @@ coordinator_tool:

 localsetup: coordinator_api ## Local setup: build coordinator_api, copy config, and setup releases
 	@echo "Copying configuration files..."
-	cp -r $(PWD)/conf $(PWD)/build/bin/
+	cp -r $(PWD)/conf/config.json $(PWD)/build/bin/conf/config.template.json
 	@echo "Setting up releases..."
 	cd $(PWD)/build && bash setup_releases.sh

--- a/coordinator/build/setup_releases.sh
+++ b/coordinator/build/setup_releases.sh
@@ -53,6 +53,7 @@ for ((i=0; i<$VERIFIER_COUNT; i++)); do
  # assets for verifier-only mode
  echo "Downloading assets for $FORK_NAME to $ASSET_DIR..."
  wget https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/$SCROLL_ZKVM_VERSION/verifier/verifier.bin -O ${ASSET_DIR}/verifier.bin
+  wget https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/$SCROLL_ZKVM_VERSION/verifier/root_verifier_vk -O ${ASSET_DIR}/root_verifier_vk
  wget https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/$SCROLL_ZKVM_VERSION/verifier/openVmVk.json -O ${ASSET_DIR}/openVmVk.json
  
  echo "Completed downloading assets for $FORK_NAME"
--- a/coordinator/cmd/tool/verify.go
+++ b/coordinator/cmd/tool/verify.go
@@ -36,7 +36,7 @@ func verify(cCtx *cli.Context) error {
 		return fmt.Errorf("error reading file: %w", err)
 	}

-	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier)
+	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier, cfg.L2.ValidiumMode)
 	if err != nil {
 		return err
 	}
--- a/coordinator/conf/config.json
+++ b/coordinator/conf/config.json
@@ -10,11 +10,7 @@
      "min_prover_version": "v4.4.45",
      "verifiers": [
        {
-          "assets_path": "assets",
-          "fork_name": "euclidV2"
-        },        
-        {
-          "assets_path": "assets",
+          "assets_path": "cloak",
          "fork_name": "feynman"
        }
      ]
@@ -22,19 +18,23 @@
  },
  "db": {
    "driver_name": "postgres",
-    "dsn": "postgres://localhost/scroll?sslmode=disable",
+    "dsn": "postgres://dev:dev@localhost/scroll?sslmode=disable",
    "maxOpenNum": 200,
    "maxIdleNum": 20
  },
  "l2": {
-    "chain_id": 111,
+    "validium_mode": true,
+    "chain_id": 5343513301,
    "l2geth": {
-      "endpoint": "not need to specified for mocking"
+      "endpoint": "http://cloak-xen-sequencer.sepolia.scroll.tech:8545/"
    }
  },
  "auth": {
    "secret": "prover secret key",
    "challenge_expire_duration_sec": 3600,
    "login_expire_duration_sec": 3600
+  },
+  "sequencer": {
+    "decryption_key": "sequencer decryption key"
  }
 }
--- a/coordinator/internal/config/config.go
+++ b/coordinator/internal/config/config.go
@@ -36,8 +36,9 @@ type L2Endpoint struct {
 // L2 loads l2geth configuration items.
 type L2 struct {
 	// l2geth chain_id.
-	ChainID  uint64      `json:"chain_id"`
-	Endpoint *L2Endpoint `json:"l2geth"`
+	ChainID      uint64      `json:"chain_id"`
+	Endpoint     *L2Endpoint `json:"l2geth"`
+	ValidiumMode bool        `json:"validium_mode"`
 }

 // Auth provides the auth coordinator
@@ -47,17 +48,24 @@ type Auth struct {
 	LoginExpireDurationSec     int    `json:"login_expire_duration_sec"`
 }

+// The sequencer controlled data
+type Sequencer struct {
+	DecryptionKey string `json:"decryption_key"`
+}
+
 // Config load configuration items.
 type Config struct {
 	ProverManager *ProverManager   `json:"prover_manager"`
 	DB            *database.Config `json:"db"`
 	L2            *L2              `json:"l2"`
 	Auth          *Auth            `json:"auth"`
+	Sequencer     *Sequencer       `json:"sequencer"`
 }

 // AssetConfig contain assets configurated for each fork, the defaul vkfile name is "OpenVmVk.json".
 type AssetConfig struct {
 	AssetsPath       string `json:"assets_path"`
+	Version          uint8  `json:"version,omitempty"`
 	ForkName         string `json:"fork_name"`
 	Vkfile           string `json:"vk_file,omitempty"`
 	MinProverVersion string `json:"min_prover_version,omitempty"`
--- a/coordinator/internal/config/config_test.go
+++ b/coordinator/internal/config/config_test.go
@@ -35,13 +35,17 @@ func TestConfig(t *testing.T) {
 			"maxIdleNum": 20
 		},
 		"l2": {
-			"chain_id": 111
+			"chain_id": 111,
+			"validium_mode": false
 		},
 		"auth": {
 			"secret": "prover secret key",
 			"challenge_expire_duration_sec": 3600,
 			"login_expire_duration_sec": 3600
-  		}
+  		},
+    	"sequencer": {
+     		"decryption_key": "sequencer decryption key"
+     	}
 	}`

 	t.Run("Success Case", func(t *testing.T) {
--- a/coordinator/internal/controller/api/controller.go
+++ b/coordinator/internal/controller/api/controller.go
@@ -24,7 +24,9 @@ var (

 // InitController inits Controller with database
 func InitController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) {
-	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier)
+	validiumMode := cfg.L2.ValidiumMode
+
+	vf, err := verifier.NewVerifier(cfg.ProverManager.Verifier, validiumMode)
 	if err != nil {
 		panic("proof receiver new verifier failure")
 	}
--- a/coordinator/internal/logic/libzkp/lib.go
+++ b/coordinator/internal/logic/libzkp/lib.go
@@ -93,8 +93,8 @@ func fromMessageTaskType(taskType int) int {
 }

 // Generate a universal task
-func GenerateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte) (bool, string, string, []byte) {
-	return generateUniversalTask(fromMessageTaskType(taskType), taskJSON, strings.ToLower(forkName), expectedVk)
+func GenerateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte, decryptionKey []byte) (bool, string, string, []byte) {
+	return generateUniversalTask(fromMessageTaskType(taskType), taskJSON, strings.ToLower(forkName), expectedVk, decryptionKey)
 }

 // Generate wrapped proof
--- a/coordinator/internal/logic/libzkp/libzkp.h
+++ b/coordinator/internal/logic/libzkp/libzkp.h
@@ -40,7 +40,9 @@ HandlingResult gen_universal_task(
    char* task,
    char* fork_name,
    const unsigned char* expected_vk,
-    size_t expected_vk_len
+    size_t expected_vk_len,
+    const unsigned char* decryption_key,
+    size_t decryption_key_len
 );

 // Release memory allocated for a HandlingResult returned by gen_universal_task
--- a/coordinator/internal/logic/libzkp/mock_universal_task.go
+++ b/coordinator/internal/logic/libzkp/mock_universal_task.go
@@ -14,7 +14,7 @@ import (
 func InitL2geth(configJSON string) {
 }

-func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte) (bool, string, string, []byte) {
+func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte, decryptionKey []byte) (bool, string, string, []byte) {

 	fmt.Printf("call mocked generate universal task %d, taskJson %s\n", taskType, taskJSON)
 	var metadata interface{}
--- a/coordinator/internal/logic/libzkp/universal_task.go
+++ b/coordinator/internal/logic/libzkp/universal_task.go
@@ -17,7 +17,7 @@ func InitL2geth(configJSON string) {
 	C.init_l2geth(cConfig)
 }

-func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte) (bool, string, string, []byte) {
+func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk []byte, decryptionKey []byte) (bool, string, string, []byte) {
 	cTask := goToCString(taskJSON)
 	cForkName := goToCString(forkName)
 	defer freeCString(cTask)
@@ -29,7 +29,13 @@ func generateUniversalTask(taskType int, taskJSON, forkName string, expectedVk [
 		cVk = (*C.uchar)(unsafe.Pointer(&expectedVk[0]))
 	}

-	result := C.gen_universal_task(C.int(taskType), cTask, cForkName, cVk, C.size_t(len(expectedVk)))
+	// Create a C array from Go slice
+	var cDk *C.uchar
+	if len(decryptionKey) > 0 {
+		cDk = (*C.uchar)(unsafe.Pointer(&decryptionKey[0]))
+	}
+
+	result := C.gen_universal_task(C.int(taskType), cTask, cForkName, cVk, C.size_t(len(expectedVk)), cDk, C.size_t(len(decryptionKey)))
 	defer C.release_task_result(result)

 	// Check if the operation was successful
--- a/coordinator/internal/logic/provertask/batch_prover_task.go
+++ b/coordinator/internal/logic/provertask/batch_prover_task.go
@@ -269,6 +269,7 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 			InitialBlockNumber: proof.MetaData.ChunkInfo.InitialBlockNumber,
 			BlockCtxs:          proof.MetaData.ChunkInfo.BlockCtxs,
 			TxDataLength:       proof.MetaData.ChunkInfo.TxDataLength,
+			EncryptionKey:      proof.MetaData.ChunkInfo.EncryptionKey,
 		}
 		chunkInfos = append(chunkInfos, &chunkInfo)
 	}
@@ -278,7 +279,7 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		return nil, fmt.Errorf("failed to get batch task detail, taskID:%s err:%w", task.TaskID, err)
 	}

-	chunkProofsBytes, err := json.Marshal(taskDetail)
+	taskBytesWithchunkProofs, err := json.Marshal(taskDetail)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal chunk proofs, taskID:%s err:%w", task.TaskID, err)
 	}
@@ -286,7 +287,7 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	taskMsg := &coordinatorType.GetTaskSchema{
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeBatch),
-		TaskData:     string(chunkProofsBytes),
+		TaskData:     string(taskBytesWithchunkProofs),
 		HardForkName: hardForkName,
 	}

@@ -302,37 +303,56 @@ func (bp *BatchProverTask) recoverActiveAttempts(ctx *gin.Context, batchTask *or
 }

 func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*message.ChunkInfo, chunkProofs []*message.OpenVMChunkProof, hardForkName string) (*message.BatchTaskDetail, error) {
+	// Get the version byte.
+	version, err := bp.version(hardForkName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode version byte: %w", err)
+	}
+
 	taskDetail := &message.BatchTaskDetail{
+		Version:     version,
 		ChunkInfos:  chunkInfos,
 		ChunkProofs: chunkProofs,
 		ForkName:    hardForkName,
 	}

-	dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
-	switch dbBatchCodecVersion {
-	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7, encoding.CodecV8:
-	default:
-		return taskDetail, nil
-	}
-
-	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
-	if err != nil {
-		return nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
-	}
-
-	batchHeader, decodeErr := codec.NewDABatchFromBytes(dbBatch.BatchHeader)
-	if decodeErr != nil {
-		return nil, fmt.Errorf("failed to decode batch header version %d: %w", dbBatch.CodecVersion, decodeErr)
-	}
-	taskDetail.BatchHeader = batchHeader
 	taskDetail.BlobBytes = dbBatch.BlobBytes
-	taskDetail.ChallengeDigest = common.HexToHash(dbBatch.ChallengeDigest)
-	// Memory layout of `BlobDataProof`: used in Codec.BlobDataProofForPointEvaluation()
-	// | z       | y       | kzg_commitment | kzg_proof |
-	// |---------|---------|----------------|-----------|
-	// | bytes32 | bytes32 | bytes48        | bytes48   |
-	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]))}
+	if !bp.validiumMode() {
+		dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
+		switch dbBatchCodecVersion {
+		case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7, encoding.CodecV8:
+		default:
+			return taskDetail, nil
+		}
+
+		codec, err := encoding.CodecFromVersion(encoding.CodecVersion(dbBatch.CodecVersion))
+		if err != nil {
+			return nil, fmt.Errorf("failed to get codec from version %d, err: %w", dbBatch.CodecVersion, err)
+		}
+
+		batchHeader, decodeErr := codec.NewDABatchFromBytes(dbBatch.BatchHeader)
+		if decodeErr != nil {
+			return nil, fmt.Errorf("failed to decode batch header version %d: %w", dbBatch.CodecVersion, decodeErr)
+		}
+		taskDetail.BatchHeader = batchHeader
+
+		taskDetail.ChallengeDigest = common.HexToHash(dbBatch.ChallengeDigest)
+		// Memory layout of `BlobDataProof`: used in Codec.BlobDataProofForPointEvaluation()
+		// | z       | y       | kzg_commitment | kzg_proof |
+		// |---------|---------|----------------|-----------|
+		// | bytes32 | bytes32 | bytes48        | bytes48   |
+		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")
+		codec := cutils.FromVersion(version)
+		batchHeader, decodeErr := codec.DABatchForTaskFromBytes(dbBatch.BatchHeader)
+		if decodeErr != nil {
+			return nil, fmt.Errorf("failed to decode batch header version %d: %w", dbBatch.CodecVersion, decodeErr)
+		}
+		batchHeader.SetHash(common.HexToHash(dbBatch.Hash))
+		taskDetail.BatchHeader = batchHeader
+	}

 	return taskDetail, nil
 }
--- a/coordinator/internal/logic/provertask/bundle_prover_task.go
+++ b/coordinator/internal/logic/provertask/bundle_prover_task.go
@@ -265,7 +265,14 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 		batchProofs = append(batchProofs, &proof)
 	}

+	// Get the version byte.
+	version, err := bp.version(hardForkName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode version byte: %w", err)
+	}
+
 	taskDetail := message.BundleTaskDetail{
+		Version:     version,
 		BatchProofs: batchProofs,
 		ForkName:    hardForkName,
 	}
--- a/coordinator/internal/logic/provertask/chunk_prover_task.go
+++ b/coordinator/internal/logic/provertask/chunk_prover_task.go
@@ -237,14 +237,21 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 		return nil, fmt.Errorf("failed to fetch block hashes of a chunk, chunk hash:%s err:%v", task.TaskID, dbErr)
 	}

+	// Get the version byte.
+	version, err := cp.version(hardForkName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode version byte: %w", err)
+	}
+
 	var taskDetailBytes []byte
 	taskDetail := message.ChunkTaskDetail{
+		Version:          version,
 		BlockHashes:      blockHashes,
 		PrevMsgQueueHash: common.HexToHash(chunk.PrevL1MessageQueueHash),
+		PostMsgQueueHash: common.HexToHash(chunk.PostL1MessageQueueHash),
 		ForkName:         hardForkName,
 	}

-	var err error
 	taskDetailBytes, err = json.Marshal(taskDetail)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal block hashes hash:%s, err:%w", task.TaskID, err)
--- a/coordinator/internal/logic/provertask/prover_task.go
+++ b/coordinator/internal/logic/provertask/prover_task.go
@@ -1,6 +1,7 @@
 package provertask

 import (
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"strings"
@@ -19,6 +20,7 @@ import (
 	"scroll-tech/coordinator/internal/logic/libzkp"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
+	"scroll-tech/coordinator/internal/utils"
 )

 var (
@@ -65,6 +67,17 @@ type proverTaskContext struct {
 	hasAssignedTask *orm.ProverTask
 }

+func (b *BaseProverTask) version(hardForkName string) (uint8, error) {
+	return utils.Version(hardForkName, b.validiumMode())
+}
+
+// validiumMode induce different behavior in task generation:
+// + skip the point_evaluation part in batch task
+// + encode batch header with codec in utils instead of da-codec
+func (b *BaseProverTask) validiumMode() bool {
+	return b.cfg.L2.ValidiumMode
+}
+
 // hardForkName get the chunk/batch/bundle hard fork name
 func (b *BaseProverTask) hardForkName(ctx *gin.Context, taskCtx *proverTaskContext) (string, error) {
 	switch {
@@ -192,7 +205,12 @@ func (b *BaseProverTask) applyUniversal(schema *coordinatorType.GetTaskSchema) (
 		return nil, nil, fmt.Errorf("no expectedVk found from hardfork %s", schema.HardForkName)
 	}

-	ok, uTaskData, metadata, _ := libzkp.GenerateUniversalTask(schema.TaskType, schema.TaskData, schema.HardForkName, expectedVk)
+	decryptionKey, err := hex.DecodeString(b.cfg.Sequencer.DecryptionKey)
+	if err != nil {
+		return nil, nil, fmt.Errorf("sequencer decryption key hex-decoding failed")
+	}
+
+	ok, uTaskData, metadata, _ := libzkp.GenerateUniversalTask(schema.TaskType, schema.TaskData, schema.HardForkName, expectedVk, decryptionKey)
 	if !ok {
 		return nil, nil, fmt.Errorf("can not generate universal task, see coordinator log for the reason")
 	}
--- a/coordinator/internal/logic/submitproof/proof_receiver.go
+++ b/coordinator/internal/logic/submitproof/proof_receiver.go
@@ -219,6 +219,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 		if unmarshalErr := json.Unmarshal([]byte(proofParameter.Proof), &chunkProof); unmarshalErr != nil {
 			return unmarshalErr
 		}
+		log.Info("parse chunkproof", "key", chunkProof.MetaData.ChunkInfo.EncryptionKey)
 		success, verifyErr = m.verifier.VerifyChunkProof(chunkProof, hardForkName)
 		if stat := chunkProof.VmProof.Stat; stat != nil {
 			if g, _ := m.proverSpeed.GetMetricWithLabelValues("chunk", "exec"); g != nil && stat.ExecutionTimeMills > 0 {
--- a/coordinator/internal/logic/verifier/verifier.go
+++ b/coordinator/internal/logic/verifier/verifier.go
@@ -19,20 +19,34 @@ import (

 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/logic/libzkp"
+	"scroll-tech/coordinator/internal/utils"
 )

 // This struct maps to `CircuitConfig` in libzkp/src/verifier.rs
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.CircuitConfig` being changed
 type rustCircuitConfig struct {
+	Version    uint   `json:"version"`
 	ForkName   string `json:"fork_name"`
 	AssetsPath string `json:"assets_path"`
 }

+var validiumMode bool
+
 func newRustCircuitConfig(cfg config.AssetConfig) *rustCircuitConfig {
+	ver := cfg.Version
+	if ver == 0 {
+		var err error
+		ver, err = utils.Version(cfg.ForkName, validiumMode)
+		if err != nil {
+			panic(err)
+		}
+	}
+
 	return &rustCircuitConfig{
-		ForkName:   cfg.ForkName,
+		Version:    uint(ver),
 		AssetsPath: cfg.AssetsPath,
+		ForkName:   cfg.ForkName,
 	}
 }

@@ -60,7 +74,8 @@ type rustVkDump struct {
 }

 // NewVerifier Sets up a rust ffi to call verify.
-func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
+func NewVerifier(cfg *config.VerifierConfig, useValidiumMode bool) (*Verifier, error) {
+	validiumMode = useValidiumMode
 	verifierConfig := newRustVerifierConfig(cfg)
 	configBytes, err := json.Marshal(verifierConfig)
 	if err != nil {
--- a/coordinator/internal/utils/codec_validium.go
+++ b/coordinator/internal/utils/codec_validium.go
@@ -0,0 +1,92 @@
+package utils
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/scroll-tech/go-ethereum/common"
+)
+
+type CodecVersion uint8
+
+const (
+	daBatchValidiumEncodedLength = 137
+)
+
+type DABatch interface {
+	SetHash(common.Hash)
+}
+
+type daBatchValidiumV1 struct {
+	Version           CodecVersion `json:"version"`
+	BatchIndex        uint64       `json:"batch_index"`
+	BlobVersionedHash common.Hash  `json:"blob_versioned_hash"`
+	ParentBatchHash   common.Hash  `json:"parent_batch_hash"`
+	PostStateRoot     common.Hash  `json:"post_state_root"`
+	WithDrawRoot      common.Hash  `json:"withdraw_root"`
+	Commitment        common.Hash  `json:"commitment"`
+}
+
+type daBatchValidium struct {
+	V1        *daBatchValidiumV1 `json:"V1,omitempty"`
+	BatchHash common.Hash        `json:"batch_hash"`
+}
+
+func (da *daBatchValidium) SetHash(h common.Hash) {
+	da.BatchHash = h
+}
+
+func FromVersion(v uint8) CodecVersion {
+	return CodecVersion(v & STFVersionMask)
+}
+
+func (c CodecVersion) DABatchForTaskFromBytes(b []byte) (DABatch, error) {
+	switch c {
+	case 1:
+		if v1, err := decodeDABatchV1(b); err == nil {
+			return &daBatchValidium{
+				V1: v1,
+			}, nil
+		} else {
+			return nil, err
+		}
+	default:
+		return nil, fmt.Errorf("unknown codec type %d", c)
+	}
+}
+
+func decodeDABatchV1(data []byte) (*daBatchValidiumV1, error) {
+	if len(data) != daBatchValidiumEncodedLength {
+		return nil, fmt.Errorf("invalid data length for DABatchV7, expected %d bytes but got %d", daBatchValidiumEncodedLength, len(data))
+	}
+
+	const (
+		versionSize = 1
+		indexSize   = 8
+		hashSize    = 32
+	)
+
+	// Offsets (same as encodeBatchHeaderValidium)
+	versionOffset := 0
+	indexOffset := versionOffset + versionSize
+	parentHashOffset := indexOffset + indexSize
+	stateRootOffset := parentHashOffset + hashSize
+	withdrawRootOffset := stateRootOffset + hashSize
+	commitmentOffset := withdrawRootOffset + hashSize
+
+	version := CodecVersion(data[versionOffset])
+	batchIndex := binary.BigEndian.Uint64(data[indexOffset : indexOffset+indexSize])
+	parentBatchHash := common.BytesToHash(data[parentHashOffset : parentHashOffset+hashSize])
+	postStateRoot := common.BytesToHash(data[stateRootOffset : stateRootOffset+hashSize])
+	withdrawRoot := common.BytesToHash(data[withdrawRootOffset : withdrawRootOffset+hashSize])
+	commitment := common.BytesToHash(data[commitmentOffset : commitmentOffset+hashSize])
+
+	return &daBatchValidiumV1{
+		Version:         version,
+		BatchIndex:      batchIndex,
+		ParentBatchHash: parentBatchHash,
+		PostStateRoot:   postStateRoot,
+		WithDrawRoot:    withdrawRoot,
+		Commitment:      commitment,
+	}, nil
+}
--- a/coordinator/internal/utils/version.go
+++ b/coordinator/internal/utils/version.go
@@ -0,0 +1,38 @@
+package utils
+
+import (
+	"errors"
+	"strings"
+)
+
+const (
+	DomainOffset   = 6
+	STFVersionMask = (1 << DomainOffset) - 1
+)
+
+// version get the version for the chain instance
+//
+// TODO: This is not foolproof and does not cover all scenarios.
+func Version(hardForkName string, ValidiumMode bool) (uint8, error) {
+
+	var domain, stfVersion uint8
+
+	if ValidiumMode {
+		domain = 1
+		stfVersion = 1
+	} else {
+		domain = 0
+		switch canonicalName := strings.ToLower(hardForkName); canonicalName {
+		case "euclidv1":
+			stfVersion = 6
+		case "euclidv2":
+			stfVersion = 7
+		case "feynman":
+			stfVersion = 8
+		default:
+			return 0, errors.New("unknown fork name " + canonicalName)
+		}
+	}
+
+	return (domain << DomainOffset) + stfVersion, nil
+}
--- a/crates/l2geth/src/rpc_client.rs
+++ b/crates/l2geth/src/rpc_client.rs
@@ -5,7 +5,7 @@ use alloy::{
 };
 use eyre::Result;
 use libzkp::tasks::ChunkInterpreter;
-use sbv_primitives::types::Network;
+use sbv_primitives::types::{consensus::TxL1Message, Network};
 use serde::{Deserialize, Serialize};

 fn default_max_retry() -> u32 {
@@ -168,6 +168,40 @@ impl<T: Provider<Network>> ChunkInterpreter for RpcClient<'_, T> {
        self.handle
            .block_on(fetch_storage_node_async(&self.provider, node_hash))
    }
+
+    fn try_fetch_l1_msgs(&self, block_number: u64) -> Result<Vec<TxL1Message>> {
+        async fn fetch_l1_msgs(
+            provider: impl Provider<Network>,
+            block_number: u64,
+        ) -> Result<Vec<TxL1Message>> {
+            let block_number_hex = format!("0x{:x}", block_number);
+
+            #[derive(Deserialize, Debug)]
+            #[serde(untagged)]
+            enum NullOrVec {
+                Null,                  // matches JSON `null`
+                Vec(Vec<TxL1Message>), // matches JSON array
+            }
+
+            Ok(
+                match provider
+                    .client()
+                    .request::<_, NullOrVec>(
+                        "scroll_getL1MessagesInBlock",
+                        (block_number_hex, "synced"),
+                    )
+                    .await?
+                {
+                    NullOrVec::Null => Vec::new(),
+                    NullOrVec::Vec(r) => r,
+                },
+            )
+        }
+
+        tracing::debug!("fetch L1 msgs for {block_number}");
+        self.handle
+            .block_on(fetch_l1_msgs(&self.provider, block_number))
+    }
 }

 #[cfg(test)]
@@ -218,4 +252,16 @@ mod tests {

        println!("{}", serde_json::to_string_pretty(&wit2).unwrap());
    }
+
+    #[test]
+    #[ignore = "Requires L2GETH_ENDPOINT environment variable"]
+    fn test_try_fetch_l1_messages() {
+        let config = create_config_from_env();
+        let client_core = RpcClientCore::create(&config).expect("Failed to create RPC client");
+        let client = client_core.get_client();
+
+        let msgs = client.try_fetch_l1_msgs(32).expect("should success");
+
+        println!("{}", serde_json::to_string_pretty(&msgs).unwrap());
+    }
 }
--- a/crates/libzkp/src/lib.rs
+++ b/crates/libzkp/src/lib.rs
@@ -13,10 +13,13 @@ 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() -> bool {
    unsafe { LEGACY_WITNESS_ENCODING }
 }

+pub const VALIDIUM_VERSION: u8 = 0b01000001;
+
 pub fn set_dynamic_feature(feats: &str) {
    for feat_s in feats.split(':') {
        match feat_s.trim().to_lowercase().as_str() {
@@ -36,14 +39,13 @@ pub fn set_dynamic_feature(feats: &str) {
 /// task (with full witnesses)
 pub fn checkout_chunk_task(
    task_json: &str,
+    decryption_key: Option<&[u8]>,
    interpreter: impl ChunkInterpreter,
 ) -> eyre::Result<String> {
    let chunk_task = serde_json::from_str::<tasks::ChunkTask>(task_json)?;
-    let ret = serde_json::to_string(&tasks::ChunkProvingTask::try_from_with_interpret(
-        chunk_task,
-        interpreter,
-    )?)?;
-    Ok(ret)
+    Ok(serde_json::to_string(
+        &tasks::ChunkProvingTask::try_from_with_interpret(chunk_task, decryption_key, interpreter)?,
+    )?)
 }

 /// Generate required staff for proving tasks
--- a/crates/libzkp/src/proofs.rs
+++ b/crates/libzkp/src/proofs.rs
@@ -8,9 +8,10 @@ use scroll_zkvm_types::{
    bundle::BundleInfo,
    chunk::ChunkInfo,
    proof::{EvmProof, OpenVmEvmProof, ProofEnum, StarkProof},
-    public_inputs::{ForkName, MultiVersionPublicInputs},
+    public_inputs::MultiVersionPublicInputs,
    types_agg::AggregationInput,
    utils::{serialize_vk, vec_as_base64},
+    version,
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};

@@ -181,13 +182,13 @@ impl<Metadata: ProofMetadata> WrappedProof<Metadata> {
    /// Sanity checks on the wrapped proof:
    ///
    /// - pi_hash computed in host does in fact match pi_hash computed in guest
-    pub fn pi_hash_check(&self, fork_name: ForkName) -> bool {
+    pub fn pi_hash_check(&self, ver: version::Version) -> bool {
        let proof_pi = self.proof.public_values();

        let expected_pi = self
            .metadata
            .pi_hash_info()
-            .pi_hash_by_fork(fork_name)
+            .pi_hash_by_version(ver)
            .0
            .as_ref()
            .iter()
@@ -252,6 +253,7 @@ mod tests {
                batch_hash: B256::repeat_byte(4),
                withdraw_root: B256::repeat_byte(5),
                msg_queue_hash: B256::repeat_byte(6),
+                encryption_key: None,
            };
            let bundle_pi_hash = bundle_info.pi_hash(ForkName::EuclidV1);
            BundleProofMetadata {
--- a/crates/libzkp/src/tasks.rs
+++ b/crates/libzkp/src/tasks.rs
@@ -14,7 +14,7 @@ use crate::{
    utils::panic_catch,
 };
 use sbv_primitives::B256;
-use scroll_zkvm_types::public_inputs::{ForkName, MultiVersionPublicInputs};
+use scroll_zkvm_types::public_inputs::{ForkName, MultiVersionPublicInputs, Version};

 fn encode_task_to_witness<T: serde::Serialize>(task: &T) -> eyre::Result<Vec<u8>> {
    let config = bincode::config::standard();
@@ -23,7 +23,7 @@ fn encode_task_to_witness<T: serde::Serialize>(task: &T) -> eyre::Result<Vec<u8>

 fn check_aggregation_proofs<Metadata>(
    proofs: &[proofs::WrappedProof<Metadata>],
-    fork_name: ForkName,
+    version: Version,
 ) -> eyre::Result<()>
 where
    Metadata: proofs::ProofMetadata,
@@ -32,7 +32,7 @@ where
        for w in proofs.windows(2) {
            w[1].metadata
                .pi_hash_info()
-                .validate(w[0].metadata.pi_hash_info(), fork_name);
+                .validate(w[0].metadata.pi_hash_info(), version);
        }
    })
    .map_err(|e| eyre::eyre!("Chunk data validation failed: {}", e))?;
--- a/crates/libzkp/src/tasks/batch.rs
+++ b/crates/libzkp/src/tasks/batch.rs
@@ -1,21 +1,30 @@
-use crate::proofs::ChunkProof;
 use c_kzg::Bytes48;
 use eyre::Result;
 use sbv_primitives::{B256, U256};
 use scroll_zkvm_types::{
    batch::{
        build_point_eval_witness, BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchHeaderV8,
-        BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8, LegacyBatchWitness,
-        ReferenceHeader, N_BLOB_BYTES,
+        BatchHeaderValidium, BatchInfo, BatchWitness, Envelope, EnvelopeV6, EnvelopeV7, EnvelopeV8,
+        LegacyBatchWitness, ReferenceHeader, N_BLOB_BYTES,
    },
-    public_inputs::ForkName,
+    public_inputs::{ForkName, Version},
    task::ProvingTask,
    utils::{to_rkyv_bytes, RancorError},
+    version::{Domain, STFVersion},
 };

+use crate::proofs::ChunkProof;
+
 mod utils;
 use utils::{base64, point_eval};

+#[derive(Clone, serde::Deserialize, serde::Serialize)]
+pub struct BatchHeaderValidiumWithHash {
+    #[serde(flatten)]
+    header: BatchHeaderValidium,
+    batch_hash: B256,
+}
+
 /// Define variable batch header type, since BatchHeaderV6 can not
 /// be decoded as V7 we can always has correct deserialization
 /// Notice: V6 header MUST be put above V7 since untagged enum
@@ -23,6 +32,7 @@ use utils::{base64, point_eval};
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 #[serde(untagged)]
 pub enum BatchHeaderV {
+    Validium(BatchHeaderValidiumWithHash),
    V6(BatchHeaderV6),
    V7_8(BatchHeaderV7),
 }
@@ -32,6 +42,7 @@ impl BatchHeaderV {
        match self {
            BatchHeaderV::V6(h) => h.batch_hash(),
            BatchHeaderV::V7_8(h) => h.batch_hash(),
+            BatchHeaderV::Validium(h) => h.header.batch_hash(),
        }
    }

@@ -55,12 +66,21 @@ impl BatchHeaderV {
            _ => panic!("try to pick other header type"),
        }
    }
+
+    pub fn must_validium_header(&self) -> &BatchHeaderValidium {
+        match self {
+            BatchHeaderV::Validium(h) => &h.header,
+            _ => panic!("try to pick other header type"),
+        }
+    }
 }

 /// Defines a proving task for batch proof generation, the format
 /// is compatible with both pre-euclidv2 and euclidv2
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct BatchProvingTask {
+    /// The version of the chunks in the batch, as per [`Version`].
+    pub version: u8,
    /// Chunk proofs for the contiguous list of chunks within the batch.
    pub chunk_proofs: Vec<ChunkProof>,
    /// The [`BatchHeaderV6/V7`], as computed on-chain for this batch.
@@ -107,79 +127,116 @@ impl TryFrom<BatchProvingTask> for ProvingTask {

 impl BatchProvingTask {
    fn build_guest_input(&self) -> BatchWitness {
-        let fork_name = self.fork_name.to_lowercase().as_str().into();
+        let version = Version::from(self.version);

-        // sanity check: calculate point eval needed and compare with task input
-        let (kzg_commitment, kzg_proof, challenge_digest) = {
-            let blob = point_eval::to_blob(&self.blob_bytes);
-            let commitment = point_eval::blob_to_kzg_commitment(&blob);
-            let versioned_hash = point_eval::get_versioned_hash(&commitment);
-            let challenge_digest = match &self.batch_header {
-                BatchHeaderV::V6(_) => {
-                    assert_eq!(
-                        fork_name,
-                        ForkName::EuclidV1,
-                        "hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
-                        ForkName::EuclidV1,
-                    );
-                    EnvelopeV6::from_slice(self.blob_bytes.as_slice())
-                        .challenge_digest(versioned_hash)
-                }
-                BatchHeaderV::V7_8(_) => {
-                    let padded_blob_bytes = {
-                        let mut padded_blob_bytes = self.blob_bytes.to_vec();
-                        padded_blob_bytes.resize(N_BLOB_BYTES, 0);
-                        padded_blob_bytes
-                    };
-
-                    match fork_name {
-                        ForkName::EuclidV2 => {
-                            <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
-                                .challenge_digest(versioned_hash)
-                        }
-                        ForkName::Feynman => {
-                            <EnvelopeV8 as Envelope>::from_slice(padded_blob_bytes.as_slice())
-                                .challenge_digest(versioned_hash)
-                        }
-                        f => unreachable!(
-                            "hardfork mismatch for da-codec@v7 header: found={}, expected={:?}",
-                            f,
-                            [ForkName::EuclidV2, ForkName::Feynman],
-                        ),
+        let point_eval_witness = if !version.is_validium() {
+            // sanity check: calculate point eval needed and compare with task input
+            let (kzg_commitment, kzg_proof, challenge_digest) = {
+                let blob = point_eval::to_blob(&self.blob_bytes);
+                let commitment = point_eval::blob_to_kzg_commitment(&blob);
+                let versioned_hash = point_eval::get_versioned_hash(&commitment);
+                let challenge_digest = match &self.batch_header {
+                    BatchHeaderV::V6(_) => {
+                        assert_eq!(
+                            version.fork,
+                            ForkName::EuclidV1,
+                            "hardfork mismatch for da-codec@v6 header: found={:?}, expected={:?}",
+                            version.fork,
+                            ForkName::EuclidV1,
+                        );
+                        EnvelopeV6::from_slice(self.blob_bytes.as_slice())
+                            .challenge_digest(versioned_hash)
                    }
-                }
+                    BatchHeaderV::V7_8(_) => {
+                        let padded_blob_bytes = {
+                            let mut padded_blob_bytes = self.blob_bytes.to_vec();
+                            padded_blob_bytes.resize(N_BLOB_BYTES, 0);
+                            padded_blob_bytes
+                        };
+
+                        match version.fork {
+                            ForkName::EuclidV2 => {
+                                <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
+                                    .challenge_digest(versioned_hash)
+                            }
+                            ForkName::Feynman => {
+                                <EnvelopeV8 as Envelope>::from_slice(padded_blob_bytes.as_slice())
+                                    .challenge_digest(versioned_hash)
+                            }
+                            fork_name => unreachable!(
+                                "hardfork mismatch for da-codec@v7 header: found={}, expected={:?}",
+                                fork_name,
+                                [ForkName::EuclidV2, ForkName::Feynman],
+                            ),
+                        }
+                    }
+                    BatchHeaderV::Validium(_) => unreachable!("version!=validium"),
+                };
+
+                let (proof, _) = point_eval::get_kzg_proof(&blob, challenge_digest);
+
+                (commitment.to_bytes(), proof.to_bytes(), challenge_digest)
            };

-            let (proof, _) = point_eval::get_kzg_proof(&blob, challenge_digest);
+            if let Some(k) = self.kzg_commitment {
+                assert_eq!(k, kzg_commitment);
+            }

-            (commitment.to_bytes(), proof.to_bytes(), challenge_digest)
+            if let Some(c) = self.challenge_digest {
+                assert_eq!(c, U256::from_be_bytes(challenge_digest.0));
+            }
+
+            if let Some(p) = self.kzg_proof {
+                assert_eq!(p, kzg_proof);
+            }
+
+            Some(build_point_eval_witness(
+                kzg_commitment.into_inner(),
+                kzg_proof.into_inner(),
+            ))
+        } else {
+            assert!(self.kzg_proof.is_none(), "domain=validium has no blob-da");
+            assert!(
+                self.kzg_commitment.is_none(),
+                "domain=validium has no blob-da"
+            );
+            assert!(
+                self.challenge_digest.is_none(),
+                "domain=validium has no blob-da"
+            );
+
+            match &self.batch_header {
+                BatchHeaderV::Validium(h) => assert_eq!(
+                    h.header.batch_hash(),
+                    h.batch_hash,
+                    "calculated batch hash match which from coordinator"
+                ),
+                _ => panic!("unexpected header type"),
+            }
+            None
        };

-        if let Some(k) = self.kzg_commitment {
-            assert_eq!(k, kzg_commitment);
-        }
-
-        if let Some(c) = self.challenge_digest {
-            assert_eq!(c, U256::from_be_bytes(challenge_digest.0));
-        }
-
-        if let Some(p) = self.kzg_proof {
-            assert_eq!(p, kzg_proof);
-        }
-
-        let point_eval_witness = Some(build_point_eval_witness(
-            kzg_commitment.into_inner(),
-            kzg_proof.into_inner(),
-        ));
-
-        let reference_header = match fork_name {
-            ForkName::EuclidV1 => ReferenceHeader::V6(*self.batch_header.must_v6_header()),
-            ForkName::EuclidV2 => ReferenceHeader::V7(*self.batch_header.must_v7_header()),
-            ForkName::Feynman => ReferenceHeader::V8(*self.batch_header.must_v8_header()),
+        let reference_header = match (version.domain, version.stf_version) {
+            (Domain::Scroll, STFVersion::V6) => {
+                ReferenceHeader::V6(*self.batch_header.must_v6_header())
+            }
+            (Domain::Scroll, STFVersion::V7) => {
+                ReferenceHeader::V7(*self.batch_header.must_v7_header())
+            }
+            (Domain::Scroll, STFVersion::V8) => {
+                ReferenceHeader::V8(*self.batch_header.must_v8_header())
+            }
+            (Domain::Validium, STFVersion::V1) => {
+                ReferenceHeader::Validium(*self.batch_header.must_validium_header())
+            }
+            (domain, stf_version) => {
+                unreachable!("unsupported domain={domain:?},stf-version={stf_version:?}")
+            }
        };

        BatchWitness {
-            fork_name,
+            version: version.as_version_byte(),
+            fork_name: version.fork,
            chunk_proofs: self.chunk_proofs.iter().map(|proof| proof.into()).collect(),
            chunk_infos: self
                .chunk_proofs
@@ -193,15 +250,78 @@ impl BatchProvingTask {
    }

    pub fn precheck_and_build_metadata(&self) -> Result<BatchInfo> {
-        let fork_name = ForkName::from(self.fork_name.as_str());
        // for every aggregation task, there are two steps needed to build the metadata:
        // 1. generate data for metadata from the witness
        // 2. validate every adjacent proof pair
        let witness = self.build_guest_input();
        let metadata = BatchInfo::from(&witness);
-
-        super::check_aggregation_proofs(self.chunk_proofs.as_slice(), fork_name)?;
+        super::check_aggregation_proofs(self.chunk_proofs.as_slice(), Version::from(self.version))?;

        Ok(metadata)
    }
 }
+
+#[test]
+fn test_deserde_batch_header_v_validium() {
+    use std::str::FromStr;
+
+    // Top-level JSON: flattened enum tag "V1" + batch_hash
+    let json = r#"{
+        "V1": {
+        "version": 1,
+        "batch_index": 42,
+        "parent_batch_hash": "0x1111111111111111111111111111111111111111111111111111111111111111",
+        "post_state_root": "0x2222222222222222222222222222222222222222222222222222222222222222",
+        "withdraw_root": "0x3333333333333333333333333333333333333333333333333333333333333333",
+        "commitment": "0x4444444444444444444444444444444444444444444444444444444444444444"
+        },
+        "batch_hash": "0x5555555555555555555555555555555555555555555555555555555555555555"
+    }"#;
+
+    let parsed: BatchHeaderV = serde_json::from_str(json).expect("deserialize BatchHeaderV");
+
+    match parsed {
+        BatchHeaderV::Validium(v) => {
+            // Check the batch_hash field
+            let expected_batch_hash = B256::from_str(
+                "0x5555555555555555555555555555555555555555555555555555555555555555",
+            )
+            .unwrap();
+            assert_eq!(v.batch_hash, expected_batch_hash);
+
+            // Check the inner header variant and fields
+            match v.header {
+                BatchHeaderValidium::V1(h) => {
+                    assert_eq!(h.version, 1);
+                    assert_eq!(h.batch_index, 42);
+
+                    let p = B256::from_str(
+                        "0x1111111111111111111111111111111111111111111111111111111111111111",
+                    )
+                    .unwrap();
+                    let s = B256::from_str(
+                        "0x2222222222222222222222222222222222222222222222222222222222222222",
+                    )
+                    .unwrap();
+                    let w = B256::from_str(
+                        "0x3333333333333333333333333333333333333333333333333333333333333333",
+                    )
+                    .unwrap();
+                    let c = B256::from_str(
+                        "0x4444444444444444444444444444444444444444444444444444444444444444",
+                    )
+                    .unwrap();
+
+                    assert_eq!(h.parent_batch_hash, p);
+                    assert_eq!(h.post_state_root, s);
+                    assert_eq!(h.withdraw_root, w);
+                    assert_eq!(h.commitment, c);
+
+                    // Sanity: computed batch hash equals the provided one (if method available)
+                    // assert_eq!(v.header.batch_hash(), expected_batch_hash);
+                }
+            }
+        }
+        _ => panic!("expected validium header variant"),
+    }
+}
--- a/crates/libzkp/src/tasks/bundle.rs
+++ b/crates/libzkp/src/tasks/bundle.rs
@@ -1,17 +1,21 @@
-use crate::proofs::BatchProof;
 use eyre::Result;
 use scroll_zkvm_types::{
-    bundle::{BundleInfo, BundleWitness},
-    public_inputs::ForkName,
+    bundle::{BundleInfo, BundleWitness, LegacyBundleWitness},
+    public_inputs::Version,
    task::ProvingTask,
    utils::{to_rkyv_bytes, RancorError},
 };

+use crate::proofs::BatchProof;
+
 /// Message indicating a sanity check failure.
 const BUNDLE_SANITY_MSG: &str = "bundle must have at least one batch";

 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct BundleProvingTask {
+    /// The version of batches in the bundle.
+    pub version: u8,
+    /// The STARK proofs of each batch in the bundle.
    pub batch_proofs: Vec<BatchProof>,
    /// for sanity check
    pub bundle_info: Option<BundleInfo>,
@@ -40,26 +44,26 @@ impl BundleProvingTask {
    }

    fn build_guest_input(&self) -> BundleWitness {
+        let version = Version::from(self.version);
        BundleWitness {
+            version: version.as_version_byte(),
            batch_proofs: self.batch_proofs.iter().map(|proof| proof.into()).collect(),
            batch_infos: self
                .batch_proofs
                .iter()
                .map(|wrapped_proof| wrapped_proof.metadata.batch_info.clone())
                .collect(),
-            fork_name: self.fork_name.to_lowercase().as_str().into(),
+            fork_name: version.fork,
        }
    }

    pub fn precheck_and_build_metadata(&self) -> Result<BundleInfo> {
-        let fork_name = ForkName::from(self.fork_name.as_str());
        // for every aggregation task, there are two steps needed to build the metadata:
        // 1. generate data for metadata from the witness
        // 2. validate every adjacent proof pair
        let witness = self.build_guest_input();
        let metadata = BundleInfo::from(&witness);
-
-        super::check_aggregation_proofs(self.batch_proofs.as_slice(), fork_name)?;
+        super::check_aggregation_proofs(self.batch_proofs.as_slice(), Version::from(self.version))?;

        Ok(metadata)
    }
@@ -71,7 +75,8 @@ impl TryFrom<BundleProvingTask> for ProvingTask {
    fn try_from(value: BundleProvingTask) -> Result<Self> {
        let witness = value.build_guest_input();
        let serialized_witness = if crate::witness_use_legacy_mode() {
-            to_rkyv_bytes::<RancorError>(&witness)?.into_vec()
+            let legacy = LegacyBundleWitness::from(witness);
+            to_rkyv_bytes::<RancorError>(&legacy)?.into_vec()
        } else {
            super::encode_task_to_witness(&witness)?
        };
--- a/crates/libzkp/src/tasks/chunk.rs
+++ b/crates/libzkp/src/tasks/chunk.rs
@@ -1,20 +1,26 @@
-use super::chunk_interpreter::*;
 use eyre::Result;
 use sbv_core::BlockWitness;
-use sbv_primitives::B256;
+use sbv_primitives::{types::consensus::BlockHeader, B256};
 use scroll_zkvm_types::{
-    chunk::{execute, ChunkInfo, ChunkWitness, LegacyChunkWitness},
+    chunk::{execute, ChunkInfo, ChunkWitness, LegacyChunkWitness, ValidiumInputs},
    task::ProvingTask,
    utils::{to_rkyv_bytes, RancorError},
+    version::Version,
 };

+use super::chunk_interpreter::*;
+
 /// The type aligned with coordinator's defination
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ChunkTask {
+    /// The version for the chunk, as per [`Version`].
+    pub version: u8,
    /// block hashes for a series of block
    pub block_hashes: Vec<B256>,
    /// The on-chain L1 msg queue hash before applying L1 msg txs from the chunk.
    pub prev_msg_queue_hash: B256,
+    /// The on-chain L1 msg queue hash after applying L1 msg txs from the chunk (for validate)
+    pub post_msg_queue_hash: B256,
    /// Fork name specify
    pub fork_name: String,
 }
@@ -22,19 +28,64 @@ pub struct ChunkTask {
 impl TryFromWithInterpreter<ChunkTask> for ChunkProvingTask {
    fn try_from_with_interpret(
        value: ChunkTask,
+        decryption_key: Option<&[u8]>,
        interpreter: impl ChunkInterpreter,
    ) -> Result<Self> {
        let mut block_witnesses = Vec::new();
        for block_hash in value.block_hashes {
-            let witness =
+            let mut witness =
                interpreter.try_fetch_block_witness(block_hash, block_witnesses.last())?;
+            if witness.header.number == 1 {
+                use std::str::FromStr;
+                let hacked_state_root = match witness.chain_id {
+                    // cloak-xen-sequencer.sepolia
+                    5343513301 => Some(B256::from_str(
+                        "0x0711f02d6f85b0597c4705298e01ee27159fdd8bd8bdeda670ae8b9073091246",
+                    )?),
+                    // cloak-etherfi-sequencer.sepolia
+                    5343513302 => Some(B256::from_str(
+                        "0x7b44ea23770dda8810801779eb6847d56be0399e35de7c56465ccf8b7578ddf6",
+                    )?),
+                    // cloak-shiga-sequencer.sepolia
+                    5343513303 => Some(B256::from_str(
+                        "0x05973227854ac82c22f164ed3d4510b7df516a0eecdfd9bed5f2446efc9994b9",
+                    )?),
+                    // cloak-xen-sequencer.mainnet
+                    5343523301 => Some(B256::from_str(
+                        "0x8da1aaf41660ddf7870ab5ff4f6a3ab4b2e652568d341ede87ada56aad5fb097",
+                    )?),
+                    _ => None,
+                };
+                if let Some(hacked_state_root) = hacked_state_root {
+                    witness.prev_state_root = hacked_state_root;
+                    tracing::warn!("hack genesis state root {:?} for cloak testnet to work around a wrong gensis configuration", witness.prev_state_root);
+                }
+            }
            block_witnesses.push(witness);
        }

+        let validium_txs = if Version::from(value.version).is_validium() {
+            let mut validium_txs = Vec::new();
+            for block_number in block_witnesses.iter().map(|w| w.header.number()) {
+                validium_txs.push(interpreter.try_fetch_l1_msgs(block_number)?);
+            }
+            validium_txs
+        } else {
+            vec![]
+        };
+
+        let validium_inputs = decryption_key.map(|secret_key| ValidiumInputs {
+            validium_txs,
+            secret_key: secret_key.into(),
+        });
+
        Ok(Self {
+            version: value.version,
            block_witnesses,
            prev_msg_queue_hash: value.prev_msg_queue_hash,
+            post_msg_queue_hash: value.post_msg_queue_hash,
            fork_name: value.fork_name,
+            validium_inputs,
        })
    }
 }
@@ -48,12 +99,18 @@ const CHUNK_SANITY_MSG: &str = "chunk must have at least one block";
 /// - {first_block_number}-{last_block_number}
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 pub struct ChunkProvingTask {
+    /// The version for the chunk, as per [Version][scroll_zkvm_types::version::Version].
+    pub version: u8,
    /// Witnesses for every block in the chunk.
    pub block_witnesses: Vec<BlockWitness>,
    /// The on-chain L1 msg queue hash before applying L1 msg txs from the chunk.
    pub prev_msg_queue_hash: B256,
+    /// The on-chain L1 msg queue hash after applying L1 msg txs from the chunk (for validate)
+    pub post_msg_queue_hash: B256,
    /// Fork name specify
    pub fork_name: String,
+    /// Optional inputs in case of domain=validium.
+    pub validium_inputs: Option<ValidiumInputs>,
 }

 #[derive(Clone, Debug)]
@@ -126,11 +183,25 @@ impl ChunkProvingTask {
    }

    fn build_guest_input(&self) -> ChunkWitness {
-        ChunkWitness::new(
-            &self.block_witnesses,
-            self.prev_msg_queue_hash,
-            self.fork_name.to_lowercase().as_str().into(),
-        )
+        let version = Version::from(self.version);
+
+        if version.is_validium() {
+            assert!(self.validium_inputs.is_some());
+            ChunkWitness::new(
+                version.as_version_byte(),
+                &self.block_witnesses,
+                self.prev_msg_queue_hash,
+                version.fork,
+                self.validium_inputs.clone(),
+            )
+        } else {
+            ChunkWitness::new_scroll(
+                version.as_version_byte(),
+                &self.block_witnesses,
+                self.prev_msg_queue_hash,
+                version.fork,
+            )
+        }
    }

    fn insert_state(&mut self, node: sbv_primitives::Bytes) {
@@ -139,8 +210,8 @@ impl ChunkProvingTask {

    pub fn precheck_and_build_metadata(&self) -> Result<ChunkInfo> {
        let witness = self.build_guest_input();
-
        let ret = ChunkInfo::try_from(witness).map_err(|e| eyre::eyre!("{e}"))?;
+        assert_eq!(ret.post_msg_queue_hash, self.post_msg_queue_hash);
        Ok(ret)
    }

--- a/crates/libzkp/src/tasks/chunk_interpreter.rs
+++ b/crates/libzkp/src/tasks/chunk_interpreter.rs
@@ -1,6 +1,6 @@
 use eyre::Result;
 use sbv_core::BlockWitness;
-use sbv_primitives::{Bytes, B256};
+use sbv_primitives::{types::consensus::TxL1Message, Bytes, B256};

 /// An interpreter which is cirtical in translating chunk data
 /// since we need to grep block witness and storage node data
@@ -13,13 +13,22 @@ pub trait ChunkInterpreter {
    ) -> Result<BlockWitness> {
        Err(eyre::eyre!("no implement"))
    }
+
    fn try_fetch_storage_node(&self, _node_hash: B256) -> Result<Bytes> {
        Err(eyre::eyre!("no implement"))
    }
+
+    fn try_fetch_l1_msgs(&self, _block_number: u64) -> Result<Vec<TxL1Message>> {
+        Err(eyre::eyre!("no implement"))
+    }
 }

 pub trait TryFromWithInterpreter<T>: Sized {
-    fn try_from_with_interpret(value: T, intepreter: impl ChunkInterpreter) -> Result<Self>;
+    fn try_from_with_interpret(
+        value: T,
+        decryption_key: Option<&[u8]>,
+        intepreter: impl ChunkInterpreter,
+    ) -> Result<Self>;
 }

 pub struct DummyInterpreter {}
--- a/crates/libzkp/src/verifier.rs
+++ b/crates/libzkp/src/verifier.rs
@@ -41,6 +41,7 @@ pub trait ProofVerifier {

 #[derive(Debug, Serialize, Deserialize)]
 pub struct CircuitConfig {
+    pub version: u8,
    pub fork_name: String,
    pub assets_path: String,
 }
@@ -61,14 +62,18 @@ pub fn init(config: VerifierConfig) {
    for cfg in &config.circuits {
        let canonical_fork_name = cfg.fork_name.to_lowercase();

-        let verifier = Verifier::new(&cfg.assets_path, canonical_fork_name.as_str().into());
+        let verifier = Verifier::new(&cfg.assets_path, cfg.version);
        let ret = verifiers.insert(canonical_fork_name, Arc::new(Mutex::new(verifier)));
        assert!(
            ret.is_none(),
            "DO NOT init the same fork {} twice",
            cfg.fork_name
        );
-        tracing::info!("load verifier config for fork {}", cfg.fork_name);
+        tracing::info!(
+            "load verifier config for fork {} (ver {})",
+            cfg.fork_name,
+            cfg.version
+        );
    }

    let ret = VERIFIERS.set(verifiers).is_ok();
--- a/crates/libzkp/src/verifier/universal.rs
+++ b/crates/libzkp/src/verifier/universal.rs
@@ -6,22 +6,22 @@ use crate::{
    proofs::{AsRootProof, BatchProof, BundleProof, ChunkProof, IntoEvmProof},
    utils::panic_catch,
 };
-use scroll_zkvm_types::public_inputs::ForkName;
+use scroll_zkvm_types::version::Version;
 use scroll_zkvm_verifier::verifier::UniversalVerifier;
 use std::path::Path;

 pub struct Verifier {
    verifier: UniversalVerifier,
-    fork: ForkName,
+    version: Version,
 }

 impl Verifier {
-    pub fn new(assets_dir: &str, fork: ForkName) -> Self {
+    pub fn new(assets_dir: &str, ver_n: u8) -> Self {
        let verifier_bin = Path::new(assets_dir);

        Self {
            verifier: UniversalVerifier::setup(verifier_bin).expect("Setting up chunk verifier"),
-            fork,
+            version: Version::from(ver_n),
        }
    }
 }
@@ -31,21 +31,21 @@ impl ProofVerifier for Verifier {
        panic_catch(|| match task_type {
            TaskType::Chunk => {
                let proof = serde_json::from_slice::<ChunkProof>(proof).unwrap();
-                assert!(proof.pi_hash_check(self.fork));
+                assert!(proof.pi_hash_check(self.version));
                self.verifier
                    .verify_stark_proof(proof.as_root_proof(), &proof.vk)
                    .unwrap()
            }
            TaskType::Batch => {
                let proof = serde_json::from_slice::<BatchProof>(proof).unwrap();
-                assert!(proof.pi_hash_check(self.fork));
+                assert!(proof.pi_hash_check(self.version));
                self.verifier
                    .verify_stark_proof(proof.as_root_proof(), &proof.vk)
                    .unwrap()
            }
            TaskType::Bundle => {
                let proof = serde_json::from_slice::<BundleProof>(proof).unwrap();
-                assert!(proof.pi_hash_check(self.fork));
+                assert!(proof.pi_hash_check(self.version));
                let vk = proof.vk.clone();
                let evm_proof = proof.into_evm_proof();
                self.verifier.verify_evm_proof(&evm_proof, &vk).unwrap()
--- a/crates/libzkp_c/src/lib.rs
+++ b/crates/libzkp_c/src/lib.rs
@@ -152,11 +152,22 @@ pub unsafe extern "C" fn gen_universal_task(
    fork_name: *const c_char,
    expected_vk: *const u8,
    expected_vk_len: usize,
+    decryption_key: *const u8,
+    decryption_key_len: usize,
 ) -> HandlingResult {
    let task_json = if task_type == TaskType::Chunk as i32 {
        let pre_task_str = c_char_to_str(task);
        let cli = l2geth::get_client();
-        match libzkp::checkout_chunk_task(pre_task_str, cli) {
+        let decryption_key = if decryption_key_len > 0 {
+            assert_eq!(decryption_key_len, 32, "len(decryption_key) != 32");
+            Some(std::slice::from_raw_parts(
+                decryption_key,
+                decryption_key_len,
+            ))
+        } else {
+            None
+        };
+        match libzkp::checkout_chunk_task(pre_task_str, decryption_key, cli) {
            Ok(str) => str,
            Err(e) => {
                tracing::error!("gen_universal_task failed at pre interpret step, error: {e}");
--- a/crates/prover-bin/assets_url_preset.json
+++ b/crates/prover-bin/assets_url_preset.json
@@ -2,6 +2,9 @@
    "feynman": {
        "b68fdc3f28a5ce006280980df70cd3447e56913e5bca6054603ba85f0794c23a6618ea25a7991845bbc5fd571670ee47379ba31ace92d345bca59702a0d4112d": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/chunk/",
        "9a3f66370f11e3303f1a1248921025104e83253efea43a70d221cf4e15fc145bf2be2f4468d1ac4a70e7682babb1c60417e21c7633d4b55b58f44703ec82b05a": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/batch/",
-        "1f8627277e1c1f6e1cc70c03e6fde06929e5ea27ca5b1d56e23b235dfeda282e22c0e5294bcb1b3a9def836f8d0f18612a9860629b9497292976ca11844b7e73": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/bundle/"
+        "1f8627277e1c1f6e1cc70c03e6fde06929e5ea27ca5b1d56e23b235dfeda282e22c0e5294bcb1b3a9def836f8d0f18612a9860629b9497292976ca11844b7e73": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.5.2/bundle/",
+        "7eb91f1885cc7a63cc848928f043fa56bf747161a74cd933d88c0456b90643346618ea25a7991845bbc5fd571670ee47379ba31ace92d345bca59702a0d4112d": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.6.0-rc.1/chunk/",
+        "dc653e7416628c612fa4d80b4724002bad4fde3653aef7316b80df0c19740a1bf2be2f4468d1ac4a70e7682babb1c60417e21c7633d4b55b58f44703ec82b05a": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.6.0-rc.1/batch/",
+        "14de1c74b663ed3c99acb03e90a5753b5923233c5c590864ad7746570297d16722c0e5294bcb1b3a9def836f8d0f18612a9860629b9497292976ca11844b7e73": "https://circuit-release.s3.us-west-2.amazonaws.com/scroll-zkvm/releases/0.6.0-rc.1/bundle/"
    }
 }
--- a/go.work
+++ b/go.work
@@ -1,7 +1,7 @@
 go 1.22.4

 use (
-	./bridge-history-api
+	// ./bridge-history-api
 	./common
 	./coordinator
 	./database
--- a/go.work.sum
+++ b/go.work.sum
@@ -731,8 +731,10 @@ github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:
 github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM=
 github.com/compose-spec/compose-go v1.20.0 h1:h4ZKOst1EF/DwZp7dWkb+wbTVE4nEyT9Lc89to84Ol4=
 github.com/compose-spec/compose-go v1.20.0/go.mod h1:+MdqXV4RA7wdFsahh/Kb8U0pAJqkg7mr4PM9tFKU8RM=
+github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
 github.com/consensys/bavard v0.1.27/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs=
 github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY=
+github.com/consensys/gnark-crypto v0.13.0/go.mod h1:wKqwsieaKPThcFkHe0d0zMsbHEUWFmZcG7KBCse210o=
 github.com/container-orchestrated-devices/container-device-interface v0.6.1 h1:mz77uJoP8im/4Zins+mPqt677ZMaflhoGaYrRAl5jvA=
 github.com/container-orchestrated-devices/container-device-interface v0.6.1/go.mod h1:40T6oW59rFrL/ksiSs7q45GzjGlbvxnA4xaK6cyq+kA=
 github.com/containerd/aufs v1.0.0 h1:2oeJiwX5HstO7shSrPZjrohJZLzK36wvpdmzDRkL/LY=
@@ -792,6 +794,7 @@ github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS3
 github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
 github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
+github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
 github.com/deepmap/oapi-codegen v1.6.0 h1:w/d1ntwh91XI0b/8ja7+u5SvA4IFfM0UNNLmiDR1gg0=
@@ -1199,6 +1202,7 @@ github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
 github.com/labstack/gommon v0.3.1/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
 github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
+github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
 github.com/lestrrat-go/backoff/v2 v2.0.8 h1:oNb5E5isby2kiro9AgdHLv5N5tint1AnDVVf2E2un5A=
 github.com/lestrrat-go/backoff/v2 v2.0.8/go.mod h1:rHP/q/r9aT27n24JQLa7JhSQZCKBBOiM/uP402WwN8Y=
 github.com/lestrrat-go/blackmagic v1.0.0 h1:XzdxDbuQTz0RZZEmdU7cnQxUtFUzgCSPq8RCz4BxIi4=
@@ -1409,6 +1413,7 @@ github.com/scroll-tech/da-codec v0.1.3-0.20250609113414-f33adf0904bd/go.mod h1:g
 github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148 h1:cyK1ifU2fRoMl8YWR9LOsZK4RvJnlG3RODgakj5I8VY=
 github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148/go.mod h1:gz5x3CsLy5htNTbv4PWRPBU9nSAujfx1U2XtFcXoFuk=
 github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
+github.com/scroll-tech/da-codec v0.1.3-0.20250825071838-cddc263e5ef6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240607130425-e2becce6a1a4/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240821074444-b3fa00861e5e/go.mod h1:swB5NSp8pKNDuYsTxfR08bHS6L56i119PBx8fxvV8Cs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20241010064814-3d88e870ae22/go.mod h1:r9FwtxCtybMkTbWYCyBuevT9TW3zHmOTHqD082Uh+Oo=
@@ -1611,6 +1616,7 @@ golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOM
 golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -1781,6 +1787,7 @@ golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2 h1:IRJeR9r1pYWsHKTRe/IInb7lYvbBVIqOgsX/u0mbOWY=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
@@ -1789,6 +1796,7 @@ golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
 golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
 golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
--- a/rollup/cmd/rollup_relayer/app/app.go
+++ b/rollup/cmd/rollup_relayer/app/app.go
@@ -111,7 +111,7 @@ func action(ctx *cli.Context) error {
 	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, minCodecVersion, genesis.Config, db, cfg.L2Config.RelayerConfig.ValidiumMode, registry)
 	bundleProposer := watcher.NewBundleProposer(subCtx, cfg.L2Config.BundleProposerConfig, minCodecVersion, genesis.Config, db, registry)

-	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, genesis.Config, db, registry)
+	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, genesis.Config, db, cfg.L2Config.RelayerConfig.ValidiumMode, registry)

 	if cfg.RecoveryConfig != nil && cfg.RecoveryConfig.Enable {
 		log.Info("Starting rollup-relayer in recovery mode", "version", version.Version)
--- a/rollup/go.mod
+++ b/rollup/go.mod
@@ -16,7 +16,7 @@ require (
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.16.0
 	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250929111815-80dc0952e664
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/spf13/viper v1.19.0
 	github.com/stretchr/testify v1.10.0
@@ -51,6 +51,7 @@ require (
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
 	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
 	github.com/fjl/memsize v0.0.2 // indirect
@@ -109,6 +110,7 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/scroll-tech/ecies-go/v2 v2.0.10-beta.1 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/smartystreets/assertions v1.13.1 // indirect
--- a/rollup/go.sum
+++ b/rollup/go.sum
@@ -88,6 +88,8 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea h1:j4317fAZh7X6GqbFowYdYdI0L9bwxL07jyPZIdepyZ0=
 github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
@@ -287,8 +289,10 @@ github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6g
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
 github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178 h1:4utngmJHXSOS5FoSdZhEV1xMRirpArbXvyoCZY9nYj0=
 github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7 h1:1rN1qocsQlOyk1VCpIEF1J5pfQbLAi1pnMZSLQS37jQ=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
+github.com/scroll-tech/ecies-go/v2 v2.0.10-beta.1 h1:plwnNnxdaPH7VZ1adhVceHzYVq0s51KV8ObKX9dcgnU=
+github.com/scroll-tech/ecies-go/v2 v2.0.10-beta.1/go.mod h1:A+pHaITd+ogBm4Rk35xebF9OPiyMYlFlgqBOiY5PSjg=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250929111815-80dc0952e664 h1:kfjpLET2ZJGt8023+2Ygjs4yjtsFrWuQxSWPOyZJoB0=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250929111815-80dc0952e664/go.mod h1:7k+F68rIpx6js9Q+rgwnokywAMSDgkgKwg5iogEkrTI=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
--- a/rollup/internal/controller/relayer/l2_relayer.go
+++ b/rollup/internal/controller/relayer/l2_relayer.go
@@ -1040,7 +1040,15 @@ func (r *Layer2Relayer) constructCommitBatchPayloadValidium(batch *dbBatchWithCh
 	lastChunk := batch.Chunks[len(batch.Chunks)-1]
 	commitment := common.HexToHash(lastChunk.EndBlockHash)

-	version := encoding.CodecVersion(batch.Batch.CodecVersion)
+	var version uint8
+	if encoding.CodecVersion(batch.Batch.CodecVersion) == encoding.CodecV8 {
+		// Validium version line starts with v1,
+		// but rollup-relayer behavior follows v8.
+		version = 1
+	} else {
+		return nil, 0, 0, fmt.Errorf("unexpected codec version %d for validium mode", batch.Batch.CodecVersion)
+	}
+
 	calldata, err := r.validiumABI.Pack("commitBatch", version, common.HexToHash(batch.Batch.ParentBatchHash), common.HexToHash(batch.Batch.StateRoot), common.HexToHash(batch.Batch.WithdrawRoot), commitment[:])
 	if err != nil {
 		return nil, 0, 0, fmt.Errorf("failed to pack commitBatch: %w", err)
--- a/rollup/internal/controller/watcher/l2_watcher.go
+++ b/rollup/internal/controller/watcher/l2_watcher.go
@@ -8,6 +8,8 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/eth"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/event"
 	"github.com/scroll-tech/go-ethereum/log"
@@ -32,13 +34,15 @@ type L2WatcherClient struct {
 	messageQueueAddress  common.Address
 	withdrawTrieRootSlot common.Hash

+	validiumMode bool
+
 	metrics *l2WatcherMetrics

 	chainCfg *params.ChainConfig
 }

 // NewL2WatcherClient take a l2geth instance to generate a l2watcherclient instance
-func NewL2WatcherClient(ctx context.Context, client *ethclient.Client, confirmations rpc.BlockNumber, messageQueueAddress common.Address, withdrawTrieRootSlot common.Hash, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *L2WatcherClient {
+func NewL2WatcherClient(ctx context.Context, client *ethclient.Client, confirmations rpc.BlockNumber, messageQueueAddress common.Address, withdrawTrieRootSlot common.Hash, chainCfg *params.ChainConfig, db *gorm.DB, validiumMode bool, reg prometheus.Registerer) *L2WatcherClient {
 	return &L2WatcherClient{
 		ctx:    ctx,
 		Client: client,
@@ -50,6 +54,8 @@ func NewL2WatcherClient(ctx context.Context, client *ethclient.Client, confirmat
 		messageQueueAddress:  messageQueueAddress,
 		withdrawTrieRootSlot: withdrawTrieRootSlot,

+		validiumMode: validiumMode,
+
 		metrics: initL2WatcherMetrics(reg),

 		chainCfg: chainCfg,
@@ -95,21 +101,51 @@ func (w *L2WatcherClient) GetAndStoreBlocks(ctx context.Context, from, to uint64
 			return fmt.Errorf("failed to BlockByNumber: %v. number: %v", err, number)
 		}

+		blockTxs := block.Transactions()
+
 		var count int
-		for _, tx := range block.Transactions() {
+		for _, tx := range blockTxs {
 			if tx.IsL1MessageTx() {
 				count++
 			}
 		}
 		log.Info("retrieved block", "height", block.Header().Number, "hash", block.Header().Hash().String(), "L1 message count", count)

+		// use original (encrypted) L1 message txs in validium mode
+		if w.validiumMode {
+			var txs []*types.Transaction
+
+			if count > 0 {
+				log.Info("Fetching encrypted messages in validium mode")
+				txs, err = w.GetL1MessagesInBlock(context.Background(), block.Hash(), eth.QueryModeSynced)
+				if err != nil {
+					return fmt.Errorf("failed to get L1 messages: %v, block hash: %v", err, block.Hash().Hex())
+				}
+			}
+
+			// sanity check
+			if len(txs) != count {
+				return fmt.Errorf("L1 message count mismatch: expected %d, got %d", count, len(txs))
+			}
+
+			for ii := 0; ii < count; ii++ {
+				// sanity check
+				if blockTxs[ii].AsL1MessageTx().QueueIndex != txs[ii].AsL1MessageTx().QueueIndex {
+					return fmt.Errorf("L1 message queue index mismatch at index %d: expected %d, got %d", ii, blockTxs[ii].AsL1MessageTx().QueueIndex, txs[ii].AsL1MessageTx().QueueIndex)
+				}
+
+				log.Info("Replacing L1 message tx in validium mode", "index", ii, "queueIndex", txs[ii].AsL1MessageTx().QueueIndex, "decryptedTxHash", blockTxs[ii].Hash().Hex(), "originalTxHash", txs[ii].Hash().Hex())
+				blockTxs[ii] = txs[ii]
+			}
+		}
+
 		withdrawRoot, err3 := w.StorageAt(ctx, w.messageQueueAddress, w.withdrawTrieRootSlot, big.NewInt(int64(number)))
 		if err3 != nil {
 			return fmt.Errorf("failed to get withdrawRoot: %v. number: %v", err3, number)
 		}
 		blocks = append(blocks, &encoding.Block{
 			Header:       block.Header(),
-			Transactions: encoding.TxsToTxsData(block.Transactions()),
+			Transactions: encoding.TxsToTxsData(blockTxs),
 			WithdrawRoot: common.BytesToHash(withdrawRoot),
 		})
 	}
--- a/rollup/internal/utils/utils.go
+++ b/rollup/internal/utils/utils.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"

+	"github.com/ethereum/go-ethereum/log"
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/crypto"
@@ -138,6 +139,26 @@ func encodeBatchHeaderValidium(b *encoding.Batch, codecVersion encoding.CodecVer
 	// TODO: This is a temporary solution, we might use a larger commitment in the future
 	lastBlock := b.Blocks[len(b.Blocks)-1]
 	commitment := lastBlock.Header.Hash()
+	stateRoot := b.StateRoot()
+
+	// Temporary workaround for the wrong genesis state root configuration issue.
+	if lastBlock.Header.Number.Uint64() == 0 {
+		if commitment == common.HexToHash("0x76a8e1359fe1a51ec3917ca98dec95ba005f1a73bcdbc2c7f87c7683e828fbb1") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
+			// cloak-xen/sepolia
+			stateRoot = common.HexToHash("0x0711f02d6f85b0597c4705298e01ee27159fdd8bd8bdeda670ae8b9073091246")
+		} else if commitment == common.HexToHash("0x8005a02271085eaded2565f3e252013cd9d3cd0a4775d89f9ba4224289671276") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
+			// cloak-xen/mainnet
+			stateRoot = common.HexToHash("0x8da1aaf41660ddf7870ab5ff4f6a3ab4b2e652568d341ede87ada56aad5fb097")
+		} else if commitment == common.HexToHash("0xa7e50dfc812039410c2009c74cdcb0c0797aa5485dec062985eaa43b17d333ea") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
+			// cloak-etherfi/sepolia
+			stateRoot = common.HexToHash("0x7b44ea23770dda8810801779eb6847d56be0399e35de7c56465ccf8b7578ddf6")
+		} else if commitment == common.HexToHash("0xeccf4fab24f8b5dd3b72667c6bf5e28b17ccffdea01e3e5c08f393edaa9e7657") && stateRoot == common.HexToHash("0x08d535cc60f40af5dd3b31e0998d7567c2d568b224bed2ba26070aeb078d1339") {
+			// cloak-shiga/sepolia
+			stateRoot = common.HexToHash("0x05973227854ac82c22f164ed3d4510b7df516a0eecdfd9bed5f2446efc9994b9")
+		}
+
+		log.Warn("Using genesis state root", "stateRoot", stateRoot.Hex())
+	}

 	// Batch header field sizes
 	const (
@@ -164,10 +185,22 @@ func encodeBatchHeaderValidium(b *encoding.Batch, codecVersion encoding.CodecVer
 		commitmentOffset   = withdrawRootOffset + withdrawRootSize
 	)

-	batchBytes[versionOffset] = uint8(codecVersion)                                                                        // version
+	var version uint8
+	if codecVersion == encoding.CodecV8 {
+		// Validium version line starts with v1,
+		// but rollup-relayer behavior follows v8.
+		version = 1
+	} else if codecVersion == encoding.CodecV0 {
+		// Special case for genesis batch
+		version = 0
+	} else {
+		return nil, common.Hash{}, fmt.Errorf("unexpected codec version %d for batch %v in validium mode", codecVersion, b.Index)
+	}
+
+	batchBytes[versionOffset] = version                                                                                    // version
 	binary.BigEndian.PutUint64(batchBytes[indexOffset:indexOffset+indexSize], b.Index)                                     // batch index
 	copy(batchBytes[parentHashOffset:parentHashOffset+parentHashSize], b.ParentBatchHash[0:parentHashSize])                // parentBatchHash
-	copy(batchBytes[stateRootOffset:stateRootOffset+stateRootSize], b.StateRoot().Bytes()[0:stateRootSize])                // postStateRoot
+	copy(batchBytes[stateRootOffset:stateRootOffset+stateRootSize], stateRoot.Bytes()[0:stateRootSize])                    // postStateRoot
 	copy(batchBytes[withdrawRootOffset:withdrawRootOffset+withdrawRootSize], b.WithdrawRoot().Bytes()[0:withdrawRootSize]) // postWithdrawRoot
 	copy(batchBytes[commitmentOffset:commitmentOffset+commitmentSize], commitment[0:commitmentSize])                       // data commitment

--- a/rollup/tests/integration_tool/imports.go
+++ b/rollup/tests/integration_tool/imports.go
@@ -185,7 +185,9 @@ func importBatch(ctx context.Context, db *gorm.DB, chks []*orm.Chunk, encChks []
 		Blocks:                     blks,
 	}

-	dbBatch, err := batchOrm.InsertBatch(ctx, batch, codecCfg, utils.BatchMetrics{})
+	dbBatch, err := batchOrm.InsertBatch(ctx, batch, codecCfg, utils.BatchMetrics{
+		ValidiumMode: cfg.ValidiumMode,
+	})
 	if err != nil {
 		return nil, err
 	}
--- a/rollup/tests/integration_tool/main.go
+++ b/rollup/tests/integration_tool/main.go
@@ -86,7 +86,8 @@ func parseThreeIntegers(value string) (int, int, int, error) {

 // load a comptabile type of config for rollup
 type config struct {
-	DBConfig *database.Config `json:"db_config"`
+	DBConfig     *database.Config `json:"db_config"`
+	ValidiumMode bool             `json:"validium_mode"`
 }

 func init() {
--- a/tests/prover-e2e/00100_import_blocks.sql
+++ b/tests/prover-e2e/00100_import_blocks.sql
--- a/tests/prover-e2e/Makefile
+++ b/tests/prover-e2e/Makefile
@@ -1,7 +1,8 @@
 .PHONY: clean setup_db test_tool all check_vars

 GOOSE_CMD?=goose
-
+BEGIN_BLOCK?=20
+END_BLOCK?=30

 all: setup_db test_tool import_data

--- a/tests/prover-e2e/config.json
+++ b/tests/prover-e2e/config.json
@@ -4,5 +4,6 @@
    "dsn": "postgres://dev:dev@localhost:5432/scroll?sslmode=disable",
    "maxOpenNum": 5,
    "maxIdleNum": 1
-  }
+  },
+  "validium_mode": true
 }
--- a/tests/prover-e2e/prepare/dump_block_records.sql
+++ b/tests/prover-e2e/prepare/dump_block_records.sql
@@ -1,7 +1,12 @@
 -- Create a file with INSERT statements for the specific records
-\o block_export.sql
+\o 00100_import_blocks.sql
 \t on
 \a
+-- Write header comment
+SELECT '-- +goose Up';
+SELECT '-- +goose StatementBegin';
+SELECT '';
+
 SELECT 'INSERT INTO l2_block (number, hash, parent_hash, header, withdraw_root,
       state_root, tx_num, gas_used, block_timestamp, row_consumption,
       chunk_hash, transactions
@@ -20,8 +25,17 @@ SELECT 'INSERT INTO l2_block (number, hash, parent_hash, header, withdraw_root,
       quote_literal(transactions) ||
       ');'
 FROM l2_block 
-WHERE number >= 10973700 and number <= 10973730
+WHERE number >= 5 and number <= 36
 ORDER BY number ASC;
+
+-- Write footer
+SELECT '';
+SELECT '-- +goose StatementEnd';
+SELECT '-- +goose Down';
+SELECT '-- +goose StatementBegin';
+SELECT 'DELETE FROM l2_block;';
+SELECT '-- +goose StatementEnd';
+
 \t off
 \a
 \o
Author	SHA1	Message	Date
Péter Garamvölgyi	38c4eff041	fix: genesis state root commit workaround	2025-10-02 14:20:56 +02:00
Ho	6fa0f869ff	update dep	2025-10-01 19:05:54 +09:00
Ho	28a2173724	lint	2025-09-29 21:17:57 +09:00
Ho	32a7398db5	sanity check for msg_queue_hash	2025-09-29 21:17:26 +09:00
Péter Garamvölgyi	09ef1ddb5c	fix(validium): use original l1 msg hash for msg queue hash (#1743 )	2025-09-29 21:16:31 +09:00
Ho	fb2ad50010	bump version	2025-09-29 16:16:15 +09:00
Ho	d9fe2e0366	fmt	2025-09-29 16:15:25 +09:00
Ho	6d9e525e48	patch for work around configuration issue	2025-09-29 16:14:51 +09:00
Ho	e3353662a8	Merge remote-tracking branch 'origin/develop' into feat/cloak	2025-09-26 19:21:40 +09:00
Ho	45c343c2f7	bump version	2025-09-26 19:16:26 +09:00
Ho	71b6c214d8	updated zkvm-prover dependencies	2025-09-26 19:15:30 +09:00
Ho	9c8782fc12	fix coordinator generate validium batch	2025-09-26 11:33:58 +09:00
Ho	b63e2473dd	init verifier with version, fix pi hash checking in validium mode	2025-09-25 22:15:00 +09:00
Ho	76e9283cc0	TaskProvingTask omit kzg part in validium mode	2025-09-25 10:27:59 +09:00
Ho	58c8ca3b40	update e2e test generator	2025-09-25 10:26:20 +09:00
Ho	39f2d254d4	Avoiding encode entryption key	2025-09-25 08:30:24 +09:00
Ho	6f282c455e	handling null return in getL1message	2025-09-25 08:28:27 +09:00
Péter Garamvölgyi	0b511d2904	undo unrelated change	2025-09-24 11:52:09 +02:00
Péter Garamvölgyi	99fe0a75a8	fix scroll_getL1MessagesInBlock call	2025-09-24 11:51:14 +02:00
Ho	4977b3a8a0	bump minor version	2025-09-19 15:47:49 +09:00
Ho	c9ae48b28f	update local test staffs	2025-09-19 15:45:36 +09:00
Zhang Zhuo	d2dd018d50	Merge branch 'feat/cloak' into HEAD	2025-09-19 09:38:31 +08:00
Zhang Zhuo	3b40a6bb64	Merge remote-tracking branch 'origin/develop' into HEAD	2025-09-19 09:38:24 +08:00
Rohit Narurkar	f17c273997	config for 0.6.0-rc.1	2025-09-17 10:15:58 +01:00
Péter Garamvölgyi	9f125c9fcc	fix: use codec v1 for validium encoding (#1739 )	2025-09-17 08:48:22 +01:00
Ho	aacc0c0936	prune gpu prover making	2025-09-17 11:47:19 +09:00
Ho	9c906a4ef8	add missed cuda feature in building	2025-09-17 11:43:02 +09:00
Rohit Narurkar	bae85beb94	Merge branch 'feat/openvm_1.4' into feat/cloak	2025-09-16 14:48:20 +01:00
Rohit Narurkar	416f1af3c8	feat: handle decryption key and validium chunk task	2025-09-16 14:46:24 +01:00
Rohit Narurkar	e8e047264e	test: add validium mode to test data	2025-09-16 12:01:03 +01:00
Rohit Narurkar	3663e51150	feat: version byte to tasks	2025-09-16 11:58:43 +01:00
Rohit Narurkar	07ebd015a5	feat: add more arguments to task and metadata	2025-09-16 11:09:36 +01:00
Rohit Narurkar	342c015382	feat: handle versioning and validium tasks	2025-09-16 10:25:03 +01:00
Ho	ad13b56d7c	clean up	2025-09-16 15:12:17 +09:00
Zhang Zhuo	f6e6176b99	Merge branch 'feat/openvm_1.4' into feat/cloak	2025-09-16 11:04:32 +08:00
Zhang Zhuo	53d7112591	cargo check ok	2025-09-16 11:02:33 +08:00
Ho	722cc5ee76	fix gpu prover building and update build route	2025-09-16 11:55:25 +09:00
Zhang Zhuo	25fd6aa231	upgrade some deps	2025-09-16 10:54:03 +08:00
Ho	ab8df8e4b5	trival update considering AI reviews	2025-09-16 11:13:53 +09:00
Ho	755ed6074e	update toolchain for CI	2025-09-15 20:35:12 +09:00
Ho	0d6eaf74fc	deprecate patch for gpu building	2025-09-15 20:12:36 +09:00
Ho	953ba50c07	update gpu building	2025-09-15 19:57:04 +09:00
Ho	9998069515	upgrade zkvm dep	2025-09-15 19:46:35 +09:00
Ho	fcda68b5b3	fix, e2e for 0.5.6 passed	2025-09-12 17:18:28 +09:00
Ho	f3d1b151b2	fmt	2025-09-12 15:35:58 +09:00
Ho	e33d11ddc7	apply features in configuration	2025-09-12 15:35:48 +09:00
Ho	642ee2f975	export new func with ffi	2025-09-12 11:36:54 +09:00
Ho	8fcd27333f	prune storage fetch in execution	2025-09-12 11:27:02 +09:00
Ho	f640ef9377	update dep to openvm 14 and fix issues after upgrade	2025-09-11 22:32:26 +09:00