@metamask/snaps-rpc-methods 15.1.0 → 16.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"invokeSnapSugar.d.cts","sourceRoot":"","sources":["../../src/permitted/invokeSnapSugar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,yBAAyB,EAC1B,kCAAkC;AAGnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,4BAA4B;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,wBAAwB;AAK9E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,sBAAsB;;;;;;CAUlC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACrE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,cAAc,CAAC,gBAAgB,CAAC,EAMrC,GAAG,EAAE,sBAAsB,CAAC,gBAAgB,CAAC,EAC7C,KAAK,EAAE,yBAAyB,EAChC,GAAG,EAAE,wBAAwB,EAC7B,EAAE,UAAU,EAAE,EAAE,oBAAoB,GACnC,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAsBpE"}
+{"version":3,"file":"invokeSnapSugar.d.cts","sourceRoot":"","sources":["../../src/permitted/invokeSnapSugar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,yBAAyB,EAE1B,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AACrD,OAAO,KAAK,EAAE,iDAAiD,EAAE,wCAAwC;AAEzG,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,4BAA4B;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAI9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,qBAAiB;AAEzD,MAAM,MAAM,4BAA4B,GACtC,iDAAiD,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,sBAAsB;;;CASlC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,wBAAwB,CAAC,gBAAgB,CAAC,EAM/C,GAAG,EAAE,sBAAsB,CAAC,gBAAgB,CAAC,EAC7C,KAAK,EAAE,yBAAyB,EAChC,GAAG,EAAE,wBAAwB,EAC7B,MAAM,EAAE,KAAK,EACb,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,4BAA4B,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC,CAaf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAsBpE"}

package/dist/permitted/invokeSnapSugar.d.mts

@@ -1,6 +1,10 @@
 import type { JsonRpcEngineEndCallback, JsonRpcEngineNextCallback } from "@metamask/json-rpc-engine";
+import type { Messenger } from "@metamask/messenger";
+import type { PermissionControllerExecuteRestrictedMethodAction } from "@metamask/permission-controller";
 import type { InvokeSnapParams, InvokeSnapResult } from "@metamask/snaps-sdk";
-import type { JsonRpcRequest, PendingJsonRpcResponse } from "@metamask/utils";
+import type { PendingJsonRpcResponse } from "@metamask/utils";
+import type { JsonRpcRequestWithOrigin } from "../types.mjs";
+export type InvokeSnapSugarMethodActions = PermissionControllerExecuteRestrictedMethodAction;
 /**
  * Invoke a method of a Snap, designated by the `snapId` parameter, with a
  * JSON-RPC request specified in the `request` parameter. This is effectively a
@@ -27,14 +31,8 @@ import type { JsonRpcRequest, PendingJsonRpcResponse } from "@metamask/utils";
  * ```
  */
 export declare const invokeSnapSugarHandler: {
-    methodNames: ["wallet_invokeSnap"];
     implementation: typeof invokeSnapSugar;
-    hookNames: {
-        invokeSnap: true;
-    };
-};
-export type InvokeSnapSugarHooks = {
-    invokeSnap: (params: InvokeSnapParams) => Promise<InvokeSnapResult>;
+    actionNames: "PermissionController:executeRestrictedMethod"[];
 };
 /**
  * The `wallet_invokeSnap` method implementation.
@@ -44,13 +42,12 @@ export type InvokeSnapSugarHooks = {
  * @param res - The JSON-RPC response object.
  * @param _next - The `json-rpc-engine` "next" callback.
  * @param end - The `json-rpc-engine` "end" callback.
- * @param hooks - The RPC method hooks.
- * @param hooks.invokeSnap - A function to invoke a snap designated by its parameters,
- * bound to the requesting origin.
+ * @param _hooks - The RPC method hooks. Not used by this function.
+ * @param messenger - The messenger used to call controller actions.
  * @returns Nothing.
  * @throws If the params are invalid.
  */
-export declare function invokeSnapSugar(req: JsonRpcRequest<InvokeSnapParams>, res: PendingJsonRpcResponse<InvokeSnapResult>, _next: JsonRpcEngineNextCallback, end: JsonRpcEngineEndCallback, { invokeSnap }: InvokeSnapSugarHooks): Promise<void>;
+export declare function invokeSnapSugar(req: JsonRpcRequestWithOrigin<InvokeSnapParams>, res: PendingJsonRpcResponse<InvokeSnapResult>, _next: JsonRpcEngineNextCallback, end: JsonRpcEngineEndCallback, _hooks: never, messenger: Messenger<string, InvokeSnapSugarMethodActions>): Promise<void>;
 /**
  * Validates the wallet_invokeSnap method `params` and returns them cast to the correct
  * type. Throws if validation fails.

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

@@ -1 +1 @@
-{"version":3,"file":"invokeSnapSugar.d.mts","sourceRoot":"","sources":["../../src/permitted/invokeSnapSugar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,yBAAyB,EAC1B,kCAAkC;AAGnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,4BAA4B;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,wBAAwB;AAK9E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,sBAAsB;;;;;;CAUlC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACrE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,cAAc,CAAC,gBAAgB,CAAC,EAMrC,GAAG,EAAE,sBAAsB,CAAC,gBAAgB,CAAC,EAC7C,KAAK,EAAE,yBAAyB,EAChC,GAAG,EAAE,wBAAwB,EAC7B,EAAE,UAAU,EAAE,EAAE,oBAAoB,GACnC,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAsBpE"}
+{"version":3,"file":"invokeSnapSugar.d.mts","sourceRoot":"","sources":["../../src/permitted/invokeSnapSugar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,yBAAyB,EAE1B,kCAAkC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,4BAA4B;AACrD,OAAO,KAAK,EAAE,iDAAiD,EAAE,wCAAwC;AAEzG,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,4BAA4B;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB;AAI9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,qBAAiB;AAEzD,MAAM,MAAM,4BAA4B,GACtC,iDAAiD,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,sBAAsB;;;CASlC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,wBAAwB,CAAC,gBAAgB,CAAC,EAM/C,GAAG,EAAE,sBAAsB,CAAC,gBAAgB,CAAC,EAC7C,KAAK,EAAE,yBAAyB,EAChC,GAAG,EAAE,wBAAwB,EAC7B,MAAM,EAAE,KAAK,EACb,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,4BAA4B,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC,CAaf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAsBpE"}

package/dist/permitted/invokeSnapSugar.mjs

@@ -1,6 +1,6 @@
 import { rpcErrors } from "@metamask/rpc-errors";
 import { isObject } from "@metamask/utils";
-const methodName = 'wallet_invokeSnap';
+import { WALLET_SNAP_PERMISSION_KEY } from "../restricted/invokeSnap.mjs";
 /**
  * Invoke a method of a Snap, designated by the `snapId` parameter, with a
  * JSON-RPC request specified in the `request` parameter. This is effectively a
@@ -27,11 +27,8 @@ const methodName = 'wallet_invokeSnap';
  * ```
  */
 export const invokeSnapSugarHandler = {
-    methodNames: [methodName],
     implementation: invokeSnapSugar,
-    hookNames: {
-        invokeSnap: true,
-    },
+    actionNames: ['PermissionController:executeRestrictedMethod'],
 };
 /**
  * The `wallet_invokeSnap` method implementation.
@@ -41,9 +38,8 @@ export const invokeSnapSugarHandler = {
  * @param res - The JSON-RPC response object.
  * @param _next - The `json-rpc-engine` "next" callback.
  * @param end - The `json-rpc-engine` "end" callback.
- * @param hooks - The RPC method hooks.
- * @param hooks.invokeSnap - A function to invoke a snap designated by its parameters,
- * bound to the requesting origin.
+ * @param _hooks - The RPC method hooks. Not used by this function.
+ * @param messenger - The messenger used to call controller actions.
  * @returns Nothing.
  * @throws If the params are invalid.
  */
@@ -53,10 +49,10 @@ export async function invokeSnapSugar(req,
 // future. We use `InvokeSnapResult` here to make it clear that this is the
 // expected type of the result.
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-arguments
-res, _next, end, { invokeSnap }) {
+res, _next, end, _hooks, messenger) {
     try {
         const params = getValidatedParams(req.params);
-        res.result = await invokeSnap(params);
+        res.result = await messenger.call('PermissionController:executeRestrictedMethod', req.origin, WALLET_SNAP_PERMISSION_KEY, params);
     }
     catch (error) {
         return end(error);

package/dist/permitted/invokeSnapSugar.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"invokeSnapSugar.mjs","sourceRoot":"","sources":["../../src/permitted/invokeSnapSugar.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,6BAA6B;AAGjD,OAAO,EAAE,QAAQ,EAAE,wBAAwB;AAE3C,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,WAAW,EAAE,CAAC,UAAU,CAAU;IAClC,cAAc,EAAE,eAAe;IAC/B,SAAS,EAAE;QACT,UAAU,EAAE,IAAI;KACjB;CAKF,CAAC;AAMF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,GAAqC;AACrC,uEAAuE;AACvE,8EAA8E;AAC9E,2EAA2E;AAC3E,+BAA+B;AAC/B,4EAA4E;AAC5E,GAA6C,EAC7C,KAAgC,EAChC,GAA6B,EAC7B,EAAE,UAAU,EAAwB;IAEpC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC9C,GAAG,CAAC,MAAM,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,GAAG,EAAE,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAe;IAChD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACtB,MAAM,SAAS,CAAC,aAAa,CAAC;YAC5B,OAAO,EAAE,wCAAwC;SAClD,CAAC,CAAC;IACL,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAEnC,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QAC3D,MAAM,SAAS,CAAC,aAAa,CAAC;YAC5B,OAAO,EAAE,+BAA+B;SACzC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACvB,MAAM,SAAS,CAAC,aAAa,CAAC;YAC5B,OAAO,EAAE,yCAAyC;SACnD,CAAC,CAAC;IACL,CAAC;IAED,OAAO,MAA0B,CAAC;AACpC,CAAC","sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  JsonRpcEngineNextCallback,\n} from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { InvokeSnapParams, InvokeSnapResult } from '@metamask/snaps-sdk';\nimport type { JsonRpcRequest, PendingJsonRpcResponse } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\nconst methodName = 'wallet_invokeSnap';\n\n/**\n * Invoke a method of a Snap, designated by the `snapId` parameter, with a\n * JSON-RPC request specified in the `request` parameter. This is effectively a\n * wrapper around [`wallet_snap`](https://docs.metamask.io/snaps/reference/snaps-api/wallet_snap)\n * that allows for more convenient invocation of Snap methods without needing to\n * specify the full `wallet_snap` parameters.\n *\n * The Snap must be installed and the dapp must have permission to communicate\n * with the Snap, or the request is rejected. The dapp can install the Snap and\n * request permission to communicate with it using [`wallet_requestSnaps`](https://docs.metamask.io/snaps/reference/snaps-api/wallet_requestsnaps).\n *\n * @example\n * ```ts\n * const result = await snap.request({\n *   method: 'wallet_invokeSnap',\n *   params: {\n *     snapId: 'npm:@metamask/example-snap',\n *     request: {\n *       method: 'someMethod',\n *       params: { some: 'params' },\n *     },\n *   },\n * });\n * ```\n */\nexport const invokeSnapSugarHandler = {\n  methodNames: [methodName] as const,\n  implementation: invokeSnapSugar,\n  hookNames: {\n    invokeSnap: true,\n  },\n} satisfies PermittedHandlerExport<\n  InvokeSnapSugarHooks,\n  InvokeSnapParams,\n  InvokeSnapResult\n>;\n\nexport type InvokeSnapSugarHooks = {\n  invokeSnap: (params: InvokeSnapParams) => Promise<InvokeSnapResult>;\n};\n\n/**\n * The `wallet_invokeSnap` method implementation.\n * Effectively calls `wallet_snap` under the hood.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.invokeSnap - A function to invoke a snap designated by its parameters,\n * bound to the requesting origin.\n * @returns Nothing.\n * @throws If the params are invalid.\n */\nexport async function invokeSnapSugar(\n  req: JsonRpcRequest<InvokeSnapParams>,\n  // `InvokeSnapResult` is an alias for `Json` (which is the default type\n  // argument for `PendingJsonRpcResponse`), but that may not be the case in the\n  // future. We use `InvokeSnapResult` here to make it clear that this is the\n  // expected type of the result.\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-arguments\n  res: PendingJsonRpcResponse<InvokeSnapResult>,\n  _next: JsonRpcEngineNextCallback,\n  end: JsonRpcEngineEndCallback,\n  { invokeSnap }: InvokeSnapSugarHooks,\n): Promise<void> {\n  try {\n    const params = getValidatedParams(req.params);\n    res.result = await invokeSnap(params);\n  } catch (error) {\n    return end(error);\n  }\n  return end();\n}\n\n/**\n * Validates the wallet_invokeSnap method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(params: unknown): InvokeSnapParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { snapId, request } = params;\n\n  if (!snapId || typeof snapId !== 'string' || snapId === '') {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid snap ID.',\n    });\n  }\n\n  if (!isObject(request)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected request to be a single object.',\n    });\n  }\n\n  return params as InvokeSnapParams;\n}\n"]}
+{"version":3,"file":"invokeSnapSugar.mjs","sourceRoot":"","sources":["../../src/permitted/invokeSnapSugar.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,SAAS,EAAE,6BAA6B;AAGjD,OAAO,EAAE,QAAQ,EAAE,wBAAwB;AAE3C,OAAO,EAAE,0BAA0B,EAAE,qCAAiC;AAMtE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,cAAc,EAAE,eAAe;IAC/B,WAAW,EAAE,CAAC,8CAA8C,CAAC;CAO9D,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,GAA+C;AAC/C,uEAAuE;AACvE,8EAA8E;AAC9E,2EAA2E;AAC3E,+BAA+B;AAC/B,4EAA4E;AAC5E,GAA6C,EAC7C,KAAgC,EAChC,GAA6B,EAC7B,MAAa,EACb,SAA0D;IAE1D,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC9C,GAAG,CAAC,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CAC/B,8CAA8C,EAC9C,GAAG,CAAC,MAAM,EACV,0BAA0B,EAC1B,MAAM,CACP,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,GAAG,EAAE,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAe;IAChD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACtB,MAAM,SAAS,CAAC,aAAa,CAAC;YAC5B,OAAO,EAAE,wCAAwC;SAClD,CAAC,CAAC;IACL,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAEnC,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QAC3D,MAAM,SAAS,CAAC,aAAa,CAAC;YAC5B,OAAO,EAAE,+BAA+B;SACzC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACvB,MAAM,SAAS,CAAC,aAAa,CAAC;YAC5B,OAAO,EAAE,yCAAyC;SACnD,CAAC,CAAC;IACL,CAAC;IAED,OAAO,MAA0B,CAAC;AACpC,CAAC","sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  JsonRpcEngineNextCallback,\n  MethodHandler,\n} from '@metamask/json-rpc-engine';\nimport type { Messenger } from '@metamask/messenger';\nimport type { PermissionControllerExecuteRestrictedMethodAction } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { InvokeSnapParams, InvokeSnapResult } from '@metamask/snaps-sdk';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\nimport { WALLET_SNAP_PERMISSION_KEY } from '../restricted/invokeSnap';\nimport type { JsonRpcRequestWithOrigin } from '../types';\n\nexport type InvokeSnapSugarMethodActions =\n  PermissionControllerExecuteRestrictedMethodAction;\n\n/**\n * Invoke a method of a Snap, designated by the `snapId` parameter, with a\n * JSON-RPC request specified in the `request` parameter. This is effectively a\n * wrapper around [`wallet_snap`](https://docs.metamask.io/snaps/reference/snaps-api/wallet_snap)\n * that allows for more convenient invocation of Snap methods without needing to\n * specify the full `wallet_snap` parameters.\n *\n * The Snap must be installed and the dapp must have permission to communicate\n * with the Snap, or the request is rejected. The dapp can install the Snap and\n * request permission to communicate with it using [`wallet_requestSnaps`](https://docs.metamask.io/snaps/reference/snaps-api/wallet_requestsnaps).\n *\n * @example\n * ```ts\n * const result = await snap.request({\n *   method: 'wallet_invokeSnap',\n *   params: {\n *     snapId: 'npm:@metamask/example-snap',\n *     request: {\n *       method: 'someMethod',\n *       params: { some: 'params' },\n *     },\n *   },\n * });\n * ```\n */\nexport const invokeSnapSugarHandler = {\n  implementation: invokeSnapSugar,\n  actionNames: ['PermissionController:executeRestrictedMethod'],\n} satisfies MethodHandler<\n  never,\n  InvokeSnapSugarMethodActions,\n  InvokeSnapParams,\n  InvokeSnapResult,\n  { origin: string }\n>;\n\n/**\n * The `wallet_invokeSnap` method implementation.\n * Effectively calls `wallet_snap` under the hood.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param _hooks - The RPC method hooks. Not used by this function.\n * @param messenger - The messenger used to call controller actions.\n * @returns Nothing.\n * @throws If the params are invalid.\n */\nexport async function invokeSnapSugar(\n  req: JsonRpcRequestWithOrigin<InvokeSnapParams>,\n  // `InvokeSnapResult` is an alias for `Json` (which is the default type\n  // argument for `PendingJsonRpcResponse`), but that may not be the case in the\n  // future. We use `InvokeSnapResult` here to make it clear that this is the\n  // expected type of the result.\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-arguments\n  res: PendingJsonRpcResponse<InvokeSnapResult>,\n  _next: JsonRpcEngineNextCallback,\n  end: JsonRpcEngineEndCallback,\n  _hooks: never,\n  messenger: Messenger<string, InvokeSnapSugarMethodActions>,\n): Promise<void> {\n  try {\n    const params = getValidatedParams(req.params);\n    res.result = await messenger.call(\n      'PermissionController:executeRestrictedMethod',\n      req.origin,\n      WALLET_SNAP_PERMISSION_KEY,\n      params,\n    );\n  } catch (error) {\n    return end(error);\n  }\n  return end();\n}\n\n/**\n * Validates the wallet_invokeSnap method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(params: unknown): InvokeSnapParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { snapId, request } = params;\n\n  if (!snapId || typeof snapId !== 'string' || snapId === '') {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid snap ID.',\n    });\n  }\n\n  if (!isObject(request)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected request to be a single object.',\n    });\n  }\n\n  return params as InvokeSnapParams;\n}\n"]}

package/dist/permitted/listEntropySources.cjs

@@ -16,10 +16,11 @@ const REQUIRED_PERMISSIONS = [
     getBip44Entropy_1.getBip44EntropyBuilder.targetName,
     getEntropy_1.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,
 };
 /**
@@ -61,32 +62,47 @@ const hookNames = {
  * ```
  */
 exports.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(rpc_errors_1.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.cjs.map

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;