@metamask/snaps-rpc-methods 15.1.1 → 16.0.0

package/dist/permitted/listEntropySources.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"listEntropySources.cjs","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":";;;AAEA,qDAAsD;AAStD,uEAAuE;AACvE,2EAA2E;AAC3E,uEAAuE;AACvE,6DAA6D;AAG7D;;;GAGG;AACH,MAAM,oBAAoB,GAAG;IAC3B,wCAAsB,CAAC,UAAU;IACjC,4CAAwB,CAAC,UAAU;IACnC,wCAAsB,CAAC,UAAU;IACjC,8BAAiB,CAAC,UAAU;CAC7B,CAAC;AAEF,MAAM,UAAU,GAAG,yBAAyB,CAAC;AAE7C,MAAM,SAAS,GAA+C;IAC5D,aAAa,EAAE,IAAI;IACnB,iBAAiB,EAAE,IAAI;IACvB,gBAAgB,EAAE,IAAI;CACvB,CAAC;AA0BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACU,QAAA,yBAAyB,GAAG;IACvC,WAAW,EAAE,CAAC,UAAU,CAAU;IAClC,cAAc,EAAE,gCAAgC;IAChD,SAAS;CAKV,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,KAAK,UAAU,gCAAgC,CAC7C,QAAkD,EAClD,QAA0D,EAC1D,KAAc,EACd,GAA6B,EAC7B,EACE,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACQ;IAE1B,MAAM,WAAW,GAAG,oBAAoB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC7D,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,GAAG,CAAC,2BAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAE7B,QAAQ,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACtC,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { providerErrors } from '@metamask/rpc-errors';\nimport type {\n  EntropySource,\n  JsonRpcRequest,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult,\n} from '@metamask/snaps-sdk';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { getBip32EntropyBuilder } from '../restricted/getBip32Entropy';\nimport { getBip32PublicKeyBuilder } from '../restricted/getBip32PublicKey';\nimport { getBip44EntropyBuilder } from '../restricted/getBip44Entropy';\nimport { getEntropyBuilder } from '../restricted/getEntropy';\nimport type { MethodHooksObject } from '../utils';\n\n/**\n * A list of permissions that the requesting origin must have at least one of\n * in order to call this method.\n */\nconst REQUIRED_PERMISSIONS = [\n  getBip32EntropyBuilder.targetName,\n  getBip32PublicKeyBuilder.targetName,\n  getBip44EntropyBuilder.targetName,\n  getEntropyBuilder.targetName,\n];\n\nconst methodName = 'snap_listEntropySources';\n\nconst hookNames: MethodHooksObject<ListEntropySourcesHooks> = {\n  hasPermission: true,\n  getEntropySources: true,\n  getUnlockPromise: true,\n};\n\nexport type ListEntropySourcesHooks = {\n  /**\n   * Check if the requesting origin has a given permission.\n   *\n   * @param permissionName - The name of the permission to check.\n   * @returns Whether the origin has the permission.\n   */\n  hasPermission: (permissionName: string) => boolean;\n\n  /**\n   * Get the entropy sources from the client.\n   *\n   * @returns The entropy sources.\n   */\n  getEntropySources: () => EntropySource[];\n\n  /**\n   * Wait for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\n/**\n * Get a list of entropy sources available to the Snap. The requesting origin\n * must have at least one of the following permissions to access entropy source\n * metadata:\n *\n * - `snap_getBip32Entropy`\n * - `snap_getBip32PublicKey`\n * - `snap_getBip44Entropy`\n * - `snap_getEntropy`\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"snap_getBip32Entropy\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * const entropySources = await snap.request({ method: 'snap_listEntropySources' });\n * console.log(entropySources);\n * // Example output:\n * // [\n * //   {\n * //     name: 'Mnemonic 1',\n * //     id: 'mnemonic-1',\n * //     type: 'mnemonic',\n * //     primary: true,\n * //   },\n * //   {\n * //     name: 'Mnemonic 2',\n * //     id: 'mnemonic-2',\n * //     type: 'mnemonic',\n * //     primary: false,\n * //   },\n * // ]\n * ```\n */\nexport const listEntropySourcesHandler = {\n  methodNames: [methodName] as const,\n  implementation: listEntropySourcesImplementation,\n  hookNames,\n} satisfies PermittedHandlerExport<\n  ListEntropySourcesHooks,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult\n>;\n\n/**\n * The `snap_listEntropySources` method implementation.\n *\n * @param _request - The JSON-RPC request object. Not used by this function.\n * @param response - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.hasPermission - The function to check if the origin has a\n * permission.\n * @param hooks.getEntropySources - The function to get the entropy sources.\n * @param hooks.getUnlockPromise - The function to get the unlock promise.\n * @returns Noting.\n */\nasync function listEntropySourcesImplementation(\n  _request: JsonRpcRequest<ListEntropySourcesParams>,\n  response: PendingJsonRpcResponse<ListEntropySourcesResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  {\n    hasPermission,\n    getEntropySources,\n    getUnlockPromise,\n  }: ListEntropySourcesHooks,\n): Promise<void> {\n  const isPermitted = REQUIRED_PERMISSIONS.some(hasPermission);\n  if (!isPermitted) {\n    return end(providerErrors.unauthorized());\n  }\n\n  await getUnlockPromise(true);\n\n  response.result = getEntropySources();\n  return end();\n}\n"]}
+{"version":3,"file":"listEntropySources.cjs","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":";;;AAMA,qDAAsD;AAQtD,uEAAuE;AACvE,2EAA2E;AAC3E,uEAAuE;AACvE,6DAA6D;AAO7D;;;GAGG;AACH,MAAM,oBAAoB,GAAG;IAC3B,wCAAsB,CAAC,UAAU;IACjC,4CAAwB,CAAC,UAAU;IACnC,wCAAsB,CAAC,UAAU;IACjC,8BAAiB,CAAC,UAAU;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,eAAe,GAAG,aAAa,CAAC;AAEtC,MAAM,SAAS,GAAqD;IAClE,gBAAgB,EAAE,IAAI;CACvB,CAAC;AAeF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACU,QAAA,yBAAyB,GAAG;IACvC,cAAc,EAAE,gCAAgC;IAChD,SAAS;IACT,WAAW,EAAE;QACX,oCAAoC;QACpC,4BAA4B;KAC7B;CAOF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,KAAK,UAAU,gCAAgC,CAC7C,OAA2D,EAC3D,QAA0D,EAC1D,KAAc,EACd,GAA6B,EAC7B,EAAE,gBAAgB,EAAiC,EACnD,SAA6D;IAE7D,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAE3B,MAAM,WAAW,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAC3D,SAAS,CAAC,IAAI,CAAC,oCAAoC,EAAE,MAAM,EAAE,UAAU,CAAC,CACzE,CAAC;IAEF,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,GAAG,CAAC,2BAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAE7B,MAAM,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;IAElE,QAAQ,CAAC,MAAM,GAAG,QAAQ;SACvB,GAAG,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;QACtB,IAAI,OAAO,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;YACrC,OAAO;gBACL,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE;gBACvB,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAC3B,IAAI,EAAE,UAAU;gBAChB,OAAO,EAAE,KAAK,KAAK,CAAC;aACrB,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;SACD,MAAM,CAAC,CAAC,aAAa,EAAkC,EAAE,CACxD,OAAO,CAAC,aAAa,CAAC,CACvB,CAAC;IAEJ,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  MethodHandler,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport type { PermissionControllerHasPermissionAction } from '@metamask/permission-controller';\nimport { providerErrors } from '@metamask/rpc-errors';\nimport type {\n  EntropySource,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult,\n} from '@metamask/snaps-sdk';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { getBip32EntropyBuilder } from '../restricted/getBip32Entropy';\nimport { getBip32PublicKeyBuilder } from '../restricted/getBip32PublicKey';\nimport { getBip44EntropyBuilder } from '../restricted/getBip44Entropy';\nimport { getEntropyBuilder } from '../restricted/getEntropy';\nimport type {\n  JsonRpcRequestWithOrigin,\n  KeyringControllerGetStateAction,\n} from '../types';\nimport type { MethodHooksObject } from '../utils';\n\n/**\n * A list of permissions that the requesting origin must have at least one of\n * in order to call this method.\n */\nconst REQUIRED_PERMISSIONS = [\n  getBip32EntropyBuilder.targetName,\n  getBip32PublicKeyBuilder.targetName,\n  getBip44EntropyBuilder.targetName,\n  getEntropyBuilder.targetName,\n];\n\n/**\n * The keyring type used by HD (mnemonic-based) keyrings.\n */\nconst HD_KEYRING_TYPE = 'HD Key Tree';\n\nconst hookNames: MethodHooksObject<ListEntropySourcesMethodHooks> = {\n  getUnlockPromise: true,\n};\n\nexport type ListEntropySourcesMethodHooks = {\n  /**\n   * Wait for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\nexport type ListEntropySourcesMethodActions =\n  | PermissionControllerHasPermissionAction\n  | KeyringControllerGetStateAction;\n\n/**\n * Get a list of entropy sources available to the Snap. The requesting origin\n * must have at least one of the following permissions to access entropy source\n * metadata:\n *\n * - `snap_getBip32Entropy`\n * - `snap_getBip32PublicKey`\n * - `snap_getBip44Entropy`\n * - `snap_getEntropy`\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"snap_getBip32Entropy\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * const entropySources = await snap.request({ method: 'snap_listEntropySources' });\n * console.log(entropySources);\n * // Example output:\n * // [\n * //   {\n * //     name: 'Mnemonic 1',\n * //     id: 'mnemonic-1',\n * //     type: 'mnemonic',\n * //     primary: true,\n * //   },\n * //   {\n * //     name: 'Mnemonic 2',\n * //     id: 'mnemonic-2',\n * //     type: 'mnemonic',\n * //     primary: false,\n * //   },\n * // ]\n * ```\n */\nexport const listEntropySourcesHandler = {\n  implementation: listEntropySourcesImplementation,\n  hookNames,\n  actionNames: [\n    'PermissionController:hasPermission',\n    'KeyringController:getState',\n  ],\n} satisfies MethodHandler<\n  ListEntropySourcesMethodHooks,\n  ListEntropySourcesMethodActions,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult,\n  { origin: string }\n>;\n\n/**\n * The `snap_listEntropySources` method implementation.\n *\n * @param request - The JSON-RPC request object.\n * @param response - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.getUnlockPromise - The function to get the unlock promise.\n * @param messenger - The messenger used to call controller actions.\n * @returns Nothing.\n */\nasync function listEntropySourcesImplementation(\n  request: JsonRpcRequestWithOrigin<ListEntropySourcesParams>,\n  response: PendingJsonRpcResponse<ListEntropySourcesResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getUnlockPromise }: ListEntropySourcesMethodHooks,\n  messenger: Messenger<string, ListEntropySourcesMethodActions>,\n): Promise<void> {\n  const { origin } = request;\n\n  const isPermitted = REQUIRED_PERMISSIONS.some((permission) =>\n    messenger.call('PermissionController:hasPermission', origin, permission),\n  );\n\n  if (!isPermitted) {\n    return end(providerErrors.unauthorized());\n  }\n\n  await getUnlockPromise(true);\n\n  const { keyrings } = messenger.call('KeyringController:getState');\n\n  response.result = keyrings\n    .map((keyring, index) => {\n      if (keyring.type === HD_KEYRING_TYPE) {\n        return {\n          id: keyring.metadata.id,\n          name: keyring.metadata.name,\n          type: 'mnemonic',\n          primary: index === 0,\n        };\n      }\n\n      return null;\n    })\n    .filter((entropySource): entropySource is EntropySource =>\n      Boolean(entropySource),\n    );\n\n  return end();\n}\n"]}

package/dist/permitted/listEntropySources.d.cts

@@ -1,21 +1,11 @@
 import type { JsonRpcEngineEndCallback } from "@metamask/json-rpc-engine";
-import type { EntropySource, JsonRpcRequest, ListEntropySourcesParams, ListEntropySourcesResult } from "@metamask/snaps-sdk";
+import type { Messenger } from "@metamask/messenger";
+import type { PermissionControllerHasPermissionAction } from "@metamask/permission-controller";
+import type { ListEntropySourcesParams, ListEntropySourcesResult } from "@metamask/snaps-sdk";
 import type { PendingJsonRpcResponse } from "@metamask/utils";
+import type { JsonRpcRequestWithOrigin, KeyringControllerGetStateAction } from "../types.cjs";
 import type { MethodHooksObject } from "../utils.cjs";
-export type ListEntropySourcesHooks = {
-    /**
-     * Check if the requesting origin has a given permission.
-     *
-     * @param permissionName - The name of the permission to check.
-     * @returns Whether the origin has the permission.
-     */
-    hasPermission: (permissionName: string) => boolean;
-    /**
-     * Get the entropy sources from the client.
-     *
-     * @returns The entropy sources.
-     */
-    getEntropySources: () => EntropySource[];
+export type ListEntropySourcesMethodHooks = {
     /**
      * Wait for the extension to be unlocked.
      *
@@ -23,6 +13,7 @@ export type ListEntropySourcesHooks = {
      */
     getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;
 };
+export type ListEntropySourcesMethodActions = PermissionControllerHasPermissionAction | KeyringControllerGetStateAction;
 /**
  * Get a list of entropy sources available to the Snap. The requesting origin
  * must have at least one of the following permissions to access entropy source
@@ -62,25 +53,23 @@ export type ListEntropySourcesHooks = {
  * ```
  */
 export declare const listEntropySourcesHandler: {
-    methodNames: ["snap_listEntropySources"];
     implementation: typeof listEntropySourcesImplementation;
-    hookNames: MethodHooksObject<ListEntropySourcesHooks>;
+    hookNames: MethodHooksObject<ListEntropySourcesMethodHooks>;
+    actionNames: ("KeyringController:getState" | "PermissionController:hasPermission")[];
 };
 /**
  * The `snap_listEntropySources` method implementation.
  *
- * @param _request - The JSON-RPC request object. Not used by this function.
+ * @param request - The JSON-RPC request object.
  * @param response - The JSON-RPC response object.
  * @param _next - The `json-rpc-engine` "next" callback. Not used by this
  * function.
  * @param end - The `json-rpc-engine` "end" callback.
  * @param hooks - The RPC method hooks.
- * @param hooks.hasPermission - The function to check if the origin has a
- * permission.
- * @param hooks.getEntropySources - The function to get the entropy sources.
  * @param hooks.getUnlockPromise - The function to get the unlock promise.
- * @returns Noting.
+ * @param messenger - The messenger used to call controller actions.
+ * @returns Nothing.
  */
-declare function listEntropySourcesImplementation(_request: JsonRpcRequest<ListEntropySourcesParams>, response: PendingJsonRpcResponse<ListEntropySourcesResult>, _next: unknown, end: JsonRpcEngineEndCallback, { hasPermission, getEntropySources, getUnlockPromise, }: ListEntropySourcesHooks): Promise<void>;
+declare function listEntropySourcesImplementation(request: JsonRpcRequestWithOrigin<ListEntropySourcesParams>, response: PendingJsonRpcResponse<ListEntropySourcesResult>, _next: unknown, end: JsonRpcEngineEndCallback, { getUnlockPromise }: ListEntropySourcesMethodHooks, messenger: Messenger<string, ListEntropySourcesMethodActions>): Promise<void>;
 export {};
 //# sourceMappingURL=listEntropySources.d.cts.map

package/dist/permitted/listEntropySources.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"listEntropySources.d.cts","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,kCAAkC;AAG1E,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACzB,4BAA4B;AAC7B,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAM9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAiB;AAqBlD,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;;;OAKG;IACH,aAAa,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IAEnD;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,aAAa,EAAE,CAAC;IAEzC;;;;OAIG;IACH,gBAAgB,EAAE,CAAC,uBAAuB,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,yBAAyB;;;;CAQrC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,iBAAe,gCAAgC,CAC7C,QAAQ,EAAE,cAAc,CAAC,wBAAwB,CAAC,EAClD,QAAQ,EAAE,sBAAsB,CAAC,wBAAwB,CAAC,EAC1D,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,EACE,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACjB,EAAE,uBAAuB,GACzB,OAAO,CAAC,IAAI,CAAC,CAUf"}
+{"version":3,"file":"listEntropySources.d.cts","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EAEzB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AACrD,OAAO,KAAK,EAAE,uCAAuC,EAAE,wCAAwC;AAE/F,OAAO,KAAK,EAEV,wBAAwB,EACxB,wBAAwB,EACzB,4BAA4B;AAC7B,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAM9D,OAAO,KAAK,EACV,wBAAwB,EACxB,+BAA+B,EAChC,qBAAiB;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAiB;AAsBlD,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;;;OAIG;IACH,gBAAgB,EAAE,CAAC,uBAAuB,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE,CAAC;AAEF,MAAM,MAAM,+BAA+B,GACvC,uCAAuC,GACvC,+BAA+B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,yBAAyB;;;;CAarC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,iBAAe,gCAAgC,CAC7C,OAAO,EAAE,wBAAwB,CAAC,wBAAwB,CAAC,EAC3D,QAAQ,EAAE,sBAAsB,CAAC,wBAAwB,CAAC,EAC1D,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,EAAE,gBAAgB,EAAE,EAAE,6BAA6B,EACnD,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,+BAA+B,CAAC,GAC5D,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/dist/permitted/listEntropySources.d.mts

@@ -1,21 +1,11 @@
 import type { JsonRpcEngineEndCallback } from "@metamask/json-rpc-engine";
-import type { EntropySource, JsonRpcRequest, ListEntropySourcesParams, ListEntropySourcesResult } from "@metamask/snaps-sdk";
+import type { Messenger } from "@metamask/messenger";
+import type { PermissionControllerHasPermissionAction } from "@metamask/permission-controller";
+import type { ListEntropySourcesParams, ListEntropySourcesResult } from "@metamask/snaps-sdk";
 import type { PendingJsonRpcResponse } from "@metamask/utils";
+import type { JsonRpcRequestWithOrigin, KeyringControllerGetStateAction } from "../types.mjs";
 import type { MethodHooksObject } from "../utils.mjs";
-export type ListEntropySourcesHooks = {
-    /**
-     * Check if the requesting origin has a given permission.
-     *
-     * @param permissionName - The name of the permission to check.
-     * @returns Whether the origin has the permission.
-     */
-    hasPermission: (permissionName: string) => boolean;
-    /**
-     * Get the entropy sources from the client.
-     *
-     * @returns The entropy sources.
-     */
-    getEntropySources: () => EntropySource[];
+export type ListEntropySourcesMethodHooks = {
     /**
      * Wait for the extension to be unlocked.
      *
@@ -23,6 +13,7 @@ export type ListEntropySourcesHooks = {
      */
     getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;
 };
+export type ListEntropySourcesMethodActions = PermissionControllerHasPermissionAction | KeyringControllerGetStateAction;
 /**
  * Get a list of entropy sources available to the Snap. The requesting origin
  * must have at least one of the following permissions to access entropy source
@@ -62,25 +53,23 @@ export type ListEntropySourcesHooks = {
  * ```
  */
 export declare const listEntropySourcesHandler: {
-    methodNames: ["snap_listEntropySources"];
     implementation: typeof listEntropySourcesImplementation;
-    hookNames: MethodHooksObject<ListEntropySourcesHooks>;
+    hookNames: MethodHooksObject<ListEntropySourcesMethodHooks>;
+    actionNames: ("KeyringController:getState" | "PermissionController:hasPermission")[];
 };
 /**
  * The `snap_listEntropySources` method implementation.
  *
- * @param _request - The JSON-RPC request object. Not used by this function.
+ * @param request - The JSON-RPC request object.
  * @param response - The JSON-RPC response object.
  * @param _next - The `json-rpc-engine` "next" callback. Not used by this
  * function.
  * @param end - The `json-rpc-engine` "end" callback.
  * @param hooks - The RPC method hooks.
- * @param hooks.hasPermission - The function to check if the origin has a
- * permission.
- * @param hooks.getEntropySources - The function to get the entropy sources.
  * @param hooks.getUnlockPromise - The function to get the unlock promise.
- * @returns Noting.
+ * @param messenger - The messenger used to call controller actions.
+ * @returns Nothing.
  */
-declare function listEntropySourcesImplementation(_request: JsonRpcRequest<ListEntropySourcesParams>, response: PendingJsonRpcResponse<ListEntropySourcesResult>, _next: unknown, end: JsonRpcEngineEndCallback, { hasPermission, getEntropySources, getUnlockPromise, }: ListEntropySourcesHooks): Promise<void>;
+declare function listEntropySourcesImplementation(request: JsonRpcRequestWithOrigin<ListEntropySourcesParams>, response: PendingJsonRpcResponse<ListEntropySourcesResult>, _next: unknown, end: JsonRpcEngineEndCallback, { getUnlockPromise }: ListEntropySourcesMethodHooks, messenger: Messenger<string, ListEntropySourcesMethodActions>): Promise<void>;
 export {};
 //# sourceMappingURL=listEntropySources.d.mts.map

package/dist/permitted/listEntropySources.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"listEntropySources.d.mts","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,kCAAkC;AAG1E,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACzB,4BAA4B;AAC7B,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAM9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAiB;AAqBlD,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;;;OAKG;IACH,aAAa,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IAEnD;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,aAAa,EAAE,CAAC;IAEzC;;;;OAIG;IACH,gBAAgB,EAAE,CAAC,uBAAuB,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,yBAAyB;;;;CAQrC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,iBAAe,gCAAgC,CAC7C,QAAQ,EAAE,cAAc,CAAC,wBAAwB,CAAC,EAClD,QAAQ,EAAE,sBAAsB,CAAC,wBAAwB,CAAC,EAC1D,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,EACE,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACjB,EAAE,uBAAuB,GACzB,OAAO,CAAC,IAAI,CAAC,CAUf"}
+{"version":3,"file":"listEntropySources.d.mts","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EAEzB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AACrD,OAAO,KAAK,EAAE,uCAAuC,EAAE,wCAAwC;AAE/F,OAAO,KAAK,EAEV,wBAAwB,EACxB,wBAAwB,EACzB,4BAA4B;AAC7B,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAM9D,OAAO,KAAK,EACV,wBAAwB,EACxB,+BAA+B,EAChC,qBAAiB;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAiB;AAsBlD,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;;;OAIG;IACH,gBAAgB,EAAE,CAAC,uBAAuB,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE,CAAC;AAEF,MAAM,MAAM,+BAA+B,GACvC,uCAAuC,GACvC,+BAA+B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,yBAAyB;;;;CAarC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,iBAAe,gCAAgC,CAC7C,OAAO,EAAE,wBAAwB,CAAC,wBAAwB,CAAC,EAC3D,QAAQ,EAAE,sBAAsB,CAAC,wBAAwB,CAAC,EAC1D,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,wBAAwB,EAC7B,EAAE,gBAAgB,EAAE,EAAE,6BAA6B,EACnD,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,+BAA+B,CAAC,GAC5D,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/dist/permitted/listEntropySources.mjs

@@ -13,10 +13,11 @@ const REQUIRED_PERMISSIONS = [
     getBip44EntropyBuilder.targetName,
     getEntropyBuilder.targetName,
 ];
-const methodName = 'snap_listEntropySources';
+/**
+ * The keyring type used by HD (mnemonic-based) keyrings.
+ */
+const HD_KEYRING_TYPE = 'HD Key Tree';
 const hookNames = {
-    hasPermission: true,
-    getEntropySources: true,
     getUnlockPromise: true,
 };
 /**
@@ -58,32 +59,47 @@ const hookNames = {
  * ```
  */
 export const listEntropySourcesHandler = {
-    methodNames: [methodName],
     implementation: listEntropySourcesImplementation,
     hookNames,
+    actionNames: [
+        'PermissionController:hasPermission',
+        'KeyringController:getState',
+    ],
 };
 /**
  * The `snap_listEntropySources` method implementation.
  *
- * @param _request - The JSON-RPC request object. Not used by this function.
+ * @param request - The JSON-RPC request object.
  * @param response - The JSON-RPC response object.
  * @param _next - The `json-rpc-engine` "next" callback. Not used by this
  * function.
  * @param end - The `json-rpc-engine` "end" callback.
  * @param hooks - The RPC method hooks.
- * @param hooks.hasPermission - The function to check if the origin has a
- * permission.
- * @param hooks.getEntropySources - The function to get the entropy sources.
  * @param hooks.getUnlockPromise - The function to get the unlock promise.
- * @returns Noting.
+ * @param messenger - The messenger used to call controller actions.
+ * @returns Nothing.
  */
-async function listEntropySourcesImplementation(_request, response, _next, end, { hasPermission, getEntropySources, getUnlockPromise, }) {
-    const isPermitted = REQUIRED_PERMISSIONS.some(hasPermission);
+async function listEntropySourcesImplementation(request, response, _next, end, { getUnlockPromise }, messenger) {
+    const { origin } = request;
+    const isPermitted = REQUIRED_PERMISSIONS.some((permission) => messenger.call('PermissionController:hasPermission', origin, permission));
     if (!isPermitted) {
         return end(providerErrors.unauthorized());
     }
     await getUnlockPromise(true);
-    response.result = getEntropySources();
+    const { keyrings } = messenger.call('KeyringController:getState');
+    response.result = keyrings
+        .map((keyring, index) => {
+        if (keyring.type === HD_KEYRING_TYPE) {
+            return {
+                id: keyring.metadata.id,
+                name: keyring.metadata.name,
+                type: 'mnemonic',
+                primary: index === 0,
+            };
+        }
+        return null;
+    })
+        .filter((entropySource) => Boolean(entropySource));
     return end();
 }
 //# sourceMappingURL=listEntropySources.mjs.map

package/dist/permitted/listEntropySources.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"listEntropySources.mjs","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,6BAA6B;AAStD,OAAO,EAAE,sBAAsB,EAAE,0CAAsC;AACvE,OAAO,EAAE,wBAAwB,EAAE,4CAAwC;AAC3E,OAAO,EAAE,sBAAsB,EAAE,0CAAsC;AACvE,OAAO,EAAE,iBAAiB,EAAE,qCAAiC;AAG7D;;;GAGG;AACH,MAAM,oBAAoB,GAAG;IAC3B,sBAAsB,CAAC,UAAU;IACjC,wBAAwB,CAAC,UAAU;IACnC,sBAAsB,CAAC,UAAU;IACjC,iBAAiB,CAAC,UAAU;CAC7B,CAAC;AAEF,MAAM,UAAU,GAAG,yBAAyB,CAAC;AAE7C,MAAM,SAAS,GAA+C;IAC5D,aAAa,EAAE,IAAI;IACnB,iBAAiB,EAAE,IAAI;IACvB,gBAAgB,EAAE,IAAI;CACvB,CAAC;AA0BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,WAAW,EAAE,CAAC,UAAU,CAAU;IAClC,cAAc,EAAE,gCAAgC;IAChD,SAAS;CAKV,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,KAAK,UAAU,gCAAgC,CAC7C,QAAkD,EAClD,QAA0D,EAC1D,KAAc,EACd,GAA6B,EAC7B,EACE,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACQ;IAE1B,MAAM,WAAW,GAAG,oBAAoB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC7D,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,GAAG,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAE7B,QAAQ,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACtC,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { providerErrors } from '@metamask/rpc-errors';\nimport type {\n  EntropySource,\n  JsonRpcRequest,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult,\n} from '@metamask/snaps-sdk';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { getBip32EntropyBuilder } from '../restricted/getBip32Entropy';\nimport { getBip32PublicKeyBuilder } from '../restricted/getBip32PublicKey';\nimport { getBip44EntropyBuilder } from '../restricted/getBip44Entropy';\nimport { getEntropyBuilder } from '../restricted/getEntropy';\nimport type { MethodHooksObject } from '../utils';\n\n/**\n * A list of permissions that the requesting origin must have at least one of\n * in order to call this method.\n */\nconst REQUIRED_PERMISSIONS = [\n  getBip32EntropyBuilder.targetName,\n  getBip32PublicKeyBuilder.targetName,\n  getBip44EntropyBuilder.targetName,\n  getEntropyBuilder.targetName,\n];\n\nconst methodName = 'snap_listEntropySources';\n\nconst hookNames: MethodHooksObject<ListEntropySourcesHooks> = {\n  hasPermission: true,\n  getEntropySources: true,\n  getUnlockPromise: true,\n};\n\nexport type ListEntropySourcesHooks = {\n  /**\n   * Check if the requesting origin has a given permission.\n   *\n   * @param permissionName - The name of the permission to check.\n   * @returns Whether the origin has the permission.\n   */\n  hasPermission: (permissionName: string) => boolean;\n\n  /**\n   * Get the entropy sources from the client.\n   *\n   * @returns The entropy sources.\n   */\n  getEntropySources: () => EntropySource[];\n\n  /**\n   * Wait for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\n/**\n * Get a list of entropy sources available to the Snap. The requesting origin\n * must have at least one of the following permissions to access entropy source\n * metadata:\n *\n * - `snap_getBip32Entropy`\n * - `snap_getBip32PublicKey`\n * - `snap_getBip44Entropy`\n * - `snap_getEntropy`\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"snap_getBip32Entropy\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * const entropySources = await snap.request({ method: 'snap_listEntropySources' });\n * console.log(entropySources);\n * // Example output:\n * // [\n * //   {\n * //     name: 'Mnemonic 1',\n * //     id: 'mnemonic-1',\n * //     type: 'mnemonic',\n * //     primary: true,\n * //   },\n * //   {\n * //     name: 'Mnemonic 2',\n * //     id: 'mnemonic-2',\n * //     type: 'mnemonic',\n * //     primary: false,\n * //   },\n * // ]\n * ```\n */\nexport const listEntropySourcesHandler = {\n  methodNames: [methodName] as const,\n  implementation: listEntropySourcesImplementation,\n  hookNames,\n} satisfies PermittedHandlerExport<\n  ListEntropySourcesHooks,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult\n>;\n\n/**\n * The `snap_listEntropySources` method implementation.\n *\n * @param _request - The JSON-RPC request object. Not used by this function.\n * @param response - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.hasPermission - The function to check if the origin has a\n * permission.\n * @param hooks.getEntropySources - The function to get the entropy sources.\n * @param hooks.getUnlockPromise - The function to get the unlock promise.\n * @returns Noting.\n */\nasync function listEntropySourcesImplementation(\n  _request: JsonRpcRequest<ListEntropySourcesParams>,\n  response: PendingJsonRpcResponse<ListEntropySourcesResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  {\n    hasPermission,\n    getEntropySources,\n    getUnlockPromise,\n  }: ListEntropySourcesHooks,\n): Promise<void> {\n  const isPermitted = REQUIRED_PERMISSIONS.some(hasPermission);\n  if (!isPermitted) {\n    return end(providerErrors.unauthorized());\n  }\n\n  await getUnlockPromise(true);\n\n  response.result = getEntropySources();\n  return end();\n}\n"]}
+{"version":3,"file":"listEntropySources.mjs","sourceRoot":"","sources":["../../src/permitted/listEntropySources.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,6BAA6B;AAQtD,OAAO,EAAE,sBAAsB,EAAE,0CAAsC;AACvE,OAAO,EAAE,wBAAwB,EAAE,4CAAwC;AAC3E,OAAO,EAAE,sBAAsB,EAAE,0CAAsC;AACvE,OAAO,EAAE,iBAAiB,EAAE,qCAAiC;AAO7D;;;GAGG;AACH,MAAM,oBAAoB,GAAG;IAC3B,sBAAsB,CAAC,UAAU;IACjC,wBAAwB,CAAC,UAAU;IACnC,sBAAsB,CAAC,UAAU;IACjC,iBAAiB,CAAC,UAAU;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,eAAe,GAAG,aAAa,CAAC;AAEtC,MAAM,SAAS,GAAqD;IAClE,gBAAgB,EAAE,IAAI;CACvB,CAAC;AAeF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,cAAc,EAAE,gCAAgC;IAChD,SAAS;IACT,WAAW,EAAE;QACX,oCAAoC;QACpC,4BAA4B;KAC7B;CAOF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,KAAK,UAAU,gCAAgC,CAC7C,OAA2D,EAC3D,QAA0D,EAC1D,KAAc,EACd,GAA6B,EAC7B,EAAE,gBAAgB,EAAiC,EACnD,SAA6D;IAE7D,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAE3B,MAAM,WAAW,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAC3D,SAAS,CAAC,IAAI,CAAC,oCAAoC,EAAE,MAAM,EAAE,UAAU,CAAC,CACzE,CAAC;IAEF,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,GAAG,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAE7B,MAAM,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;IAElE,QAAQ,CAAC,MAAM,GAAG,QAAQ;SACvB,GAAG,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;QACtB,IAAI,OAAO,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;YACrC,OAAO;gBACL,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE;gBACvB,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAC3B,IAAI,EAAE,UAAU;gBAChB,OAAO,EAAE,KAAK,KAAK,CAAC;aACrB,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;SACD,MAAM,CAAC,CAAC,aAAa,EAAkC,EAAE,CACxD,OAAO,CAAC,aAAa,CAAC,CACvB,CAAC;IAEJ,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  MethodHandler,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport type { PermissionControllerHasPermissionAction } from '@metamask/permission-controller';\nimport { providerErrors } from '@metamask/rpc-errors';\nimport type {\n  EntropySource,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult,\n} from '@metamask/snaps-sdk';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { getBip32EntropyBuilder } from '../restricted/getBip32Entropy';\nimport { getBip32PublicKeyBuilder } from '../restricted/getBip32PublicKey';\nimport { getBip44EntropyBuilder } from '../restricted/getBip44Entropy';\nimport { getEntropyBuilder } from '../restricted/getEntropy';\nimport type {\n  JsonRpcRequestWithOrigin,\n  KeyringControllerGetStateAction,\n} from '../types';\nimport type { MethodHooksObject } from '../utils';\n\n/**\n * A list of permissions that the requesting origin must have at least one of\n * in order to call this method.\n */\nconst REQUIRED_PERMISSIONS = [\n  getBip32EntropyBuilder.targetName,\n  getBip32PublicKeyBuilder.targetName,\n  getBip44EntropyBuilder.targetName,\n  getEntropyBuilder.targetName,\n];\n\n/**\n * The keyring type used by HD (mnemonic-based) keyrings.\n */\nconst HD_KEYRING_TYPE = 'HD Key Tree';\n\nconst hookNames: MethodHooksObject<ListEntropySourcesMethodHooks> = {\n  getUnlockPromise: true,\n};\n\nexport type ListEntropySourcesMethodHooks = {\n  /**\n   * Wait for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\nexport type ListEntropySourcesMethodActions =\n  | PermissionControllerHasPermissionAction\n  | KeyringControllerGetStateAction;\n\n/**\n * Get a list of entropy sources available to the Snap. The requesting origin\n * must have at least one of the following permissions to access entropy source\n * metadata:\n *\n * - `snap_getBip32Entropy`\n * - `snap_getBip32PublicKey`\n * - `snap_getBip44Entropy`\n * - `snap_getEntropy`\n *\n * @example\n * ```json name=\"Manifest\"\n * {\n *   \"initialPermissions\": {\n *     \"snap_getBip32Entropy\": {}\n *   }\n * }\n * ```\n * ```ts name=\"Usage\"\n * const entropySources = await snap.request({ method: 'snap_listEntropySources' });\n * console.log(entropySources);\n * // Example output:\n * // [\n * //   {\n * //     name: 'Mnemonic 1',\n * //     id: 'mnemonic-1',\n * //     type: 'mnemonic',\n * //     primary: true,\n * //   },\n * //   {\n * //     name: 'Mnemonic 2',\n * //     id: 'mnemonic-2',\n * //     type: 'mnemonic',\n * //     primary: false,\n * //   },\n * // ]\n * ```\n */\nexport const listEntropySourcesHandler = {\n  implementation: listEntropySourcesImplementation,\n  hookNames,\n  actionNames: [\n    'PermissionController:hasPermission',\n    'KeyringController:getState',\n  ],\n} satisfies MethodHandler<\n  ListEntropySourcesMethodHooks,\n  ListEntropySourcesMethodActions,\n  ListEntropySourcesParams,\n  ListEntropySourcesResult,\n  { origin: string }\n>;\n\n/**\n * The `snap_listEntropySources` method implementation.\n *\n * @param request - The JSON-RPC request object.\n * @param response - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.getUnlockPromise - The function to get the unlock promise.\n * @param messenger - The messenger used to call controller actions.\n * @returns Nothing.\n */\nasync function listEntropySourcesImplementation(\n  request: JsonRpcRequestWithOrigin<ListEntropySourcesParams>,\n  response: PendingJsonRpcResponse<ListEntropySourcesResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getUnlockPromise }: ListEntropySourcesMethodHooks,\n  messenger: Messenger<string, ListEntropySourcesMethodActions>,\n): Promise<void> {\n  const { origin } = request;\n\n  const isPermitted = REQUIRED_PERMISSIONS.some((permission) =>\n    messenger.call('PermissionController:hasPermission', origin, permission),\n  );\n\n  if (!isPermitted) {\n    return end(providerErrors.unauthorized());\n  }\n\n  await getUnlockPromise(true);\n\n  const { keyrings } = messenger.call('KeyringController:getState');\n\n  response.result = keyrings\n    .map((keyring, index) => {\n      if (keyring.type === HD_KEYRING_TYPE) {\n        return {\n          id: keyring.metadata.id,\n          name: keyring.metadata.name,\n          type: 'mnemonic',\n          primary: index === 0,\n        };\n      }\n\n      return null;\n    })\n    .filter((entropySource): entropySource is EntropySource =>\n      Boolean(entropySource),\n    );\n\n  return end();\n}\n"]}

package/dist/permitted/middleware.cjs

@@ -1,39 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSnapsMethodMiddleware = void 0;
+const json_rpc_engine_1 = require("@metamask/json-rpc-engine");
 const rpc_errors_1 = require("@metamask/rpc-errors");
 const snaps_utils_1 = require("@metamask/snaps-utils");
-const handlers_1 = require("./handlers.cjs");
-const utils_1 = require("../utils.cjs");
+const cancelBackgroundEvent_1 = require("./cancelBackgroundEvent.cjs");
+const clearState_1 = require("./clearState.cjs");
+const closeWebSocket_1 = require("./closeWebSocket.cjs");
+const createInterface_1 = require("./createInterface.cjs");
+const endTrace_1 = require("./endTrace.cjs");
+const getAllSnaps_1 = require("./getAllSnaps.cjs");
+const getBackgroundEvents_1 = require("./getBackgroundEvents.cjs");
+const getClientStatus_1 = require("./getClientStatus.cjs");
+const getFile_1 = require("./getFile.cjs");
+const getInterfaceContext_1 = require("./getInterfaceContext.cjs");
+const getInterfaceState_1 = require("./getInterfaceState.cjs");
+const getSnaps_1 = require("./getSnaps.cjs");
+const getState_1 = require("./getState.cjs");
+const getWebSockets_1 = require("./getWebSockets.cjs");
+const invokeKeyring_1 = require("./invokeKeyring.cjs");
+const invokeSnapSugar_1 = require("./invokeSnapSugar.cjs");
+const listEntropySources_1 = require("./listEntropySources.cjs");
+const openWebSocket_1 = require("./openWebSocket.cjs");
+const requestSnaps_1 = require("./requestSnaps.cjs");
+const resolveInterface_1 = require("./resolveInterface.cjs");
+const scheduleBackgroundEvent_1 = require("./scheduleBackgroundEvent.cjs");
+const sendWebSocketMessage_1 = require("./sendWebSocketMessage.cjs");
+const setState_1 = require("./setState.cjs");
+const startTrace_1 = require("./startTrace.cjs");
+const trackError_1 = require("./trackError.cjs");
+const trackEvent_1 = require("./trackEvent.cjs");
+const updateInterface_1 = require("./updateInterface.cjs");
+/* eslint-disable @typescript-eslint/naming-convention */
+const methodHandlers = {
+    wallet_getAllSnaps: getAllSnaps_1.getAllSnapsHandler,
+    wallet_getSnaps: getSnaps_1.getSnapsHandler,
+    wallet_requestSnaps: requestSnaps_1.requestSnapsHandler,
+    wallet_invokeSnap: invokeSnapSugar_1.invokeSnapSugarHandler,
+    wallet_invokeKeyring: invokeKeyring_1.invokeKeyringHandler,
+    snap_clearState: clearState_1.clearStateHandler,
+    snap_getClientStatus: getClientStatus_1.getClientStatusHandler,
+    snap_getFile: getFile_1.getFileHandler,
+    snap_getState: getState_1.getStateHandler,
+    snap_createInterface: createInterface_1.createInterfaceHandler,
+    snap_updateInterface: updateInterface_1.updateInterfaceHandler,
+    snap_getInterfaceState: getInterfaceState_1.getInterfaceStateHandler,
+    snap_getInterfaceContext: getInterfaceContext_1.getInterfaceContextHandler,
+    snap_listEntropySources: listEntropySources_1.listEntropySourcesHandler,
+    snap_resolveInterface: resolveInterface_1.resolveInterfaceHandler,
+    snap_scheduleBackgroundEvent: scheduleBackgroundEvent_1.scheduleBackgroundEventHandler,
+    snap_cancelBackgroundEvent: cancelBackgroundEvent_1.cancelBackgroundEventHandler,
+    snap_getBackgroundEvents: getBackgroundEvents_1.getBackgroundEventsHandler,
+    snap_setState: setState_1.setStateHandler,
+    snap_trackError: trackError_1.trackErrorHandler,
+    snap_trackEvent: trackEvent_1.trackEventHandler,
+    snap_openWebSocket: openWebSocket_1.openWebSocketHandler,
+    snap_closeWebSocket: closeWebSocket_1.closeWebSocketHandler,
+    snap_sendWebSocketMessage: sendWebSocketMessage_1.sendWebSocketMessageHandler,
+    snap_getWebSockets: getWebSockets_1.getWebSocketsHandler,
+    snap_startTrace: startTrace_1.startTraceHandler,
+    snap_endTrace: endTrace_1.endTraceHandler,
+};
+/* eslint-enable @typescript-eslint/naming-convention */
 /**
  * Creates a middleware that handles permitted snap RPC methods.
  *
  * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.
  * @param hooks - An object containing the hooks made available to the permitted RPC methods.
+ * @param messenger - The messenger.
  * @returns The middleware.
  */
-function createSnapsMethodMiddleware(isSnap, hooks) {
+function createSnapsMethodMiddleware(isSnap, hooks, messenger) {
+    const nestedMiddleware = (0, json_rpc_engine_1.createMethodMiddleware)({
+        handlers: methodHandlers,
+        hooks,
+        messenger,
+        onError: snaps_utils_1.logError,
+    });
     // This is not actually a misused promise, the type is just wrong
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     return async function methodMiddleware(request, response, next, end) {
-        const handler = handlers_1.methodHandlers[request.method];
-        if (handler) {
-            if (String.prototype.startsWith.call(request.method, 'snap_') &&
-                !isSnap) {
-                return end(rpc_errors_1.rpcErrors.methodNotFound());
-            }
-            // TODO: Once json-rpc-engine types are up to date, we should type this correctly
-            const { implementation, hookNames } = handler;
-            try {
-                // Implementations may or may not be async, so we must await them.
-                return await implementation(request, response, next, end, (0, utils_1.selectHooks)(hooks, hookNames));
-            }
-            catch (error) {
-                (0, snaps_utils_1.logError)(error);
-                return end(error);
-            }
+        if (String.prototype.startsWith.call(request.method, 'snap_') && !isSnap) {
+            return end(rpc_errors_1.rpcErrors.methodNotFound());
         }
-        return next();
+        return nestedMiddleware(request, response, next, end);
     };
 }
 exports.createSnapsMethodMiddleware = createSnapsMethodMiddleware;

package/dist/permitted/middleware.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.cjs","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":";;;AACA,qDAAiD;AACjD,uDAAiD;AAGjD,6CAA4C;AAC5C,wCAAuC;AAEvC;;;;;;GAMG;AACH,SAAgB,2BAA2B,CACzC,MAAe,EACf,KAA8B;IAE9B,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,KAAK,UAAU,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG;QACjE,MAAM,OAAO,GACX,yBAAc,CAAC,OAAO,CAAC,MAAqC,CAAC,CAAC;QAChE,IAAI,OAAO,EAAE,CAAC;YACZ,IACE,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC;gBACzD,CAAC,MAAM,EACP,CAAC;gBACD,OAAO,GAAG,CAAC,sBAAS,CAAC,cAAc,EAAE,CAAC,CAAC;YACzC,CAAC;YAED,iFAAiF;YACjF,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,OAAc,CAAC;YACrD,IAAI,CAAC;gBACH,kEAAkE;gBAClE,OAAO,MAAM,cAAc,CACzB,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,GAAG,EACH,IAAA,mBAAW,EAAC,KAAK,EAAE,SAAS,CAAC,CAC9B,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAA,sBAAQ,EAAC,KAAK,CAAC,CAAC;gBAChB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QAED,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AApCD,kEAoCC","sourcesContent":["import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport { methodHandlers } from './handlers';\nimport { selectHooks } from '../utils';\n\n/**\n * Creates a middleware that handles permitted snap RPC methods.\n *\n * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.\n * @param hooks - An object containing the hooks made available to the permitted RPC methods.\n * @returns The middleware.\n */\nexport function createSnapsMethodMiddleware(\n  isSnap: boolean,\n  hooks: Record<string, unknown>,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  // This is not actually a misused promise, the type is just wrong\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    const handler =\n      methodHandlers[request.method as keyof typeof methodHandlers];\n    if (handler) {\n      if (\n        String.prototype.startsWith.call(request.method, 'snap_') &&\n        !isSnap\n      ) {\n        return end(rpcErrors.methodNotFound());\n      }\n\n      // TODO: Once json-rpc-engine types are up to date, we should type this correctly\n      const { implementation, hookNames } = handler as any;\n      try {\n        // Implementations may or may not be async, so we must await them.\n        return await implementation(\n          request,\n          response,\n          next,\n          end,\n          selectHooks(hooks, hookNames),\n        );\n      } catch (error) {\n        logError(error);\n        return end(error);\n      }\n    }\n\n    return next();\n  };\n}\n"]}
+{"version":3,"file":"middleware.cjs","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":";;;AAAA,+DAGmC;AAEnC,qDAAiD;AACjD,uDAAiD;AAIjD,uEAAuE;AACvE,iDAAiD;AACjD,yDAAyD;AACzD,2DAA2D;AAC3D,6CAA6C;AAC7C,mDAAmD;AACnD,mEAAmE;AACnE,2DAA2D;AAC3D,2CAA2C;AAC3C,mEAAmE;AACnE,+DAA+D;AAC/D,6CAA6C;AAC7C,6CAA6C;AAC7C,uDAAuD;AACvD,uDAAuD;AACvD,2DAA2D;AAC3D,iEAAiE;AACjE,uDAAuD;AACvD,qDAAqD;AACrD,6DAA6D;AAC7D,2EAA2E;AAC3E,qEAAqE;AACrE,6CAA6C;AAC7C,iDAAiD;AACjD,iDAAiD;AACjD,iDAAiD;AACjD,2DAA2D;AAE3D,yDAAyD;AACzD,MAAM,cAAc,GAAG;IACrB,kBAAkB,EAAE,gCAAkB;IACtC,eAAe,EAAE,0BAAe;IAChC,mBAAmB,EAAE,kCAAmB;IACxC,iBAAiB,EAAE,wCAAsB;IACzC,oBAAoB,EAAE,oCAAoB;IAC1C,eAAe,EAAE,8BAAiB;IAClC,oBAAoB,EAAE,wCAAsB;IAC5C,YAAY,EAAE,wBAAc;IAC5B,aAAa,EAAE,0BAAe;IAC9B,oBAAoB,EAAE,wCAAsB;IAC5C,oBAAoB,EAAE,wCAAsB;IAC5C,sBAAsB,EAAE,4CAAwB;IAChD,wBAAwB,EAAE,gDAA0B;IACpD,uBAAuB,EAAE,8CAAyB;IAClD,qBAAqB,EAAE,0CAAuB;IAC9C,4BAA4B,EAAE,wDAA8B;IAC5D,0BAA0B,EAAE,oDAA4B;IACxD,wBAAwB,EAAE,gDAA0B;IACpD,aAAa,EAAE,0BAAe;IAC9B,eAAe,EAAE,8BAAiB;IAClC,eAAe,EAAE,8BAAiB;IAClC,kBAAkB,EAAE,oCAAoB;IACxC,mBAAmB,EAAE,sCAAqB;IAC1C,yBAAyB,EAAE,kDAA2B;IACtD,kBAAkB,EAAE,oCAAoB;IACxC,eAAe,EAAE,8BAAiB;IAClC,aAAa,EAAE,0BAAe;CAC/B,CAAC;AACF,wDAAwD;AAExD;;;;;;;GAOG;AACH,SAAgB,2BAA2B,CACzC,MAAe,EACf,KAA8B,EAC9B,SAAuD;IAEvD,MAAM,gBAAgB,GAAG,IAAA,wCAAsB,EAAC;QAC9C,QAAQ,EAAE,cAAc;QACxB,KAAK;QACL,SAAS;QACT,OAAO,EAAE,sBAAQ;KAClB,CAAC,CAAC;IAEH,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,KAAK,UAAU,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG;QACjE,IAAI,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACzE,OAAO,GAAG,CAAC,sBAAS,CAAC,cAAc,EAAE,CAAC,CAAC;QACzC,CAAC;QAED,OAAO,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;IACxD,CAAC,CAAC;AACJ,CAAC;AArBD,kEAqBC","sourcesContent":["import {\n  createMethodMiddleware,\n  type JsonRpcMiddleware,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport type { PermittedRpcMethodActions, PermittedRpcMethodHooks } from '.';\nimport { cancelBackgroundEventHandler } from './cancelBackgroundEvent';\nimport { clearStateHandler } from './clearState';\nimport { closeWebSocketHandler } from './closeWebSocket';\nimport { createInterfaceHandler } from './createInterface';\nimport { endTraceHandler } from './endTrace';\nimport { getAllSnapsHandler } from './getAllSnaps';\nimport { getBackgroundEventsHandler } from './getBackgroundEvents';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getInterfaceContextHandler } from './getInterfaceContext';\nimport { getInterfaceStateHandler } from './getInterfaceState';\nimport { getSnapsHandler } from './getSnaps';\nimport { getStateHandler } from './getState';\nimport { getWebSocketsHandler } from './getWebSockets';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { listEntropySourcesHandler } from './listEntropySources';\nimport { openWebSocketHandler } from './openWebSocket';\nimport { requestSnapsHandler } from './requestSnaps';\nimport { resolveInterfaceHandler } from './resolveInterface';\nimport { scheduleBackgroundEventHandler } from './scheduleBackgroundEvent';\nimport { sendWebSocketMessageHandler } from './sendWebSocketMessage';\nimport { setStateHandler } from './setState';\nimport { startTraceHandler } from './startTrace';\nimport { trackErrorHandler } from './trackError';\nimport { trackEventHandler } from './trackEvent';\nimport { updateInterfaceHandler } from './updateInterface';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nconst methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_clearState: clearStateHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n  snap_getState: getStateHandler,\n  snap_createInterface: createInterfaceHandler,\n  snap_updateInterface: updateInterfaceHandler,\n  snap_getInterfaceState: getInterfaceStateHandler,\n  snap_getInterfaceContext: getInterfaceContextHandler,\n  snap_listEntropySources: listEntropySourcesHandler,\n  snap_resolveInterface: resolveInterfaceHandler,\n  snap_scheduleBackgroundEvent: scheduleBackgroundEventHandler,\n  snap_cancelBackgroundEvent: cancelBackgroundEventHandler,\n  snap_getBackgroundEvents: getBackgroundEventsHandler,\n  snap_setState: setStateHandler,\n  snap_trackError: trackErrorHandler,\n  snap_trackEvent: trackEventHandler,\n  snap_openWebSocket: openWebSocketHandler,\n  snap_closeWebSocket: closeWebSocketHandler,\n  snap_sendWebSocketMessage: sendWebSocketMessageHandler,\n  snap_getWebSockets: getWebSocketsHandler,\n  snap_startTrace: startTraceHandler,\n  snap_endTrace: endTraceHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\n/**\n * Creates a middleware that handles permitted snap RPC methods.\n *\n * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.\n * @param hooks - An object containing the hooks made available to the permitted RPC methods.\n * @param messenger - The messenger.\n * @returns The middleware.\n */\nexport function createSnapsMethodMiddleware(\n  isSnap: boolean,\n  hooks: PermittedRpcMethodHooks,\n  messenger: Messenger<string, PermittedRpcMethodActions>,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  const nestedMiddleware = createMethodMiddleware({\n    handlers: methodHandlers,\n    hooks,\n    messenger,\n    onError: logError,\n  });\n\n  // This is not actually a misused promise, the type is just wrong\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    if (String.prototype.startsWith.call(request.method, 'snap_') && !isSnap) {\n      return end(rpcErrors.methodNotFound());\n    }\n\n    return nestedMiddleware(request, response, next, end);\n  };\n}\n"]}

package/dist/permitted/middleware.d.cts

@@ -1,11 +1,14 @@
-import type { JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import { type JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import type { Messenger } from "@metamask/messenger";
 import type { Json, JsonRpcParams } from "@metamask/utils";
+import type { PermittedRpcMethodActions, PermittedRpcMethodHooks } from "./index.cjs";
 /**
  * Creates a middleware that handles permitted snap RPC methods.
  *
  * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.
  * @param hooks - An object containing the hooks made available to the permitted RPC methods.
+ * @param messenger - The messenger.
  * @returns The middleware.
  */
-export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: Record<string, unknown>): JsonRpcMiddleware<JsonRpcParams, Json>;
+export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: PermittedRpcMethodHooks, messenger: Messenger<string, PermittedRpcMethodActions>): JsonRpcMiddleware<JsonRpcParams, Json>;
 //# sourceMappingURL=middleware.d.cts.map

package/dist/permitted/middleware.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.cts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kCAAkC;AAGnE,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAK3D;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiCxC"}
+{"version":3,"file":"middleware.d.cts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACvB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AAGrD,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAE3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,oBAAU;AA6D5E;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,uBAAuB,EAC9B,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,yBAAyB,CAAC,GACtD,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiBxC"}

package/dist/permitted/middleware.d.mts

@@ -1,11 +1,14 @@
-import type { JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import { type JsonRpcMiddleware } from "@metamask/json-rpc-engine";
+import type { Messenger } from "@metamask/messenger";
 import type { Json, JsonRpcParams } from "@metamask/utils";
+import type { PermittedRpcMethodActions, PermittedRpcMethodHooks } from "./index.mjs";
 /**
  * Creates a middleware that handles permitted snap RPC methods.
  *
  * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.
  * @param hooks - An object containing the hooks made available to the permitted RPC methods.
+ * @param messenger - The messenger.
  * @returns The middleware.
  */
-export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: Record<string, unknown>): JsonRpcMiddleware<JsonRpcParams, Json>;
+export declare function createSnapsMethodMiddleware(isSnap: boolean, hooks: PermittedRpcMethodHooks, messenger: Messenger<string, PermittedRpcMethodActions>): JsonRpcMiddleware<JsonRpcParams, Json>;
 //# sourceMappingURL=middleware.d.mts.map

package/dist/permitted/middleware.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.mts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kCAAkC;AAGnE,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAK3D;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiCxC"}
+{"version":3,"file":"middleware.d.mts","sourceRoot":"","sources":["../../src/permitted/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACvB,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AAGrD,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,wBAAwB;AAE3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,oBAAU;AA6D5E;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,uBAAuB,EAC9B,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,yBAAyB,CAAC,GACtD,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAiBxC"}

package/dist/permitted/middleware.mjs

@@ -1,36 +1,86 @@
+import { createMethodMiddleware } from "@metamask/json-rpc-engine";
 import { rpcErrors } from "@metamask/rpc-errors";
 import { logError } from "@metamask/snaps-utils";
-import { methodHandlers } from "./handlers.mjs";
-import { selectHooks } from "../utils.mjs";
+import { cancelBackgroundEventHandler } from "./cancelBackgroundEvent.mjs";
+import { clearStateHandler } from "./clearState.mjs";
+import { closeWebSocketHandler } from "./closeWebSocket.mjs";
+import { createInterfaceHandler } from "./createInterface.mjs";
+import { endTraceHandler } from "./endTrace.mjs";
+import { getAllSnapsHandler } from "./getAllSnaps.mjs";
+import { getBackgroundEventsHandler } from "./getBackgroundEvents.mjs";
+import { getClientStatusHandler } from "./getClientStatus.mjs";
+import { getFileHandler } from "./getFile.mjs";
+import { getInterfaceContextHandler } from "./getInterfaceContext.mjs";
+import { getInterfaceStateHandler } from "./getInterfaceState.mjs";
+import { getSnapsHandler } from "./getSnaps.mjs";
+import { getStateHandler } from "./getState.mjs";
+import { getWebSocketsHandler } from "./getWebSockets.mjs";
+import { invokeKeyringHandler } from "./invokeKeyring.mjs";
+import { invokeSnapSugarHandler } from "./invokeSnapSugar.mjs";
+import { listEntropySourcesHandler } from "./listEntropySources.mjs";
+import { openWebSocketHandler } from "./openWebSocket.mjs";
+import { requestSnapsHandler } from "./requestSnaps.mjs";
+import { resolveInterfaceHandler } from "./resolveInterface.mjs";
+import { scheduleBackgroundEventHandler } from "./scheduleBackgroundEvent.mjs";
+import { sendWebSocketMessageHandler } from "./sendWebSocketMessage.mjs";
+import { setStateHandler } from "./setState.mjs";
+import { startTraceHandler } from "./startTrace.mjs";
+import { trackErrorHandler } from "./trackError.mjs";
+import { trackEventHandler } from "./trackEvent.mjs";
+import { updateInterfaceHandler } from "./updateInterface.mjs";
+/* eslint-disable @typescript-eslint/naming-convention */
+const methodHandlers = {
+    wallet_getAllSnaps: getAllSnapsHandler,
+    wallet_getSnaps: getSnapsHandler,
+    wallet_requestSnaps: requestSnapsHandler,
+    wallet_invokeSnap: invokeSnapSugarHandler,
+    wallet_invokeKeyring: invokeKeyringHandler,
+    snap_clearState: clearStateHandler,
+    snap_getClientStatus: getClientStatusHandler,
+    snap_getFile: getFileHandler,
+    snap_getState: getStateHandler,
+    snap_createInterface: createInterfaceHandler,
+    snap_updateInterface: updateInterfaceHandler,
+    snap_getInterfaceState: getInterfaceStateHandler,
+    snap_getInterfaceContext: getInterfaceContextHandler,
+    snap_listEntropySources: listEntropySourcesHandler,
+    snap_resolveInterface: resolveInterfaceHandler,
+    snap_scheduleBackgroundEvent: scheduleBackgroundEventHandler,
+    snap_cancelBackgroundEvent: cancelBackgroundEventHandler,
+    snap_getBackgroundEvents: getBackgroundEventsHandler,
+    snap_setState: setStateHandler,
+    snap_trackError: trackErrorHandler,
+    snap_trackEvent: trackEventHandler,
+    snap_openWebSocket: openWebSocketHandler,
+    snap_closeWebSocket: closeWebSocketHandler,
+    snap_sendWebSocketMessage: sendWebSocketMessageHandler,
+    snap_getWebSockets: getWebSocketsHandler,
+    snap_startTrace: startTraceHandler,
+    snap_endTrace: endTraceHandler,
+};
+/* eslint-enable @typescript-eslint/naming-convention */
 /**
  * Creates a middleware that handles permitted snap RPC methods.
  *
  * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.
  * @param hooks - An object containing the hooks made available to the permitted RPC methods.
+ * @param messenger - The messenger.
  * @returns The middleware.
  */
-export function createSnapsMethodMiddleware(isSnap, hooks) {
+export function createSnapsMethodMiddleware(isSnap, hooks, messenger) {
+    const nestedMiddleware = createMethodMiddleware({
+        handlers: methodHandlers,
+        hooks,
+        messenger,
+        onError: logError,
+    });
     // This is not actually a misused promise, the type is just wrong
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     return async function methodMiddleware(request, response, next, end) {
-        const handler = methodHandlers[request.method];
-        if (handler) {
-            if (String.prototype.startsWith.call(request.method, 'snap_') &&
-                !isSnap) {
-                return end(rpcErrors.methodNotFound());
-            }
-            // TODO: Once json-rpc-engine types are up to date, we should type this correctly
-            const { implementation, hookNames } = handler;
-            try {
-                // Implementations may or may not be async, so we must await them.
-                return await implementation(request, response, next, end, selectHooks(hooks, hookNames));
-            }
-            catch (error) {
-                logError(error);
-                return end(error);
-            }
+        if (String.prototype.startsWith.call(request.method, 'snap_') && !isSnap) {
+            return end(rpcErrors.methodNotFound());
         }
-        return next();
+        return nestedMiddleware(request, response, next, end);
     };
 }
 //# sourceMappingURL=middleware.mjs.map