fix: preserve local pay activity transactions

Co-authored-by: Francis Nepomuceno <n3ps@users.noreply.github.com>

Author: cursoragent

app/components/Views/UnifiedTransactionsView/helpers/transformations.test.ts

@@ -75,4 +75,17 @@ describe('selectTransactions', () => {
 
     expect(result.pages[0].data).toHaveLength(0);
   });
+
+  it('filters out transactions with excluded hashes', () => {
+    const excluded = buildTransaction({ hash: '0xEXCLUDED' });
+    const normal = buildTransaction({ hash: '0xnormal' });
+
+    const result = selectTransactions({
+      address,
+      excludedTxHashes: new Set(['0xexcluded']),
+    })(buildData([excluded, normal]));
+
+    expect(result.pages[0].data).toHaveLength(1);
+    expect(result.pages[0].data[0].hash).toBe('0xnormal');
+  });
 });

app/components/Views/UnifiedTransactionsView/helpers/transformations.ts

@@ -85,9 +85,15 @@ function isIncomingNativeTransfer(
 function shouldSkipTransaction(
   address: string,
   transaction: V1TransactionByHashResponse,
+  excludedTxHashes?: Set<string>,
 ) {
   const rawFrom = transaction.from?.toLowerCase();
   const rawTo = transaction.to?.toLowerCase();
+  const hash = transaction.hash?.toLowerCase();
+
+  if (hash && excludedTxHashes?.has(hash)) {
+    return true;
+  }
 
   if (rawFrom !== address && rawTo !== address) {
     return true;
@@ -120,11 +126,12 @@ function shouldSkipTransaction(
 function transformTransactions(
   address: string,
   transactions: V1TransactionByHashResponse[],
+  excludedTxHashes?: Set<string>,
 ): TransactionViewModel[] {
   const filteredTransactions = [];
 
   for (const tx of transactions) {
-    if (shouldSkipTransaction(address, tx)) {
+    if (shouldSkipTransaction(address, tx, excludedTxHashes)) {
       continue;
     }
 
@@ -146,12 +153,18 @@ function transformTransactions(
   });
 }
 
-export function selectTransactions({ address }: { address: string }) {
+export function selectTransactions({
+  address,
+  excludedTxHashes,
+}: {
+  address: string;
+  excludedTxHashes?: Set<string>;
+}) {
   return (data: InfiniteData<V4MultiAccountTransactionsResponse>) => ({
     ...data,
     pages: data.pages.map((page) => ({
       ...page,
-      data: transformTransactions(address, page.data),
+      data: transformTransactions(address, page.data, excludedTxHashes),
     })),
   });
 }

app/components/Views/UnifiedTransactionsView/useTransactionsQuery.ts

@@ -7,10 +7,12 @@ import { selectEvmAddress } from '../../../selectors/accountsController';
 import { selectEvmEnabledCaipNetworks } from '../../../selectors/networkEnablementController';
 import { selectTransactions } from './helpers/transformations';
 import { MINUTE } from '../../../constants/time';
+import { selectRequiredTransactionHashes } from '../../../selectors/transactionController';
 
 export const useTransactionsQuery = () => {
   const evmAddress = useSelector(selectEvmAddress) || '';
   const networks = useSelector(selectEvmEnabledCaipNetworks);
+  const excludedTxHashes = useSelector(selectRequiredTransactionHashes);
   const accountAddresses = evmAddress
     ? [toCaipAccountId(KnownCaipNamespace.Eip155, '0', evmAddress)]
     : [];
@@ -23,8 +25,8 @@ export const useTransactionsQuery = () => {
     });
 
   const selectFn = useMemo(
-    () => selectTransactions({ address: evmAddress }),
-    [evmAddress],
+    () => selectTransactions({ address: evmAddress, excludedTxHashes }),
+    [evmAddress, excludedTxHashes],
   );
 
   // @ts-expect-error apiClient returns v5 types, repo still in v4

app/selectors/transactionController.test.ts

@@ -4,7 +4,9 @@ import { TransactionType } from '@metamask/transaction-controller';
 import {
   selectTransactions,
   selectLastWithdrawTokenByType,
+  selectLocalTransactions,
   selectNonReplacedTransactions,
+  selectRequiredTransactionHashes,
   selectSwapsTransactions,
   selectTransactionMetadataById,
   selectSortedTransactions,
@@ -96,6 +98,87 @@ describe('TransactionController Selectors', () => {
     });
   });
 
+  describe('selectRequiredTransactionHashes', () => {
+    it('returns hashes for required child transactions', () => {
+      const state = {
+        engine: {
+          backgroundState: {
+            TransactionController: {
+              transactions: [
+                {
+                  id: 'parent',
+                  requiredTransactionIds: ['child'],
+                },
+                {
+                  id: 'child',
+                  hash: '0xABC',
+                },
+              ],
+            },
+          },
+        },
+      } as unknown as RootState;
+
+      expect(selectRequiredTransactionHashes(state)).toStrictEqual(
+        new Set(['0xabc']),
+      );
+    });
+  });
+
+  describe('selectLocalTransactions', () => {
+    it('filters required child transactions before nonce dedupe', () => {
+      const activeEvmAddress = '0x0000000000000000000000000000000000000001';
+      const state = {
+        engine: {
+          backgroundState: {
+            AccountsController: {
+              internalAccounts: {
+                selectedAccount: 'account-1',
+                accounts: {
+                  'account-1': {
+                    id: 'account-1',
+                    address: activeEvmAddress,
+                    type: 'eip155:eoa',
+                  },
+                },
+              },
+            },
+            TransactionController: {
+              transactions: [
+                {
+                  id: 'child',
+                  hash: '0xCHILD',
+                  chainId: '0x1',
+                  time: 200,
+                  txParams: {
+                    from: activeEvmAddress,
+                    nonce: '0x1',
+                  },
+                },
+                {
+                  id: 'parent',
+                  chainId: '0x1',
+                  requiredTransactionIds: ['child'],
+                  time: 100,
+                  type: TransactionType.predictDeposit,
+                  txParams: {
+                    from: activeEvmAddress,
+                    nonce: '0x1',
+                  },
+                },
+              ],
+            },
+          },
+        },
+        pendingSmartTransactionsForGroup: [],
+      } as unknown as RootState;
+
+      expect(selectLocalTransactions(state).map(({ id }) => id)).toStrictEqual([
+        'parent',
+      ]);
+    });
+  });
+
   describe('selectTransactionMetadataById', () => {
     it('returns the transaction matching the given id', () => {
       const transactions = [

app/selectors/transactionController.ts

@@ -93,6 +93,28 @@ const selectTransactionBatchesStrict = createSelector(
   (transactionControllerState) => transactionControllerState.transactionBatches,
 );
 
+export const selectRequiredTransactionIds = createSelector(
+  selectTransactionsStrict,
+  (transactions) =>
+    new Set(transactions.flatMap((tx) => tx.requiredTransactionIds ?? [])),
+);
+
+export const selectRequiredTransactions = createSelector(
+  [selectTransactionsStrict, selectRequiredTransactionIds],
+  (transactions, requiredTransactionIds) =>
+    transactions.filter((tx) => requiredTransactionIds.has(tx.id)),
+);
+
+export const selectRequiredTransactionHashes = createSelector(
+  selectRequiredTransactions,
+  (transactions) =>
+    new Set(
+      transactions
+        .map((tx) => tx.hash?.toLowerCase())
+        .filter((hash): hash is string => Boolean(hash)),
+    ),
+);
+
 export const selectTransactions = createDeepEqualSelector(
   selectTransactionsStrict,
   (transactions) => transactions,
@@ -168,9 +190,23 @@ export const selectLocalTransactions = createDeepEqualSelector(
     selectNonReplacedTransactions,
     selectPendingSmartTransactionsForSelectedAccountGroup,
     selectEvmAddress,
+    selectRequiredTransactionHashes,
   ],
-  (nonReplacedTransactions, pendingSmartTransactions, activeEvmAddress) => {
+  (
+    nonReplacedTransactions,
+    pendingSmartTransactions,
+    activeEvmAddress,
+    requiredTransactionHashes,
+  ) => {
     const transactions = nonReplacedTransactions.filter((transaction) => {
+      const hash =
+        'hash' in transaction && typeof transaction.hash === 'string'
+          ? transaction.hash.toLowerCase()
+          : undefined;
+      if (hash && requiredTransactionHashes.has(hash)) {
+        return false;
+      }
+
       const fromAddress = transaction.txParams?.from;
       if (!fromAddress || !activeEvmAddress) {
         return false;
@@ -181,6 +217,14 @@ export const selectLocalTransactions = createDeepEqualSelector(
 
     const pendingSmartTransactionsForActiveAddress =
       pendingSmartTransactions.filter((transaction) => {
+        const hash =
+          'hash' in transaction && typeof transaction.hash === 'string'
+            ? transaction.hash.toLowerCase()
+            : undefined;
+        if (hash && requiredTransactionHashes.has(hash)) {
+          return false;
+        }
+
         const fromAddress = transaction.txParams?.from;
         if (!fromAddress || !activeEvmAddress) {
           return false;