feat(gas-oracle): support moving average base fee

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.5.45"
+var tag = "v4.5.46"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

rollup/conf/config.json

@@ -21,7 +21,8 @@
         "check_committed_batches_window_minutes": 5,
         "l1_base_fee_default": 15000000000,
         "l1_blob_base_fee_default": 1,
-        "l1_blob_base_fee_threshold": 0
+        "l1_blob_base_fee_threshold": 0,
+        "calculate_average_fees_window_size": 100
       },
       "gas_oracle_sender_signer_config": {
         "signer_type": "PrivateKey",

rollup/internal/config/relayer.go

@@ -103,6 +103,9 @@ type GasOracleConfig struct {
 
 	// L1BlobBaseFeeThreshold the threshold of L1 blob base fee to enter the default gas price mode
 	L1BlobBaseFeeThreshold uint64 `json:"l1_blob_base_fee_threshold"`
+
+	// CalculateAverageFeesWindowSize the number of blocks used for average fee calculation
+	CalculateAverageFeesWindowSize int `json:"calculate_average_fees_window_size"`
 }
 
 // SignerConfig - config of signer, contains type and config corresponding to type

rollup/internal/controller/relayer/l1_relayer.go

@@ -105,23 +105,20 @@ func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfi
 // ProcessGasPriceOracle imports gas price to layer2
 func (r *Layer1Relayer) ProcessGasPriceOracle() {
 	r.metrics.rollupL1RelayerGasPriceOraclerRunTotal.Inc()
-	latestBlockHeight, err := r.l1BlockOrm.GetLatestL1BlockHeight(r.ctx)
-	if err != nil {
-		log.Warn("Failed to fetch latest L1 block height from db", "err", err)
-		return
-	}
 
-	blocks, err := r.l1BlockOrm.GetL1Blocks(r.ctx, map[string]interface{}{
-		"number": latestBlockHeight,
-	})
+	limit := r.cfg.GasOracleConfig.CalculateAverageFeesWindowSize
+	blocks, err := r.l1BlockOrm.GetLatestL1Blocks(r.ctx, limit)
 	if err != nil {
-		log.Error("Failed to GetL1Blocks from db", "height", latestBlockHeight, "err", err)
+		log.Error("Failed to GetLatestL1Blocks from db", "limit", limit, "err", err)
 		return
 	}
-	if len(blocks) != 1 {
-		log.Error("Block not exist", "height", latestBlockHeight)
+
+	// nothing to do if we don't have any l1 blocks
+	if len(blocks) == 0 {
+		log.Info("No l1 blocks to process", "limit", limit)
 		return
 	}
+
 	block := blocks[0]
 
 	if types.GasOracleStatus(block.GasOracleStatus) == types.GasOraclePending {
@@ -130,8 +127,8 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 			return
 		}
 
-		baseFee := block.BaseFee
-		blobBaseFee := block.BlobBaseFee
+		// calculate the average base fee and blob base fee of the last N blocks
+		baseFee, blobBaseFee := r.calculateAverageFees(blocks)
 
 		// include the token exchange rate in the fee data if alternative gas token enabled
 		if r.cfg.GasOracleConfig.AlternativeGasTokenConfig != nil && r.cfg.GasOracleConfig.AlternativeGasTokenConfig.Enabled {
@@ -287,3 +284,19 @@ func (r *Layer1Relayer) commitBatchReachTimeout() (bool, error) {
 	// Because batches[0].CommittedAt is nil in this case, this will only continue for a short time window.
 	return len(batches) == 0 || (batches[0].Index != 0 && batches[0].CommittedAt != nil && utils.NowUTC().Sub(*batches[0].CommittedAt) > time.Duration(r.cfg.GasOracleConfig.CheckCommittedBatchesWindowMinutes)*time.Minute), nil
 }
+
+// calculateAverageFees returns the average base fee and blob base fee.
+func (r *Layer1Relayer) calculateAverageFees(blocks []orm.L1Block) (avgBaseFee uint64, avgBlobBaseFee uint64) {
+	if len(blocks) == 0 {
+		return 0, 0
+	}
+
+	var totalBaseFee, totalBlobBaseFee uint64
+	for _, b := range blocks {
+		totalBaseFee += b.BaseFee
+		totalBlobBaseFee += b.BlobBaseFee
+	}
+
+	count := uint64(len(blocks))
+	return totalBaseFee / count, totalBlobBaseFee / count
+}

rollup/internal/orm/l1_block.go

@@ -71,6 +71,46 @@ func (o *L1Block) GetL1Blocks(ctx context.Context, fields map[string]interface{}
 	return l1Blocks, nil
 }
 
+// GetLatestL1Blocks get the latest N l1 blocks ordered by block number descending
+func (o *L1Block) GetLatestL1Blocks(ctx context.Context, limit int) ([]L1Block, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&L1Block{})
+	db = db.Order("number DESC")
+	db = db.Limit(limit)
+
+	var l1Blocks []L1Block
+	if err := db.Find(&l1Blocks).Error; err != nil {
+		return nil, fmt.Errorf("L1Block.GetLatestL1Blocks error: %w, limit: %d", err, limit)
+	}
+	return l1Blocks, nil
+}
+
+// GetAverageFees returns the average base_fee and blob_base_fee of all blocks
+func (o *L1Block) GetAverageFees(ctx context.Context) (avgBaseFee float64, avgBlobBaseFee float64, err error) {
+	db := o.db.WithContext(ctx)
+
+	var l1Blocks []L1Block
+	if err := db.Model(&L1Block{}).Find(&l1Blocks).Error; err != nil {
+		return 0, 0, fmt.Errorf("L1Block.GetAverageFees error: %w", err)
+	}
+
+	if len(l1Blocks) == 0 {
+		return 0, 0, nil
+	}
+
+	var totalBaseFee, totalBlobBaseFee uint64
+	for _, block := range l1Blocks {
+		totalBaseFee += block.BaseFee
+		totalBlobBaseFee += block.BlobBaseFee
+	}
+
+	count := float64(len(l1Blocks))
+	avgBaseFee = float64(totalBaseFee) / count
+	avgBlobBaseFee = float64(totalBlobBaseFee) / count
+
+	return avgBaseFee, avgBlobBaseFee, nil
+}
+
 // GetBlobFeesInRange returns all blob_base_fee values for blocks
 // with number ∈ [startBlock..endBlock], ordered by block number ascending.
 func (o *L1Block) GetBlobFeesInRange(ctx context.Context, startBlock, endBlock uint64) ([]uint64, error) {