feat(walletconnect): add multichain routing and namespace approval for first non-EVM chain (Tron)

app/components/Views/MultichainAccounts/MultichainAccountConnect/MultichainAccountConnect.test.tsx

@@ -356,6 +356,11 @@ jest.mock(
   }),
 );
 
+const { useAccountGroupsForPermissions: mockUseAccountGroupsForPermissions } =
+  jest.requireMock(
+    '../../../hooks/useAccountGroupsForPermissions/useAccountGroupsForPermissions',
+  );
+
 // Mock useWalletInfo hook
 jest.mock(
   '../../../../components/Views/MultichainAccounts/WalletDetails/hooks/useWalletInfo',
@@ -699,6 +704,174 @@ describe('MultichainAccountConnect', () => {
     });
   });
 
+  it('passes EVM chains to permissions hook for mixed wallet:eip155 + tron requests', () => {
+    renderWithProvider(
+      <MultichainAccountConnect
+        route={{
+          params: {
+            hostInfo: {
+              metadata: {
+                id: 'mockId',
+                origin: 'wc-channel-id',
+                isEip1193Request: false,
+              },
+              permissions: createMockCaip25Permission({
+                'wallet:eip155': {
+                  accounts: [],
+                },
+                'tron:728126428': {
+                  accounts: [],
+                },
+              }),
+            },
+            permissionRequestId: 'test-mixed-request',
+          },
+        }}
+      />,
+      { state: createMockState() },
+    );
+
+    const requestedChainIds =
+      mockUseAccountGroupsForPermissions.mock.calls.at(-1)?.[2] ?? [];
+    expect(requestedChainIds).toContain('eip155:1');
+    expect(requestedChainIds).toContain('tron:728126428');
+  });
+
+  it('does not expand explicit eip155 chain requests to all EVM chains', () => {
+    const stateWithMultipleEvmNetworks: DeepPartial<RootState> = {
+      ...createMockState(),
+      engine: {
+        ...createMockState().engine,
+        backgroundState: {
+          ...createMockState().engine?.backgroundState,
+          NetworkController: {
+            ...createMockState().engine?.backgroundState?.NetworkController,
+            networksMetadata: {
+              ...(createMockState().engine?.backgroundState?.NetworkController
+                ?.networksMetadata ?? {}),
+              polygon: { status: NetworkStatus.Available, EIPS: {} },
+            },
+            networkConfigurationsByChainId: {
+              ...(createMockState().engine?.backgroundState?.NetworkController
+                ?.networkConfigurationsByChainId ?? {}),
+              '0x89': {
+                blockExplorerUrls: ['https://polygonscan.com'],
+                chainId: '0x89',
+                defaultRpcEndpointIndex: 0,
+                name: 'Polygon Mainnet',
+                nativeCurrency: 'POL',
+                rpcEndpoints: [
+                  {
+                    networkClientId: 'polygon',
+                    type: RpcEndpointType.Custom,
+                    url: 'https://polygon-rpc.com',
+                  },
+                ],
+              },
+            },
+          },
+        },
+      },
+    };
+
+    renderWithProvider(
+      <MultichainAccountConnect
+        route={{
+          params: {
+            hostInfo: {
+              metadata: {
+                id: 'mockId',
+                origin: 'wc-channel-id',
+                isEip1193Request: false,
+              },
+              permissions: createMockCaip25Permission({
+                'wallet:eip155': {
+                  accounts: [],
+                },
+                'eip155:1': {
+                  accounts: [],
+                },
+              }),
+            },
+            permissionRequestId: 'test-explicit-eip155-request',
+          },
+        }}
+      />,
+      { state: stateWithMultipleEvmNetworks },
+    );
+
+    const requestedChainIds =
+      mockUseAccountGroupsForPermissions.mock.calls.at(-1)?.[2] ?? [];
+    expect(requestedChainIds).toContain('eip155:1');
+    expect(requestedChainIds).not.toContain('eip155:137');
+  });
+
+  it('keeps delegated wallet:eip155 expansion when no explicit eip155 chains are requested', () => {
+    const stateWithMultipleEvmNetworks: DeepPartial<RootState> = {
+      ...createMockState(),
+      engine: {
+        ...createMockState().engine,
+        backgroundState: {
+          ...createMockState().engine?.backgroundState,
+          NetworkController: {
+            ...createMockState().engine?.backgroundState?.NetworkController,
+            networksMetadata: {
+              ...(createMockState().engine?.backgroundState?.NetworkController
+                ?.networksMetadata ?? {}),
+              polygon: { status: NetworkStatus.Available, EIPS: {} },
+            },
+            networkConfigurationsByChainId: {
+              ...(createMockState().engine?.backgroundState?.NetworkController
+                ?.networkConfigurationsByChainId ?? {}),
+              '0x89': {
+                blockExplorerUrls: ['https://polygonscan.com'],
+                chainId: '0x89',
+                defaultRpcEndpointIndex: 0,
+                name: 'Polygon Mainnet',
+                nativeCurrency: 'POL',
+                rpcEndpoints: [
+                  {
+                    networkClientId: 'polygon',
+                    type: RpcEndpointType.Custom,
+                    url: 'https://polygon-rpc.com',
+                  },
+                ],
+              },
+            },
+          },
+        },
+      },
+    };
+
+    renderWithProvider(
+      <MultichainAccountConnect
+        route={{
+          params: {
+            hostInfo: {
+              metadata: {
+                id: 'mockId',
+                origin: 'wc-channel-id',
+                isEip1193Request: false,
+              },
+              permissions: createMockCaip25Permission({
+                'wallet:eip155': {
+                  accounts: [],
+                },
+              }),
+            },
+            permissionRequestId: 'test-delegated-eip155-expansion',
+          },
+        }}
+      />,
+      { state: stateWithMultipleEvmNetworks },
+    );
+
+    const requestedChainIds =
+      mockUseAccountGroupsForPermissions.mock.calls.at(-1)?.[2] ?? [];
+    expect(requestedChainIds).toContain('eip155:1');
+    expect(requestedChainIds).toContain('eip155:137');
+  });
+
   describe('Phishing detection', () => {
     describe('dapp scanning is enabled', () => {
       it('does not show phishing modal for safe URLs', async () => {

app/components/Views/MultichainAccounts/MultichainAccountConnect/MultichainAccountConnect.tsx

@@ -71,6 +71,7 @@
 import {
   CaipAccountId,
   CaipChainId,
+  CaipNamespace,
   KnownCaipNamespace,
   parseCaipChainId,
 } from '@metamask/utils';
@@ -215,6 +216,27 @@
     [requestedNamespaces],
   );
 
+  const requestedNamespacesForNetworkSelection = useMemo(() => {
+    const namespaces = new Set(requestedNamespacesWithoutWallet);
+    const rawScopeKeys = [
+      ...Object.keys(requestedCaip25CaveatValue.requiredScopes ?? {}),
+      ...Object.keys(requestedCaip25CaveatValue.optionalScopes ?? {}),
+    ];
+
+    // CAIP-25 may encode delegated namespace requests (for example wallet:eip155).
+    // Expand wallet:<namespace> scopes so default network selection still includes
+    // those concrete namespaces in multichain WalletConnect flows.
+    rawScopeKeys.forEach((scope) => {
+      const { namespace, reference } = parseCaipChainId(scope as CaipChainId);
+      if (namespace !== KnownCaipNamespace.Wallet || !reference) {
+        return;
+      }
+      namespaces.add(reference as CaipNamespace);
+    });
+
+    return Array.from(namespaces);
+  }, [requestedNamespacesWithoutWallet, requestedCaip25CaveatValue]);
+
   const networkConfigurations = useSelector(
     selectNetworkConfigurationsByCaipChainId,
   );
@@ -322,14 +344,28 @@
       return defaultSelectedNetworkList;
     }
 
-    let additionalChains: CaipChainId[] = [];
-    if (isEip1193Request) {
-      additionalChains = nonTestNetworkCaipChainIds.filter((caipChainId) =>
-        requestedNamespacesWithoutWallet.includes(
-          parseCaipChainId(caipChainId).namespace,
-        ),
-      );
-    }
+    const namespacesWithExplicitChainRequests = new Set(
+      requestedCaipChainIds.map(
+        (caipChainId) => parseCaipChainId(caipChainId).namespace,
+      ),
+    );
+
+    // Expand only namespaces that were requested without explicit chains
+    // (e.g. wallet:eip155 delegated requests in mixed namespace proposals).
+    // Intentionally restrictive: if explicit eip155 chains are requested, treat
+    // that list as authoritative and do not expand to all eip155 networks. This
+    // prevents approving more chains than requested. Delegated namespace
+    // expansion still applies when no explicit chain ids are provided.
+    // TODO: check if this restrictive logic has already been applied in the past or if this modifies previous behavior.
+    const additionalChains = nonTestNetworkCaipChainIds.filter(
+      (caipChainId) => {
+        const { namespace } = parseCaipChainId(caipChainId);
+        return (
+          requestedNamespacesForNetworkSelection.includes(namespace) &&
+          !namespacesWithExplicitChainRequests.has(namespace)
+        );
+      },
+    );
 
     const supportedRequestedCaipChainIds = Array.from(
       new Set([
@@ -350,12 +386,12 @@
       );
     }
 
-    if (requestedNamespaces.length > 0) {
+    if (requestedNamespacesForNetworkSelection.length > 0) {
       return Array.from(
         new Set(
           defaultSelectedNetworkList.filter((caipChainId) => {
             const { namespace } = parseCaipChainId(caipChainId);
-            return requestedNamespaces.includes(namespace);
+            return requestedNamespacesForNetworkSelection.includes(namespace);
           }),
         ),
       );
@@ -368,8 +404,7 @@
     requestedCaipChainIds,
     isEip1193Request,
     currentlySelectedNetwork.chainId,
-    requestedNamespaces,
-    requestedNamespacesWithoutWallet,
+    requestedNamespacesForNetworkSelection,
     alreadyConnectedCaipChainIds,
     isSolanaWalletStandardRequest,
   ]);

app/core/Permissions/index.test.ts

@@ -389,7 +389,10 @@ describe('Permission Utility Functions', () => {
       const result = getDefaultCaip25CaveatValue();
       expect(result).toEqual({
         requiredScopes: {},
-        optionalScopes: { 'wallet:eip155': { accounts: [] } },
+        optionalScopes: {
+          'wallet:eip155': { accounts: [] },
+          'tron:728126428': { accounts: [] },
+        },
         sessionProperties: {},
         isMultichainOrigin: false,
       });

app/core/Permissions/index.ts

@@ -8,6 +8,9 @@
   parseCaipAccountId,
   parseCaipChainId,
 } from '@metamask/utils';
+///: BEGIN:ONLY_INCLUDE_IF(tron)
+import { TrxScope } from '@metamask/keyring-api';
+///: END:ONLY_INCLUDE_IF
 import { InternalAccount } from '@metamask/keyring-internal-api';
 import {
   Caip25CaveatType,
@@ -16,7 +19,7 @@
   getAllScopesFromCaip25CaveatValue,
   getCaipAccountIdsFromCaip25CaveatValue,
   getEthAccounts,
   getPermittedEthChainIds,
   isInternalAccountInPermittedAccountIds,
   setChainIdsInCaip25CaveatValue,
   setNonSCACaipAccountIdsInCaip25CaveatValue,
@@ -297,18 +300,25 @@
 
 /**
  * Returns a default CAIP-25 caveat value.
+ * Each chain appends its optional scope below (feature-flagged).
  * @returns Default {@link Caip25CaveatValue}
  */
-export const getDefaultCaip25CaveatValue = (): Caip25CaveatValue => ({
-  requiredScopes: {},
-  optionalScopes: {
-    'wallet:eip155': {
-      accounts: [],
-    },
-  },
-  sessionProperties: {},
-  isMultichainOrigin: false,
-});
+export const getDefaultCaip25CaveatValue = (): Caip25CaveatValue => {
+  const optionalScopes: Caip25CaveatValue['optionalScopes'] = {
+    'wallet:eip155': { accounts: [] },
+  };
+
+  ///: BEGIN:ONLY_INCLUDE_IF(tron)
+  optionalScopes[TrxScope.Mainnet] = { accounts: [] };
+  ///: END:ONLY_INCLUDE_IF
+
+  return {
+    requiredScopes: {},
+    optionalScopes,
+    sessionProperties: {},
+    isMultichainOrigin: false,
+  };
+};
 
 // Returns the CAIP-25 caveat or undefined if it does not exist
 export const getCaip25Caveat = (origin: string) => {
@@ -624,10 +634,11 @@
 };
 
 /**
- * Get permitted chains for the given the host.
+ * Get permitted chains for the given the host, across all namespaces.
+ * Returns all non-wallet scopes stored in the CAIP-25 caveat.
  *
  * @param hostname - Subject to check if permissions exists. Ex: A Dapp is a subject.
- * @returns An array containing permitted chains for the specified host.
+ * @returns An array containing permitted CAIP chain IDs for the specified host.
  */
 export const getPermittedChains = async (
   hostname: string,
@@ -640,14 +651,16 @@
   );
 
   if (caveat) {
-    const chains = getPermittedEthChainIds(caveat.value).map(
-      (chainId: string) =>
-        `${KnownCaipNamespace.Eip155.toString()}:${parseInt(
-          chainId,
-        )}` as CaipChainId,
+    return getAllScopesFromCaip25CaveatValue(caveat.value).filter(
+      (caipChainId: CaipChainId) => {
+        try {
+          const { namespace } = parseCaipChainId(caipChainId);
+          return namespace !== KnownCaipNamespace.Wallet;
+        } catch {
+          return false;
+        }
+      },
     );
-
-    return chains;
   }
 
   return [];