cleanup

Co-authored-by: Copilot <copilot@github.com>

Author: n3ps

app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.tsx

@@ -138,8 +138,6 @@ const UnifiedTransactionsView = ({
   const selectedAccountGroupInternalAccounts = useSelector(
     selectSelectedAccountGroupInternalAccounts,
   );
-  const selectedAccountGroupInternalAccountsAddresses =
-    selectedAccountGroupInternalAccounts.map((account) => account.address);
   const selectedAccountGroupEvmAddress = useMemo(() => {
     const evmAccount = selectedAccountGroupInternalAccounts.find(
       (account) =>
@@ -181,52 +179,36 @@ const UnifiedTransactionsView = ({
     evmConfirmedItems: UnifiedItem[];
     chainFilteredNonEvmTransactionsForSelectedChain: NonEvmTransaction[];
   }>(() => {
-    // Deduplicate submitted by (address + chain + nonce) and drop if already confirmed
-    const seenSubmittedNonces = new Set<string>();
-    const submittedTxsFiltered = submittedTxs.filter((tx): tx is EvmTransaction => {
-      if (!isEvmTransaction(tx)) {
-        return false;
-      }
-
-      const { chainId: _chainId, txParams } = tx;
-      const hash = 'hash' in tx ? tx.hash : undefined;
-      const { from, nonce, actionId } = txParams || {};
-      // Some txs don't have nonce, like intent based swaps
-      const hasNonce = nonce !== undefined && nonce !== null;
-      if (
-        !selectedAccountGroupInternalAccountsAddresses.some((addr) =>
-          areAddressesEqual(from, addr),
-        )
-      ) {
-        return false;
-      }
-      const dedupeKeyPrefix = `${_chainId}-${String(from).toLowerCase()}`;
-      const dedupeKey = hasNonce
-        ? `${dedupeKeyPrefix}-${nonce}`
-        : `${dedupeKeyPrefix}-${actionId}`;
-      if (seenSubmittedNonces.has(dedupeKey)) {
-        return false;
-      }
+    const submittedTxsFiltered = submittedTxs.filter(
+      (tx): tx is EvmTransaction => {
+        if (!isEvmTransaction(tx)) {
+          return false;
+        }
 
-      const alreadyConfirmed = allConfirmedFiltered.find(
-        (confirmedTx) =>
-          (typeof hash === 'string' &&
-            confirmedTx.hash.toLowerCase() === hash.toLowerCase() &&
-            confirmedTx.txChainId === _chainId) ||
-          (hasNonce &&
-            confirmedTx.nonce === nonce &&
-            confirmedTx.txChainId === _chainId &&
-            Boolean(from) &&
-            areAddressesEqual(confirmedTx.from, from)),
-      );
+        const { chainId: _chainId, txParams } = tx;
+        const hash = 'hash' in tx ? tx.hash : undefined;
+        const { from, nonce } = txParams || {};
+        const hasNonce = nonce !== undefined && nonce !== null;
+
+        const alreadyConfirmed = allConfirmedFiltered.find(
+          (confirmedTx) =>
+            (typeof hash === 'string' &&
+              confirmedTx.hash.toLowerCase() === hash.toLowerCase() &&
+              confirmedTx.txChainId === _chainId) ||
+            (hasNonce &&
+              confirmedTx.nonce === nonce &&
+              confirmedTx.txChainId === _chainId &&
+              Boolean(from) &&
+              areAddressesEqual(confirmedTx.from, from)),
+        );
 
-      if (alreadyConfirmed) {
-        return false;
-      }
+        if (alreadyConfirmed) {
+          return false;
+        }
 
-      seenSubmittedNonces.add(dedupeKey);
-      return true;
-    });
+        return true;
+      },
+    );
 
     // EVM: pending/submitted first (desc), then confirmed (dedup outgoing)
     const evmPendingFirst = [...submittedTxsFiltered].sort(
@@ -271,7 +253,6 @@ const UnifiedTransactionsView = ({
     allConfirmedFiltered,
     submittedTxs,
     nonEvmTransactions,
-    selectedAccountGroupInternalAccountsAddresses,
     enabledEVMChainIds,
     enabledNonEVMChainIds,
     bridgeHistory,
@@ -590,11 +571,6 @@ const UnifiedTransactionsView = ({
           navigation={navigation}
           txChainId={item.tx.txChainId}
           selectedAddress={selectedInternalAccount?.address}
-          signQRTransaction={signQRTransaction}
-          cancelUnsignedQRTransaction={cancelUnsignedQRTransaction}
-          isQRHardwareAccount={false}
-          isLedgerAccount={false}
-          signLedgerTransaction={signLedgerTransaction}
           currentCurrency={currentCurrency}
           showBottomBorder
           location={location}

app/components/Views/UnifiedTransactionsView/hooks/useTransactionsQuery.ts

@@ -1,30 +1,19 @@
-import {
-  InfiniteData,
-  QueryFunctionContext,
-  QueryFunction,
-  QueryKey,
-  useInfiniteQuery,
-} from '@tanstack/react-query';
+import { InfiniteData, useInfiniteQuery } from '@tanstack/react-query';
 import { useMemo } from 'react';
 import { useSelector } from 'react-redux';
 import { V4MultiAccountTransactionsResponse } from '@metamask/core-backend';
-import { getApiClient } from '../../../../core/apiClient';
+import { apiClient } from '../../../../core/apiClient';
 import { selectAccountGroupEvmAccountAddresses } from '../../../../selectors/multichainAccounts/accountTreeController';
 import { selectEvmEnabledCaipNetworks } from '../../../../selectors/networkEnablementController';
 import { selectConfirmedTransactions } from '../helpers/mappers';
 import { MINUTE } from '../../../../constants/time';
-import type { ConfirmedEvmTransaction } from '../helpers/types';
-
-type ConfirmedEvmTransactionsPage = Omit<
-  V4MultiAccountTransactionsResponse,
-  'data'
-> & {
-  data: ConfirmedEvmTransaction[];
-};
 
 export const useTransactionsQuery = () => {
-  const accountAddresses = useSelector(selectAccountGroupEvmAccountAddresses);
+  const accountAddresses = useSelector(
+    selectAccountGroupEvmAccountAddresses,
+  ) as string[];
   const networks = useSelector(selectEvmEnabledCaipNetworks);
+
   const selectFn = useMemo(
     () =>
       selectConfirmedTransactions({
@@ -33,49 +22,16 @@ export const useTransactionsQuery = () => {
     [accountAddresses],
   );
 
-  const queryOptions = useMemo(() => {
-    const options =
-      getApiClient().accounts.getV4MultiAccountTransactionsInfiniteQueryOptions(
-        {
-          accountAddresses: [...accountAddresses],
-          networks: [...networks],
-          includeTxMetadata: true,
-        },
-      );
-
-    return {
-      queryKey: options.queryKey as QueryKey,
-      queryFn: options.queryFn as QueryFunction<
-        V4MultiAccountTransactionsResponse,
-        QueryKey,
-        string | undefined
-      >,
-    };
-  }, [accountAddresses, networks]);
+  const queryOptions =
+    apiClient.accounts.getV4MultiAccountTransactionsInfiniteQueryOptions({
+      accountAddresses,
+      networks,
+      includeTxMetadata: true,
+    });
 
-  return useInfiniteQuery<
-    V4MultiAccountTransactionsResponse,
-    Error,
-    ConfirmedEvmTransactionsPage,
-    QueryKey
-  >({
-    queryKey: queryOptions.queryKey,
-    queryFn: (({
-      pageParam,
-      signal,
-    }: QueryFunctionContext<QueryKey, string | undefined>) =>
-      queryOptions.queryFn({
-        pageParam,
-        signal,
-        queryKey: queryOptions.queryKey,
-        meta: undefined,
-      })) as QueryFunction<
-      V4MultiAccountTransactionsResponse,
-      QueryKey,
-      string | undefined
-    >,
-    getNextPageParam: ({ pageInfo }) =>
-      pageInfo.hasNextPage ? pageInfo.endCursor : undefined,
+  // @ts-expect-error apiClient returns v5 types, repo still in v4
+  return useInfiniteQuery({
+    ...queryOptions,
     select: selectFn,
     enabled: accountAddresses.length > 0 && networks.length > 0,
     staleTime: 5 * MINUTE,

app/core/apiClient.ts

@@ -1,21 +1,13 @@
 import { createApiPlatformClient } from '@metamask/core-backend';
 import Engine from './Engine';
 
-let apiClient: ReturnType<typeof createApiPlatformClient> | undefined;
-
-export const getApiClient = () => {
-  if (!apiClient) {
-    apiClient = createApiPlatformClient({
-      clientProduct: 'metamask-mobile',
-      getBearerToken: async () => {
-        try {
-          return await Engine.context.AuthenticationController.getBearerToken();
-        } catch {
-          return undefined;
-        }
-      },
-    });
-  }
-
-  return apiClient;
-};
+export const apiClient = createApiPlatformClient({
+  clientProduct: 'metamask-mobile',
+  getBearerToken: async () => {
+    try {
+      return await Engine.context.AuthenticationController.getBearerToken();
+    } catch {
+      return undefined;
+    }
+  },
+});

app/selectors/multichainAccounts/accountTreeController.ts

@@ -430,13 +430,13 @@ export const selectAccountGroupEvmAccountAddresses = createSelector(
   [selectSelectedInternalAccount, selectAccountGroupEvmInternalAccounts],
   (selectedInternalAccount, groupEvmAccounts) => {
     const selectedEvmAccount =
-      selectedInternalAccount &&
-      isEvmAccountType(selectedInternalAccount.type)
-      ? selectedInternalAccount
-      : (groupEvmAccounts.find(
-          (account) =>
-            account.type === 'eip155:eoa' || account.type === 'eip155:erc4337',
-        ) ?? groupEvmAccounts[0]);
+      selectedInternalAccount && isEvmAccountType(selectedInternalAccount.type)
+        ? selectedInternalAccount
+        : (groupEvmAccounts.find(
+            (account) =>
+              account.type === 'eip155:eoa' ||
+              account.type === 'eip155:erc4337',
+          ) ?? groupEvmAccounts[0]);
 
     if (!selectedEvmAccount?.address) {
       return EMPTY_ARR as readonly CaipAccountId[];
@@ -470,6 +470,6 @@ export const selectSelectedAccountGroupWithInternalAccountsAddresses =
           }
           return null;
         })
-        .filter(Boolean);
+        .filter((address): address is string => Boolean(address));
     },
   );

app/selectors/transactionController.ts

@@ -5,11 +5,12 @@ import {
   selectPendingSmartTransactionsBySender,
   selectPendingSmartTransactionsForSelectedAccountGroup,
 } from './smartTransactionsController';
-import { selectSelectedAccountGroupInternalAccounts } from './multichainAccounts/accountTreeController';
+import { selectSelectedAccountGroupWithInternalAccountsAddresses } from './multichainAccounts/accountTreeController';
 import {
   TransactionMeta,
   TransactionType,
 } from '@metamask/transaction-controller';
+import { SmartTransaction } from '@metamask/smart-transactions-controller';
 import { Hex } from '@metamask/utils';
 import { areAddressesEqual } from '../util/address';
 
@@ -18,14 +19,53 @@ interface MetaMaskPayToken {
   chainId: Hex;
 }
 
-const PENDING_EVM_TRANSACTION_STATUSES = new Set([
+type LocalTransaction = TransactionMeta | SmartTransaction;
+
+const transactionPendingStatuses = new Set([
   'submitted',
   'signed',
   'unapproved',
   'approved',
   'pending',
 ]);
 
+function dedupeTransactions(
+  transactions: LocalTransaction[],
+  addresses: readonly string[],
+) {
+  // Deduplicate submitted by (address + chain + nonce) and drop if already confirmed
+  const seenTransactions = new Set<string>();
+
+  return transactions.filter((transaction) => {
+    const { chainId, txParams } = transaction;
+    const { from, nonce, actionId } = txParams || {};
+    const hasNonce = nonce !== undefined && nonce !== null;
+
+    // Skip transactions that do not belong to one of the selected addresses
+    if (
+      !from ||
+      !addresses.some((address) => areAddressesEqual(from, address || ''))
+    ) {
+      return false;
+    }
+
+    // Build a stable local dedupe key using nonce when available, or actionId for nonce-less flows
+    // Extracted from UnifiedTransactionsView
+    const dedupeKeyPrefix = `${chainId}-${String(from).toLowerCase()}`;
+    const dedupeKey = hasNonce
+      ? `${dedupeKeyPrefix}-${nonce}`
+      : `${dedupeKeyPrefix}-${actionId}`;
+
+    // Keep only the first local pending transaction for each dedupe key
+    if (seenTransactions.has(dedupeKey)) {
+      return false;
+    }
+
+    seenTransactions.add(dedupeKey);
+    return true;
+  });
+}
+
 function getNestedTransactionTypes(
   transaction: TransactionMeta,
 ): TransactionType[] {
@@ -139,37 +179,35 @@ export const selectLocalTransactions = createDeepEqualSelector(
   [
     selectNonReplacedTransactions,
     selectPendingSmartTransactionsForSelectedAccountGroup,
-    selectSelectedAccountGroupInternalAccounts,
+    selectSelectedAccountGroupWithInternalAccountsAddresses,
   ],
-  (
-    nonReplacedTransactions,
-    pendingSmartTransactions,
-    selectedAccountGroupInternalAccounts,
-  ) => {
-    const selectedAddresses = selectedAccountGroupInternalAccounts
-      .map((account) => account.address)
-      .filter(Boolean);
-
+  (nonReplacedTransactions, pendingSmartTransactions, addresses) => {
     const pendingTransactions = nonReplacedTransactions.filter(
       (transaction) => {
-        if (!PENDING_EVM_TRANSACTION_STATUSES.has(transaction.status)) {
+        // Only keep local EVM transactions that are pending-like
+        // Extracted from UnifiedTransactionsView submittedTxs filter
+        if (!transactionPendingStatuses.has(transaction.status)) {
           return false;
         }
 
+        // We can only scope a pending transaction to the active account if it has a sender
         const fromAddress = transaction.txParams?.from;
         if (!fromAddress) {
           return false;
         }
 
-        return selectedAddresses.some((address) =>
+        // Only keep pending transactions sent from one of the selected account addresses
+        // Extracted from UnifiedTransactionsView submittedTxsFiltered filter
+        return addresses.some((address) =>
           areAddressesEqual(fromAddress, address),
         );
       },
     );
 
-    return [...pendingTransactions, ...pendingSmartTransactions].sort(
-      (a, b) => (b?.time ?? 0) - (a?.time ?? 0),
-    );
+    return dedupeTransactions(
+      [...pendingTransactions, ...pendingSmartTransactions],
+      addresses,
+    ).sort((a, b) => (b?.time ?? 0) - (a?.time ?? 0));
   },
 );