MetaMask
diff --git a/‎app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.test.tsx‎
Lines changed: 276 additions & 1 deletion b/‎app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.test.tsx‎
Lines changed: 276 additions & 1 deletion
diff --git a/‎app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.tsx‎
Lines changed: 32 additions & 7 deletions b/‎app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.tsx‎
Lines changed: 32 additions & 7 deletions
@@ -2,7 +2,10 @@ import React, { ComponentType } from 'react';
 import { RefreshControl } from 'react-native';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import type { V1TransactionByHashResponse } from '@metamask/core-backend';
-import { TransactionStatus } from '@metamask/transaction-controller';
+import {
+  TransactionStatus,
+  type TransactionMeta,
+} from '@metamask/transaction-controller';
 import { Hex } from '@metamask/utils';
 import UnifiedTransactionsView from './UnifiedTransactionsView';
 import _renderWithProvider from '../../../util/test/renderWithProvider';
@@ -615,6 +618,278 @@ describe('UnifiedTransactionsView with transactions', () => {
   });
 });
 
+describe('UnifiedTransactionsView - EVM network filter for unified list', () => {
+  const WALLET = '0xabc';
+
+  /** Required so selectLocalTransactions includes pending txs for UnifiedTransactionsView filtering. */
+  const accountsControllerForWallet = {
+    ...backgroundState.AccountsController,
+    internalAccounts: {
+      accounts: {
+        'wallet-evm-id': {
+          id: 'wallet-evm-id',
+          type: 'eip155:eoa' as const,
+          address: WALLET,
+          options: {},
+          methods: [],
+          metadata: {
+            name: 'Account 1',
+            keyring: { type: 'HD Key Tree' },
+          },
+        },
+      },
+      selectedAccount: 'wallet-evm-id',
+    },
+  };
+
+  const emptyEvmChainsState = {
+    engine: {
+      backgroundState: {
+        ...backgroundState,
+        AccountsController: accountsControllerForWallet,
+        NetworkEnablementController: {
+          ...backgroundState.NetworkEnablementController,
+          enabledNetworkMap: {
+            ...backgroundState.NetworkEnablementController.enabledNetworkMap,
+            eip155: {},
+          },
+        },
+      },
+    },
+  };
+
+  const stateOnlyOptimism = {
+    engine: {
+      backgroundState: {
+        ...backgroundState,
+        AccountsController: accountsControllerForWallet,
+        NetworkEnablementController: {
+          ...backgroundState.NetworkEnablementController,
+          enabledNetworkMap: {
+            ...backgroundState.NetworkEnablementController.enabledNetworkMap,
+            eip155: { '0xa': true },
+          },
+        },
+      },
+    },
+  };
+
+  const stateOnlyMainnet = {
+    engine: {
+      backgroundState: {
+        ...backgroundState,
+        AccountsController: accountsControllerForWallet,
+        NetworkEnablementController: {
+          ...backgroundState.NetworkEnablementController,
+          enabledNetworkMap: {
+            ...backgroundState.NetworkEnablementController.enabledNetworkMap,
+            eip155: { '0x1': true },
+          },
+        },
+      },
+    },
+  };
+
+  const createOutgoingMainnetConfirmed = (): V1TransactionByHashResponse =>
+    ({
+      accountId: `eip155:1:${WALLET}`,
+      blockHash: '0xblock',
+      blockNumber: 1,
+      chainId: 1,
+      cumulativeGasUsed: 21000,
+      effectiveGasPrice: '1',
+      from: WALLET,
+      gas: 21000,
+      gasPrice: '1',
+      gasUsed: 21000,
+      hash: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      isError: false,
+      logs: [],
+      methodId: '0x',
+      nonce: 1,
+      readable: 'Transfer',
+      timestamp: '2026-04-29T19:28:41.000Z',
+      to: '0x1111111111111111111111111111111111111111',
+      transactionCategory: 'TRANSFER',
+      transactionType: 'SIMPLE_SEND',
+      value: '1',
+      valueTransfers: [],
+    }) as V1TransactionByHashResponse;
+
+  const queryDataMainnetConfirmed = selectTransactions({
+    address: WALLET,
+  })({
+    pageParams: [undefined],
+    pages: [
+      {
+        data: [createOutgoingMainnetConfirmed()],
+        unprocessedNetworks: [],
+        pageInfo: {
+          count: 1,
+          endCursor: undefined,
+          hasNextPage: false,
+        },
+      },
+    ],
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUseTransactionsQuery();
+    (useUnifiedTxActions as jest.Mock).mockImplementation(
+      () => mockDefaultUnifiedTxActionsReturn,
+    );
+  });
+
+  it('hides confirmed EVM rows when no EVM chains are enabled', () => {
+    mockUseTransactionsQuery(queryDataMainnetConfirmed);
+
+    const { getByText } = renderWithProvider(<UnifiedTransactionsView />, {
+      state: emptyEvmChainsState,
+    });
+
+    expect(getByText('You have no transactions')).toBeOnTheScreen();
+  });
+
+  it('hides confirmed EVM rows when their chain is not in the enabled filter', () => {
+    mockUseTransactionsQuery(queryDataMainnetConfirmed);
+
+    const { getByText } = renderWithProvider(<UnifiedTransactionsView />, {
+      state: stateOnlyOptimism,
+    });
+
+    expect(getByText('You have no transactions')).toBeOnTheScreen();
+  });
+
+  it('shows confirmed EVM rows when their chain matches the enabled filter', () => {
+    mockUseTransactionsQuery(queryDataMainnetConfirmed);
+
+    const { UNSAFE_queryAllByType } = renderWithProvider(
+      <UnifiedTransactionsView />,
+      { state: stateOnlyMainnet },
+    );
+
+    expect(
+      UNSAFE_queryAllByType(asComponentType('TransactionElement')).length,
+    ).toBeGreaterThanOrEqual(1);
+  });
+
+  it('hides pending EVM transactions when their chain is not in the enabled filter', () => {
+    mockUseTransactionsQuery(emptyTransactionsQueryData);
+
+    const stateWithPendingMainnet = {
+      engine: {
+        backgroundState: {
+          ...backgroundState,
+          AccountsController: accountsControllerForWallet,
+          NetworkEnablementController:
+            stateOnlyOptimism.engine.backgroundState
+              .NetworkEnablementController,
+          TransactionController: {
+            ...backgroundState.TransactionController,
+            transactions: [
+              {
+                id: 'pending-mainnet',
+                chainId: '0x1' as const,
+                status: TransactionStatus.submitted,
+                time: Date.now(),
+                txParams: {
+                  from: WALLET,
+                  to: '0x1111111111111111111111111111111111111111',
+                  value: '0x0',
+                  nonce: '0x1',
+                },
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const { getByText } = renderWithProvider(<UnifiedTransactionsView />, {
+      state: stateWithPendingMainnet,
+    });
+
+    expect(getByText('You have no transactions')).toBeOnTheScreen();
+  });
+
+  it('hides pending EVM transactions when no EVM chains are enabled', () => {
+    mockUseTransactionsQuery(emptyTransactionsQueryData);
+
+    const stateWithPendingButNoEvmNetworks = {
+      engine: {
+        backgroundState: {
+          ...backgroundState,
+          AccountsController: accountsControllerForWallet,
+          NetworkEnablementController:
+            emptyEvmChainsState.engine.backgroundState
+              .NetworkEnablementController,
+          TransactionController: {
+            ...backgroundState.TransactionController,
+            transactions: [
+              {
+                id: 'pending-no-enabled-evm',
+                chainId: '0x1' as const,
+                status: TransactionStatus.submitted,
+                time: Date.now(),
+                txParams: {
+                  from: WALLET,
+                  to: '0x1111111111111111111111111111111111111111',
+                  value: '0x0',
+                  nonce: '0x1',
+                },
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const { getByText } = renderWithProvider(<UnifiedTransactionsView />, {
+      state: stateWithPendingButNoEvmNetworks,
+    });
+
+    expect(getByText('You have no transactions')).toBeOnTheScreen();
+  });
+
+  it('hides pending EVM transactions when chainId is missing', () => {
+    mockUseTransactionsQuery(emptyTransactionsQueryData);
+
+    const pendingWithoutChainId = {
+      id: 'pending-missing-chain',
+      status: TransactionStatus.submitted,
+      time: Date.now(),
+      txParams: {
+        from: WALLET,
+        to: '0x1111111111111111111111111111111111111111',
+        value: '0x0',
+        nonce: '0x1',
+      },
+    } as unknown as TransactionMeta;
+
+    const stateWithPendingMissingChainId = {
+      engine: {
+        backgroundState: {
+          ...backgroundState,
+          AccountsController: accountsControllerForWallet,
+          NetworkEnablementController:
+            stateOnlyMainnet.engine.backgroundState.NetworkEnablementController,
+          TransactionController: {
+            ...backgroundState.TransactionController,
+            transactions: [pendingWithoutChainId],
+          },
+        },
+      },
+    };
+
+    const { getByText } = renderWithProvider(<UnifiedTransactionsView />, {
+      state: stateWithPendingMissingChainId,
+    });
+
+    expect(getByText('You have no transactions')).toBeOnTheScreen();
+  });
+});
+
 describe('UnifiedTransactionsView - Speed up / Cancel modal', () => {
   const initialState = {
     engine: {
 
@@ -167,6 +167,20 @@ const UnifiedTransactionsView = ({
     [enabledNonEVMNetworks],
   );
 
+  /** Drop confirmed rows not on currently enabled EVM chains (guards stale query pages). */
+  const allConfirmedForEnabledChains = useMemo<TransactionViewModel[]>(() => {
+    const chains = enabledEVMChainIds ?? [];
+    if (chains.length === 0) {
+      return [];
+    }
+    const allowed = new Set(chains.map((c) => c.toLowerCase()));
+    return allConfirmedFiltered.filter(
+      (tx) =>
+        typeof tx.hexChainId === 'string' &&
+        allowed.has(tx.hexChainId.toLowerCase()),
+    );
+  }, [allConfirmedFiltered, enabledEVMChainIds]);
+
   const { maliciousTokenKeys } =
     useMultichainActivityMaliciousTokenKeys(nonEvmTransactions);
 
@@ -183,13 +197,22 @@ const UnifiedTransactionsView = ({
     chainFilteredNonEvmTransactionsForSelectedChain: NonEvmTransaction[];
   }>(() => {
     const bridgeHistoryValues = Object.values(bridgeHistory ?? {});
+    const enabledEvmSet = new Set(
+      (enabledEVMChainIds ?? []).map((id) => id.toLowerCase()),
+    );
     const submittedTxsFiltered = submittedTxs.filter(
       (tx): tx is EvmTransaction => {
         if (!isTransactionMetaLike(tx)) {
           return false;
         }
 
         const { chainId: _chainId, txParams } = tx;
+        if (!enabledEvmSet.size) {
+          return false;
+        }
+        if (!_chainId || !enabledEvmSet.has(String(_chainId).toLowerCase())) {
+          return false;
+        }
         const isBridgeTransaction = isBridgeHistoryForEvmTransaction(
           tx,
           bridgeHistoryValues,
@@ -198,17 +221,17 @@ const UnifiedTransactionsView = ({
         const { from, nonce } = txParams || {};
         const hasNonce = nonce !== undefined && nonce !== null;
 
-        const matchingConfirmedByHash = allConfirmedFiltered.some(
+        const matchingConfirmedByHash = allConfirmedForEnabledChains.some(
           (confirmedTx) =>
             typeof hash === 'string' &&
             confirmedTx.hash.toLowerCase() === hash.toLowerCase() &&
-            confirmedTx.hexChainId === _chainId,
+            confirmedTx.hexChainId?.toLowerCase() === _chainId?.toLowerCase(),
         );
-        const matchingConfirmedByNonce = allConfirmedFiltered.some(
+        const matchingConfirmedByNonce = allConfirmedForEnabledChains.some(
           (confirmedTx) =>
             hasNonce &&
             confirmedTx.nonce === nonce &&
-            confirmedTx.hexChainId === _chainId &&
+            confirmedTx.hexChainId?.toLowerCase() === _chainId?.toLowerCase() &&
             Boolean(from) &&
             areAddressesEqual(confirmedTx.from, from),
         );
@@ -250,11 +273,11 @@ const UnifiedTransactionsView = ({
 
     return {
       evmPendingTxs: evmPendingFirst,
-      evmConfirmedTxs: allConfirmedFiltered,
+      evmConfirmedTxs: allConfirmedForEnabledChains,
       chainFilteredNonEvmTransactionsForSelectedChain,
     };
   }, [
-    allConfirmedFiltered,
+    allConfirmedForEnabledChains,
     submittedTxs,
     nonEvmTransactions,
     enabledEVMChainIds,
@@ -609,7 +632,9 @@ const UnifiedTransactionsView = ({
           i={index}
           navigation={navigation}
           txChainId={item.tx.hexChainId}
-          selectedAddress={selectedInternalAccount?.address}
+          selectedAddress={
+            selectedAccountGroupEvmAddress || selectedInternalAccount?.address
+          }
           currentCurrency={currentCurrency}
           showBottomBorder
           location={location}