fix: use currency rate fallback for native token fiat when market data missing (#7636)

## Explanation

The `selectAssetsBySelectedAccountGroup` selector was returning
`undefined` for the `fiat` field on native tokens for certain chains
(like Ink chain `0xdef1`) even though the currency conversion rate was
available.

**Problem:**
The `getFiatBalanceForEvmToken` function requires
`marketData[chainId][tokenAddress]` to exist in order to calculate fiat
values. For native tokens, this market data entry should contain `price:
1` (since 1 ETH = 1 ETH). However, some chains don't have this native
token entry in `marketData`, causing the function to return `undefined`
even when `currencyRates` has the conversion rate for the native
currency symbol (e.g., ETH).

**Solution:**
Added a fallback mechanism specifically for native tokens: when
`marketData` doesn't have an entry for the native token but
`currencyRates` has the conversion rate for the native currency symbol,
the function now uses `price = 1` and multiplies directly by the
currency rate. This ensures native token fiat values are calculated
correctly for chains like Ink (`0xdef1`) that use ETH as their native
currency but don't have explicit market data entries.

UI extension: MetaMask/metamask-extension#39269

## References

- Fixes native token fiat calculation for Ink chain and similar L2s that
share the same native currency as mainnet but lack market data entries

## Checklist

- [x] I've updated the test suite for new or updated code as appropriate
- [x] I've updated documentation (JSDoc, Markdown, etc.) for new or
updated code as appropriate
- [x] I've communicated my changes to consumers by [updating changelogs
for packages I've
changed](https://github.com/MetaMask/core/tree/main/docs/processes/updating-changelogs.md)
- [ ] I've introduced [breaking
changes](https://github.com/MetaMask/core/tree/main/docs/processes/breaking-changes.md)
in this PR and have prepared draft pull requests for clients and
consumer packages to resolve them


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Ensures native token fiat is calculated even when market data is
absent by leveraging the native currency conversion rate.
> 
> - Update `getFiatBalanceForEvmToken` to accept `nativeCurrencySymbol`
and, when no market data exists for a native token, compute fiat using
`currencyRates` (price=1 in native units); return `undefined` if rate
also missing
> - Pass native currency from `selectAssetsBySelectedAccountGroup` into
`getFiatBalanceForEvmToken`
> - Add unit tests covering fallback calculation and missing-rate
behavior
> - Update `CHANGELOG.md` under Unreleased -> Fixed
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
7f46dc3. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: salimtb

packages/assets-controllers/CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add BOB (0xed88) mapping to eip155:60808/erc20:0x0000000000000000000000000000000000000000 ([#7635](https://github.com/MetaMask/core/pull/7635))
 
+### Fixed
+
+- Fix native token fiat calculation for chains without market data by using currency rate fallback ([#7636](https://github.com/MetaMask/core/pull/7636))
+
 ## [95.2.0]
 
 ### Added

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

@@ -1024,5 +1024,92 @@ describe('token-selectors', () => {
       expect(result[TrxScope.Nile].length > 1).toBe(true);
       expect(result[TrxScope.Shasta].length > 1).toBe(true);
     });
+
+    it('calculates fiat for native token using currency rate fallback when market data is missing', () => {
+      // Setup: Add a new chain (Ink chain 0xdef1) with native balance but NO market data
+      const inkChainId = '0xdef1' as Hex;
+      const stateWithInkChain = {
+        ...mockedMergedState,
+        // Add Ink chain to network configuration
+        networkConfigurationsByChainId: {
+          ...mockNetworkControllerState.networkConfigurationsByChainId,
+          [inkChainId]: {
+            nativeCurrency: 'ETH', // Ink chain uses ETH as native currency
+          },
+        },
+        // Add native balance for the account on Ink chain
+        accountsByChainId: {
+          ...mockAccountsTrackerControllerState.accountsByChainId,
+          [inkChainId]: {
+            '0x2bd63233fe369b0f13eaf25292af5a9b63d2b7ab': {
+              balance: '0xDE0B6B3A7640000', // 1 ETH (1000000000000000000 wei)
+            },
+          },
+        },
+        // Market data does NOT include Ink chain native token
+        // (using existing mockTokenRatesControllerState which doesn't have 0xdef1)
+      };
+
+      const result = selectAssetsBySelectedAccountGroup(stateWithInkChain);
+
+      // Find the Ink chain native token
+      const inkNativeToken = result[inkChainId]?.find(
+        (asset) => asset.isNative,
+      );
+
+      // Should have fiat calculated using the ETH currency rate fallback
+      expect(inkNativeToken).toStrictEqual({
+        accountType: 'eip155:eoa',
+        accountId: 'd7f11451-9d79-4df4-a012-afd253443639',
+        chainId: inkChainId,
+        assetId: '0x0000000000000000000000000000000000000000',
+        address: '0x0000000000000000000000000000000000000000',
+        image: '',
+        name: 'Ethereum',
+        symbol: 'ETH',
+        isNative: true,
+        decimals: 18,
+        rawBalance: '0xDE0B6B3A7640000',
+        balance: '1',
+        fiat: {
+          balance: 2400, // 1 ETH * 2400 USD/ETH
+          conversionRate: 2400,
+          currency: 'USD',
+        },
+      });
+    });
+
+    it('returns undefined fiat for native token when both market data and currency rate are missing', () => {
+      const inkChainId = '0xdef1' as Hex;
+      const stateWithMissingCurrencyRate = {
+        ...mockedMergedState,
+        networkConfigurationsByChainId: {
+          ...mockNetworkControllerState.networkConfigurationsByChainId,
+          [inkChainId]: {
+            nativeCurrency: 'INK', // Custom native currency with no currency rate
+          },
+        },
+        accountsByChainId: {
+          ...mockAccountsTrackerControllerState.accountsByChainId,
+          [inkChainId]: {
+            '0x2bd63233fe369b0f13eaf25292af5a9b63d2b7ab': {
+              balance: '0xDE0B6B3A7640000',
+            },
+          },
+        },
+        // currencyRates doesn't have 'INK', only 'ETH'
+      };
+
+      const result = selectAssetsBySelectedAccountGroup(
+        stateWithMissingCurrencyRate,
+      );
+
+      const inkNativeToken = result[inkChainId]?.find(
+        (asset) => asset.isNative,
+      );
+
+      // Should have undefined fiat since there's no currency rate for 'INK'
+      expect(inkNativeToken?.fiat).toBeUndefined();
+    });
   });
 });

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

@@ -208,6 +208,7 @@ const selectAllEvmAccountNativeBalances = createAssetListSelector(
           currencyRates,
           chainId,
           nativeToken.address,
+          nativeCurrency, // Pass native currency symbol for fallback when market data is missing
         );
 
         groupChainAssets.push({
@@ -564,6 +565,7 @@ function mergeAssets(
  * @param currencyRates - The currency rates for the token
  * @param chainId - The chain id of the token
  * @param tokenAddress - The address of the token
+ * @param nativeCurrencySymbol - The native currency symbol (e.g., 'ETH', 'BNB') - used for fallback when market data is missing for native tokens
  * @returns The price and currency of the token in the current currency. Returns undefined if the asset is not found in the market data or currency rates.
  */
 function getFiatBalanceForEvmToken(
@@ -573,9 +575,29 @@ function getFiatBalanceForEvmToken(
   currencyRates: CurrencyRateState['currencyRates'],
   chainId: Hex,
   tokenAddress: Hex,
+  nativeCurrencySymbol?: string,
 ) {
   const tokenMarketData = marketData[chainId]?.[tokenAddress];
 
+  // For native tokens: if no market data exists, use price=1 and look up currency rate directly
+  // This is because native tokens are priced in themselves (1 ETH = 1 ETH)
+  if (!tokenMarketData && nativeCurrencySymbol) {
+    const currencyRate = currencyRates[nativeCurrencySymbol];
+
+    if (!currencyRate?.conversionRate) {
+      return undefined;
+    }
+
+    const fiatBalance =
+      (convertHexToDecimal(rawBalance) / 10 ** decimals) *
+      currencyRate.conversionRate;
+
+    return {
+      balance: fiatBalance,
+      conversionRate: currencyRate.conversionRate,
+    };
+  }
+
   if (!tokenMarketData) {
     return undefined;
   }