fix: hide tempo native tokens [WIP]

packages/assets-controller/CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - **BREAKING:** Rename state and `DataResponse` property from `assetsMetadata` to `assetsInfo`. Update consumers that read `state.assetsMetadata` or set `response.assetsMetadata` to use `assetsInfo` instead ([#7902](https://github.com/MetaMask/core/pull/7902))
+- Hide native tokens on Tempo networks (testnet and mainnet) in `getAssets` method ([#7882](https://github.com/MetaMask/core/pull/7882))
 - Bump `@metamask/keyring-api` from `^21.0.0` to `^21.5.0` ([#7857](https://github.com/MetaMask/core/pull/7857))
 - Bump `@metamask/keyring-internal-api` from `^9.0.0` to `^10.0.0` ([#7857](https://github.com/MetaMask/core/pull/7857))
 - Bump `@metamask/keyring-snap-client` from `^8.0.0` to `^8.2.0` ([#7857](https://github.com/MetaMask/core/pull/7857))

packages/assets-controller/src/AssetsController.test.ts

@@ -488,6 +488,180 @@
         expect(assets).toBeDefined();
       });
     });
+
+    it('hides native tokens on Tempo testnet (eip155:42431)', async () => {
+      await withController(
+        {
+          state: {
+            assetsMetadata: {
+              'eip155:42431/slip44:60': {
+                type: 'native',
+                symbol: 'ETH',
+                name: 'Ethereum',
+                decimals: 18,
+              },
+              'eip155:42431/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': {
+                type: 'erc20',
+                symbol: 'USDC',
+                name: 'USD Coin',
+                decimals: 6,
+              },
+            },
+            assetsBalance: {
+              [MOCK_ACCOUNT_ID]: {
+                'eip155:42431/slip44:60': {
+                  amount: '1',
+                  unit: 'ETH',
+                },
+                'eip155:42431/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': {
+                  amount: '100',
+                  unit: 'USDC',
+                },
+              },
+            },
+            assetsPrice: {},
+            customAssets: {},
+            assetPreferences: {},
+          },
+        },
+        async ({ controller }) => {
+          const accounts = [createMockInternalAccount()];
+          const assets = await controller.getAssets(accounts, {
+            chainIds: ['eip155:42431'],
+          });
+
+          // Native token should be hidden
+          expect(
+            assets[MOCK_ACCOUNT_ID]['eip155:42431/slip44:60'],
+          ).toBeUndefined();
+
+          // ERC20 token should still be visible
+          expect(
+            assets[MOCK_ACCOUNT_ID][
+              'eip155:42431/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
+            ],
+          ).toBeDefined();
+        },
+      );
+    });
+
+    it('hides native tokens on Tempo mainnet (eip155:4217)', async () => {
+      await withController(
+        {
+          state: {
+            assetsMetadata: {
+              'eip155:4217/slip44:60': {
+                type: 'native',
+                symbol: 'ETH',
+                name: 'Ethereum',
+                decimals: 18,
+              },
+            },
+            assetsBalance: {
+              [MOCK_ACCOUNT_ID]: {
+                'eip155:4217/slip44:60': {
+                  amount: '1',
+                  unit: 'ETH',
+                },
+              },
+            },
+            assetsPrice: {},
+            customAssets: {},
+            assetPreferences: {},
+          },
+        },
+        async ({ controller }) => {
+          const accounts = [createMockInternalAccount()];
+          const assets = await controller.getAssets(accounts, {
+            chainIds: ['eip155:4217'],
+          });
+
+          // Native token should be hidden
+          expect(
+            assets[MOCK_ACCOUNT_ID]['eip155:4217/slip44:60'],
+          ).toBeUndefined();
+        },
+      );
+    });
+
+    it('does not hide native tokens on non-Tempo networks', async () => {
+      await withController(
+        {
+          state: {
+            assetsMetadata: {
+              'eip155:1/slip44:60': {
+                type: 'native',
+                symbol: 'ETH',
+                name: 'Ethereum',
+                decimals: 18,
+              },
+            },
+            assetsBalance: {
+              [MOCK_ACCOUNT_ID]: {
+                'eip155:1/slip44:60': {
+                  amount: '1',
+                  unit: 'ETH',
+                },
+              },
+            },
+            assetsPrice: {},
+            customAssets: {},
+            assetPreferences: {},
+          },
+        },
+        async ({ controller }) => {
+          const accounts = [createMockInternalAccount()];
+          const assets = await controller.getAssets(accounts, {
+            chainIds: ['eip155:1'],
+          });
+
+          // Native token should still be visible on Ethereum
+          expect(assets[MOCK_ACCOUNT_ID]['eip155:1/slip44:60']).toBeDefined();
+          expect(
+            assets[MOCK_ACCOUNT_ID]['eip155:1/slip44:60'].metadata.symbol,
+          ).toBe('ETH');
+        },
+      );
+    });
+
+    it('hides native tokens identified by metadata type', async () => {
+      await withController(
+        {
+          state: {
+            assetsMetadata: {
+              'eip155:42431/some:other': {
+                type: 'native',
+                symbol: 'ETH',
+                name: 'Ethereum',
+                decimals: 18,
+              },
+            },
+            assetsBalance: {
+              [MOCK_ACCOUNT_ID]: {
+                'eip155:42431/some:other': {
+                  amount: '1',
+                  unit: 'ETH',
+                },
+              },
+            },
+            assetsPrice: {},
+            customAssets: {},
+            assetPreferences: {},
+          },
+        },
+        async ({ controller }) => {
+          const accounts = [createMockInternalAccount()];
+          const assets = await controller.getAssets(accounts, {
+            chainIds: ['eip155:42431'],
+          });
+
+          // Native token should be hidden even if assetId doesn't have slip44
+          expect(
+            assets[MOCK_ACCOUNT_ID]['eip155:42431/some:other'],
+          ).toBeUndefined();
+        },
+      );
+    });
   });
 
   describe('getAssetsBalance', () => {

packages/assets-controller/src/AssetsController.ts

@@ -1246,6 +1246,11 @@
 
         const assetChainId = extractChainId(typedAssetId);
 
+        // Skip native tokens on Tempo networks
+        if (this.#shouldHideNativeToken(assetChainId, typedAssetId, metadata)) {
+          continue;
+        }
+
         if (!chainIdSet.has(assetChainId)) {
           continue;
         }
@@ -1287,6 +1292,38 @@
     return result;
   }
 
+  /**
+   * Determines if a native token should be hidden on specific networks.
+   *
+   * @param chainId - The CAIP-2 chain ID (e.g., "eip155:42431").
+   * @param assetId - The CAIP-19 asset ID (e.g., "eip155:42431/slip44:60").
+   * @param metadata - The asset metadata.
+   * @returns True if the token should be hidden, false otherwise.
+   */
+  #shouldHideNativeToken(
+    chainId: ChainId,
+    assetId: Caip19AssetId,
+    metadata: AssetMetadata,
+  ): boolean {
+    const TEMPO_CHAIN_IDS = ['eip155:42431', 'eip155:4217']; // Tempo Testnet (42431) and Mainnet (4217)
+
+    // Check if it's a Tempo network
+    if (!TEMPO_CHAIN_IDS.includes(chainId)) {
+      return false;
+    }
+
+    // Check if it's a native token (either by metadata type or assetId format)
+    const isNative =
+      metadata.type === 'native' || assetId.includes('/slip44:');
+
+    if (isNative) {
+      return true;
+    }
+
+
+    return false;
+  }
+
   /**
    * Maps a token standard to its corresponding asset type.
    *

packages/assets-controllers/CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `CodefiTokenPricesServiceV2` now supports fetching prices of ETH on Ink Mainnet (chain `0xdef1`) ([#7688](https://github.com/MetaMask/core/pull/7688))
 
+### Changed
+
+- Hide native tokens on Tempo networks (testnet and mainnet) in asset selectors ([#7882](https://github.com/MetaMask/core/pull/7882))
+
 ## [99.3.2]
 
 ### Changed

packages/assets-controllers/src/selectors/token-selectors.test.ts

@@ -11,7 +11,10 @@ import type { Hex } from '@metamask/utils';
 import { cloneDeep } from 'lodash';
 
 import { MOCK_TRON_TOKENS } from './__fixtures__/arrange-tron-state';
-import { selectAssetsBySelectedAccountGroup } from './token-selectors';
+import {
+  AssetListState,
+  selectAssetsBySelectedAccountGroup,
+} from './token-selectors';
 import type { AccountGroupMultichainAccountObject } from '../../../account-tree-controller/src/group';
 import type { CurrencyRateState } from '../CurrencyRateController';
 import type { MultichainAssetsControllerState } from '../MultichainAssetsController';
@@ -1111,5 +1114,131 @@ describe('token-selectors', () => {
       // Should have undefined fiat since there's no currency rate for 'INK'
       expect(inkNativeToken?.fiat).toBeUndefined();
     });
+
+    it('hides native tokens on Tempo testnet (0xa5bf)', () => {
+      const tempoTestnetChainId = '0xa5bf' as Hex; // 42431 in decimal
+      const stateWithTempoTestnet = {
+        ...mockedMergedState,
+        networkConfigurationsByChainId: {
+          ...mockNetworkControllerState.networkConfigurationsByChainId,
+          [tempoTestnetChainId]: {
+            nativeCurrency: 'ETH',
+          },
+        },
+        accountsByChainId: {
+          ...mockAccountsTrackerControllerState.accountsByChainId,
+          [tempoTestnetChainId]: {
+            '0x2bd63233fe369b0f13eaf25292af5a9b63d2b7ab': {
+              balance: '0xDE0B6B3A7640000', // 1 ETH
+            },
+          },
+        },
+      };
+
+      const result = selectAssetsBySelectedAccountGroup(stateWithTempoTestnet);
+
+      // Native token should be hidden on Tempo testnet
+      const nativeToken = result[tempoTestnetChainId]?.find(
+        (asset) => asset.isNative,
+      );
+      expect(nativeToken).toBeUndefined();
+    });
+
+    it('hides native tokens on Tempo mainnet (0x1079)', () => {
+      const tempoMainnetChainId = '0x1079' as Hex; // 4217 in decimal
+      const stateWithTempoMainnet = {
+        ...mockedMergedState,
+        networkConfigurationsByChainId: {
+          ...mockNetworkControllerState.networkConfigurationsByChainId,
+          [tempoMainnetChainId]: {
+            nativeCurrency: 'ETH',
+          },
+        },
+        accountsByChainId: {
+          ...mockAccountsTrackerControllerState.accountsByChainId,
+          [tempoMainnetChainId]: {
+            '0x2bd63233fe369b0f13eaf25292af5a9b63d2b7ab': {
+              balance: '0xDE0B6B3A7640000', // 1 ETH
+            },
+          },
+        },
+      };
+
+      const result = selectAssetsBySelectedAccountGroup(stateWithTempoMainnet);
+
+      // Native token should be hidden on Tempo mainnet
+      const nativeToken = result[tempoMainnetChainId]?.find(
+        (asset) => asset.isNative,
+      );
+      expect(nativeToken).toBeUndefined();
+    });
+
+    it('does not hide native tokens on non-Tempo networks', () => {
+      const ethereumChainId = '0x1' as Hex;
+      const result = selectAssetsBySelectedAccountGroup(mockedMergedState);
+
+      // Native token should still be visible on Ethereum
+      const nativeToken = result[ethereumChainId]?.find(
+        (asset) => asset.isNative,
+      );
+      expect(nativeToken).toBeDefined();
+      expect(nativeToken?.symbol).toBe('ETH');
+    });
+
+    it('hides native multichain tokens on Tempo networks', () => {
+      const tempoCaipChainId = 'eip155:42431';
+      const tempoNativeAssetId = `${tempoCaipChainId}/slip44:60` as const;
+
+      const stateWithTempoMultichain: AssetListState = {
+        ...mockedMergedState,
+        accountsAssets: {
+          ...mockMultichainAssetsControllerState.accountsAssets,
+          '2d89e6a0-b4e6-45a8-a707-f10cef143b42': [
+            ...mockMultichainAssetsControllerState.accountsAssets[
+              '2d89e6a0-b4e6-45a8-a707-f10cef143b42'
+            ],
+            tempoNativeAssetId,
+          ],
+        },
+        assetsMetadata: {
+          ...mockMultichainAssetsControllerState.assetsMetadata,
+          [tempoNativeAssetId]: {
+            fungible: true,
+            iconUrl: '',
+            name: 'Ethereum',
+            symbol: 'ETH',
+            units: [
+              {
+                decimals: 18,
+                name: 'Ethereum',
+                symbol: 'ETH',
+              },
+            ],
+          },
+        },
+        balances: {
+          ...mockMultichainBalancesControllerState.balances,
+          '2d89e6a0-b4e6-45a8-a707-f10cef143b42': {
+            ...mockMultichainBalancesControllerState.balances[
+              '2d89e6a0-b4e6-45a8-a707-f10cef143b42'
+            ],
+            [tempoNativeAssetId]: {
+              amount: '1',
+              unit: 'ETH',
+            },
+          },
+        },
+      };
+
+      const result = selectAssetsBySelectedAccountGroup(
+        stateWithTempoMultichain,
+      );
+
+      // Native token should be hidden on Tempo testnet
+      const nativeToken = result[tempoCaipChainId]?.find(
+        (asset) => asset.isNative,
+      );
+      expect(nativeToken).toBeUndefined();
+    });
   });
 });