@metamask/snaps-rpc-methods 10.0.1 → 11.1.0

package/dist/chunk-FCVWU5XH.js

@@ -1,73 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/caveats/requestTime.ts
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapsutils = require('@metamask/snaps-utils');
-var _utils = require('@metamask/utils');
-function assertIsMaxRequestTime(value, ErrorWrapper) {
-  _utils.assertStruct.call(void 0, 
-    value,
-    _snapsutils.MaxRequestTimeStruct,
-    "Invalid maxRequestTime",
-    ErrorWrapper
-  );
-}
-function validateMaxRequestTimeCaveat(caveat) {
-  if (!_utils.hasProperty.call(void 0, caveat, "value")) {
-    throw _rpcerrors.rpcErrors.invalidParams({
-      message: "Invalid maxRequestTime caveat."
-    });
-  }
-  const { value } = caveat;
-  assertIsMaxRequestTime(value, _rpcerrors.rpcErrors.invalidParams);
-}
-function getMaxRequestTimeCaveatMapper(value) {
-  if (!value || !_utils.isObject.call(void 0, value) || _utils.isObject.call(void 0, value) && !_utils.hasProperty.call(void 0, value, "maxRequestTime")) {
-    return { caveats: null };
-  }
-  return {
-    caveats: [
-      {
-        type: _snapsutils.SnapCaveatType.MaxRequestTime,
-        value: value.maxRequestTime
-      }
-    ]
-  };
-}
-function createMaxRequestTimeMapper(mapper) {
-  return function(value) {
-    const { maxRequestTime, ...rest } = value;
-    const mapperResult = mapper(rest);
-    if (!maxRequestTime) {
-      return mapperResult;
-    }
-    return {
-      ...mapperResult,
-      caveats: [
-        ...mapperResult.caveats ?? [],
-        {
-          type: _snapsutils.SnapCaveatType.MaxRequestTime,
-          value: maxRequestTime
-        }
-      ]
-    };
-  };
-}
-function getMaxRequestTimeCaveat(permission) {
-  const foundCaveat = permission?.caveats?.find(
-    (caveat) => caveat.type === _snapsutils.SnapCaveatType.MaxRequestTime
-  );
-  return foundCaveat?.value ?? null;
-}
-var maxRequestTimeCaveatSpecifications = {
-  [_snapsutils.SnapCaveatType.MaxRequestTime]: Object.freeze({
-    type: _snapsutils.SnapCaveatType.MaxRequestTime,
-    validator: (caveat) => validateMaxRequestTimeCaveat(caveat)
-  })
-};
-
-
-
-
-
-
-exports.getMaxRequestTimeCaveatMapper = getMaxRequestTimeCaveatMapper; exports.createMaxRequestTimeMapper = createMaxRequestTimeMapper; exports.getMaxRequestTimeCaveat = getMaxRequestTimeCaveat; exports.maxRequestTimeCaveatSpecifications = maxRequestTimeCaveatSpecifications;
-//# sourceMappingURL=chunk-FCVWU5XH.js.map

package/dist/chunk-FFHVA6PP.js

@@ -1,82 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/invokeSnap.ts
-var _permissioncontroller = require('@metamask/permission-controller');
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapsutils = require('@metamask/snaps-utils');
-var WALLET_SNAP_PERMISSION_KEY = "wallet_snap";
-var handleSnapInstall = async ({ requestData, messagingSystem }) => {
-  const snaps = requestData.permissions[WALLET_SNAP_PERMISSION_KEY].caveats?.[0].value;
-  const permittedSnaps = messagingSystem.call(
-    `SnapController:getPermitted`,
-    requestData.metadata.origin
-  );
-  const dedupedSnaps = Object.keys(snaps).reduce(
-    (filteredSnaps, snap) => {
-      if (!permittedSnaps[snap]) {
-        filteredSnaps[snap] = snaps[snap];
-      }
-      return filteredSnaps;
-    },
-    {}
-  );
-  return messagingSystem.call(
-    `SnapController:install`,
-    requestData.metadata.origin,
-    dedupedSnaps
-  );
-};
-var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
-  return {
-    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-    targetName: WALLET_SNAP_PERMISSION_KEY,
-    allowedCaveats: [_snapsutils.SnapCaveatType.SnapIds],
-    methodImplementation: getInvokeSnapImplementation(methodHooks2),
-    validator: ({ caveats }) => {
-      if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.SnapIds) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-          message: `Expected a single "${_snapsutils.SnapCaveatType.SnapIds}" caveat.`
-        });
-      }
-    },
-    sideEffect: {
-      onPermitted: handleSnapInstall
-    }
-  };
-};
-var methodHooks = {
-  getSnap: true,
-  handleSnapRpcRequest: true
-};
-var invokeSnapBuilder = Object.freeze({
-  targetName: WALLET_SNAP_PERMISSION_KEY,
-  specificationBuilder,
-  methodHooks
-});
-function getInvokeSnapImplementation({
-  getSnap,
-  handleSnapRpcRequest
-}) {
-  return async function invokeSnap(options) {
-    const { params = {}, context } = options;
-    const { snapId, request } = params;
-    if (!getSnap(snapId)) {
-      throw _rpcerrors.rpcErrors.invalidRequest({
-        message: `The snap "${snapId}" is not installed. Please install it first, before invoking the snap.`
-      });
-    }
-    const { origin } = context;
-    return await handleSnapRpcRequest({
-      snapId,
-      origin,
-      request,
-      handler: _snapsutils.HandlerType.OnRpcRequest
-    });
-  };
-}
-
-
-
-
-
-
-exports.WALLET_SNAP_PERMISSION_KEY = WALLET_SNAP_PERMISSION_KEY; exports.handleSnapInstall = handleSnapInstall; exports.invokeSnapBuilder = invokeSnapBuilder; exports.getInvokeSnapImplementation = getInvokeSnapImplementation;
-//# sourceMappingURL=chunk-FFHVA6PP.js.map

package/dist/chunk-FFHVA6PP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/invokeSnap.ts"],"names":["methodHooks"],"mappings":";AAOA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAO1B,SAAS,aAAa,sBAAsB;AAKrC,IAAM,6BAA6B;AAwDnC,IAAM,oBAGM,OAAO,EAAE,aAAa,gBAAgB,MAAM;AAC7D,QAAM,QAAQ,YAAY,YAAY,0BAA0B,EAAE,UAAU,CAAC,EAC1E;AAEH,QAAM,iBAAiB,gBAAgB;AAAA,IACrC;AAAA,IACA,YAAY,SAAS;AAAA,EACvB;AAEA,QAAM,eAAe,OAAO,KAAK,KAAK,EAAE;AAAA,IACtC,CAAC,eAAe,SAAS;AACvB,UAAI,CAAC,eAAe,IAAI,GAAG;AACzB,sBAAc,IAAI,IAAI,MAAM,IAAI;AAAA,MAClC;AACA,aAAO;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH;AAEA,SAAO,gBAAgB;AAAA,IACrB;AAAA,IACA,YAAY,SAAS;AAAA,IACrB;AAAA,EACF;AACF;AAaA,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAA6C;AAC9D,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB,CAAC,eAAe,OAAO;AAAA,IACvC,sBAAsB,4BAA4BA,YAAW;AAAA,IAC7D,WAAW,CAAC,EAAE,QAAQ,MAAM;AAC1B,UAAI,SAAS,WAAW,KAAK,QAAQ,CAAC,EAAE,SAAS,eAAe,SAAS;AACvE,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS,sBAAsB,eAAe,OAAO;AAAA,QACvD,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,YAAY;AAAA,MACV,aAAa;AAAA,IACf;AAAA,EACF;AACF;AAEA,IAAM,cAAwD;AAAA,EAC5D,SAAS;AAAA,EACT,sBAAsB;AACxB;AAEO,IAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AAWH,SAAS,4BAA4B;AAAA,EAC1C;AAAA,EACA;AACF,GAA0B;AACxB,SAAO,eAAe,WACpB,SAC2B;AAC3B,UAAM,EAAE,SAAS,CAAC,GAAG,QAAQ,IAAI;AAEjC,UAAM,EAAE,QAAQ,QAAQ,IAAI;AAE5B,QAAI,CAAC,QAAQ,MAAM,GAAG;AACpB,YAAM,UAAU,eAAe;AAAA,QAC7B,SAAS,aAAa,MAAM;AAAA,MAC9B,CAAC;AAAA,IACH;AAEA,UAAM,EAAE,OAAO,IAAI;AAEnB,WAAQ,MAAM,qBAAqB;AAAA,MACjC;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,YAAY;AAAA,IACvB,CAAC;AAAA,EACH;AACF","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n  PermissionValidatorConstraint,\n  PermissionSideEffect,\n} from '@metamask/permission-controller';\nimport { PermissionType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  InvokeSnapResult,\n  RequestSnapsParams,\n  RequestSnapsResult,\n} from '@metamask/snaps-sdk';\nimport type { Snap, SnapRpcHookArgs } from '@metamask/snaps-utils';\nimport { HandlerType, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';\n\n// Redeclare installSnaps action type to avoid circular dependencies\nexport type InstallSnaps = {\n  type: `SnapController:install`;\n  handler: (\n    origin: string,\n    requestedSnaps: RequestSnapsParams,\n  ) => Promise<RequestSnapsResult>;\n};\n\nexport type GetPermittedSnaps = {\n  type: `SnapController:getPermitted`;\n  handler: (origin: string) => RequestSnapsResult;\n};\n\ntype AllowedActions = InstallSnaps | GetPermittedSnaps;\n\nexport type InvokeSnapMethodHooks = {\n  getSnap: (snapId: string) => Snap | undefined;\n  handleSnapRpcRequest: ({\n    snapId,\n    origin,\n    handler,\n    request,\n  }: SnapRpcHookArgs & { snapId: string }) => Promise<unknown>;\n};\n\ntype InvokeSnapSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: InvokeSnapMethodHooks;\n};\n\ntype InvokeSnapSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof WALLET_SNAP_PERMISSION_KEY;\n  methodImplementation: ReturnType<typeof getInvokeSnapImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  sideEffect: {\n    onPermitted: PermissionSideEffect<AllowedActions, never>['onPermitted'];\n  };\n}>;\n\nexport type InvokeSnapParams = {\n  snapId: string;\n  request: Record<string, Json>;\n};\n\n/**\n * The side-effect method to handle the snap install.\n *\n * @param params - The side-effect params.\n * @param params.requestData - The request data associated to the requested permission.\n * @param params.messagingSystem - The messenger to call an action.\n */\nexport const handleSnapInstall: PermissionSideEffect<\n  AllowedActions,\n  never\n>['onPermitted'] = async ({ requestData, messagingSystem }) => {\n  const snaps = requestData.permissions[WALLET_SNAP_PERMISSION_KEY].caveats?.[0]\n    .value as RequestSnapsParams;\n\n  const permittedSnaps = messagingSystem.call(\n    `SnapController:getPermitted`,\n    requestData.metadata.origin,\n  );\n\n  const dedupedSnaps = Object.keys(snaps).reduce<RequestSnapsParams>(\n    (filteredSnaps, snap) => {\n      if (!permittedSnaps[snap]) {\n        filteredSnaps[snap] = snaps[snap];\n      }\n      return filteredSnaps;\n    },\n    {},\n  );\n\n  return messagingSystem.call(\n    `SnapController:install`,\n    requestData.metadata.origin,\n    dedupedSnaps,\n  );\n};\n/**\n * The specification builder for the `wallet_snap_*` permission.\n *\n * `wallet_snap_*` attempts to invoke an RPC method of the specified Snap.\n *\n * Requesting its corresponding permission will attempt to connect to the Snap,\n * and install it if it's not available yet.\n *\n * @param options - The specification builder options.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `wallet_snap_*` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  InvokeSnapSpecificationBuilderOptions,\n  InvokeSnapSpecification\n> = ({ methodHooks }: InvokeSnapSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: WALLET_SNAP_PERMISSION_KEY,\n    allowedCaveats: [SnapCaveatType.SnapIds],\n    methodImplementation: getInvokeSnapImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.SnapIds) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.SnapIds}\" caveat.`,\n        });\n      }\n    },\n    sideEffect: {\n      onPermitted: handleSnapInstall,\n    },\n  };\n};\n\nconst methodHooks: MethodHooksObject<InvokeSnapMethodHooks> = {\n  getSnap: true,\n  handleSnapRpcRequest: true,\n};\n\nexport const invokeSnapBuilder = Object.freeze({\n  targetName: WALLET_SNAP_PERMISSION_KEY,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `wallet_snap_*`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getSnap - A function that retrieves all information stored about a snap.\n * @param hooks.handleSnapRpcRequest - A function that sends an RPC request to a snap's RPC handler or throws if that fails.\n * @returns The method implementation which returns the result of `handleSnapRpcRequest`.\n * @throws If the params are invalid.\n */\nexport function getInvokeSnapImplementation({\n  getSnap,\n  handleSnapRpcRequest,\n}: InvokeSnapMethodHooks) {\n  return async function invokeSnap(\n    options: RestrictedMethodOptions<InvokeSnapParams>,\n  ): Promise<InvokeSnapResult> {\n    const { params = {}, context } = options;\n\n    const { snapId, request } = params as InvokeSnapParams;\n\n    if (!getSnap(snapId)) {\n      throw rpcErrors.invalidRequest({\n        message: `The snap \"${snapId}\" is not installed. Please install it first, before invoking the snap.`,\n      });\n    }\n\n    const { origin } = context;\n\n    return (await handleSnapRpcRequest({\n      snapId,\n      origin,\n      request,\n      handler: HandlerType.OnRpcRequest,\n    })) as Json;\n  };\n}\n"]}

package/dist/chunk-FJ7COFRJ.mjs

@@ -1,54 +0,0 @@
-// src/restricted/caveats/snapIds.ts
-import { rpcErrors } from "@metamask/rpc-errors";
-import { SnapCaveatType, SnapIdsStruct } from "@metamask/snaps-utils";
-import { type } from "@metamask/superstruct";
-import { hasProperty, assertStruct } from "@metamask/utils";
-function snapIdsCaveatMapper(value) {
-  return {
-    caveats: [
-      {
-        type: SnapCaveatType.SnapIds,
-        value
-      }
-    ]
-  };
-}
-function validateSnapIdsCaveat(caveat) {
-  assertStruct(
-    caveat,
-    type({
-      value: SnapIdsStruct
-    }),
-    "Expected caveat to have a value property of a non-empty object of snap IDs.",
-    rpcErrors.invalidParams
-  );
-}
-var SnapIdsCaveatSpecification = {
-  [SnapCaveatType.SnapIds]: Object.freeze({
-    type: SnapCaveatType.SnapIds,
-    validator: (caveat) => validateSnapIdsCaveat(caveat),
-    decorator: (method, caveat) => {
-      return async (args) => {
-        const {
-          params,
-          context: { origin }
-        } = args;
-        const snapIds = caveat.value;
-        const { snapId } = params;
-        if (!hasProperty(snapIds, snapId)) {
-          throw new Error(
-            `${origin} does not have permission to invoke ${snapId} snap.`
-          );
-        }
-        return await method(args);
-      };
-    }
-  })
-};
-
-export {
-  snapIdsCaveatMapper,
-  validateSnapIdsCaveat,
-  SnapIdsCaveatSpecification
-};
-//# sourceMappingURL=chunk-FJ7COFRJ.mjs.map

package/dist/chunk-FJ7COFRJ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/caveats/snapIds.ts"],"sourcesContent":["import type {\n  Caveat,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n  RestrictedMethodCaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { SnapIds } from '@metamask/snaps-utils';\nimport { SnapCaveatType, SnapIdsStruct } from '@metamask/snaps-utils';\nimport { type } from '@metamask/superstruct';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, assertStruct } from '@metamask/utils';\n\nimport type { InvokeSnapParams } from '../invokeSnap';\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 snapIdsCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapIds,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validates that the caveat value exists and is a non-empty object.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateSnapIdsCaveat(\n  caveat: Caveat<string, any>,\n): asserts caveat is Caveat<string, SnapIds> {\n  assertStruct(\n    caveat,\n    type({\n      value: SnapIdsStruct,\n    }),\n    'Expected caveat to have a value property of a non-empty object of snap IDs.',\n    rpcErrors.invalidParams,\n  );\n}\n\nexport const SnapIdsCaveatSpecification: Record<\n  SnapCaveatType.SnapIds,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SnapIds]: Object.freeze({\n    type: SnapCaveatType.SnapIds,\n    validator: (caveat) => validateSnapIdsCaveat(caveat),\n    decorator: (method, caveat) => {\n      return async (args) => {\n        const {\n          params,\n          context: { origin },\n        }: RestrictedMethodOptions<RestrictedMethodParameters> = args;\n        const snapIds = caveat.value as SnapIds;\n        const { snapId } = params as InvokeSnapParams;\n        if (!hasProperty(snapIds, snapId)) {\n          throw new Error(\n            `${origin} does not have permission to invoke ${snapId} snap.`,\n          );\n        }\n        return await method(args);\n      };\n    },\n  }),\n};\n"],"mappings":";AAOA,SAAS,iBAAiB;AAE1B,SAAS,gBAAgB,qBAAqB;AAC9C,SAAS,YAAY;AAErB,SAAS,aAAa,oBAAoB;AAYnC,SAAS,oBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,sBACd,QAC2C;AAC3C;AAAA,IACE;AAAA,IACA,KAAK;AAAA,MACH,OAAO;AAAA,IACT,CAAC;AAAA,IACD;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAEO,IAAM,6BAGT;AAAA,EACF,CAAC,eAAe,OAAO,GAAG,OAAO,OAAO;AAAA,IACtC,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAW,sBAAsB,MAAM;AAAA,IACnD,WAAW,CAAC,QAAQ,WAAW;AAC7B,aAAO,OAAO,SAAS;AACrB,cAAM;AAAA,UACJ;AAAA,UACA,SAAS,EAAE,OAAO;AAAA,QACpB,IAAyD;AACzD,cAAM,UAAU,OAAO;AACvB,cAAM,EAAE,OAAO,IAAI;AACnB,YAAI,CAAC,YAAY,SAAS,MAAM,GAAG;AACjC,gBAAM,IAAI;AAAA,YACR,GAAG,MAAM,uCAAuC,MAAM;AAAA,UACxD;AAAA,QACF;AACA,eAAO,MAAM,OAAO,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-FNUO7MQ4.mjs

@@ -1,43 +0,0 @@
-import {
-  PermittedCoinTypesCaveatSpecification,
-  permittedCoinTypesCaveatMapper
-} from "./chunk-PIAWDTWO.mjs";
-import {
-  PermittedDerivationPathsCaveatSpecification,
-  permittedDerivationPathsCaveatMapper
-} from "./chunk-I2P65KBQ.mjs";
-import {
-  SnapIdsCaveatSpecification,
-  snapIdsCaveatMapper
-} from "./chunk-FJ7COFRJ.mjs";
-import {
-  getBip32PublicKeyBuilder
-} from "./chunk-VYII7C3J.mjs";
-import {
-  getBip44EntropyBuilder
-} from "./chunk-LR7UR4YU.mjs";
-import {
-  getBip32EntropyBuilder
-} from "./chunk-LXJBBRQ4.mjs";
-import {
-  invokeSnapBuilder
-} from "./chunk-VVBTXSID.mjs";
-
-// src/restricted/caveats/index.ts
-var caveatSpecifications = {
-  ...PermittedDerivationPathsCaveatSpecification,
-  ...PermittedCoinTypesCaveatSpecification,
-  ...SnapIdsCaveatSpecification
-};
-var caveatMappers = {
-  [getBip32EntropyBuilder.targetName]: permittedDerivationPathsCaveatMapper,
-  [getBip32PublicKeyBuilder.targetName]: permittedDerivationPathsCaveatMapper,
-  [getBip44EntropyBuilder.targetName]: permittedCoinTypesCaveatMapper,
-  [invokeSnapBuilder.targetName]: snapIdsCaveatMapper
-};
-
-export {
-  caveatSpecifications,
-  caveatMappers
-};
-//# sourceMappingURL=chunk-FNUO7MQ4.mjs.map

package/dist/chunk-FNUO7MQ4.mjs.map

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAiBO,IAAM,uBAAuB;AAAA,EAClC,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AACL;AAEO,IAAM,gBAGT;AAAA,EACF,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,yBAAyB,UAAU,GAAG;AAAA,EACvC,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,kBAAkB,UAAU,GAAG;AAClC;","names":[]}

package/dist/chunk-GE5XFDUE.js

@@ -1,21 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/lifecycle-hooks.ts
-var _permissioncontroller = require('@metamask/permission-controller');
-var permissionName = "endowment:lifecycle-hooks" /* LifecycleHooks */;
-var specificationBuilder = (_builderOptions) => {
-  return {
-    permissionType: _permissioncontroller.PermissionType.Endowment,
-    targetName: permissionName,
-    allowedCaveats: null,
-    endowmentGetter: (_getterOptions) => null,
-    subjectTypes: [_permissioncontroller.SubjectType.Snap]
-  };
-};
-var lifecycleHooksEndowmentBuilder = Object.freeze({
-  targetName: permissionName,
-  specificationBuilder
-});
-
-
-
-exports.lifecycleHooksEndowmentBuilder = lifecycleHooksEndowmentBuilder;
-//# sourceMappingURL=chunk-GE5XFDUE.js.map

package/dist/chunk-GE5XFDUE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endowments/lifecycle-hooks.ts"],"names":[],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAK5C,IAAM;AAiBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,iCAAiC,OAAO,OAAO;AAAA,EAC1D,YAAY;AAAA,EACZ;AACF,CAAU","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.LifecycleHooks;\n\ntype LifecycleHooksEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => null;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:lifecycle-hooks` returns nothing; it is intended to be used as a\n * flag by the snap controller to detect whether the snap has the capability to\n * use lifecycle hooks.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the `lifecycle-hooks` endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  LifecycleHooksEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => null,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const lifecycleHooksEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"]}

package/dist/chunk-GPV4ETUH.mjs

@@ -1,47 +0,0 @@
-// src/permitted/getFile.ts
-import { rpcErrors } from "@metamask/rpc-errors";
-import { AuxiliaryFileEncoding, enumValue } from "@metamask/snaps-sdk";
-import { object, optional, string, union } from "@metamask/superstruct";
-import { assertStruct } from "@metamask/utils";
-var GetFileArgsStruct = object({
-  path: string(),
-  encoding: optional(
-    union([
-      enumValue(AuxiliaryFileEncoding.Base64),
-      enumValue(AuxiliaryFileEncoding.Hex),
-      enumValue(AuxiliaryFileEncoding.Utf8)
-    ])
-  )
-});
-var hookNames = {
-  getSnapFile: true
-};
-var getFileHandler = {
-  methodNames: ["snap_getFile"],
-  implementation,
-  hookNames
-};
-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();
-}
-
-export {
-  GetFileArgsStruct,
-  getFileHandler
-};
-//# sourceMappingURL=chunk-GPV4ETUH.mjs.map

package/dist/chunk-GPV4ETUH.mjs.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 { object, optional, string, union } from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\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"],"mappings":";AAEA,SAAS,iBAAiB;AAE1B,SAAS,uBAAuB,iBAAiB;AAEjD,SAAS,QAAQ,UAAU,QAAQ,aAAa;AAEhD,SAAS,oBAAoB;AAItB,IAAM,oBAAoB,OAAO;AAAA,EACtC,MAAM,OAAO;AAAA,EACb,UAAU;AAAA,IACR,MAAM;AAAA,MACJ,UAAU,sBAAsB,MAAM;AAAA,MACtC,UAAU,sBAAsB,GAAG;AAAA,MACnC,UAAU,sBAAsB,IAAI;AAAA,IACtC,CAAC;AAAA,EACH;AACF,CAAC;AAOD,IAAM,YAA6C;AAAA,EACjD,aAAa;AACf;AAEO,IAAM,iBAIT;AAAA,EACF,aAAa,CAAC,cAAc;AAAA,EAC5B;AAAA,EACA;AACF;AAqBA,eAAe,eACb,KACA,KACA,OACA,KACA,EAAE,YAAY,GACC;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AAEA,MAAI;AACF,QAAI,SAAS,MAAM;AAAA,MACjB,OAAO;AAAA,MACP,OAAO,YAAY,sBAAsB;AAAA,IAC3C;AAAA,EACF,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;","names":[]}

package/dist/chunk-H6X3CWWQ.js

@@ -1,54 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/caveats/snapIds.ts
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapsutils = require('@metamask/snaps-utils');
-var _superstruct = require('@metamask/superstruct');
-var _utils = require('@metamask/utils');
-function snapIdsCaveatMapper(value) {
-  return {
-    caveats: [
-      {
-        type: _snapsutils.SnapCaveatType.SnapIds,
-        value
-      }
-    ]
-  };
-}
-function validateSnapIdsCaveat(caveat) {
-  _utils.assertStruct.call(void 0, 
-    caveat,
-    _superstruct.type.call(void 0, {
-      value: _snapsutils.SnapIdsStruct
-    }),
-    "Expected caveat to have a value property of a non-empty object of snap IDs.",
-    _rpcerrors.rpcErrors.invalidParams
-  );
-}
-var SnapIdsCaveatSpecification = {
-  [_snapsutils.SnapCaveatType.SnapIds]: Object.freeze({
-    type: _snapsutils.SnapCaveatType.SnapIds,
-    validator: (caveat) => validateSnapIdsCaveat(caveat),
-    decorator: (method, caveat) => {
-      return async (args) => {
-        const {
-          params,
-          context: { origin }
-        } = args;
-        const snapIds = caveat.value;
-        const { snapId } = params;
-        if (!_utils.hasProperty.call(void 0, snapIds, snapId)) {
-          throw new Error(
-            `${origin} does not have permission to invoke ${snapId} snap.`
-          );
-        }
-        return await method(args);
-      };
-    }
-  })
-};
-
-
-
-
-
-exports.snapIdsCaveatMapper = snapIdsCaveatMapper; exports.validateSnapIdsCaveat = validateSnapIdsCaveat; exports.SnapIdsCaveatSpecification = SnapIdsCaveatSpecification;
-//# sourceMappingURL=chunk-H6X3CWWQ.js.map

package/dist/chunk-H6X3CWWQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/caveats/snapIds.ts"],"names":[],"mappings":";AAOA,SAAS,iBAAiB;AAE1B,SAAS,gBAAgB,qBAAqB;AAC9C,SAAS,YAAY;AAErB,SAAS,aAAa,oBAAoB;AAYnC,SAAS,oBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,sBACd,QAC2C;AAC3C;AAAA,IACE;AAAA,IACA,KAAK;AAAA,MACH,OAAO;AAAA,IACT,CAAC;AAAA,IACD;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAEO,IAAM,6BAGT;AAAA,EACF,CAAC,eAAe,OAAO,GAAG,OAAO,OAAO;AAAA,IACtC,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAW,sBAAsB,MAAM;AAAA,IACnD,WAAW,CAAC,QAAQ,WAAW;AAC7B,aAAO,OAAO,SAAS;AACrB,cAAM;AAAA,UACJ;AAAA,UACA,SAAS,EAAE,OAAO;AAAA,QACpB,IAAyD;AACzD,cAAM,UAAU,OAAO;AACvB,cAAM,EAAE,OAAO,IAAI;AACnB,YAAI,CAAC,YAAY,SAAS,MAAM,GAAG;AACjC,gBAAM,IAAI;AAAA,YACR,GAAG,MAAM,uCAAuC,MAAM;AAAA,UACxD;AAAA,QACF;AACA,eAAO,MAAM,OAAO,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,CAAC;AACH","sourcesContent":["import type {\n  Caveat,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n  RestrictedMethodCaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { SnapIds } from '@metamask/snaps-utils';\nimport { SnapCaveatType, SnapIdsStruct } from '@metamask/snaps-utils';\nimport { type } from '@metamask/superstruct';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, assertStruct } from '@metamask/utils';\n\nimport type { InvokeSnapParams } from '../invokeSnap';\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 snapIdsCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapIds,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validates that the caveat value exists and is a non-empty object.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateSnapIdsCaveat(\n  caveat: Caveat<string, any>,\n): asserts caveat is Caveat<string, SnapIds> {\n  assertStruct(\n    caveat,\n    type({\n      value: SnapIdsStruct,\n    }),\n    'Expected caveat to have a value property of a non-empty object of snap IDs.',\n    rpcErrors.invalidParams,\n  );\n}\n\nexport const SnapIdsCaveatSpecification: Record<\n  SnapCaveatType.SnapIds,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SnapIds]: Object.freeze({\n    type: SnapCaveatType.SnapIds,\n    validator: (caveat) => validateSnapIdsCaveat(caveat),\n    decorator: (method, caveat) => {\n      return async (args) => {\n        const {\n          params,\n          context: { origin },\n        }: RestrictedMethodOptions<RestrictedMethodParameters> = args;\n        const snapIds = caveat.value as SnapIds;\n        const { snapId } = params as InvokeSnapParams;\n        if (!hasProperty(snapIds, snapId)) {\n          throw new Error(\n            `${origin} does not have permission to invoke ${snapId} snap.`,\n          );\n        }\n        return await method(args);\n      };\n    },\n  }),\n};\n"]}

package/dist/chunk-HOECEYMT.mjs

@@ -1,70 +0,0 @@
-import {
-  createGenericPermissionValidator
-} from "./chunk-TT4DP2YW.mjs";
-
-// src/endowments/keyring.ts
-import { PermissionType, SubjectType } from "@metamask/permission-controller";
-import { rpcErrors } from "@metamask/rpc-errors";
-import { assertIsKeyringOrigins, SnapCaveatType } from "@metamask/snaps-utils";
-import { assert, hasProperty, isPlainObject } from "@metamask/utils";
-var permissionName = "endowment:keyring" /* Keyring */;
-var specificationBuilder = (_builderOptions) => {
-  return {
-    permissionType: PermissionType.Endowment,
-    targetName: permissionName,
-    allowedCaveats: [
-      SnapCaveatType.KeyringOrigin,
-      SnapCaveatType.MaxRequestTime
-    ],
-    endowmentGetter: (_getterOptions) => null,
-    validator: createGenericPermissionValidator([
-      { type: SnapCaveatType.KeyringOrigin },
-      { type: SnapCaveatType.MaxRequestTime, optional: true }
-    ]),
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var keyringEndowmentBuilder = Object.freeze({
-  targetName: permissionName,
-  specificationBuilder
-});
-function validateCaveatOrigins(caveat) {
-  if (!hasProperty(caveat, "value") || !isPlainObject(caveat.value)) {
-    throw rpcErrors.invalidParams({
-      message: "Invalid keyring origins: Expected a plain object."
-    });
-  }
-  const { value } = caveat;
-  assertIsKeyringOrigins(value, rpcErrors.invalidParams);
-}
-function getKeyringCaveatMapper(value) {
-  return {
-    caveats: [
-      {
-        type: SnapCaveatType.KeyringOrigin,
-        value
-      }
-    ]
-  };
-}
-function getKeyringCaveatOrigins(permission) {
-  assert(permission?.caveats);
-  assert(permission.caveats.length === 1);
-  assert(permission.caveats[0].type === SnapCaveatType.KeyringOrigin);
-  const caveat = permission.caveats[0];
-  return caveat.value;
-}
-var keyringCaveatSpecifications = {
-  [SnapCaveatType.KeyringOrigin]: Object.freeze({
-    type: SnapCaveatType.KeyringOrigin,
-    validator: (caveat) => validateCaveatOrigins(caveat)
-  })
-};
-
-export {
-  keyringEndowmentBuilder,
-  getKeyringCaveatMapper,
-  getKeyringCaveatOrigins,
-  keyringCaveatSpecifications
-};
-//# sourceMappingURL=chunk-HOECEYMT.mjs.map

package/dist/chunk-HOECEYMT.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endowments/keyring.ts"],"sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  EndowmentGetterParams,\n  PermissionConstraint,\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { KeyringOrigins } from '@metamask/snaps-utils';\nimport { assertIsKeyringOrigins, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isPlainObject } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.Keyring;\n\ntype KeyringEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => null;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  subjectTypes: readonly SubjectType[];\n}>;\n\n/**\n * `endowment:keyring` returns nothing; it is intended to be used as a flag\n * by the client to detect whether the snap has keyring capabilities.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the keyring endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  KeyringEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.KeyringOrigin,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => null,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.KeyringOrigin },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const keyringEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Validate the value of a caveat. This does not validate the type of the\n * caveat itself, only the value of the caveat.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateCaveatOrigins(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid keyring origins: Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsKeyringOrigins(value, rpcErrors.invalidParams);\n}\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 getKeyringCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.KeyringOrigin,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the {@link KeyringOrigins} caveat value from a\n * permission.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value.\n * @throws If the permission does not have a valid {@link KeyringOrigins}\n * caveat.\n */\nexport function getKeyringCaveatOrigins(\n  permission?: PermissionConstraint,\n): KeyringOrigins | null {\n  assert(permission?.caveats);\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.KeyringOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, KeyringOrigins>;\n  return caveat.value;\n}\n\nexport const keyringCaveatSpecifications: Record<\n  SnapCaveatType.KeyringOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.KeyringOrigin]: Object.freeze({\n    type: SnapCaveatType.KeyringOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveatOrigins(caveat),\n  }),\n};\n"],"mappings":";;;;;AASA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAE1B,SAAS,wBAAwB,sBAAsB;AAEvD,SAAS,QAAQ,aAAa,qBAAqB;AAKnD,IAAM;AAkBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,MACd,eAAe;AAAA,MACf,eAAe;AAAA,IACjB;AAAA,IACA,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,WAAW,iCAAiC;AAAA,MAC1C,EAAE,MAAM,eAAe,cAAc;AAAA,MACrC,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,0BAA0B,OAAO,OAAO;AAAA,EACnD,YAAY;AAAA,EACZ;AACF,CAAU;AASV,SAAS,sBAAsB,QAA6B;AAC1D,MAAI,CAAC,YAAY,QAAQ,OAAO,KAAK,CAAC,cAAc,OAAO,KAAK,GAAG;AACjE,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAClB,yBAAuB,OAAO,UAAU,aAAa;AACvD;AAUO,SAAS,uBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAWO,SAAS,wBACd,YACuB;AACvB,SAAO,YAAY,OAAO;AAC1B,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,aAAa;AAElE,QAAM,SAAS,WAAW,QAAQ,CAAC;AACnC,SAAO,OAAO;AAChB;AAEO,IAAM,8BAGT;AAAA,EACF,CAAC,eAAe,aAAa,GAAG,OAAO,OAAO;AAAA,IAC5C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,sBAAsB,MAAM;AAAA,EAC1E,CAAC;AACH;","names":[]}

package/dist/chunk-HZQ34FQT.js

@@ -1,49 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkQDZAWH6Fjs = require('./chunk-QDZAWH6F.js');
-
-
-var _chunk4PWFZPJCjs = require('./chunk-4PWFZPJC.js');
-
-
-var _chunkVUA6ICJOjs = require('./chunk-VUA6ICJO.js');
-
-
-var _chunkZKISN6YPjs = require('./chunk-ZKISN6YP.js');
-
-
-var _chunkSYUGPLEPjs = require('./chunk-SYUGPLEP.js');
-
-
-var _chunkA6H6I4VHjs = require('./chunk-A6H6I4VH.js');
-
-
-var _chunkM2JQCKR7js = require('./chunk-M2JQCKR7.js');
-
-
-var _chunkELCOEVKAjs = require('./chunk-ELCOEVKA.js');
-
-
-var _chunkIE6EHYEGjs = require('./chunk-IE6EHYEG.js');
-
-
-var _chunkFFHVA6PPjs = require('./chunk-FFHVA6PP.js');
-
-// src/restricted/index.ts
-var restrictedMethodPermissionBuilders = {
-  [_chunkELCOEVKAjs.dialogBuilder.targetName]: _chunkELCOEVKAjs.dialogBuilder,
-  [_chunkIE6EHYEGjs.getBip32EntropyBuilder.targetName]: _chunkIE6EHYEGjs.getBip32EntropyBuilder,
-  [_chunk4PWFZPJCjs.getBip32PublicKeyBuilder.targetName]: _chunk4PWFZPJCjs.getBip32PublicKeyBuilder,
-  [_chunkVUA6ICJOjs.getBip44EntropyBuilder.targetName]: _chunkVUA6ICJOjs.getBip44EntropyBuilder,
-  [_chunkZKISN6YPjs.getEntropyBuilder.targetName]: _chunkZKISN6YPjs.getEntropyBuilder,
-  [_chunkFFHVA6PPjs.invokeSnapBuilder.targetName]: _chunkFFHVA6PPjs.invokeSnapBuilder,
-  [_chunkM2JQCKR7js.manageStateBuilder.targetName]: _chunkM2JQCKR7js.manageStateBuilder,
-  [_chunkQDZAWH6Fjs.notifyBuilder.targetName]: _chunkQDZAWH6Fjs.notifyBuilder,
-  [_chunkA6H6I4VHjs.manageAccountsBuilder.targetName]: _chunkA6H6I4VHjs.manageAccountsBuilder,
-  [_chunkSYUGPLEPjs.getLocaleBuilder.targetName]: _chunkSYUGPLEPjs.getLocaleBuilder
-};
-
-
-
-exports.restrictedMethodPermissionBuilders = restrictedMethodPermissionBuilders;
-//# sourceMappingURL=chunk-HZQ34FQT.js.map

package/dist/chunk-HZQ34FQT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCO,IAAM,qCAAqC;AAAA,EAChD,CAAC,cAAc,UAAU,GAAG;AAAA,EAC5B,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,yBAAyB,UAAU,GAAG;AAAA,EACvC,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,kBAAkB,UAAU,GAAG;AAAA,EAChC,CAAC,kBAAkB,UAAU,GAAG;AAAA,EAChC,CAAC,mBAAmB,UAAU,GAAG;AAAA,EACjC,CAAC,cAAc,UAAU,GAAG;AAAA,EAC5B,CAAC,sBAAsB,UAAU,GAAG;AAAA,EACpC,CAAC,iBAAiB,UAAU,GAAG;AACjC","sourcesContent":["import type { DialogMethodHooks } from './dialog';\nimport { dialogBuilder } from './dialog';\nimport type { GetBip32EntropyMethodHooks } from './getBip32Entropy';\nimport { getBip32EntropyBuilder } from './getBip32Entropy';\nimport type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';\nimport { getBip32PublicKeyBuilder } from './getBip32PublicKey';\nimport type { GetBip44EntropyMethodHooks } from './getBip44Entropy';\nimport { getBip44EntropyBuilder } from './getBip44Entropy';\nimport type { GetEntropyHooks } from './getEntropy';\nimport { getEntropyBuilder } from './getEntropy';\nimport type { GetLocaleMethodHooks } from './getLocale';\nimport { getLocaleBuilder } from './getLocale';\nimport type { InvokeSnapMethodHooks } from './invokeSnap';\nimport { invokeSnapBuilder } from './invokeSnap';\nimport type { ManageAccountsMethodHooks } from './manageAccounts';\nimport { manageAccountsBuilder } from './manageAccounts';\nimport type { ManageStateMethodHooks } from './manageState';\nimport { manageStateBuilder } from './manageState';\nimport type { NotifyMethodHooks } from './notify';\nimport { notifyBuilder } from './notify';\n\nexport { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';\nexport { getEncryptionEntropy } from './manageState';\n\nexport type RestrictedMethodHooks = DialogMethodHooks &\n  GetBip32EntropyMethodHooks &\n  GetBip32PublicKeyMethodHooks &\n  GetBip44EntropyMethodHooks &\n  GetEntropyHooks &\n  InvokeSnapMethodHooks &\n  ManageStateMethodHooks &\n  NotifyMethodHooks &\n  ManageAccountsMethodHooks &\n  GetLocaleMethodHooks;\n\nexport const restrictedMethodPermissionBuilders = {\n  [dialogBuilder.targetName]: dialogBuilder,\n  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,\n  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,\n  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,\n  [getEntropyBuilder.targetName]: getEntropyBuilder,\n  [invokeSnapBuilder.targetName]: invokeSnapBuilder,\n  [manageStateBuilder.targetName]: manageStateBuilder,\n  [notifyBuilder.targetName]: notifyBuilder,\n  [manageAccountsBuilder.targetName]: manageAccountsBuilder,\n  [getLocaleBuilder.targetName]: getLocaleBuilder,\n} as const;\n\nexport * from './caveats';\nexport type { DialogApprovalTypes } from './dialog';\nexport { DIALOG_APPROVAL_TYPES } from './dialog';\n"]}

package/dist/chunk-I2P65KBQ.mjs

@@ -1,67 +0,0 @@
-// src/restricted/caveats/permittedDerivationPaths.ts
-import { providerErrors, rpcErrors } from "@metamask/rpc-errors";
-import {
-  SnapCaveatType,
-  Bip32EntropyStruct,
-  isEqual
-} from "@metamask/snaps-utils";
-import { array, size, type } from "@metamask/superstruct";
-import { assertStruct } from "@metamask/utils";
-function permittedDerivationPathsCaveatMapper(value) {
-  return {
-    caveats: [
-      {
-        type: SnapCaveatType.PermittedDerivationPaths,
-        value
-      }
-    ]
-  };
-}
-function validateBIP32Path(value) {
-  assertStruct(
-    value,
-    Bip32EntropyStruct,
-    "Invalid BIP-32 entropy path definition",
-    rpcErrors.invalidParams
-  );
-}
-function validateBIP32CaveatPaths(caveat) {
-  assertStruct(
-    caveat,
-    type({ value: size(array(Bip32EntropyStruct), 1, Infinity) }),
-    "Invalid BIP-32 entropy caveat",
-    rpcErrors.internal
-  );
-}
-var PermittedDerivationPathsCaveatSpecification = {
-  [SnapCaveatType.PermittedDerivationPaths]: Object.freeze({
-    type: SnapCaveatType.PermittedDerivationPaths,
-    decorator: (method, caveat) => {
-      return async (args) => {
-        const { params } = args;
-        validateBIP32Path(params);
-        const path = caveat.value.find(
-          (caveatPath) => isEqual(
-            params.path.slice(0, caveatPath.path.length),
-            caveatPath.path
-          ) && caveatPath.curve === params.curve
-        );
-        if (!path) {
-          throw providerErrors.unauthorized({
-            message: "The requested path is not permitted. Allowed paths must be specified in the snap manifest."
-          });
-        }
-        return await method(args);
-      };
-    },
-    validator: (caveat) => validateBIP32CaveatPaths(caveat)
-  })
-};
-
-export {
-  permittedDerivationPathsCaveatMapper,
-  validateBIP32Path,
-  validateBIP32CaveatPaths,
-  PermittedDerivationPathsCaveatSpecification
-};
-//# sourceMappingURL=chunk-I2P65KBQ.mjs.map