@metamask/snaps-rpc-methods 5.0.0 → 7.0.0

package/dist/chunk-3FKD2O7M.js

@@ -0,0 +1,151 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/dialog.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var _rpcerrors = require('@metamask/rpc-errors');
+
+
+
+
+
+var _snapssdk = require('@metamask/snaps-sdk');
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+
+
+
+
+
+
+
+
+var _superstruct = require('superstruct');
+var methodName = "snap_dialog";
+var PlaceholderStruct = _superstruct.optional.call(void 0, _superstruct.size.call(void 0, _superstruct.string.call(void 0, ), 1, 40));
+var specificationBuilder = ({
+  allowedCaveats = null,
+  methodHooks: methodHooks2
+}) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
+    targetName: methodName,
+    allowedCaveats,
+    methodImplementation: getDialogImplementation(methodHooks2),
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  showDialog: true,
+  createInterface: true,
+  getInterface: true
+};
+var dialogBuilder = Object.freeze({
+  targetName: methodName,
+  specificationBuilder,
+  methodHooks
+});
+var BaseParamsStruct = _superstruct.type.call(void 0, {
+  type: _superstruct.enums.call(void 0, [_snapssdk.DialogType.Alert, _snapssdk.DialogType.Confirmation, _snapssdk.DialogType.Prompt])
+});
+var AlertParametersWithContentStruct = _superstruct.object.call(void 0, {
+  type: _snapssdk.enumValue.call(void 0, _snapssdk.DialogType.Alert),
+  content: _snapssdk.ComponentStruct
+});
+var AlertParametersWithIdStruct = _superstruct.object.call(void 0, {
+  type: _snapssdk.enumValue.call(void 0, _snapssdk.DialogType.Alert),
+  id: _superstruct.string.call(void 0, )
+});
+var AlertParametersStruct = _snapssdk.union.call(void 0, [
+  AlertParametersWithContentStruct,
+  AlertParametersWithIdStruct
+]);
+var ConfirmationParametersWithContentStruct = _superstruct.object.call(void 0, {
+  type: _snapssdk.enumValue.call(void 0, _snapssdk.DialogType.Confirmation),
+  content: _snapssdk.ComponentStruct
+});
+var ConfirmationParametersWithIdStruct = _superstruct.object.call(void 0, {
+  type: _snapssdk.enumValue.call(void 0, _snapssdk.DialogType.Confirmation),
+  id: _superstruct.string.call(void 0, )
+});
+var ConfirmationParametersStruct = _snapssdk.union.call(void 0, [
+  ConfirmationParametersWithContentStruct,
+  ConfirmationParametersWithIdStruct
+]);
+var PromptParametersWithContentStruct = _superstruct.object.call(void 0, {
+  type: _snapssdk.enumValue.call(void 0, _snapssdk.DialogType.Prompt),
+  content: _snapssdk.ComponentStruct,
+  placeholder: PlaceholderStruct
+});
+var PromptParametersWithIdStruct = _superstruct.object.call(void 0, {
+  type: _snapssdk.enumValue.call(void 0, _snapssdk.DialogType.Prompt),
+  id: _superstruct.string.call(void 0, ),
+  placeholder: PlaceholderStruct
+});
+var PromptParametersStruct = _snapssdk.union.call(void 0, [
+  PromptParametersWithContentStruct,
+  PromptParametersWithIdStruct
+]);
+var DialogParametersStruct = _snapssdk.union.call(void 0, [
+  AlertParametersStruct,
+  ConfirmationParametersStruct,
+  PromptParametersStruct
+]);
+var structs = {
+  [_snapssdk.DialogType.Alert]: AlertParametersStruct,
+  [_snapssdk.DialogType.Confirmation]: ConfirmationParametersStruct,
+  [_snapssdk.DialogType.Prompt]: PromptParametersStruct
+};
+function getDialogImplementation({
+  showDialog,
+  createInterface,
+  getInterface
+}) {
+  return async function dialogImplementation(args) {
+    const {
+      params,
+      context: { origin }
+    } = args;
+    const validatedType = getValidatedType(params);
+    const validatedParams = getValidatedParams(params, structs[validatedType]);
+    const placeholder = validatedParams.type === _snapssdk.DialogType.Prompt ? validatedParams.placeholder : void 0;
+    if (_utils.hasProperty.call(void 0, validatedParams, "content")) {
+      const id = await createInterface(
+        origin,
+        validatedParams.content
+      );
+      return showDialog(origin, validatedType, id, placeholder);
+    }
+    try {
+      getInterface(origin, validatedParams.id);
+    } catch (error) {
+      throw _rpcerrors.rpcErrors.invalidParams({
+        message: `Invalid params: ${error.message}`
+      });
+    }
+    return showDialog(origin, validatedType, validatedParams.id, placeholder);
+  };
+}
+function getValidatedType(params) {
+  try {
+    return _superstruct.create.call(void 0, params, BaseParamsStruct).type;
+  } catch (error) {
+    throw _rpcerrors.rpcErrors.invalidParams({
+      message: `The "type" property must be one of: ${Object.values(
+        _snapssdk.DialogType
+      ).join(", ")}.`
+    });
+  }
+}
+function getValidatedParams(params, struct) {
+  try {
+    return _snapsutils.createUnion.call(void 0, params, struct, "type");
+  } catch (error) {
+    throw _rpcerrors.rpcErrors.invalidParams({
+      message: `Invalid params: ${error.message}`
+    });
+  }
+}
+
+
+
+
+exports.dialogBuilder = dialogBuilder; exports.getDialogImplementation = getDialogImplementation;
+//# sourceMappingURL=chunk-3FKD2O7M.js.map

package/dist/chunk-3FKD2O7M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/dialog.ts"],"names":["methodHooks"],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAQP,SAAS,mBAAmB;AAE5B,SAAS,mBAAuC;AAEhD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAIP,IAAM,aAAa;AAEnB,IAAM,oBAAoB,SAAS,KAAK,OAAO,GAAG,GAAG,EAAE,CAAC;AAgExD,IAAM,uBAIF,CAAC;AAAA,EACH,iBAAiB;AAAA,EACjB,aAAAA;AACF,MAAyC;AACvC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ;AAAA,IACA,sBAAsB,wBAAwBA,YAAW;AAAA,IACzD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAAoD;AAAA,EACxD,YAAY;AAAA,EACZ,iBAAiB;AAAA,EACjB,cAAc;AAChB;AAEO,IAAM,gBAAgB,OAAO,OAAO;AAAA,EACzC,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AAIV,IAAM,mBAAmB,KAAK;AAAA,EAC5B,MAAM,MAAM,CAAC,WAAW,OAAO,WAAW,cAAc,WAAW,MAAM,CAAC;AAC5E,CAAC;AAED,IAAM,mCAAmC,OAAO;AAAA,EAC9C,MAAM,UAAU,WAAW,KAAK;AAAA,EAChC,SAAS;AACX,CAAC;AACD,IAAM,8BAA8B,OAAO;AAAA,EACzC,MAAM,UAAU,WAAW,KAAK;AAAA,EAChC,IAAI,OAAO;AACb,CAAC;AAED,IAAM,wBAAwB,MAAM;AAAA,EAClC;AAAA,EACA;AACF,CAAC;AAED,IAAM,0CAA0C,OAAO;AAAA,EACrD,MAAM,UAAU,WAAW,YAAY;AAAA,EACvC,SAAS;AACX,CAAC;AAED,IAAM,qCAAqC,OAAO;AAAA,EAChD,MAAM,UAAU,WAAW,YAAY;AAAA,EACvC,IAAI,OAAO;AACb,CAAC;AAED,IAAM,+BAA+B,MAAM;AAAA,EACzC;AAAA,EACA;AACF,CAAC;AAED,IAAM,oCAAoC,OAAO;AAAA,EAC/C,MAAM,UAAU,WAAW,MAAM;AAAA,EACjC,SAAS;AAAA,EACT,aAAa;AACf,CAAC;AAED,IAAM,+BAA+B,OAAO;AAAA,EAC1C,MAAM,UAAU,WAAW,MAAM;AAAA,EACjC,IAAI,OAAO;AAAA,EACX,aAAa;AACf,CAAC;AAED,IAAM,yBAAyB,MAAM;AAAA,EACnC;AAAA,EACA;AACF,CAAC;AAED,IAAM,yBAAyB,MAAM;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAOD,IAAM,UAAU;AAAA,EACd,CAAC,WAAW,KAAK,GAAG;AAAA,EACpB,CAAC,WAAW,YAAY,GAAG;AAAA,EAC3B,CAAC,WAAW,MAAM,GAAG;AACvB;AAaO,SAAS,wBAAwB;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,SAAO,eAAe,qBACpB,MACkC;AAClC,UAAM;AAAA,MACJ;AAAA,MACA,SAAS,EAAE,OAAO;AAAA,IACpB,IAAI;AAEJ,UAAM,gBAAgB,iBAAiB,MAAM;AAC7C,UAAM,kBAAkB,mBAAmB,QAAQ,QAAQ,aAAa,CAAC;AAEzE,UAAM,cACJ,gBAAgB,SAAS,WAAW,SAChC,gBAAgB,cAChB;AAEN,QAAI,YAAY,iBAAiB,SAAS,GAAG;AAC3C,YAAM,KAAK,MAAM;AAAA,QACf;AAAA,QACA,gBAAgB;AAAA,MAClB;AACA,aAAO,WAAW,QAAQ,eAAe,IAAI,WAAW;AAAA,IAC1D;AAIA,QAAI;AACF,mBAAa,QAAQ,gBAAgB,EAAE;AAAA,IACzC,SAAS,OAAO;AACd,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,WAAO,WAAW,QAAQ,eAAe,gBAAgB,IAAI,WAAW;AAAA,EAC1E;AACF;AASA,SAAS,iBAAiB,QAA6B;AACrD,MAAI;AACF,WAAO,OAAO,QAAQ,gBAAgB,EAAE;AAAA,EAC1C,SAAS,OAAO;AACd,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS,uCAAuC,OAAO;AAAA,QACrD;AAAA,MACF,EAAE,KAAK,IAAI,CAAC;AAAA,IACd,CAAC;AAAA,EACH;AACF;AAUA,SAAS,mBACP,QACA,QACkB;AAClB,MAAI;AACF,WAAO,YAAY,QAAQ,QAAQ,MAAM;AAAA,EAC3C,SAAS,OAAO;AACd,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,IAC3C,CAAC;AAAA,EACH;AACF","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 {\n  DialogType,\n  ComponentStruct,\n  enumValue,\n  union,\n} from '@metamask/snaps-sdk';\nimport type {\n  DialogParams,\n  EnumToUnion,\n  Component,\n  InterfaceState,\n  SnapId,\n} from '@metamask/snaps-sdk';\nimport { createUnion } from '@metamask/snaps-utils';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport { hasProperty, type NonEmptyArray } from '@metamask/utils';\nimport type { Infer, Struct } from 'superstruct';\nimport {\n  create,\n  enums,\n  object,\n  optional,\n  size,\n  string,\n  type,\n} from 'superstruct';\n\nimport { type MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_dialog';\n\nconst PlaceholderStruct = optional(size(string(), 1, 40));\n\nexport type Placeholder = Infer<typeof PlaceholderStruct>;\n\ntype ShowDialog = (\n  snapId: string,\n  type: EnumToUnion<DialogType>,\n  id: string,\n  placeholder?: Placeholder,\n) => Promise<null | boolean | string>;\n\ntype CreateInterface = (snapId: string, content: Component) => Promise<string>;\ntype GetInterface = (\n  snapId: string,\n  id: string,\n) => { content: Component; snapId: SnapId; state: InterfaceState };\n\nexport type DialogMethodHooks = {\n  /**\n   * @param snapId - The ID of the Snap that created the alert.\n   * @param type - The dialog type.\n   * @param id - The interface ID.\n   * @param placeholder - The placeholder for the Prompt dialog input.\n   */\n  showDialog: ShowDialog;\n\n  /**\n   * @param snapId - The Snap ID creating the interface.\n   * @param content - The content of the interface.\n   */\n  createInterface: CreateInterface;\n  /**\n   * @param snapId - The SnapId requesting the interface.\n   * @param id - The interface ID.\n   */\n  getInterface: GetInterface;\n};\n\ntype DialogSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: DialogMethodHooks;\n};\n\ntype DialogSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getDialogImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_dialog` permission. `snap_dialog`\n * lets the Snap display one of the following dialogs to the user:\n * - An alert, for displaying information.\n * - A confirmation, for accepting or rejecting some action.\n * - A prompt, for inputting some information.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the\n * permission.\n * @param options.methodHooks - The RPC method hooks needed by the method\n * implementation.\n * @returns The specification for the `snap_dialog` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  DialogSpecificationBuilderOptions,\n  DialogSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: DialogSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getDialogImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<DialogMethodHooks> = {\n  showDialog: true,\n  createInterface: true,\n  getInterface: true,\n};\n\nexport const dialogBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n// Note: We use `type` here instead of `object` because `type` does not validate\n// the keys of the object, which is what we want.\nconst BaseParamsStruct = type({\n  type: enums([DialogType.Alert, DialogType.Confirmation, DialogType.Prompt]),\n});\n\nconst AlertParametersWithContentStruct = object({\n  type: enumValue(DialogType.Alert),\n  content: ComponentStruct,\n});\nconst AlertParametersWithIdStruct = object({\n  type: enumValue(DialogType.Alert),\n  id: string(),\n});\n\nconst AlertParametersStruct = union([\n  AlertParametersWithContentStruct,\n  AlertParametersWithIdStruct,\n]);\n\nconst ConfirmationParametersWithContentStruct = object({\n  type: enumValue(DialogType.Confirmation),\n  content: ComponentStruct,\n});\n\nconst ConfirmationParametersWithIdStruct = object({\n  type: enumValue(DialogType.Confirmation),\n  id: string(),\n});\n\nconst ConfirmationParametersStruct = union([\n  ConfirmationParametersWithContentStruct,\n  ConfirmationParametersWithIdStruct,\n]);\n\nconst PromptParametersWithContentStruct = object({\n  type: enumValue(DialogType.Prompt),\n  content: ComponentStruct,\n  placeholder: PlaceholderStruct,\n});\n\nconst PromptParametersWithIdStruct = object({\n  type: enumValue(DialogType.Prompt),\n  id: string(),\n  placeholder: PlaceholderStruct,\n});\n\nconst PromptParametersStruct = union([\n  PromptParametersWithContentStruct,\n  PromptParametersWithIdStruct,\n]);\n\nconst DialogParametersStruct = union([\n  AlertParametersStruct,\n  ConfirmationParametersStruct,\n  PromptParametersStruct,\n]);\n\nexport type DialogParameters = InferMatching<\n  typeof DialogParametersStruct,\n  DialogParams\n>;\n\nconst structs = {\n  [DialogType.Alert]: AlertParametersStruct,\n  [DialogType.Confirmation]: ConfirmationParametersStruct,\n  [DialogType.Prompt]: PromptParametersStruct,\n};\n\n/**\n * Builds the method implementation for `snap_dialog`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.showDialog - A function that shows the specified dialog in the\n * MetaMask UI and returns the appropriate value for the dialog type.\n * @param hooks.createInterface - A function that creates the interface in SnapInterfaceController.\n * @param hooks.getInterface - A function that gets an interface from SnapInterfaceController.\n * @returns The method implementation which return value depends on the dialog\n * type, valid return types are: string, boolean, null.\n */\nexport function getDialogImplementation({\n  showDialog,\n  createInterface,\n  getInterface,\n}: DialogMethodHooks) {\n  return async function dialogImplementation(\n    args: RestrictedMethodOptions<DialogParameters>,\n  ): Promise<boolean | null | string> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    const validatedType = getValidatedType(params);\n    const validatedParams = getValidatedParams(params, structs[validatedType]);\n\n    const placeholder =\n      validatedParams.type === DialogType.Prompt\n        ? validatedParams.placeholder\n        : undefined;\n\n    if (hasProperty(validatedParams, 'content')) {\n      const id = await createInterface(\n        origin,\n        validatedParams.content as Component,\n      );\n      return showDialog(origin, validatedType, id, placeholder);\n    }\n\n    // Verify that the passed interface ID is valid.\n    // This will throw if the interface ID is invalid (not created by the snap or doesn't exist)\n    try {\n      getInterface(origin, validatedParams.id);\n    } catch (error) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}`,\n      });\n    }\n\n    return showDialog(origin, validatedType, validatedParams.id, placeholder);\n  };\n}\n\n/**\n * Get the validated type of the dialog parameters. Throws an error if the type\n * is invalid.\n *\n * @param params - The parameters to validate.\n * @returns The validated type of the dialog parameters.\n */\nfunction getValidatedType(params: unknown): DialogType {\n  try {\n    return create(params, BaseParamsStruct).type;\n  } catch (error) {\n    throw rpcErrors.invalidParams({\n      message: `The \"type\" property must be one of: ${Object.values(\n        DialogType,\n      ).join(', ')}.`,\n    });\n  }\n}\n\n/**\n * Validates the confirm 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 * @param struct - The struct to validate the params against.\n * @returns The validated confirm method parameter object.\n */\nfunction getValidatedParams(\n  params: unknown,\n  struct: Struct<any, any>,\n): DialogParameters {\n  try {\n    return createUnion(params, struct, 'type');\n  } catch (error) {\n    throw rpcErrors.invalidParams({\n      message: `Invalid params: ${error.message}`,\n    });\n  }\n}\n"]}

package/dist/chunk-4ALFLY5D.js

@@ -0,0 +1,105 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkUYSXSKMLjs = require('./chunk-UYSXSKML.js');
+
+// src/permitted/requestSnaps.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+
+
+
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+var hookNames = {
+  installSnaps: true,
+  requestPermissions: true,
+  getPermissions: true
+};
+var requestSnapsHandler = {
+  methodNames: ["wallet_requestSnaps"],
+  implementation: requestSnapsImplementation,
+  hookNames
+};
+function hasRequestedSnaps(existingPermissions, requestedSnaps) {
+  const snapIdCaveat = _optionalChain([existingPermissions, 'access', _ => _[_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY], 'optionalAccess', _2 => _2.caveats, 'optionalAccess', _3 => _3.find, 'call', _4 => _4(
+    (caveat) => caveat.type === _snapsutils.SnapCaveatType.SnapIds
+  )]);
+  const permittedSnaps = _optionalChain([snapIdCaveat, 'optionalAccess', _5 => _5.value]);
+  if (_utils.isObject.call(void 0, permittedSnaps)) {
+    return Object.keys(requestedSnaps).every(
+      (requestedSnap) => _utils.hasProperty.call(void 0, permittedSnaps, requestedSnap)
+    );
+  }
+  return false;
+}
+function getSnapPermissionsRequest(existingPermissions, requestedPermissions) {
+  _snapsutils.verifyRequestedSnapPermissions.call(void 0, requestedPermissions);
+  if (!existingPermissions[_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY]) {
+    return requestedPermissions;
+  }
+  const snapIdCaveat = _optionalChain([existingPermissions, 'access', _6 => _6[_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY], 'access', _7 => _7.caveats, 'optionalAccess', _8 => _8.find, 'call', _9 => _9(
+    (caveat) => caveat.type === _snapsutils.SnapCaveatType.SnapIds
+  )]);
+  const permittedSnaps = _nullishCoalesce(_optionalChain([snapIdCaveat, 'optionalAccess', _10 => _10.value]), () => ( {}));
+  const requestedSnaps = requestedPermissions[_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY].caveats[0].value;
+  const snapIdSet = /* @__PURE__ */ new Set([
+    ...Object.keys(permittedSnaps),
+    ...Object.keys(requestedSnaps)
+  ]);
+  const mergedCaveatValue = [...snapIdSet].reduce(
+    (request, snapId) => {
+      request[snapId] = _nullishCoalesce(requestedSnaps[snapId], () => ( permittedSnaps[snapId]));
+      return request;
+    },
+    {}
+  );
+  requestedPermissions[_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY].caveats[0].value = mergedCaveatValue;
+  return requestedPermissions;
+}
+async function requestSnapsImplementation(req, res, _next, end, { installSnaps, requestPermissions, getPermissions }) {
+  const requestedSnaps = req.params;
+  if (!_utils.isObject.call(void 0, requestedSnaps)) {
+    return end(
+      _rpcerrors.rpcErrors.invalidParams({
+        message: '"params" must be an object.'
+      })
+    );
+  }
+  try {
+    if (Object.keys(requestedSnaps).length === 0) {
+      return end(
+        _rpcerrors.rpcErrors.invalidParams({
+          message: "Request must have at least one requested snap."
+        })
+      );
+    }
+    const requestedPermissions = {
+      [_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY]: {
+        caveats: [{ type: _snapsutils.SnapCaveatType.SnapIds, value: requestedSnaps }]
+      }
+    };
+    const existingPermissions = await getPermissions();
+    if (!existingPermissions) {
+      const [, metadata] = await requestPermissions(requestedPermissions);
+      res.result = metadata.data[_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY];
+    } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {
+      res.result = await installSnaps(requestedSnaps);
+    } else {
+      const mergedPermissionsRequest = getSnapPermissionsRequest(
+        existingPermissions,
+        requestedPermissions
+      );
+      const [, metadata] = await requestPermissions(mergedPermissionsRequest);
+      res.result = metadata.data[_chunkUYSXSKMLjs.WALLET_SNAP_PERMISSION_KEY];
+    }
+  } catch (error) {
+    res.error = error;
+  }
+  return end();
+}
+
+
+
+
+
+exports.requestSnapsHandler = requestSnapsHandler; exports.hasRequestedSnaps = hasRequestedSnaps; exports.getSnapPermissionsRequest = getSnapPermissionsRequest;
+//# sourceMappingURL=chunk-4ALFLY5D.js.map

package/dist/chunk-4ALFLY5D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/requestSnaps.ts"],"names":[],"mappings":";;;;;AAOA,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP,SAAS,aAAa,gBAAgB;AAKtC,IAAM,YAAkD;AAAA,EACtD,cAAc;AAAA,EACd,oBAAoB;AAAA,EACpB,gBAAgB;AAClB;AAKO,IAAM,sBAIT;AAAA,EACF,aAAa,CAAC,qBAAqB;AAAA,EACnC,gBAAgB;AAAA,EAChB;AACF;AA0CO,SAAS,kBACd,qBACA,gBACS;AACT,QAAM,eAAe,oBACnB,0BACF,GAAG,SAAS;AAAA,IACV,CAAC,WAAiC,OAAO,SAAS,eAAe;AAAA,EACnE;AAEA,QAAM,iBAAiB,cAAc;AACrC,MAAI,SAAS,cAAc,GAAG;AAC5B,WAAO,OAAO,KAAK,cAAc,EAAE;AAAA,MAAM,CAAC,kBACxC,YAAY,gBAAgB,aAAa;AAAA,IAC3C;AAAA,EACF;AACA,SAAO;AACT;AAUO,SAAS,0BACd,qBACA,sBACwB;AACxB,iCAA+B,oBAAoB;AAEnD,MAAI,CAAC,oBAAoB,0BAA0B,GAAG;AACpD,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,oBACnB,0BACF,EAAE,SAAS;AAAA,IACT,CAAC,WAAiC,OAAO,SAAS,eAAe;AAAA,EACnE;AAEA,QAAM,iBAAkB,cAAc,SAAkC,CAAC;AAEzE,QAAM,iBACJ,qBAAqB,0BAA0B,EAAE,QAAQ,CAAC,EAAE;AAE9D,QAAM,YAAY,oBAAI,IAAI;AAAA,IACxB,GAAG,OAAO,KAAK,cAAc;AAAA,IAC7B,GAAG,OAAO,KAAK,cAAc;AAAA,EAC/B,CAAC;AAED,QAAM,oBAAoB,CAAC,GAAG,SAAS,EAAE;AAAA,IACvC,CAAC,SAAS,WAAW;AACnB,cAAQ,MAAM,IAAI,eAAe,MAAM,KAAK,eAAe,MAAM;AACjE,aAAO;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH;AAEA,uBAAqB,0BAA0B,EAAE,QAAQ,CAAC,EAAE,QAC1D;AAEF,SAAO;AACT;AAmBA,eAAe,2BACb,KACA,KACA,OACA,KACA,EAAE,cAAc,oBAAoB,eAAe,GACpC;AACf,QAAM,iBAAiB,IAAI;AAC3B,MAAI,CAAC,SAAS,cAAc,GAAG;AAC7B,WAAO;AAAA,MACL,UAAU,cAAc;AAAA,QACtB,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI;AACF,QAAI,OAAO,KAAK,cAAc,EAAE,WAAW,GAAG;AAC5C,aAAO;AAAA,QACL,UAAU,cAAc;AAAA,UACtB,SAAS;AAAA,QACX,CAAC;AAAA,MACH;AAAA,IACF;AAEA,UAAM,uBAAuB;AAAA,MAC3B,CAAC,0BAA0B,GAAG;AAAA,QAC5B,SAAS,CAAC,EAAE,MAAM,eAAe,SAAS,OAAO,eAAe,CAAC;AAAA,MACnE;AAAA,IACF;AACA,UAAM,sBAAsB,MAAM,eAAe;AAEjD,QAAI,CAAC,qBAAqB;AACxB,YAAM,CAAC,EAAE,QAAQ,IAAI,MAAM,mBAAmB,oBAAoB;AAClE,UAAI,SAAS,SAAS,KACpB,0BACF;AAAA,IACF,WAAW,kBAAkB,qBAAqB,cAAc,GAAG;AACjE,UAAI,SAAS,MAAM,aAAa,cAAc;AAAA,IAChD,OAAO;AACL,YAAM,2BAA2B;AAAA,QAC/B;AAAA,QACA;AAAA,MACF;AAEA,YAAM,CAAC,EAAE,QAAQ,IAAI,MAAM,mBAAmB,wBAAwB;AACtE,UAAI,SAAS,SAAS,KACpB,0BACF;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,QAAI,QAAQ;AAAA,EACd;AAEA,SAAO,IAAI;AACb","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type {\n  PermissionConstraint,\n  RequestedPermissions,\n  Caveat,\n  PermittedHandlerExport,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  RequestSnapsParams,\n  RequestSnapsResult,\n} from '@metamask/snaps-sdk';\nimport type { SnapsPermissionRequest } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  verifyRequestedSnapPermissions,\n} from '@metamask/snaps-utils';\nimport type {\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n  Json,\n} from '@metamask/utils';\nimport { hasProperty, isObject } from '@metamask/utils';\n\nimport { WALLET_SNAP_PERMISSION_KEY } from '../restricted/invokeSnap';\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<RequestSnapsHooks> = {\n  installSnaps: true,\n  requestPermissions: true,\n  getPermissions: true,\n};\n\n/**\n * `wallet_requestSnaps` installs the requested Snaps and requests permission to use them if necessary.\n */\nexport const requestSnapsHandler: PermittedHandlerExport<\n  RequestSnapsHooks,\n  RequestSnapsParams,\n  RequestSnapsResult\n> = {\n  methodNames: ['wallet_requestSnaps'],\n  implementation: requestSnapsImplementation,\n  hookNames,\n};\n\nexport type RequestSnapsHooks = {\n  /**\n   * Installs the requested snaps if they are permitted.\n   */\n  installSnaps: (\n    requestedSnaps: RequestSnapsParams,\n  ) => Promise<RequestSnapsResult>;\n\n  /**\n   * Initiates a permission request for the requesting origin.\n   *\n   * @returns The result of the permissions request.\n   */\n  requestPermissions: (\n    permissions: RequestedPermissions,\n  ) => Promise<\n    [\n      Record<string, PermissionConstraint>,\n      { data: Record<string, unknown>; id: string; origin: string },\n    ]\n  >;\n\n  /**\n   * Gets the current permissions for the requesting origin.\n   *\n   * @returns The current permissions of the requesting origin.\n   */\n  getPermissions: () => Promise<\n    Record<string, PermissionConstraint> | undefined\n  >;\n};\n\n/**\n * Checks whether an origin has existing `wallet_snap` permission and\n * whether or not it has the requested snapIds caveat.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedSnaps - The requested snaps.\n * @returns True if the existing permissions satisfy the requested snaps, otherwise false.\n */\nexport function hasRequestedSnaps(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedSnaps: Record<string, unknown>,\n): boolean {\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ]?.caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = snapIdCaveat?.value;\n  if (isObject(permittedSnaps)) {\n    return Object.keys(requestedSnaps).every((requestedSnap) =>\n      hasProperty(permittedSnaps, requestedSnap),\n    );\n  }\n  return false;\n}\n\n/**\n * Constructs a valid permission request with merged caveats based on existing permissions\n * and the requested snaps.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedPermissions - The permission request passed into `requestPermissions`.\n * @returns `requestedPermissions`.\n */\nexport function getSnapPermissionsRequest(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedPermissions: unknown,\n): SnapsPermissionRequest {\n  verifyRequestedSnapPermissions(requestedPermissions);\n\n  if (!existingPermissions[WALLET_SNAP_PERMISSION_KEY]) {\n    return requestedPermissions;\n  }\n\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ].caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = (snapIdCaveat?.value as Record<string, Json>) ?? {};\n\n  const requestedSnaps =\n    requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value;\n\n  const snapIdSet = new Set([\n    ...Object.keys(permittedSnaps),\n    ...Object.keys(requestedSnaps),\n  ]);\n\n  const mergedCaveatValue = [...snapIdSet].reduce<Record<string, Json>>(\n    (request, snapId) => {\n      request[snapId] = requestedSnaps[snapId] ?? permittedSnaps[snapId];\n      return request;\n    },\n    {},\n  );\n\n  requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value =\n    mergedCaveatValue;\n\n  return requestedPermissions;\n}\n\n/**\n * The `wallet_requestSnaps` method implementation.\n * Tries to install the requested snaps and adds them to the JSON-RPC response.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.installSnaps - A function that tries to install a given snap, prompting the user if necessary.\n * @param hooks.requestPermissions - A function that requests permissions on\n * behalf of a subject.\n * @param hooks.getPermissions - A function that gets the current permissions.\n * @returns A promise that resolves once the JSON-RPC response has been modified.\n * @throws If the params are invalid.\n */\nasync function requestSnapsImplementation(\n  req: JsonRpcRequest<RequestSnapsParams>,\n  res: PendingJsonRpcResponse<RequestSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { installSnaps, requestPermissions, getPermissions }: RequestSnapsHooks,\n): Promise<void> {\n  const requestedSnaps = req.params;\n  if (!isObject(requestedSnaps)) {\n    return end(\n      rpcErrors.invalidParams({\n        message: '\"params\" must be an object.',\n      }),\n    );\n  }\n\n  try {\n    if (Object.keys(requestedSnaps).length === 0) {\n      return end(\n        rpcErrors.invalidParams({\n          message: 'Request must have at least one requested snap.',\n        }),\n      );\n    }\n\n    const requestedPermissions = {\n      [WALLET_SNAP_PERMISSION_KEY]: {\n        caveats: [{ type: SnapCaveatType.SnapIds, value: requestedSnaps }],\n      },\n    } as RequestedPermissions;\n    const existingPermissions = await getPermissions();\n\n    if (!existingPermissions) {\n      const [, metadata] = await requestPermissions(requestedPermissions);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as RequestSnapsResult;\n    } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {\n      res.result = await installSnaps(requestedSnaps);\n    } else {\n      const mergedPermissionsRequest = getSnapPermissionsRequest(\n        existingPermissions,\n        requestedPermissions,\n      );\n\n      const [, metadata] = await requestPermissions(mergedPermissionsRequest);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as RequestSnapsResult;\n    }\n  } catch (error) {\n    res.error = error;\n  }\n\n  return end();\n}\n"]}

package/dist/chunk-4Z4X6EJP.mjs

@@ -0,0 +1,67 @@
+// src/restricted/caveats/permittedDerivationPaths.ts
+import { providerErrors, rpcErrors } from "@metamask/rpc-errors";
+import {
+  SnapCaveatType,
+  Bip32EntropyStruct,
+  isEqual
+} from "@metamask/snaps-utils";
+import { assertStruct } from "@metamask/utils";
+import { array, size, type } from "superstruct";
+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-4Z4X6EJP.mjs.map

package/dist/chunk-4Z4X6EJP.mjs.map

@@ -0,0 +1 @@
+{"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 type { Json } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { array, size, type } from 'superstruct';\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: (\n      method,\n      caveat: Caveat<SnapCaveatType.PermittedDerivationPaths, Bip32Entropy[]>,\n    ) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP32Path(params);\n\n        const path = caveat.value.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;AAEP,SAAS,oBAAoB;AAC7B,SAAS,OAAO,MAAM,YAAY;AAU3B,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,CACT,QACA,WACG;AACH,aAAO,OAAO,SAAS;AACrB,cAAM,EAAE,OAAO,IAAI;AACnB,0BAAkB,MAAM;AAExB,cAAM,OAAO,OAAO,MAAM;AAAA,UACxB,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-5HIIIAIS.mjs

@@ -0,0 +1,57 @@
+import {
+  getNode
+} from "./chunk-DR63Z4PV.mjs";
+
+// src/restricted/getBip32Entropy.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { SnapCaveatType } from "@metamask/snaps-utils";
+import { assert } from "@metamask/utils";
+var targetName = "snap_getBip32Entropy";
+var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName,
+    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],
+    methodImplementation: getBip32EntropyImplementation(methodHooks2),
+    validator: ({ caveats }) => {
+      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
+        throw rpcErrors.invalidParams({
+          message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`
+        });
+      }
+    },
+    subjectTypes: [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;
+    assert(params);
+    const node = await getNode({
+      curve: params.curve,
+      path: params.path,
+      secretRecoveryPhrase: await getMnemonic()
+    });
+    return node.toJSON();
+  };
+}
+
+export {
+  getBip32EntropyBuilder,
+  getBip32EntropyImplementation
+};
+//# sourceMappingURL=chunk-5HIIIAIS.mjs.map

package/dist/chunk-5HIIIAIS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getBip32Entropy.ts"],"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"],"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;","names":["methodHooks"]}

package/dist/chunk-632BZ6JY.js

@@ -0,0 +1,83 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils.ts
+var _keytree = require('@metamask/key-tree');
+
+
+
+
+
+
+var _utils = require('@metamask/utils');
+var _sha3 = require('@noble/hashes/sha3');
+var HARDENED_VALUE = 2147483648;
+function selectHooks(hooks, hookNames) {
+  if (hookNames) {
+    return Object.keys(hookNames).reduce(
+      (hookSubset, _hookName) => {
+        const hookName = _hookName;
+        hookSubset[hookName] = hooks[hookName];
+        return hookSubset;
+      },
+      {}
+    );
+  }
+  return void 0;
+}
+function getDerivationPathArray(hash) {
+  const array = [];
+  const view = _utils.createDataView.call(void 0, hash);
+  for (let index = 0; index < 8; index++) {
+    const uint32 = view.getUint32(index * 4);
+    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;
+    array.push(`bip32:${pathIndex - HARDENED_VALUE}'`);
+  }
+  return array;
+}
+async function deriveEntropy({
+  input,
+  salt = "",
+  mnemonicPhrase,
+  magic
+}) {
+  const inputBytes = _utils.stringToBytes.call(void 0, input);
+  const saltBytes = _utils.stringToBytes.call(void 0, salt);
+  const hash = _sha3.keccak_256.call(void 0, _utils.concatBytes.call(void 0, [inputBytes, _sha3.keccak_256.call(void 0, saltBytes)]));
+  const computedDerivationPath = getDerivationPathArray(hash);
+  const { privateKey } = await _keytree.SLIP10Node.fromDerivationPath({
+    derivationPath: [
+      mnemonicPhrase,
+      `bip32:${magic}`,
+      ...computedDerivationPath
+    ],
+    curve: "secp256k1"
+  });
+  _utils.assert.call(void 0, privateKey, "Failed to derive the entropy.");
+  return _utils.add0x.call(void 0, privateKey);
+}
+function getPathPrefix(curve) {
+  if (curve === "secp256k1") {
+    return "bip32";
+  }
+  return "slip10";
+}
+async function getNode({
+  curve,
+  secretRecoveryPhrase,
+  path
+}) {
+  const prefix = getPathPrefix(curve);
+  return await _keytree.SLIP10Node.fromDerivationPath({
+    curve,
+    derivationPath: [
+      secretRecoveryPhrase,
+      ...path.slice(1).map((index) => `${prefix}:${index}`)
+    ]
+  });
+}
+
+
+
+
+
+
+exports.selectHooks = selectHooks; exports.deriveEntropy = deriveEntropy; exports.getPathPrefix = getPathPrefix; exports.getNode = getNode;
+//# sourceMappingURL=chunk-632BZ6JY.js.map

package/dist/{cjs/utils.js.map → chunk-632BZ6JY.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import type {\n  HardenedBIP32Node,\n  BIP32Node,\n  SLIP10PathNode,\n} from '@metamask/key-tree';\nimport { SLIP10Node } from '@metamask/key-tree';\nimport type { MagicValue } from '@metamask/snaps-utils';\nimport type { Hex } from '@metamask/utils';\nimport {\n  add0x,\n  assert,\n  concatBytes,\n  createDataView,\n  stringToBytes,\n} from '@metamask/utils';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\n\nconst HARDENED_VALUE = 0x80000000;\n\n/**\n * Maps an interface with method hooks to an object, using the keys of the\n * interface, and `true` as value. This ensures that the `methodHooks` object\n * has the same values as the interface.\n */\nexport type MethodHooksObject<HooksType extends Record<string, unknown>> = {\n  [Key in keyof HooksType]: true;\n};\n\n/**\n * Returns the subset of the specified `hooks` that are included in the\n * `hookNames` object. This is a Principle of Least Authority (POLA) measure\n * to ensure that each RPC method implementation only has access to the\n * API \"hooks\" it needs to do its job.\n *\n * @param hooks - The hooks to select from.\n * @param hookNames - The names of the hooks to select.\n * @returns The selected hooks.\n * @template Hooks - The hooks to select from.\n * @template HookName - The names of the hooks to select.\n */\nexport function selectHooks<\n  Hooks extends Record<string, unknown>,\n  HookName extends keyof Hooks,\n>(\n  hooks: Hooks,\n  hookNames?: Record<HookName, boolean>,\n): Pick<Hooks, HookName> | undefined {\n  if (hookNames) {\n    return Object.keys(hookNames).reduce<Partial<Pick<Hooks, HookName>>>(\n      (hookSubset, _hookName) => {\n        const hookName = _hookName as HookName;\n        hookSubset[hookName] = hooks[hookName];\n        return hookSubset;\n      },\n      {},\n    ) as Pick<Hooks, HookName>;\n  }\n  return undefined;\n}\n\n/**\n * Get a BIP-32 derivation path array from a hash, which is compatible with\n * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.\n *\n * @param hash - The hash to derive indices from.\n * @returns The derived indices as a {@link HardenedBIP32Node} array.\n */\nfunction getDerivationPathArray(hash: Uint8Array): HardenedBIP32Node[] {\n  const array: HardenedBIP32Node[] = [];\n  const view = createDataView(hash);\n\n  for (let index = 0; index < 8; index++) {\n    const uint32 = view.getUint32(index * 4);\n\n    // This is essentially `index | 0x80000000`. Because JavaScript numbers are\n    // signed, we use the bitwise unsigned right shift operator to ensure that\n    // the result is a positive number.\n    // eslint-disable-next-line no-bitwise\n    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;\n    array.push(`bip32:${pathIndex - HARDENED_VALUE}'` as const);\n  }\n\n  return array;\n}\n\ntype DeriveEntropyOptions = {\n  /**\n   * The input value to derive entropy from.\n   */\n  input: string;\n\n  /**\n   * An optional salt to use when deriving entropy.\n   */\n  salt?: string;\n\n  /**\n   * The mnemonic phrase to use for entropy derivation.\n   */\n  mnemonicPhrase: Uint8Array;\n\n  /**\n   * A hardened BIP-32 index, which is used to derive the root key from the\n   * mnemonic phrase.\n   */\n  magic: MagicValue;\n};\n\n/**\n * Derive entropy from the given mnemonic phrase and salt.\n *\n * This is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param options - The options for entropy derivation.\n * @param options.input - The input value to derive entropy from.\n * @param options.salt - An optional salt to use when deriving entropy.\n * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy\n * derivation.\n * @param options.magic - A hardened BIP-32 index, which is used to derive the\n * root key from the mnemonic phrase.\n * @returns The derived entropy.\n */\nexport async function deriveEntropy({\n  input,\n  salt = '',\n  mnemonicPhrase,\n  magic,\n}: DeriveEntropyOptions): Promise<Hex> {\n  const inputBytes = stringToBytes(input);\n  const saltBytes = stringToBytes(salt);\n\n  // Get the derivation path from the snap ID.\n  const hash = keccak256(concatBytes([inputBytes, keccak256(saltBytes)]));\n  const computedDerivationPath = getDerivationPathArray(hash);\n\n  // Derive the private key using BIP-32.\n  const { privateKey } = await SLIP10Node.fromDerivationPath({\n    derivationPath: [\n      mnemonicPhrase,\n      `bip32:${magic}`,\n      ...computedDerivationPath,\n    ],\n    curve: 'secp256k1',\n  });\n\n  // This should never happen, but this keeps TypeScript happy.\n  assert(privateKey, 'Failed to derive the entropy.');\n\n  return add0x(privateKey);\n}\n\n/**\n * Get the path prefix to use for key derivation in `key-tree`. This assumes the\n * following:\n *\n * - The Secp256k1 curve always use the BIP-32 specification.\n * - The Ed25519 curve always use the SLIP-10 specification.\n *\n * While this does not matter in most situations (no known case at the time of\n * writing), `key-tree` requires a specific specification to be used.\n *\n * @param curve - The curve to get the path prefix for. The curve is NOT\n * validated by this function.\n * @returns The path prefix, i.e., `secp256k1` or `ed25519`.\n */\nexport function getPathPrefix(\n  curve: 'secp256k1' | 'ed25519',\n): 'bip32' | 'slip10' {\n  if (curve === 'secp256k1') {\n    return 'bip32';\n  }\n\n  return 'slip10';\n}\n\ntype GetNodeArgs = {\n  curve: 'secp256k1' | 'ed25519';\n  secretRecoveryPhrase: Uint8Array;\n  path: string[];\n};\n\n/**\n * Get a `key-tree`-compatible node.\n *\n * Note: This function assumes that all the parameters have been validated\n * beforehand.\n *\n * @param options - The derivation options.\n * @param options.curve - The curve to use for derivation.\n * @param options.secretRecoveryPhrase - The secret recovery phrase to use for\n * derivation.\n * @param options.path - The derivation path to use as array, starting with an\n * \"m\" as the first item.\n */\nexport async function getNode({\n  curve,\n  secretRecoveryPhrase,\n  path,\n}: GetNodeArgs) {\n  const prefix = getPathPrefix(curve);\n  return await SLIP10Node.fromDerivationPath({\n    curve,\n    derivationPath: [\n      secretRecoveryPhrase,\n      ...(path.slice(1).map((index) => `${prefix}:${index}`) as\n        | BIP32Node[]\n        | SLIP10PathNode[]),\n    ],\n  });\n}\n"],"names":["selectHooks","deriveEntropy","getPathPrefix","getNode","HARDENED_VALUE","hooks","hookNames","Object","keys","reduce","hookSubset","_hookName","hookName","undefined","getDerivationPathArray","hash","array","view","createDataView","index","uint32","getUint32","pathIndex","push","input","salt","mnemonicPhrase","magic","inputBytes","stringToBytes","saltBytes","keccak256","concatBytes","computedDerivationPath","privateKey","SLIP10Node","fromDerivationPath","derivationPath","curve","assert","add0x","secretRecoveryPhrase","path","prefix","slice","map"],"mappings":";;;;;;;;;;;IAwCgBA,WAAW;eAAXA;;IAmFMC,aAAa;eAAbA;;IA2CNC,aAAa;eAAbA;;IA6BMC,OAAO;eAAPA;;;yBA9LK;uBASpB;sBACiC;AAExC,MAAMC,iBAAiB;AAuBhB,SAASJ,YAIdK,KAAY,EACZC,SAAqC;IAErC,IAAIA,WAAW;QACb,OAAOC,OAAOC,IAAI,CAACF,WAAWG,MAAM,CAClC,CAACC,YAAYC;YACX,MAAMC,WAAWD;YACjBD,UAAU,CAACE,SAAS,GAAGP,KAAK,CAACO,SAAS;YACtC,OAAOF;QACT,GACA,CAAC;IAEL;IACA,OAAOG;AACT;AAEA;;;;;;CAMC,GACD,SAASC,uBAAuBC,IAAgB;IAC9C,MAAMC,QAA6B,EAAE;IACrC,MAAMC,OAAOC,IAAAA,qBAAc,EAACH;IAE5B,IAAK,IAAII,QAAQ,GAAGA,QAAQ,GAAGA,QAAS;QACtC,MAAMC,SAASH,KAAKI,SAAS,CAACF,QAAQ;QAEtC,2EAA2E;QAC3E,0EAA0E;QAC1E,mCAAmC;QACnC,sCAAsC;QACtC,MAAMG,YAAY,AAACF,CAAAA,SAAShB,cAAa,MAAO;QAChDY,MAAMO,IAAI,CAAC,CAAC,MAAM,EAAED,YAAYlB,eAAe,CAAC,CAAC;IACnD;IAEA,OAAOY;AACT;AAwCO,eAAef,cAAc,EAClCuB,KAAK,EACLC,OAAO,EAAE,EACTC,cAAc,EACdC,KAAK,EACgB;IACrB,MAAMC,aAAaC,IAAAA,oBAAa,EAACL;IACjC,MAAMM,YAAYD,IAAAA,oBAAa,EAACJ;IAEhC,4CAA4C;IAC5C,MAAMV,OAAOgB,IAAAA,gBAAS,EAACC,IAAAA,kBAAW,EAAC;QAACJ;QAAYG,IAAAA,gBAAS,EAACD;KAAW;IACrE,MAAMG,yBAAyBnB,uBAAuBC;IAEtD,uCAAuC;IACvC,MAAM,EAAEmB,UAAU,EAAE,GAAG,MAAMC,mBAAU,CAACC,kBAAkB,CAAC;QACzDC,gBAAgB;YACdX;YACA,CAAC,MAAM,EAAEC,MAAM,CAAC;eACbM;SACJ;QACDK,OAAO;IACT;IAEA,6DAA6D;IAC7DC,IAAAA,aAAM,EAACL,YAAY;IAEnB,OAAOM,IAAAA,YAAK,EAACN;AACf;AAgBO,SAAShC,cACdoC,KAA8B;IAE9B,IAAIA,UAAU,aAAa;QACzB,OAAO;IACT;IAEA,OAAO;AACT;AAqBO,eAAenC,QAAQ,EAC5BmC,KAAK,EACLG,oBAAoB,EACpBC,IAAI,EACQ;IACZ,MAAMC,SAASzC,cAAcoC;IAC7B,OAAO,MAAMH,mBAAU,CAACC,kBAAkB,CAAC;QACzCE;QACAD,gBAAgB;YACdI;eACIC,KAAKE,KAAK,CAAC,GAAGC,GAAG,CAAC,CAAC1B,QAAU,CAAC,EAAEwB,OAAO,CAAC,EAAExB,MAAM,CAAC;SAGtD;IACH;AACF"}
+{"version":3,"sources":["../src/utils.ts"],"names":[],"mappings":";AAKA,SAAS,kBAAkB;AAG3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc,iBAAiB;AAExC,IAAM,iBAAiB;AAuBhB,SAAS,YAId,OACA,WACmC;AACnC,MAAI,WAAW;AACb,WAAO,OAAO,KAAK,SAAS,EAAE;AAAA,MAC5B,CAAC,YAAY,cAAc;AACzB,cAAM,WAAW;AACjB,mBAAW,QAAQ,IAAI,MAAM,QAAQ;AACrC,eAAO;AAAA,MACT;AAAA,MACA,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO;AACT;AASA,SAAS,uBAAuB,MAAuC;AACrE,QAAM,QAA6B,CAAC;AACpC,QAAM,OAAO,eAAe,IAAI;AAEhC,WAAS,QAAQ,GAAG,QAAQ,GAAG,SAAS;AACtC,UAAM,SAAS,KAAK,UAAU,QAAQ,CAAC;AAMvC,UAAM,aAAa,SAAS,oBAAoB;AAChD,UAAM,KAAK,SAAS,YAAY,cAAc,GAAY;AAAA,EAC5D;AAEA,SAAO;AACT;AAwCA,eAAsB,cAAc;AAAA,EAClC;AAAA,EACA,OAAO;AAAA,EACP;AAAA,EACA;AACF,GAAuC;AACrC,QAAM,aAAa,cAAc,KAAK;AACtC,QAAM,YAAY,cAAc,IAAI;AAGpC,QAAM,OAAO,UAAU,YAAY,CAAC,YAAY,UAAU,SAAS,CAAC,CAAC,CAAC;AACtE,QAAM,yBAAyB,uBAAuB,IAAI;AAG1D,QAAM,EAAE,WAAW,IAAI,MAAM,WAAW,mBAAmB;AAAA,IACzD,gBAAgB;AAAA,MACd;AAAA,MACA,SAAS,KAAK;AAAA,MACd,GAAG;AAAA,IACL;AAAA,IACA,OAAO;AAAA,EACT,CAAC;AAGD,SAAO,YAAY,+BAA+B;AAElD,SAAO,MAAM,UAAU;AACzB;AAgBO,SAAS,cACd,OACoB;AACpB,MAAI,UAAU,aAAa;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAqBA,eAAsB,QAAQ;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AACF,GAAgB;AACd,QAAM,SAAS,cAAc,KAAK;AAClC,SAAO,MAAM,WAAW,mBAAmB;AAAA,IACzC;AAAA,IACA,gBAAgB;AAAA,MACd;AAAA,MACA,GAAI,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,UAAU,GAAG,MAAM,IAAI,KAAK,EAAE;AAAA,IAGvD;AAAA,EACF,CAAC;AACH","sourcesContent":["import type {\n  HardenedBIP32Node,\n  BIP32Node,\n  SLIP10PathNode,\n} from '@metamask/key-tree';\nimport { SLIP10Node } from '@metamask/key-tree';\nimport type { MagicValue } from '@metamask/snaps-utils';\nimport type { Hex } from '@metamask/utils';\nimport {\n  add0x,\n  assert,\n  concatBytes,\n  createDataView,\n  stringToBytes,\n} from '@metamask/utils';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\n\nconst HARDENED_VALUE = 0x80000000;\n\n/**\n * Maps an interface with method hooks to an object, using the keys of the\n * interface, and `true` as value. This ensures that the `methodHooks` object\n * has the same values as the interface.\n */\nexport type MethodHooksObject<HooksType extends Record<string, unknown>> = {\n  [Key in keyof HooksType]: true;\n};\n\n/**\n * Returns the subset of the specified `hooks` that are included in the\n * `hookNames` object. This is a Principle of Least Authority (POLA) measure\n * to ensure that each RPC method implementation only has access to the\n * API \"hooks\" it needs to do its job.\n *\n * @param hooks - The hooks to select from.\n * @param hookNames - The names of the hooks to select.\n * @returns The selected hooks.\n * @template Hooks - The hooks to select from.\n * @template HookName - The names of the hooks to select.\n */\nexport function selectHooks<\n  Hooks extends Record<string, unknown>,\n  HookName extends keyof Hooks,\n>(\n  hooks: Hooks,\n  hookNames?: Record<HookName, boolean>,\n): Pick<Hooks, HookName> | undefined {\n  if (hookNames) {\n    return Object.keys(hookNames).reduce<Partial<Pick<Hooks, HookName>>>(\n      (hookSubset, _hookName) => {\n        const hookName = _hookName as HookName;\n        hookSubset[hookName] = hooks[hookName];\n        return hookSubset;\n      },\n      {},\n    ) as Pick<Hooks, HookName>;\n  }\n  return undefined;\n}\n\n/**\n * Get a BIP-32 derivation path array from a hash, which is compatible with\n * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.\n *\n * @param hash - The hash to derive indices from.\n * @returns The derived indices as a {@link HardenedBIP32Node} array.\n */\nfunction getDerivationPathArray(hash: Uint8Array): HardenedBIP32Node[] {\n  const array: HardenedBIP32Node[] = [];\n  const view = createDataView(hash);\n\n  for (let index = 0; index < 8; index++) {\n    const uint32 = view.getUint32(index * 4);\n\n    // This is essentially `index | 0x80000000`. Because JavaScript numbers are\n    // signed, we use the bitwise unsigned right shift operator to ensure that\n    // the result is a positive number.\n    // eslint-disable-next-line no-bitwise\n    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;\n    array.push(`bip32:${pathIndex - HARDENED_VALUE}'` as const);\n  }\n\n  return array;\n}\n\ntype DeriveEntropyOptions = {\n  /**\n   * The input value to derive entropy from.\n   */\n  input: string;\n\n  /**\n   * An optional salt to use when deriving entropy.\n   */\n  salt?: string;\n\n  /**\n   * The mnemonic phrase to use for entropy derivation.\n   */\n  mnemonicPhrase: Uint8Array;\n\n  /**\n   * A hardened BIP-32 index, which is used to derive the root key from the\n   * mnemonic phrase.\n   */\n  magic: MagicValue;\n};\n\n/**\n * Derive entropy from the given mnemonic phrase and salt.\n *\n * This is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param options - The options for entropy derivation.\n * @param options.input - The input value to derive entropy from.\n * @param options.salt - An optional salt to use when deriving entropy.\n * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy\n * derivation.\n * @param options.magic - A hardened BIP-32 index, which is used to derive the\n * root key from the mnemonic phrase.\n * @returns The derived entropy.\n */\nexport async function deriveEntropy({\n  input,\n  salt = '',\n  mnemonicPhrase,\n  magic,\n}: DeriveEntropyOptions): Promise<Hex> {\n  const inputBytes = stringToBytes(input);\n  const saltBytes = stringToBytes(salt);\n\n  // Get the derivation path from the snap ID.\n  const hash = keccak256(concatBytes([inputBytes, keccak256(saltBytes)]));\n  const computedDerivationPath = getDerivationPathArray(hash);\n\n  // Derive the private key using BIP-32.\n  const { privateKey } = await SLIP10Node.fromDerivationPath({\n    derivationPath: [\n      mnemonicPhrase,\n      `bip32:${magic}`,\n      ...computedDerivationPath,\n    ],\n    curve: 'secp256k1',\n  });\n\n  // This should never happen, but this keeps TypeScript happy.\n  assert(privateKey, 'Failed to derive the entropy.');\n\n  return add0x(privateKey);\n}\n\n/**\n * Get the path prefix to use for key derivation in `key-tree`. This assumes the\n * following:\n *\n * - The Secp256k1 curve always use the BIP-32 specification.\n * - The Ed25519 curve always use the SLIP-10 specification.\n *\n * While this does not matter in most situations (no known case at the time of\n * writing), `key-tree` requires a specific specification to be used.\n *\n * @param curve - The curve to get the path prefix for. The curve is NOT\n * validated by this function.\n * @returns The path prefix, i.e., `secp256k1` or `ed25519`.\n */\nexport function getPathPrefix(\n  curve: 'secp256k1' | 'ed25519',\n): 'bip32' | 'slip10' {\n  if (curve === 'secp256k1') {\n    return 'bip32';\n  }\n\n  return 'slip10';\n}\n\ntype GetNodeArgs = {\n  curve: 'secp256k1' | 'ed25519';\n  secretRecoveryPhrase: Uint8Array;\n  path: string[];\n};\n\n/**\n * Get a `key-tree`-compatible node.\n *\n * Note: This function assumes that all the parameters have been validated\n * beforehand.\n *\n * @param options - The derivation options.\n * @param options.curve - The curve to use for derivation.\n * @param options.secretRecoveryPhrase - The secret recovery phrase to use for\n * derivation.\n * @param options.path - The derivation path to use as array, starting with an\n * \"m\" as the first item.\n */\nexport async function getNode({\n  curve,\n  secretRecoveryPhrase,\n  path,\n}: GetNodeArgs) {\n  const prefix = getPathPrefix(curve);\n  return await SLIP10Node.fromDerivationPath({\n    curve,\n    derivationPath: [\n      secretRecoveryPhrase,\n      ...(path.slice(1).map((index) => `${prefix}:${index}`) as\n        | BIP32Node[]\n        | SLIP10PathNode[]),\n    ],\n  });\n}\n"]}

package/dist/chunk-6DUTJBD2.mjs

@@ -0,0 +1,82 @@
+// src/restricted/invokeSnap.ts
+import { PermissionType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { HandlerType, SnapCaveatType } from "@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: PermissionType.RestrictedMethod,
+    targetName: WALLET_SNAP_PERMISSION_KEY,
+    allowedCaveats: [SnapCaveatType.SnapIds],
+    methodImplementation: getInvokeSnapImplementation(methodHooks2),
+    validator: ({ caveats }) => {
+      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.SnapIds) {
+        throw rpcErrors.invalidParams({
+          message: `Expected a single "${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.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: HandlerType.OnRpcRequest
+    });
+  };
+}
+
+export {
+  WALLET_SNAP_PERMISSION_KEY,
+  handleSnapInstall,
+  invokeSnapBuilder,
+  getInvokeSnapImplementation
+};
+//# sourceMappingURL=chunk-6DUTJBD2.mjs.map