Update tx submission logic to only fetch a single account key from the COA

Author: m-Peter

services/requester/batch_tx_pool.go

@@ -161,10 +161,10 @@ func (t *BatchTxPool) processPooledTransactions(ctx context.Context) {
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
-			latestBlock, account, err := t.fetchFlowLatestBlockAndCOA(ctx)
+			latestBlock, err := t.client.GetLatestBlock(ctx, true)
 			if err != nil {
 				t.logger.Error().Err(err).Msg(
-					"failed to get COA / latest Flow block on batch tx submission",
+					"failed to get latest Flow block on batch tx submission",
 				)
 				continue
 			}
@@ -181,7 +181,6 @@ func (t *BatchTxPool) processPooledTransactions(ctx context.Context) {
 				err := t.batchSubmitTransactionsForSameAddress(
 					ctx,
 					latestBlock,
-					account,
 					pooledTxs,
 				)
 				if err != nil {
@@ -199,7 +198,6 @@ func (t *BatchTxPool) processPooledTransactions(ctx context.Context) {
 func (t *BatchTxPool) batchSubmitTransactionsForSameAddress(
 	ctx context.Context,
 	latestBlock *flow.Block,
-	account *flow.Account,
 	pooledTxs []pooledEvmTx,
 ) error {
 	// Sort the transactions based on their nonce, to make sure
@@ -220,8 +218,8 @@ func (t *BatchTxPool) batchSubmitTransactionsForSameAddress(
 
 	script := replaceAddresses(runTxScript, t.config.FlowNetworkID)
 	flowTx, err := t.buildTransaction(
+		ctx,
 		latestBlock,
-		account,
 		script,
 		cadence.NewArray(hexEncodedTxs),
 		coinbaseAddress,
@@ -244,7 +242,7 @@ func (t *BatchTxPool) submitSingleTransaction(
 	ctx context.Context,
 	hexEncodedTx cadence.String,
 ) error {
-	latestBlock, account, err := t.fetchFlowLatestBlockAndCOA(ctx)
+	latestBlock, err := t.client.GetLatestBlock(ctx, true)
 	if err != nil {
 		return err
 	}
@@ -256,8 +254,8 @@ func (t *BatchTxPool) submitSingleTransaction(
 
 	script := replaceAddresses(runTxScript, t.config.FlowNetworkID)
 	flowTx, err := t.buildTransaction(
+		ctx,
 		latestBlock,
-		account,
 		script,
 		cadence.NewArray([]cadence.Value{hexEncodedTx}),
 		coinbaseAddress,

services/requester/keystore/account_key.go

@@ -54,26 +54,31 @@ func (k *AccountKey) SetLockMetadata(txID flowsdk.Identifier, referenceBlockHeig
 // SetProposerPayerAndSign sets the proposer, payer, and signs the transaction with the key.
 func (k *AccountKey) SetProposerPayerAndSign(
 	tx *flowsdk.Transaction,
-	account *flowsdk.Account,
+	address flowsdk.Address,
+	acckey *flowsdk.AccountKey,
 ) error {
-	if k.Address != account.Address {
+	if acckey == nil {
+		return fmt.Errorf("nil account key provided for address %s (index %d)", address, k.Index)
+	}
+
+	if k.Address != address {
 		return fmt.Errorf(
-			"expected address: %v, got address: %v",
+			"expected address: %s, got address: %s",
 			k.Address,
-			account.Address,
+			address,
 		)
 	}
-	if k.Index >= uint32(len(account.Keys)) {
+
+	if k.Index != acckey.Index {
 		return fmt.Errorf(
-			"key index: %d exceeds keys length: %d",
+			"expected account key with index: %d, got key with index: %d",
 			k.Index,
-			len(account.Keys),
+			acckey.Index,
 		)
 	}
-	seqNumber := account.Keys[k.Index].SequenceNumber
 
 	return tx.
-		SetProposalKey(k.Address, k.Index, seqNumber).
+		SetProposalKey(k.Address, k.Index, acckey.SequenceNumber).
 		SetPayer(k.Address).
 		SignEnvelope(k.Address, k.Index, k.Signer)
 }

services/requester/keystore/key_store_test.go

@@ -200,7 +200,7 @@ func TestKeySigning(t *testing.T) {
 	}
 	tx := sdk.NewTransaction()
 
-	err = key.SetProposerPayerAndSign(tx, account)
+	err = key.SetProposerPayerAndSign(tx, address, accountKey)
 	require.NoError(t, err)
 
 	assert.Equal(t, account.Address, tx.ProposalKey.Address)

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"
@@ -93,15 +92,15 @@ func (t *SingleTxPool) Add(
 		return err
 	}
 
-	latestBlock, account, err := t.fetchFlowLatestBlockAndCOA(ctx)
+	latestBlock, err := t.client.GetLatestBlock(ctx, true)
 	if err != nil {
 		return err
 	}
 
 	script := replaceAddresses(runTxScript, t.config.FlowNetworkID)
 	flowTx, err := t.buildTransaction(
+		ctx,
 		latestBlock,
-		account,
 		script,
 		cadence.NewArray([]cadence.Value{hexEncodedTx}),
 		coinbaseAddress,
@@ -157,8 +156,8 @@ 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(
+	ctx context.Context,
 	latestBlock *flow.Block,
-	account *flow.Account,
 	script []byte,
 	args ...cadence.Value,
 ) (*flow.Transaction, error) {
@@ -177,53 +176,33 @@ func (t *SingleTxPool) buildTransaction(
 		}
 	}
 
-	// building and signing transactions should be blocking,
-	// so we don't have keys conflict
-	t.mux.Lock()
-	defer t.mux.Unlock()
+	accKey, err := t.fetchSigningAccountKey()
+	if err != nil {
+		return nil, err
+	}
 
-	accKey, err := t.keystore.Take()
+	coaAddress := t.config.COAAddress
+	accountKey, err := t.client.GetAccountKeyAtLatestBlock(ctx, coaAddress, accKey.Index)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := accKey.SetProposerPayerAndSign(flowTx, account); err != nil {
+	if err := accKey.SetProposerPayerAndSign(flowTx, coaAddress, accountKey); err != nil {
 		accKey.Done()
 		return nil, err
 	}
 
 	// now that the transaction is prepared, store the transaction's metadata
 	accKey.SetLockMetadata(flowTx.ID(), latestBlock.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) fetchSigningAccountKey() (*keystore.AccountKey, error) {
+	// building and signing transactions should be
+	// blocking, so we don't have conflicts with keys.
+	t.mux.Lock()
+	defer t.mux.Unlock()
 
-	return latestBlock, account, nil
+	return t.keystore.Take()
 }