@metamask/snaps-rpc-methods 11.0.0 → 11.1.0

package/dist/chunk-GEJDXRTL.mjs.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"],"mappings":";;;;;;;;;;;;;;;AAKA,SAAS,mBAAmB;AAuBrB,SAAS,uBACd,oBACuD;AACvD,SAAO,OAAO;AAAA,IACZ,OAAO,QAAQ,kBAAkB,EAAE,IAAI,CAAC,CAAC,mBAAmB,KAAK,MAAM;AACrE,UAAI,YAAY,eAAe,iBAAiB,GAAG;AACjD,eAAO,CAAC,mBAAmB,cAAc,iBAAiB,EAAE,KAAK,CAAC;AAAA,MACpE,WAAW,YAAY,wBAAwB,iBAAiB,GAAG;AACjE,eAAO;AAAA,UACL;AAAA,UACA,uBAAuB,iBAAiB,EAAE,KAAK;AAAA,QACjD;AAAA,MACF;AAGA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEO,IAAM,mCAAmC,CAC9C,uBAEA,OAAO,OAAO,2BAA2B,EAAE,OAEzC,CAAC,mBAAmB,EAAE,YAAY,qBAAqB,MAAM;AAC7D,MAAI,CAAC,mBAAmB,SAAS,UAAU,GAAG;AAC5C,sBAAkB,UAAU,IAAI,qBAAqB,CAAC,CAAC;AAAA,EACzD;AACA,SAAO;AACT,GAAG,CAAC,CAAC;AAEA,IAAM,0CAA0C,CACrD,qBACA,UAEA,OAAO,OAAO,kCAAkC,EAAE,OAEhD,CAAC,gBAAgB,EAAE,YAAY,sBAAsB,YAAY,MAAM;AACvE,MAAI,CAAC,oBAAoB,SAAS,UAAU,GAAG;AAC7C,mBAAe,UAAU,IAAI,qBAAqB;AAAA;AAAA,MAEhD,aAAa;AAAA,QACX;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO;AACT,GAAG,CAAC,CAAC;","names":[]}

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-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

package/dist/chunk-I2P65KBQ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/caveats/permittedDerivationPaths.ts"],"sourcesContent":["import type {\n  Caveat,\n  PermissionConstraint,\n  RestrictedMethodCaveatSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport type { Bip32Entropy } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  Bip32EntropyStruct,\n  isEqual,\n} from '@metamask/snaps-utils';\nimport { array, size, type } from '@metamask/superstruct';\nimport type { Json } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\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 permittedDerivationPathsCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.PermittedDerivationPaths,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validate a caveat path object. The object must consist of a `path` array and\n * a `curve` string. Paths must start with `m`, and must contain at\n * least two indices. If `ed25519` is used, this checks if all the path indices\n * are hardened.\n *\n * @param value - The value to validate.\n * @throws If the value is invalid.\n */\nexport function validateBIP32Path(\n  value: unknown,\n): asserts value is Bip32Entropy {\n  assertStruct(\n    value,\n    Bip32EntropyStruct,\n    'Invalid BIP-32 entropy path definition',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Validate the path values associated with a caveat. This validates that the\n * value is a non-empty array with valid derivation paths and curves.\n *\n * @param caveat - The caveat to validate.\n * @throws If the value is invalid.\n */\nexport function validateBIP32CaveatPaths(\n  caveat: Caveat<string, any>,\n): asserts caveat is Caveat<string, Bip32Entropy[]> {\n  assertStruct(\n    caveat,\n    type({ value: size(array(Bip32EntropyStruct), 1, Infinity) }),\n    'Invalid BIP-32 entropy caveat',\n    rpcErrors.internal,\n  );\n}\n\nexport const PermittedDerivationPathsCaveatSpecification: Record<\n  SnapCaveatType.PermittedDerivationPaths,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.PermittedDerivationPaths]: Object.freeze({\n    type: SnapCaveatType.PermittedDerivationPaths,\n    decorator: (method, caveat) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP32Path(params);\n\n        const path = (caveat.value as Bip32Entropy[]).find(\n          (caveatPath) =>\n            isEqual(\n              params.path.slice(0, caveatPath.path.length),\n              caveatPath.path,\n            ) && caveatPath.curve === params.curve,\n        );\n\n        if (!path) {\n          throw providerErrors.unauthorized({\n            message:\n              'The requested path is not permitted. Allowed paths must be specified in the snap manifest.',\n          });\n        }\n\n        return await method(args);\n      };\n    },\n    validator: (caveat) => validateBIP32CaveatPaths(caveat),\n  }),\n};\n"],"mappings":";AAKA,SAAS,gBAAgB,iBAAiB;AAE1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,OAAO,MAAM,YAAY;AAElC,SAAS,oBAAoB;AAUtB,SAAS,qCACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAWO,SAAS,kBACd,OAC+B;AAC/B;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AASO,SAAS,yBACd,QACkD;AAClD;AAAA,IACE;AAAA,IACA,KAAK,EAAE,OAAO,KAAK,MAAM,kBAAkB,GAAG,GAAG,QAAQ,EAAE,CAAC;AAAA,IAC5D;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAEO,IAAM,8CAGT;AAAA,EACF,CAAC,eAAe,wBAAwB,GAAG,OAAO,OAAO;AAAA,IACvD,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,QAAQ,WAAW;AAC7B,aAAO,OAAO,SAAS;AACrB,cAAM,EAAE,OAAO,IAAI;AACnB,0BAAkB,MAAM;AAExB,cAAM,OAAQ,OAAO,MAAyB;AAAA,UAC5C,CAAC,eACC;AAAA,YACE,OAAO,KAAK,MAAM,GAAG,WAAW,KAAK,MAAM;AAAA,YAC3C,WAAW;AAAA,UACb,KAAK,WAAW,UAAU,OAAO;AAAA,QACrC;AAEA,YAAI,CAAC,MAAM;AACT,gBAAM,eAAe,aAAa;AAAA,YAChC,SACE;AAAA,UACJ,CAAC;AAAA,QACH;AAEA,eAAO,MAAM,OAAO,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,IACA,WAAW,CAAC,WAAW,yBAAyB,MAAM;AAAA,EACxD,CAAC;AACH;","names":[]}

package/dist/chunk-I3G6S6MJ.js

@@ -1,68 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/caveats/permittedCoinTypes.ts
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapsutils = require('@metamask/snaps-utils');
-var _utils = require('@metamask/utils');
-function permittedCoinTypesCaveatMapper(value) {
-  return {
-    caveats: [
-      {
-        type: _snapsutils.SnapCaveatType.PermittedCoinTypes,
-        value
-      }
-    ]
-  };
-}
-function validateBIP44Params(value) {
-  if (!_utils.isPlainObject.call(void 0, value) || !_utils.hasProperty.call(void 0, value, "coinType")) {
-    throw _rpcerrors.rpcErrors.invalidParams({
-      message: "Expected a plain object containing a coin type."
-    });
-  }
-  if (typeof value.coinType !== "number" || !Number.isInteger(value.coinType) || value.coinType < 0 || value.coinType > 2147483647) {
-    throw _rpcerrors.rpcErrors.invalidParams({
-      message: 'Invalid "coinType" parameter. Coin type must be a non-negative integer.'
-    });
-  }
-  if (_snapsutils.FORBIDDEN_COIN_TYPES.includes(value.coinType)) {
-    throw _rpcerrors.rpcErrors.invalidParams({
-      message: `Coin type ${value.coinType} is forbidden.`
-    });
-  }
-}
-function validateBIP44Caveat(caveat) {
-  if (!_utils.hasProperty.call(void 0, caveat, "value") || !Array.isArray(caveat.value) || caveat.value.length === 0) {
-    throw _rpcerrors.rpcErrors.invalidParams({
-      message: "Expected non-empty array of coin types."
-    });
-  }
-  caveat.value.forEach(validateBIP44Params);
-}
-var PermittedCoinTypesCaveatSpecification = {
-  [_snapsutils.SnapCaveatType.PermittedCoinTypes]: Object.freeze({
-    type: _snapsutils.SnapCaveatType.PermittedCoinTypes,
-    decorator: (method, caveat) => {
-      return async (args) => {
-        const { params } = args;
-        validateBIP44Params(params);
-        const coinType = caveat.value.find(
-          (caveatValue) => caveatValue.coinType === params.coinType
-        );
-        if (!coinType) {
-          throw _rpcerrors.providerErrors.unauthorized({
-            message: "The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest."
-          });
-        }
-        return await method(args);
-      };
-    },
-    validator: (caveat) => validateBIP44Caveat(caveat)
-  })
-};
-
-
-
-
-
-
-exports.permittedCoinTypesCaveatMapper = permittedCoinTypesCaveatMapper; exports.validateBIP44Params = validateBIP44Params; exports.validateBIP44Caveat = validateBIP44Caveat; exports.PermittedCoinTypesCaveatSpecification = PermittedCoinTypesCaveatSpecification;
-//# sourceMappingURL=chunk-I3G6S6MJ.js.map

package/dist/chunk-I3G6S6MJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/caveats/permittedCoinTypes.ts"],"names":[],"mappings":";AAKA,SAAS,gBAAgB,iBAAiB;AAE1C,SAAS,sBAAsB,sBAAsB;AAErD,SAAS,aAAa,qBAAqB;AAUpC,SAAS,+BACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,oBACd,OACwC;AACxC,MAAI,CAAC,cAAc,KAAK,KAAK,CAAC,YAAY,OAAO,UAAU,GAAG;AAC5D,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,MACE,OAAO,MAAM,aAAa,YAC1B,CAAC,OAAO,UAAU,MAAM,QAAQ,KAChC,MAAM,WAAW,KACjB,MAAM,WAAW,YACjB;AACA,UAAM,UAAU,cAAc;AAAA,MAC5B,SACE;AAAA,IACJ,CAAC;AAAA,EACH;AAEA,MAAI,qBAAqB,SAAS,MAAM,QAAQ,GAAG;AACjD,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS,aAAa,MAAM,QAAQ;AAAA,IACtC,CAAC;AAAA,EACH;AACF;AASO,SAAS,oBAAoB,QAA6B;AAC/D,MACE,CAAC,YAAY,QAAQ,OAAO,KAC5B,CAAC,MAAM,QAAQ,OAAO,KAAK,KAC3B,OAAO,MAAM,WAAW,GACxB;AACA,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,SAAO,MAAM,QAAQ,mBAAmB;AAC1C;AAEO,IAAM,wCAGT;AAAA,EACF,CAAC,eAAe,kBAAkB,GAAG,OAAO,OAAO;AAAA,IACjD,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,QAAQ,WAAW;AAC7B,aAAO,OAAO,SAAS;AACrB,cAAM,EAAE,OAAO,IAAI;AACnB,4BAAoB,MAAM;AAE1B,cAAM,WAAY,OAAO,MAAkC;AAAA,UACzD,CAAC,gBAAgB,YAAY,aAAa,OAAO;AAAA,QACnD;AAEA,YAAI,CAAC,UAAU;AACb,gBAAM,eAAe,aAAa;AAAA,YAChC,SACE;AAAA,UACJ,CAAC;AAAA,QACH;AAEA,eAAO,MAAM,OAAO,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,IACA,WAAW,CAAC,WAAW,oBAAoB,MAAM;AAAA,EACnD,CAAC;AACH","sourcesContent":["import type {\n  PermissionConstraint,\n  RestrictedMethodCaveatSpecificationConstraint,\n  Caveat,\n} from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport type { GetBip44EntropyParams } from '@metamask/snaps-sdk';\nimport { FORBIDDEN_COIN_TYPES, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, isPlainObject } from '@metamask/utils';\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function permittedCoinTypesCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.PermittedCoinTypes,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validate the params for `snap_getBip44Entropy`.\n *\n * @param value - The params to validate.\n * @throws If the params are invalid.\n */\nexport function validateBIP44Params(\n  value: unknown,\n): asserts value is GetBip44EntropyParams {\n  if (!isPlainObject(value) || !hasProperty(value, 'coinType')) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object containing a coin type.',\n    });\n  }\n\n  if (\n    typeof value.coinType !== 'number' ||\n    !Number.isInteger(value.coinType) ||\n    value.coinType < 0 ||\n    value.coinType > 0x7fffffff\n  ) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Invalid \"coinType\" parameter. Coin type must be a non-negative integer.',\n    });\n  }\n\n  if (FORBIDDEN_COIN_TYPES.includes(value.coinType)) {\n    throw rpcErrors.invalidParams({\n      message: `Coin type ${value.coinType} is forbidden.`,\n    });\n  }\n}\n\n/**\n * Validate the coin types values associated with a caveat. This checks if the\n * values are non-negative integers (>= 0).\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateBIP44Caveat(caveat: Caveat<string, any>) {\n  if (\n    !hasProperty(caveat, 'value') ||\n    !Array.isArray(caveat.value) ||\n    caveat.value.length === 0\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected non-empty array of coin types.',\n    });\n  }\n\n  caveat.value.forEach(validateBIP44Params);\n}\n\nexport const PermittedCoinTypesCaveatSpecification: Record<\n  SnapCaveatType.PermittedCoinTypes,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.PermittedCoinTypes]: Object.freeze({\n    type: SnapCaveatType.PermittedCoinTypes,\n    decorator: (method, caveat) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP44Params(params);\n\n        const coinType = (caveat.value as GetBip44EntropyParams[]).find(\n          (caveatValue) => caveatValue.coinType === params.coinType,\n        );\n\n        if (!coinType) {\n          throw providerErrors.unauthorized({\n            message:\n              'The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest.',\n          });\n        }\n\n        return await method(args);\n      };\n    },\n    validator: (caveat) => validateBIP44Caveat(caveat),\n  }),\n};\n"]}

package/dist/chunk-IE6EHYEG.js

@@ -1,57 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunk33MTKZ4Hjs = require('./chunk-33MTKZ4H.js');
-
-// src/restricted/getBip32Entropy.ts
-var _permissioncontroller = require('@metamask/permission-controller');
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapsutils = require('@metamask/snaps-utils');
-var _utils = require('@metamask/utils');
-var targetName = "snap_getBip32Entropy";
-var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
-  return {
-    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-    targetName,
-    allowedCaveats: [_snapsutils.SnapCaveatType.PermittedDerivationPaths],
-    methodImplementation: getBip32EntropyImplementation(methodHooks2),
-    validator: ({ caveats }) => {
-      if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.PermittedDerivationPaths) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-          message: `Expected a single "${_snapsutils.SnapCaveatType.PermittedDerivationPaths}" caveat.`
-        });
-      }
-    },
-    subjectTypes: [_permissioncontroller.SubjectType.Snap]
-  };
-};
-var methodHooks = {
-  getMnemonic: true,
-  getUnlockPromise: true
-};
-var getBip32EntropyBuilder = Object.freeze({
-  targetName,
-  specificationBuilder,
-  methodHooks
-});
-function getBip32EntropyImplementation({
-  getMnemonic,
-  getUnlockPromise
-}) {
-  return async function getBip32Entropy(args) {
-    await getUnlockPromise(true);
-    const { params } = args;
-    _utils.assert.call(void 0, params);
-    const node = await _chunk33MTKZ4Hjs.getNode.call(void 0, {
-      curve: params.curve,
-      path: params.path,
-      secretRecoveryPhrase: await getMnemonic()
-    });
-    return node.toJSON();
-  };
-}
-
-
-
-
-exports.getBip32EntropyBuilder = getBip32EntropyBuilder; exports.getBip32EntropyImplementation = getBip32EntropyImplementation;
-//# sourceMappingURL=chunk-IE6EHYEG.js.map

package/dist/chunk-IE6EHYEG.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/getBip32Entropy.ts"],"names":["methodHooks"],"mappings":";;;;;AAMA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAK1B,SAAS,sBAAsB;AAE/B,SAAS,cAAc;AAKvB,IAAM,aAAa;AAqCnB,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAAkD;AACnE,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,gBAAgB,CAAC,eAAe,wBAAwB;AAAA,IACxD,sBAAsB,8BAA8BA,YAAW;AAAA,IAC/D,WAAW,CAAC,EAAE,QAAQ,MAAM;AAC1B,UACE,SAAS,WAAW,KACpB,QAAQ,CAAC,EAAE,SAAS,eAAe,0BACnC;AACA,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS,sBAAsB,eAAe,wBAAwB;AAAA,QACxE,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAA6D;AAAA,EACjE,aAAa;AAAA,EACb,kBAAkB;AACpB;AAEO,IAAM,yBAAyB,OAAO,OAAO;AAAA,EAClD;AAAA,EACA;AAAA,EACA;AACF,CAAU;AAYH,SAAS,8BAA8B;AAAA,EAC5C;AAAA,EACA;AACF,GAA+B;AAC7B,SAAO,eAAe,gBACpB,MACgC;AAChC,UAAM,iBAAiB,IAAI;AAE3B,UAAM,EAAE,OAAO,IAAI;AACnB,WAAO,MAAM;AAEb,UAAM,OAAO,MAAM,QAAQ;AAAA,MACzB,OAAO,OAAO;AAAA,MACd,MAAM,OAAO;AAAA,MACb,sBAAsB,MAAM,YAAY;AAAA,IAC1C,CAAC;AAED,WAAO,KAAK,OAAO;AAAA,EACrB;AACF","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  GetBip32EntropyParams,\n  GetBip32EntropyResult,\n} from '@metamask/snaps-sdk';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assert } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { getNode } from '../utils';\n\nconst targetName = 'snap_getBip32Entropy';\n\nexport type GetBip32EntropyMethodHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\ntype GetBip32EntropySpecificationBuilderOptions = {\n  methodHooks: GetBip32EntropyMethodHooks;\n};\n\ntype GetBip32EntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip32EntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * The specification builder for the `snap_getBip32Entropy` permission.\n * `snap_getBip32Entropy` lets the Snap control private keys for a particular\n * BIP-32 node.\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 `snap_getBip32Entropy` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip32EntropySpecificationBuilderOptions,\n  GetBip32EntropySpecification\n> = ({ methodHooks }: GetBip32EntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],\n    methodImplementation: getBip32EntropyImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (\n        caveats?.length !== 1 ||\n        caveats[0].type !== SnapCaveatType.PermittedDerivationPaths\n      ) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.PermittedDerivationPaths}\" caveat.`,\n        });\n      }\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetBip32EntropyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip32EntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip32Entropy`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked\n * and prompts the user to unlock their MetaMask if it is locked.\n * @returns The method implementation which returns a `JsonSLIP10Node`.\n * @throws If the params are invalid.\n */\nexport function getBip32EntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip32EntropyMethodHooks) {\n  return async function getBip32Entropy(\n    args: RestrictedMethodOptions<GetBip32EntropyParams>,\n  ): Promise<GetBip32EntropyResult> {\n    await getUnlockPromise(true);\n\n    const { params } = args;\n    assert(params);\n\n    const node = await getNode({\n      curve: params.curve,\n      path: params.path,\n      secretRecoveryPhrase: await getMnemonic(),\n    });\n\n    return node.toJSON();\n  };\n}\n"]}

package/dist/chunk-JWDQUKKU.mjs

@@ -1,80 +0,0 @@
-// src/restricted/notify.ts
-import { PermissionType, SubjectType } from "@metamask/permission-controller";
-import { rpcErrors } from "@metamask/rpc-errors";
-import { NotificationType } from "@metamask/snaps-sdk";
-import { validateTextLinks } from "@metamask/snaps-utils";
-import { isObject } from "@metamask/utils";
-var methodName = "snap_notify";
-var specificationBuilder = ({ allowedCaveats = null, methodHooks: methodHooks2 }) => {
-  return {
-    permissionType: PermissionType.RestrictedMethod,
-    targetName: methodName,
-    allowedCaveats,
-    methodImplementation: getImplementation(methodHooks2),
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var methodHooks = {
-  showNativeNotification: true,
-  showInAppNotification: true,
-  isOnPhishingList: true,
-  maybeUpdatePhishingList: true
-};
-var notifyBuilder = Object.freeze({
-  targetName: methodName,
-  specificationBuilder,
-  methodHooks
-});
-function getImplementation({
-  showNativeNotification,
-  showInAppNotification,
-  isOnPhishingList,
-  maybeUpdatePhishingList
-}) {
-  return async function implementation(args) {
-    const {
-      params,
-      context: { origin }
-    } = args;
-    const validatedParams = getValidatedParams(params);
-    await maybeUpdatePhishingList();
-    validateTextLinks(validatedParams.message, isOnPhishingList);
-    switch (validatedParams.type) {
-      case NotificationType.Native:
-        return await showNativeNotification(origin, validatedParams);
-      case NotificationType.InApp:
-        return await showInAppNotification(origin, validatedParams);
-      default:
-        throw rpcErrors.invalidParams({
-          message: 'Must specify a valid notification "type".'
-        });
-    }
-  };
-}
-function getValidatedParams(params) {
-  if (!isObject(params)) {
-    throw rpcErrors.invalidParams({
-      message: "Expected params to be a single object."
-    });
-  }
-  const { type, message } = params;
-  if (!type || typeof type !== "string" || !Object.values(NotificationType).includes(type)) {
-    throw rpcErrors.invalidParams({
-      message: 'Must specify a valid notification "type".'
-    });
-  }
-  if (!message || typeof message !== "string" || message.length >= 50) {
-    throw rpcErrors.invalidParams({
-      message: 'Must specify a non-empty string "message" less than 50 characters long.'
-    });
-  }
-  return params;
-}
-
-export {
-  specificationBuilder,
-  notifyBuilder,
-  getImplementation,
-  getValidatedParams
-};
-//# sourceMappingURL=chunk-JWDQUKKU.mjs.map

package/dist/chunk-JWDQUKKU.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/notify.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { NotificationType } from '@metamask/snaps-sdk';\nimport type {\n  NotifyParams,\n  NotifyResult,\n  EnumToUnion,\n} from '@metamask/snaps-sdk';\nimport { validateTextLinks } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\nimport { type MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_notify';\n\nexport type NotificationArgs = {\n  /**\n   * Enum type to determine notification type.\n   */\n  type: EnumToUnion<NotificationType>;\n\n  /**\n   * A message to show on the notification.\n   */\n  message: string;\n};\n\nexport type NotifyMethodHooks = {\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showNativeNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showInAppNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  isOnPhishingList: (url: string) => boolean;\n\n  maybeUpdatePhishingList: () => Promise<void>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: NotifyMethodHooks;\n};\n\ntype Specification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_notify` permission.\n * `snap_notify` allows snaps to send multiple types of notifications to its users.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_notify` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  SpecificationBuilderOptions,\n  Specification\n> = ({ allowedCaveats = null, methodHooks }: SpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<NotifyMethodHooks> = {\n  showNativeNotification: true,\n  showInAppNotification: true,\n  isOnPhishingList: true,\n  maybeUpdatePhishingList: true,\n};\n\nexport const notifyBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_notify`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.showNativeNotification - A function that shows a native browser notification.\n * @param hooks.showInAppNotification - A function that shows a notification in the MetaMask UI.\n * @param hooks.isOnPhishingList - A function that checks for links against the phishing list.\n * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.\n * @returns The method implementation which returns `null` on success.\n * @throws If the params are invalid.\n */\nexport function getImplementation({\n  showNativeNotification,\n  showInAppNotification,\n  isOnPhishingList,\n  maybeUpdatePhishingList,\n}: NotifyMethodHooks) {\n  return async function implementation(\n    args: RestrictedMethodOptions<NotifyParams>,\n  ): Promise<NotifyResult> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    const validatedParams = getValidatedParams(params);\n\n    await maybeUpdatePhishingList();\n\n    validateTextLinks(validatedParams.message, isOnPhishingList);\n\n    switch (validatedParams.type) {\n      case NotificationType.Native:\n        return await showNativeNotification(origin, validatedParams);\n      case NotificationType.InApp:\n        return await showInAppNotification(origin, validatedParams);\n      default:\n        throw rpcErrors.invalidParams({\n          message: 'Must specify a valid notification \"type\".',\n        });\n    }\n  };\n}\n\n/**\n * Validates the notify method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(params: unknown): NotifyParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { type, message } = params;\n\n  if (\n    !type ||\n    typeof type !== 'string' ||\n    !Object.values(NotificationType).includes(type as NotificationType)\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid notification \"type\".',\n    });\n  }\n\n  // Set to the max message length on a Mac notification for now.\n  if (!message || typeof message !== 'string' || message.length >= 50) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Must specify a non-empty string \"message\" less than 50 characters long.',\n    });\n  }\n\n  return params as NotificationArgs;\n}\n"],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAC1B,SAAS,wBAAwB;AAMjC,SAAS,yBAAyB;AAElC,SAAS,gBAAgB;AAIzB,IAAM,aAAa;AA2DZ,IAAM,uBAIT,CAAC,EAAE,iBAAiB,MAAM,aAAAA,aAAY,MAAmC;AAC3E,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ;AAAA,IACA,sBAAsB,kBAAkBA,YAAW;AAAA,IACnD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAAoD;AAAA,EACxD,wBAAwB;AAAA,EACxB,uBAAuB;AAAA,EACvB,kBAAkB;AAAA,EAClB,yBAAyB;AAC3B;AAEO,IAAM,gBAAgB,OAAO,OAAO;AAAA,EACzC,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AAaH,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,SAAO,eAAe,eACpB,MACuB;AACvB,UAAM;AAAA,MACJ;AAAA,MACA,SAAS,EAAE,OAAO;AAAA,IACpB,IAAI;AAEJ,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,wBAAwB;AAE9B,sBAAkB,gBAAgB,SAAS,gBAAgB;AAE3D,YAAQ,gBAAgB,MAAM;AAAA,MAC5B,KAAK,iBAAiB;AACpB,eAAO,MAAM,uBAAuB,QAAQ,eAAe;AAAA,MAC7D,KAAK,iBAAiB;AACpB,eAAO,MAAM,sBAAsB,QAAQ,eAAe;AAAA,MAC5D;AACE,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS;AAAA,QACX,CAAC;AAAA,IACL;AAAA,EACF;AACF;AASO,SAAS,mBAAmB,QAA+B;AAChE,MAAI,CAAC,SAAS,MAAM,GAAG;AACrB,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,QAAQ,IAAI;AAE1B,MACE,CAAC,QACD,OAAO,SAAS,YAChB,CAAC,OAAO,OAAO,gBAAgB,EAAE,SAAS,IAAwB,GAClE;AACA,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAGA,MAAI,CAAC,WAAW,OAAO,YAAY,YAAY,QAAQ,UAAU,IAAI;AACnE,UAAM,UAAU,cAAc;AAAA,MAC5B,SACE;AAAA,IACJ,CAAC;AAAA,EACH;AAEA,SAAO;AACT;","names":["methodHooks"]}

package/dist/chunk-K3UL5RVN.mjs

@@ -1,43 +0,0 @@
-import {
-  SnapIdsCaveatSpecification,
-  snapIdsCaveatMapper
-} from "./chunk-FJ7COFRJ.mjs";
-import {
-  PermittedCoinTypesCaveatSpecification,
-  permittedCoinTypesCaveatMapper
-} from "./chunk-PIAWDTWO.mjs";
-import {
-  PermittedDerivationPathsCaveatSpecification,
-  permittedDerivationPathsCaveatMapper
-} from "./chunk-I2P65KBQ.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-K3UL5RVN.mjs.map

package/dist/chunk-K3UL5RVN.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":[]}