@metamask/snaps-rpc-methods 3.1.0

package/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [3.1.0]
+### Changed
+- Rename package to `@metamask/snaps-rpc-methods` ([#1864](https://github.com/MetaMask/snaps/pull/1864))
+- Update multiple MetaMask dependencies ([#1841](https://github.com/MetaMask/snaps/pull/1841))
+
+## [3.0.0]
+### Added
+- Add keyring export and endowment ([#1787](https://github.com/MetaMask/snaps/pull/1787))
+
+### Changed
+- **BREAKING:** Bump minimum Node.js version to `^18.16.0` ([#1741](https://github.com/MetaMask/snaps/pull/1741))
+
+## [2.0.0]
+### Changed
+- Initial stable release from main branch ([#1757](https://github.com/MetaMask/snaps/pull/1757))
+
+## [0.38.3-flask.1]
+### Changed
+- Bump `metamask/utils` and `metamask/snaps-registry` ([#1738](https://github.com/MetaMask/snaps/pull/1738))
+
+## [0.38.2-flask.1]
+### Changed
+- Remove business-logic callbacks from `manageAccounts` ([#1725](https://github.com/MetaMask/snaps/pull/1725))
+- Bump `@metamask/utils` and `@metamask/snaps-registry` ([#1694](https://github.com/MetaMask/snaps/pull/1694))
+
+## [0.38.1-flask.1]
+### Fixed
+- Make `manageAccounts` arguments extend `RestrictedMethodParameters` ([#1687](https://github.com/MetaMask/snaps/pull/1687))
+
+## [0.38.0-flask.1]
+### Added
+- Add `snap_getLocale` JSON-RPC method ([#1557](https://github.com/MetaMask/snaps/pull/1557))
+   - This will let snaps get the user locale from the client.
+
+### Fixed
+- Fix ed25519 public key derivation ([#1678](https://github.com/MetaMask/snaps/pull/1678))
+
+## [0.37.2-flask.1]
+### Changed
+- Release package independently ([#1600](https://github.com/MetaMask/snaps/pull/1600))
+  - The version of the package no longer needs to match the version of all other
+    MetaMask Snaps packages.
+
+[Unreleased]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@3.1.0...HEAD
+[3.1.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@3.0.0...@metamask/snaps-rpc-methods@3.1.0
+[3.0.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@2.0.0...@metamask/snaps-rpc-methods@3.0.0
+[2.0.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@0.38.3-flask.1...@metamask/snaps-rpc-methods@2.0.0
+[0.38.3-flask.1]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@0.38.2-flask.1...@metamask/snaps-rpc-methods@0.38.3-flask.1
+[0.38.2-flask.1]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@0.38.1-flask.1...@metamask/snaps-rpc-methods@0.38.2-flask.1
+[0.38.1-flask.1]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@0.38.0-flask.1...@metamask/snaps-rpc-methods@0.38.1-flask.1
+[0.38.0-flask.1]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-rpc-methods@0.37.2-flask.1...@metamask/snaps-rpc-methods@0.38.0-flask.1
+[0.37.2-flask.1]: https://github.com/MetaMask/snaps/releases/tag/@metamask/snaps-rpc-methods@0.37.2-flask.1

package/LICENSE

@@ -0,0 +1,18 @@
+Copyright ConsenSys Software Inc. 2021. All rights reserved.
+ 
+You acknowledge and agree that ConsenSys Software Inc. (“ConsenSys”) (or ConsenSys’s licensors) own all legal right, title and interest in and to the work, software, application, source code, documentation and any other documents in this repository (collectively, the “Program”), including any intellectual property rights which subsist in the Program (whether those rights happen to be registered or not, and wherever in the world those rights may exist), whether in source code or any other form.
+ 
+Subject to the limited license below, you may not (and you may not permit anyone else to) distribute, publish, copy, modify, merge, combine with another program, create derivative works of, reverse engineer, decompile or otherwise attempt to extract the source code of, the Program or any part thereof, except that you may contribute to this repository.
+ 
+You are granted a non-exclusive, non-transferable, non-sublicensable license to distribute, publish, copy, modify, merge, combine with another program or create derivative works of the Program (such resulting program, collectively, the “Resulting Program”) solely for Non-Commercial Use as long as you:
+ 1. give prominent notice (“Notice”) with each copy of the Resulting Program that the Program is used in the Resulting Program and that the Program is the copyright of ConsenSys; and
+ 2. subject the Resulting Program and any distribution, publication, copy, modification, merger therewith, combination with another program or derivative works thereof to the same Notice requirement and Non-Commercial Use restriction set forth herein.
+ 
+“Non-Commercial Use” means each use as described in clauses (1)-(3) below, as reasonably determined by ConsenSys in its sole discretion: 
+ 1. personal use for research, personal study, private entertainment, hobby projects or amateur pursuits, in each case without any anticipated commercial application;
+ 2. use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization or government institution; or
+ 3. the number of monthly active users of the Resulting Program across all versions thereof and platforms globally do not exceed 10,000 at any time.
+ 
+You will not use any trade mark, service mark, trade name, logo of ConsenSys or any other company or organization in a way that is likely or intended to cause confusion about the owner or authorized user of such marks, names or logos.
+ 
+If you have any questions, comments or interest in pursuing any other use cases, please reach out to us at metamask.license@consensys.net.

package/README.md

@@ -0,0 +1,3 @@
+# @metamask/snaps-rpc-methods
+
+JSON-RPC methods for MetaMask Snaps functionality.

package/dist/cjs/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    permittedMethods: function() {
+        return _permitted.handlers;
+    },
+    createSnapsMethodMiddleware: function() {
+        return _permitted.createSnapsMethodMiddleware;
+    },
+    SnapCaveatType: function() {
+        return _snapsutils.SnapCaveatType;
+    },
+    selectHooks: function() {
+        return _utils.selectHooks;
+    }
+});
+const _permitted = require("./permitted");
+_export_star(require("./restricted"), exports);
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("./utils");
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export type { PermittedRpcMethodHooks } from './permitted';\nexport {\n  handlers as permittedMethods,\n  createSnapsMethodMiddleware,\n} from './permitted';\nexport * from './restricted';\nexport { SnapCaveatType } from '@metamask/snaps-utils';\nexport { selectHooks } from './utils';\nexport type { RequestFunction, SnapsGlobalObject } from './request';\n"],"names":["permittedMethods","handlers","createSnapsMethodMiddleware","SnapCaveatType","selectHooks"],"mappings":";;;;;;;;;;;IAEcA,gBAAgB;eAA5BC,mBAAQ;;IACRC,2BAA2B;eAA3BA,sCAA2B;;IAGpBC,cAAc;eAAdA,0BAAc;;IACdC,WAAW;eAAXA,kBAAW;;;2BAHb;qBACO;4BACiB;uBACH"}

package/dist/cjs/permitted/common/snapInstallation.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "handleInstallSnaps", {
+    enumerable: true,
+    get: function() {
+        return handleInstallSnaps;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _utils = require("@metamask/utils");
+async function handleInstallSnaps(requestedSnaps, installSnaps) {
+    if (!(0, _utils.isObject)(requestedSnaps)) {
+        throw _rpcerrors.rpcErrors.invalidParams({
+            message: `Invalid snap installation params.`,
+            data: {
+                requestedSnaps
+            }
+        });
+    } else if (Object.keys(requestedSnaps).length === 0) {
+        throw _rpcerrors.rpcErrors.invalidParams({
+            message: `Must specify at least one snap to install.`,
+            data: {
+                requestedSnaps
+            }
+        });
+    }
+    // installSnaps is bound to the origin
+    return await installSnaps(requestedSnaps);
+}
+
+//# sourceMappingURL=snapInstallation.js.map

package/dist/cjs/permitted/common/snapInstallation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/permitted/common/snapInstallation.ts"],"sourcesContent":["import type { RequestedPermissions } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { InstallSnapsResult } from '@metamask/snaps-utils';\nimport { isObject } from '@metamask/utils';\n\nexport type { InstallSnapsResult } from '@metamask/snaps-utils';\n\nexport type InstallSnapsHook = (\n  requestedSnaps: RequestedPermissions,\n) => Promise<InstallSnapsResult>;\n\n/**\n * Typechecks the requested snaps and passes them to the permissions\n * controller for installation.\n *\n * @param requestedSnaps - An object containing the requested snaps to be installed. The key of the\n * object is the snap id and the value is potential extra data, i.e. version.\n * @param installSnaps - A function that tries to install a given snap, prompting the user if\n * necessary.\n * @returns An object containing the installed snaps.\n * @throws If the params are invalid or the snap installation fails.\n */\nexport async function handleInstallSnaps(\n  requestedSnaps: RequestedPermissions,\n  installSnaps: InstallSnapsHook,\n): Promise<InstallSnapsResult> {\n  if (!isObject(requestedSnaps)) {\n    throw rpcErrors.invalidParams({\n      message: `Invalid snap installation params.`,\n      data: { requestedSnaps },\n    });\n  } else if (Object.keys(requestedSnaps).length === 0) {\n    throw rpcErrors.invalidParams({\n      message: `Must specify at least one snap to install.`,\n      data: { requestedSnaps },\n    });\n  }\n\n  // installSnaps is bound to the origin\n  return await installSnaps(requestedSnaps);\n}\n"],"names":["handleInstallSnaps","requestedSnaps","installSnaps","isObject","rpcErrors","invalidParams","message","data","Object","keys","length"],"mappings":";;;;+BAsBsBA;;;eAAAA;;;2BArBI;uBAED;AAmBlB,eAAeA,mBACpBC,cAAoC,EACpCC,YAA8B;IAE9B,IAAI,CAACC,IAAAA,eAAQ,EAACF,iBAAiB;QAC7B,MAAMG,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS,CAAC,iCAAiC,CAAC;YAC5CC,MAAM;gBAAEN;YAAe;QACzB;IACF,OAAO,IAAIO,OAAOC,IAAI,CAACR,gBAAgBS,MAAM,KAAK,GAAG;QACnD,MAAMN,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS,CAAC,0CAA0C,CAAC;YACrDC,MAAM;gBAAEN;YAAe;QACzB;IACF;IAEA,sCAAsC;IACtC,OAAO,MAAMC,aAAaD;AAC5B"}

package/dist/cjs/permitted/getFile.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    GetFileArgsStruct: function() {
+        return GetFileArgsStruct;
+    },
+    getFileHandler: function() {
+        return getFileHandler;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _superstruct = require("superstruct");
+const GetFileArgsStruct = (0, _superstruct.object)({
+    path: (0, _superstruct.string)(),
+    encoding: (0, _superstruct.optional)((0, _superstruct.union)([
+        (0, _snapsutils.enumValue)(_snapsutils.AuxiliaryFileEncoding.Base64),
+        (0, _snapsutils.enumValue)(_snapsutils.AuxiliaryFileEncoding.Hex),
+        (0, _snapsutils.enumValue)(_snapsutils.AuxiliaryFileEncoding.Utf8)
+    ]))
+});
+const hookNames = {
+    getSnapFile: true
+};
+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;
+    (0, _utils.assertStruct)(params, GetFileArgsStruct, 'Invalid "snap_getFile" parameters', _rpcerrors.rpcErrors.invalidParams);
+    try {
+        res.result = await getSnapFile(params.path, params.encoding ?? _snapsutils.AuxiliaryFileEncoding.Base64);
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+
+//# sourceMappingURL=getFile.js.map

package/dist/cjs/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":["GetFileArgsStruct","getFileHandler","object","path","string","encoding","optional","union","enumValue","AuxiliaryFileEncoding","Base64","Hex","Utf8","hookNames","getSnapFile","methodNames","implementation","req","res","_next","end","params","assertStruct","rpcErrors","invalidParams","result","error"],"mappings":";;;;;;;;;;;IAeaA,iBAAiB;eAAjBA;;IAiBAC,cAAc;eAAdA;;;2BA9Ba;4BACuB;uBAMpB;6BAEmB;AAIzC,MAAMD,oBAAoBE,IAAAA,mBAAM,EAAC;IACtCC,MAAMC,IAAAA,mBAAM;IACZC,UAAUC,IAAAA,qBAAQ,EAChBC,IAAAA,kBAAK,EAAC;QACJC,IAAAA,qBAAS,EAACC,iCAAqB,CAACC,MAAM;QACtCF,IAAAA,qBAAS,EAACC,iCAAqB,CAACE,GAAG;QACnCH,IAAAA,qBAAS,EAACC,iCAAqB,CAACG,IAAI;KACrC;AAEL;AAIA,MAAMC,YAA6C;IACjDC,aAAa;AACf;AAEO,MAAMb,iBAIT;IACFc,aAAa;QAAC;KAAe;IAC7BC;IACAH;AACF;AASA;;;;;;;;;;;CAWC,GACD,eAAeG,eACbC,GAAgC,EAChCC,GAAiC,EACjCC,KAAc,EACdC,GAA6B,EAC7B,EAAEN,WAAW,EAAgB;IAE7B,MAAM,EAAEO,MAAM,EAAE,GAAGJ;IAEnBK,IAAAA,mBAAY,EACVD,QACArB,mBACA,qCACAuB,oBAAS,CAACC,aAAa;IAGzB,IAAI;QACFN,IAAIO,MAAM,GAAG,MAAMX,YACjBO,OAAOlB,IAAI,EACXkB,OAAOhB,QAAQ,IAAII,iCAAqB,CAACC,MAAM;IAEnD,EAAE,OAAOgB,OAAO;QACd,OAAON,IAAIM;IACb;IAEA,OAAON;AACT"}

package/dist/cjs/permitted/getSnaps.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getSnapsHandler", {
+    enumerable: true,
+    get: function() {
+        return getSnapsHandler;
+    }
+});
+const hookNames = {
+    getSnaps: true
+};
+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/cjs/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":["getSnapsHandler","hookNames","getSnaps","methodNames","implementation","getSnapsImplementation","_req","res","_next","end","result"],"mappings":";;;;+BAcaA;;;eAAAA;;;AAPb,MAAMC,YAA8C;IAClDC,UAAU;AACZ;AAKO,MAAMF,kBAIT;IACFG,aAAa;QAAC;KAAkB;IAChCC,gBAAgBC;IAChBJ;AACF;AASA;;;;;;;;;;;;CAYC,GACD,eAAeI,uBACbC,IAAa,EACbC,GAA+C,EAC/CC,KAAc,EACdC,GAA6B,EAC7B,EAAEP,QAAQ,EAAiB;IAE3B,0CAA0C;IAC1CK,IAAIG,MAAM,GAAG,MAAMR;IACnB,OAAOO;AACT"}

package/dist/cjs/permitted/handlers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    methodHandlers: function() {
+        return methodHandlers;
+    },
+    handlers: function() {
+        return handlers;
+    }
+});
+const _getFile = require("./getFile");
+const _getSnaps = require("./getSnaps");
+const _invokeKeyring = require("./invokeKeyring");
+const _invokeSnapSugar = require("./invokeSnapSugar");
+const _requestSnaps = require("./requestSnaps");
+const methodHandlers = {
+    wallet_getSnaps: _getSnaps.getSnapsHandler,
+    wallet_requestSnaps: _requestSnaps.requestSnapsHandler,
+    wallet_invokeSnap: _invokeSnapSugar.invokeSnapSugarHandler,
+    wallet_invokeKeyring: _invokeKeyring.invokeKeyringHandler,
+    snap_getFile: _getFile.getFileHandler
+};
+const handlers = Object.values(methodHandlers);
+
+//# sourceMappingURL=handlers.js.map

package/dist/cjs/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":["methodHandlers","handlers","wallet_getSnaps","getSnapsHandler","wallet_requestSnaps","requestSnapsHandler","wallet_invokeSnap","invokeSnapSugarHandler","wallet_invokeKeyring","invokeKeyringHandler","snap_getFile","getFileHandler","Object","values"],"mappings":";;;;;;;;;;;IAOaA,cAAc;eAAdA;;IASAC,QAAQ;eAARA;;;yBAhBkB;0BACC;+BACK;iCACE;8BACH;AAG7B,MAAMD,iBAAiB;IAC5BE,iBAAiBC,yBAAe;IAChCC,qBAAqBC,iCAAmB;IACxCC,mBAAmBC,uCAAsB;IACzCC,sBAAsBC,mCAAoB;IAC1CC,cAAcC,uBAAc;AAC9B;AAGO,MAAMV,WAAWW,OAAOC,MAAM,CAACb"}

package/dist/cjs/permitted/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./handlers"), exports);
+_export_star(require("./middleware"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/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":";;;;qBAKc;qBACA"}

package/dist/cjs/permitted/invokeKeyring.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "invokeKeyringHandler", {
+    enumerable: true,
+    get: function() {
+        return invokeKeyringHandler;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _invokeSnapSugar = require("./invokeSnapSugar");
+const hookNames = {
+    hasPermission: true,
+    handleSnapRpcRequest: true,
+    getSnap: true,
+    getAllowedKeyringMethods: true
+};
+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 = (0, _invokeSnapSugar.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, _snapsutils.WALLET_SNAP_PERMISSION_KEY)) {
+        return end(_rpcerrors.rpcErrors.invalidRequest({
+            message: `The snap "${snapId}" is not connected to "${origin}". Please connect before invoking the snap.`
+        }));
+    }
+    if (!getSnap(snapId)) {
+        return end(_rpcerrors.rpcErrors.invalidRequest({
+            message: `The snap "${snapId}" is not installed. Please install it first, before invoking the snap.`
+        }));
+    }
+    if (!(0, _utils.hasProperty)(request, 'method') || typeof request.method !== 'string') {
+        return end(_rpcerrors.rpcErrors.invalidRequest({
+            message: 'The request must have a method.'
+        }));
+    }
+    const allowedMethods = getAllowedKeyringMethods(origin);
+    if (!allowedMethods.includes(request.method)) {
+        return end(_rpcerrors.rpcErrors.invalidRequest({
+            message: `The origin "${origin}" is not allowed to invoke the method "${request.method}".`
+        }));
+    }
+    try {
+        res.result = await handleSnapRpcRequest({
+            snapId,
+            origin,
+            request,
+            handler: _snapsutils.HandlerType.OnKeyringRequest
+        });
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+
+//# sourceMappingURL=invokeKeyring.js.map

package/dist/cjs/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":["invokeKeyringHandler","hookNames","hasPermission","handleSnapRpcRequest","getSnap","getAllowedKeyringMethods","methodNames","implementation","invokeKeyringImplementation","req","res","_next","end","params","getValidatedParams","error","origin","snapId","request","WALLET_SNAP_PERMISSION_KEY","rpcErrors","invalidRequest","message","hasProperty","method","allowedMethods","includes","result","handler","HandlerType","OnKeyringRequest"],"mappings":";;;;+BA2BaA;;;eAAAA;;;2BAzBa;4BAOnB;uBAEgC;iCAIJ;AAEnC,MAAMC,YAAmD;IACvDC,eAAe;IACfC,sBAAsB;IACtBC,SAAS;IACTC,0BAA0B;AAC5B;AAKO,MAAML,uBAIT;IACFM,aAAa;QAAC;KAAuB;IACrCC,gBAAgBC;IAChBP;AACF;AAiBA;;;;;;;;;;;;;;;;CAgBC,GACD,eAAeO,4BACbC,GAAmB,EACnBC,GAAiC,EACjCC,KAAc,EACdC,GAA6B,EAC7B,EACET,oBAAoB,EACpBD,aAAa,EACbE,OAAO,EACPC,wBAAwB,EACL;IAErB,IAAIQ;IACJ,IAAI;QACFA,SAASC,IAAAA,mCAAkB,EAACL,IAAII,MAAM;IACxC,EAAE,OAAOE,OAAO;QACd,OAAOH,IAAIG;IACb;IAEA,yEAAyE;IACzE,MAAM,EAAEC,MAAM,EAAE,GAAGP;IACnB,MAAM,EAAEQ,MAAM,EAAEC,OAAO,EAAE,GAAGL;IAE5B,IAAI,CAACG,UAAU,CAACd,cAAcc,QAAQG,sCAA0B,GAAG;QACjE,OAAOP,IACLQ,oBAAS,CAACC,cAAc,CAAC;YACvBC,SAAS,CAAC,UAAU,EAAEL,OAAO,uBAAuB,EAAED,OAAO,2CAA2C,CAAC;QAC3G;IAEJ;IAEA,IAAI,CAACZ,QAAQa,SAAS;QACpB,OAAOL,IACLQ,oBAAS,CAACC,cAAc,CAAC;YACvBC,SAAS,CAAC,UAAU,EAAEL,OAAO,sEAAsE,CAAC;QACtG;IAEJ;IAEA,IAAI,CAACM,IAAAA,kBAAW,EAACL,SAAS,aAAa,OAAOA,QAAQM,MAAM,KAAK,UAAU;QACzE,OAAOZ,IACLQ,oBAAS,CAACC,cAAc,CAAC;YACvBC,SAAS;QACX;IAEJ;IAEA,MAAMG,iBAAiBpB,yBAAyBW;IAChD,IAAI,CAACS,eAAeC,QAAQ,CAACR,QAAQM,MAAM,GAAG;QAC5C,OAAOZ,IACLQ,oBAAS,CAACC,cAAc,CAAC;YACvBC,SAAS,CAAC,YAAY,EAAEN,OAAO,uCAAuC,EAAEE,QAAQM,MAAM,CAAC,EAAE,CAAC;QAC5F;IAEJ;IAEA,IAAI;QACFd,IAAIiB,MAAM,GAAI,MAAMxB,qBAAqB;YACvCc;YACAD;YACAE;YACAU,SAASC,uBAAW,CAACC,gBAAgB;QACvC;IACF,EAAE,OAAOf,OAAO;QACd,OAAOH,IAAIG;IACb;IAEA,OAAOH;AACT"}

package/dist/cjs/permitted/invokeSnapSugar.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    invokeSnapSugarHandler: function() {
+        return invokeSnapSugarHandler;
+    },
+    invokeSnapSugar: function() {
+        return invokeSnapSugar;
+    },
+    getValidatedParams: function() {
+        return getValidatedParams;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _utils = require("@metamask/utils");
+const invokeSnapSugarHandler = {
+    methodNames: [
+        'wallet_invokeSnap'
+    ],
+    implementation: invokeSnapSugar,
+    hookNames: undefined
+};
+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();
+}
+function getValidatedParams(params) {
+    if (!(0, _utils.isObject)(params)) {
+        throw _rpcerrors.rpcErrors.invalidParams({
+            message: 'Expected params to be a single object.'
+        });
+    }
+    const { snapId, request } = params;
+    if (!snapId || typeof snapId !== 'string' || snapId === '') {
+        throw _rpcerrors.rpcErrors.invalidParams({
+            message: 'Must specify a valid snap ID.'
+        });
+    }
+    if (!(0, _utils.isObject)(request)) {
+        throw _rpcerrors.rpcErrors.invalidParams({
+            message: 'Expected request to be a single object.'
+        });
+    }
+    return params;
+}
+
+//# sourceMappingURL=invokeSnapSugar.js.map

package/dist/cjs/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":["invokeSnapSugarHandler","invokeSnapSugar","getValidatedParams","methodNames","implementation","hookNames","undefined","req","_res","next","end","params","error","method","isObject","rpcErrors","invalidParams","message","snapId","request"],"mappings":";;;;;;;;;;;IAiBaA,sBAAsB;eAAtBA;;IAsBGC,eAAe;eAAfA;;IAyBAC,kBAAkB;eAAlBA;;;2BA3DU;uBAED;AAUlB,MAAMF,yBAIT;IACFG,aAAa;QAAC;KAAoB;IAClCC,gBAAgBH;IAChBI,WAAWC;AACb;AAcO,SAASL,gBACdM,GAAwC,EACxCC,IAAa,EACbC,IAA+B,EAC/BC,GAA6B;IAE7B,IAAIC;IACJ,IAAI;QACFA,SAAST,mBAAmBK,IAAII,MAAM;IACxC,EAAE,OAAOC,OAAO;QACd,OAAOF,IAAIE;IACb;IAEAL,IAAIM,MAAM,GAAG;IACbN,IAAII,MAAM,GAAGA;IACb,OAAOF;AACT;AASO,SAASP,mBAAmBS,MAAe;IAChD,IAAI,CAACG,IAAAA,eAAQ,EAACH,SAAS;QACrB,MAAMI,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEC,MAAM,EAAEC,OAAO,EAAE,GAAGR;IAE5B,IAAI,CAACO,UAAU,OAAOA,WAAW,YAAYA,WAAW,IAAI;QAC1D,MAAMH,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,IAAI,CAACH,IAAAA,eAAQ,EAACK,UAAU;QACtB,MAAMJ,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,OAAON;AACT"}

package/dist/cjs/permitted/middleware.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createSnapsMethodMiddleware", {
+    enumerable: true,
+    get: function() {
+        return createSnapsMethodMiddleware;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("../utils");
+const _handlers = require("./handlers");
+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 = _handlers.methodHandlers[request.method];
+        if (handler) {
+            if (request.method.startsWith('snap_') && !isSnap) {
+                return end(_rpcerrors.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.selectHooks)(hooks, hookNames));
+            } catch (error) {
+                (0, _snapsutils.logError)(error);
+                return end(error);
+            }
+        }
+        return next();
+    };
+}
+
+//# sourceMappingURL=middleware.js.map

package/dist/cjs/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":["createSnapsMethodMiddleware","isSnap","hooks","methodMiddleware","request","response","next","end","handler","methodHandlers","method","startsWith","rpcErrors","methodNotFound","implementation","hookNames","selectHooks","error","logError"],"mappings":";;;;+BAegBA;;;eAAAA;;;2BAdU;4BACD;uBAGG;0BACG;AASxB,SAASA,4BACdC,MAAe,EACfC,KAA8B;IAE9B,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,eAAeC,iBAAiBC,OAAO,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,GAAG;QACjE,MAAMC,UACJC,wBAAc,CAACL,QAAQM,MAAM,CAAgC;QAC/D,IAAIF,SAAS;YACX,IAAIJ,QAAQM,MAAM,CAACC,UAAU,CAAC,YAAY,CAACV,QAAQ;gBACjD,OAAOM,IAAIK,oBAAS,CAACC,cAAc;YACrC;YAEA,iFAAiF;YACjF,MAAM,EAAEC,cAAc,EAAEC,SAAS,EAAE,GAAGP;YACtC,IAAI;gBACF,kEAAkE;gBAClE,OAAO,MAAMM,eACXV,SACAC,UACAC,MACAC,KACAS,IAAAA,kBAAW,EAACd,OAAOa;YAEvB,EAAE,OAAOE,OAAO;gBACdC,IAAAA,oBAAQ,EAACD;gBACT,OAAOV,IAAIU;YACb;QACF;QAEA,OAAOX;IACT;AACF"}