chore(runway): cherry-pick fix: cp-7.77.0 cp-7.78.0 missing metamask pay transactions in activity (#30217)

runway-github[bot] · matthewwalsh0 · web-flow · commit b35b7f445303 · 2026-05-15T12:52:47.000+02:00
- fix: cp-7.77.0 cp-7.78.0 missing metamask pay transactions in activity (#30145) ## **Description** The Activity tab had several bugs causing MetaMask Pay transactions to be missing, duplicated, or unreachable from the source chain. This PR addresses four root causes in production code plus a test alignment for the bridge smoke E2E: 1. **Source-chain visibility.** Submitted EVM transactions were filtered strictly by `tx.chainId`, so a MetaMask Pay parent was only visible on its destination chain. The source chain is recorded on `metamaskPay.chainId` (for gasless flows) or on linked child transactions via `requiredTransactionIds` (for non-gasless flows). A new `selectRelatedChainIdsByTransactionId` selector returns the full set of chain IDs a transaction relates to, and the Activity list now matches against that set. 2. **Dedupe fallback collapsed internal MetaMask Pay transactions.** When a transaction had no nonce, `selectLocalTransactions` fell back to `txParams.actionId` as the dedupe key. `actionId` is a top-level field on `TransactionMeta`, not on `txParams`, so for MetaMask Pay internal transactions (which have no nonce) every entry collapsed onto the same `undefined` key and all but one were dropped. The fallback now uses the top-level `id`, which is always present. 3. **Local transactions were scoped to the wrong account.** `selectLocalTransactions` gated on `selectEvmAddress` — the EVM address of the **currently selected internal account**. When the user picked a non-EVM account (e.g. Solana), this was `undefined` and the selector returned an empty list. Switching to "All popular networks" did not restore the address because that toggle changes enabled networks, not the selected account. It now uses `selectSelectedAccountGroupEvmInternalAccount`, the same source already used by the Activity tab's API query. 4. **Incoming-transaction duplicates.** The `TransactionController` incoming-transactions feature stores incoming transfers as separate `TransactionMeta` entries marked with `isTransfer !== undefined`. The accounts API also returns these transactions in its confirmed history, producing duplicate rows in the Activity tab. The dedupe step now skips entries with `isTransfer !== undefined`, leaving the accounts-API row as the canonical source. 5. **Bridge smoke E2E row alignment.** The Activity list merges pending smart transactions in alongside the real `TransactionMeta` row, producing a stale shell entry that lands at row 0. `bridge-action-smoke` was asserting on row 0 and timing out. The test now asserts on row 1, with a TODO to remove the STX-state merge from the Activity selectors and restore row 0. ## **Changelog** CHANGELOG entry: Fixed MetaMask Pay transactions appearing duplicated or missing from the Activity tab, including on the source chain and when the selected account is non-EVM. ## **Related issues** Fixes: [#30066](#30066) ## **Manual testing steps** ```gherkin Feature: MetaMask Pay Activity visibility Scenario: User views Activity on the chain that funded a MetaMask Pay transaction Given the user has completed a MetaMask Pay transaction funded by a token on chain X with destination chain Y And both chains X and Y are enabled networks When the user opens the Activity tab with chain X selected Then the MetaMask Pay transaction is visible in the list When the user opens the Activity tab with chain Y selected Then the MetaMask Pay transaction is also visible in the list Scenario: User views Activity after switching to a non-EVM account Given the user has pending MetaMask Pay transactions visible in the Activity tab When the user switches to a non-EVM account in the same account group And switches back to "All popular networks" Then the pending MetaMask Pay transactions remain visible Scenario: User views a single on-chain MetaMask Pay transaction Given the user has completed a single-chain MetaMask Pay transaction (for example an mUSD conversion) When the user opens the Activity tab Then the transaction appears exactly once ``` ## **Screenshots/Recordings** ### **Before**  ### **After**  ## **Pre-merge author checklist** - [x] I've followed [MetaMask Contributor Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile Coding Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md). - [x] I've completed the PR template to the best of my ability - [x] I've included tests if applicable - [x] I've documented my code using [JSDoc](https://jsdoc.app/) format if applicable - [x] I've applied the right labels on the PR (see [labeling guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)). Not required for external contributors. #### Performance checks (if applicable) - [ ] I've tested on Android - [ ] I've tested with a power user scenario - [ ] I've instrumented key operations with Sentry traces for production performance metrics ## **Pre-merge reviewer checklist** - [ ] I've manually tested the PR (e.g. pull and build branch, run the app, test code being changed). - [ ] I confirm that this PR addresses all acceptance criteria described in the ticket it closes and includes the necessary testing evidence such as recordings and or screenshots.  --- > [!NOTE] > <sup>[Cursor Bugbot](https://cursor.com/bugbot) is generating a summary for commit f45d17e. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup>  [ff95f16](ff95f16) Co-authored-by: Matthew Walsh <matthew.walsh@consensys.net>
diff --git a/app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.tsx b/app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.tsx
@@ -28,7 +28,10 @@ import {
   selectEVMEnabledNetworks,
   selectNonEVMEnabledNetworks,
 } from '../../../selectors/networkEnablementController';
-import { selectLocalTransactions } from '../../../selectors/transactionController';
+import {
+  selectLocalTransactions,
+  selectRelatedChainIdsByTransactionId,
+} from '../../../selectors/transactionController';
 import { baseStyles } from '../../../styles/common';
 import { areAddressesEqual, isHardwareAccount } from '../../../util/address';
 import { getBlockExplorerAddressUrl } from '../../../util/networks';
@@ -167,6 +170,10 @@ const UnifiedTransactionsView = ({
     [enabledNonEVMNetworks],
   );
 
+  const relatedChainIdsByTransactionId = useSelector(
+    selectRelatedChainIdsByTransactionId,
+  );
+
   /** Drop confirmed rows not on currently enabled EVM chains (guards stale query pages). */
   const allConfirmedForEnabledChains = useMemo<TransactionViewModel[]>(() => {
     const chains = enabledEVMChainIds ?? [];
@@ -207,12 +214,18 @@ const UnifiedTransactionsView = ({
         }
 
         const { chainId: _chainId, txParams } = tx;
+
         if (!enabledEvmSet.size) {
           return false;
         }
-        if (!_chainId || !enabledEvmSet.has(String(_chainId).toLowerCase())) {
+
+        const relatedChainIds = relatedChainIdsByTransactionId.get(tx.id) ?? [
+          String(_chainId ?? '').toLowerCase(),
+        ];
+        if (!relatedChainIds.some((id) => enabledEvmSet.has(id))) {
           return false;
         }
+
         const isBridgeTransaction = isBridgeHistoryForEvmTransaction(
           tx,
           bridgeHistoryValues,
@@ -283,6 +296,7 @@ const UnifiedTransactionsView = ({
     enabledEVMChainIds,
     enabledNonEVMChainIds,
     bridgeHistory,
+    relatedChainIdsByTransactionId,
   ]);
 
   const { data, nonEvmTransactionsForSelectedChain } = useMemo<{
diff --git a/app/selectors/transactionController.test.ts b/app/selectors/transactionController.test.ts
@@ -6,6 +6,7 @@ import {
   selectLastWithdrawTokenByType,
   selectLocalTransactions,
   selectNonReplacedTransactions,
+  selectRelatedChainIdsByTransactionId,
   selectRequiredTransactionIds,
   selectRequiredTransactionHashes,
   selectRequiredTransactions,
@@ -27,6 +28,17 @@ jest.mock('./smartTransactionsController', () => ({
   }) => state.pendingSmartTransactionsForGroup || [],
 }));
 
+jest.mock('./multichainAccounts/accountTreeController', () => ({
+  selectSelectedAccountGroupEvmInternalAccount: (state: {
+    groupEvmAccount?: { address: string } | null;
+  }) => state.groupEvmAccount ?? null,
+}));
+
+jest.mock('./accountsController', () => ({
+  selectEvmAddress: (state: { fallbackEvmAddress?: string }) =>
+    state.fallbackEvmAddress,
+}));
+
 describe('TransactionController Selectors', () => {
   describe('selectTransactions', () => {
     it('returns transactions from TransactionController state', () => {
@@ -181,58 +193,156 @@ describe('TransactionController Selectors', () => {
     });
   });
 
+  describe('selectRelatedChainIdsByTransactionId', () => {
+    const buildState = (transactions: unknown[]) =>
+      ({
+        engine: {
+          backgroundState: {
+            TransactionController: { transactions },
+          },
+        },
+      }) as unknown as RootState;
+
+    it('returns the transaction own chain id, lower-cased', () => {
+      const state = buildState([{ id: 'lone', chainId: '0xA4B1' }]);
+
+      expect(selectRelatedChainIdsByTransactionId(state).get('lone')).toEqual([
+        '0xa4b1',
+      ]);
+    });
+
+    it('includes metamaskPay.chainId for gasless MetaMask Pay parents', () => {
+      const state = buildState([
+        {
+          id: 'pay-parent',
+          chainId: '0xA4B1',
+          metamaskPay: { chainId: '0x1' },
+        },
+      ]);
+
+      expect(
+        selectRelatedChainIdsByTransactionId(state).get('pay-parent')?.sort(),
+      ).toEqual(['0x1', '0xa4b1']);
+    });
+
+    it('includes chain ids of required (child) transactions', () => {
+      const state = buildState([
+        {
+          id: 'parent',
+          chainId: '0xA4B1',
+          requiredTransactionIds: ['child-1', 'child-2'],
+        },
+        { id: 'child-1', chainId: '0x1' },
+        { id: 'child-2', chainId: '0xA' },
+      ]);
+
+      expect(
+        selectRelatedChainIdsByTransactionId(state).get('parent')?.sort(),
+      ).toEqual(['0x1', '0xa', '0xa4b1']);
+    });
+
+    it('dedupes overlapping chain ids', () => {
+      const state = buildState([
+        {
+          id: 'parent',
+          chainId: '0x1',
+          metamaskPay: { chainId: '0x1' },
+          requiredTransactionIds: ['child'],
+        },
+        { id: 'child', chainId: '0x1' },
+      ]);
+
+      expect(selectRelatedChainIdsByTransactionId(state).get('parent')).toEqual(
+        ['0x1'],
+      );
+    });
+
+    it('ignores required ids that point to missing children', () => {
+      const state = buildState([
+        { id: 'parent', chainId: '0x1', requiredTransactionIds: ['ghost'] },
+      ]);
+
+      expect(selectRelatedChainIdsByTransactionId(state).get('parent')).toEqual(
+        ['0x1'],
+      );
+    });
+  });
+
   describe('selectLocalTransactions', () => {
-    it('filters required child transactions before nonce dedupe', () => {
-      const activeEvmAddress = '0x0000000000000000000000000000000000000001';
-      const state = {
+    const evmAddress = '0x0000000000000000000000000000000000000001';
+
+    const buildLocalTxState = ({
+      groupEvmAccount = { address: evmAddress },
+      transactions,
+    }: {
+      groupEvmAccount?: { address: string } | null;
+      transactions?: unknown[];
+    } = {}) =>
+      ({
         engine: {
           backgroundState: {
-            AccountsController: {
-              internalAccounts: {
-                selectedAccount: 'account-1',
-                accounts: {
-                  'account-1': {
-                    id: 'account-1',
-                    address: activeEvmAddress,
-                    type: 'eip155:eoa',
-                  },
-                },
-              },
-            },
             TransactionController: {
-              transactions: [
+              transactions: transactions ?? [
                 {
                   id: 'child',
                   hash: '0xCHILD',
                   chainId: '0x1',
                   time: 200,
-                  txParams: {
-                    from: activeEvmAddress,
-                    nonce: '0x1',
-                  },
+                  txParams: { from: evmAddress, nonce: '0x1' },
                 },
                 {
                   id: 'parent',
                   chainId: '0x1',
                   requiredTransactionIds: ['child'],
                   time: 100,
                   type: TransactionType.predictDeposit,
-                  txParams: {
-                    from: activeEvmAddress,
-                    nonce: '0x1',
-                  },
+                  txParams: { from: evmAddress, nonce: '0x1' },
                 },
               ],
             },
           },
         },
+        groupEvmAccount,
         pendingSmartTransactionsForGroup: [],
-      } as unknown as RootState;
+      }) as unknown as RootState;
 
-      expect(selectLocalTransactions(state)).toStrictEqual([
+    it('filters required child transactions before nonce dedupe', () => {
+      expect(selectLocalTransactions(buildLocalTxState())).toStrictEqual([
         expect.objectContaining({ id: 'parent' }),
       ]);
     });
+
+    it('returns no transactions when the selected group has no EVM account', () => {
+      expect(
+        selectLocalTransactions(buildLocalTxState({ groupEvmAccount: null })),
+      ).toStrictEqual([]);
+    });
+
+    it('excludes incoming transactions populated by the TransactionController incoming-transactions feature', () => {
+      const state = buildLocalTxState({
+        transactions: [
+          {
+            id: 'outgoing',
+            hash: '0xOUTGOING',
+            chainId: '0x1',
+            time: 200,
+            txParams: { from: evmAddress, nonce: '0x1' },
+          },
+          {
+            id: 'incoming-duplicate',
+            hash: '0xOUTGOING',
+            chainId: '0x1',
+            time: 100,
+            isTransfer: true,
+            txParams: { from: evmAddress },
+          },
+        ],
+      });
+
+      expect(selectLocalTransactions(state)).toStrictEqual([
+        expect.objectContaining({ id: 'outgoing' }),
+      ]);
+    });
   });
 
   describe('selectTransactionMetadataById', () => {
diff --git a/app/selectors/transactionController.ts b/app/selectors/transactionController.ts
@@ -6,6 +6,7 @@ import {
   selectPendingSmartTransactionsForSelectedAccountGroup,
 } from './smartTransactionsController';
 import { selectEvmAddress } from './accountsController';
+import { selectSelectedAccountGroupEvmInternalAccount } from './multichainAccounts/accountTreeController';
 import {
   TransactionMeta,
   TransactionType,
@@ -26,13 +27,14 @@ function dedupeTransactions(transactions: LocalTransaction[]) {
   const seenTransactions = new Set<string>();
 
   return transactions.filter((transaction) => {
-    const { chainId, txParams } = transaction;
-    const { from, nonce, actionId } = txParams || {};
+    const { chainId, txParams, id, isTransfer } =
+      transaction as TransactionMeta;
+    const { from, nonce } = txParams || {};
     const hash = 'hash' in transaction ? transaction.hash : undefined;
     const isBridgeTransaction = transaction.type === TransactionType.bridge;
     const hasNonce = nonce !== undefined && nonce !== null;
 
-    if (!from) {
+    if (!from || isTransfer !== undefined) {
       return false;
     }
 
@@ -42,7 +44,7 @@ function dedupeTransactions(transactions: LocalTransaction[]) {
         ? `${dedupeKeyPrefix}-bridge-${hash.toLowerCase()}`
         : hasNonce
           ? `${dedupeKeyPrefix}-${nonce}`
-          : `${dedupeKeyPrefix}-${actionId}`;
+          : `${dedupeKeyPrefix}-${id}`;
 
     // Keep only the first local transaction for each dedupe key
     if (seenTransactions.has(dedupeKey)) {
@@ -115,6 +117,35 @@ export const selectRequiredTransactionHashes = createSelector(
     ),
 );
 
+export const selectRelatedChainIdsByTransactionId = createSelector(
+  selectTransactionsStrict,
+  (transactions) => {
+    const transactionsById = new Map<string, TransactionMeta>(
+      transactions.map((tx) => [tx.id, tx]),
+    );
+
+    return new Map<string, string[]>(
+      transactions
+        .map((tx) => {
+          const childChainIds = (tx.requiredTransactionIds ?? []).map(
+            (childId) => transactionsById.get(childId)?.chainId,
+          );
+
+          const chainIds = [
+            tx.chainId,
+            tx.metamaskPay?.chainId,
+            ...childChainIds,
+          ]
+            .filter((chainId): chainId is Hex => Boolean(chainId))
+            .map((chainId) => chainId.toLowerCase());
+
+          return [tx.id, [...new Set(chainIds)]] satisfies [string, string[]];
+        })
+        .filter(([, chainIds]) => chainIds.length > 0),
+    );
+  },
+);
+
 export const selectTransactions = createDeepEqualSelector(
   selectTransactionsStrict,
   (transactions) => transactions,
@@ -189,15 +220,19 @@ export const selectLocalTransactions = createDeepEqualSelector(
   [
     selectNonReplacedTransactions,
     selectPendingSmartTransactionsForSelectedAccountGroup,
+    selectSelectedAccountGroupEvmInternalAccount,
     selectEvmAddress,
     selectRequiredTransactionIds,
   ],
   (
     nonReplacedTransactions,
     pendingSmartTransactions,
-    activeEvmAddress,
+    groupEvmAccount,
+    fallbackEvmAddress,
     requiredTransactionIds,
   ) => {
+    const activeEvmAddress = groupEvmAccount?.address ?? fallbackEvmAddress;
+
     const transactions = nonReplacedTransactions.filter((transaction) => {
       if (requiredTransactionIds.has(transaction.id)) {
         return false;
diff --git a/tests/smoke/swap/bridge-action-smoke.spec.ts b/tests/smoke/swap/bridge-action-smoke.spec.ts
@@ -26,7 +26,11 @@ describe(SmokeSwap('Bridge functionality'), () => {
     const sourceSymbol: string = 'ETH';
     const chainId = '0x1';
     const destChainId = '0x2105';
-    const FIRST_ROW: number = 0;
+
+    // Row 0 is a stale STX-shaped entry; the confirmed bridge tx is on row 1.
+    // TODO: stop merging SmartTransactionsController state into
+    // selectLocalTransactions / selectSortedTransactions, then assert row 0.
+    const BRIDGE_ROW: number = 1;
 
     await withFixtures(
       {
@@ -103,7 +107,7 @@ describe(SmokeSwap('Bridge functionality'), () => {
         );
 
         await Assertions.expectElementToHaveText(
-          ActivitiesView.transactionStatus(FIRST_ROW),
+          ActivitiesView.transactionStatus(BRIDGE_ROW),
           ActivitiesViewSelectorsText.CONFIRM_TEXT,
           {
             timeout: 120000,
