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,39 @@ 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');
+  });
+
   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 { getPhishingTestResultAsync } from '../../../../util/phishingDetection.t
 import {
   CaipAccountId,
   CaipChainId,
+  CaipNamespace,
   KnownCaipNamespace,
   parseCaipChainId,
 } from '@metamask/utils';
@@ -215,6 +216,32 @@ const MultichainAccountConnect = (props: AccountConnectProps) => {
     [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) => {
+      if (!scope.startsWith(`${KnownCaipNamespace.Wallet}:`)) {
+        return;
+      }
+
+      const delegatedNamespace = scope.slice(
+        `${KnownCaipNamespace.Wallet}:`.length,
+      );
+      if (delegatedNamespace) {
+        namespaces.add(delegatedNamespace as CaipNamespace);
+      }
+    });
+
+    return Array.from(namespaces);
+  }, [requestedNamespacesWithoutWallet, requestedCaip25CaveatValue]);
+
   const networkConfigurations = useSelector(
     selectNetworkConfigurationsByCaipChainId,
   );
@@ -322,14 +349,11 @@ const MultichainAccountConnect = (props: AccountConnectProps) => {
       return defaultSelectedNetworkList;
     }
 
-    let additionalChains: CaipChainId[] = [];
-    if (isEip1193Request) {
-      additionalChains = nonTestNetworkCaipChainIds.filter((caipChainId) =>
-        requestedNamespacesWithoutWallet.includes(
-          parseCaipChainId(caipChainId).namespace,
-        ),
-      );
-    }
+    const additionalChains = nonTestNetworkCaipChainIds.filter((caipChainId) =>
+      requestedNamespacesForNetworkSelection.includes(
+        parseCaipChainId(caipChainId).namespace,
+      ),
+    );
 
     const supportedRequestedCaipChainIds = Array.from(
       new Set([
@@ -350,12 +374,12 @@ const MultichainAccountConnect = (props: AccountConnectProps) => {
       );
     }
 
-    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 +392,7 @@ const MultichainAccountConnect = (props: AccountConnectProps) => {
     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 [];