cleanup

Author: n3ps

ui/selectors/activity.test.ts

@@ -1,6 +1,7 @@
 import { AccountGroupId } from '@metamask/account-api';
 import type { Transaction } from '@metamask/keyring-api';
 import type { MultichainTransactionsControllerState } from '@metamask/multichain-transactions-controller';
+import { MultichainNetworks } from '../../shared/constants/multichain/networks';
 import type { MetaMaskReduxState as _MetaMaskReduxState } from '../store/store';
 import { generateTokenCacheKey } from '../helpers/utils/token-scan';
 import type { AccountTreeState } from './multichain-accounts/account-tree.types';
@@ -18,8 +19,6 @@ jest.mock('./multichain-accounts/account-tree', () => {
   };
 });
 
-const SOLANA_MAINNET = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp';
-
 type NonEvmTransactionsMap =
   MultichainTransactionsControllerState['nonEvmTransactions'];
 
@@ -46,7 +45,7 @@ function buildState(
     metamask: {
       nonEvmTransactions: nonEvmTransactions as NonEvmTransactionsMap,
       enabledNetworkMap: {
-        solana: { [SOLANA_MAINNET]: true },
+        solana: { [MultichainNetworks.SOLANA]: true },
       },
       tokenScanCache: tokenScanCache ?? {},
     },
@@ -57,25 +56,25 @@ describe('selectNonEvmTransactionsForActivity', () => {
   it('filters malicious non-EVM token transactions', () => {
     const maliciousTx = {
       id: 'bad-tx',
-      chain: SOLANA_MAINNET,
+      chain: MultichainNetworks.SOLANA,
       from: [
         {
           asset: {
             fungible: true,
-            type: `${SOLANA_MAINNET}/token:BadMint111`,
+            type: `${MultichainNetworks.SOLANA}/token:BadMint111`,
           },
         },
       ],
       to: [],
     } as unknown as Transaction;
     const benignTx = {
       id: 'good-tx',
-      chain: SOLANA_MAINNET,
+      chain: MultichainNetworks.SOLANA,
       from: [
         {
           asset: {
             fungible: true,
-            type: `${SOLANA_MAINNET}/token:GoodMint222`,
+            type: `${MultichainNetworks.SOLANA}/token:GoodMint222`,
           },
         },
       ],
@@ -85,15 +84,15 @@ describe('selectNonEvmTransactionsForActivity', () => {
     const state = buildState(
       {
         'acc-1': {
-          [SOLANA_MAINNET]: {
+          [MultichainNetworks.SOLANA]: {
             transactions: [maliciousTx, benignTx],
             next: null,
             lastUpdated: 0,
           },
         },
       },
       {
-        [generateTokenCacheKey(SOLANA_MAINNET, 'BadMint111')]: {
+        [generateTokenCacheKey(MultichainNetworks.SOLANA, 'BadMint111')]: {
           data: {
             // eslint-disable-next-line @typescript-eslint/naming-convention
             result_type: 'Malicious',
@@ -104,48 +103,4 @@ describe('selectNonEvmTransactionsForActivity', () => {
 
     expect(selectNonEvmTransactionsForActivity(state)).toEqual([benignTx]);
   });
-
-  it('keeps native-only and uncached token transactions visible', () => {
-    const nativeOnlyTx = {
-      id: 'native-tx',
-      chain: SOLANA_MAINNET,
-      from: [
-        {
-          asset: {
-            fungible: true,
-            type: `${SOLANA_MAINNET}/slip44:501`,
-          },
-        },
-      ],
-      to: [],
-    } as unknown as Transaction;
-    const uncachedTokenTx = {
-      id: 'uncached-token-tx',
-      chain: SOLANA_MAINNET,
-      from: [
-        {
-          asset: {
-            fungible: true,
-            type: `${SOLANA_MAINNET}/token:UnknownMint333`,
-          },
-        },
-      ],
-      to: [],
-    } as unknown as Transaction;
-
-    const state = buildState({
-      'acc-1': {
-        [SOLANA_MAINNET]: {
-          transactions: [nativeOnlyTx, uncachedTokenTx],
-          next: null,
-          lastUpdated: 0,
-        },
-      },
-    });
-
-    expect(selectNonEvmTransactionsForActivity(state)).toEqual([
-      nativeOnlyTx,
-      uncachedTokenTx,
-    ]);
-  });
 });

ui/selectors/activity.ts

@@ -10,6 +10,7 @@ import {
 import type { TransactionGroup } from '../../shared/lib/multichain/types';
 import { CHAIN_ID_TO_CURRENCY_SYMBOL_MAP } from '../../shared/constants/network';
 import { NATIVE_TOKEN_ADDRESS } from '../../shared/constants/transaction';
+import type { MetaMaskReduxState } from '../store/store';
 import {
   groupAndSortTransactionsByNonce,
   smartTransactionsListSelector,
@@ -19,10 +20,14 @@ import {
   selectOrderedTransactions,
   selectRequiredTransactionHashes,
 } from './transactionController';
-import { getTokenScanResultsForCacheKeys } from './token-trust-signals';
-import { getMarketData, getCurrencyRates } from './selectors';
+import type { TokenScanCacheResults } from './token-scan';
+import {
+  getMarketData,
+  getCurrencyRates,
+  getTokenScanCache,
+} from './selectors';
 import { getSelectedInternalAccount } from './accounts';
-import { EMPTY_ARRAY } from './shared';
+import { EMPTY_ARRAY, EMPTY_OBJECT } from './shared';
 
 function isFromSelectedAccount(tx: TransactionMeta, selectedAddress: string) {
   // Ported from selectedAddressTxListSelector
@@ -75,32 +80,32 @@ export const selectLocalTransactions = createSelector(
 );
 
 export const selectNonEvmTransactionsForActivity = createSelector(
-  [selectCurrentAccountNonEvmTransactions, (state) => state],
-  (nonEvmTransactions, state) => {
-    const tokenScanCacheKeys: MultichainTokenScanKey[] = [
+  [
+    selectCurrentAccountNonEvmTransactions,
+    (state: MetaMaskReduxState) =>
+      (getTokenScanCache(state) as TokenScanCacheResults | undefined) ??
+      (EMPTY_OBJECT as TokenScanCacheResults),
+  ],
+  (nonEvmTransactions, tokenScanCache) => {
+    const tokenScanKeys: MultichainTokenScanKey[] = [
       ...new Set(
         nonEvmTransactions.flatMap((transaction) =>
           collectTransactionTokenScanKeys(transaction),
         ),
       ),
     ];
 
-    const tokenScanResults = getTokenScanResultsForCacheKeys(
-      state,
-      tokenScanCacheKeys,
-    );
-
     const maliciousTokenKeys = new Set<MultichainTokenScanKey>(
-      Object.entries(tokenScanResults)
-        .filter(
-          ([, tokenScanResult]) =>
-            tokenScanResult.data?.result_type === ResultType.Malicious,
-        )
-        .map(
-          ([tokenScanCacheKey]) => tokenScanCacheKey as MultichainTokenScanKey,
-        ),
+      tokenScanKeys.filter(
+        (key) =>
+          tokenScanCache[key]?.data?.result_type === ResultType.Malicious,
+      ),
     );
 
+    if (maliciousTokenKeys.size === 0) {
+      return nonEvmTransactions;
+    }
+
     return filterMaliciousTransactions(nonEvmTransactions, maliciousTokenKeys);
   },
 );

ui/selectors/selectors.js

@@ -2960,7 +2960,7 @@ export function getUrlScanCacheResult(state, hostname) {
  * @param {*} state
  * @returns The token scan cache object
  */
-function getTokenScanCache(state) {
+export function getTokenScanCache(state) {
   return state.metamask.tokenScanCache;
 }
 

ui/selectors/token-trust-signals.test.ts ui/selectors/token-scan.test.tsui/selectors/token-trust-signals.test.ts renamed to ui/selectors/token-scan.test.ts

@@ -1,4 +1,4 @@
-import { getTokenScanResultsForCacheKeys } from './token-trust-signals';
+import { selectTokenScanResults } from './token-scan';
 
 describe('token trust signal selectors', () => {
   it('returns only entries matching the requested cache keys', () => {
@@ -22,7 +22,7 @@ describe('token trust signal selectors', () => {
     } as never;
 
     expect(
-      getTokenScanResultsForCacheKeys(state, [
+      selectTokenScanResults(state, [
         'solana:mainnet:badmint111',
         'solana:mainnet:missing333',
       ]),
@@ -50,7 +50,7 @@ describe('token trust signal selectors', () => {
       },
     } as never;
 
-    expect(getTokenScanResultsForCacheKeys(state, [])).toEqual({});
-    expect(getTokenScanResultsForCacheKeys(state, undefined)).toEqual({});
+    expect(selectTokenScanResults(state, [])).toEqual({});
+    expect(selectTokenScanResults(state, undefined)).toEqual({});
   });
 });

ui/selectors/token-trust-signals.ts ui/selectors/token-scan.tsui/selectors/token-trust-signals.ts renamed to ui/selectors/token-scan.ts

@@ -1,6 +1,7 @@
 import { createDeepEqualSelector } from '../../shared/lib/selectors/selector-creators';
 import type { MultichainTokenScanKey } from '../helpers/utils/token-scan';
 import type { MetaMaskReduxState } from '../store/store';
+import { getTokenScanCache } from './selectors';
 import { EMPTY_OBJECT } from './shared';
 
 type TokenScanCacheResult = {
@@ -16,43 +17,27 @@ export type TokenScanCacheResults = Record<
   TokenScanCacheResult
 >;
 
-type MetaMaskWithTokenScanCache = {
-  tokenScanCache?: TokenScanCacheResults;
-};
-
-const getTokenScanCache = (
-  state: MetaMaskReduxState,
-): TokenScanCacheResults => {
-  const metamaskState = state.metamask as unknown as
-    | MetaMaskWithTokenScanCache
-    | undefined;
-
-  return (
-    metamaskState?.tokenScanCache ?? (EMPTY_OBJECT as TokenScanCacheResults)
-  );
-};
-
-export const getTokenScanResultsForCacheKeys = createDeepEqualSelector(
-  getTokenScanCache,
+export const selectTokenScanResults = createDeepEqualSelector(
+  (state: MetaMaskReduxState) =>
+    (getTokenScanCache(state) as TokenScanCacheResults | undefined) ??
+    (EMPTY_OBJECT as TokenScanCacheResults),
   (_state: MetaMaskReduxState, tokenScanCacheKeys?: MultichainTokenScanKey[]) =>
     tokenScanCacheKeys,
   (tokenScanCache, tokenScanCacheKeys): TokenScanCacheResults => {
     if (!tokenScanCacheKeys?.length) {
       return EMPTY_OBJECT as TokenScanCacheResults;
     }
 
-    const tokenScanResults: TokenScanCacheResults = {};
+    const results: TokenScanCacheResults = {};
 
-    for (const tokenScanCacheKey of tokenScanCacheKeys) {
-      const tokenScanResult = tokenScanCacheKey
-        ? tokenScanCache[tokenScanCacheKey]
-        : undefined;
+    for (const key of tokenScanCacheKeys) {
+      const tokenScanResult = key ? tokenScanCache[key] : undefined;
 
       if (tokenScanResult) {
-        tokenScanResults[tokenScanCacheKey] = tokenScanResult;
+        results[key] = tokenScanResult;
       }
     }
 
-    return tokenScanResults;
+    return results;
   },
 );