feat: useAccountGroupForPermissions 2 (#35402)

<!--
Please submit this PR as a draft initially.
Do not mark it as "Ready for review" until the template has been
completely filled out, and PR status checks have passed at least once.
-->

## **Description**


This PR create a new hook to retrieve the supported and connected
multichain accounts, and caip25account ids from a specific caveat value.

The hook is not used at the moment and will be used once the multichain
account versions of the dapp connection components are completed.

<!--
Write a short description of the changes included in this pull request,
also include relevant motivation and context. Have in mind the following
questions:
1. What is the reason for the change?
2. What is the improvement/solution?
-->

[![Open in GitHub
Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/MetaMask/metamask-extension/pull/35111?quickstart=1)

## **Changelog**

<!--
If this PR is not End-User-Facing and should not show up in the
CHANGELOG, you can choose to either:
1. Write `CHANGELOG entry: null`
2. Label with `no-changelog`

If this PR is End-User-Facing, please write a short User-Facing
description in the past tense like:
`CHANGELOG entry: Added a new tab for users to see their NFTs`
`CHANGELOG entry: Fixed a bug that was causing some NFTs to flicker`

(This helps the Release Engineer do their job more quickly and
accurately)
-->

CHANGELOG entry: null

## **Related issues**

## **Manual testing steps**

N/a this hook is not being used right now. 
## **Screenshots/Recordings**

<!-- If applicable, add screenshots and/or recordings to visualize the
before and after of your change. -->

N/a this hook is not being used right now. 


## **Pre-merge author checklist**

- [x] I've followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask
Extension Coding
Standards](https://github.com/MetaMask/metamask-extension/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-extension/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.

Author: montelaidev

shared/lib/multichain/scope-utils.test.ts

@@ -0,0 +1,120 @@
+import { EthScope } from '@metamask/keyring-api';
+import { anyScopesMatch, scopeMatches } from './scope-utils';
+
+describe('scope-utils', () => {
+  describe('anyScopesMatch', () => {
+    it('returns false for empty account scopes', () => {
+      expect(anyScopesMatch([], 'eip155:1')).toBe(false);
+      // @ts-expect-error - testing undefined scope
+      expect(anyScopesMatch(undefined, 'eip155:1')).toBe(false);
+    });
+
+    it('returns true for direct scope match', () => {
+      const accountScopes = ['eip155:1', 'solana:mainnet'];
+      expect(anyScopesMatch(accountScopes, 'eip155:1')).toBe(true);
+      expect(anyScopesMatch(accountScopes, 'solana:mainnet')).toBe(true);
+    });
+
+    it('returns false for non-matching scope', () => {
+      const accountScopes = ['eip155:1', 'solana:mainnet'];
+      expect(anyScopesMatch(accountScopes, 'eip155:137')).toBe(false);
+      expect(
+        anyScopesMatch(
+          accountScopes,
+          'bip122:000000000019d6689c085ae165831e93',
+        ),
+      ).toBe(false);
+    });
+
+    describe('eip155:0 wildcard handling', () => {
+      it('returns true when requesting eip155:0 and account has any EVM scope', () => {
+        const accountScopes = ['eip155:1', 'eip155:137'];
+        expect(anyScopesMatch(accountScopes, 'eip155:0')).toBe(true);
+      });
+
+      it('returns true when requesting eip155:0 and account has eip155:0 scope', () => {
+        const accountScopes = ['eip155:0'];
+        expect(anyScopesMatch(accountScopes, 'eip155:0')).toBe(true);
+      });
+
+      it('returns false when requesting eip155:0 and account has no EVM scopes', () => {
+        const accountScopes = [
+          'solana:mainnet',
+          'bip122:000000000019d6689c085ae165831e93',
+        ];
+        expect(anyScopesMatch(accountScopes, 'eip155:0')).toBe(false);
+      });
+    });
+
+    describe('specific EVM chain handling', () => {
+      it('returns true when requesting specific EVM chain and account has eip155:0 scope', () => {
+        const accountScopes = [EthScope.Eoa]; // eip155:0
+        expect(anyScopesMatch(accountScopes, 'eip155:1')).toBe(true);
+        expect(anyScopesMatch(accountScopes, 'eip155:137')).toBe(true);
+      });
+
+      it('returns true when requesting specific EVM chain and account has exact match', () => {
+        const accountScopes = ['eip155:1'];
+        expect(anyScopesMatch(accountScopes, 'eip155:1')).toBe(true);
+      });
+
+      it('returns false when requesting specific EVM chain and account has different EVM chain', () => {
+        const accountScopes = ['eip155:137'];
+        expect(anyScopesMatch(accountScopes, 'eip155:1')).toBe(false);
+      });
+    });
+
+    describe('non-EVM scope handling', () => {
+      it('returns true for exact non-EVM scope match', () => {
+        const accountScopes = [
+          'solana:mainnet',
+          'bip122:000000000019d6689c085ae165831e93',
+        ];
+        expect(anyScopesMatch(accountScopes, 'solana:mainnet')).toBe(true);
+        expect(
+          anyScopesMatch(
+            accountScopes,
+            'bip122:000000000019d6689c085ae165831e93',
+          ),
+        ).toBe(true);
+      });
+
+      it('returns false for non-matching non-EVM scope', () => {
+        const accountScopes = ['solana:mainnet'];
+        expect(
+          anyScopesMatch(
+            accountScopes,
+            'bip122:000000000019d6689c085ae165831e93',
+          ),
+        ).toBe(false);
+      });
+    });
+
+    describe('malformed scope handling', () => {
+      it('returns false for malformed target scope', () => {
+        const accountScopes = ['eip155:1'];
+        expect(anyScopesMatch(accountScopes, 'invalid-scope')).toBe(false);
+        expect(anyScopesMatch(accountScopes, 'eip155')).toBe(false);
+        expect(anyScopesMatch(accountScopes, '')).toBe(false);
+      });
+    });
+  });
+
+  describe('scopeMatches', () => {
+    it('returns true for matching single scope', () => {
+      expect(scopeMatches('eip155:1', 'eip155:1')).toBe(true);
+      expect(scopeMatches('solana:mainnet', 'solana:mainnet')).toBe(true);
+    });
+
+    it('returns false for non-matching single scope', () => {
+      expect(scopeMatches('eip155:1', 'eip155:137')).toBe(false);
+      expect(scopeMatches('solana:mainnet', 'eip155:1')).toBe(false);
+    });
+
+    it('handles eip155:0 wildcard correctly', () => {
+      expect(scopeMatches('eip155:1', 'eip155:0')).toBe(true);
+      expect(scopeMatches('eip155:0', 'eip155:1')).toBe(true);
+      expect(scopeMatches('solana:mainnet', 'eip155:0')).toBe(false);
+    });
+  });
+});

shared/lib/multichain/scope-utils.ts

@@ -0,0 +1,118 @@
+import {
+  KnownCaipNamespace,
+  parseCaipChainId,
+  CaipChainId,
+  CaipNamespace,
+} from '@metamask/utils';
+import { EthScope } from '@metamask/keyring-api';
+
+/**
+ * Helper function to check if any of the account scopes match the target scope.
+ * Handles the special case of eip155:0 (wildcard) which matches any EVM scope.
+ *
+ * This function provides a consistent approach to scope matching across the codebase,
+ * ensuring that eip155:0 wildcard logic is handled uniformly in both selectors and
+ * permission/handler level code.
+ *
+ * @param accountScopes - Array of scope strings from the account
+ * @param targetScope - The target scope to match against
+ * @returns True if any scope matches, false otherwise
+ */
+export const anyScopesMatch = (
+  accountScopes: string[],
+  targetScope: string,
+): boolean => {
+  if (!Array.isArray(accountScopes) || accountScopes.length === 0) {
+    return false;
+  }
+
+  // Direct match
+  if (accountScopes.includes(targetScope)) {
+    return true;
+  }
+
+  try {
+    const parsed = parseCaipChainId(targetScope as `${string}:${string}`);
+    const { namespace, reference } = parsed;
+
+    if (namespace === KnownCaipNamespace.Eip155) {
+      // If requesting eip155:0 (wildcard), include any account that has any EVM scope
+      if (reference === '0') {
+        return accountScopes.some((scope) =>
+          scope.startsWith(`${KnownCaipNamespace.Eip155}:`),
+        );
+      }
+
+      // For a specific EVM chain, include accounts that have the wildcard scope
+      return accountScopes.includes(EthScope.Eoa);
+    }
+  } catch {
+    // If parsing fails, fall back to exact match only
+  }
+
+  return false;
+};
+
+/**
+ * Helper function to check if a single account scope matches the target scope.
+ * This is a convenience wrapper around anyScopesMatch for single scope comparisons.
+ *
+ * @param accountScope - Single scope string from the account
+ * @param targetScope - The target scope to match against
+ * @returns True if the scope matches, false otherwise
+ */
+export const scopeMatches = (
+  accountScope: string,
+  targetScope: string,
+): boolean => {
+  return anyScopesMatch([accountScope], targetScope);
+};
+
+/**
+ * Checks if an account supports the requested chain IDs
+ *
+ * @param accountScopes - Array of account scopes to check
+ * @param requestedChainIds - Array of requested chain IDs to match against
+ * @returns True if any scope matches any requested chain ID
+ */
+export const hasChainIdSupport = (
+  accountScopes: string[] | undefined,
+  requestedChainIds: CaipChainId[],
+): boolean => {
+  if (!accountScopes || requestedChainIds.length === 0) {
+    return false;
+  }
+
+  return accountScopes.some((accountScope) =>
+    requestedChainIds.some((requestedChainId) =>
+      anyScopesMatch([accountScope], requestedChainId),
+    ),
+  );
+};
+
+/**
+ * Checks if an account supports the requested namespaces
+ *
+ * @param accountScopes - Array of account scopes to check
+ * @param requestedNamespaces - Set of requested namespaces to match against
+ * @returns True if any scope namespace matches any requested namespace
+ */
+export const hasNamespaceSupport = (
+  accountScopes: string[] | undefined,
+  requestedNamespaces: Set<CaipNamespace>,
+): boolean => {
+  if (!accountScopes || requestedNamespaces.size === 0) {
+    return false;
+  }
+
+  for (const scope of accountScopes) {
+    const [scopeNamespace] = scope.split(':');
+    if (
+      scopeNamespace &&
+      requestedNamespaces.has(scopeNamespace as CaipNamespace)
+    ) {
+      return true;
+    }
+  }
+  return false;
+};