WIP

Author: m-Peter

Makefile

@@ -23,7 +23,7 @@ EMULATOR_ARGS := --flow-network-id=flow-emulator \
 		--coa-address=$(EMULATOR_COA_ADDRESS)  \
 		--coa-key=$(EMULATOR_COA_KEY)  \
 		--wallet-api-key=2619878f0e2ff438d17835c2a4561cb87b4d24d72d12ec34569acd0dd4af7c21 \
-		--gas-price=0 \
+		--gas-price=100 \
 		--log-writer=console \
 		--tx-state-validation=local-index \
 		--profiler-enabled=true \

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,
@@ -1007,7 +1010,16 @@ 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 {
+		return nil, err
+	}
+
+	surgeFactor := uint64(feeParams.SurgeFactor)
+	multiplier := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(8)), nil)
+	gp := b.config.GasPrice.Uint64()
+	gasPrice := new(big.Int).SetUint64(uint64(gp * surgeFactor))
+	return (*hexutil.Big)(new(big.Int).Div(gasPrice, multiplier)), nil
 }
 
 // GetUncleCountByBlockHash returns number of uncles in the block for the given block hash

bootstrap/bootstrap.go

@@ -51,12 +51,13 @@ const (
 )
 
 type Storages struct {
-	Storage      *pebble.Storage
-	Registers    *pebble.RegisterStorage
-	Blocks       storage.BlockIndexer
-	Transactions storage.TransactionIndexer
-	Receipts     storage.ReceiptIndexer
-	Traces       storage.TraceIndexer
+	Storage       *pebble.Storage
+	Registers     *pebble.RegisterStorage
+	Blocks        storage.BlockIndexer
+	Transactions  storage.TransactionIndexer
+	Receipts      storage.ReceiptIndexer
+	Traces        storage.TraceIndexer
+	FeeParameters storage.FeeParametersIndexer
 }
 
 type Publishers struct {
@@ -191,6 +192,7 @@ func (b *Bootstrap) StartEventIngestion(ctx context.Context) error {
 		b.storages.Receipts,
 		b.storages.Transactions,
 		b.storages.Traces,
+		b.storages.FeeParameters,
 		b.publishers.Block,
 		b.publishers.Logs,
 		b.logger,
@@ -314,6 +316,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,
@@ -645,6 +648,13 @@ 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)
+		}
+	}
+
 	if batch.Count() > 0 {
 		err = batch.Commit(pebbleDB.Sync)
 		if err != nil {
@@ -653,12 +663,13 @@ func setupStorage(
 	}
 
 	return db, &Storages{
-		Storage:      store,
-		Blocks:       blocks,
-		Registers:    registerStore,
-		Transactions: pebble.NewTransactions(store),
-		Receipts:     pebble.NewReceipts(store),
-		Traces:       pebble.NewTraces(store),
+		Storage:       store,
+		Blocks:        blocks,
+		Registers:     registerStore,
+		Transactions:  pebble.NewTransactions(store),
+		Receipts:      pebble.NewReceipts(store),
+		Traces:        pebble.NewTraces(store),
+		FeeParameters: feeParameters,
 	}, 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 {
@@ -42,6 +52,7 @@ type CadenceEvents struct {
 	transactions      []Transaction                    // transactions in the EVM block
 	txEventPayloads   []events.TransactionEventPayload // EVM.TransactionExecuted event payloads
 	receipts          []*Receipt                       // receipts for transactions
+	feeParameters     *FeeParameters                   // updates to Flow fees parameters
 }
 
 // NewCadenceEvents decodes the events into evm types.
@@ -124,6 +135,15 @@ func decodeCadenceEvents(events flow.BlockEvents) (*CadenceEvents, error) {
 			e.txEventPayloads = append(e.txEventPayloads, *txEventPayload)
 			e.receipts = append(e.receipts, receipt)
 		}
+
+		if isFeeParametersChangedEvent(val) {
+			feeParameters, err := decodeFeeParametersChangedEvent(val)
+			if err != nil {
+				return nil, err
+			}
+
+			e.feeParameters = feeParameters
+		}
 	}
 
 	// safety check, we have a missing block in the events
@@ -182,6 +202,11 @@ func (c *CadenceEvents) Receipts() []*Receipt {
 	return c.receipts
 }
 
+// FeeParameters returns any updates to the Flow fees parameters.
+func (c *CadenceEvents) FeeParameters() *FeeParameters {
+	return c.feeParameters
+}
+
 // Empty checks if there is an EVM block included in the events.
 // If there are no evm block or transactions events this is a heartbeat event.
 func (c *CadenceEvents) Empty() bool {

models/fee_parameters.go

@@ -0,0 +1,46 @@
+package models
+
+import (
+	"fmt"
+
+	"github.com/onflow/cadence"
+	"github.com/onflow/go-ethereum/rlp"
+)
+
+var DefaultFeeParameters = &FeeParameters{
+	SurgeFactor:         cadence.UFix64(100_000_000),
+	InclusionEffortCost: cadence.UFix64(100_000_000),
+	ExecutionEffortCost: cadence.UFix64(100_000_000),
+}
+
+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 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
+}

services/ingestion/engine.go

@@ -48,6 +48,7 @@ type Engine struct {
 	receipts        storage.ReceiptIndexer
 	transactions    storage.TransactionIndexer
 	traces          storage.TraceIndexer
+	feeParameters   storage.FeeParametersIndexer
 	log             zerolog.Logger
 	evmLastHeight   *models.SequentialHeight
 	blocksPublisher *models.Publisher[*models.Block]
@@ -65,6 +66,7 @@ func NewEventIngestionEngine(
 	receipts storage.ReceiptIndexer,
 	transactions storage.TransactionIndexer,
 	traces storage.TraceIndexer,
+	feeParameters storage.FeeParametersIndexer,
 	blocksPublisher *models.Publisher[*models.Block],
 	logsPublisher *models.Publisher[[]*gethTypes.Log],
 	log zerolog.Logger,
@@ -84,6 +86,7 @@ func NewEventIngestionEngine(
 		receipts:        receipts,
 		transactions:    transactions,
 		traces:          traces,
+		feeParameters:   feeParameters,
 		log:             log,
 		blocksPublisher: blocksPublisher,
 		logsPublisher:   logsPublisher,
@@ -217,6 +220,10 @@ func (e *Engine) processEvents(events *models.CadenceEvents) error {
 
 // indexEvents will replay the evm transactions using the block events and index all results.
 func (e *Engine) indexEvents(events *models.CadenceEvents, batch *pebbleDB.Batch) error {
+	if events.FeeParameters() != nil {
+		e.feeParameters.Store(events.FeeParameters(), batch)
+	}
+
 	// if heartbeat interval with no data still update the cadence height
 	if events.Empty() {
 		if err := e.blocks.SetLatestCadenceHeight(events.CadenceHeight(), batch); err != nil {

services/ingestion/event_subscriber.go

@@ -556,7 +556,9 @@ func (r *RPCEventSubscriber) recover(
 // A.{evm}.EVM.BlockExecuted and A.{evm}.EVM.TransactionExecuted,
 // where {evm} is EVM deployed contract address, which depends on the chain ID we configure.
 func blocksFilter(chainId flowGo.ChainID) flow.EventFilter {
-	evmAddress := common.Address(systemcontracts.SystemContractsForChain(chainId).EVMContract.Address)
+	contracts := systemcontracts.SystemContractsForChain(chainId)
+	flowFeesAddress := common.Address(contracts.FlowFees.Address)
+	evmAddress := common.Address(contracts.EVMContract.Address)
 
 	blockExecutedEvent := common.NewAddressLocation(
 		nil,
@@ -570,10 +572,17 @@ func blocksFilter(chainId flowGo.ChainID) flow.EventFilter {
 		string(events.EventTypeTransactionExecuted),
 	).ID()
 
+	feeParametersChangedEvent := common.NewAddressLocation(
+		nil,
+		flowFeesAddress,
+		"FlowFees.FeeParametersChanged",
+	).ID()
+
 	return flow.EventFilter{
 		EventTypes: []string{
 			blockExecutedEvent,
 			transactionExecutedEvent,
+			feeParametersChangedEvent,
 		},
 	}
 }

storage/index.go

@@ -102,3 +102,9 @@ type TraceIndexer interface {
 	// GetTransaction will retrieve transaction trace by the transaction ID.
 	GetTransaction(ID common.Hash) (json.RawMessage, error)
 }
+
+type FeeParametersIndexer interface {
+	Store(feeParameters *models.FeeParameters, batch *pebble.Batch) error
+
+	Get() (*models.FeeParameters, error)
+}

storage/pebble/fee_parameters.go

@@ -0,0 +1,56 @@
+package pebble
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/cockroachdb/pebble"
+	"github.com/onflow/flow-evm-gateway/models"
+	"github.com/onflow/flow-evm-gateway/storage"
+)
+
+var _ storage.FeeParametersIndexer = &FeeParameters{}
+
+type FeeParameters struct {
+	store *Storage
+	mu    sync.Mutex
+}
+
+func NewFeeParameters(store *Storage) *FeeParameters {
+	return &FeeParameters{
+		store: store,
+	}
+}
+
+func (f *FeeParameters) Store(feeParameters *models.FeeParameters, batch *pebble.Batch) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	val, err := feeParameters.ToBytes()
+	if err != nil {
+		return err
+	}
+
+	if err := f.store.set(feeParametersKey, nil, val, batch); err != nil {
+		return fmt.Errorf("failed to store fee parameters %s: %w", feeParameters, err)
+	}
+
+	return nil
+}
+
+func (f *FeeParameters) Get() (*models.FeeParameters, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	data, err := f.store.get(feeParametersKey, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get fee parameters: %w", err)
+	}
+
+	feeParameters, err := models.NewFeeParametersFromBytes(data)
+	if err != nil {
+		return nil, err
+	}
+
+	return feeParameters, nil
+}

storage/pebble/keys.go

@@ -27,6 +27,9 @@ const (
 	// registers
 	registerKeyMarker = byte(50)
 
+	// fee parameters keys
+	feeParametersKey = byte(60)
+
 	// special keys
 	latestEVMHeightKey     = byte(100)
 	latestCadenceHeightKey = byte(102)