compare the batch hashes of the calldata + blob hash vs database

Author: colinlyguo

rollup/internal/controller/relayer/l2_relayer_sanity.go

@@ -2,9 +2,11 @@ package relayer
 
 import (
 	"fmt"
+	"math/big"
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/crypto/kzg4844"
 
 	"scroll-tech/rollup/internal/orm"
@@ -28,22 +30,14 @@ func (r *Layer2Relayer) sanityChecksCommitBatchCodecV7CalldataAndBlobs(calldata
 		return fmt.Errorf("failed to get batches from database: %w", err)
 	}
 
-	if len(blobs) != len(batchesToValidate) {
-		return fmt.Errorf("blob count mismatch: got %d blobs, expected %d batches", len(blobs), len(batchesToValidate))
-	}
-
-	if err := r.validateCalldataAgainstDatabase(calldataInfo, firstBatch, lastBatch); err != nil {
-		return fmt.Errorf("calldata validation failed: %w", err)
+	if err := r.validateCalldataAndBlobsAgainstDatabase(calldataInfo, blobs, batchesToValidate, firstBatch, lastBatch); err != nil {
+		return fmt.Errorf("calldata and blobs validation failed: %w", err)
 	}
 
 	if err := r.validateDatabaseConsistency(batchesToValidate); err != nil {
 		return fmt.Errorf("database consistency validation failed: %w", err)
 	}
 
-	if err := r.validateBlobsAgainstDatabase(blobs, batchesToValidate); err != nil {
-		return fmt.Errorf("blob validation failed: %w", err)
-	}
-
 	return nil
 }
 
@@ -138,26 +132,6 @@ func (r *Layer2Relayer) getBatchesFromCalldata(info *CalldataInfo) ([]*dbBatchWi
 	return batchesToValidate, firstBatch, lastBatch, nil
 }
 
-// validateCalldataAgainstDatabase validates calldata parameters against database records
-func (r *Layer2Relayer) validateCalldataAgainstDatabase(info *CalldataInfo, firstBatch, lastBatch *orm.Batch) error {
-	// Validate codec version
-	if info.Version != uint8(firstBatch.CodecVersion) {
-		return fmt.Errorf("version mismatch: calldata=%d, db=%d", info.Version, firstBatch.CodecVersion)
-	}
-
-	// Validate parent batch hash
-	if info.ParentBatchHash != common.HexToHash(firstBatch.ParentBatchHash) {
-		return fmt.Errorf("parentBatchHash mismatch: calldata=%s, db=%s", info.ParentBatchHash.Hex(), firstBatch.ParentBatchHash)
-	}
-
-	// Validate last batch hash
-	if info.LastBatchHash != common.HexToHash(lastBatch.Hash) {
-		return fmt.Errorf("lastBatchHash mismatch: calldata=%s, db=%s", info.LastBatchHash.Hex(), lastBatch.Hash)
-	}
-
-	return nil
-}
-
 // validateDatabaseConsistency performs comprehensive validation of database records
 func (r *Layer2Relayer) validateDatabaseConsistency(batchesToValidate []*dbBatchWithChunks) error {
 	if len(batchesToValidate) == 0 {
@@ -328,10 +302,29 @@ func (r *Layer2Relayer) validateSingleChunkConsistency(chunk *orm.Chunk, prevChu
 	return nil
 }
 
-// validateBlobsAgainstDatabase validates blobs against database records
-func (r *Layer2Relayer) validateBlobsAgainstDatabase(blobs []*kzg4844.Blob, batchesToValidate []*dbBatchWithChunks) error {
+// validateCalldataAndBlobsAgainstDatabase validates calldata and blobs against database records
+func (r *Layer2Relayer) validateCalldataAndBlobsAgainstDatabase(calldataInfo *CalldataInfo, blobs []*kzg4844.Blob, batchesToValidate []*dbBatchWithChunks, firstBatch, lastBatch *orm.Batch) error {
+	// Validate blob count
+	if len(blobs) != len(batchesToValidate) {
+		return fmt.Errorf("blob count mismatch: got %d blobs, expected %d batches", len(blobs), len(batchesToValidate))
+	}
+
+	// Validate codec version
+	if calldataInfo.Version != uint8(firstBatch.CodecVersion) {
+		return fmt.Errorf("version mismatch: calldata=%d, db=%d", calldataInfo.Version, firstBatch.CodecVersion)
+	}
+
+	// Validate parent batch hash
+	if calldataInfo.ParentBatchHash != common.HexToHash(firstBatch.ParentBatchHash) {
+		return fmt.Errorf("parentBatchHash mismatch: calldata=%s, db=%s", calldataInfo.ParentBatchHash.Hex(), firstBatch.ParentBatchHash)
+	}
+
+	// Validate last batch hash
+	if calldataInfo.LastBatchHash != common.HexToHash(lastBatch.Hash) {
+		return fmt.Errorf("lastBatchHash mismatch: calldata=%s, db=%s", calldataInfo.LastBatchHash.Hex(), lastBatch.Hash)
+	}
+
 	// Get codec for blob decoding
-	firstBatch := batchesToValidate[0].Batch
 	codec, err := encoding.CodecFromVersion(encoding.CodecVersion(firstBatch.CodecVersion))
 	if err != nil {
 		return fmt.Errorf("failed to get codec: %w", err)
@@ -340,9 +333,7 @@ func (r *Layer2Relayer) validateBlobsAgainstDatabase(blobs []*kzg4844.Blob, batc
 	// Validate each blob against its corresponding batch
 	for i, blob := range blobs {
 		dbBatch := batchesToValidate[i].Batch
-		dbChunks := batchesToValidate[i].Chunks
-
-		if err := r.validateSingleBlobAgainstBatch(blob, dbBatch, dbChunks, codec); err != nil {
+		if err := r.validateSingleBlobAgainstBatch(calldataInfo, blob, dbBatch, codec); err != nil {
 			return fmt.Errorf("blob validation failed for batch %d: %w", dbBatch.Index, err)
 		}
 	}
@@ -351,53 +342,21 @@ func (r *Layer2Relayer) validateBlobsAgainstDatabase(blobs []*kzg4844.Blob, batc
 }
 
 // validateSingleBlobAgainstBatch validates a single blob against its batch data
-func (r *Layer2Relayer) validateSingleBlobAgainstBatch(blob *kzg4844.Blob, dbBatch *orm.Batch, dbChunks []*orm.Chunk, codec encoding.Codec) error {
-	// Collect all blocks for the batch
-	var batchBlocks []*encoding.Block
-	for _, c := range dbChunks {
-		blocks, err := r.l2BlockOrm.GetL2BlocksInRange(r.ctx, c.StartBlockNumber, c.EndBlockNumber)
-		if err != nil {
-			return fmt.Errorf("failed to get blocks for chunk %d: %w", c.Index, err)
-		}
-
-		if len(blocks) == 0 {
-			return fmt.Errorf("chunk %d has no blocks in range [%d, %d]", c.Index, c.StartBlockNumber, c.EndBlockNumber)
-		}
-
-		// Verify block count matches expected range
-		expectedBlockCount := c.EndBlockNumber - c.StartBlockNumber + 1
-		if len(blocks) != int(expectedBlockCount) {
-			return fmt.Errorf("chunk %d expected %d blocks but got %d", c.Index, expectedBlockCount, len(blocks))
-		}
-
-		batchBlocks = append(batchBlocks, blocks...)
-	}
-
+func (r *Layer2Relayer) validateSingleBlobAgainstBatch(calldataInfo *CalldataInfo, blob *kzg4844.Blob, dbBatch *orm.Batch, codec encoding.Codec) error {
 	// Decode blob payload
 	payload, err := codec.DecodeBlob(blob)
 	if err != nil {
 		return fmt.Errorf("failed to decode blob: %w", err)
 	}
 
-	// Validate L1 message queue hashes
-	if payload.PrevL1MessageQueueHash() != common.HexToHash(dbBatch.PrevL1MessageQueueHash) {
-		return fmt.Errorf("prevL1MessageQueueHash mismatch: decoded=%s, db=%s", payload.PrevL1MessageQueueHash().Hex(), dbBatch.PrevL1MessageQueueHash)
-	}
-
-	if payload.PostL1MessageQueueHash() != common.HexToHash(dbBatch.PostL1MessageQueueHash) {
-		return fmt.Errorf("postL1MessageQueueHash mismatch: decoded=%s, db=%s", payload.PostL1MessageQueueHash().Hex(), dbBatch.PostL1MessageQueueHash)
+	// Validate batch hash
+	daBatch, err := assembleDABatchFromPayload(calldataInfo, payload, dbBatch, codec)
+	if err != nil {
+		return fmt.Errorf("failed to assemble batch from payload: %w", err)
 	}
 
-	// Validate block data
-	decodedBlocks := payload.Blocks()
-	if len(decodedBlocks) != len(batchBlocks) {
-		return fmt.Errorf("block count mismatch: decoded=%d, db=%d", len(decodedBlocks), len(batchBlocks))
-	}
-
-	for j, dbBlock := range batchBlocks {
-		if decodedBlocks[j].Number() != dbBlock.Header.Number.Uint64() {
-			return fmt.Errorf("block number mismatch at index %d: decoded=%d, db=%d", j, decodedBlocks[j].Number(), dbBlock.Header.Number.Uint64())
-		}
+	if daBatch.Hash() != common.HexToHash(dbBatch.Hash) {
+		return fmt.Errorf("batch hash mismatch: decoded from blob=%s, db=%s", daBatch.Hash().Hex(), dbBatch.Hash)
 	}
 
 	return nil
@@ -436,3 +395,51 @@ func (r *Layer2Relayer) validateMessageQueueConsistency(batchIndex uint64, chunk
 
 	return nil
 }
+
+func assembleDABatchFromPayload(calldataInfo *CalldataInfo, payload encoding.DABlobPayload, dbBatch *orm.Batch, codec encoding.Codec) (encoding.DABatch, error) {
+	blocks, err := assembleBlocksFromPayload(payload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to assemble blocks from payload batch_index=%d codec_version=%d parent_batch_hash=%s: %w", dbBatch.Index, dbBatch.CodecVersion, calldataInfo.ParentBatchHash.Hex(), err)
+	}
+	parentBatchHash := calldataInfo.ParentBatchHash
+	batch := &encoding.Batch{
+		Index:                  dbBatch.Index, // The database provides only batch index, other fields are derived from blob payload
+		ParentBatchHash:        parentBatchHash,
+		PrevL1MessageQueueHash: payload.PrevL1MessageQueueHash(),
+		PostL1MessageQueueHash: payload.PostL1MessageQueueHash(),
+		Blocks:                 blocks,
+		Chunks: []*encoding.Chunk{ // One chunk for this batch to pass sanity checks when building DABatch
+			{
+				Blocks:                 blocks,
+				PrevL1MessageQueueHash: payload.PrevL1MessageQueueHash(),
+				PostL1MessageQueueHash: payload.PostL1MessageQueueHash(),
+			},
+		},
+	}
+	daBatch, err := codec.NewDABatch(batch)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build DABatch batch_index=%d codec_version=%d parent_batch_hash=%s: %w", dbBatch.Index, dbBatch.CodecVersion, calldataInfo.ParentBatchHash.Hex(), err)
+	}
+	return daBatch, nil
+}
+
+func assembleBlocksFromPayload(payload encoding.DABlobPayload) ([]*encoding.Block, error) {
+	daBlocks := payload.Blocks()
+	txss := payload.Transactions()
+	if len(daBlocks) != len(txss) {
+		return nil, fmt.Errorf("mismatched number of blocks and transactions: %d blocks, %d transactions", len(daBlocks), len(txss))
+	}
+	blocks := make([]*encoding.Block, len(daBlocks))
+	for i := range daBlocks {
+		blocks[i] = &encoding.Block{
+			Header: &types.Header{
+				Number:   new(big.Int).SetUint64(daBlocks[i].Number()),
+				Time:     daBlocks[i].Timestamp(),
+				BaseFee:  daBlocks[i].BaseFee(),
+				GasLimit: daBlocks[i].GasLimit(),
+			},
+			Transactions: encoding.TxsToTxsData(txss[i]),
+		}
+	}
+	return blocks, nil
+}