feat(rollup-verifier): codecv4

core/rawdb/accessors_rollup_event.go

@@ -16,6 +16,13 @@ type ChunkBlockRange struct {
 	EndBlockNumber   uint64
 }
 
+// CommittedBatchMeta holds metadata for committed batches.
+type CommittedBatchMeta struct {
+	Version             uint8
+	BlobVersionedHashes []common.Hash
+	ChunkBlockRanges    []*ChunkBlockRange
+}
+
 // FinalizedBatchMeta holds metadata for finalized batches.
 type FinalizedBatchMeta struct {
 	BatchHash            common.Hash
@@ -53,6 +60,7 @@ func ReadRollupEventSyncedL1BlockNumber(db ethdb.Reader) *uint64 {
 
 // WriteBatchChunkRanges writes the block ranges for each chunk within a batch to the database.
 // It serializes the chunk ranges using RLP and stores them under a key derived from the batch index.
+// for backward compatibility, new info is also stored in CommittedBatchMeta.
 func WriteBatchChunkRanges(db ethdb.KeyValueWriter, batchIndex uint64, chunkBlockRanges []*ChunkBlockRange) {
 	value, err := rlp.EncodeToBytes(chunkBlockRanges)
 	if err != nil {
@@ -65,6 +73,7 @@ func WriteBatchChunkRanges(db ethdb.KeyValueWriter, batchIndex uint64, chunkBloc
 
 // DeleteBatchChunkRanges removes the block ranges of all chunks associated with a specific batch from the database.
 // Note: Only non-finalized batches can be reverted.
+// for backward compatibility, new info is also stored in CommittedBatchMeta.
 func DeleteBatchChunkRanges(db ethdb.KeyValueWriter, batchIndex uint64) {
 	if err := db.Delete(batchChunkRangesKey(batchIndex)); err != nil {
 		log.Crit("failed to delete batch chunk ranges", "batch index", batchIndex, "err", err)
@@ -73,6 +82,7 @@ func DeleteBatchChunkRanges(db ethdb.KeyValueWriter, batchIndex uint64) {
 
 // ReadBatchChunkRanges retrieves the block ranges of all chunks associated with a specific batch from the database.
 // It returns a list of ChunkBlockRange pointers, or nil if no chunk ranges are found for the given batch index.
+// for backward compatibility, new info is also stored in CommittedBatchMeta.
 func ReadBatchChunkRanges(db ethdb.Reader, batchIndex uint64) []*ChunkBlockRange {
 	data, err := db.Get(batchChunkRangesKey(batchIndex))
 	if err != nil && isNotFoundErr(err) {
@@ -91,13 +101,12 @@ func ReadBatchChunkRanges(db ethdb.Reader, batchIndex uint64) []*ChunkBlockRange
 
 // WriteFinalizedBatchMeta stores the metadata of a finalized batch in the database.
 func WriteFinalizedBatchMeta(db ethdb.KeyValueWriter, batchIndex uint64, finalizedBatchMeta *FinalizedBatchMeta) {
-	var err error
 	value, err := rlp.EncodeToBytes(finalizedBatchMeta)
 	if err != nil {
-		log.Crit("failed to RLP encode batch metadata", "batch index", batchIndex, "finalized batch meta", finalizedBatchMeta, "err", err)
+		log.Crit("failed to RLP encode finalized batch metadata", "batch index", batchIndex, "finalized batch meta", finalizedBatchMeta, "err", err)
 	}
 	if err := db.Put(batchMetaKey(batchIndex), value); err != nil {
-		log.Crit("failed to store batch metadata", "batch index", batchIndex, "value", value, "err", err)
+		log.Crit("failed to store finalized batch metadata", "batch index", batchIndex, "value", value, "err", err)
 	}
 }
 
@@ -171,3 +180,31 @@ func ReadLastFinalizedBatchIndex(db ethdb.Reader) *uint64 {
 	lastFinalizedBatchIndex := number.Uint64()
 	return &lastFinalizedBatchIndex
 }
+
+// WriteCommittedBatchMeta stores the CommittedBatchMeta for a specific batch in the database.
+func WriteCommittedBatchMeta(db ethdb.KeyValueWriter, batchIndex uint64, committedBatchMeta *CommittedBatchMeta) {
+	value, err := rlp.EncodeToBytes(committedBatchMeta)
+	if err != nil {
+		log.Crit("failed to RLP encode committed batch metadata", "batch index", batchIndex, "committed batch meta", committedBatchMeta, "err", err)
+	}
+	if err := db.Put(committedBatchMetaKey(batchIndex), value); err != nil {
+		log.Crit("failed to store committed batch metadata", "batch index", batchIndex, "value", value, "err", err)
+	}
+}
+
+// ReadCommittedBatchMeta fetches the CommittedBatchMeta for a specific batch from the database.
+func ReadCommittedBatchMeta(db ethdb.Reader, batchIndex uint64) *CommittedBatchMeta {
+	data, err := db.Get(committedBatchMetaKey(batchIndex))
+	if err != nil && isNotFoundErr(err) {
+		return nil
+	}
+	if err != nil {
+		log.Crit("failed to read committed batch metadata from database", "batch index", batchIndex, "err", err)
+	}
+
+	cbm := new(CommittedBatchMeta)
+	if err := rlp.Decode(bytes.NewReader(data), cbm); err != nil {
+		log.Crit("Invalid CommittedBatchMeta RLP", "batch index", batchIndex, "data", data, "err", err)
+	}
+	return cbm
+}

core/rawdb/accessors_rollup_event_test.go

@@ -210,3 +210,118 @@ func TestBatchChunkRanges(t *testing.T) {
 	// delete non-existing value: ensure the delete operation handles non-existing values without errors.
 	DeleteBatchChunkRanges(db, uint64(len(chunks)+1))
 }
+
+func TestWriteReadCommittedBatchMeta(t *testing.T) {
+	db := NewMemoryDatabase()
+
+	testCases := []struct {
+		batchIndex uint64
+		meta       *CommittedBatchMeta
+	}{
+		{
+			batchIndex: 0,
+			meta: &CommittedBatchMeta{
+				Version:             0,
+				BlobVersionedHashes: []common.Hash{},
+				ChunkBlockRanges:    []*ChunkBlockRange{},
+			},
+		},
+		{
+			batchIndex: 1,
+			meta: &CommittedBatchMeta{
+				Version:             1,
+				BlobVersionedHashes: []common.Hash{common.HexToHash("0x1234")},
+				ChunkBlockRanges:    []*ChunkBlockRange{{StartBlockNumber: 0, EndBlockNumber: 10}},
+			},
+		},
+		{
+			batchIndex: 255,
+			meta: &CommittedBatchMeta{
+				Version:             255,
+				BlobVersionedHashes: []common.Hash{common.HexToHash("0xabcd"), common.HexToHash("0xef01")},
+				ChunkBlockRanges:    []*ChunkBlockRange{{StartBlockNumber: 0, EndBlockNumber: 10}, {StartBlockNumber: 11, EndBlockNumber: 20}},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		WriteCommittedBatchMeta(db, tc.batchIndex, tc.meta)
+		got := ReadCommittedBatchMeta(db, tc.batchIndex)
+
+		if got == nil {
+			t.Fatalf("Expected non-nil value for batch index %d", tc.batchIndex)
+		}
+
+		if !compareCommittedBatchMeta(tc.meta, got) {
+			t.Fatalf("CommittedBatchMeta mismatch for batch index %d, expected %+v, got %+v", tc.batchIndex, tc.meta, got)
+		}
+	}
+
+	// reading a non-existing value
+	if got := ReadCommittedBatchMeta(db, 256); got != nil {
+		t.Fatalf("Expected nil for non-existing value, got %+v", got)
+	}
+}
+
+func TestOverwriteCommittedBatchMeta(t *testing.T) {
+	db := NewMemoryDatabase()
+
+	batchIndex := uint64(42)
+	initialMeta := &CommittedBatchMeta{
+		Version:             1,
+		BlobVersionedHashes: []common.Hash{common.HexToHash("0x1234")},
+		ChunkBlockRanges:    []*ChunkBlockRange{{StartBlockNumber: 0, EndBlockNumber: 10}},
+	}
+	newMeta := &CommittedBatchMeta{
+		Version:             2,
+		BlobVersionedHashes: []common.Hash{common.HexToHash("0x5678"), common.HexToHash("0x9abc")},
+		ChunkBlockRanges:    []*ChunkBlockRange{{StartBlockNumber: 0, EndBlockNumber: 20}, {StartBlockNumber: 21, EndBlockNumber: 30}},
+	}
+
+	// write initial meta
+	WriteCommittedBatchMeta(db, batchIndex, initialMeta)
+	got := ReadCommittedBatchMeta(db, batchIndex)
+
+	if !compareCommittedBatchMeta(initialMeta, got) {
+		t.Fatalf("Initial write failed, expected %+v, got %+v", initialMeta, got)
+	}
+
+	// overwrite with new meta
+	WriteCommittedBatchMeta(db, batchIndex, newMeta)
+	got = ReadCommittedBatchMeta(db, batchIndex)
+
+	if !compareCommittedBatchMeta(newMeta, got) {
+		t.Fatalf("Overwrite failed, expected %+v, got %+v", newMeta, got)
+	}
+
+	// read non-existing batch index
+	nonExistingIndex := uint64(999)
+	got = ReadCommittedBatchMeta(db, nonExistingIndex)
+
+	if got != nil {
+		t.Fatalf("Expected nil for non-existing batch index, got %+v", got)
+	}
+}
+
+func compareCommittedBatchMeta(a, b *CommittedBatchMeta) bool {
+	if a.Version != b.Version {
+		return false
+	}
+	if len(a.BlobVersionedHashes) != len(b.BlobVersionedHashes) {
+		return false
+	}
+	for i := range a.BlobVersionedHashes {
+		if a.BlobVersionedHashes[i] != b.BlobVersionedHashes[i] {
+			return false
+		}
+	}
+	if len(a.ChunkBlockRanges) != len(b.ChunkBlockRanges) {
+		return false
+	}
+	for i := range a.ChunkBlockRanges {
+		if a.ChunkBlockRanges[i].StartBlockNumber != b.ChunkBlockRanges[i].StartBlockNumber || a.ChunkBlockRanges[i].EndBlockNumber != b.ChunkBlockRanges[i].EndBlockNumber {
+			return false
+		}
+	}
+	return true
+}

core/rawdb/schema.go

@@ -116,6 +116,7 @@ var (
 	batchMetaPrefix                   = []byte("R-bm")
 	finalizedL2BlockNumberKey         = []byte("R-finalized")
 	lastFinalizedBatchIndexKey        = []byte("R-finalizedBatchIndex")
+	committedBatchMetaPrefix          = []byte("R-cbm")
 
 	// Row consumption
 	rowConsumptionPrefix = []byte("rc") // rowConsumptionPrefix + hash -> row consumption by block
@@ -309,3 +310,8 @@ func batchChunkRangesKey(batchIndex uint64) []byte {
 func batchMetaKey(batchIndex uint64) []byte {
 	return append(batchMetaPrefix, encodeBigEndian(batchIndex)...)
 }
+
+// committedBatchMetaKey = committedBatchMetaPrefix + batch index (uint64 big endian)
+func committedBatchMetaKey(batchIndex uint64) []byte {
+	return append(committedBatchMetaPrefix, encodeBigEndian(batchIndex)...)
+}

go.mod

@@ -50,7 +50,7 @@ require (
 	github.com/prometheus/tsdb v0.7.1
 	github.com/rjeczalik/notify v0.9.1
 	github.com/rs/cors v1.7.0
-	github.com/scroll-tech/da-codec v0.1.1-0.20240718144756-1875fd490923
+	github.com/scroll-tech/da-codec v0.1.1-0.20240822151711-9e32313056ac
 	github.com/scroll-tech/zktrie v0.8.4
 	github.com/shirou/gopsutil v3.21.11+incompatible
 	github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4

go.sum

@@ -392,8 +392,8 @@ github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncj
 github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.1-0.20240718144756-1875fd490923 h1:A1ItzpnFDCHMh4g6cpeBZf7/fPf2lfwHbhjr/FSpk2w=
-github.com/scroll-tech/da-codec v0.1.1-0.20240718144756-1875fd490923/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/da-codec v0.1.1-0.20240822151711-9e32313056ac h1:DjLrqjoOLVFug9ZkAbJYwjtYW51YZE0Num3p4cZXaZs=
+github.com/scroll-tech/da-codec v0.1.1-0.20240822151711-9e32313056ac/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
 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/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=

params/version.go

@@ -24,7 +24,7 @@ import (
 const (
 	VersionMajor = 5         // Major version component of the current release
 	VersionMinor = 6         // Minor version component of the current release
-	VersionPatch = 2         // Patch version component of the current release
+	VersionPatch = 3         // Patch version component of the current release
 	VersionMeta  = "mainnet" // Version metadata to append to the version string
 )