scroll-tech · lispc · Sep 11, 2025 · Sep 12, 2025 · Sep 12, 2025 · Sep 12, 2025
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -17,10 +17,9 @@ repository = "https://github.com/scroll-tech/scroll"
 version = "4.5.47"
 
 [workspace.dependencies]
-# include compatiblity fixing from "fix/coordinator"
-scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "a71dd2b" }
-scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "a71dd2b" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "a71dd2b" }
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "546172b" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "546172b" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "546172b" }
 
 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" }

diff --git 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)
+}
-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)
-}
+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)
+}
+
+func (r *RawBytes) UnmarshalJSON(data []byte) error {
+	var ints []uint16
+	if err := json.Unmarshal(data, &ints); err == nil {
+		buf := make([]byte, len(ints))
+		for i, v := range ints {
+			if v > 0xFF {
+				return fmt.Errorf("byte value %d out of range", v)
+			}
+			buf[i] = byte(v)
+		}
+		*r = RawBytes(buf)
+		return nil
+	}
+
+	if string(data) == "null" {
+		*r = nil
+		return nil
+	}
+
+	var encoded string
+	if err := json.Unmarshal(data, &encoded); err != nil {
+		return err
+	}
+	raw, err := base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		return err
+	}
+	*r = RawBytes(raw)
+	return nil
+}
-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)
-}
+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)
+}
+
+func (r *RawBytes) UnmarshalJSON(data []byte) error {
+	var ints []uint16
+	if err := json.Unmarshal(data, &ints); err == nil {
+		buf := make([]byte, len(ints))
+		for i, v := range ints {
+			if v > 0xFF {
+				return fmt.Errorf("byte value %d out of range", v)
+			}
+			buf[i] = byte(v)
+		}
+		*r = RawBytes(buf)
+		return nil
+	}
+
+	if string(data) == "null" {
+		*r = nil
+		return nil
+	}
+
+	var encoded string
+	if err := json.Unmarshal(data, &encoded); err != nil {
+		return err
+	}
+	raw, err := base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		return err
+	}
+	*r = RawBytes(raw)
+	return nil
+}
+
 // 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.

diff --git a/common/version/version.go b/common/version/version.go
@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.6.1"
+var tag = "v4.6.3"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

diff --git 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
 	}

diff --git a/coordinator/conf/config.json b/coordinator/conf/config.json
@@ -10,31 +10,31 @@
       "min_prover_version": "v4.4.45",
       "verifiers": [
         {
-          "assets_path": "assets",
-          "fork_name": "euclidV2"
-        },        
-        {
-          "assets_path": "assets",
+          "assets_path": "cloak",
           "fork_name": "feynman"
         }
       ]
     }
   },
   "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"
   }
 }
diff --git 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"`

diff --git 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) {

diff --git a/coordinator/internal/controller/api/controller.go b/coordinator/internal/controller/api/controller.go
@@ -24,7 +24,9 @@
 
 // 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")
 	}

diff --git 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

diff --git 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

diff --git 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{}

diff --git 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