@metamask-previews/chain-agnostic-permission 0.1.0-preview-b69c669

package/dist/scope/filter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.mts","sourceRoot":"","sources":["../../src/scope/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,wBAAwB;AAIxD,OAAO,KAAK,EAGV,sBAAsB,EACvB,oBAAgB;AAEjB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,WACxB,sBAAsB;qCAMK,GAAG,KAAK,OAAO;oCAChB,WAAW,KAAK,OAAO;uCACpB,WAAW,KAAK,MAAM,EAAE;;;;CAqB9D,CAAC;AAsCF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,WAC3B,sBAAsB;uCAIO,WAAW,KAAK,MAAM,EAAE;4BAe9D,CAAC"}

package/dist/scope/filter.mjs

@@ -0,0 +1,71 @@
+import { assertIsInternalScopeString, assertScopeSupported } from "./assert.mjs";
+import { isSupportedMethod, isSupportedNotification } from "./supported.mjs";
+/**
+ * Groups a NormalizedScopesObject into two separate
+ * NormalizedScopesObject with supported scopes in one
+ * and unsupported scopes in the other.
+ *
+ * @param scopes - The NormalizedScopesObject to group.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.
+ * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.
+ * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.
+ * @returns The supported and unsupported scopes.
+ */
+export const bucketScopesBySupport = (scopes, { isEvmChainIdSupported, isNonEvmScopeSupported, getNonEvmSupportedMethods, }) => {
+    const supportedScopes = {};
+    const unsupportedScopes = {};
+    for (const [scopeString, scopeObject] of Object.entries(scopes)) {
+        assertIsInternalScopeString(scopeString);
+        try {
+            assertScopeSupported(scopeString, scopeObject, {
+                isEvmChainIdSupported,
+                isNonEvmScopeSupported,
+                getNonEvmSupportedMethods,
+            });
+            supportedScopes[scopeString] = scopeObject;
+        }
+        catch {
+            unsupportedScopes[scopeString] = scopeObject;
+        }
+    }
+    return { supportedScopes, unsupportedScopes };
+};
+/**
+ * Returns a NormalizedScopeObject with
+ * unsupported methods and notifications removed.
+ *
+ * @param scopeString - The InternalScopeString for the scopeObject.
+ * @param scopeObject - The NormalizedScopeObject to filter.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.
+ * @returns a NormalizedScopeObject with only methods and notifications that are currently supported.
+ */
+const getSupportedScopeObject = (scopeString, scopeObject, { getNonEvmSupportedMethods, }) => {
+    const { methods, notifications } = scopeObject;
+    const supportedMethods = methods.filter((method) => isSupportedMethod(scopeString, method, { getNonEvmSupportedMethods }));
+    const supportedNotifications = notifications.filter((notification) => isSupportedNotification(scopeString, notification));
+    return {
+        ...scopeObject,
+        methods: supportedMethods,
+        notifications: supportedNotifications,
+    };
+};
+/**
+ * Returns a NormalizedScopesObject with
+ * unsupported methods and notifications removed from scopeObjects.
+ *
+ * @param scopes - The NormalizedScopesObject to filter.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.
+ * @returns a NormalizedScopesObject with only methods, and notifications that are currently supported.
+ */
+export const getSupportedScopeObjects = (scopes, { getNonEvmSupportedMethods, }) => {
+    const filteredScopesObject = {};
+    for (const [scopeString, scopeObject] of Object.entries(scopes)) {
+        assertIsInternalScopeString(scopeString);
+        filteredScopesObject[scopeString] = getSupportedScopeObject(scopeString, scopeObject, { getNonEvmSupportedMethods });
+    }
+    return filteredScopesObject;
+};
+//# sourceMappingURL=filter.mjs.map

package/dist/scope/filter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.mjs","sourceRoot":"","sources":["../../src/scope/filter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,oBAAoB,EAAE,qBAAiB;AAC7E,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,wBAAoB;AAOzE;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,MAA8B,EAC9B,EACE,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,GAK1B,EACD,EAAE;IACF,MAAM,eAAe,GAA2B,EAAE,CAAC;IACnD,MAAM,iBAAiB,GAA2B,EAAE,CAAC;IAErD,KAAK,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QAC/D,2BAA2B,CAAC,WAAW,CAAC,CAAC;QACzC,IAAI;YACF,oBAAoB,CAAC,WAAW,EAAE,WAAW,EAAE;gBAC7C,qBAAqB;gBACrB,sBAAsB;gBACtB,yBAAyB;aAC1B,CAAC,CAAC;YACH,eAAe,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC;SAC5C;QAAC,MAAM;YACN,iBAAiB,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC;SAC9C;KACF;IAED,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,CAAC;AAChD,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,uBAAuB,GAAG,CAC9B,WAAgC,EAChC,WAAkC,EAClC,EACE,yBAAyB,GAG1B,EACD,EAAE;IACF,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,WAAW,CAAC;IAE/C,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CACjD,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,yBAAyB,EAAE,CAAC,CACtE,CAAC;IAEF,MAAM,sBAAsB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,CACnE,uBAAuB,CAAC,WAAW,EAAE,YAAY,CAAC,CACnD,CAAC;IAEF,OAAO;QACL,GAAG,WAAW;QACd,OAAO,EAAE,gBAAgB;QACzB,aAAa,EAAE,sBAAsB;KACtC,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CACtC,MAA8B,EAC9B,EACE,yBAAyB,GAG1B,EACD,EAAE;IACF,MAAM,oBAAoB,GAA2B,EAAE,CAAC;IAExD,KAAK,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QAC/D,2BAA2B,CAAC,WAAW,CAAC,CAAC;QACzC,oBAAoB,CAAC,WAAW,CAAC,GAAG,uBAAuB,CACzD,WAAW,EACX,WAAW,EACX,EAAE,yBAAyB,EAAE,CAC9B,CAAC;KACH;IAED,OAAO,oBAAoB,CAAC;AAC9B,CAAC,CAAC","sourcesContent":["import type { CaipChainId, Hex } from '@metamask/utils';\n\nimport { assertIsInternalScopeString, assertScopeSupported } from './assert';\nimport { isSupportedMethod, isSupportedNotification } from './supported';\nimport type {\n  InternalScopeString,\n  NormalizedScopeObject,\n  NormalizedScopesObject,\n} from './types';\n\n/**\n * Groups a NormalizedScopesObject into two separate\n * NormalizedScopesObject with supported scopes in one\n * and unsupported scopes in the other.\n *\n * @param scopes - The NormalizedScopesObject to group.\n * @param hooks - An object containing the following properties:\n * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.\n * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.\n * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.\n * @returns The supported and unsupported scopes.\n */\nexport const bucketScopesBySupport = (\n  scopes: NormalizedScopesObject,\n  {\n    isEvmChainIdSupported,\n    isNonEvmScopeSupported,\n    getNonEvmSupportedMethods,\n  }: {\n    isEvmChainIdSupported: (chainId: Hex) => boolean;\n    isNonEvmScopeSupported: (scope: CaipChainId) => boolean;\n    getNonEvmSupportedMethods: (scope: CaipChainId) => string[];\n  },\n) => {\n  const supportedScopes: NormalizedScopesObject = {};\n  const unsupportedScopes: NormalizedScopesObject = {};\n\n  for (const [scopeString, scopeObject] of Object.entries(scopes)) {\n    assertIsInternalScopeString(scopeString);\n    try {\n      assertScopeSupported(scopeString, scopeObject, {\n        isEvmChainIdSupported,\n        isNonEvmScopeSupported,\n        getNonEvmSupportedMethods,\n      });\n      supportedScopes[scopeString] = scopeObject;\n    } catch {\n      unsupportedScopes[scopeString] = scopeObject;\n    }\n  }\n\n  return { supportedScopes, unsupportedScopes };\n};\n\n/**\n * Returns a NormalizedScopeObject with\n * unsupported methods and notifications removed.\n *\n * @param scopeString - The InternalScopeString for the scopeObject.\n * @param scopeObject - The NormalizedScopeObject to filter.\n * @param hooks - An object containing the following properties:\n * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.\n * @returns a NormalizedScopeObject with only methods and notifications that are currently supported.\n */\nconst getSupportedScopeObject = (\n  scopeString: InternalScopeString,\n  scopeObject: NormalizedScopeObject,\n  {\n    getNonEvmSupportedMethods,\n  }: {\n    getNonEvmSupportedMethods: (scope: CaipChainId) => string[];\n  },\n) => {\n  const { methods, notifications } = scopeObject;\n\n  const supportedMethods = methods.filter((method) =>\n    isSupportedMethod(scopeString, method, { getNonEvmSupportedMethods }),\n  );\n\n  const supportedNotifications = notifications.filter((notification) =>\n    isSupportedNotification(scopeString, notification),\n  );\n\n  return {\n    ...scopeObject,\n    methods: supportedMethods,\n    notifications: supportedNotifications,\n  };\n};\n\n/**\n * Returns a NormalizedScopesObject with\n * unsupported methods and notifications removed from scopeObjects.\n *\n * @param scopes - The NormalizedScopesObject to filter.\n * @param hooks - An object containing the following properties:\n * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.\n * @returns a NormalizedScopesObject with only methods, and notifications that are currently supported.\n */\nexport const getSupportedScopeObjects = (\n  scopes: NormalizedScopesObject,\n  {\n    getNonEvmSupportedMethods,\n  }: {\n    getNonEvmSupportedMethods: (scope: CaipChainId) => string[];\n  },\n) => {\n  const filteredScopesObject: NormalizedScopesObject = {};\n\n  for (const [scopeString, scopeObject] of Object.entries(scopes)) {\n    assertIsInternalScopeString(scopeString);\n    filteredScopesObject[scopeString] = getSupportedScopeObject(\n      scopeString,\n      scopeObject,\n      { getNonEvmSupportedMethods },\n    );\n  }\n\n  return filteredScopesObject;\n};\n"]}

package/dist/scope/supported.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupportedNotification = exports.isSupportedMethod = exports.isSupportedAccount = exports.isSupportedScopeString = void 0;
+const controller_utils_1 = require("@metamask/controller-utils");
+const utils_1 = require("@metamask/utils");
+const constants_1 = require("./constants.cjs");
+const types_1 = require("./types.cjs");
+/**
+ * Determines if a scope string is supported.
+ *
+ * @param scopeString - The scope string to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.
+ * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.
+ * @returns A boolean indicating if the scope string is supported.
+ */
+const isSupportedScopeString = (scopeString, { isEvmChainIdSupported, isNonEvmScopeSupported, }) => {
+    const { namespace, reference } = (0, types_1.parseScopeString)(scopeString);
+    switch (namespace) {
+        case utils_1.KnownCaipNamespace.Wallet:
+            if ((0, utils_1.isCaipChainId)(scopeString) &&
+                reference !== utils_1.KnownCaipNamespace.Eip155) {
+                return isNonEvmScopeSupported(scopeString);
+            }
+            return true;
+        case utils_1.KnownCaipNamespace.Eip155:
+            return (!reference ||
+                (constants_1.CaipReferenceRegexes.eip155.test(reference) &&
+                    isEvmChainIdSupported((0, controller_utils_1.toHex)(reference))));
+        default:
+            return (0, utils_1.isCaipChainId)(scopeString)
+                ? isNonEvmScopeSupported(scopeString)
+                : false;
+    }
+};
+exports.isSupportedScopeString = isSupportedScopeString;
+/**
+ * Determines if an account is supported by the wallet (i.e. on a keyring known to the wallet).
+ *
+ * @param account - The CAIP account ID to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getEvmInternalAccounts - A function that returns the EVM internal accounts.
+ * @param hooks.getNonEvmAccountAddresses - A function that returns the supported CAIP-10 account addresses for a non EVM scope.
+ * @returns A boolean indicating if the account is supported by the wallet.
+ */
+const isSupportedAccount = (account, { getEvmInternalAccounts, getNonEvmAccountAddresses, }) => {
+    const { address, chainId, chain: { namespace, reference }, } = (0, utils_1.parseCaipAccountId)(account);
+    const isSupportedEip155Account = () => getEvmInternalAccounts().some((internalAccount) => ['eip155:eoa', 'eip155:erc4337'].includes(internalAccount.type) &&
+        (0, controller_utils_1.isEqualCaseInsensitive)(address, internalAccount.address));
+    const isSupportedNonEvmAccount = () => getNonEvmAccountAddresses(chainId).includes(account);
+    // We are trying to discern the type of `namespace`.
+    /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+    switch (namespace) {
+        case utils_1.KnownCaipNamespace.Wallet:
+            if (reference === utils_1.KnownCaipNamespace.Eip155) {
+                return isSupportedEip155Account();
+            }
+            return isSupportedNonEvmAccount();
+        case utils_1.KnownCaipNamespace.Eip155:
+            return isSupportedEip155Account();
+        default:
+            return isSupportedNonEvmAccount();
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
+};
+exports.isSupportedAccount = isSupportedAccount;
+/**
+ * Determines if a method is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param method - The method to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.
+ * @returns A boolean indicating if the method is supported by the wallet.
+ */
+const isSupportedMethod = (scopeString, method, { getNonEvmSupportedMethods, }) => {
+    const { namespace, reference } = (0, types_1.parseScopeString)(scopeString);
+    if (!namespace) {
+        return false;
+    }
+    const isSupportedNonEvmMethod = () => (0, utils_1.isCaipChainId)(scopeString) &&
+        getNonEvmSupportedMethods(scopeString).includes(method);
+    // We are trying to discern the type of `namespace`.
+    /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+    if (namespace === utils_1.KnownCaipNamespace.Wallet) {
+        if (!reference) {
+            return constants_1.KnownWalletRpcMethods.includes(method);
+        }
+        if (reference === utils_1.KnownCaipNamespace.Eip155) {
+            return constants_1.KnownWalletNamespaceRpcMethods[reference].includes(method);
+        }
+        return isSupportedNonEvmMethod();
+    }
+    if (namespace === utils_1.KnownCaipNamespace.Eip155) {
+        return constants_1.KnownRpcMethods[namespace].includes(method);
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
+    return isSupportedNonEvmMethod();
+};
+exports.isSupportedMethod = isSupportedMethod;
+/**
+ * Determines if a notification is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param notification - The notification to check.
+ * @returns A boolean indicating if the notification is supported by the wallet.
+ */
+const isSupportedNotification = (scopeString, notification) => {
+    const { namespace } = (0, types_1.parseScopeString)(scopeString);
+    if (namespace === utils_1.KnownCaipNamespace.Eip155) {
+        return constants_1.KnownNotifications[namespace].includes(notification);
+    }
+    return false;
+};
+exports.isSupportedNotification = isSupportedNotification;
+//# sourceMappingURL=supported.cjs.map

package/dist/scope/supported.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"supported.cjs","sourceRoot":"","sources":["../../src/scope/supported.ts"],"names":[],"mappings":"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","sourcesContent":["import { toHex, isEqualCaseInsensitive } from '@metamask/controller-utils';\nimport type { CaipAccountId, CaipChainId, Hex } from '@metamask/utils';\nimport {\n  isCaipChainId,\n  KnownCaipNamespace,\n  parseCaipAccountId,\n} from '@metamask/utils';\n\nimport {\n  CaipReferenceRegexes,\n  KnownNotifications,\n  KnownRpcMethods,\n  KnownWalletNamespaceRpcMethods,\n  KnownWalletRpcMethods,\n} from './constants';\nimport type { ExternalScopeString } from './types';\nimport { parseScopeString } from './types';\n\n/**\n * Determines if a scope string is supported.\n *\n * @param scopeString - The scope string to check.\n * @param hooks - An object containing the following properties:\n * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.\n * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.\n * @returns A boolean indicating if the scope string is supported.\n */\nexport const isSupportedScopeString = (\n  scopeString: string,\n  {\n    isEvmChainIdSupported,\n    isNonEvmScopeSupported,\n  }: {\n    isEvmChainIdSupported: (chainId: Hex) => boolean;\n    isNonEvmScopeSupported: (scope: CaipChainId) => boolean;\n  },\n) => {\n  const { namespace, reference } = parseScopeString(scopeString);\n\n  switch (namespace) {\n    case KnownCaipNamespace.Wallet:\n      if (\n        isCaipChainId(scopeString) &&\n        reference !== KnownCaipNamespace.Eip155\n      ) {\n        return isNonEvmScopeSupported(scopeString);\n      }\n      return true;\n    case KnownCaipNamespace.Eip155:\n      return (\n        !reference ||\n        (CaipReferenceRegexes.eip155.test(reference) &&\n          isEvmChainIdSupported(toHex(reference)))\n      );\n    default:\n      return isCaipChainId(scopeString)\n        ? isNonEvmScopeSupported(scopeString)\n        : false;\n  }\n};\n\n/**\n * Determines if an account is supported by the wallet (i.e. on a keyring known to the wallet).\n *\n * @param account - The CAIP account ID to check.\n * @param hooks - An object containing the following properties:\n * @param hooks.getEvmInternalAccounts - A function that returns the EVM internal accounts.\n * @param hooks.getNonEvmAccountAddresses - A function that returns the supported CAIP-10 account addresses for a non EVM scope.\n * @returns A boolean indicating if the account is supported by the wallet.\n */\nexport const isSupportedAccount = (\n  account: CaipAccountId,\n  {\n    getEvmInternalAccounts,\n    getNonEvmAccountAddresses,\n  }: {\n    getEvmInternalAccounts: () => { type: string; address: Hex }[];\n    getNonEvmAccountAddresses: (scope: CaipChainId) => string[];\n  },\n) => {\n  const {\n    address,\n    chainId,\n    chain: { namespace, reference },\n  } = parseCaipAccountId(account);\n\n  const isSupportedEip155Account = () =>\n    getEvmInternalAccounts().some(\n      (internalAccount) =>\n        ['eip155:eoa', 'eip155:erc4337'].includes(internalAccount.type) &&\n        isEqualCaseInsensitive(address, internalAccount.address),\n    );\n\n  const isSupportedNonEvmAccount = () =>\n    getNonEvmAccountAddresses(chainId).includes(account);\n\n  // We are trying to discern the type of `namespace`.\n  /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n  switch (namespace) {\n    case KnownCaipNamespace.Wallet:\n      if (reference === KnownCaipNamespace.Eip155) {\n        return isSupportedEip155Account();\n      }\n      return isSupportedNonEvmAccount();\n    case KnownCaipNamespace.Eip155:\n      return isSupportedEip155Account();\n    default:\n      return isSupportedNonEvmAccount();\n  }\n  /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */\n};\n\n/**\n * Determines if a method is supported by the wallet.\n *\n * @param scopeString - The scope string to check.\n * @param method - The method to check.\n * @param hooks - An object containing the following properties:\n * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.\n * @returns A boolean indicating if the method is supported by the wallet.\n */\nexport const isSupportedMethod = (\n  scopeString: ExternalScopeString,\n  method: string,\n  {\n    getNonEvmSupportedMethods,\n  }: {\n    getNonEvmSupportedMethods: (scope: CaipChainId) => string[];\n  },\n): boolean => {\n  const { namespace, reference } = parseScopeString(scopeString);\n\n  if (!namespace) {\n    return false;\n  }\n\n  const isSupportedNonEvmMethod = () =>\n    isCaipChainId(scopeString) &&\n    getNonEvmSupportedMethods(scopeString).includes(method);\n\n  // We are trying to discern the type of `namespace`.\n  /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n  if (namespace === KnownCaipNamespace.Wallet) {\n    if (!reference) {\n      return KnownWalletRpcMethods.includes(method);\n    }\n\n    if (reference === KnownCaipNamespace.Eip155) {\n      return KnownWalletNamespaceRpcMethods[reference].includes(method);\n    }\n\n    return isSupportedNonEvmMethod();\n  }\n\n  if (namespace === KnownCaipNamespace.Eip155) {\n    return KnownRpcMethods[namespace].includes(method);\n  }\n  /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */\n\n  return isSupportedNonEvmMethod();\n};\n\n/**\n * Determines if a notification is supported by the wallet.\n *\n * @param scopeString - The scope string to check.\n * @param notification - The notification to check.\n * @returns A boolean indicating if the notification is supported by the wallet.\n */\nexport const isSupportedNotification = (\n  scopeString: ExternalScopeString,\n  notification: string,\n): boolean => {\n  const { namespace } = parseScopeString(scopeString);\n\n  if (namespace === KnownCaipNamespace.Eip155) {\n    return KnownNotifications[namespace].includes(notification);\n  }\n\n  return false;\n};\n"]}

package/dist/scope/supported.d.cts

@@ -0,0 +1,52 @@
+import type { CaipAccountId, CaipChainId, Hex } from "@metamask/utils";
+import type { ExternalScopeString } from "./types.cjs";
+/**
+ * Determines if a scope string is supported.
+ *
+ * @param scopeString - The scope string to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.
+ * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.
+ * @returns A boolean indicating if the scope string is supported.
+ */
+export declare const isSupportedScopeString: (scopeString: string, { isEvmChainIdSupported, isNonEvmScopeSupported, }: {
+    isEvmChainIdSupported: (chainId: Hex) => boolean;
+    isNonEvmScopeSupported: (scope: CaipChainId) => boolean;
+}) => boolean;
+/**
+ * Determines if an account is supported by the wallet (i.e. on a keyring known to the wallet).
+ *
+ * @param account - The CAIP account ID to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getEvmInternalAccounts - A function that returns the EVM internal accounts.
+ * @param hooks.getNonEvmAccountAddresses - A function that returns the supported CAIP-10 account addresses for a non EVM scope.
+ * @returns A boolean indicating if the account is supported by the wallet.
+ */
+export declare const isSupportedAccount: (account: CaipAccountId, { getEvmInternalAccounts, getNonEvmAccountAddresses, }: {
+    getEvmInternalAccounts: () => {
+        type: string;
+        address: Hex;
+    }[];
+    getNonEvmAccountAddresses: (scope: CaipChainId) => string[];
+}) => boolean;
+/**
+ * Determines if a method is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param method - The method to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.
+ * @returns A boolean indicating if the method is supported by the wallet.
+ */
+export declare const isSupportedMethod: (scopeString: ExternalScopeString, method: string, { getNonEvmSupportedMethods, }: {
+    getNonEvmSupportedMethods: (scope: CaipChainId) => string[];
+}) => boolean;
+/**
+ * Determines if a notification is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param notification - The notification to check.
+ * @returns A boolean indicating if the notification is supported by the wallet.
+ */
+export declare const isSupportedNotification: (scopeString: ExternalScopeString, notification: string) => boolean;
+//# sourceMappingURL=supported.d.cts.map

package/dist/scope/supported.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supported.d.cts","sourceRoot":"","sources":["../../src/scope/supported.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,EAAE,wBAAwB;AAcvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAgB;AAGnD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,gBACpB,MAAM;qCAKgB,GAAG,KAAK,OAAO;oCAChB,WAAW,KAAK,OAAO;aAyB1D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,YACpB,aAAa;4BAKI,MAAM;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAE,EAAE;uCAC3B,WAAW,KAAK,MAAM,EAAE;aAiC9D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,gBACf,mBAAmB,UACxB,MAAM;uCAIuB,WAAW,KAAK,MAAM,EAAE;MAE5D,OA+BF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,gBACrB,mBAAmB,gBAClB,MAAM,KACnB,OAQF,CAAC"}

package/dist/scope/supported.d.mts

@@ -0,0 +1,52 @@
+import type { CaipAccountId, CaipChainId, Hex } from "@metamask/utils";
+import type { ExternalScopeString } from "./types.mjs";
+/**
+ * Determines if a scope string is supported.
+ *
+ * @param scopeString - The scope string to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.
+ * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.
+ * @returns A boolean indicating if the scope string is supported.
+ */
+export declare const isSupportedScopeString: (scopeString: string, { isEvmChainIdSupported, isNonEvmScopeSupported, }: {
+    isEvmChainIdSupported: (chainId: Hex) => boolean;
+    isNonEvmScopeSupported: (scope: CaipChainId) => boolean;
+}) => boolean;
+/**
+ * Determines if an account is supported by the wallet (i.e. on a keyring known to the wallet).
+ *
+ * @param account - The CAIP account ID to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getEvmInternalAccounts - A function that returns the EVM internal accounts.
+ * @param hooks.getNonEvmAccountAddresses - A function that returns the supported CAIP-10 account addresses for a non EVM scope.
+ * @returns A boolean indicating if the account is supported by the wallet.
+ */
+export declare const isSupportedAccount: (account: CaipAccountId, { getEvmInternalAccounts, getNonEvmAccountAddresses, }: {
+    getEvmInternalAccounts: () => {
+        type: string;
+        address: Hex;
+    }[];
+    getNonEvmAccountAddresses: (scope: CaipChainId) => string[];
+}) => boolean;
+/**
+ * Determines if a method is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param method - The method to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.
+ * @returns A boolean indicating if the method is supported by the wallet.
+ */
+export declare const isSupportedMethod: (scopeString: ExternalScopeString, method: string, { getNonEvmSupportedMethods, }: {
+    getNonEvmSupportedMethods: (scope: CaipChainId) => string[];
+}) => boolean;
+/**
+ * Determines if a notification is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param notification - The notification to check.
+ * @returns A boolean indicating if the notification is supported by the wallet.
+ */
+export declare const isSupportedNotification: (scopeString: ExternalScopeString, notification: string) => boolean;
+//# sourceMappingURL=supported.d.mts.map

package/dist/scope/supported.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supported.d.mts","sourceRoot":"","sources":["../../src/scope/supported.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,EAAE,wBAAwB;AAcvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAgB;AAGnD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,gBACpB,MAAM;qCAKgB,GAAG,KAAK,OAAO;oCAChB,WAAW,KAAK,OAAO;aAyB1D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,YACpB,aAAa;4BAKI,MAAM;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAE,EAAE;uCAC3B,WAAW,KAAK,MAAM,EAAE;aAiC9D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,gBACf,mBAAmB,UACxB,MAAM;uCAIuB,WAAW,KAAK,MAAM,EAAE;MAE5D,OA+BF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,gBACrB,mBAAmB,gBAClB,MAAM,KACnB,OAQF,CAAC"}

package/dist/scope/supported.mjs

@@ -0,0 +1,109 @@
+import { toHex, isEqualCaseInsensitive } from "@metamask/controller-utils";
+import { isCaipChainId, KnownCaipNamespace, parseCaipAccountId } from "@metamask/utils";
+import { CaipReferenceRegexes, KnownNotifications, KnownRpcMethods, KnownWalletNamespaceRpcMethods, KnownWalletRpcMethods } from "./constants.mjs";
+import { parseScopeString } from "./types.mjs";
+/**
+ * Determines if a scope string is supported.
+ *
+ * @param scopeString - The scope string to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.
+ * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.
+ * @returns A boolean indicating if the scope string is supported.
+ */
+export const isSupportedScopeString = (scopeString, { isEvmChainIdSupported, isNonEvmScopeSupported, }) => {
+    const { namespace, reference } = parseScopeString(scopeString);
+    switch (namespace) {
+        case KnownCaipNamespace.Wallet:
+            if (isCaipChainId(scopeString) &&
+                reference !== KnownCaipNamespace.Eip155) {
+                return isNonEvmScopeSupported(scopeString);
+            }
+            return true;
+        case KnownCaipNamespace.Eip155:
+            return (!reference ||
+                (CaipReferenceRegexes.eip155.test(reference) &&
+                    isEvmChainIdSupported(toHex(reference))));
+        default:
+            return isCaipChainId(scopeString)
+                ? isNonEvmScopeSupported(scopeString)
+                : false;
+    }
+};
+/**
+ * Determines if an account is supported by the wallet (i.e. on a keyring known to the wallet).
+ *
+ * @param account - The CAIP account ID to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getEvmInternalAccounts - A function that returns the EVM internal accounts.
+ * @param hooks.getNonEvmAccountAddresses - A function that returns the supported CAIP-10 account addresses for a non EVM scope.
+ * @returns A boolean indicating if the account is supported by the wallet.
+ */
+export const isSupportedAccount = (account, { getEvmInternalAccounts, getNonEvmAccountAddresses, }) => {
+    const { address, chainId, chain: { namespace, reference }, } = parseCaipAccountId(account);
+    const isSupportedEip155Account = () => getEvmInternalAccounts().some((internalAccount) => ['eip155:eoa', 'eip155:erc4337'].includes(internalAccount.type) &&
+        isEqualCaseInsensitive(address, internalAccount.address));
+    const isSupportedNonEvmAccount = () => getNonEvmAccountAddresses(chainId).includes(account);
+    // We are trying to discern the type of `namespace`.
+    /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+    switch (namespace) {
+        case KnownCaipNamespace.Wallet:
+            if (reference === KnownCaipNamespace.Eip155) {
+                return isSupportedEip155Account();
+            }
+            return isSupportedNonEvmAccount();
+        case KnownCaipNamespace.Eip155:
+            return isSupportedEip155Account();
+        default:
+            return isSupportedNonEvmAccount();
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
+};
+/**
+ * Determines if a method is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param method - The method to check.
+ * @param hooks - An object containing the following properties:
+ * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.
+ * @returns A boolean indicating if the method is supported by the wallet.
+ */
+export const isSupportedMethod = (scopeString, method, { getNonEvmSupportedMethods, }) => {
+    const { namespace, reference } = parseScopeString(scopeString);
+    if (!namespace) {
+        return false;
+    }
+    const isSupportedNonEvmMethod = () => isCaipChainId(scopeString) &&
+        getNonEvmSupportedMethods(scopeString).includes(method);
+    // We are trying to discern the type of `namespace`.
+    /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+    if (namespace === KnownCaipNamespace.Wallet) {
+        if (!reference) {
+            return KnownWalletRpcMethods.includes(method);
+        }
+        if (reference === KnownCaipNamespace.Eip155) {
+            return KnownWalletNamespaceRpcMethods[reference].includes(method);
+        }
+        return isSupportedNonEvmMethod();
+    }
+    if (namespace === KnownCaipNamespace.Eip155) {
+        return KnownRpcMethods[namespace].includes(method);
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
+    return isSupportedNonEvmMethod();
+};
+/**
+ * Determines if a notification is supported by the wallet.
+ *
+ * @param scopeString - The scope string to check.
+ * @param notification - The notification to check.
+ * @returns A boolean indicating if the notification is supported by the wallet.
+ */
+export const isSupportedNotification = (scopeString, notification) => {
+    const { namespace } = parseScopeString(scopeString);
+    if (namespace === KnownCaipNamespace.Eip155) {
+        return KnownNotifications[namespace].includes(notification);
+    }
+    return false;
+};
+//# sourceMappingURL=supported.mjs.map

package/dist/scope/supported.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"supported.mjs","sourceRoot":"","sources":["../../src/scope/supported.ts"],"names":[],"mappings":"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","sourcesContent":["import { toHex, isEqualCaseInsensitive } from '@metamask/controller-utils';\nimport type { CaipAccountId, CaipChainId, Hex } from '@metamask/utils';\nimport {\n  isCaipChainId,\n  KnownCaipNamespace,\n  parseCaipAccountId,\n} from '@metamask/utils';\n\nimport {\n  CaipReferenceRegexes,\n  KnownNotifications,\n  KnownRpcMethods,\n  KnownWalletNamespaceRpcMethods,\n  KnownWalletRpcMethods,\n} from './constants';\nimport type { ExternalScopeString } from './types';\nimport { parseScopeString } from './types';\n\n/**\n * Determines if a scope string is supported.\n *\n * @param scopeString - The scope string to check.\n * @param hooks - An object containing the following properties:\n * @param hooks.isEvmChainIdSupported - A predicate that determines if an EVM chainID is supported.\n * @param hooks.isNonEvmScopeSupported - A predicate that determines if an non EVM scopeString is supported.\n * @returns A boolean indicating if the scope string is supported.\n */\nexport const isSupportedScopeString = (\n  scopeString: string,\n  {\n    isEvmChainIdSupported,\n    isNonEvmScopeSupported,\n  }: {\n    isEvmChainIdSupported: (chainId: Hex) => boolean;\n    isNonEvmScopeSupported: (scope: CaipChainId) => boolean;\n  },\n) => {\n  const { namespace, reference } = parseScopeString(scopeString);\n\n  switch (namespace) {\n    case KnownCaipNamespace.Wallet:\n      if (\n        isCaipChainId(scopeString) &&\n        reference !== KnownCaipNamespace.Eip155\n      ) {\n        return isNonEvmScopeSupported(scopeString);\n      }\n      return true;\n    case KnownCaipNamespace.Eip155:\n      return (\n        !reference ||\n        (CaipReferenceRegexes.eip155.test(reference) &&\n          isEvmChainIdSupported(toHex(reference)))\n      );\n    default:\n      return isCaipChainId(scopeString)\n        ? isNonEvmScopeSupported(scopeString)\n        : false;\n  }\n};\n\n/**\n * Determines if an account is supported by the wallet (i.e. on a keyring known to the wallet).\n *\n * @param account - The CAIP account ID to check.\n * @param hooks - An object containing the following properties:\n * @param hooks.getEvmInternalAccounts - A function that returns the EVM internal accounts.\n * @param hooks.getNonEvmAccountAddresses - A function that returns the supported CAIP-10 account addresses for a non EVM scope.\n * @returns A boolean indicating if the account is supported by the wallet.\n */\nexport const isSupportedAccount = (\n  account: CaipAccountId,\n  {\n    getEvmInternalAccounts,\n    getNonEvmAccountAddresses,\n  }: {\n    getEvmInternalAccounts: () => { type: string; address: Hex }[];\n    getNonEvmAccountAddresses: (scope: CaipChainId) => string[];\n  },\n) => {\n  const {\n    address,\n    chainId,\n    chain: { namespace, reference },\n  } = parseCaipAccountId(account);\n\n  const isSupportedEip155Account = () =>\n    getEvmInternalAccounts().some(\n      (internalAccount) =>\n        ['eip155:eoa', 'eip155:erc4337'].includes(internalAccount.type) &&\n        isEqualCaseInsensitive(address, internalAccount.address),\n    );\n\n  const isSupportedNonEvmAccount = () =>\n    getNonEvmAccountAddresses(chainId).includes(account);\n\n  // We are trying to discern the type of `namespace`.\n  /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n  switch (namespace) {\n    case KnownCaipNamespace.Wallet:\n      if (reference === KnownCaipNamespace.Eip155) {\n        return isSupportedEip155Account();\n      }\n      return isSupportedNonEvmAccount();\n    case KnownCaipNamespace.Eip155:\n      return isSupportedEip155Account();\n    default:\n      return isSupportedNonEvmAccount();\n  }\n  /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */\n};\n\n/**\n * Determines if a method is supported by the wallet.\n *\n * @param scopeString - The scope string to check.\n * @param method - The method to check.\n * @param hooks - An object containing the following properties:\n * @param hooks.getNonEvmSupportedMethods - A function that returns the supported methods for a non EVM scope.\n * @returns A boolean indicating if the method is supported by the wallet.\n */\nexport const isSupportedMethod = (\n  scopeString: ExternalScopeString,\n  method: string,\n  {\n    getNonEvmSupportedMethods,\n  }: {\n    getNonEvmSupportedMethods: (scope: CaipChainId) => string[];\n  },\n): boolean => {\n  const { namespace, reference } = parseScopeString(scopeString);\n\n  if (!namespace) {\n    return false;\n  }\n\n  const isSupportedNonEvmMethod = () =>\n    isCaipChainId(scopeString) &&\n    getNonEvmSupportedMethods(scopeString).includes(method);\n\n  // We are trying to discern the type of `namespace`.\n  /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n  if (namespace === KnownCaipNamespace.Wallet) {\n    if (!reference) {\n      return KnownWalletRpcMethods.includes(method);\n    }\n\n    if (reference === KnownCaipNamespace.Eip155) {\n      return KnownWalletNamespaceRpcMethods[reference].includes(method);\n    }\n\n    return isSupportedNonEvmMethod();\n  }\n\n  if (namespace === KnownCaipNamespace.Eip155) {\n    return KnownRpcMethods[namespace].includes(method);\n  }\n  /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */\n\n  return isSupportedNonEvmMethod();\n};\n\n/**\n * Determines if a notification is supported by the wallet.\n *\n * @param scopeString - The scope string to check.\n * @param notification - The notification to check.\n * @returns A boolean indicating if the notification is supported by the wallet.\n */\nexport const isSupportedNotification = (\n  scopeString: ExternalScopeString,\n  notification: string,\n): boolean => {\n  const { namespace } = parseScopeString(scopeString);\n\n  if (namespace === KnownCaipNamespace.Eip155) {\n    return KnownNotifications[namespace].includes(notification);\n  }\n\n  return false;\n};\n"]}

package/dist/scope/transform.cjs

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAndMergeScopes = exports.mergeInternalScopes = exports.mergeNormalizedScopes = exports.mergeScopeObject = exports.normalizeScope = exports.getUniqueArrayItems = void 0;
+const lodash_1 = require("lodash");
+const types_1 = require("./types.cjs");
+/**
+ * Returns a list of unique items
+ *
+ * @param list - The list of items to filter
+ * @returns A list of unique items
+ */
+const getUniqueArrayItems = (list) => {
+    return Array.from(new Set(list));
+};
+exports.getUniqueArrayItems = getUniqueArrayItems;
+/**
+ * Normalizes a ScopeString and ExternalScopeObject into a separate
+ * InternalScopeString and NormalizedScopeObject for each reference in the `references`
+ * value if defined and adds an empty `accounts` array if not defined.
+ *
+ * @param scopeString - The string representing the scope
+ * @param externalScopeObject - The object that defines the scope
+ * @returns a map of caipChainId to ScopeObjects
+ */
+const normalizeScope = (scopeString, externalScopeObject) => {
+    const { references, ...scopeObject } = externalScopeObject;
+    const { namespace, reference } = (0, types_1.parseScopeString)(scopeString);
+    const normalizedScopeObject = {
+        accounts: [],
+        ...scopeObject,
+    };
+    const shouldFlatten = namespace &&
+        !reference &&
+        references !== undefined &&
+        references.length > 0;
+    if (shouldFlatten) {
+        return Object.fromEntries(references.map((ref) => [
+            `${namespace}:${ref}`,
+            (0, lodash_1.cloneDeep)(normalizedScopeObject),
+        ]));
+    }
+    return { [scopeString]: normalizedScopeObject };
+};
+exports.normalizeScope = normalizeScope;
+/**
+ * Merges two NormalizedScopeObjects
+ *
+ * @param scopeObjectA - The first scope object to merge.
+ * @param scopeObjectB - The second scope object to merge.
+ * @returns The merged scope object.
+ */
+const mergeScopeObject = (scopeObjectA, scopeObjectB) => {
+    const mergedScopeObject = {
+        methods: (0, exports.getUniqueArrayItems)([
+            ...scopeObjectA.methods,
+            ...scopeObjectB.methods,
+        ]),
+        notifications: (0, exports.getUniqueArrayItems)([
+            ...scopeObjectA.notifications,
+            ...scopeObjectB.notifications,
+        ]),
+        accounts: (0, exports.getUniqueArrayItems)([
+            ...scopeObjectA.accounts,
+            ...scopeObjectB.accounts,
+        ]),
+    };
+    if (scopeObjectA.rpcDocuments || scopeObjectB.rpcDocuments) {
+        mergedScopeObject.rpcDocuments = (0, exports.getUniqueArrayItems)([
+            ...(scopeObjectA.rpcDocuments ?? []),
+            ...(scopeObjectB.rpcDocuments ?? []),
+        ]);
+    }
+    if (scopeObjectA.rpcEndpoints || scopeObjectB.rpcEndpoints) {
+        mergedScopeObject.rpcEndpoints = (0, exports.getUniqueArrayItems)([
+            ...(scopeObjectA.rpcEndpoints ?? []),
+            ...(scopeObjectB.rpcEndpoints ?? []),
+        ]);
+    }
+    return mergedScopeObject;
+};
+exports.mergeScopeObject = mergeScopeObject;
+/**
+ * Merges two NormalizedScopeObjects
+ *
+ * @param scopeA - The first normalized scope object to merge.
+ * @param scopeB - The second normalized scope object to merge.
+ * @returns The merged normalized scope object from the [CAIP-25](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-25.md) request.
+ */
+const mergeNormalizedScopes = (scopeA, scopeB) => {
+    const scope = {};
+    Object.entries(scopeA).forEach(([_scopeString, scopeObjectA]) => {
+        // Cast needed because index type is returned as `string` by `Object.entries`
+        const scopeString = _scopeString;
+        const scopeObjectB = scopeB[scopeString];
+        scope[scopeString] = scopeObjectB
+            ? (0, exports.mergeScopeObject)(scopeObjectA, scopeObjectB)
+            : scopeObjectA;
+    });
+    Object.entries(scopeB).forEach(([_scopeString, scopeObjectB]) => {
+        // Cast needed because index type is returned as `string` by `Object.entries`
+        const scopeString = _scopeString;
+        const scopeObjectA = scopeA[scopeString];
+        if (!scopeObjectA) {
+            scope[scopeString] = scopeObjectB;
+        }
+    });
+    return scope;
+};
+exports.mergeNormalizedScopes = mergeNormalizedScopes;
+/**
+ * Merges two InternalScopeObjects
+ *
+ * @param scopeA - The first internal scope object to merge.
+ * @param scopeB - The second internal scope object to merge.
+ * @returns The merged internal scope object from the [CAIP-25](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-25.md) request.
+ */
+const mergeInternalScopes = (scopeA, scopeB) => {
+    const resultScope = (0, lodash_1.cloneDeep)(scopeA);
+    Object.entries(scopeB).forEach(([scopeString, rightScopeObject]) => {
+        const internalScopeString = scopeString;
+        const leftRequiredScopeObject = resultScope[internalScopeString];
+        if (!leftRequiredScopeObject) {
+            resultScope[internalScopeString] = rightScopeObject;
+        }
+        else {
+            resultScope[internalScopeString] = {
+                accounts: (0, exports.getUniqueArrayItems)([
+                    ...leftRequiredScopeObject.accounts,
+                    ...rightScopeObject.accounts,
+                ]),
+            };
+        }
+    });
+    return resultScope;
+};
+exports.mergeInternalScopes = mergeInternalScopes;
+/**
+ * Normalizes and merges a set of ExternalScopesObjects into a NormalizedScopesObject (i.e. a set of NormalizedScopeObjects where references are flattened).
+ *
+ * @param scopes - The external scopes to normalize and merge.
+ * @returns The normalized and merged scopes.
+ */
+const normalizeAndMergeScopes = (scopes) => {
+    let mergedScopes = {};
+    Object.keys(scopes).forEach((scopeString) => {
+        const normalizedScopes = (0, exports.normalizeScope)(scopeString, scopes[scopeString]);
+        mergedScopes = (0, exports.mergeNormalizedScopes)(mergedScopes, normalizedScopes);
+    });
+    return mergedScopes;
+};
+exports.normalizeAndMergeScopes = normalizeAndMergeScopes;
+//# sourceMappingURL=transform.cjs.map

package/dist/scope/transform.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.cjs","sourceRoot":"","sources":["../../src/scope/transform.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CaipReference } from '@metamask/utils';\nimport { cloneDeep } from 'lodash';\n\nimport type {\n  ExternalScopeObject,\n  ExternalScopesObject,\n  InternalScopesObject,\n  NormalizedScopeObject,\n  NormalizedScopesObject,\n} from './types';\nimport { parseScopeString } from './types';\n\n/**\n * Returns a list of unique items\n *\n * @param list - The list of items to filter\n * @returns A list of unique items\n */\nexport const getUniqueArrayItems = <Value>(list: Value[]): Value[] => {\n  return Array.from(new Set(list));\n};\n\n/**\n * Normalizes a ScopeString and ExternalScopeObject into a separate\n * InternalScopeString and NormalizedScopeObject for each reference in the `references`\n * value if defined and adds an empty `accounts` array if not defined.\n *\n * @param scopeString - The string representing the scope\n * @param externalScopeObject - The object that defines the scope\n * @returns a map of caipChainId to ScopeObjects\n */\nexport const normalizeScope = (\n  scopeString: string,\n  externalScopeObject: ExternalScopeObject,\n): NormalizedScopesObject => {\n  const { references, ...scopeObject } = externalScopeObject;\n  const { namespace, reference } = parseScopeString(scopeString);\n\n  const normalizedScopeObject: NormalizedScopeObject = {\n    accounts: [],\n    ...scopeObject,\n  };\n\n  const shouldFlatten =\n    namespace &&\n    !reference &&\n    references !== undefined &&\n    references.length > 0;\n\n  if (shouldFlatten) {\n    return Object.fromEntries(\n      references.map((ref: CaipReference) => [\n        `${namespace}:${ref}`,\n        cloneDeep(normalizedScopeObject),\n      ]),\n    );\n  }\n  return { [scopeString]: normalizedScopeObject };\n};\n\n/**\n * Merges two NormalizedScopeObjects\n *\n * @param scopeObjectA - The first scope object to merge.\n * @param scopeObjectB - The second scope object to merge.\n * @returns The merged scope object.\n */\nexport const mergeScopeObject = (\n  scopeObjectA: NormalizedScopeObject,\n  scopeObjectB: NormalizedScopeObject,\n) => {\n  const mergedScopeObject: NormalizedScopeObject = {\n    methods: getUniqueArrayItems([\n      ...scopeObjectA.methods,\n      ...scopeObjectB.methods,\n    ]),\n    notifications: getUniqueArrayItems([\n      ...scopeObjectA.notifications,\n      ...scopeObjectB.notifications,\n    ]),\n    accounts: getUniqueArrayItems([\n      ...scopeObjectA.accounts,\n      ...scopeObjectB.accounts,\n    ]),\n  };\n\n  if (scopeObjectA.rpcDocuments || scopeObjectB.rpcDocuments) {\n    mergedScopeObject.rpcDocuments = getUniqueArrayItems([\n      ...(scopeObjectA.rpcDocuments ?? []),\n      ...(scopeObjectB.rpcDocuments ?? []),\n    ]);\n  }\n\n  if (scopeObjectA.rpcEndpoints || scopeObjectB.rpcEndpoints) {\n    mergedScopeObject.rpcEndpoints = getUniqueArrayItems([\n      ...(scopeObjectA.rpcEndpoints ?? []),\n      ...(scopeObjectB.rpcEndpoints ?? []),\n    ]);\n  }\n\n  return mergedScopeObject;\n};\n\n/**\n * Merges two NormalizedScopeObjects\n *\n * @param scopeA - The first normalized scope object to merge.\n * @param scopeB - The second normalized scope object to merge.\n * @returns The merged normalized scope object from the [CAIP-25](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-25.md) request.\n */\nexport const mergeNormalizedScopes = (\n  scopeA: NormalizedScopesObject,\n  scopeB: NormalizedScopesObject,\n): NormalizedScopesObject => {\n  const scope: NormalizedScopesObject = {};\n\n  Object.entries(scopeA).forEach(([_scopeString, scopeObjectA]) => {\n    // Cast needed because index type is returned as `string` by `Object.entries`\n    const scopeString = _scopeString as keyof typeof scopeA;\n    const scopeObjectB = scopeB[scopeString];\n\n    scope[scopeString] = scopeObjectB\n      ? mergeScopeObject(scopeObjectA, scopeObjectB)\n      : scopeObjectA;\n  });\n\n  Object.entries(scopeB).forEach(([_scopeString, scopeObjectB]) => {\n    // Cast needed because index type is returned as `string` by `Object.entries`\n    const scopeString = _scopeString as keyof typeof scopeB;\n    const scopeObjectA = scopeA[scopeString];\n\n    if (!scopeObjectA) {\n      scope[scopeString] = scopeObjectB;\n    }\n  });\n\n  return scope;\n};\n\n/**\n * Merges two InternalScopeObjects\n *\n * @param scopeA - The first internal scope object to merge.\n * @param scopeB - The second internal scope object to merge.\n * @returns The merged internal scope object from the [CAIP-25](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-25.md) request.\n */\nexport const mergeInternalScopes = (\n  scopeA: InternalScopesObject,\n  scopeB: InternalScopesObject,\n): InternalScopesObject => {\n  const resultScope = cloneDeep(scopeA);\n\n  Object.entries(scopeB).forEach(([scopeString, rightScopeObject]) => {\n    const internalScopeString = scopeString as keyof typeof scopeB;\n    const leftRequiredScopeObject = resultScope[internalScopeString];\n    if (!leftRequiredScopeObject) {\n      resultScope[internalScopeString] = rightScopeObject;\n    } else {\n      resultScope[internalScopeString] = {\n        accounts: getUniqueArrayItems([\n          ...leftRequiredScopeObject.accounts,\n          ...rightScopeObject.accounts,\n        ]),\n      };\n    }\n  });\n\n  return resultScope;\n};\n\n/**\n * Normalizes and merges a set of ExternalScopesObjects into a NormalizedScopesObject (i.e. a set of NormalizedScopeObjects where references are flattened).\n *\n * @param scopes - The external scopes to normalize and merge.\n * @returns The normalized and merged scopes.\n */\nexport const normalizeAndMergeScopes = (\n  scopes: ExternalScopesObject,\n): NormalizedScopesObject => {\n  let mergedScopes: NormalizedScopesObject = {};\n  Object.keys(scopes).forEach((scopeString) => {\n    const normalizedScopes = normalizeScope(scopeString, scopes[scopeString]);\n    mergedScopes = mergeNormalizedScopes(mergedScopes, normalizedScopes);\n  });\n\n  return mergedScopes;\n};\n"]}