feat: add more arguments to task and metadata

roynalnaruto · roynalnaruto · commit 07ebd015a511 · 2025-09-16T11:09:36.000+01:00
diff --git a/common/types/message/message.go b/common/types/message/message.go
@@ -39,6 +39,7 @@ 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"`
@@ -90,6 +91,7 @@ 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"`
@@ -103,6 +105,7 @@ type BatchTaskDetail struct {
 
 // 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"`
@@ -124,6 +127,9 @@ type ChunkInfo struct {
 	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      []byte           `json:"encryption_key"`
 }
 
 // BlockContextV2 is the block context for euclid v2
@@ -186,6 +192,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    []byte      `json:"encryption_key"`
 }
 
 // BatchProof includes the proof info that are required for batch verification and rollup.
@@ -246,6 +253,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 []byte      `json:"encryption_key"`
 }
 
 // OpenVMBundleProof includes the proof info that are required for verification of a bundle of batch proofs.
diff --git a/coordinator/conf/config.json b/coordinator/conf/config.json
@@ -12,7 +12,7 @@
         {
           "assets_path": "assets",
           "fork_name": "euclidV2"
-        },        
+        },
         {
           "assets_path": "assets",
           "fork_name": "feynman"
@@ -36,5 +36,8 @@
     "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
@@ -47,12 +47,18 @@ 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".
diff --git a/coordinator/internal/config/config_test.go b/coordinator/internal/config/config_test.go
@@ -41,7 +41,10 @@ func TestConfig(t *testing.T) {
 			"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/crates/libzkp/src/tasks/batch.rs b/crates/libzkp/src/tasks/batch.rs
@@ -73,7 +73,7 @@ impl BatchHeaderV {
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct BatchProvingTask {
     /// The version of the chunks in the batch, as per [`Version`].
-    pub version: 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.
@@ -106,7 +106,7 @@ impl TryFrom<BatchProvingTask> for ProvingTask {
 
         Ok(ProvingTask {
             identifier: value.batch_header.batch_hash().to_string(),
-            fork_name: value.version.fork.to_string(),
+            fork_name: value.fork_name,
             aggregated_proofs: value
                 .chunk_proofs
                 .into_iter()
@@ -120,7 +120,9 @@ impl TryFrom<BatchProvingTask> for ProvingTask {
 
 impl BatchProvingTask {
     fn build_guest_input(&self) -> BatchWitness {
-        let point_eval_witness = if !self.version.is_validium() {
+        let version = Version::from(self.version);
+
+        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);
@@ -129,10 +131,10 @@ impl BatchProvingTask {
                 let challenge_digest = match &self.batch_header {
                     BatchHeaderV::V6(_) => {
                         assert_eq!(
-                            self.version.fork,
+                            version.fork,
                             ForkName::EuclidV1,
                             "hardfork mismatch for da-codec@v6 header: found={:?}, expected={:?}",
-                            self.version.fork,
+                            version.fork,
                             ForkName::EuclidV1,
                         );
                         EnvelopeV6::from_slice(self.blob_bytes.as_slice())
@@ -145,7 +147,7 @@ impl BatchProvingTask {
                             padded_blob_bytes
                         };
 
-                        match self.version.fork {
+                        match version.fork {
                             ForkName::EuclidV2 => {
                                 <EnvelopeV7 as Envelope>::from_slice(padded_blob_bytes.as_slice())
                                     .challenge_digest(versioned_hash)
@@ -198,7 +200,7 @@ impl BatchProvingTask {
             None
         };
 
-        let reference_header = match (self.version.domain, self.version.stf_version) {
+        let reference_header = match (version.domain, version.stf_version) {
             (Domain::Scroll, STFVersion::V6) => {
                 ReferenceHeader::V6(*self.batch_header.must_v6_header())
             }
@@ -217,8 +219,8 @@ impl BatchProvingTask {
         };
 
         BatchWitness {
-            version: self.version.as_version_byte(),
-            fork_name: self.version.fork,
+            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
@@ -237,7 +239,7 @@ impl BatchProvingTask {
         // 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(), self.version)?;
+        super::check_aggregation_proofs(self.chunk_proofs.as_slice(), Version::from(self.version))?;
 
         Ok(metadata)
     }
diff --git a/crates/libzkp/src/tasks/bundle.rs b/crates/libzkp/src/tasks/bundle.rs
@@ -14,7 +14,7 @@ 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: Version,
+    pub version: u8,
     /// The STARK proofs of each batch in the bundle.
     pub batch_proofs: Vec<BatchProof>,
     /// for sanity check
@@ -44,15 +44,16 @@ impl BundleProvingTask {
     }
 
     fn build_guest_input(&self) -> BundleWitness {
+        let version = Version::from(self.version);
         BundleWitness {
-            version: self.version.as_version_byte(),
+            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.version.fork,
+            fork_name: version.fork,
         }
     }
 
@@ -62,7 +63,7 @@ impl BundleProvingTask {
         // 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(), self.version)?;
+        super::check_aggregation_proofs(self.batch_proofs.as_slice(), Version::from(self.version))?;
 
         Ok(metadata)
     }
diff --git a/crates/libzkp/src/tasks/chunk.rs b/crates/libzkp/src/tasks/chunk.rs
@@ -54,7 +54,7 @@ const CHUNK_SANITY_MSG: &str = "chunk must have at least one block";
 #[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: 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.
@@ -133,21 +133,22 @@ impl ChunkProvingTask {
     }
 
     fn build_guest_input(&self) -> ChunkWitness {
-        if self.version.is_validium() {
+        let version = Version::from(self.version);
+        if version.is_validium() {
             ChunkWitness::new_validium(
-                self.version.as_version_byte(),
+                version.as_version_byte(),
                 &self.block_witnesses,
                 self.prev_msg_queue_hash,
-                self.version.fork,
+                version.fork,
                 vec![], // TODO: validium txs
                 SecretKey::try_from_bytes(vec![0; 32]).expect("should be ok"), // TODO: secret key
             )
         } else {
             ChunkWitness::new_scroll(
-                self.version.as_version_byte(),
+                version.as_version_byte(),
                 &self.block_witnesses,
                 self.prev_msg_queue_hash,
-                self.version.fork,
+                version.fork,
             )
         }
     }
@@ -158,9 +159,7 @@ 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}"))?;
-        Ok(ret)
+        Ok(ChunkInfo::try_from(witness).map_err(|e| eyre::eyre!("{e}"))?)
     }
 
     /// this method check the validate of current task (there may be missing storage node)

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	`{`
`13`	`13`	`"assets_path": "assets",`
`14`	`14`	`"fork_name": "euclidV2"`
`15`		`- },`
	`15`	`+ },`
`16`	`16`	`{`
`17`	`17`	`"assets_path": "assets",`
`18`	`18`	`"fork_name": "feynman"`
`@@ -36,5 +36,8 @@`
`36`	`36`	`"secret": "prover secret key",`
`37`	`37`	`"challenge_expire_duration_sec": 3600,`
`38`	`38`	`"login_expire_duration_sec": 3600`
	`39`	`+ },`
	`40`	`+ "sequencer": {`
	`41`	`+ "decryption_key": "sequencer decryption key"`
`39`	`42`	`}`
`40`	`43`	`}`