Merge branch 'mpeter/track-surge-factor' into mpeter/surge-factor-for-soft-finality

Author: m-Peter

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,12 @@ func (b *BlockChainAPI) SendRawTransaction(
 		return common.Hash{}, err
 	}
 
-	id, err := b.evm.SendRawTransaction(ctx, input)
+	feeParams, err := b.feeParameters.Get()
+	if err != nil {
+		return common.Hash{}, err
+	}
+
+	id, err := b.evm.SendRawTransaction(ctx, input, feeParams)
 	if err != nil {
 		return handleError[common.Hash](err, l, b.collector)
 	}
@@ -805,12 +813,6 @@ func (b *BlockChainAPI) FeeHistory(
 	)
 
 	maxCount := min(uint64(blockCount), lastBlockNumber)
-
-	blockRewards := make([]*hexutil.Big, len(rewardPercentiles))
-	for i := range rewardPercentiles {
-		blockRewards[i] = (*hexutil.Big)(b.config.GasPrice)
-	}
-
 	for i := maxCount; i >= uint64(1); i-- {
 		// If the requested block count is 5, and the last block number
 		// is 20, then we need the blocks [16, 17, 18, 19, 20] in this
@@ -827,6 +829,21 @@ func (b *BlockChainAPI) FeeHistory(
 
 		baseFees = append(baseFees, (*hexutil.Big)(models.BaseFeePerGas))
 
+		blockRewards := make([]*hexutil.Big, len(rewardPercentiles))
+		feeParams, err := b.feeParameters.Get()
+		if err != nil {
+			b.logger.Warn().
+				Uint64("height", blockHeight).
+				Err(err).
+				Msg("failed to get fee parameters for block in fee history")
+
+			continue
+		}
+		gasPrice := feeParams.CalculateGasPrice(b.config.GasPrice)
+		for i := range rewardPercentiles {
+			blockRewards[i] = (*hexutil.Big)(gasPrice)
+		}
+
 		rewards = append(rewards, blockRewards)
 
 		gasUsedRatio := float64(block.TotalGasUsed) / float64(BlockGasLimit)
@@ -1007,7 +1024,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
@@ -1048,7 +1071,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

@@ -51,13 +51,14 @@ const (
 )
 
 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 +206,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 +348,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 +691,15 @@ func setupStorage(
 	//	// TODO(JanezP): verify storage account owner is correct
 	// }
 
+	feeParameters := pebble.NewFeeParameters(store)
+	if _, err = feeParameters.Get(); errors.Is(err, errs.ErrEntityNotFound) {
+		if err := feeParameters.Store(models.DefaultFeeParameters, batch); err != nil {
+			return nil, nil, fmt.Errorf("failed to bootstrap fee parameters: %w", err)
+		}
+	} else if err != nil {
+		return nil, nil, fmt.Errorf("failed to load latest fee parameters: %w", err)
+	}
+
 	if batch.Count() > 0 {
 		err = batch.Commit(pebbleDB.Sync)
 		if err != nil {
@@ -688,13 +708,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
 }
 

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,62 @@
+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)
+
+var DefaultFeeParameters = &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
+}