refactor

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

Author: n3ps

app/components/Views/UnifiedTransactionsView/UnifiedTransactionsView.tsx

@@ -57,8 +57,16 @@ import { UnifiedTransactionsViewSelectorsIDs } from './UnifiedTransactionsView.t
 import { useMultichainActivityMaliciousTokenKeys } from '../../hooks/useMultichainActivityMaliciousTokenKeys/useMultichainActivityMaliciousTokenKeys';
 import { filterMultichainTransactionsExcludingMaliciousTokenActivity } from '../../../util/multichain/multichainTransactionTokenScan';
 import { useTransactionsQuery } from './useTransactionsQuery';
-import type { EvmTransaction, TransactionViewModel } from './types';
-import { isBridgeHistoryForEvmTransaction } from './helpers/transformations';
+import {
+  type EvmTransaction,
+  TransactionKind,
+  type TransactionViewModel,
+  type UnifiedItem,
+} from './types';
+import {
+  isBridgeHistoryForEvmTransaction,
+  mergeTransactionsByTime,
+} from './helpers/transformations';
 
 const confirmedEvmOverscan = 5;
 const visibilityConfig = { itemVisiblePercentThreshold: 1 };
@@ -72,28 +80,6 @@ const getEvmTransactionTime = (tx: EvmTransaction) => tx.time ?? 0;
 
 const getEvmChainId = (tx: EvmTransaction) => tx.chainId;
 
-enum TransactionKind {
-  Evm = 'evm',
-  ConfirmedEvm = 'confirmed',
-  NonEvm = 'nonEvm',
-}
-
-type UnifiedItem =
-  | { kind: TransactionKind.Evm; tx: EvmTransaction }
-  | { kind: TransactionKind.ConfirmedEvm; tx: TransactionViewModel }
-  | { kind: TransactionKind.NonEvm; tx: NonEvmTransaction };
-
-const normalizeTimestamp = (item: UnifiedItem) => {
-  switch (item.kind) {
-    case TransactionKind.Evm:
-      return item.tx.time ?? 0;
-    case TransactionKind.ConfirmedEvm:
-      return item.tx.time;
-    case TransactionKind.NonEvm:
-      return (item.tx.timestamp ?? 0) * 1000;
-  }
-};
-
 const generateKey = (item: UnifiedItem) => {
   if (item.kind === TransactionKind.Evm) {
     return getTransactionId(item.tx);
@@ -192,8 +178,8 @@ const UnifiedTransactionsView = ({
   const bridgeHistory = useSelector(selectBridgeHistoryForAccount);
 
   const unifiedTransactionSource = useMemo<{
-    evmPendingItems: UnifiedItem[];
-    evmConfirmedItems: UnifiedItem[];
+    evmPendingTxs: EvmTransaction[];
+    evmConfirmedTxs: TransactionViewModel[];
     chainFilteredNonEvmTransactionsForSelectedChain: NonEvmTransaction[];
   }>(() => {
     const bridgeHistoryValues = Object.values(bridgeHistory ?? {});
@@ -262,18 +248,9 @@ const UnifiedTransactionsView = ({
         (tx, index, self) => index === self.findIndex((t) => t.id === tx.id),
       );
 
-    const evmPendingItems: UnifiedItem[] = evmPendingFirst.map((tx) => ({
-      kind: TransactionKind.Evm,
-      tx,
-    }));
-    const evmConfirmedItems: UnifiedItem[] = allConfirmedFiltered.map((tx) => ({
-      kind: TransactionKind.ConfirmedEvm,
-      tx,
-    }));
-
     return {
-      evmPendingItems,
-      evmConfirmedItems,
+      evmPendingTxs: evmPendingFirst,
+      evmConfirmedTxs: allConfirmedFiltered,
       chainFilteredNonEvmTransactionsForSelectedChain,
     };
   }, [
@@ -290,8 +267,8 @@ const UnifiedTransactionsView = ({
     nonEvmTransactionsForSelectedChain: NonEvmTransaction[];
   }>(() => {
     const {
-      evmPendingItems,
-      evmConfirmedItems,
+      evmPendingTxs,
+      evmConfirmedTxs,
       chainFilteredNonEvmTransactionsForSelectedChain,
     } = unifiedTransactionSource;
 
@@ -301,18 +278,14 @@ const UnifiedTransactionsView = ({
         maliciousTokenKeys,
       );
 
-    const nonEvmItems: UnifiedItem[] =
-      filteredNonEvmTransactionsForSelectedChain.map((tx) => ({
-        kind: TransactionKind.NonEvm,
-        tx,
-      }));
-
-    const confirmedUnified = [...evmConfirmedItems, ...nonEvmItems].sort(
-      (a, b) => normalizeTimestamp(b) - normalizeTimestamp(a),
+    const data = mergeTransactionsByTime(
+      evmPendingTxs,
+      evmConfirmedTxs,
+      filteredNonEvmTransactionsForSelectedChain,
     );
 
     return {
-      data: [...evmPendingItems, ...confirmedUnified],
+      data,
       nonEvmTransactionsForSelectedChain:
         filteredNonEvmTransactionsForSelectedChain,
     };

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

@@ -3,9 +3,15 @@ import {
   type V4MultiAccountTransactionsResponse,
 } from '@metamask/core-backend';
 import type { BridgeHistoryItem } from '@metamask/bridge-status-controller';
+import type { Transaction as NonEvmTransaction } from '@metamask/keyring-api';
 import type { InfiniteData } from '@tanstack/react-query';
 import { normalizeTransaction } from './adapters';
-import { EvmTransaction, TransactionViewModel } from '../types';
+import {
+  EvmTransaction,
+  TransactionKind,
+  TransactionViewModel,
+  UnifiedItem,
+} from '../types';
 import { equalsIgnoreCase } from '../../../../util/string';
 
 const excludedTransactionTypes = ['SPAM_TOKEN_TRANSFER'];
@@ -149,3 +155,60 @@ export function selectTransactions({ address }: { address: string }) {
     })),
   });
 }
+
+const getEvmTime = (tx: EvmTransaction) => tx.time ?? 0;
+const getNonEvmTime = (tx: NonEvmTransaction) => (tx.timestamp ?? 0) * 1000;
+const getEvmHash = (tx: EvmTransaction) =>
+  'hash' in tx && typeof tx.hash === 'string' ? tx.hash.toLowerCase() : '';
+
+// Merges local EVM, API-confirmed EVM and non-EVM transactions into one list
+// sorted by time (newest first), deduplicated by hash (API-confirmed wins).
+export function mergeTransactionsByTime(
+  evmLocalTransactions: EvmTransaction[],
+  evmConfirmedTransactions: TransactionViewModel[],
+  nonEvmTransactions: NonEvmTransaction[],
+) {
+  const seenHashes = new Set<string>();
+
+  const confirmedItems: UnifiedItem[] = [];
+  for (const tx of evmConfirmedTransactions) {
+    const hash = tx.hash?.toLowerCase();
+    if (hash) {
+      if (seenHashes.has(hash)) {
+        continue;
+      }
+      seenHashes.add(hash);
+    }
+    confirmedItems.push({
+      kind: TransactionKind.ConfirmedEvm,
+      tx,
+      time: tx.time ?? 0,
+    });
+  }
+
+  const localItems: UnifiedItem[] = [];
+  for (const tx of evmLocalTransactions) {
+    const hash = getEvmHash(tx);
+    if (hash) {
+      if (seenHashes.has(hash)) {
+        continue;
+      }
+      seenHashes.add(hash);
+    }
+    localItems.push({
+      kind: TransactionKind.Evm,
+      tx,
+      time: getEvmTime(tx),
+    });
+  }
+
+  const nonEvmItems: UnifiedItem[] = nonEvmTransactions.map((tx) => ({
+    kind: TransactionKind.NonEvm,
+    tx,
+    time: getNonEvmTime(tx),
+  }));
+
+  return [...localItems, ...confirmedItems, ...nonEvmItems].sort(
+    (a, b) => b.time - a.time,
+  );
+}

app/components/Views/UnifiedTransactionsView/types.ts

@@ -1,6 +1,7 @@
 import type { V1TransactionByHashResponse } from '@metamask/core-backend';
 import { SmartTransaction } from '@metamask/smart-transactions-controller';
 import type { TransactionMeta } from '@metamask/transaction-controller';
+import type { Transaction as NonEvmTransaction } from '@metamask/keyring-api';
 
 export type SmartTransactionWithId = SmartTransaction & { id: string };
 
@@ -14,3 +15,18 @@ export type TransactionViewModel = V1TransactionByHashResponse & {
   // But for now, we keep this until we can refactor the UI components
   transactionMeta: TransactionMeta;
 };
+
+export enum TransactionKind {
+  Evm = 'evm',
+  ConfirmedEvm = 'confirmed',
+  NonEvm = 'nonEvm',
+}
+
+export type UnifiedItem =
+  | { kind: TransactionKind.Evm; tx: EvmTransaction; time: number }
+  | {
+      kind: TransactionKind.ConfirmedEvm;
+      tx: TransactionViewModel;
+      time: number;
+    }
+  | { kind: TransactionKind.NonEvm; tx: NonEvmTransaction; time: number };

app/core/apiClient.test.ts

@@ -0,0 +1,58 @@
+import { createApiPlatformClient } from '@metamask/core-backend';
+import Engine from './Engine';
+
+jest.mock('@metamask/core-backend', () => ({
+  createApiPlatformClient: jest.fn(() => ({ accounts: {} })),
+}));
+
+jest.mock('./Engine', () => ({
+  __esModule: true,
+  default: {
+    context: {
+      AuthenticationController: {
+        getBearerToken: jest.fn(),
+      },
+    },
+  },
+}));
+
+const createApiPlatformClientMock = jest.mocked(createApiPlatformClient);
+const getBearerTokenMock = jest.mocked(
+  Engine.context.AuthenticationController.getBearerToken,
+);
+
+// Import once so the module-level createApiPlatformClient call is captured.
+require('./apiClient');
+
+const [firstCallArgs] = createApiPlatformClientMock.mock.calls;
+const getBearerToken = firstCallArgs[0].getBearerToken as () => Promise<
+  string | undefined
+>;
+
+describe('apiClient', () => {
+  beforeEach(() => {
+    getBearerTokenMock.mockReset();
+  });
+
+  it('creates the API platform client with the mobile product identifier', () => {
+    expect(createApiPlatformClientMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        clientProduct: 'metamask-mobile',
+        getBearerToken: expect.any(Function),
+      }),
+    );
+  });
+
+  it('returns the bearer token from AuthenticationController', async () => {
+    getBearerTokenMock.mockResolvedValueOnce('bearer-token-mock');
+
+    await expect(getBearerToken()).resolves.toBe('bearer-token-mock');
+    expect(getBearerTokenMock).toHaveBeenCalled();
+  });
+
+  it('returns undefined when AuthenticationController throws', async () => {
+    getBearerTokenMock.mockRejectedValueOnce(new Error('boom'));
+
+    await expect(getBearerToken()).resolves.toBeUndefined();
+  });
+});