refactor(batch): removing db fields in batch encoding type (#1196)

tests/integration-test/integration_test.go

@@ -22,7 +22,6 @@ import (
 	"scroll-tech/common/database"
 	"scroll-tech/common/docker"
 	"scroll-tech/common/types/encoding"
-	"scroll-tech/common/types/encoding/codecv0"
 	"scroll-tech/common/utils"
 	"scroll-tech/common/version"
 
@@ -93,22 +92,11 @@ func TestCoordinatorProverInteraction(t *testing.T) {
 		RowConsumption: &gethTypes.RowConsumption{},
 	}
 	chunk := &encoding.Chunk{Blocks: []*encoding.Block{block}}
-
-	daChunk, err := codecv0.NewDAChunk(chunk, 0)
-	assert.NoError(t, err)
-
-	daChunkHash, err := daChunk.Hash()
-	assert.NoError(t, err)
-
 	batch := &encoding.Batch{
 		Index:                      0,
 		TotalL1MessagePoppedBefore: 0,
 		ParentBatchHash:            common.Hash{},
 		Chunks:                     []*encoding.Chunk{chunk},
-		StartChunkIndex:            0,
-		EndChunkIndex:              0,
-		StartChunkHash:             daChunkHash,
-		EndChunkHash:               daChunkHash,
 	}
 
 	err = l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block})

tests/integration-test/orm/batch.go

@@ -73,6 +73,9 @@ func (o *Batch) GetLatestBatch(ctx context.Context) (*Batch, error) {
 
 	var latestBatch Batch
 	if err := db.First(&latestBatch).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
 		return nil, fmt.Errorf("Batch.GetLatestBatch error: %w", err)
 	}
 	return &latestBatch, nil
@@ -85,21 +88,73 @@ func (o *Batch) InsertBatch(ctx context.Context, batch *encoding.Batch, dbTX ...
 		return nil, errors.New("invalid args: batch is nil")
 	}
 
+	numChunks := uint64(len(batch.Chunks))
+	if numChunks == 0 {
+		return nil, errors.New("invalid args: batch contains 0 chunk")
+	}
+
 	daBatch, err := codecv0.NewDABatch(batch)
 	if err != nil {
 		log.Error("failed to create new DA batch",
 			"index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
-			"parent hash", batch.ParentBatchHash, "number of chunks", len(batch.Chunks), "err", err)
+			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
 		return nil, err
 	}
 
+	var startChunkIndex uint64
+	parentBatch, err := o.GetLatestBatch(ctx)
+	if err != nil {
+		log.Error("failed to get latest batch", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
+			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
+		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
+	}
+
+	// if parentBatch==nil then err==gorm.ErrRecordNotFound, which means there's
+	// no batch record in the db, we then use default empty values for the creating batch;
+	// if parentBatch!=nil then err==nil, then we fill the parentBatch-related data into the creating batch
+	if parentBatch != nil {
+		startChunkIndex = parentBatch.EndChunkIndex + 1
+	}
+
+	startDAChunk, err := codecv0.NewDAChunk(batch.Chunks[0], batch.TotalL1MessagePoppedBefore)
+	if err != nil {
+		log.Error("failed to create start DA chunk", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
+			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
+		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
+	}
+
+	startDAChunkHash, err := startDAChunk.Hash()
+	if err != nil {
+		log.Error("failed to get start DA chunk hash", "index", batch.Index, "total l1 message popped before", batch.TotalL1MessagePoppedBefore,
+			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
+		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
+	}
+
+	totalL1MessagePoppedBeforeEndDAChunk := batch.TotalL1MessagePoppedBefore
+	for i := uint64(0); i < numChunks-1; i++ {
+		totalL1MessagePoppedBeforeEndDAChunk += batch.Chunks[i].NumL1Messages(totalL1MessagePoppedBeforeEndDAChunk)
+	}
+	endDAChunk, err := codecv0.NewDAChunk(batch.Chunks[numChunks-1], totalL1MessagePoppedBeforeEndDAChunk)
+	if err != nil {
+		log.Error("failed to create end DA chunk", "index", batch.Index, "total l1 message popped before", totalL1MessagePoppedBeforeEndDAChunk,
+			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
+		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
+	}
+
+	endDAChunkHash, err := endDAChunk.Hash()
+	if err != nil {
+		log.Error("failed to get end DA chunk hash", "index", batch.Index, "total l1 message popped before", totalL1MessagePoppedBeforeEndDAChunk,
+			"parent hash", batch.ParentBatchHash, "number of chunks", numChunks, "err", err)
+		return nil, fmt.Errorf("Batch.InsertBatch error: %w", err)
+	}
+
 	newBatch := Batch{
 		Index:             batch.Index,
 		Hash:              daBatch.Hash().Hex(),
-		StartChunkHash:    batch.StartChunkHash.Hex(),
-		StartChunkIndex:   batch.StartChunkIndex,
-		EndChunkHash:      batch.EndChunkHash.Hex(),
-		EndChunkIndex:     batch.EndChunkIndex,
+		StartChunkHash:    startDAChunkHash.Hex(),
+		StartChunkIndex:   startChunkIndex,
+		EndChunkHash:      endDAChunkHash.Hex(),
+		EndChunkIndex:     startChunkIndex + numChunks - 1,
 		StateRoot:         batch.StateRoot().Hex(),
 		WithdrawRoot:      batch.WithdrawRoot().Hex(),
 		ParentBatchHash:   batch.ParentBatchHash.Hex(),

tests/integration-test/orm/chunk.go

@@ -63,15 +63,18 @@ func (*Chunk) TableName() string {
 	return "chunk"
 }
 
-// GetLatestChunk retrieves the latest chunk from the database.
-func (o *Chunk) GetLatestChunk(ctx context.Context) (*Chunk, error) {
+// getLatestChunk retrieves the latest chunk from the database.
+func (o *Chunk) getLatestChunk(ctx context.Context) (*Chunk, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&Chunk{})
 	db = db.Order("index desc")
 
 	var latestChunk Chunk
 	if err := db.First(&latestChunk).Error; err != nil {
-		return nil, fmt.Errorf("Chunk.GetLatestChunk error: %w", err)
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("Chunk.getLatestChunk error: %w", err)
 	}
 	return &latestChunk, nil
 }
@@ -87,15 +90,15 @@ func (o *Chunk) InsertChunk(ctx context.Context, chunk *encoding.Chunk, dbTX ...
 	var totalL1MessagePoppedBefore uint64
 	var parentChunkHash string
 	var parentChunkStateRoot string
-	parentChunk, err := o.GetLatestChunk(ctx)
-	if err != nil && !errors.Is(errors.Unwrap(err), gorm.ErrRecordNotFound) {
+	parentChunk, err := o.getLatestChunk(ctx)
+	if err != nil {
 		log.Error("failed to get latest chunk", "err", err)
 		return nil, fmt.Errorf("Chunk.InsertChunk error: %w", err)
 	}
 
 	// if parentChunk==nil then err==gorm.ErrRecordNotFound, which means there's
-	// not chunk record in the db, we then use default empty values for the creating chunk;
-	// if parentChunk!=nil then err=nil, then we fill the parentChunk-related data into the creating chunk
+	// no chunk record in the db, we then use default empty values for the creating chunk;
+	// if parentChunk!=nil then err==nil, then we fill the parentChunk-related data into the creating chunk
 	if parentChunk != nil {
 		chunkIndex = parentChunk.Index + 1
 		totalL1MessagePoppedBefore = parentChunk.TotalL1MessagesPoppedBefore + parentChunk.TotalL1MessagesPoppedInChunk