feat(bundle-proposer): static batch per bundle

Author: colinlyguo

rollup/conf/config.json

@@ -103,8 +103,7 @@
       "max_uncompressed_batch_bytes_size": 634880
     },
     "bundle_proposer_config": {
-      "max_batch_num_per_bundle": 20,
-      "bundle_timeout_sec": 36000
+      "batch_num_per_bundle": 20
     }
   },
   "db_config": {

rollup/internal/config/l2.go

@@ -51,6 +51,5 @@ type BatchProposerConfig struct {
 
 // BundleProposerConfig loads bundle_proposer configuration items.
 type BundleProposerConfig struct {
-	MaxBatchNumPerBundle uint64 `json:"max_batch_num_per_bundle"`
-	BundleTimeoutSec     uint64 `json:"bundle_timeout_sec"`
+	BatchNumPerBundle uint64 `json:"batch_num_per_bundle"`
 }

rollup/internal/controller/watcher/bundle_proposer.go

@@ -3,7 +3,6 @@ package watcher
 import (
 	"context"
 	"errors"
-	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -25,8 +24,7 @@ type BundleProposer struct {
 	batchOrm  *orm.Batch
 	bundleOrm *orm.Bundle
 
-	maxBatchNumPerBundle uint64
-	bundleTimeoutSec     uint64
+	batchNumPerBundle uint64
 
 	chainCfg *params.ChainConfig
 
@@ -41,17 +39,16 @@ type BundleProposer struct {
 
 // NewBundleProposer creates a new BundleProposer instance.
 func NewBundleProposer(ctx context.Context, cfg *config.BundleProposerConfig, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BundleProposer {
-	log.Info("new bundle proposer", "bundleBatchesNum", cfg.MaxBatchNumPerBundle, "bundleTimeoutSec", cfg.BundleTimeoutSec)
+	log.Info("new bundle proposer", "bundleBatchesNum", cfg.BatchNumPerBundle)
 
 	p := &BundleProposer{
-		ctx:                  ctx,
-		db:                   db,
-		chunkOrm:             orm.NewChunk(db),
-		batchOrm:             orm.NewBatch(db),
-		bundleOrm:            orm.NewBundle(db),
-		maxBatchNumPerBundle: cfg.MaxBatchNumPerBundle,
-		bundleTimeoutSec:     cfg.BundleTimeoutSec,
-		chainCfg:             chainCfg,
+		ctx:               ctx,
+		db:                db,
+		chunkOrm:          orm.NewChunk(db),
+		batchOrm:          orm.NewBatch(db),
+		bundleOrm:         orm.NewBundle(db),
+		batchNumPerBundle: cfg.BatchNumPerBundle,
+		chainCfg:          chainCfg,
 
 		bundleProposerCircleTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 			Name: "rollup_propose_bundle_circle_total",
@@ -129,8 +126,8 @@ func (p *BundleProposer) proposeBundle() error {
 	}
 
 	// select at most maxBlocksThisChunk blocks
-	maxBatchesThisBundle := p.maxBatchNumPerBundle
-	batches, err := p.batchOrm.GetBatchesGEIndexGECodecVersion(p.ctx, firstUnbundledBatchIndex, encoding.CodecV3, int(maxBatchesThisBundle))
+	batchesThisBundle := p.batchNumPerBundle
+	batches, err := p.batchOrm.GetBatchesGEIndexGECodecVersion(p.ctx, firstUnbundledBatchIndex, encoding.CodecV3, int(batchesThisBundle))
 	if err != nil {
 		return err
 	}
@@ -161,21 +158,13 @@ func (p *BundleProposer) proposeBundle() error {
 		currentHardfork := encoding.GetHardforkName(p.chainCfg, chunk.StartBlockNumber, chunk.StartBlockTime)
 		if currentHardfork != hardforkName {
 			batches = batches[:i]
-			maxBatchesThisBundle = uint64(i) // update maxBlocksThisChunk to trigger chunking, because these blocks are the last blocks before the hardfork
+			batchesThisBundle = uint64(i) // update maxBlocksThisChunk to trigger chunking, because these blocks are the last blocks before the hardfork
 			break
 		}
 	}
 
-	if uint64(len(batches)) == maxBatchesThisBundle {
-		log.Info("reached maximum number of batches per bundle", "batch count", len(batches), "start batch index", batches[0].Index, "end batch index", batches[len(batches)-1].Index)
-		p.bundleFirstBlockTimeoutReached.Inc()
-		p.bundleBatchesNum.Set(float64(len(batches)))
-		return p.updateDBBundleInfo(batches, codecVersion)
-	}
-
-	currentTimeSec := uint64(time.Now().Unix())
-	if firstChunk.StartBlockTime+p.bundleTimeoutSec < currentTimeSec {
-		log.Info("first block timeout", "batch count", len(batches), "start block number", firstChunk.StartBlockNumber, "start block timestamp", firstChunk.StartBlockTime, "current time", currentTimeSec)
+	if uint64(len(batches)) == batchesThisBundle {
+		log.Info("reached number of batches per bundle", "batch count", len(batches), "start batch index", batches[0].Index, "end batch index", batches[len(batches)-1].Index)
 		p.bundleFirstBlockTimeoutReached.Inc()
 		p.bundleBatchesNum.Set(float64(len(batches)))
 		return p.updateDBBundleInfo(batches, codecVersion)

rollup/internal/controller/watcher/bundle_proposer_test.go

@@ -23,33 +23,33 @@ import (
 func testBundleProposerLimits(t *testing.T) {
 	tests := []struct {
 		name                         string
-		maxBatchNumPerBundle         uint64
+		batchNumPerBundle            uint64
 		bundleTimeoutSec             uint64
 		expectedBundlesLen           int
 		expectedBatchesInFirstBundle uint64 // only be checked when expectedBundlesLen > 0
 	}{
 		{
-			name:                 "NoLimitReached",
-			maxBatchNumPerBundle: math.MaxUint64,
-			bundleTimeoutSec:     math.MaxUint32,
-			expectedBundlesLen:   0,
+			name:               "NoLimitReached",
+			batchNumPerBundle:  math.MaxUint64,
+			bundleTimeoutSec:   math.MaxUint32,
+			expectedBundlesLen: 0,
 		},
 		{
 			name:                         "Timeout",
-			maxBatchNumPerBundle:         math.MaxUint64,
+			batchNumPerBundle:            math.MaxUint64,
 			bundleTimeoutSec:             0,
 			expectedBundlesLen:           1,
 			expectedBatchesInFirstBundle: 2,
 		},
 		{
-			name:                 "maxBatchNumPerBundleIs0",
-			maxBatchNumPerBundle: 0,
-			bundleTimeoutSec:     math.MaxUint32,
-			expectedBundlesLen:   0,
+			name:               "maxBatchNumPerBundleIs0",
+			batchNumPerBundle:  0,
+			bundleTimeoutSec:   math.MaxUint32,
+			expectedBundlesLen: 0,
 		},
 		{
 			name:                         "maxBatchNumPerBundleIs1",
-			maxBatchNumPerBundle:         1,
+			batchNumPerBundle:            1,
 			bundleTimeoutSec:             math.MaxUint32,
 			expectedBundlesLen:           1,
 			expectedBatchesInFirstBundle: 1,
@@ -115,8 +115,7 @@ func testBundleProposerLimits(t *testing.T) {
 			bap.TryProposeBatch() // batch2 contains chunk2
 
 			bup := NewBundleProposer(context.Background(), &config.BundleProposerConfig{
-				MaxBatchNumPerBundle: tt.maxBatchNumPerBundle,
-				BundleTimeoutSec:     tt.bundleTimeoutSec,
+				BatchNumPerBundle: tt.batchNumPerBundle,
 			}, chainConfig, db, nil)
 
 			bup.TryProposeBundle()
@@ -205,8 +204,7 @@ func testBundleProposerRespectHardforks(t *testing.T) {
 	}
 
 	bup := NewBundleProposer(context.Background(), &config.BundleProposerConfig{
-		MaxBatchNumPerBundle: math.MaxUint64,
-		BundleTimeoutSec:     0,
+		BatchNumPerBundle: math.MaxUint64,
 	}, chainConfig, db, nil)
 
 	for i := 0; i < 5; i++ {

rollup/tests/rollup_test.go

@@ -113,8 +113,7 @@ func testCommitBatchAndFinalizeBatchOrBundleWithAllCodecVersions(t *testing.T) {
 		}, chainConfig, db, nil)
 
 		bup := watcher.NewBundleProposer(context.Background(), &config.BundleProposerConfig{
-			MaxBatchNumPerBundle: 1000000,
-			BundleTimeoutSec:     300,
+			BatchNumPerBundle: 1000000,
 		}, chainConfig, db, nil)
 
 		l2BlockOrm := orm.NewL2Block(db)
@@ -280,8 +279,7 @@ func testCommitBatchAndFinalizeBatchOrBundleCrossingAllTransitions(t *testing.T)
 	}, chainConfig, db, nil)
 
 	bup := watcher.NewBundleProposer(context.Background(), &config.BundleProposerConfig{
-		MaxBatchNumPerBundle: 1000000,
-		BundleTimeoutSec:     300,
+		BatchNumPerBundle: 1000000,
 	}, chainConfig, db, nil)
 
 	cp.TryProposeChunk()