fix coordinator generate validium batch

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -316,25 +316,26 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*
 		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
 	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 |
@@ -342,6 +343,15 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*
 		// | 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

coordinator/internal/logic/provertask/prover_task.go

@@ -20,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 (
@@ -66,29 +67,13 @@ type proverTaskContext struct {
 	hasAssignedTask *orm.ProverTask
 }
 
-// version get the version for the chain instance
-//
-// TODO: This is not foolproof and does not cover all scenarios.
 func (b *BaseProverTask) version(hardForkName string) (uint8, error) {
-	var domain, stfVersion uint8
-
-	if b.cfg.L2.ValidiumMode {
-		domain = 1
-		stfVersion = 1
-	} else {
-		domain = 0
-		stfVersion = 8
-		if hardForkName != "feynman" {
-			return 0, errors.New("expected hardfork=feynman")
-		}
-	}
-
-	return (domain << 6) + stfVersion, nil
+	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
 }

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -207,6 +207,7 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 			return errors.New("no vk specified match current hard fork, check your config")
 		}
 
+		log.Info("metadata", "string", string(proverTask.Metadata))
 		proofParameter.Proof = libzkp.GenerateWrappedProof(proofParameter.Proof, string(proverTask.Metadata), expected_vk)
 		if proofParameter.Proof == "" {
 			return errors.New("can not re-wrapping proof, see coordinator log for reason")
@@ -219,6 +220,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 {

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
+}

coordinator/internal/utils/version.go

@@ -5,6 +5,11 @@ import (
 	"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.
@@ -29,5 +34,5 @@ func Version(hardForkName string, ValidiumMode bool) (uint8, error) {
 		}
 	}
 
-	return (domain << 6) + stfVersion, nil
+	return (domain << DomainOffset) + stfVersion, nil
 }

crates/libzkp/src/tasks/batch.rs

@@ -18,6 +18,13 @@ 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
@@ -25,9 +32,9 @@ use utils::{base64, point_eval};
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 #[serde(untagged)]
 pub enum BatchHeaderV {
+    Validium(BatchHeaderValidiumWithHash),
     V6(BatchHeaderV6),
     V7_8(BatchHeaderV7),
-    Validium(BatchHeaderValidium),
 }
 
 impl BatchHeaderV {
@@ -35,7 +42,7 @@ impl BatchHeaderV {
         match self {
             BatchHeaderV::V6(h) => h.batch_hash(),
             BatchHeaderV::V7_8(h) => h.batch_hash(),
-            BatchHeaderV::Validium(h) => h.batch_hash(),
+            BatchHeaderV::Validium(h) => h.header.batch_hash(),
         }
     }
 
@@ -62,7 +69,7 @@ impl BatchHeaderV {
 
     pub fn must_validium_header(&self) -> &BatchHeaderValidium {
         match self {
-            BatchHeaderV::Validium(h) => h,
+            BatchHeaderV::Validium(h) => &h.header,
             _ => panic!("try to pick other header type"),
         }
     }
@@ -197,6 +204,15 @@ impl BatchProvingTask {
                 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
         };
 
@@ -244,3 +260,58 @@ impl BatchProvingTask {
         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"),
+    }
+}