@metamask/snaps-rpc-methods 3.1.0

package/dist/esm/permitted/getFile.js

@@ -0,0 +1,45 @@
+import { rpcErrors } from '@metamask/rpc-errors';
+import { enumValue, AuxiliaryFileEncoding } from '@metamask/snaps-utils';
+import { assertStruct } from '@metamask/utils';
+import { object, optional, string, union } from 'superstruct';
+export const GetFileArgsStruct = object({
+    path: string(),
+    encoding: optional(union([
+        enumValue(AuxiliaryFileEncoding.Base64),
+        enumValue(AuxiliaryFileEncoding.Hex),
+        enumValue(AuxiliaryFileEncoding.Utf8)
+    ]))
+});
+const hookNames = {
+    getSnapFile: true
+};
+export const getFileHandler = {
+    methodNames: [
+        'snap_getFile'
+    ],
+    implementation,
+    hookNames
+};
+/**
+ * The `snap_getFile` method implementation.
+ *
+ * @param req - The JSON-RPC request object.
+ * @param res - 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.getSnapFile - The funnction to load a static snap file.
+ * @returns Nothing.
+ */ async function implementation(req, res, _next, end, { getSnapFile }) {
+    const { params } = req;
+    assertStruct(params, GetFileArgsStruct, 'Invalid "snap_getFile" parameters', rpcErrors.invalidParams);
+    try {
+        res.result = await getSnapFile(params.path, params.encoding ?? AuxiliaryFileEncoding.Base64);
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+
+//# sourceMappingURL=getFile.js.map

package/dist/esm/permitted/getFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/getFile.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { enumValue, AuxiliaryFileEncoding } from '@metamask/snaps-utils';\nimport type {\n  PendingJsonRpcResponse,\n  JsonRpcRequest,\n  Json,\n} from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport type { Infer } from 'superstruct';\nimport { object, optional, string, union } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const GetFileArgsStruct = object({\n  path: string(),\n  encoding: optional(\n    union([\n      enumValue(AuxiliaryFileEncoding.Base64),\n      enumValue(AuxiliaryFileEncoding.Hex),\n      enumValue(AuxiliaryFileEncoding.Utf8),\n    ]),\n  ),\n});\n\nexport type GetFileArgs = Infer<typeof GetFileArgsStruct>;\n\nconst hookNames: MethodHooksObject<GetFileHooks> = {\n  getSnapFile: true,\n};\n\nexport const getFileHandler: PermittedHandlerExport<\n  GetFileHooks,\n  GetFileArgs,\n  string\n> = {\n  methodNames: ['snap_getFile'],\n  implementation,\n  hookNames,\n};\n\nexport type GetFileHooks = {\n  getSnapFile: (\n    path: GetFileArgs['path'],\n    encoding: GetFileArgs['encoding'],\n  ) => Promise<string>;\n};\n\n/**\n * The `snap_getFile` method implementation.\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. 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.getSnapFile - The funnction to load a static snap file.\n * @returns Nothing.\n */\nasync function implementation(\n  req: JsonRpcRequest<GetFileArgs>,\n  res: PendingJsonRpcResponse<Json>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnapFile }: GetFileHooks,\n): Promise<void> {\n  const { params } = req;\n\n  assertStruct(\n    params,\n    GetFileArgsStruct,\n    'Invalid \"snap_getFile\" parameters',\n    rpcErrors.invalidParams,\n  );\n\n  try {\n    res.result = await getSnapFile(\n      params.path,\n      params.encoding ?? AuxiliaryFileEncoding.Base64,\n    );\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n"],"names":["rpcErrors","enumValue","AuxiliaryFileEncoding","assertStruct","object","optional","string","union","GetFileArgsStruct","path","encoding","Base64","Hex","Utf8","hookNames","getSnapFile","getFileHandler","methodNames","implementation","req","res","_next","end","params","invalidParams","result","error"],"mappings":"AAEA,SAASA,SAAS,QAAQ,uBAAuB;AACjD,SAASC,SAAS,EAAEC,qBAAqB,QAAQ,wBAAwB;AAMzE,SAASC,YAAY,QAAQ,kBAAkB;AAE/C,SAASC,MAAM,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,KAAK,QAAQ,cAAc;AAI9D,OAAO,MAAMC,oBAAoBJ,OAAO;IACtCK,MAAMH;IACNI,UAAUL,SACRE,MAAM;QACJN,UAAUC,sBAAsBS,MAAM;QACtCV,UAAUC,sBAAsBU,GAAG;QACnCX,UAAUC,sBAAsBW,IAAI;KACrC;AAEL,GAAG;AAIH,MAAMC,YAA6C;IACjDC,aAAa;AACf;AAEA,OAAO,MAAMC,iBAIT;IACFC,aAAa;QAAC;KAAe;IAC7BC;IACAJ;AACF,EAAE;AASF;;;;;;;;;;;CAWC,GACD,eAAeI,eACbC,GAAgC,EAChCC,GAAiC,EACjCC,KAAc,EACdC,GAA6B,EAC7B,EAAEP,WAAW,EAAgB;IAE7B,MAAM,EAAEQ,MAAM,EAAE,GAAGJ;IAEnBhB,aACEoB,QACAf,mBACA,qCACAR,UAAUwB,aAAa;IAGzB,IAAI;QACFJ,IAAIK,MAAM,GAAG,MAAMV,YACjBQ,OAAOd,IAAI,EACXc,OAAOb,QAAQ,IAAIR,sBAAsBS,MAAM;IAEnD,EAAE,OAAOe,OAAO;QACd,OAAOJ,IAAII;IACb;IAEA,OAAOJ;AACT"}

package/dist/esm/permitted/getSnaps.js

@@ -0,0 +1,31 @@
+const hookNames = {
+    getSnaps: true
+};
+/**
+ * `wallet_getSnaps` gets the requester's permitted and installed Snaps.
+ */ export const getSnapsHandler = {
+    methodNames: [
+        'wallet_getSnaps'
+    ],
+    implementation: getSnapsImplementation,
+    hookNames
+};
+/**
+ * The `wallet_getSnaps` method implementation.
+ * Fetches available snaps for the requesting origin and adds them to the JSON-RPC response.
+ *
+ * @param _req - The JSON-RPC request object. Not used by this function.
+ * @param res - 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.getSnaps - A function that returns the snaps available for the requesting origin.
+ * @returns Nothing.
+ */ async function getSnapsImplementation(_req, res, _next, end, { getSnaps }) {
+    // getSnaps is already bound to the origin
+    res.result = await getSnaps();
+    return end();
+}
+
+//# sourceMappingURL=getSnaps.js.map

package/dist/esm/permitted/getSnaps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/getSnaps.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport type { InstallSnapsResult } from '@metamask/snaps-utils';\nimport type { JsonRpcParams, PendingJsonRpcResponse } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetSnapsHooks> = {\n  getSnaps: true,\n};\n\n/**\n * `wallet_getSnaps` gets the requester's permitted and installed Snaps.\n */\nexport const getSnapsHandler: PermittedHandlerExport<\n  GetSnapsHooks,\n  JsonRpcParams,\n  InstallSnapsResult\n> = {\n  methodNames: ['wallet_getSnaps'],\n  implementation: getSnapsImplementation,\n  hookNames,\n};\n\nexport type GetSnapsHooks = {\n  /**\n   * @returns The permitted and installed snaps for the requesting origin.\n   */\n  getSnaps: () => Promise<InstallSnapsResult>;\n};\n\n/**\n * The `wallet_getSnaps` method implementation.\n * Fetches available snaps for the requesting origin and adds them to the JSON-RPC response.\n *\n * @param _req - The JSON-RPC request object. Not used by this function.\n * @param res - 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.getSnaps - A function that returns the snaps available for the requesting origin.\n * @returns Nothing.\n */\nasync function getSnapsImplementation(\n  _req: unknown,\n  res: PendingJsonRpcResponse<InstallSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnaps }: GetSnapsHooks,\n): Promise<void> {\n  // getSnaps is already bound to the origin\n  res.result = await getSnaps();\n  return end();\n}\n"],"names":["hookNames","getSnaps","getSnapsHandler","methodNames","implementation","getSnapsImplementation","_req","res","_next","end","result"],"mappings":"AAOA,MAAMA,YAA8C;IAClDC,UAAU;AACZ;AAEA;;CAEC,GACD,OAAO,MAAMC,kBAIT;IACFC,aAAa;QAAC;KAAkB;IAChCC,gBAAgBC;IAChBL;AACF,EAAE;AASF;;;;;;;;;;;;CAYC,GACD,eAAeK,uBACbC,IAAa,EACbC,GAA+C,EAC/CC,KAAc,EACdC,GAA6B,EAC7B,EAAER,QAAQ,EAAiB;IAE3B,0CAA0C;IAC1CM,IAAIG,MAAM,GAAG,MAAMT;IACnB,OAAOQ;AACT"}

package/dist/esm/permitted/handlers.js

@@ -0,0 +1,15 @@
+import { getFileHandler } from './getFile';
+import { getSnapsHandler } from './getSnaps';
+import { invokeKeyringHandler } from './invokeKeyring';
+import { invokeSnapSugarHandler } from './invokeSnapSugar';
+import { requestSnapsHandler } from './requestSnaps';
+/* eslint-disable @typescript-eslint/naming-convention */ export const methodHandlers = {
+    wallet_getSnaps: getSnapsHandler,
+    wallet_requestSnaps: requestSnapsHandler,
+    wallet_invokeSnap: invokeSnapSugarHandler,
+    wallet_invokeKeyring: invokeKeyringHandler,
+    snap_getFile: getFileHandler
+};
+/* eslint-enable @typescript-eslint/naming-convention */ export const handlers = Object.values(methodHandlers);
+
+//# sourceMappingURL=handlers.js.map

package/dist/esm/permitted/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/handlers.ts"],"sourcesContent":["import { getFileHandler } from './getFile';\nimport { getSnapsHandler } from './getSnaps';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { requestSnapsHandler } from './requestSnaps';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const methodHandlers = {\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_getFile: getFileHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport const handlers = Object.values(methodHandlers);\n"],"names":["getFileHandler","getSnapsHandler","invokeKeyringHandler","invokeSnapSugarHandler","requestSnapsHandler","methodHandlers","wallet_getSnaps","wallet_requestSnaps","wallet_invokeSnap","wallet_invokeKeyring","snap_getFile","handlers","Object","values"],"mappings":"AAAA,SAASA,cAAc,QAAQ,YAAY;AAC3C,SAASC,eAAe,QAAQ,aAAa;AAC7C,SAASC,oBAAoB,QAAQ,kBAAkB;AACvD,SAASC,sBAAsB,QAAQ,oBAAoB;AAC3D,SAASC,mBAAmB,QAAQ,iBAAiB;AAErD,uDAAuD,GACvD,OAAO,MAAMC,iBAAiB;IAC5BC,iBAAiBL;IACjBM,qBAAqBH;IACrBI,mBAAmBL;IACnBM,sBAAsBP;IACtBQ,cAAcV;AAChB,EAAE;AACF,sDAAsD,GAEtD,OAAO,MAAMW,WAAWC,OAAOC,MAAM,CAACR,gBAAgB"}

package/dist/esm/permitted/index.js

@@ -0,0 +1,4 @@
+export * from './handlers';
+export * from './middleware';
+
+//# sourceMappingURL=index.js.map

package/dist/esm/permitted/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/index.ts"],"sourcesContent":["import type { GetSnapsHooks } from './getSnaps';\nimport type { RequestSnapsHooks } from './requestSnaps';\n\nexport type PermittedRpcMethodHooks = GetSnapsHooks & RequestSnapsHooks;\n\nexport * from './handlers';\nexport * from './middleware';\n"],"names":[],"mappings":"AAKA,cAAc,aAAa;AAC3B,cAAc,eAAe"}

package/dist/esm/permitted/invokeKeyring.js

@@ -0,0 +1,80 @@
+import { rpcErrors } from '@metamask/rpc-errors';
+import { HandlerType, WALLET_SNAP_PERMISSION_KEY } from '@metamask/snaps-utils';
+import { hasProperty } from '@metamask/utils';
+import { getValidatedParams } from './invokeSnapSugar';
+const hookNames = {
+    hasPermission: true,
+    handleSnapRpcRequest: true,
+    getSnap: true,
+    getAllowedKeyringMethods: true
+};
+/**
+ * `wallet_invokeKeyring` gets the requester's permitted and installed Snaps.
+ */ export const invokeKeyringHandler = {
+    methodNames: [
+        'wallet_invokeKeyring'
+    ],
+    implementation: invokeKeyringImplementation,
+    hookNames
+};
+/**
+ * The `wallet_invokeKeyring` method implementation.
+ * Invokes onKeyringRequest if the snap requested is installed and connected to the dapp.
+ *
+ * @param req - The JSON-RPC request object.
+ * @param res - 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.handleSnapRpcRequest - Invokes a snap with a given RPC request.
+ * @param hooks.hasPermission - Checks whether a given origin has a given permission.
+ * @param hooks.getSnap - Gets information about a given snap.
+ * @param hooks.getAllowedKeyringMethods - Get the list of allowed Keyring
+ * methods for a given origin.
+ * @returns Nothing.
+ */ async function invokeKeyringImplementation(req, res, _next, end, { handleSnapRpcRequest, hasPermission, getSnap, getAllowedKeyringMethods }) {
+    let params;
+    try {
+        params = getValidatedParams(req.params);
+    } catch (error) {
+        return end(error);
+    }
+    // We expect the MM middleware stack to always add the origin to requests
+    const { origin } = req;
+    const { snapId, request } = params;
+    if (!origin || !hasPermission(origin, WALLET_SNAP_PERMISSION_KEY)) {
+        return end(rpcErrors.invalidRequest({
+            message: `The snap "${snapId}" is not connected to "${origin}". Please connect before invoking the snap.`
+        }));
+    }
+    if (!getSnap(snapId)) {
+        return end(rpcErrors.invalidRequest({
+            message: `The snap "${snapId}" is not installed. Please install it first, before invoking the snap.`
+        }));
+    }
+    if (!hasProperty(request, 'method') || typeof request.method !== 'string') {
+        return end(rpcErrors.invalidRequest({
+            message: 'The request must have a method.'
+        }));
+    }
+    const allowedMethods = getAllowedKeyringMethods(origin);
+    if (!allowedMethods.includes(request.method)) {
+        return end(rpcErrors.invalidRequest({
+            message: `The origin "${origin}" is not allowed to invoke the method "${request.method}".`
+        }));
+    }
+    try {
+        res.result = await handleSnapRpcRequest({
+            snapId,
+            origin,
+            request,
+            handler: HandlerType.OnKeyringRequest
+        });
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+
+//# sourceMappingURL=invokeKeyring.js.map

package/dist/esm/permitted/invokeKeyring.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/invokeKeyring.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { Snap } from '@metamask/snaps-utils';\nimport {\n  HandlerType,\n  WALLET_SNAP_PERMISSION_KEY,\n  type SnapId,\n  type SnapRpcHookArgs,\n} from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { hasProperty, type Json } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport type { InvokeSnapSugarArgs } from './invokeSnapSugar';\nimport { getValidatedParams } from './invokeSnapSugar';\n\nconst hookNames: MethodHooksObject<InvokeKeyringHooks> = {\n  hasPermission: true,\n  handleSnapRpcRequest: true,\n  getSnap: true,\n  getAllowedKeyringMethods: true,\n};\n\n/**\n * `wallet_invokeKeyring` gets the requester's permitted and installed Snaps.\n */\nexport const invokeKeyringHandler: PermittedHandlerExport<\n  InvokeKeyringHooks,\n  JsonRpcRequest,\n  Json\n> = {\n  methodNames: ['wallet_invokeKeyring'],\n  implementation: invokeKeyringImplementation,\n  hookNames,\n};\n\nexport type InvokeKeyringHooks = {\n  hasPermission: (origin: string, permissionName: string) => boolean;\n\n  handleSnapRpcRequest: ({\n    snapId,\n    origin,\n    handler,\n    request,\n  }: SnapRpcHookArgs & { snapId: SnapId }) => Promise<unknown>;\n\n  getSnap: (snapId: SnapId) => Snap | undefined;\n\n  getAllowedKeyringMethods: (origin: string) => string[];\n};\n\n/**\n * The `wallet_invokeKeyring` method implementation.\n * Invokes onKeyringRequest if the snap requested is installed and connected to the dapp.\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. 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.handleSnapRpcRequest - Invokes a snap with a given RPC request.\n * @param hooks.hasPermission - Checks whether a given origin has a given permission.\n * @param hooks.getSnap - Gets information about a given snap.\n * @param hooks.getAllowedKeyringMethods - Get the list of allowed Keyring\n * methods for a given origin.\n * @returns Nothing.\n */\nasync function invokeKeyringImplementation(\n  req: JsonRpcRequest,\n  res: PendingJsonRpcResponse<Json>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  {\n    handleSnapRpcRequest,\n    hasPermission,\n    getSnap,\n    getAllowedKeyringMethods,\n  }: InvokeKeyringHooks,\n): Promise<void> {\n  let params: InvokeSnapSugarArgs;\n  try {\n    params = getValidatedParams(req.params);\n  } catch (error) {\n    return end(error);\n  }\n\n  // We expect the MM middleware stack to always add the origin to requests\n  const { origin } = req as JsonRpcRequest & { origin: string };\n  const { snapId, request } = params;\n\n  if (!origin || !hasPermission(origin, WALLET_SNAP_PERMISSION_KEY)) {\n    return end(\n      rpcErrors.invalidRequest({\n        message: `The snap \"${snapId}\" is not connected to \"${origin}\". Please connect before invoking the snap.`,\n      }),\n    );\n  }\n\n  if (!getSnap(snapId)) {\n    return end(\n      rpcErrors.invalidRequest({\n        message: `The snap \"${snapId}\" is not installed. Please install it first, before invoking the snap.`,\n      }),\n    );\n  }\n\n  if (!hasProperty(request, 'method') || typeof request.method !== 'string') {\n    return end(\n      rpcErrors.invalidRequest({\n        message: 'The request must have a method.',\n      }),\n    );\n  }\n\n  const allowedMethods = getAllowedKeyringMethods(origin);\n  if (!allowedMethods.includes(request.method)) {\n    return end(\n      rpcErrors.invalidRequest({\n        message: `The origin \"${origin}\" is not allowed to invoke the method \"${request.method}\".`,\n      }),\n    );\n  }\n\n  try {\n    res.result = (await handleSnapRpcRequest({\n      snapId,\n      origin,\n      request,\n      handler: HandlerType.OnKeyringRequest,\n    })) as Json;\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n"],"names":["rpcErrors","HandlerType","WALLET_SNAP_PERMISSION_KEY","hasProperty","getValidatedParams","hookNames","hasPermission","handleSnapRpcRequest","getSnap","getAllowedKeyringMethods","invokeKeyringHandler","methodNames","implementation","invokeKeyringImplementation","req","res","_next","end","params","error","origin","snapId","request","invalidRequest","message","method","allowedMethods","includes","result","handler","OnKeyringRequest"],"mappings":"AAEA,SAASA,SAAS,QAAQ,uBAAuB;AAEjD,SACEC,WAAW,EACXC,0BAA0B,QAGrB,wBAAwB;AAE/B,SAASC,WAAW,QAAmB,kBAAkB;AAIzD,SAASC,kBAAkB,QAAQ,oBAAoB;AAEvD,MAAMC,YAAmD;IACvDC,eAAe;IACfC,sBAAsB;IACtBC,SAAS;IACTC,0BAA0B;AAC5B;AAEA;;CAEC,GACD,OAAO,MAAMC,uBAIT;IACFC,aAAa;QAAC;KAAuB;IACrCC,gBAAgBC;IAChBR;AACF,EAAE;AAiBF;;;;;;;;;;;;;;;;CAgBC,GACD,eAAeQ,4BACbC,GAAmB,EACnBC,GAAiC,EACjCC,KAAc,EACdC,GAA6B,EAC7B,EACEV,oBAAoB,EACpBD,aAAa,EACbE,OAAO,EACPC,wBAAwB,EACL;IAErB,IAAIS;IACJ,IAAI;QACFA,SAASd,mBAAmBU,IAAII,MAAM;IACxC,EAAE,OAAOC,OAAO;QACd,OAAOF,IAAIE;IACb;IAEA,yEAAyE;IACzE,MAAM,EAAEC,MAAM,EAAE,GAAGN;IACnB,MAAM,EAAEO,MAAM,EAAEC,OAAO,EAAE,GAAGJ;IAE5B,IAAI,CAACE,UAAU,CAACd,cAAcc,QAAQlB,6BAA6B;QACjE,OAAOe,IACLjB,UAAUuB,cAAc,CAAC;YACvBC,SAAS,CAAC,UAAU,EAAEH,OAAO,uBAAuB,EAAED,OAAO,2CAA2C,CAAC;QAC3G;IAEJ;IAEA,IAAI,CAACZ,QAAQa,SAAS;QACpB,OAAOJ,IACLjB,UAAUuB,cAAc,CAAC;YACvBC,SAAS,CAAC,UAAU,EAAEH,OAAO,sEAAsE,CAAC;QACtG;IAEJ;IAEA,IAAI,CAAClB,YAAYmB,SAAS,aAAa,OAAOA,QAAQG,MAAM,KAAK,UAAU;QACzE,OAAOR,IACLjB,UAAUuB,cAAc,CAAC;YACvBC,SAAS;QACX;IAEJ;IAEA,MAAME,iBAAiBjB,yBAAyBW;IAChD,IAAI,CAACM,eAAeC,QAAQ,CAACL,QAAQG,MAAM,GAAG;QAC5C,OAAOR,IACLjB,UAAUuB,cAAc,CAAC;YACvBC,SAAS,CAAC,YAAY,EAAEJ,OAAO,uCAAuC,EAAEE,QAAQG,MAAM,CAAC,EAAE,CAAC;QAC5F;IAEJ;IAEA,IAAI;QACFV,IAAIa,MAAM,GAAI,MAAMrB,qBAAqB;YACvCc;YACAD;YACAE;YACAO,SAAS5B,YAAY6B,gBAAgB;QACvC;IACF,EAAE,OAAOX,OAAO;QACd,OAAOF,IAAIE;IACb;IAEA,OAAOF;AACT"}

package/dist/esm/permitted/invokeSnapSugar.js

@@ -0,0 +1,60 @@
+import { rpcErrors } from '@metamask/rpc-errors';
+import { isObject } from '@metamask/utils';
+/**
+ * `wallet_invokeSnap` attempts to invoke an RPC method of the specified Snap.
+ */ export const invokeSnapSugarHandler = {
+    methodNames: [
+        'wallet_invokeSnap'
+    ],
+    implementation: invokeSnapSugar,
+    hookNames: undefined
+};
+/**
+ * The `wallet_invokeSnap` method implementation.
+ * Reroutes incoming JSON-RPC requests that are targeting snaps, by modifying the method and params.
+ *
+ * @param req - The JSON-RPC request object.
+ * @param _res - The JSON-RPC response object. Not used by this
+ * function.
+ * @param next - The `json-rpc-engine` "next" callback.
+ * @param end - The `json-rpc-engine` "end" callback.
+ * @returns Nothing.
+ * @throws If the params are invalid.
+ */ export function invokeSnapSugar(req, _res, next, end) {
+    let params;
+    try {
+        params = getValidatedParams(req.params);
+    } catch (error) {
+        return end(error);
+    }
+    req.method = 'wallet_snap';
+    req.params = params;
+    return next();
+}
+/**
+ * Validates the wallet_invokeSnap method `params` and returns them cast to the correct
+ * type. Throws if validation fails.
+ *
+ * @param params - The unvalidated params object from the method request.
+ * @returns The validated method parameter object.
+ */ export function getValidatedParams(params) {
+    if (!isObject(params)) {
+        throw rpcErrors.invalidParams({
+            message: 'Expected params to be a single object.'
+        });
+    }
+    const { snapId, request } = params;
+    if (!snapId || typeof snapId !== 'string' || snapId === '') {
+        throw rpcErrors.invalidParams({
+            message: 'Must specify a valid snap ID.'
+        });
+    }
+    if (!isObject(request)) {
+        throw rpcErrors.invalidParams({
+            message: 'Expected request to be a single object.'
+        });
+    }
+    return params;
+}
+
+//# sourceMappingURL=invokeSnapSugar.js.map

package/dist/esm/permitted/invokeSnapSugar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/invokeSnapSugar.ts"],"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 { Json, JsonRpcRequest } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\nexport type InvokeSnapSugarArgs = {\n  snapId: string;\n  request: Record<string, Json>;\n};\n\n/**\n * `wallet_invokeSnap` attempts to invoke an RPC method of the specified Snap.\n */\nexport const invokeSnapSugarHandler: PermittedHandlerExport<\n  void,\n  InvokeSnapSugarArgs,\n  Json\n> = {\n  methodNames: ['wallet_invokeSnap'],\n  implementation: invokeSnapSugar,\n  hookNames: undefined,\n};\n\n/**\n * The `wallet_invokeSnap` method implementation.\n * Reroutes incoming JSON-RPC requests that are targeting snaps, by modifying the method and params.\n *\n * @param req - The JSON-RPC request object.\n * @param _res - The JSON-RPC response object. Not used by this\n * function.\n * @param next - The `json-rpc-engine` \"next\" callback.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @returns Nothing.\n * @throws If the params are invalid.\n */\nexport function invokeSnapSugar(\n  req: JsonRpcRequest<InvokeSnapSugarArgs>,\n  _res: unknown,\n  next: JsonRpcEngineNextCallback,\n  end: JsonRpcEngineEndCallback,\n): void {\n  let params: InvokeSnapSugarArgs;\n  try {\n    params = getValidatedParams(req.params);\n  } catch (error) {\n    return end(error);\n  }\n\n  req.method = 'wallet_snap';\n  req.params = params;\n  return next();\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): InvokeSnapSugarArgs {\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 InvokeSnapSugarArgs;\n}\n"],"names":["rpcErrors","isObject","invokeSnapSugarHandler","methodNames","implementation","invokeSnapSugar","hookNames","undefined","req","_res","next","end","params","getValidatedParams","error","method","invalidParams","message","snapId","request"],"mappings":"AAKA,SAASA,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,QAAQ,QAAQ,kBAAkB;AAO3C;;CAEC,GACD,OAAO,MAAMC,yBAIT;IACFC,aAAa;QAAC;KAAoB;IAClCC,gBAAgBC;IAChBC,WAAWC;AACb,EAAE;AAEF;;;;;;;;;;;CAWC,GACD,OAAO,SAASF,gBACdG,GAAwC,EACxCC,IAAa,EACbC,IAA+B,EAC/BC,GAA6B;IAE7B,IAAIC;IACJ,IAAI;QACFA,SAASC,mBAAmBL,IAAII,MAAM;IACxC,EAAE,OAAOE,OAAO;QACd,OAAOH,IAAIG;IACb;IAEAN,IAAIO,MAAM,GAAG;IACbP,IAAII,MAAM,GAAGA;IACb,OAAOF;AACT;AAEA;;;;;;CAMC,GACD,OAAO,SAASG,mBAAmBD,MAAe;IAChD,IAAI,CAACX,SAASW,SAAS;QACrB,MAAMZ,UAAUgB,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEC,MAAM,EAAEC,OAAO,EAAE,GAAGP;IAE5B,IAAI,CAACM,UAAU,OAAOA,WAAW,YAAYA,WAAW,IAAI;QAC1D,MAAMlB,UAAUgB,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,IAAI,CAAChB,SAASkB,UAAU;QACtB,MAAMnB,UAAUgB,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,OAAOL;AACT"}

package/dist/esm/permitted/middleware.js

@@ -0,0 +1,34 @@
+import { rpcErrors } from '@metamask/rpc-errors';
+import { logError } from '@metamask/snaps-utils';
+import { selectHooks } from '../utils';
+import { methodHandlers } from './handlers';
+/**
+ * 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.
+ * @returns The middleware.
+ */ export function createSnapsMethodMiddleware(isSnap, hooks) {
+    // 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 (request.method.startsWith('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);
+            }
+        }
+        return next();
+    };
+}
+
+//# sourceMappingURL=middleware.js.map

package/dist/esm/permitted/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/middleware.ts"],"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 { selectHooks } from '../utils';\nimport { methodHandlers } from './handlers';\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 (request.method.startsWith('snap_') && !isSnap) {\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"],"names":["rpcErrors","logError","selectHooks","methodHandlers","createSnapsMethodMiddleware","isSnap","hooks","methodMiddleware","request","response","next","end","handler","method","startsWith","methodNotFound","implementation","hookNames","error"],"mappings":"AACA,SAASA,SAAS,QAAQ,uBAAuB;AACjD,SAASC,QAAQ,QAAQ,wBAAwB;AAGjD,SAASC,WAAW,QAAQ,WAAW;AACvC,SAASC,cAAc,QAAQ,aAAa;AAE5C;;;;;;CAMC,GACD,OAAO,SAASC,4BACdC,MAAe,EACfC,KAA8B;IAE9B,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,eAAeC,iBAAiBC,OAAO,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,GAAG;QACjE,MAAMC,UACJT,cAAc,CAACK,QAAQK,MAAM,CAAgC;QAC/D,IAAID,SAAS;YACX,IAAIJ,QAAQK,MAAM,CAACC,UAAU,CAAC,YAAY,CAACT,QAAQ;gBACjD,OAAOM,IAAIX,UAAUe,cAAc;YACrC;YAEA,iFAAiF;YACjF,MAAM,EAAEC,cAAc,EAAEC,SAAS,EAAE,GAAGL;YACtC,IAAI;gBACF,kEAAkE;gBAClE,OAAO,MAAMI,eACXR,SACAC,UACAC,MACAC,KACAT,YAAYI,OAAOW;YAEvB,EAAE,OAAOC,OAAO;gBACdjB,SAASiB;gBACT,OAAOP,IAAIO;YACb;QACF;QAEA,OAAOR;IACT;AACF"}

package/dist/esm/permitted/requestSnaps.js

@@ -0,0 +1,117 @@
+import { rpcErrors } from '@metamask/rpc-errors';
+import { SnapCaveatType, verifyRequestedSnapPermissions } from '@metamask/snaps-utils';
+import { hasProperty, isObject } from '@metamask/utils';
+import { WALLET_SNAP_PERMISSION_KEY } from '../restricted/invokeSnap';
+import { handleInstallSnaps } from './common/snapInstallation';
+const hookNames = {
+    installSnaps: true,
+    requestPermissions: true,
+    getPermissions: true
+};
+/**
+ * `wallet_requestSnaps` installs the requested Snaps and requests permission to use them if necessary.
+ */ export const requestSnapsHandler = {
+    methodNames: [
+        'wallet_requestSnaps'
+    ],
+    implementation: requestSnapsImplementation,
+    hookNames
+};
+/**
+ * Checks whether an origin has existing `wallet_snap` permission and
+ * whether or not it has the requested snapIds caveat.
+ *
+ * @param existingPermissions - The existing permissions for the origin.
+ * @param requestedSnaps - The requested snaps.
+ * @returns True if the existing permissions satisfy the requested snaps, otherwise false.
+ */ export function hasRequestedSnaps(existingPermissions, requestedSnaps) {
+    const snapIdCaveat = existingPermissions[WALLET_SNAP_PERMISSION_KEY]?.caveats?.find((caveat)=>caveat.type === SnapCaveatType.SnapIds);
+    const permittedSnaps = snapIdCaveat?.value;
+    if (isObject(permittedSnaps)) {
+        return Object.keys(requestedSnaps).every((requestedSnap)=>hasProperty(permittedSnaps, requestedSnap));
+    }
+    return false;
+}
+/**
+ * Constructs a valid permission request with merged caveats based on existing permissions
+ * and the requested snaps.
+ *
+ * @param existingPermissions - The existing permissions for the origin.
+ * @param requestedPermissions - The permission request passed into `requestPermissions`.
+ * @returns `requestedPermissions`.
+ */ export function getSnapPermissionsRequest(existingPermissions, requestedPermissions) {
+    verifyRequestedSnapPermissions(requestedPermissions);
+    if (!existingPermissions[WALLET_SNAP_PERMISSION_KEY]) {
+        return requestedPermissions;
+    }
+    const snapIdCaveat = existingPermissions[WALLET_SNAP_PERMISSION_KEY].caveats?.find((caveat)=>caveat.type === SnapCaveatType.SnapIds);
+    const permittedSnaps = (snapIdCaveat?.value) ?? {};
+    const requestedSnaps = requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value;
+    const snapIdSet = new Set([
+        ...Object.keys(permittedSnaps),
+        ...Object.keys(requestedSnaps)
+    ]);
+    const mergedCaveatValue = [
+        ...snapIdSet
+    ].reduce((request, snapId)=>{
+        request[snapId] = requestedSnaps[snapId] ?? permittedSnaps[snapId];
+        return request;
+    }, {});
+    requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value = mergedCaveatValue;
+    return requestedPermissions;
+}
+/**
+ * The `wallet_requestSnaps` method implementation.
+ * Tries to install the requested snaps and adds them to the JSON-RPC response.
+ *
+ * @param req - The JSON-RPC request object.
+ * @param res - 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.installSnaps - A function that tries to install a given snap, prompting the user if necessary.
+ * @param hooks.requestPermissions - A function that requests permissions on
+ * behalf of a subject.
+ * @param hooks.getPermissions - A function that gets the current permissions.
+ * @returns A promise that resolves once the JSON-RPC response has been modified.
+ * @throws If the params are invalid.
+ */ async function requestSnapsImplementation(req, res, _next, end, { installSnaps, requestPermissions, getPermissions }) {
+    const requestedSnaps = req.params;
+    if (!isObject(requestedSnaps)) {
+        return end(rpcErrors.invalidParams({
+            message: '"params" must be an object.'
+        }));
+    }
+    try {
+        if (!Object.keys(requestedSnaps).length) {
+            throw new Error('Request must have at least one requested snap.');
+        }
+        const requestedPermissions = {
+            [WALLET_SNAP_PERMISSION_KEY]: {
+                caveats: [
+                    {
+                        type: SnapCaveatType.SnapIds,
+                        value: requestedSnaps
+                    }
+                ]
+            }
+        };
+        const existingPermissions = await getPermissions();
+        if (!existingPermissions) {
+            const [, metadata] = await requestPermissions(requestedPermissions);
+            res.result = metadata.data[WALLET_SNAP_PERMISSION_KEY];
+        } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {
+            res.result = await handleInstallSnaps(requestedSnaps, installSnaps);
+        } else {
+            const mergedPermissionsRequest = getSnapPermissionsRequest(existingPermissions, requestedPermissions);
+            const [, metadata] = await requestPermissions(mergedPermissionsRequest);
+            res.result = metadata.data[WALLET_SNAP_PERMISSION_KEY];
+        }
+    } catch (error) {
+        res.error = error;
+    }
+    return end();
+}
+
+//# sourceMappingURL=requestSnaps.js.map

package/dist/esm/permitted/requestSnaps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/requestSnaps.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type {\n  PermissionConstraint,\n  RequestedPermissions,\n  Caveat,\n  PermittedHandlerExport,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { SnapsPermissionRequest } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  verifyRequestedSnapPermissions,\n} from '@metamask/snaps-utils';\nimport type {\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n  Json,\n} from '@metamask/utils';\nimport { hasProperty, isObject } from '@metamask/utils';\n\nimport { WALLET_SNAP_PERMISSION_KEY } from '../restricted/invokeSnap';\nimport type { MethodHooksObject } from '../utils';\nimport type {\n  InstallSnapsHook,\n  InstallSnapsResult,\n} from './common/snapInstallation';\nimport { handleInstallSnaps } from './common/snapInstallation';\n\nconst hookNames: MethodHooksObject<RequestSnapsHooks> = {\n  installSnaps: true,\n  requestPermissions: true,\n  getPermissions: true,\n};\n\n/**\n * `wallet_requestSnaps` installs the requested Snaps and requests permission to use them if necessary.\n */\nexport const requestSnapsHandler: PermittedHandlerExport<\n  RequestSnapsHooks,\n  RequestedPermissions,\n  InstallSnapsResult\n> = {\n  methodNames: ['wallet_requestSnaps'],\n  implementation: requestSnapsImplementation,\n  hookNames,\n};\n\nexport type RequestSnapsHooks = {\n  /**\n   * Installs the requested snaps if they are permitted.\n   */\n  installSnaps: InstallSnapsHook;\n\n  /**\n   * Initiates a permission request for the requesting origin.\n   *\n   * @returns The result of the permissions request.\n   */\n  requestPermissions: (\n    permissions: RequestedPermissions,\n  ) => Promise<\n    [\n      Record<string, PermissionConstraint>,\n      { data: Record<string, unknown>; id: string; origin: string },\n    ]\n  >;\n\n  /**\n   * Gets the current permissions for the requesting origin.\n   *\n   * @returns The current permissions of the requesting origin.\n   */\n  getPermissions: () => Promise<\n    Record<string, PermissionConstraint> | undefined\n  >;\n};\n\n/**\n * Checks whether an origin has existing `wallet_snap` permission and\n * whether or not it has the requested snapIds caveat.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedSnaps - The requested snaps.\n * @returns True if the existing permissions satisfy the requested snaps, otherwise false.\n */\nexport function hasRequestedSnaps(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedSnaps: Record<string, unknown>,\n): boolean {\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ]?.caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = snapIdCaveat?.value;\n  if (isObject(permittedSnaps)) {\n    return Object.keys(requestedSnaps).every((requestedSnap) =>\n      hasProperty(permittedSnaps, requestedSnap),\n    );\n  }\n  return false;\n}\n\n/**\n * Constructs a valid permission request with merged caveats based on existing permissions\n * and the requested snaps.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedPermissions - The permission request passed into `requestPermissions`.\n * @returns `requestedPermissions`.\n */\nexport function getSnapPermissionsRequest(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedPermissions: unknown,\n): SnapsPermissionRequest {\n  verifyRequestedSnapPermissions(requestedPermissions);\n\n  if (!existingPermissions[WALLET_SNAP_PERMISSION_KEY]) {\n    return requestedPermissions;\n  }\n\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ].caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = (snapIdCaveat?.value as Record<string, Json>) ?? {};\n\n  const requestedSnaps =\n    requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value;\n\n  const snapIdSet = new Set([\n    ...Object.keys(permittedSnaps),\n    ...Object.keys(requestedSnaps),\n  ]);\n\n  const mergedCaveatValue = [...snapIdSet].reduce<Record<string, Json>>(\n    (request, snapId) => {\n      request[snapId] = requestedSnaps[snapId] ?? permittedSnaps[snapId];\n      return request;\n    },\n    {},\n  );\n\n  requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value =\n    mergedCaveatValue;\n\n  return requestedPermissions;\n}\n\n/**\n * The `wallet_requestSnaps` method implementation.\n * Tries to install the requested snaps and adds them to the JSON-RPC response.\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. 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.installSnaps - A function that tries to install a given snap, prompting the user if necessary.\n * @param hooks.requestPermissions - A function that requests permissions on\n * behalf of a subject.\n * @param hooks.getPermissions - A function that gets the current permissions.\n * @returns A promise that resolves once the JSON-RPC response has been modified.\n * @throws If the params are invalid.\n */\nasync function requestSnapsImplementation(\n  req: JsonRpcRequest<RequestedPermissions>,\n  res: PendingJsonRpcResponse<InstallSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { installSnaps, requestPermissions, getPermissions }: RequestSnapsHooks,\n): Promise<void> {\n  const requestedSnaps = req.params;\n  if (!isObject(requestedSnaps)) {\n    return end(\n      rpcErrors.invalidParams({\n        message: '\"params\" must be an object.',\n      }),\n    );\n  }\n\n  try {\n    if (!Object.keys(requestedSnaps).length) {\n      throw new Error('Request must have at least one requested snap.');\n    }\n\n    const requestedPermissions = {\n      [WALLET_SNAP_PERMISSION_KEY]: {\n        caveats: [{ type: SnapCaveatType.SnapIds, value: requestedSnaps }],\n      },\n    } as RequestedPermissions;\n    const existingPermissions = await getPermissions();\n\n    if (!existingPermissions) {\n      const [, metadata] = await requestPermissions(requestedPermissions);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as InstallSnapsResult;\n    } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {\n      res.result = await handleInstallSnaps(requestedSnaps, installSnaps);\n    } else {\n      const mergedPermissionsRequest = getSnapPermissionsRequest(\n        existingPermissions,\n        requestedPermissions,\n      );\n\n      const [, metadata] = await requestPermissions(mergedPermissionsRequest);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as InstallSnapsResult;\n    }\n  } catch (error) {\n    res.error = error;\n  }\n\n  return end();\n}\n"],"names":["rpcErrors","SnapCaveatType","verifyRequestedSnapPermissions","hasProperty","isObject","WALLET_SNAP_PERMISSION_KEY","handleInstallSnaps","hookNames","installSnaps","requestPermissions","getPermissions","requestSnapsHandler","methodNames","implementation","requestSnapsImplementation","hasRequestedSnaps","existingPermissions","requestedSnaps","snapIdCaveat","caveats","find","caveat","type","SnapIds","permittedSnaps","value","Object","keys","every","requestedSnap","getSnapPermissionsRequest","requestedPermissions","snapIdSet","Set","mergedCaveatValue","reduce","request","snapId","req","res","_next","end","params","invalidParams","message","length","Error","metadata","result","data","mergedPermissionsRequest","error"],"mappings":"AAOA,SAASA,SAAS,QAAQ,uBAAuB;AAEjD,SACEC,cAAc,EACdC,8BAA8B,QACzB,wBAAwB;AAM/B,SAASC,WAAW,EAAEC,QAAQ,QAAQ,kBAAkB;AAExD,SAASC,0BAA0B,QAAQ,2BAA2B;AAMtE,SAASC,kBAAkB,QAAQ,4BAA4B;AAE/D,MAAMC,YAAkD;IACtDC,cAAc;IACdC,oBAAoB;IACpBC,gBAAgB;AAClB;AAEA;;CAEC,GACD,OAAO,MAAMC,sBAIT;IACFC,aAAa;QAAC;KAAsB;IACpCC,gBAAgBC;IAChBP;AACF,EAAE;AAgCF;;;;;;;CAOC,GACD,OAAO,SAASQ,kBACdC,mBAAyD,EACzDC,cAAuC;IAEvC,MAAMC,eAAeF,mBAAmB,CACtCX,2BACD,EAAEc,SAASC,KACV,CAACC,SAAiCA,OAAOC,IAAI,KAAKrB,eAAesB,OAAO;IAG1E,MAAMC,iBAAiBN,cAAcO;IACrC,IAAIrB,SAASoB,iBAAiB;QAC5B,OAAOE,OAAOC,IAAI,CAACV,gBAAgBW,KAAK,CAAC,CAACC,gBACxC1B,YAAYqB,gBAAgBK;IAEhC;IACA,OAAO;AACT;AAEA;;;;;;;CAOC,GACD,OAAO,SAASC,0BACdd,mBAAyD,EACzDe,oBAA6B;IAE7B7B,+BAA+B6B;IAE/B,IAAI,CAACf,mBAAmB,CAACX,2BAA2B,EAAE;QACpD,OAAO0B;IACT;IAEA,MAAMb,eAAeF,mBAAmB,CACtCX,2BACD,CAACc,OAAO,EAAEC,KACT,CAACC,SAAiCA,OAAOC,IAAI,KAAKrB,eAAesB,OAAO;IAG1E,MAAMC,iBAAiB,CAACN,cAAcO,KAA6B,KAAK,CAAC;IAEzE,MAAMR,iBACJc,oBAAoB,CAAC1B,2BAA2B,CAACc,OAAO,CAAC,EAAE,CAACM,KAAK;IAEnE,MAAMO,YAAY,IAAIC,IAAI;WACrBP,OAAOC,IAAI,CAACH;WACZE,OAAOC,IAAI,CAACV;KAChB;IAED,MAAMiB,oBAAoB;WAAIF;KAAU,CAACG,MAAM,CAC7C,CAACC,SAASC;QACRD,OAAO,CAACC,OAAO,GAAGpB,cAAc,CAACoB,OAAO,IAAIb,cAAc,CAACa,OAAO;QAClE,OAAOD;IACT,GACA,CAAC;IAGHL,oBAAoB,CAAC1B,2BAA2B,CAACc,OAAO,CAAC,EAAE,CAACM,KAAK,GAC/DS;IAEF,OAAOH;AACT;AAEA;;;;;;;;;;;;;;;;CAgBC,GACD,eAAejB,2BACbwB,GAAyC,EACzCC,GAA+C,EAC/CC,KAAc,EACdC,GAA6B,EAC7B,EAAEjC,YAAY,EAAEC,kBAAkB,EAAEC,cAAc,EAAqB;IAEvE,MAAMO,iBAAiBqB,IAAII,MAAM;IACjC,IAAI,CAACtC,SAASa,iBAAiB;QAC7B,OAAOwB,IACLzC,UAAU2C,aAAa,CAAC;YACtBC,SAAS;QACX;IAEJ;IAEA,IAAI;QACF,IAAI,CAAClB,OAAOC,IAAI,CAACV,gBAAgB4B,MAAM,EAAE;YACvC,MAAM,IAAIC,MAAM;QAClB;QAEA,MAAMf,uBAAuB;YAC3B,CAAC1B,2BAA2B,EAAE;gBAC5Bc,SAAS;oBAAC;wBAAEG,MAAMrB,eAAesB,OAAO;wBAAEE,OAAOR;oBAAe;iBAAE;YACpE;QACF;QACA,MAAMD,sBAAsB,MAAMN;QAElC,IAAI,CAACM,qBAAqB;YACxB,MAAM,GAAG+B,SAAS,GAAG,MAAMtC,mBAAmBsB;YAC9CQ,IAAIS,MAAM,GAAGD,SAASE,IAAI,CACxB5C,2BACD;QACH,OAAO,IAAIU,kBAAkBC,qBAAqBC,iBAAiB;YACjEsB,IAAIS,MAAM,GAAG,MAAM1C,mBAAmBW,gBAAgBT;QACxD,OAAO;YACL,MAAM0C,2BAA2BpB,0BAC/Bd,qBACAe;YAGF,MAAM,GAAGgB,SAAS,GAAG,MAAMtC,mBAAmByC;YAC9CX,IAAIS,MAAM,GAAGD,SAASE,IAAI,CACxB5C,2BACD;QACH;IACF,EAAE,OAAO8C,OAAO;QACdZ,IAAIY,KAAK,GAAGA;IACd;IAEA,OAAOV;AACT"}

package/dist/esm/request.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=request.js.map

package/dist/esm/request.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/request.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  PermissionType,\n  RestrictedMethodOptions,\n  PermittedHandlerExport,\n} from '@metamask/permission-controller';\nimport type { JsonRpcParams } from '@metamask/utils';\n\nimport type { methodHandlers } from './permitted';\nimport type { restrictedMethodPermissionBuilders } from './restricted';\n\n/**\n * Get the method implementation from a {@link PermittedHandlerExport}.\n *\n * @template Handler - A permitted handler export.\n */\ntype PermittedMethodImplementation<Handler> =\n  Handler extends PermittedHandlerExport<any, infer Args, infer Result>\n    ? (args: Args) => Promise<Result>\n    : never;\n\n/**\n * Get a JSON-RPC method type from a {@link PermittedHandlerExport} and a method\n * name.\n *\n * @template MethodName - The name of the method.\n * @template Handler - A permitted handler export.\n */\ntype PermittedMethod<\n  MethodName extends string,\n  Handler,\n> = PermittedMethodImplementation<Handler> extends (\n  args: infer Args,\n) => infer Return\n  ? (args: { method: MethodName; params?: Args }) => Return\n  : never;\n\n/**\n * Get a restricted method implementation from a\n * {@link PermissionSpecificationBuilder}.\n *\n * @template Builder - A permission specification builder.\n */\ntype RestrictedMethodImplementation<Builder> = Builder extends {\n  specificationBuilder: PermissionSpecificationBuilder<\n    PermissionType.RestrictedMethod,\n    any,\n    infer Specification\n  >;\n}\n  ? Specification['methodImplementation']\n  : never;\n\n/**\n * Get a JSON-RPC method type from a {@link PermissionSpecificationBuilder}.\n *\n * @template Builder - A permission specification builder.\n */\ntype RestrictedMethod<Builder extends { targetName: string }> =\n  RestrictedMethodImplementation<Builder> extends (\n    args: infer Args,\n  ) => infer Return\n    ? Args extends RestrictedMethodOptions<infer Params>\n      ? (args: { method: Builder['targetName']; params?: Params }) => Return\n      : never\n    : never;\n\n/**\n * A type containing all permitted JSON-RPC methods as functions.\n */\ntype PermittedMethodFunction = {\n  [MethodName in keyof typeof methodHandlers]: PermittedMethod<\n    MethodName,\n    (typeof methodHandlers)[MethodName]\n  >;\n};\n\n/**\n * A type containing all restricted JSON-RPC methods as functions.\n */\ntype RestrictedMethodFunction = {\n  [Builder in keyof typeof restrictedMethodPermissionBuilders]: RestrictedMethod<\n    (typeof restrictedMethodPermissionBuilders)[Builder]\n  >;\n};\n\n/**\n * A type containing all supported JSON-RPC methods as functions.\n */\ntype MethodFunction = RestrictedMethodFunction & PermittedMethodFunction;\n\n/**\n * Fallback method name. `wallet_*` is supported by Snaps, but these functions\n * are not implemented in `@metamask/snaps-rpc-methods`, so we don't have a type for\n * them.\n */\ntype WalletMethodName = `wallet_${string}`;\n\n/**\n * Get a typed function if the method is defined in {@link MethodFunction}, or\n * a generic function if the method name extends {@link WalletMethodName}.\n * Otherwise, this returns `never`.\n */\ntype MethodFunctionFallback<MethodName> =\n  MethodName extends keyof MethodFunction\n    ? MethodFunction[MethodName]\n    : MethodName extends WalletMethodName\n    ? (args: { method: MethodName; params?: JsonRpcParams }) => Promise<unknown>\n    : never;\n\n/**\n * Get the JSON-RPC object from a method name.\n *\n * @template MethodName - The name of the method. In most cases this is inferred\n * from the args.\n */\nexport type ObjectFromMethodName<\n  MethodName extends keyof MethodFunction | WalletMethodName,\n> = {\n  method: MethodName;\n  params?: Parameters<MethodFunctionFallback<MethodName>>[0] extends {\n    params?: infer Params;\n  }\n    ? Params\n    : never;\n};\n\nexport type MethodReturnType<\n  MethodName extends keyof MethodFunction | WalletMethodName,\n> = ReturnType<MethodFunctionFallback<MethodName>>;\n\n/**\n * A function that takes a JSON-RPC request and returns a JSON-RPC response.\n *\n * @template MethodName - The name of the method. In most cases this is inferred\n * from the args.\n */\nexport type RequestFunction = <\n  MethodName extends keyof MethodFunction | WalletMethodName,\n>(\n  args: ObjectFromMethodName<MethodName>,\n) => MethodReturnType<MethodName>;\n\n/**\n * The global `snap` object. This is injected into the global scope of a snap.\n */\nexport type SnapsGlobalObject = {\n  request: RequestFunction;\n};\n"],"names":[],"mappings":"AAAA,WAoJE"}

package/dist/esm/restricted/caveats/index.js

@@ -0,0 +1,20 @@
+import { getBip32EntropyBuilder } from '../getBip32Entropy';
+import { getBip32PublicKeyBuilder } from '../getBip32PublicKey';
+import { getBip44EntropyBuilder } from '../getBip44Entropy';
+import { invokeSnapBuilder } from '../invokeSnap';
+import { permittedCoinTypesCaveatMapper, PermittedCoinTypesCaveatSpecification } from './permittedCoinTypes';
+import { permittedDerivationPathsCaveatMapper, PermittedDerivationPathsCaveatSpecification } from './permittedDerivationPaths';
+import { snapIdsCaveatMapper, SnapIdsCaveatSpecification } from './snapIds';
+export const caveatSpecifications = {
+    ...PermittedDerivationPathsCaveatSpecification,
+    ...PermittedCoinTypesCaveatSpecification,
+    ...SnapIdsCaveatSpecification
+};
+export const caveatMappers = {
+    [getBip32EntropyBuilder.targetName]: permittedDerivationPathsCaveatMapper,
+    [getBip32PublicKeyBuilder.targetName]: permittedDerivationPathsCaveatMapper,
+    [getBip44EntropyBuilder.targetName]: permittedCoinTypesCaveatMapper,
+    [invokeSnapBuilder.targetName]: snapIdsCaveatMapper
+};
+
+//# sourceMappingURL=index.js.map

package/dist/esm/restricted/caveats/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/restricted/caveats/index.ts"],"sourcesContent":["import type { PermissionConstraint } from '@metamask/permission-controller';\nimport type { Json } from '@metamask/utils';\n\nimport { getBip32EntropyBuilder } from '../getBip32Entropy';\nimport { getBip32PublicKeyBuilder } from '../getBip32PublicKey';\nimport { getBip44EntropyBuilder } from '../getBip44Entropy';\nimport { invokeSnapBuilder } from '../invokeSnap';\nimport {\n  permittedCoinTypesCaveatMapper,\n  PermittedCoinTypesCaveatSpecification,\n} from './permittedCoinTypes';\nimport {\n  permittedDerivationPathsCaveatMapper,\n  PermittedDerivationPathsCaveatSpecification,\n} from './permittedDerivationPaths';\nimport { snapIdsCaveatMapper, SnapIdsCaveatSpecification } from './snapIds';\n\nexport const caveatSpecifications = {\n  ...PermittedDerivationPathsCaveatSpecification,\n  ...PermittedCoinTypesCaveatSpecification,\n  ...SnapIdsCaveatSpecification,\n} as const;\n\nexport const caveatMappers: Record<\n  string,\n  (value: Json) => Pick<PermissionConstraint, 'caveats'>\n> = {\n  [getBip32EntropyBuilder.targetName]: permittedDerivationPathsCaveatMapper,\n  [getBip32PublicKeyBuilder.targetName]: permittedDerivationPathsCaveatMapper,\n  [getBip44EntropyBuilder.targetName]: permittedCoinTypesCaveatMapper,\n  [invokeSnapBuilder.targetName]: snapIdsCaveatMapper,\n};\n"],"names":["getBip32EntropyBuilder","getBip32PublicKeyBuilder","getBip44EntropyBuilder","invokeSnapBuilder","permittedCoinTypesCaveatMapper","PermittedCoinTypesCaveatSpecification","permittedDerivationPathsCaveatMapper","PermittedDerivationPathsCaveatSpecification","snapIdsCaveatMapper","SnapIdsCaveatSpecification","caveatSpecifications","caveatMappers","targetName"],"mappings":"AAGA,SAASA,sBAAsB,QAAQ,qBAAqB;AAC5D,SAASC,wBAAwB,QAAQ,uBAAuB;AAChE,SAASC,sBAAsB,QAAQ,qBAAqB;AAC5D,SAASC,iBAAiB,QAAQ,gBAAgB;AAClD,SACEC,8BAA8B,EAC9BC,qCAAqC,QAChC,uBAAuB;AAC9B,SACEC,oCAAoC,EACpCC,2CAA2C,QACtC,6BAA6B;AACpC,SAASC,mBAAmB,EAAEC,0BAA0B,QAAQ,YAAY;AAE5E,OAAO,MAAMC,uBAAuB;IAClC,GAAGH,2CAA2C;IAC9C,GAAGF,qCAAqC;IACxC,GAAGI,0BAA0B;AAC/B,EAAW;AAEX,OAAO,MAAME,gBAGT;IACF,CAACX,uBAAuBY,UAAU,CAAC,EAAEN;IACrC,CAACL,yBAAyBW,UAAU,CAAC,EAAEN;IACvC,CAACJ,uBAAuBU,UAAU,CAAC,EAAER;IACrC,CAACD,kBAAkBS,UAAU,CAAC,EAAEJ;AAClC,EAAE"}

package/dist/esm/restricted/caveats/permittedCoinTypes.js

@@ -0,0 +1,77 @@
+import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
+import { FORBIDDEN_COIN_TYPES, SnapCaveatType } from '@metamask/snaps-utils';
+import { hasProperty, isPlainObject } from '@metamask/utils';
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionsController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */ export function permittedCoinTypesCaveatMapper(value) {
+    return {
+        caveats: [
+            {
+                type: SnapCaveatType.PermittedCoinTypes,
+                value
+            }
+        ]
+    };
+}
+/**
+ * Validate the params for `snap_getBip44Entropy`.
+ *
+ * @param value - The params to validate.
+ * @throws If the params are invalid.
+ */ export function validateBIP44Params(value) {
+    if (!isPlainObject(value) || !hasProperty(value, 'coinType')) {
+        throw rpcErrors.invalidParams({
+            message: 'Expected a plain object containing a coin type.'
+        });
+    }
+    if (typeof value.coinType !== 'number' || !Number.isInteger(value.coinType) || value.coinType < 0 || value.coinType > 0x7fffffff) {
+        throw rpcErrors.invalidParams({
+            message: 'Invalid "coinType" parameter. Coin type must be a non-negative integer.'
+        });
+    }
+    if (FORBIDDEN_COIN_TYPES.includes(value.coinType)) {
+        throw rpcErrors.invalidParams({
+            message: `Coin type ${value.coinType} is forbidden.`
+        });
+    }
+}
+/**
+ * Validate the coin types values associated with a caveat. This checks if the
+ * values are non-negative integers (>= 0).
+ *
+ * @param caveat - The caveat to validate.
+ * @throws If the caveat is invalid.
+ */ export function validateBIP44Caveat(caveat) {
+    if (!hasProperty(caveat, 'value') || !Array.isArray(caveat.value) || caveat.value.length === 0) {
+        throw rpcErrors.invalidParams({
+            message: 'Expected non-empty array of coin types.'
+        });
+    }
+    caveat.value.forEach(validateBIP44Params);
+}
+export const PermittedCoinTypesCaveatSpecification = {
+    [SnapCaveatType.PermittedCoinTypes]: Object.freeze({
+        type: SnapCaveatType.PermittedCoinTypes,
+        decorator: (method, caveat)=>{
+            return async (args)=>{
+                const { params } = args;
+                validateBIP44Params(params);
+                const coinType = caveat.value.find((caveatValue)=>caveatValue.coinType === params.coinType);
+                if (!coinType) {
+                    throw providerErrors.unauthorized({
+                        message: 'The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest.'
+                    });
+                }
+                return await method(args);
+            };
+        },
+        validator: (caveat)=>validateBIP44Caveat(caveat)
+    })
+};
+
+//# sourceMappingURL=permittedCoinTypes.js.map

package/dist/esm/restricted/caveats/permittedCoinTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/restricted/caveats/permittedCoinTypes.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  RestrictedMethodCaveatSpecificationConstraint,\n  Caveat,\n} from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport { FORBIDDEN_COIN_TYPES, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, isPlainObject } from '@metamask/utils';\n\nimport type { GetBip44EntropyParams } from '../getBip44Entropy';\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function permittedCoinTypesCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.PermittedCoinTypes,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validate the params for `snap_getBip44Entropy`.\n *\n * @param value - The params to validate.\n * @throws If the params are invalid.\n */\nexport function validateBIP44Params(\n  value: unknown,\n): asserts value is GetBip44EntropyParams {\n  if (!isPlainObject(value) || !hasProperty(value, 'coinType')) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object containing a coin type.',\n    });\n  }\n\n  if (\n    typeof value.coinType !== 'number' ||\n    !Number.isInteger(value.coinType) ||\n    value.coinType < 0 ||\n    value.coinType > 0x7fffffff\n  ) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Invalid \"coinType\" parameter. Coin type must be a non-negative integer.',\n    });\n  }\n\n  if (FORBIDDEN_COIN_TYPES.includes(value.coinType)) {\n    throw rpcErrors.invalidParams({\n      message: `Coin type ${value.coinType} is forbidden.`,\n    });\n  }\n}\n\n/**\n * Validate the coin types values associated with a caveat. This checks if the\n * values are non-negative integers (>= 0).\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateBIP44Caveat(caveat: Caveat<string, any>) {\n  if (\n    !hasProperty(caveat, 'value') ||\n    !Array.isArray(caveat.value) ||\n    caveat.value.length === 0\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected non-empty array of coin types.',\n    });\n  }\n\n  caveat.value.forEach(validateBIP44Params);\n}\n\nexport const PermittedCoinTypesCaveatSpecification: Record<\n  SnapCaveatType.PermittedCoinTypes,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.PermittedCoinTypes]: Object.freeze({\n    type: SnapCaveatType.PermittedCoinTypes,\n    decorator: (\n      method,\n      caveat: Caveat<\n        SnapCaveatType.PermittedCoinTypes,\n        GetBip44EntropyParams[]\n      >,\n    ) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP44Params(params);\n\n        const coinType = caveat.value.find(\n          (caveatValue) => caveatValue.coinType === params.coinType,\n        );\n\n        if (!coinType) {\n          throw providerErrors.unauthorized({\n            message:\n              'The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest.',\n          });\n        }\n\n        return await method(args);\n      };\n    },\n    validator: (caveat) => validateBIP44Caveat(caveat),\n  }),\n};\n"],"names":["providerErrors","rpcErrors","FORBIDDEN_COIN_TYPES","SnapCaveatType","hasProperty","isPlainObject","permittedCoinTypesCaveatMapper","value","caveats","type","PermittedCoinTypes","validateBIP44Params","invalidParams","message","coinType","Number","isInteger","includes","validateBIP44Caveat","caveat","Array","isArray","length","forEach","PermittedCoinTypesCaveatSpecification","Object","freeze","decorator","method","args","params","find","caveatValue","unauthorized","validator"],"mappings":"AAKA,SAASA,cAAc,EAAEC,SAAS,QAAQ,uBAAuB;AACjE,SAASC,oBAAoB,EAAEC,cAAc,QAAQ,wBAAwB;AAE7E,SAASC,WAAW,EAAEC,aAAa,QAAQ,kBAAkB;AAI7D;;;;;;;CAOC,GACD,OAAO,SAASC,+BACdC,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAMN,eAAeO,kBAAkB;gBACvCH;YACF;SACD;IACH;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASI,oBACdJ,KAAc;IAEd,IAAI,CAACF,cAAcE,UAAU,CAACH,YAAYG,OAAO,aAAa;QAC5D,MAAMN,UAAUW,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,IACE,OAAON,MAAMO,QAAQ,KAAK,YAC1B,CAACC,OAAOC,SAAS,CAACT,MAAMO,QAAQ,KAChCP,MAAMO,QAAQ,GAAG,KACjBP,MAAMO,QAAQ,GAAG,YACjB;QACA,MAAMb,UAAUW,aAAa,CAAC;YAC5BC,SACE;QACJ;IACF;IAEA,IAAIX,qBAAqBe,QAAQ,CAACV,MAAMO,QAAQ,GAAG;QACjD,MAAMb,UAAUW,aAAa,CAAC;YAC5BC,SAAS,CAAC,UAAU,EAAEN,MAAMO,QAAQ,CAAC,cAAc,CAAC;QACtD;IACF;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASI,oBAAoBC,MAA2B;IAC7D,IACE,CAACf,YAAYe,QAAQ,YACrB,CAACC,MAAMC,OAAO,CAACF,OAAOZ,KAAK,KAC3BY,OAAOZ,KAAK,CAACe,MAAM,KAAK,GACxB;QACA,MAAMrB,UAAUW,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEAM,OAAOZ,KAAK,CAACgB,OAAO,CAACZ;AACvB;AAEA,OAAO,MAAMa,wCAGT;IACF,CAACrB,eAAeO,kBAAkB,CAAC,EAAEe,OAAOC,MAAM,CAAC;QACjDjB,MAAMN,eAAeO,kBAAkB;QACvCiB,WAAW,CACTC,QACAT;YAKA,OAAO,OAAOU;gBACZ,MAAM,EAAEC,MAAM,EAAE,GAAGD;gBACnBlB,oBAAoBmB;gBAEpB,MAAMhB,WAAWK,OAAOZ,KAAK,CAACwB,IAAI,CAChC,CAACC,cAAgBA,YAAYlB,QAAQ,KAAKgB,OAAOhB,QAAQ;gBAG3D,IAAI,CAACA,UAAU;oBACb,MAAMd,eAAeiC,YAAY,CAAC;wBAChCpB,SACE;oBACJ;gBACF;gBAEA,OAAO,MAAMe,OAAOC;YACtB;QACF;QACAK,WAAW,CAACf,SAAWD,oBAAoBC;IAC7C;AACF,EAAE"}