@metamask/snaps-rpc-methods 6.0.0 → 7.0.0

package/dist/cjs/index.js

@@ -1,45 +0,0 @@
-"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");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("./utils");
-_export_star(require("./endowments"), exports);
-_export_star(require("./permissions"), exports);
-_export_star(require("./restricted"), 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/index.js.map

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

package/dist/cjs/permissions.js

@@ -1,62 +0,0 @@
-"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, {
-    processSnapPermissions: function() {
-        return processSnapPermissions;
-    },
-    buildSnapEndowmentSpecifications: function() {
-        return buildSnapEndowmentSpecifications;
-    },
-    buildSnapRestrictedMethodSpecifications: function() {
-        return buildSnapRestrictedMethodSpecifications;
-    }
-});
-const _utils = require("@metamask/utils");
-const _endowments = require("./endowments");
-const _restricted = require("./restricted");
-const _utils1 = require("./utils");
-function processSnapPermissions(initialPermissions) {
-    return Object.fromEntries(Object.entries(initialPermissions).map(([initialPermission, value])=>{
-        if ((0, _utils.hasProperty)(_restricted.caveatMappers, initialPermission)) {
-            return [
-                initialPermission,
-                _restricted.caveatMappers[initialPermission](value)
-            ];
-        } else if ((0, _utils.hasProperty)(_endowments.endowmentCaveatMappers, initialPermission)) {
-            return [
-                initialPermission,
-                _endowments.endowmentCaveatMappers[initialPermission](value)
-            ];
-        }
-        // If we have no mapping, this may be a non-snap permission, return as-is
-        return [
-            initialPermission,
-            value
-        ];
-    }));
-}
-const buildSnapEndowmentSpecifications = (excludedEndowments)=>Object.values(_endowments.endowmentPermissionBuilders).reduce((allSpecifications, { targetName, specificationBuilder })=>{
-        if (!excludedEndowments.includes(targetName)) {
-            allSpecifications[targetName] = specificationBuilder({});
-        }
-        return allSpecifications;
-    }, {});
-const buildSnapRestrictedMethodSpecifications = (excludedPermissions, hooks)=>Object.values(_restricted.restrictedMethodPermissionBuilders).reduce((specifications, { targetName, specificationBuilder, methodHooks })=>{
-        if (!excludedPermissions.includes(targetName)) {
-            specifications[targetName] = specificationBuilder({
-                // @ts-expect-error The selectHooks type is wonky
-                methodHooks: (0, _utils1.selectHooks)(hooks, methodHooks)
-            });
-        }
-        return specifications;
-    }, {});
-
-//# sourceMappingURL=permissions.js.map

package/dist/cjs/permissions.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/permissions.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport type { SnapPermissions } from '@metamask/snaps-utils';\nimport { hasProperty } from '@metamask/utils';\n\nimport {\n  endowmentCaveatMappers,\n  endowmentPermissionBuilders,\n} from './endowments';\nimport {\n  caveatMappers,\n  restrictedMethodPermissionBuilders,\n} from './restricted';\nimport { selectHooks } from './utils';\n\n/**\n * Map initial permissions as defined in a Snap manifest to something that can\n * be processed by the PermissionsController. Each caveat mapping function\n * should return a valid permission caveat value.\n *\n * This function does not validate the caveat values, since that is done by\n * the PermissionsController itself, upon requesting the permissions.\n *\n * @param initialPermissions - The initial permissions to process.\n * @returns The processed permissions.\n */\nexport function processSnapPermissions(\n  initialPermissions: SnapPermissions,\n): Record<string, Pick<PermissionConstraint, 'caveats'>> {\n  return Object.fromEntries(\n    Object.entries(initialPermissions).map(([initialPermission, value]) => {\n      if (hasProperty(caveatMappers, initialPermission)) {\n        return [initialPermission, caveatMappers[initialPermission](value)];\n      } else if (hasProperty(endowmentCaveatMappers, initialPermission)) {\n        return [\n          initialPermission,\n          endowmentCaveatMappers[initialPermission](value),\n        ];\n      }\n\n      // If we have no mapping, this may be a non-snap permission, return as-is\n      return [\n        initialPermission,\n        value as Pick<PermissionConstraint, 'caveats'>,\n      ];\n    }),\n  );\n}\n\nexport const buildSnapEndowmentSpecifications = (\n  excludedEndowments: string[],\n) =>\n  Object.values(endowmentPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((allSpecifications, { targetName, specificationBuilder }) => {\n    if (!excludedEndowments.includes(targetName)) {\n      allSpecifications[targetName] = specificationBuilder({});\n    }\n    return allSpecifications;\n  }, {});\n\nexport const buildSnapRestrictedMethodSpecifications = (\n  excludedPermissions: string[],\n  hooks: Record<string, unknown>,\n) =>\n  Object.values(restrictedMethodPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((specifications, { targetName, specificationBuilder, methodHooks }) => {\n    if (!excludedPermissions.includes(targetName)) {\n      specifications[targetName] = specificationBuilder({\n        // @ts-expect-error The selectHooks type is wonky\n        methodHooks: selectHooks<typeof hooks, keyof typeof methodHooks>(\n          hooks,\n          methodHooks,\n        ) as Pick<typeof hooks, keyof typeof methodHooks>,\n      });\n    }\n    return specifications;\n  }, {});\n"],"names":["processSnapPermissions","buildSnapEndowmentSpecifications","buildSnapRestrictedMethodSpecifications","initialPermissions","Object","fromEntries","entries","map","initialPermission","value","hasProperty","caveatMappers","endowmentCaveatMappers","excludedEndowments","values","endowmentPermissionBuilders","reduce","allSpecifications","targetName","specificationBuilder","includes","excludedPermissions","hooks","restrictedMethodPermissionBuilders","specifications","methodHooks","selectHooks"],"mappings":";;;;;;;;;;;IA4BgBA,sBAAsB;eAAtBA;;IAuBHC,gCAAgC;eAAhCA;;IAYAC,uCAAuC;eAAvCA;;;uBA1De;4BAKrB;4BAIA;wBACqB;AAarB,SAASF,uBACdG,kBAAmC;IAEnC,OAAOC,OAAOC,WAAW,CACvBD,OAAOE,OAAO,CAACH,oBAAoBI,GAAG,CAAC,CAAC,CAACC,mBAAmBC,MAAM;QAChE,IAAIC,IAAAA,kBAAW,EAACC,yBAAa,EAAEH,oBAAoB;YACjD,OAAO;gBAACA;gBAAmBG,yBAAa,CAACH,kBAAkB,CAACC;aAAO;QACrE,OAAO,IAAIC,IAAAA,kBAAW,EAACE,kCAAsB,EAAEJ,oBAAoB;YACjE,OAAO;gBACLA;gBACAI,kCAAsB,CAACJ,kBAAkB,CAACC;aAC3C;QACH;QAEA,yEAAyE;QACzE,OAAO;YACLD;YACAC;SACD;IACH;AAEJ;AAEO,MAAMR,mCAAmC,CAC9CY,qBAEAT,OAAOU,MAAM,CAACC,uCAA2B,EAAEC,MAAM,CAE/C,CAACC,mBAAmB,EAAEC,UAAU,EAAEC,oBAAoB,EAAE;QACxD,IAAI,CAACN,mBAAmBO,QAAQ,CAACF,aAAa;YAC5CD,iBAAiB,CAACC,WAAW,GAAGC,qBAAqB,CAAC;QACxD;QACA,OAAOF;IACT,GAAG,CAAC;AAEC,MAAMf,0CAA0C,CACrDmB,qBACAC,QAEAlB,OAAOU,MAAM,CAACS,8CAAkC,EAAEP,MAAM,CAEtD,CAACQ,gBAAgB,EAAEN,UAAU,EAAEC,oBAAoB,EAAEM,WAAW,EAAE;QAClE,IAAI,CAACJ,oBAAoBD,QAAQ,CAACF,aAAa;YAC7CM,cAAc,CAACN,WAAW,GAAGC,qBAAqB;gBAChD,iDAAiD;gBACjDM,aAAaC,IAAAA,mBAAW,EACtBJ,OACAG;YAEJ;QACF;QACA,OAAOD;IACT,GAAG,CAAC"}

package/dist/cjs/permitted/createInterface.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createInterfaceHandler", {
-    enumerable: true,
-    get: function() {
-        return createInterfaceHandler;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapssdk = require("@metamask/snaps-sdk");
-const _superstruct = require("superstruct");
-const hookNames = {
-    createInterface: true
-};
-const createInterfaceHandler = {
-    methodNames: [
-        'snap_createInterface'
-    ],
-    implementation: getCreateInterfaceImplementation,
-    hookNames
-};
-const CreateInterfaceParametersStruct = (0, _superstruct.object)({
-    ui: _snapssdk.ComponentStruct
-});
-/**
- * The `snap_createInterface` 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.createInterface - The function to create the interface.
- * @returns Nothing.
- */ async function getCreateInterfaceImplementation(req, res, _next, end, { createInterface }) {
-    const { params } = req;
-    try {
-        const validatedParams = getValidatedParams(params);
-        const { ui } = validatedParams;
-        res.result = await createInterface(ui);
-    } catch (error) {
-        return end(error);
-    }
-    return end();
-}
-/**
- * Validate the createInterface 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 createInterface method parameter object.
- */ function getValidatedParams(params) {
-    try {
-        return (0, _superstruct.create)(params, CreateInterfaceParametersStruct);
-    } catch (error) {
-        if (error instanceof _superstruct.StructError) {
-            throw _rpcerrors.rpcErrors.invalidParams({
-                message: `Invalid params: ${error.message}.`
-            });
-        }
-        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
-    }
-}
-
-//# sourceMappingURL=createInterface.js.map

package/dist/cjs/permitted/createInterface.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/createInterface.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 {\n  Component,\n  CreateInterfaceParams,\n  CreateInterfaceResult,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { ComponentStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<CreateInterfaceMethodHooks> = {\n  createInterface: true,\n};\n\nexport type CreateInterfaceMethodHooks = {\n  /**\n   * @param ui - The UI components.\n   * @returns The unique identifier of the interface.\n   */\n  createInterface: (ui: Component) => Promise<string>;\n};\n\nexport const createInterfaceHandler: PermittedHandlerExport<\n  CreateInterfaceMethodHooks,\n  CreateInterfaceParameters,\n  CreateInterfaceResult\n> = {\n  methodNames: ['snap_createInterface'],\n  implementation: getCreateInterfaceImplementation,\n  hookNames,\n};\n\nconst CreateInterfaceParametersStruct = object({\n  ui: ComponentStruct,\n});\n\nexport type CreateInterfaceParameters = InferMatching<\n  typeof CreateInterfaceParametersStruct,\n  CreateInterfaceParams\n>;\n\n/**\n * The `snap_createInterface` 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.createInterface - The function to create the interface.\n * @returns Nothing.\n */\nasync function getCreateInterfaceImplementation(\n  req: JsonRpcRequest<CreateInterfaceParameters>,\n  res: PendingJsonRpcResponse<CreateInterfaceResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { createInterface }: CreateInterfaceMethodHooks,\n): Promise<void> {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { ui } = validatedParams;\n\n    res.result = await createInterface(ui);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the createInterface 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 createInterface method parameter object.\n */\nfunction getValidatedParams(params: unknown): CreateInterfaceParameters {\n  try {\n    return create(params, CreateInterfaceParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["createInterfaceHandler","hookNames","createInterface","methodNames","implementation","getCreateInterfaceImplementation","CreateInterfaceParametersStruct","object","ui","ComponentStruct","req","res","_next","end","params","validatedParams","getValidatedParams","result","error","create","StructError","rpcErrors","invalidParams","message","internal"],"mappings":";;;;+BA4BaA;;;eAAAA;;;2BA1Ba;0BAOM;6BAGY;AAI5C,MAAMC,YAA2D;IAC/DC,iBAAiB;AACnB;AAUO,MAAMF,yBAIT;IACFG,aAAa;QAAC;KAAuB;IACrCC,gBAAgBC;IAChBJ;AACF;AAEA,MAAMK,kCAAkCC,IAAAA,mBAAM,EAAC;IAC7CC,IAAIC,yBAAe;AACrB;AAOA;;;;;;;;;;;CAWC,GACD,eAAeJ,iCACbK,GAA8C,EAC9CC,GAAkD,EAClDC,KAAc,EACdC,GAA6B,EAC7B,EAAEX,eAAe,EAA8B;IAE/C,MAAM,EAAEY,MAAM,EAAE,GAAGJ;IAEnB,IAAI;QACF,MAAMK,kBAAkBC,mBAAmBF;QAE3C,MAAM,EAAEN,EAAE,EAAE,GAAGO;QAEfJ,IAAIM,MAAM,GAAG,MAAMf,gBAAgBM;IACrC,EAAE,OAAOU,OAAO;QACd,OAAOL,IAAIK;IACb;IAEA,OAAOL;AACT;AAEA;;;;;;CAMC,GACD,SAASG,mBAAmBF,MAAe;IACzC,IAAI;QACF,OAAOK,IAAAA,mBAAM,EAACL,QAAQR;IACxB,EAAE,OAAOY,OAAO;QACd,IAAIA,iBAAiBE,wBAAW,EAAE;YAChC,MAAMC,oBAAS,CAACC,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEL,MAAMK,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QACA,wBAAwB,GACxB,MAAMF,oBAAS,CAACG,QAAQ;IAC1B;AACF"}

package/dist/cjs/permitted/getAllSnaps.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getAllSnapsHandler", {
-    enumerable: true,
-    get: function() {
-        return getAllSnapsHandler;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const hookNames = {
-    getAllSnaps: true
-};
-const getAllSnapsHandler = {
-    methodNames: [
-        'wallet_getAllSnaps'
-    ],
-    implementation: getAllSnapsImplementation,
-    hookNames
-};
-/**
- * The `wallet_getAllSnaps` method implementation.
- * Fetches all installed snaps and adds them to the JSON-RPC response.
- *
- * @param request - The JSON-RPC request object.
- * @param response - The JSON-RPC response object.
- * @param _next - The `json-rpc-engine` "next" callback. Not used by this
- * function.
- * @param end - The `json-rpc-engine` "end" callback.
- * @param hooks - The RPC method hooks.
- * @param hooks.getAllSnaps - A function that returns all installed snaps.
- * @returns Nothing.
- */ async function getAllSnapsImplementation(request, response, _next, end, { getAllSnaps }) {
-    // The origin is added by the MetaMask middleware stack.
-    const { origin } = request;
-    if (origin !== 'https://snaps.metamask.io') {
-        return end(_rpcerrors.rpcErrors.methodNotFound());
-    }
-    response.result = await getAllSnaps();
-    return end();
-}
-
-//# sourceMappingURL=getAllSnaps.js.map

package/dist/cjs/permitted/getAllSnaps.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/getAllSnaps.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 { GetSnapsResult } from '@metamask/snaps-sdk';\nimport type {\n  JsonRpcParams,\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetAllSnapsHooks> = {\n  getAllSnaps: true,\n};\n\n/**\n * `wallet_getAllSnaps` gets all installed Snaps. Currently, this can only be\n * called from `https://snaps.metamask.io`.\n */\nexport const getAllSnapsHandler: PermittedHandlerExport<\n  GetAllSnapsHooks,\n  JsonRpcParams,\n  GetSnapsResult\n> = {\n  methodNames: ['wallet_getAllSnaps'],\n  implementation: getAllSnapsImplementation,\n  hookNames,\n};\n\nexport type GetAllSnapsHooks = {\n  /**\n   * @returns All installed Snaps.\n   */\n  getAllSnaps: () => Promise<GetSnapsResult>;\n};\n\n/**\n * The `wallet_getAllSnaps` method implementation.\n * Fetches all installed snaps and adds them to the JSON-RPC response.\n *\n * @param request - The JSON-RPC request object.\n * @param response - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.getAllSnaps - A function that returns all installed snaps.\n * @returns Nothing.\n */\nasync function getAllSnapsImplementation(\n  request: JsonRpcRequest,\n  response: PendingJsonRpcResponse<GetSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getAllSnaps }: GetAllSnapsHooks,\n): Promise<void> {\n  // The origin is added by the MetaMask middleware stack.\n  const { origin } = request as JsonRpcRequest & { origin: string };\n\n  if (origin !== 'https://snaps.metamask.io') {\n    return end(rpcErrors.methodNotFound());\n  }\n\n  response.result = await getAllSnaps();\n  return end();\n}\n"],"names":["getAllSnapsHandler","hookNames","getAllSnaps","methodNames","implementation","getAllSnapsImplementation","request","response","_next","end","origin","rpcErrors","methodNotFound","result"],"mappings":";;;;+BAoBaA;;;eAAAA;;;2BAlBa;AAU1B,MAAMC,YAAiD;IACrDC,aAAa;AACf;AAMO,MAAMF,qBAIT;IACFG,aAAa;QAAC;KAAqB;IACnCC,gBAAgBC;IAChBJ;AACF;AASA;;;;;;;;;;;;CAYC,GACD,eAAeI,0BACbC,OAAuB,EACvBC,QAAgD,EAChDC,KAAc,EACdC,GAA6B,EAC7B,EAAEP,WAAW,EAAoB;IAEjC,wDAAwD;IACxD,MAAM,EAAEQ,MAAM,EAAE,GAAGJ;IAEnB,IAAII,WAAW,6BAA6B;QAC1C,OAAOD,IAAIE,oBAAS,CAACC,cAAc;IACrC;IAEAL,SAASM,MAAM,GAAG,MAAMX;IACxB,OAAOO;AACT"}

package/dist/cjs/permitted/getClientStatus.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getClientStatusHandler", {
-    enumerable: true,
-    get: function() {
-        return getClientStatusHandler;
-    }
-});
-const hookNames = {
-    getIsLocked: true
-};
-const getClientStatusHandler = {
-    methodNames: [
-        'snap_getClientStatus'
-    ],
-    implementation: getClientStatusImplementation,
-    hookNames
-};
-/**
- * The `snap_getClientStatus` method implementation.
- * Returns useful information about the client running the snap.
- *
- * @param _request - The JSON-RPC request object. Not used by this function.
- * @param response - The JSON-RPC response object.
- * @param _next - The `json-rpc-engine` "next" callback. Not used by this
- * function.
- * @param end - The `json-rpc-engine` "end" callback.
- * @param hooks - The RPC method hooks.
- * @param hooks.getIsLocked - A function that returns whether the client is locked or not.
- * @returns Nothing.
- */ async function getClientStatusImplementation(_request, response, _next, end, { getIsLocked }) {
-    response.result = {
-        locked: getIsLocked()
-    };
-    return end();
-}
-
-//# sourceMappingURL=getClientStatus.js.map

package/dist/cjs/permitted/getClientStatus.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/getClientStatus.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport type { GetClientStatusResult } from '@metamask/snaps-sdk';\nimport type {\n  JsonRpcParams,\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetClientStatusHooks> = {\n  getIsLocked: true,\n};\n\n/**\n * `snap_getClientStatus` returns useful information about the client running the snap.\n */\nexport const getClientStatusHandler: PermittedHandlerExport<\n  GetClientStatusHooks,\n  JsonRpcParams,\n  GetClientStatusResult\n> = {\n  methodNames: ['snap_getClientStatus'],\n  implementation: getClientStatusImplementation,\n  hookNames,\n};\n\nexport type GetClientStatusHooks = {\n  /**\n   * @returns Whether the client is locked or not.\n   */\n  getIsLocked: () => boolean;\n};\n\n/**\n * The `snap_getClientStatus` method implementation.\n * Returns useful information about the client running the snap.\n *\n * @param _request - The JSON-RPC request object. Not used by this function.\n * @param response - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.getIsLocked - A function that returns whether the client is locked or not.\n * @returns Nothing.\n */\nasync function getClientStatusImplementation(\n  _request: JsonRpcRequest,\n  response: PendingJsonRpcResponse<GetClientStatusResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getIsLocked }: GetClientStatusHooks,\n): Promise<void> {\n  response.result = { locked: getIsLocked() };\n  return end();\n}\n"],"names":["getClientStatusHandler","hookNames","getIsLocked","methodNames","implementation","getClientStatusImplementation","_request","response","_next","end","result","locked"],"mappings":";;;;+BAkBaA;;;eAAAA;;;AAPb,MAAMC,YAAqD;IACzDC,aAAa;AACf;AAKO,MAAMF,yBAIT;IACFG,aAAa;QAAC;KAAuB;IACrCC,gBAAgBC;IAChBJ;AACF;AASA;;;;;;;;;;;;CAYC,GACD,eAAeI,8BACbC,QAAwB,EACxBC,QAAuD,EACvDC,KAAc,EACdC,GAA6B,EAC7B,EAAEP,WAAW,EAAwB;IAErCK,SAASG,MAAM,GAAG;QAAEC,QAAQT;IAAc;IAC1C,OAAOO;AACT"}

package/dist/cjs/permitted/getFile.js

@@ -1,63 +0,0 @@
-"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 _snapssdk = require("@metamask/snaps-sdk");
-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, _snapssdk.enumValue)(_snapssdk.AuxiliaryFileEncoding.Base64),
-        (0, _snapssdk.enumValue)(_snapssdk.AuxiliaryFileEncoding.Hex),
-        (0, _snapssdk.enumValue)(_snapssdk.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 function 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 ?? _snapssdk.AuxiliaryFileEncoding.Base64);
-    } catch (error) {
-        return end(error);
-    }
-    return end();
-}
-
-//# sourceMappingURL=getFile.js.map

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

@@ -1 +0,0 @@
-{"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 type { GetFileParams, GetFileResult } from '@metamask/snaps-sdk';\nimport { AuxiliaryFileEncoding, enumValue } from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\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 InferredGetFileParams = InferMatching<\n  typeof GetFileArgsStruct,\n  GetFileParams\n>;\n\nconst hookNames: MethodHooksObject<GetFileHooks> = {\n  getSnapFile: true,\n};\n\nexport const getFileHandler: PermittedHandlerExport<\n  GetFileHooks,\n  InferredGetFileParams,\n  string\n> = {\n  methodNames: ['snap_getFile'],\n  implementation,\n  hookNames,\n};\n\nexport type GetFileHooks = {\n  getSnapFile: (\n    path: InferredGetFileParams['path'],\n    encoding: InferredGetFileParams['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 function to load a static snap file.\n * @returns Nothing.\n */\nasync function implementation(\n  req: JsonRpcRequest<InferredGetFileParams>,\n  res: PendingJsonRpcResponse<GetFileResult>,\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":";;;;;;;;;;;IAYaA,iBAAiB;eAAjBA;;IAoBAC,cAAc;eAAdA;;;2BA9Ba;0BAEuB;uBAGpB;6BACmB;AAIzC,MAAMD,oBAAoBE,IAAAA,mBAAM,EAAC;IACtCC,MAAMC,IAAAA,mBAAM;IACZC,UAAUC,IAAAA,qBAAQ,EAChBC,IAAAA,kBAAK,EAAC;QACJC,IAAAA,mBAAS,EAACC,+BAAqB,CAACC,MAAM;QACtCF,IAAAA,mBAAS,EAACC,+BAAqB,CAACE,GAAG;QACnCH,IAAAA,mBAAS,EAACC,+BAAqB,CAACG,IAAI;KACrC;AAEL;AAOA,MAAMC,YAA6C;IACjDC,aAAa;AACf;AAEO,MAAMb,iBAIT;IACFc,aAAa;QAAC;KAAe;IAC7BC;IACAH;AACF;AASA;;;;;;;;;;;CAWC,GACD,eAAeG,eACbC,GAA0C,EAC1CC,GAA0C,EAC1CC,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,+BAAqB,CAACC,MAAM;IAEnD,EAAE,OAAOgB,OAAO;QACd,OAAON,IAAIM;IACb;IAEA,OAAON;AACT"}

package/dist/cjs/permitted/getInterfaceState.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getInterfaceStateHandler", {
-    enumerable: true,
-    get: function() {
-        return getInterfaceStateHandler;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _superstruct = require("superstruct");
-const hookNames = {
-    getInterfaceState: true
-};
-const getInterfaceStateHandler = {
-    methodNames: [
-        'snap_getInterfaceState'
-    ],
-    implementation: getGetInterfaceStateImplementation,
-    hookNames
-};
-const GetInterfaceStateParametersStruct = (0, _superstruct.object)({
-    id: (0, _superstruct.string)()
-});
-/**
- * The `snap_getInterfaceState` 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.getInterfaceState - The function to get the interface state.
- * @returns Noting.
- */ function getGetInterfaceStateImplementation(req, res, _next, end, { getInterfaceState }) {
-    const { params } = req;
-    try {
-        const validatedParams = getValidatedParams(params);
-        const { id } = validatedParams;
-        res.result = getInterfaceState(id);
-    } catch (error) {
-        return end(error);
-    }
-    return end();
-}
-/**
- * Validate the getInterfaceState 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 getInterfaceState method parameter object.
- */ function getValidatedParams(params) {
-    try {
-        return (0, _superstruct.create)(params, GetInterfaceStateParametersStruct);
-    } catch (error) {
-        if (error instanceof _superstruct.StructError) {
-            throw _rpcerrors.rpcErrors.invalidParams({
-                message: `Invalid params: ${error.message}.`
-            });
-        }
-        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
-    }
-}
-
-//# sourceMappingURL=getInterfaceState.js.map

package/dist/cjs/permitted/getInterfaceState.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/getInterfaceState.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 {\n  GetInterfaceStateParams,\n  GetInterfaceStateResult,\n  InterfaceState,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetInterfaceStateMethodHooks> = {\n  getInterfaceState: true,\n};\n\nexport type GetInterfaceStateMethodHooks = {\n  /**\n   * @param id - The interface ID.\n   * @returns The interface state.\n   */\n  getInterfaceState: (id: string) => InterfaceState;\n};\n\nexport const getInterfaceStateHandler: PermittedHandlerExport<\n  GetInterfaceStateMethodHooks,\n  GetInterfaceStateParameters,\n  GetInterfaceStateResult\n> = {\n  methodNames: ['snap_getInterfaceState'],\n  implementation: getGetInterfaceStateImplementation,\n  hookNames,\n};\n\nconst GetInterfaceStateParametersStruct = object({\n  id: string(),\n});\n\nexport type GetInterfaceStateParameters = InferMatching<\n  typeof GetInterfaceStateParametersStruct,\n  GetInterfaceStateParams\n>;\n\n/**\n * The `snap_getInterfaceState` 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.getInterfaceState - The function to get the interface state.\n * @returns Noting.\n */\nfunction getGetInterfaceStateImplementation(\n  req: JsonRpcRequest<GetInterfaceStateParameters>,\n  res: PendingJsonRpcResponse<GetInterfaceStateResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getInterfaceState }: GetInterfaceStateMethodHooks,\n): void {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id } = validatedParams;\n\n    res.result = getInterfaceState(id);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the getInterfaceState 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 getInterfaceState method parameter object.\n */\nfunction getValidatedParams(params: unknown): GetInterfaceStateParameters {\n  try {\n    return create(params, GetInterfaceStateParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["getInterfaceStateHandler","hookNames","getInterfaceState","methodNames","implementation","getGetInterfaceStateImplementation","GetInterfaceStateParametersStruct","object","id","string","req","res","_next","end","params","validatedParams","getValidatedParams","result","error","create","StructError","rpcErrors","invalidParams","message","internal"],"mappings":";;;;+BA2BaA;;;eAAAA;;;2BAzBa;6BAS0B;AAIpD,MAAMC,YAA6D;IACjEC,mBAAmB;AACrB;AAUO,MAAMF,2BAIT;IACFG,aAAa;QAAC;KAAyB;IACvCC,gBAAgBC;IAChBJ;AACF;AAEA,MAAMK,oCAAoCC,IAAAA,mBAAM,EAAC;IAC/CC,IAAIC,IAAAA,mBAAM;AACZ;AAOA;;;;;;;;;;;CAWC,GACD,SAASJ,mCACPK,GAAgD,EAChDC,GAAoD,EACpDC,KAAc,EACdC,GAA6B,EAC7B,EAAEX,iBAAiB,EAAgC;IAEnD,MAAM,EAAEY,MAAM,EAAE,GAAGJ;IAEnB,IAAI;QACF,MAAMK,kBAAkBC,mBAAmBF;QAE3C,MAAM,EAAEN,EAAE,EAAE,GAAGO;QAEfJ,IAAIM,MAAM,GAAGf,kBAAkBM;IACjC,EAAE,OAAOU,OAAO;QACd,OAAOL,IAAIK;IACb;IAEA,OAAOL;AACT;AAEA;;;;;;CAMC,GACD,SAASG,mBAAmBF,MAAe;IACzC,IAAI;QACF,OAAOK,IAAAA,mBAAM,EAACL,QAAQR;IACxB,EAAE,OAAOY,OAAO;QACd,IAAIA,iBAAiBE,wBAAW,EAAE;YAChC,MAAMC,oBAAS,CAACC,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEL,MAAMK,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QACA,wBAAwB,GACxB,MAAMF,oBAAS,CAACG,QAAQ;IAC1B;AACF"}

package/dist/cjs/permitted/getSnaps.js

@@ -1,39 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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 { GetSnapsResult } from '@metamask/snaps-sdk';\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  GetSnapsResult\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<GetSnapsResult>;\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<GetSnapsResult>,\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,GAA2C,EAC3CC,KAAc,EACdC,GAA6B,EAC7B,EAAEP,QAAQ,EAAiB;IAE3B,0CAA0C;IAC1CK,IAAIG,MAAM,GAAG,MAAMR;IACnB,OAAOO;AACT"}

package/dist/cjs/permitted/handlers.js

@@ -1,43 +0,0 @@
-"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 _createInterface = require("./createInterface");
-const _getAllSnaps = require("./getAllSnaps");
-const _getClientStatus = require("./getClientStatus");
-const _getFile = require("./getFile");
-const _getInterfaceState = require("./getInterfaceState");
-const _getSnaps = require("./getSnaps");
-const _invokeKeyring = require("./invokeKeyring");
-const _invokeSnapSugar = require("./invokeSnapSugar");
-const _requestSnaps = require("./requestSnaps");
-const _updateInterface = require("./updateInterface");
-const methodHandlers = {
-    wallet_getAllSnaps: _getAllSnaps.getAllSnapsHandler,
-    wallet_getSnaps: _getSnaps.getSnapsHandler,
-    wallet_requestSnaps: _requestSnaps.requestSnapsHandler,
-    wallet_invokeSnap: _invokeSnapSugar.invokeSnapSugarHandler,
-    wallet_invokeKeyring: _invokeKeyring.invokeKeyringHandler,
-    snap_getClientStatus: _getClientStatus.getClientStatusHandler,
-    snap_getFile: _getFile.getFileHandler,
-    snap_createInterface: _createInterface.createInterfaceHandler,
-    snap_updateInterface: _updateInterface.updateInterfaceHandler,
-    snap_getInterfaceState: _getInterfaceState.getInterfaceStateHandler
-};
-const handlers = Object.values(methodHandlers);
-
-//# sourceMappingURL=handlers.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/handlers.ts"],"sourcesContent":["import { createInterfaceHandler } from './createInterface';\nimport { getAllSnapsHandler } from './getAllSnaps';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getInterfaceStateHandler } from './getInterfaceState';\nimport { getSnapsHandler } from './getSnaps';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { requestSnapsHandler } from './requestSnaps';\nimport { updateInterfaceHandler } from './updateInterface';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n  snap_createInterface: createInterfaceHandler,\n  snap_updateInterface: updateInterfaceHandler,\n  snap_getInterfaceState: getInterfaceStateHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport const handlers = Object.values(methodHandlers);\n"],"names":["methodHandlers","handlers","wallet_getAllSnaps","getAllSnapsHandler","wallet_getSnaps","getSnapsHandler","wallet_requestSnaps","requestSnapsHandler","wallet_invokeSnap","invokeSnapSugarHandler","wallet_invokeKeyring","invokeKeyringHandler","snap_getClientStatus","getClientStatusHandler","snap_getFile","getFileHandler","snap_createInterface","createInterfaceHandler","snap_updateInterface","updateInterfaceHandler","snap_getInterfaceState","getInterfaceStateHandler","Object","values"],"mappings":";;;;;;;;;;;IAYaA,cAAc;eAAdA;;IAcAC,QAAQ;eAARA;;;iCA1B0B;6BACJ;iCACI;yBACR;mCACU;0BACT;+BACK;iCACE;8BACH;iCACG;AAGhC,MAAMD,iBAAiB;IAC5BE,oBAAoBC,+BAAkB;IACtCC,iBAAiBC,yBAAe;IAChCC,qBAAqBC,iCAAmB;IACxCC,mBAAmBC,uCAAsB;IACzCC,sBAAsBC,mCAAoB;IAC1CC,sBAAsBC,uCAAsB;IAC5CC,cAAcC,uBAAc;IAC5BC,sBAAsBC,uCAAsB;IAC5CC,sBAAsBC,uCAAsB;IAC5CC,wBAAwBC,2CAAwB;AAClD;AAGO,MAAMpB,WAAWqB,OAAOC,MAAM,CAACvB"}

package/dist/cjs/permitted/index.js

@@ -1,21 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/index.ts"],"sourcesContent":["import type { CreateInterfaceMethodHooks } from './createInterface';\nimport type { GetAllSnapsHooks } from './getAllSnaps';\nimport type { GetClientStatusHooks } from './getClientStatus';\nimport type { GetInterfaceStateMethodHooks } from './getInterfaceState';\nimport type { GetSnapsHooks } from './getSnaps';\nimport type { RequestSnapsHooks } from './requestSnaps';\nimport type { UpdateInterfaceMethodHooks } from './updateInterface';\n\nexport type PermittedRpcMethodHooks = GetAllSnapsHooks &\n  GetClientStatusHooks &\n  GetSnapsHooks &\n  RequestSnapsHooks &\n  CreateInterfaceMethodHooks &\n  UpdateInterfaceMethodHooks &\n  GetInterfaceStateMethodHooks;\n\nexport * from './handlers';\nexport * from './middleware';\n"],"names":[],"mappings":";;;;qBAgBc;qBACA"}