Improve TXM performance by optimize Confirmer and Finalizer queries to stop pulling EVM receipt

.changeset/cuddly-eels-lay.md

@@ -0,0 +1,5 @@
+---
+"chainlink": minor
+---
+
+Improve TXM performance by optimize Confirmer and Finalizer queries to stop pulling EVM receipt. #internal #changed #updated

core/chains/evm/txmgr/evm_tx_store.go

@@ -669,10 +669,14 @@ func (o *evmTxStore) loadEthTxAttemptsReceipts(ctx context.Context, etx *Tx) (er
 	return o.loadEthTxesAttemptsReceipts(ctx, []*Tx{etx})
 }
 
-func (o *evmTxStore) loadEthTxesAttemptsReceipts(ctx context.Context, etxs []*Tx) (err error) {
+// initEthTxesAttempts takes an input txes slice, return initialized an attempt map and attemptHashes slice, as well as
+//
+//	a third value indicate if the input slice is empty
+func initEthTxesAttempts(etxs []*Tx) (map[common.Hash]*TxAttempt, [][]byte, bool) {
 	if len(etxs) == 0 {
-		return nil
+		return nil, nil, true
 	}
+
 	attemptHashM := make(map[common.Hash]*TxAttempt, len(etxs)) // len here is lower bound
 	attemptHashes := make([][]byte, len(etxs))                  // len here is lower bound
 	for _, etx := range etxs {
@@ -681,6 +685,16 @@ func (o *evmTxStore) loadEthTxesAttemptsReceipts(ctx context.Context, etxs []*Tx
 			attemptHashes = append(attemptHashes, attempt.Hash.Bytes())
 		}
 	}
+
+	return attemptHashM, attemptHashes, false
+}
+
+func (o *evmTxStore) loadEthTxesAttemptsReceipts(ctx context.Context, etxs []*Tx) (err error) {
+	attemptHashM, attemptHashes, isEmpty := initEthTxesAttempts(etxs)
+	if isEmpty {
+		return nil
+	}
+
 	var rs []DbReceipt
 	if err = o.q.SelectContext(ctx, &rs, `SELECT * FROM evm.receipts WHERE tx_hash = ANY($1)`, pq.Array(attemptHashes)); err != nil {
 		return pkgerrors.Wrap(err, "loadEthTxesAttemptsReceipts failed to load evm.receipts")
@@ -697,6 +711,37 @@ func (o *evmTxStore) loadEthTxesAttemptsReceipts(ctx context.Context, etxs []*Tx
 	return nil
 }
 
+// loadEthTxesAttemptsWithPartialReceipts loads ethTxes with partial attempts values for optimization
+func (o *evmTxStore) loadEthTxesAttemptsWithPartialReceipts(ctx context.Context, etxs []*Tx) (err error) {
+	attemptHashM, attemptHashes, isEmpty := initEthTxesAttempts(etxs)
+	if isEmpty {
+		return nil
+	}
+
+	var rs []DbReceipt
+	if err = o.q.SelectContext(ctx, &rs, `SELECT evm.receipts.block_hash, evm.receipts.block_number, evm.receipts.transaction_index, evm.receipts.tx_hash FROM evm.receipts WHERE tx_hash = ANY($1)`, pq.Array(attemptHashes)); err != nil {
+		return pkgerrors.Wrap(err, "loadEthTxesAttemptsReceipts failed to load evm.receipts")
+	}
+
+	receipts := make([]*evmtypes.Receipt, len(rs))
+	for i := 0; i < len(rs); i++ {
+		receipts[i] = &evmtypes.Receipt{
+			BlockHash:        rs[i].BlockHash,
+			BlockNumber:      big.NewInt(rs[i].BlockNumber),
+			TransactionIndex: rs[i].TransactionIndex,
+			TxHash:           rs[i].TxHash,
+		}
+	}
+
+	for _, receipt := range receipts {
+		attempt := attemptHashM[receipt.TxHash]
+		// Although the attempts struct supports multiple receipts, the expectation for EVM is that there is only one receipt
+		// per tx and therefore attempt too.
+		attempt.Receipts = append(attempt.Receipts, receipt)
+	}
+	return nil
+}
+
 func loadConfirmedAttemptsReceipts(ctx context.Context, q sqlutil.DataSource, attempts []TxAttempt) error {
 	byHash := make(map[string]*TxAttempt, len(attempts))
 	hashes := make([][]byte, len(attempts))
@@ -1172,7 +1217,9 @@ ORDER BY nonce ASC
 		if err = orm.LoadTxesAttempts(ctx, etxs); err != nil {
 			return pkgerrors.Wrap(err, "FindTransactionsConfirmedInBlockRange failed to load evm.tx_attempts")
 		}
-		err = orm.loadEthTxesAttemptsReceipts(ctx, etxs)
+
+		// retrieve tx with attempts which contain partial attempts values for optimization purpose
+		err = orm.loadEthTxesAttemptsWithPartialReceipts(ctx, etxs)
 		return pkgerrors.Wrap(err, "FindTransactionsConfirmedInBlockRange failed to load evm.receipts")
 	})
 	return etxs, pkgerrors.Wrap(err, "FindTransactionsConfirmedInBlockRange failed")
@@ -2078,8 +2125,10 @@ func (o *evmTxStore) FindConfirmedTxesReceipts(ctx context.Context, finalizedBlo
 	var cancel context.CancelFunc
 	ctx, cancel = o.stopCh.Ctx(ctx)
 	defer cancel()
+
+	// note the receipts are partially loaded for performance reason
 	err = o.Transact(ctx, true, func(orm *evmTxStore) error {
-		sql := `SELECT evm.receipts.* FROM evm.receipts
+		sql := `SELECT evm.receipts.id, evm.receipts.tx_hash, evm.receipts.block_hash, evm.receipts.block_number FROM evm.receipts
 		INNER JOIN evm.tx_attempts ON evm.tx_attempts.hash = evm.receipts.tx_hash
 		INNER JOIN evm.txes ON evm.txes.id = evm.tx_attempts.eth_tx_id
 		WHERE evm.txes.state = 'confirmed' AND evm.receipts.block_number <= $1 AND evm.txes.evm_chain_id = $2`

core/chains/evm/txmgr/evm_tx_store_test.go

@@ -816,6 +816,12 @@ func TestORM_FindTransactionsConfirmedInBlockRange(t *testing.T) {
 		assert.Equal(t, etxes[0].Sequence, etx_8.Sequence)
 		assert.Equal(t, etxes[1].Sequence, etx_9.Sequence)
 	})
+
+	t.Run("return no error when no transactions in range found", func(t *testing.T) {
+		etxes, err := txStore.FindTransactionsConfirmedInBlockRange(tests.Context(t), 0, 0, ethClient.ConfiguredChainID())
+		require.NoError(t, err)
+		assert.Len(t, etxes, 0)
+	})
 }
 
 func TestORM_FindEarliestUnconfirmedBroadcastTime(t *testing.T) {

core/chains/evm/txmgr/finalizer.go

@@ -10,6 +10,8 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/rpc"
 
+	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils"
+
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 	"github.com/smartcontractkit/chainlink-common/pkg/services"
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/mailbox"
@@ -174,7 +176,7 @@ func (f *evmFinalizer) processFinalizedHead(ctx context.Context, latestFinalized
 	// Find transactions with receipt block nums older than the latest finalized block num and block hashes still in chain
 	for _, receipt := range unfinalizedReceipts {
 		// The tx store query ensures transactions have receipts but leaving this check here for a belts and braces approach
-		if receipt.Receipt.IsZero() || receipt.Receipt.IsUnmined() {
+		if receipt.TxHash == utils.EmptyHash || receipt.BlockHash == utils.EmptyHash {
 			f.lggr.AssumptionViolationw("invalid receipt found for confirmed transaction", "receipt", receipt)
 			continue
 		}