Track & apply surge-factor pricing changes

.github/workflows/build.yml

@@ -4,6 +4,7 @@ on:
   push:
     tags:
       - '*'
+  workflow_dispatch:
 
 env:
   DOCKER_IMAGE_URL: ${{ vars.REPO_DOCKER_IMAGE_URL }}

Makefile

@@ -97,8 +97,8 @@ generate:
 	mockery --dir=storage --name=BlockIndexer --output=storage/mocks
 	mockery --dir=storage --name=ReceiptIndexer --output=storage/mocks
 	mockery --dir=storage --name=TransactionIndexer --output=storage/mocks
-	mockery --dir=storage --name=AccountIndexer --output=storage/mocks
 	mockery --dir=storage --name=TraceIndexer --output=storage/mocks
+	mockery --dir=storage --name=FeeParametersIndexer --output=storage/mocks
 	mockery --all --dir=services/traces --output=services/traces/mocks
 	mockery --all --dir=services/ingestion --output=services/ingestion/mocks
 	mockery --dir=models --name=Engine --output=models/mocks

api/api.go

@@ -85,6 +85,7 @@ type BlockChainAPI struct {
 	blocks                storage.BlockIndexer
 	transactions          storage.TransactionIndexer
 	receipts              storage.ReceiptIndexer
+	feeParameters         storage.FeeParametersIndexer
 	indexingResumedHeight uint64
 	rateLimiter           RateLimiter
 	collector             metrics.Collector
@@ -97,6 +98,7 @@ func NewBlockChainAPI(
 	blocks storage.BlockIndexer,
 	transactions storage.TransactionIndexer,
 	receipts storage.ReceiptIndexer,
+	feeParameters storage.FeeParametersIndexer,
 	rateLimiter RateLimiter,
 	collector metrics.Collector,
 	indexingResumedHeight uint64,
@@ -108,6 +110,7 @@ func NewBlockChainAPI(
 		blocks:                blocks,
 		transactions:          transactions,
 		receipts:              receipts,
+		feeParameters:         feeParameters,
 		indexingResumedHeight: indexingResumedHeight,
 		rateLimiter:           rateLimiter,
 		collector:             collector,
@@ -179,7 +182,13 @@ func (b *BlockChainAPI) SendRawTransaction(
 		return common.Hash{}, err
 	}
 
-	id, err := b.evm.SendRawTransaction(ctx, input)
+	feeParams, err := b.feeParameters.Get()
+	if err != nil {
+		b.logger.Warn().Err(err).Msg("fee parameters unavailable; falling back to base gas price")
+		feeParams = models.DefaultFeeParameters()
+	}
+
+	id, err := b.evm.SendRawTransaction(ctx, input, feeParams)
 	if err != nil {
 		return handleError[common.Hash](err, l, b.collector)
 	}
@@ -814,8 +823,17 @@ func (b *BlockChainAPI) FeeHistory(
 	maxCount := min(uint64(blockCount), lastBlockNumber)
 
 	blockRewards := make([]*hexutil.Big, len(rewardPercentiles))
+	gasPrice := b.config.GasPrice
+
+	feeParams, err := b.feeParameters.Get()
+	if err != nil {
+		b.logger.Warn().Err(err).Msg("fee parameters unavailable; falling back to base gas price")
+	} else {
+		gasPrice = feeParams.CalculateGasPrice(b.config.GasPrice)
+	}
+
 	for i := range rewardPercentiles {
-		blockRewards[i] = (*hexutil.Big)(b.config.GasPrice)
+		blockRewards[i] = (*hexutil.Big)(gasPrice)
 	}
 
 	for i := maxCount; i >= uint64(1); i-- {
@@ -1014,7 +1032,13 @@ func (b *BlockChainAPI) Coinbase(ctx context.Context) (common.Address, error) {
 
 // GasPrice returns a suggestion for a gas price for legacy transactions.
 func (b *BlockChainAPI) GasPrice(ctx context.Context) (*hexutil.Big, error) {
-	return (*hexutil.Big)(b.config.GasPrice), nil
+	feeParams, err := b.feeParameters.Get()
+	if err != nil {
+		b.logger.Warn().Err(err).Msg("fee parameters unavailable; falling back to base gas price")
+		return (*hexutil.Big)(b.config.GasPrice), nil
+	}
+	gasPrice := feeParams.CalculateGasPrice(b.config.GasPrice)
+	return (*hexutil.Big)(gasPrice), nil
 }
 
 // GetUncleCountByBlockHash returns number of uncles in the block for the given block hash
@@ -1055,7 +1079,13 @@ func (b *BlockChainAPI) GetUncleByBlockNumberAndIndex(
 
 // MaxPriorityFeePerGas returns a suggestion for a gas tip cap for dynamic fee transactions.
 func (b *BlockChainAPI) MaxPriorityFeePerGas(ctx context.Context) (*hexutil.Big, error) {
-	return (*hexutil.Big)(b.config.GasPrice), nil
+	feeParams, err := b.feeParameters.Get()
+	if err != nil {
+		b.logger.Warn().Err(err).Msg("fee parameters unavailable; falling back to base gas price")
+		return (*hexutil.Big)(b.config.GasPrice), nil
+	}
+	gasPrice := feeParams.CalculateGasPrice(b.config.GasPrice)
+	return (*hexutil.Big)(gasPrice), nil
 }
 
 // Mining returns true if client is actively mining new blocks.

bootstrap/bootstrap.go

@@ -2,13 +2,15 @@ package bootstrap
 
 import (
 	"context"
+	_ "embed"
 	"errors"
 	"fmt"
 	"math"
 	"time"
 
 	pebbleDB "github.com/cockroachdb/pebble"
 	gethTypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/onflow/cadence"
 	"github.com/onflow/flow-go-sdk/access"
 	"github.com/onflow/flow-go-sdk/access/grpc"
 	"github.com/onflow/flow-go/fvm/environment"
@@ -50,14 +52,20 @@ const (
 	DefaultResourceExhaustedMaxRetryDelay = 30 * time.Second
 )
 
+var (
+	//go:embed cadence/get_fees_surge_factor.cdc
+	getFeesSurgeFactor []byte
+)
+
 type Storages struct {
-	Storage      *pebble.Storage
-	Registers    *pebble.RegisterStorage
-	Blocks       storage.BlockIndexer
-	Transactions storage.TransactionIndexer
-	Receipts     storage.ReceiptIndexer
-	Traces       storage.TraceIndexer
-	EventsHash   *pebble.EventsHash
+	Storage       *pebble.Storage
+	Registers     *pebble.RegisterStorage
+	Blocks        storage.BlockIndexer
+	Transactions  storage.TransactionIndexer
+	Receipts      storage.ReceiptIndexer
+	Traces        storage.TraceIndexer
+	FeeParameters storage.FeeParametersIndexer
+	EventsHash    *pebble.EventsHash
 }
 
 type Publishers struct {
@@ -205,16 +213,25 @@ func (b *Bootstrap) StartEventIngestion(ctx context.Context) error {
 		ValidateResults:     true,
 	}
 
+	feeParamsSubscriber := ingestion.NewFeeParamsEventSubscriber(
+		b.logger,
+		b.client,
+		chainID,
+		nextCadenceHeight,
+	)
+
 	// initialize event ingestion engine
 	b.events = ingestion.NewEventIngestionEngine(
 		subscriber,
+		feeParamsSubscriber,
 		blocksProvider,
 		b.storages.Storage,
 		b.storages.Registers,
 		b.storages.Blocks,
 		b.storages.Receipts,
 		b.storages.Transactions,
 		b.storages.Traces,
+		b.storages.FeeParameters,
 		b.publishers.Block,
 		b.publishers.Logs,
 		b.logger,
@@ -338,6 +355,7 @@ func (b *Bootstrap) StartAPIServer(ctx context.Context) error {
 		b.storages.Blocks,
 		b.storages.Transactions,
 		b.storages.Receipts,
+		b.storages.FeeParameters,
 		rateLimiter,
 		b.collector,
 		indexingResumedHeight,
@@ -680,6 +698,15 @@ func setupStorage(
 	//	// TODO(JanezP): verify storage account owner is correct
 	// }
 
+	feeParameters := pebble.NewFeeParameters(store)
+	currentFeeParams, err := getNetworkFeeParams(context.Background(), config, client, logger)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to fetch current fees surge factor: %w", err)
+	}
+	if err := feeParameters.Store(currentFeeParams, batch); err != nil {
+		return nil, nil, fmt.Errorf("failed to bootstrap fee parameters: %w", err)
+	}
+
 	if batch.Count() > 0 {
 		err = batch.Commit(pebbleDB.Sync)
 		if err != nil {
@@ -688,13 +715,14 @@ func setupStorage(
 	}
 
 	return db, &Storages{
-		Storage:      store,
-		Blocks:       blocks,
-		Registers:    registerStore,
-		Transactions: pebble.NewTransactions(store),
-		Receipts:     pebble.NewReceipts(store),
-		Traces:       pebble.NewTraces(store),
-		EventsHash:   eventsHash,
+		Storage:       store,
+		Blocks:        blocks,
+		Registers:     registerStore,
+		Transactions:  pebble.NewTransactions(store),
+		Receipts:      pebble.NewReceipts(store),
+		Traces:        pebble.NewTraces(store),
+		FeeParameters: feeParameters,
+		EventsHash:    eventsHash,
 	}, nil
 }
 
@@ -817,3 +845,35 @@ func (m *metricsWrapper) Stop() {
 	m.stopFN()
 	<-m.Done()
 }
+
+// getNetworkFeeParams returns the network's current Flow fees parameters
+func getNetworkFeeParams(
+	ctx context.Context,
+	config config.Config,
+	client *requester.CrossSporkClient,
+	logger zerolog.Logger,
+) (*models.FeeParameters, error) {
+	val, err := client.ExecuteScriptAtLatestBlock(
+		ctx,
+		requester.ReplaceAddresses(getFeesSurgeFactor, config.FlowNetworkID),
+		nil,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// sanity check, should never occur
+	surgeFactor, ok := val.(cadence.UFix64)
+	if !ok {
+		return nil, fmt.Errorf("failed to convert surgeFactor %v to UFix64, got type: %T", val, val)
+	}
+
+	logger.Debug().
+		Uint64("surge-factor", uint64(surgeFactor)).
+		Msg("get current surge factor executed")
+
+	feeParameters := models.DefaultFeeParameters()
+	feeParameters.SurgeFactor = surgeFactor
+
+	return feeParameters, nil
+}

bootstrap/cadence/get_fees_surge_factor.cdc

@@ -0,0 +1,5 @@
+import FlowFees
+
+access(all) fun main(): UFix64 {
+    return FlowFees.getFeeParameters().surgeFactor
+}

models/events.go

@@ -13,8 +13,9 @@ import (
 )
 
 const (
-	BlockExecutedQualifiedIdentifier       = string(events.EventTypeBlockExecuted)
-	TransactionExecutedQualifiedIdentifier = string(events.EventTypeTransactionExecuted)
+	BlockExecutedQualifiedIdentifier        = string(events.EventTypeBlockExecuted)
+	TransactionExecutedQualifiedIdentifier  = string(events.EventTypeTransactionExecuted)
+	FeeParametersChangedQualifiedIdentifier = "FlowFees.FeeParametersChanged"
 )
 
 // isBlockExecutedEvent checks whether the given event contains block executed data.
@@ -33,6 +34,15 @@ func isTransactionExecutedEvent(event cadence.Event) bool {
 	return event.EventType.QualifiedIdentifier == TransactionExecutedQualifiedIdentifier
 }
 
+// isFeeParametersChangedEvent checks whether the given event contains updates
+// to Flow fees parameters.
+func isFeeParametersChangedEvent(event cadence.Event) bool {
+	if event.EventType == nil {
+		return false
+	}
+	return event.EventType.QualifiedIdentifier == FeeParametersChangedQualifiedIdentifier
+}
+
 // CadenceEvents contains Flow emitted events containing one or zero evm block executed event,
 // and multiple or zero evm transaction events.
 type CadenceEvents struct {
@@ -254,3 +264,34 @@ func NewBlockEventsError(err error) BlockEvents {
 		Err: err,
 	}
 }
+
+type FeeParamsEvents struct {
+	FeeParameters *FeeParameters // updates to Flow fees parameters
+	Err           error
+}
+
+func NewFeeParamsEvents(events flow.BlockEvents) *FeeParamsEvents {
+	for _, event := range events.Events {
+		val := event.Value
+		if isFeeParametersChangedEvent(val) {
+			feeParameters, err := decodeFeeParametersChangedEvent(val)
+			return &FeeParamsEvents{
+				FeeParameters: feeParameters,
+				Err:           err,
+			}
+		}
+	}
+
+	return &FeeParamsEvents{
+		Err: fmt.Errorf(
+			"could not find any %s events",
+			FeeParametersChangedQualifiedIdentifier,
+		),
+	}
+}
+
+func NewFeeParamsEventsError(err error) *FeeParamsEvents {
+	return &FeeParamsEvents{
+		Err: err,
+	}
+}

models/fee_parameters.go

@@ -0,0 +1,64 @@
+package models
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/onflow/cadence"
+)
+
+const feeParamsPrecision = 100_000_000
+
+var surgeFactorScale = big.NewInt(feeParamsPrecision)
+
+func DefaultFeeParameters() *FeeParameters {
+	return &FeeParameters{
+		SurgeFactor:         cadence.UFix64(feeParamsPrecision),
+		InclusionEffortCost: cadence.UFix64(feeParamsPrecision),
+		ExecutionEffortCost: cadence.UFix64(feeParamsPrecision),
+	}
+}
+
+type FeeParameters struct {
+	SurgeFactor         cadence.UFix64 `cadence:"surgeFactor"`
+	InclusionEffortCost cadence.UFix64 `cadence:"inclusionEffortCost"`
+	ExecutionEffortCost cadence.UFix64 `cadence:"executionEffortCost"`
+}
+
+func (f *FeeParameters) ToBytes() ([]byte, error) {
+	return rlp.EncodeToBytes(f)
+}
+
+func (f *FeeParameters) CalculateGasPrice(currentGasPrice *big.Int) *big.Int {
+	if currentGasPrice == nil {
+		return new(big.Int) // zero
+	}
+
+	// gasPrice = (currentGasPrice * surgeFactor) / feeParamsPrecision
+	surgeFactor := new(big.Int).SetUint64(uint64(f.SurgeFactor))
+	gasPrice := new(big.Int).Mul(currentGasPrice, surgeFactor)
+	return new(big.Int).Quo(gasPrice, surgeFactorScale)
+}
+
+func NewFeeParametersFromBytes(data []byte) (*FeeParameters, error) {
+	feeParameters := &FeeParameters{}
+	if err := rlp.DecodeBytes(data, feeParameters); err != nil {
+		return nil, err
+	}
+
+	return feeParameters, nil
+}
+
+func decodeFeeParametersChangedEvent(event cadence.Event) (*FeeParameters, error) {
+	feeParameters := &FeeParameters{}
+	if err := cadence.DecodeFields(event, feeParameters); err != nil {
+		return nil, fmt.Errorf(
+			"failed to Cadence-decode FlowFees.FeeParametersChanged event [%s]: %w",
+			event.String(),
+			err,
+		)
+	}
+
+	return feeParameters, nil
+}