fix(ramp): parse slip44 intent as native asset cp-7.61.0 (MetaMask#23689)

## **Description**

This PR adds slip44 wildcard matching support to the Deposit
`useCryptoCurrencies` hook, aligning it with the existing behavior in
the Aggregator flow.

**Reason for change:**
When navigating to the Deposit flow from the Asset Details page with a
native asset (e.g., ETH), the intent contains a wildcard asset ID like
`eip155:1/slip44:.`. However, the Deposit SDK returns native tokens with
specific slip44 coin types (e.g., `eip155:1/slip44:60`). The direct
string comparison was failing to match these, causing the native token
not to be pre-selected.

**Solution:**
Added fallback logic that parses the CAIP-19 asset ID and matches any
token with the same `chainId` and `slip44` namespace when the direct
match fails. This mirrors the existing behavior in the Aggregator
`useCryptoCurrencies` hook.

## **Changelog**

CHANGELOG entry: null

## **Related issues**

Fixes: MetaMask#23441

## **Manual testing steps**

```gherkin
Feature: Native token selection in Deposit flow

  Scenario: user navigates to Deposit from Asset Details with native token
    Given the user is on the Asset Details page for ETH (or any native token)
    And the Deposit flow is enabled for the user's region

    When user taps the "Buy" button
    Then the Deposit flow opens with ETH pre-selected as the cryptocurrency
```

## **Screenshots/Recordings**

### **Before**



https://github.com/user-attachments/assets/5a7b1ca1-3939-4ab1-a693-bf8579814e98



### **After**



https://github.com/user-attachments/assets/293d0de4-a430-43d3-b0bd-c97315baecd4



## **Pre-merge author checklist**

- [x] I've followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile
Coding
Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [x] I've completed the PR template to the best of my ability
- [x] I've included tests if applicable
- [x] I've documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [x] I've applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Adds slip44 wildcard CAIP-19 intent matching to pre-select native
tokens in the Deposit flow and introduces focused tests for this
behavior.
> 
> - **Hook**
(`app/components/UI/Ramp/Deposit/hooks/useCryptoCurrencies.ts`):
> - Add slip44 wildcard handling by parsing CAIP-19
(`parseCAIP19AssetId`) when direct `assetId` match fails, selecting a
native token with the same `chainId` and `slip44` namespace.
>   - Preserve direct `assetId` match precedence over wildcard matching.
>   - Minor refactor to use a mutable `intentCrypto` before selection.
> - **Tests**
(`app/components/UI/Ramp/Deposit/hooks/useCryptoCurrencies.test.ts`):
> - Add cases for slip44 wildcard selecting native token (same/different
`chainId`).
>   - Add fallback to first token when no native match found.
>   - Confirm direct match is preferred over wildcard.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
7d6606a. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: wachunei

app/components/UI/Ramp/Deposit/hooks/useCryptoCurrencies.test.ts

@@ -429,5 +429,102 @@ describe('useCryptoCurrencies', () => {
         cryptosWithMissing[0],
       );
     });
+
+    it('selects native token when intent has slip44 wildcard assetId', () => {
+      const intent = { assetId: 'eip155:1/slip44:.' };
+      mockUseDepositSDK.mockReturnValue(
+        createMockSDKReturn({
+          selectedRegion: MOCK_US_REGION,
+          selectedCryptoCurrency: null,
+          setSelectedCryptoCurrency: mockSetSelectedCryptoCurrency,
+          intent,
+          setIntent: mockSetIntent,
+        }),
+      );
+
+      renderHook(() => useCryptoCurrencies());
+
+      expect(mockSetSelectedCryptoCurrency).toHaveBeenCalledWith(
+        MOCK_ETH_TOKEN,
+      );
+    });
+
+    it('selects native token when intent has slip44 wildcard with different chainId', () => {
+      const mockPolygonNativeToken = {
+        assetId: 'eip155:137/slip44:966',
+        chainId: 'eip155:137',
+        name: 'Polygon',
+        symbol: 'POL',
+        decimals: 18,
+        iconUrl: 'https://example.com/pol.png',
+      };
+      const cryptosWithPolygon = [
+        ...MOCK_CRYPTOCURRENCIES,
+        mockPolygonNativeToken,
+      ];
+      mockUseDepositSdkMethod.mockReturnValue([
+        { data: cryptosWithPolygon, error: null, isFetching: false },
+        mockRetryFetchCryptoCurrencies,
+      ]);
+      mockUseSelector.mockReturnValue({
+        ...mockNetworkConfigurations,
+        'eip155:137': { name: 'Polygon', chainId: '0x89' },
+      });
+
+      const intent = { assetId: 'eip155:137/slip44:.' };
+      mockUseDepositSDK.mockReturnValue(
+        createMockSDKReturn({
+          selectedRegion: MOCK_US_REGION,
+          selectedCryptoCurrency: null,
+          setSelectedCryptoCurrency: mockSetSelectedCryptoCurrency,
+          intent,
+          setIntent: mockSetIntent,
+        }),
+      );
+
+      renderHook(() => useCryptoCurrencies());
+
+      expect(mockSetSelectedCryptoCurrency).toHaveBeenCalledWith(
+        mockPolygonNativeToken,
+      );
+    });
+
+    it('falls back to first token when slip44 wildcard does not match any native token', () => {
+      const intent = { assetId: 'eip155:999/slip44:.' };
+      mockUseDepositSDK.mockReturnValue(
+        createMockSDKReturn({
+          selectedRegion: MOCK_US_REGION,
+          selectedCryptoCurrency: null,
+          setSelectedCryptoCurrency: mockSetSelectedCryptoCurrency,
+          intent,
+          setIntent: mockSetIntent,
+        }),
+      );
+
+      renderHook(() => useCryptoCurrencies());
+
+      expect(mockSetSelectedCryptoCurrency).toHaveBeenCalledWith(
+        MOCK_CRYPTOCURRENCIES[0],
+      );
+    });
+
+    it('prefers direct match over slip44 wildcard matching', () => {
+      const intent = { assetId: MOCK_USDC_TOKEN.assetId };
+      mockUseDepositSDK.mockReturnValue(
+        createMockSDKReturn({
+          selectedRegion: MOCK_US_REGION,
+          selectedCryptoCurrency: null,
+          setSelectedCryptoCurrency: mockSetSelectedCryptoCurrency,
+          intent,
+          setIntent: mockSetIntent,
+        }),
+      );
+
+      renderHook(() => useCryptoCurrencies());
+
+      expect(mockSetSelectedCryptoCurrency).toHaveBeenCalledWith(
+        MOCK_USDC_TOKEN,
+      );
+    });
   });
 });

app/components/UI/Ramp/Deposit/hooks/useCryptoCurrencies.ts

@@ -11,6 +11,7 @@ import { isCaipChainId } from '@metamask/utils';
 import { toEvmCaipChainId } from '@metamask/multichain-network-controller';
 import { toHex } from '@metamask/controller-utils';
 import { toLowerCaseEquals } from '../../../../../util/general';
+import { parseCAIP19AssetId } from '../../Aggregator/utils/parseCaip19AssetId';
 
 export interface UseCryptoCurrenciesResult {
   cryptoCurrencies: DepositCryptoCurrency[] | null;
@@ -56,10 +57,26 @@ export function useCryptoCurrencies(): UseCryptoCurrenciesResult {
   useEffect(() => {
     if (cryptoCurrencies && cryptoCurrencies.length > 0) {
       if (intent?.assetId) {
-        const intentCrypto = cryptoCurrencies.find((token) =>
+        let intentCrypto = cryptoCurrencies.find((token) =>
           toLowerCaseEquals(token.assetId, intent.assetId),
         );
 
+        // Handle slip44 wildcard matching any native asset
+        if (!intentCrypto) {
+          const intentParsedCaip19 = parseCAIP19AssetId(intent.assetId);
+          if (intentParsedCaip19?.assetNamespace === 'slip44') {
+            intentCrypto = cryptoCurrencies.find((token) => {
+              const tokenParsed = parseCAIP19AssetId(token.assetId);
+              return (
+                tokenParsed &&
+                tokenParsed.namespace === intentParsedCaip19.namespace &&
+                tokenParsed.chainId === intentParsedCaip19.chainId &&
+                tokenParsed.assetNamespace === 'slip44'
+              );
+            });
+          }
+        }
+
         setIntent((prevIntent) =>
           prevIntent ? { ...prevIntent, assetId: undefined } : undefined,
         );