feat(rollup): sync finalized batches from L1

cmd/geth/main.go

@@ -165,6 +165,7 @@ var (
 		utils.L1ConfirmationsFlag,
 		utils.L1DeploymentBlockFlag,
 		utils.CircuitCapacityCheckEnabledFlag,
+		utils.RollupVerifyEnabledFlag,
 	}
 
 	rpcFlags = []cli.Flag{

cmd/utils/flags.go

@@ -836,6 +836,12 @@ var (
 		Usage: "Enable circuit capacity check during block validation",
 	}
 
+	// Rollup verify service settings
+	RollupVerifyEnabledFlag = cli.BoolFlag{
+		Name:  "rollup.verify",
+		Usage: "Enable verification of batch consistency between L1 and L2 in rollup",
+	}
+
 	// Max block range for `eth_getLogs` method
 	MaxBlockRangeFlag = cli.Int64Flag{
 		Name:  "rpc.getlogs.maxrange",
@@ -1546,6 +1552,12 @@ func setCircuitCapacityCheck(ctx *cli.Context, cfg *ethconfig.Config) {
 	}
 }
 
+func setEnableRollupVerify(ctx *cli.Context, cfg *ethconfig.Config) {
+	if ctx.GlobalIsSet(RollupVerifyEnabledFlag.Name) {
+		cfg.EnableRollupVerify = ctx.GlobalBool(RollupVerifyEnabledFlag.Name)
+	}
+}
+
 func setMaxBlockRange(ctx *cli.Context, cfg *ethconfig.Config) {
 	if ctx.GlobalIsSet(MaxBlockRangeFlag.Name) {
 		cfg.MaxBlockRange = ctx.GlobalInt64(MaxBlockRangeFlag.Name)
@@ -1620,6 +1632,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 	setWhitelist(ctx, cfg)
 	setLes(ctx, cfg)
 	setCircuitCapacityCheck(ctx, cfg)
+	setEnableRollupVerify(ctx, cfg)
 	setMaxBlockRange(ctx, cfg)
 
 	// Cap the cache allowance and tune the garbage collector

core/rawdb/accessors_rollup_event.go

@@ -0,0 +1,181 @@
+package rawdb
+
+import (
+	"bytes"
+	"math/big"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/ethdb"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rlp"
+)
+
+// ChunkBlockRange represents the range of blocks within a chunk.
+type ChunkBlockRange struct {
+	StartBlockNumber uint64
+	EndBlockNumber   uint64
+}
+
+// FinalizedBatchMeta holds metadata for finalized batches.
+type FinalizedBatchMeta struct {
+	BatchHash            common.Hash
+	TotalL1MessagePopped uint64 // total number of L1 messages popped before and in this batch.
+	StateRoot            common.Hash
+	WithdrawRoot         common.Hash
+}
+
+// WriteRollupEventSyncedL1BlockNumber stores the latest synced L1 block number related to rollup events in the database.
+func WriteRollupEventSyncedL1BlockNumber(db ethdb.KeyValueWriter, l1BlockNumber uint64) {
+	value := big.NewInt(0).SetUint64(l1BlockNumber).Bytes()
+	if err := db.Put(rollupEventSyncedL1BlockNumberKey, value); err != nil {
+		log.Crit("failed to store rollup event synced L1 block number for rollup event", "err", err)
+	}
+}
+
+// ReadRollupEventSyncedL1BlockNumber fetches the highest synced L1 block number associated with rollup events from the database.
+func ReadRollupEventSyncedL1BlockNumber(db ethdb.Reader) *uint64 {
+	data, err := db.Get(rollupEventSyncedL1BlockNumberKey)
+	if err != nil && isNotFoundErr(err) {
+		return nil
+	}
+	if err != nil {
+		log.Crit("failed to read rollup event synced L1 block number from database", "err", err)
+	}
+
+	number := new(big.Int).SetBytes(data)
+	if !number.IsUint64() {
+		log.Crit("unexpected rollup event synced L1 block number in database", "number", number)
+	}
+
+	rollupEventSyncedL1BlockNumber := number.Uint64()
+	return &rollupEventSyncedL1BlockNumber
+}
+
+// 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.
+func WriteBatchChunkRanges(db ethdb.KeyValueWriter, batchIndex uint64, chunkBlockRanges []*ChunkBlockRange) {
+	bytes, err := rlp.EncodeToBytes(chunkBlockRanges)
+	if err != nil {
+		log.Crit("failed to RLP encode batch chunk ranges", "batch index", batchIndex, "err", err)
+	}
+	if err := db.Put(batchChunkRangesKey(batchIndex), bytes); err != nil {
+		log.Crit("failed to store batch chunk ranges", "batch index", batchIndex, "err", err)
+	}
+}
+
+// DeleteBatchChunkRanges removes the block ranges of all chunks associated with a specific batch from the database.
+// Note: Only non-finalized batches can be reverted.
+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)
+	}
+}
+
+// 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.
+func ReadBatchChunkRanges(db ethdb.Reader, batchIndex uint64) []*ChunkBlockRange {
+	data, err := db.Get(batchChunkRangesKey(batchIndex))
+	if err != nil && isNotFoundErr(err) {
+		return nil
+	}
+	if err != nil {
+		log.Crit("failed to read batch chunk ranges from database", "err", err)
+	}
+
+	cr := new([]*ChunkBlockRange)
+	if err := rlp.Decode(bytes.NewReader(data), cr); err != nil {
+		log.Crit("Invalid ChunkBlockRange RLP", "batch index", batchIndex, "data", data, "err", err)
+	}
+	return *cr
+}
+
+// WriteFinalizedBatchMeta stores the metadata of a finalized batch in the database.
+func WriteFinalizedBatchMeta(db ethdb.KeyValueWriter, batchIndex uint64, finalizedBatchMeta *FinalizedBatchMeta) {
+	var err error
+	bytes, err := rlp.EncodeToBytes(finalizedBatchMeta)
+	if err != nil {
+		log.Crit("failed to RLP encode batch metadata", "batch index", batchIndex, "err", err)
+	}
+	if err := db.Put(batchMetaKey(batchIndex), bytes); err != nil {
+		log.Crit("failed to store batch metadata", "batch index", batchIndex, "err", err)
+	}
+}
+
+// ReadFinalizedBatchMeta fetches the metadata of a finalized batch from the database.
+func ReadFinalizedBatchMeta(db ethdb.Reader, batchIndex uint64) *FinalizedBatchMeta {
+	data, err := db.Get(batchMetaKey(batchIndex))
+	if err != nil && isNotFoundErr(err) {
+		return nil
+	}
+	if err != nil {
+		log.Crit("failed to read finalized batch metadata from database", "err", err)
+	}
+
+	fbm := new(FinalizedBatchMeta)
+	if err := rlp.Decode(bytes.NewReader(data), fbm); err != nil {
+		log.Crit("Invalid FinalizedBatchMeta RLP", "batch index", batchIndex, "data", data, "err", err)
+	}
+	return fbm
+}
+
+// WriteFinalizedL2BlockNumber stores the highest finalized L2 block number in the database.
+func WriteFinalizedL2BlockNumber(db ethdb.KeyValueWriter, l2BlockNumber uint64) {
+	value := big.NewInt(0).SetUint64(l2BlockNumber).Bytes()
+	if err := db.Put(finalizedL2BlockNumberKey, value); err != nil {
+		log.Crit("failed to store finalized L2 block number for rollup event", "err", err)
+	}
+}
+
+// ReadFinalizedL2BlockNumber fetches the highest finalized L2 block number from the database.
+func ReadFinalizedL2BlockNumber(db ethdb.Reader) *uint64 {
+	data, err := db.Get(finalizedL2BlockNumberKey)
+	if err != nil && isNotFoundErr(err) {
+		return nil
+	}
+	if err != nil {
+		log.Crit("failed to read finalized L2 block number from database", "err", err)
+	}
+
+	number := new(big.Int).SetBytes(data)
+	if !number.IsUint64() {
+		log.Crit("unexpected finalized L2 block number in database", "number", number)
+	}
+
+	finalizedL2BlockNumber := number.Uint64()
+	return &finalizedL2BlockNumber
+}
+
+// WriteBlockNumberToBatchIndex stores the mapping from a block number to a batch index in the database.
+func WriteBlockNumberToBatchIndex(db ethdb.KeyValueWriter, startBlockNumber uint64, endBlockNumber uint64, batchIndex uint64) {
+	if startBlockNumber > endBlockNumber {
+		log.Crit("Start block number cannot be greater than end block number", "startBlockNumber", startBlockNumber, "endBlockNumber", endBlockNumber)
+		return
+	}
+
+	value := big.NewInt(0).SetUint64(batchIndex).Bytes()
+	for blockNumber := startBlockNumber; blockNumber <= endBlockNumber; blockNumber++ {
+		if err := db.Put(blockNumberToBatchIndexKey(blockNumber), value); err != nil {
+			log.Crit("Failed to add block number to batch index mapping to batch", "startBlockNumber", startBlockNumber, "endBlockNumber", endBlockNumber, "batchIndex", batchIndex, "err", err)
+			return
+		}
+	}
+}
+
+// ReadBlockNumberToBatchIndex fetches the batch index associated with a block number from the database.
+func ReadBlockNumberToBatchIndex(db ethdb.Reader, blockNumber uint64) *uint64 {
+	data, err := db.Get(blockNumberToBatchIndexKey(blockNumber))
+	if err != nil && isNotFoundErr(err) {
+		return nil
+	}
+	if err != nil {
+		log.Crit("failed to read batch index for block number from database", "blockNumber", blockNumber, "err", err)
+	}
+
+	number := new(big.Int).SetBytes(data)
+	if !number.IsUint64() {
+		log.Crit("unexpected batch index for block number in database", "blockNumber", blockNumber, "number", number)
+	}
+
+	batchIndex := number.Uint64()
+	return &batchIndex
+}