Track the latest finalized block header to avoid fetching it on every tx submission

Author: m-Peter

bootstrap/bootstrap.go

@@ -259,6 +259,7 @@ func (b *Bootstrap) StartAPIServer(ctx context.Context) error {
 		)
 	} else {
 		txPool = requester.NewSingleTxPool(
+			ctx,
 			b.client,
 			b.publishers.Transaction,
 			b.logger,

services/requester/batch_tx_pool.go

@@ -62,6 +62,7 @@ func NewBatchTxPool(
 	collector.AvailableSigningKeys(keystore.AvailableKeys())
 
 	singleTxPool := NewSingleTxPool(
+		ctx,
 		client,
 		transactionsPublisher,
 		logger,
@@ -161,10 +162,10 @@ func (t *BatchTxPool) processPooledTransactions(ctx context.Context) {
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
-			latestBlock, account, err := t.fetchFlowLatestBlockAndCOA(ctx)
+			account, err := t.client.GetAccount(ctx, t.config.COAAddress)
 			if err != nil {
 				t.logger.Error().Err(err).Msg(
-					"failed to get COA / latest Flow block on batch tx submission",
+					"failed to get COA on batch tx submission",
 				)
 				continue
 			}
@@ -180,7 +181,7 @@ func (t *BatchTxPool) processPooledTransactions(ctx context.Context) {
 			for address, pooledTxs := range txsGroupedByAddress {
 				err := t.batchSubmitTransactionsForSameAddress(
 					ctx,
-					latestBlock,
+					t.latestBlockHeader,
 					account,
 					pooledTxs,
 				)
@@ -198,7 +199,7 @@ func (t *BatchTxPool) processPooledTransactions(ctx context.Context) {
 
 func (t *BatchTxPool) batchSubmitTransactionsForSameAddress(
 	ctx context.Context,
-	latestBlock *flow.Block,
+	latestBlockHeader *flow.BlockHeader,
 	account *flow.Account,
 	pooledTxs []pooledEvmTx,
 ) error {
@@ -220,7 +221,7 @@ func (t *BatchTxPool) batchSubmitTransactionsForSameAddress(
 
 	script := replaceAddresses(batchRunTxScript, t.config.FlowNetworkID)
 	flowTx, err := t.buildTransaction(
-		latestBlock,
+		latestBlockHeader,
 		account,
 		script,
 		cadence.NewArray(hexEncodedTxs),
@@ -244,7 +245,7 @@ func (t *BatchTxPool) submitSingleTransaction(
 	ctx context.Context,
 	hexEncodedTx cadence.String,
 ) error {
-	latestBlock, account, err := t.fetchFlowLatestBlockAndCOA(ctx)
+	account, err := t.client.GetAccount(ctx, t.config.COAAddress)
 	if err != nil {
 		return err
 	}
@@ -256,7 +257,7 @@ func (t *BatchTxPool) submitSingleTransaction(
 
 	script := replaceAddresses(runTxScript, t.config.FlowNetworkID)
 	flowTx, err := t.buildTransaction(
-		latestBlock,
+		t.latestBlockHeader,
 		account,
 		script,
 		hexEncodedTx,

services/requester/single_tx_pool.go

@@ -13,7 +13,6 @@ import (
 	flowGo "github.com/onflow/flow-go/model/flow"
 	"github.com/rs/zerolog"
 	"github.com/sethvargo/go-retry"
-	"golang.org/x/sync/errgroup"
 
 	"github.com/onflow/flow-evm-gateway/config"
 	"github.com/onflow/flow-evm-gateway/metrics"
@@ -33,11 +32,14 @@ type SingleTxPool struct {
 	keystore    *keystore.KeyStore
 	collector   metrics.Collector
 	// todo add methods to inspect transaction pool state
+
+	latestBlockHeader *flow.BlockHeader
 }
 
 var _ TxPool = &SingleTxPool{}
 
 func NewSingleTxPool(
+	ctx context.Context,
 	client *CrossSporkClient,
 	transactionsPublisher *models.Publisher[*gethTypes.Transaction],
 	logger zerolog.Logger,
@@ -48,7 +50,7 @@ func NewSingleTxPool(
 	// initialize the available keys metric since it is only updated when sending a tx
 	collector.AvailableSigningKeys(keystore.AvailableKeys())
 
-	return &SingleTxPool{
+	singleTxPool := &SingleTxPool{
 		logger:      logger.With().Str("component", "tx-pool").Logger(),
 		client:      client,
 		txPublisher: transactionsPublisher,
@@ -57,6 +59,10 @@ func NewSingleTxPool(
 		collector:   collector,
 		keystore:    keystore,
 	}
+
+	go singleTxPool.updateLatestBlockHeader(ctx)
+
+	return singleTxPool
 }
 
 // Add creates a Cadence transaction that wraps the given EVM transaction in
@@ -93,14 +99,14 @@ func (t *SingleTxPool) Add(
 		return err
 	}
 
-	latestBlock, account, err := t.fetchFlowLatestBlockAndCOA(ctx)
+	account, err := t.client.GetAccount(ctx, t.config.COAAddress)
 	if err != nil {
 		return err
 	}
 
 	script := replaceAddresses(runTxScript, t.config.FlowNetworkID)
 	flowTx, err := t.buildTransaction(
-		latestBlock,
+		t.latestBlockHeader,
 		account,
 		script,
 		hexEncodedTx,
@@ -157,7 +163,7 @@ func (t *SingleTxPool) Add(
 // buildTransaction creates a Cadence transaction from the provided script,
 // with the given arguments and signs it with the configured COA account.
 func (t *SingleTxPool) buildTransaction(
-	latestBlock *flow.Block,
+	latestBlockHeader *flow.BlockHeader,
 	account *flow.Account,
 	script []byte,
 	args ...cadence.Value,
@@ -168,7 +174,7 @@ func (t *SingleTxPool) buildTransaction(
 
 	flowTx := flow.NewTransaction().
 		SetScript(script).
-		SetReferenceBlockID(latestBlock.ID).
+		SetReferenceBlockID(latestBlockHeader.ID).
 		SetComputeLimit(flowGo.DefaultMaxTransactionGasLimit)
 
 	for _, arg := range args {
@@ -193,37 +199,40 @@ func (t *SingleTxPool) buildTransaction(
 	}
 
 	// now that the transaction is prepared, store the transaction's metadata
-	accKey.SetLockMetadata(flowTx.ID(), latestBlock.Height)
+	accKey.SetLockMetadata(flowTx.ID(), latestBlockHeader.Height)
 
 	t.collector.OperatorBalance(account)
 
 	return flowTx, nil
 }
 
-func (t *SingleTxPool) fetchFlowLatestBlockAndCOA(ctx context.Context) (
-	*flow.Block,
-	*flow.Account,
-	error,
-) {
-	var (
-		g           = errgroup.Group{}
-		err1, err2  error
-		latestBlock *flow.Block
-		account     *flow.Account
-	)
-
-	// execute concurrently so we can speed up all the information we need for tx
-	g.Go(func() error {
-		latestBlock, err1 = t.client.GetLatestBlock(ctx, true)
-		return err1
-	})
-	g.Go(func() error {
-		account, err2 = t.client.GetAccount(ctx, t.config.COAAddress)
-		return err2
-	})
-	if err := g.Wait(); err != nil {
-		return nil, nil, err
+func (t *SingleTxPool) updateLatestBlockHeader(ctx context.Context) {
+	if t.latestBlockHeader == nil {
+		blockHeader, err := t.client.GetLatestBlockHeader(ctx, false)
+		if err != nil {
+			t.logger.Error().Err(err).Msg(
+				"failed to update latest Flow block header",
+			)
+		}
+		t.latestBlockHeader = blockHeader
 	}
 
-	return latestBlock, account, nil
+	ticker := time.NewTicker(time.Second * 1)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			blockHeader, err := t.client.GetLatestBlockHeader(ctx, false)
+			if err != nil {
+				t.logger.Error().Err(err).Msg(
+					"failed to update latest Flow block header",
+				)
+				continue
+			}
+			t.latestBlockHeader = blockHeader
+		}
+	}
 }

tests/helpers.go

@@ -90,7 +90,7 @@ func startEmulator(createTestAccounts bool) (*server.EmulatorServer, error) {
 		GenesisTokenSupply:     genesisToken,
 		WithContracts:          true,
 		Host:                   "localhost",
-		TransactionExpiry:      10,
+		TransactionExpiry:      flow.DefaultTransactionExpiry,
 		TransactionMaxGasLimit: flow.DefaultMaxTransactionGasLimit,
 		SetupEVMEnabled:        true,
 		SetupVMBridgeEnabled:   false,