feat(CodecV7): add CodecV7 to support upgrade 5.2 Euclid phase2

encoding/codecv6.go

@@ -0,0 +1,77 @@
+package encoding
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+)
+
+type DACodecV6 struct {
+	DACodecV4
+}
+
+// Version returns the codec version.
+func (d *DACodecV6) Version() CodecVersion {
+	return CodecV6
+}
+
+// MaxNumChunksPerBatch returns the maximum number of chunks per batch.
+func (d *DACodecV6) MaxNumChunksPerBatch() int {
+	return 1
+}
+
+// NewDAChunk creates a new DAChunk from the given Chunk and the total number of L1 messages popped before.
+// Note: For DACodecV6, this function is not implemented since there is no notion of DAChunk in this version. Blobs
+// contain the entire batch data, and it is up to a prover to decide the chunk sizes.
+func (d *DACodecV6) NewDAChunk(_ *Chunk, _ uint64) (DAChunk, error) {
+	return nil, nil
+}
+
+// NewDABatch creates a DABatch including blob from the provided Batch.
+func (d *DACodecV6) NewDABatch(batch *Batch) (DABatch, error) {
+	// TODO: create DABatch from the provided batch once the blob layout is defined. See DACodecV4 for reference.
+	return nil, nil
+}
+
+// NewDABatchFromBytes decodes the given byte slice into a DABatch.
+// Note: This function only populates the batch header, it leaves the blob-related fields and skipped L1 message bitmap empty.
+func (d *DACodecV6) NewDABatchFromBytes(data []byte) (DABatch, error) {
+	daBatch, err := decodeDABatchV6(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode DA batch: %w", err)
+	}
+
+	if daBatch.version != CodecV6 {
+		return nil, fmt.Errorf("codec version mismatch: expected %d but found %d", CodecV6, daBatch.version)
+	}
+
+	return daBatch, nil
+}
+
+func (d *DACodecV6) DecodeDAChunksRawTx(chunkBytes [][]byte) ([]*DAChunkRawTx, error) {
+	return nil, nil
+}
+
+func (d *DACodecV6) DecodeTxsFromBlob(blob *kzg4844.Blob, chunks []*DAChunkRawTx) error {
+	return nil
+}
+
+// TODO: add DecodeBlob to interface to decode the blob and transactions or reuse DecodeTxsFromBlob but only have a single "chunk" for all transactions in the batch?
+
+// TODO: which of the Estimate* functions are needed?
+
+// JSONFromBytes converts the bytes to a DABatch and then marshals it to JSON.
+func (d *DACodecV6) JSONFromBytes(data []byte) ([]byte, error) {
+	batch, err := d.NewDABatchFromBytes(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode DABatch from bytes: %w", err)
+	}
+
+	jsonBytes, err := json.Marshal(batch)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal DABatch to JSON, version %d, hash %s: %w", batch.Version(), batch.Hash(), err)
+	}
+
+	return jsonBytes, nil
+}

encoding/codecv6_types.go

@@ -0,0 +1,135 @@
+package encoding
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
+)
+
+// daBatchV3 contains metadata about a batch of DAChunks.
+type daBatchV6 struct {
+	version           CodecVersion
+	batchIndex        uint64
+	parentBatchHash   common.Hash
+	blobVersionedHash common.Hash
+
+	blob      *kzg4844.Blob
+	z         *kzg4844.Point
+	blobBytes []byte
+}
+
+// newDABatchV6 is a constructor for daBatchV6 that calls blobDataProofForPICircuit internally.
+func newDABatchV6(version CodecVersion, batchIndex uint64, parentBatchHash, blobVersionedHash common.Hash, blob *kzg4844.Blob, z *kzg4844.Point, blobBytes []byte) (*daBatchV6, error) {
+	daBatch := &daBatchV6{
+		version:           version,
+		batchIndex:        batchIndex,
+		parentBatchHash:   parentBatchHash,
+		blobVersionedHash: blobVersionedHash,
+		blob:              blob,
+		z:                 z,
+		blobBytes:         blobBytes,
+	}
+
+	return daBatch, nil
+}
+
+func decodeDABatchV6(data []byte) (*daBatchV6, error) {
+	if len(data) != daBatchV6EncodedLength {
+		return nil, fmt.Errorf("invalid data length for DABatchV6, expected %d bytes but got %d", daBatchV6EncodedLength, len(data))
+	}
+
+	version := CodecVersion(data[daBatchOffsetVersion])
+	batchIndex := binary.BigEndian.Uint64(data[daBatchOffsetBatchIndex:daBatchV6OffsetBlobVersionedHash])
+	blobVersionedHash := common.BytesToHash(data[daBatchV6OffsetBlobVersionedHash:daBatchV6OffsetParentBatchHash])
+	parentBatchHash := common.BytesToHash(data[daBatchV6OffsetParentBatchHash:daBatchV6EncodedLength])
+
+	return newDABatchV6(version, batchIndex, parentBatchHash, blobVersionedHash, nil, nil, nil)
+}
+
+// Encode serializes the DABatchV3 into bytes.
+func (b *daBatchV6) Encode() []byte {
+	batchBytes := make([]byte, daBatchV6EncodedLength)
+	batchBytes[daBatchOffsetVersion] = byte(b.version)
+	binary.BigEndian.PutUint64(batchBytes[daBatchOffsetBatchIndex:daBatchV6OffsetBlobVersionedHash], b.batchIndex)
+	copy(batchBytes[daBatchV6OffsetBlobVersionedHash:daBatchV6OffsetParentBatchHash], b.blobVersionedHash[:])
+	copy(batchBytes[daBatchV6OffsetParentBatchHash:daBatchV6EncodedLength], b.parentBatchHash[:])
+	return batchBytes
+}
+
+// Hash computes the hash of the serialized DABatch.
+func (b *daBatchV6) Hash() common.Hash {
+	return crypto.Keccak256Hash(b.Encode())
+}
+
+// BlobDataProofForPointEvaluation computes the abi-encoded blob verification data.
+func (b *daBatchV6) BlobDataProofForPointEvaluation() ([]byte, error) {
+	if b.blob == nil {
+		return nil, errors.New("called BlobDataProofForPointEvaluation with empty blob")
+	}
+	if b.z == nil {
+		return nil, errors.New("called BlobDataProofForPointEvaluation with empty z")
+	}
+
+	commitment, err := kzg4844.BlobToCommitment(b.blob)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create blob commitment: %w", err)
+	}
+
+	proof, y, err := kzg4844.ComputeProof(b.blob, *b.z)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create KZG proof at point, err: %w, z: %v", err, hex.EncodeToString(b.z[:]))
+	}
+
+	return blobDataProofFromValues(*b.z, y, commitment, proof), nil
+}
+
+// Blob returns the blob of the batch.
+func (b *daBatchV6) Blob() *kzg4844.Blob {
+	return b.blob
+}
+
+// BlobBytes returns the blob bytes of the batch.
+func (b *daBatchV6) BlobBytes() []byte {
+	return b.blobBytes
+}
+
+// MarshalJSON implements the custom JSON serialization for daBatchV3.
+// This method is designed to provide prover with batch info in snake_case format.
+func (b *daBatchV6) MarshalJSON() ([]byte, error) {
+	type daBatchV6JSON struct {
+		Version           CodecVersion `json:"version"`
+		BatchIndex        uint64       `json:"batch_index"`
+		BlobVersionedHash string       `json:"blob_versioned_hash"`
+		ParentBatchHash   string       `json:"parent_batch_hash"`
+	}
+
+	return json.Marshal(&daBatchV6JSON{
+		Version:           b.version,
+		BatchIndex:        b.batchIndex,
+		BlobVersionedHash: b.blobVersionedHash.Hex(),
+		ParentBatchHash:   b.parentBatchHash.Hex(),
+	})
+}
+
+// Version returns the version of the DABatch.
+func (b *daBatchV6) Version() CodecVersion {
+	return b.version
+}
+
+// SkippedL1MessageBitmap returns the skipped L1 message bitmap of the DABatch.
+// For daBatchV6, there is no skipped L1 message bitmap.
+func (b *daBatchV6) SkippedL1MessageBitmap() []byte {
+	return nil
+}
+
+// DataHash returns the data hash of the DABatch.
+// For daBatchV6, there is no data hash.
+func (b *daBatchV6) DataHash() common.Hash {
+	return common.Hash{}
+}

encoding/da.go

@@ -77,6 +77,12 @@ const (
 	daBatchV3EncodedLength              = 193
 )
 
+const (
+	daBatchV6EncodedLength           = 73
+	daBatchV6OffsetBlobVersionedHash = 9
+	daBatchV6OffsetParentBatchHash   = 41
+)
+
 const (
 	payloadLengthBytes                 = 4
 	calldataNonZeroByteGas             = 16

encoding/interfaces.go

@@ -76,6 +76,8 @@ const (
 	CodecV2
 	CodecV3
 	CodecV4
+	_ // CodecV5 is skipped
+	CodecV6
 )
 
 // CodecFromVersion returns the appropriate codec for the given version.
@@ -91,14 +93,18 @@ func CodecFromVersion(version CodecVersion) (Codec, error) {
 		return &DACodecV3{}, nil
 	case CodecV4:
 		return &DACodecV4{}, nil
+	case CodecV6:
+		return &DACodecV6{}, nil
 	default:
 		return nil, fmt.Errorf("unsupported codec version: %v", version)
 	}
 }
 
 // CodecFromConfig determines and returns the appropriate codec based on chain configuration, block number, and timestamp.
 func CodecFromConfig(chainCfg *params.ChainConfig, startBlockNumber *big.Int, startBlockTimestamp uint64) Codec {
-	if chainCfg.IsDarwinV2(startBlockTimestamp) {
+	if chainCfg.IsDarwinV2(startBlockTimestamp) { // TODO: replace with correct fork
+		return &DACodecV6{}
+	} else if chainCfg.IsDarwinV2(startBlockTimestamp) {
 		return &DACodecV4{}
 	} else if chainCfg.IsDarwin(startBlockTimestamp) {
 		return &DACodecV3{}