@metamask/snaps-rpc-methods 6.0.0 → 7.0.1

package/dist/cjs/restricted/caveats/permittedDerivationPaths.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    permittedDerivationPathsCaveatMapper: function() {
-        return permittedDerivationPathsCaveatMapper;
-    },
-    validateBIP32Path: function() {
-        return validateBIP32Path;
-    },
-    validateBIP32CaveatPaths: function() {
-        return validateBIP32CaveatPaths;
-    },
-    PermittedDerivationPathsCaveatSpecification: function() {
-        return PermittedDerivationPathsCaveatSpecification;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-function permittedDerivationPathsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: _snapsutils.SnapCaveatType.PermittedDerivationPaths,
-                value
-            }
-        ]
-    };
-}
-function validateBIP32Path(value) {
-    (0, _utils.assertStruct)(value, _snapsutils.Bip32EntropyStruct, 'Invalid BIP-32 entropy path definition', _rpcerrors.rpcErrors.invalidParams);
-}
-function validateBIP32CaveatPaths(caveat) {
-    (0, _utils.assertStruct)(caveat, (0, _superstruct.type)({
-        value: (0, _superstruct.size)((0, _superstruct.array)(_snapsutils.Bip32EntropyStruct), 1, Infinity)
-    }), 'Invalid BIP-32 entropy caveat', _rpcerrors.rpcErrors.internal);
-}
-const PermittedDerivationPathsCaveatSpecification = {
-    [_snapsutils.SnapCaveatType.PermittedDerivationPaths]: Object.freeze({
-        type: _snapsutils.SnapCaveatType.PermittedDerivationPaths,
-        decorator: (method, caveat)=>{
-            return async (args)=>{
-                const { params } = args;
-                validateBIP32Path(params);
-                const path = caveat.value.find((caveatPath)=>(0, _snapsutils.isEqual)(params.path.slice(0, caveatPath.path.length), caveatPath.path) && caveatPath.curve === params.curve);
-                if (!path) {
-                    throw _rpcerrors.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)
-    })
-};
-
-//# sourceMappingURL=permittedDerivationPaths.js.map

package/dist/cjs/restricted/caveats/permittedDerivationPaths.js.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 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"],"names":["permittedDerivationPathsCaveatMapper","validateBIP32Path","validateBIP32CaveatPaths","PermittedDerivationPathsCaveatSpecification","value","caveats","type","SnapCaveatType","PermittedDerivationPaths","assertStruct","Bip32EntropyStruct","rpcErrors","invalidParams","caveat","size","array","Infinity","internal","Object","freeze","decorator","method","args","params","path","find","caveatPath","isEqual","slice","length","curve","providerErrors","unauthorized","message","validator"],"mappings":";;;;;;;;;;;IAwBgBA,oCAAoC;eAApCA;;IAsBAC,iBAAiB;eAAjBA;;IAkBAC,wBAAwB;eAAxBA;;IAWHC,2CAA2C;eAA3CA;;;2BAtE6B;4BAMnC;uBAEsB;6BACK;AAU3B,SAASH,qCACdI,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAMC,0BAAc,CAACC,wBAAwB;gBAC7CJ;YACF;SACD;IACH;AACF;AAWO,SAASH,kBACdG,KAAc;IAEdK,IAAAA,mBAAY,EACVL,OACAM,8BAAkB,EAClB,0CACAC,oBAAS,CAACC,aAAa;AAE3B;AASO,SAASV,yBACdW,MAA2B;IAE3BJ,IAAAA,mBAAY,EACVI,QACAP,IAAAA,iBAAI,EAAC;QAAEF,OAAOU,IAAAA,iBAAI,EAACC,IAAAA,kBAAK,EAACL,8BAAkB,GAAG,GAAGM;IAAU,IAC3D,iCACAL,oBAAS,CAACM,QAAQ;AAEtB;AAEO,MAAMd,8CAGT;IACF,CAACI,0BAAc,CAACC,wBAAwB,CAAC,EAAEU,OAAOC,MAAM,CAAC;QACvDb,MAAMC,0BAAc,CAACC,wBAAwB;QAC7CY,WAAW,CACTC,QACAR;YAEA,OAAO,OAAOS;gBACZ,MAAM,EAAEC,MAAM,EAAE,GAAGD;gBACnBrB,kBAAkBsB;gBAElB,MAAMC,OAAOX,OAAOT,KAAK,CAACqB,IAAI,CAC5B,CAACC,aACCC,IAAAA,mBAAO,EACLJ,OAAOC,IAAI,CAACI,KAAK,CAAC,GAAGF,WAAWF,IAAI,CAACK,MAAM,GAC3CH,WAAWF,IAAI,KACZE,WAAWI,KAAK,KAAKP,OAAOO,KAAK;gBAG1C,IAAI,CAACN,MAAM;oBACT,MAAMO,yBAAc,CAACC,YAAY,CAAC;wBAChCC,SACE;oBACJ;gBACF;gBAEA,OAAO,MAAMZ,OAAOC;YACtB;QACF;QACAY,WAAW,CAACrB,SAAWX,yBAAyBW;IAClD;AACF"}

package/dist/cjs/restricted/caveats/snapIds.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    snapIdsCaveatMapper: function() {
-        return snapIdsCaveatMapper;
-    },
-    validateSnapIdsCaveat: function() {
-        return validateSnapIdsCaveat;
-    },
-    SnapIdsCaveatSpecification: function() {
-        return SnapIdsCaveatSpecification;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-function snapIdsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: _snapsutils.SnapCaveatType.SnapIds,
-                value
-            }
-        ]
-    };
-}
-function validateSnapIdsCaveat(caveat) {
-    (0, _utils.assertStruct)(caveat, (0, _superstruct.type)({
-        value: _snapsutils.SnapIdsStruct
-    }), 'Expected caveat to have a value property of a non-empty object of snap IDs.', _rpcerrors.rpcErrors.invalidParams);
-}
-const 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 (!(0, _utils.hasProperty)(snapIds, snapId)) {
-                    throw new Error(`${origin} does not have permission to invoke ${snapId} snap.`);
-                }
-                return await method(args);
-            };
-        }
-    })
-};
-
-//# sourceMappingURL=snapIds.js.map

package/dist/cjs/restricted/caveats/snapIds.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/restricted/caveats/snapIds.ts"],"sourcesContent":["import type {\n  Caveat,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n  RestrictedMethodCaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { SnapIds } from '@metamask/snaps-utils';\nimport { SnapCaveatType, SnapIdsStruct } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, assertStruct } from '@metamask/utils';\nimport { type } from 'superstruct';\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;\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"],"names":["snapIdsCaveatMapper","validateSnapIdsCaveat","SnapIdsCaveatSpecification","value","caveats","type","SnapCaveatType","SnapIds","caveat","assertStruct","SnapIdsStruct","rpcErrors","invalidParams","Object","freeze","validator","decorator","method","args","params","context","origin","snapIds","snapId","hasProperty","Error"],"mappings":";;;;;;;;;;;IAwBgBA,mBAAmB;eAAnBA;;IAmBAC,qBAAqB;eAArBA;;IAaHC,0BAA0B;eAA1BA;;;2BAjDa;4BAEoB;uBAEJ;6BACrB;AAYd,SAASF,oBACdG,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAMC,0BAAc,CAACC,OAAO;gBAC5BJ;YACF;SACD;IACH;AACF;AAQO,SAASF,sBACdO,MAA2B;IAE3BC,IAAAA,mBAAY,EACVD,QACAH,IAAAA,iBAAI,EAAC;QACHF,OAAOO,yBAAa;IACtB,IACA,+EACAC,oBAAS,CAACC,aAAa;AAE3B;AAEO,MAAMV,6BAGT;IACF,CAACI,0BAAc,CAACC,OAAO,CAAC,EAAEM,OAAOC,MAAM,CAAC;QACtCT,MAAMC,0BAAc,CAACC,OAAO;QAC5BQ,WAAW,CAACP,SAAWP,sBAAsBO;QAC7CQ,WAAW,CAACC,QAAQT;YAClB,OAAO,OAAOU;gBACZ,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAwDH;gBACzD,MAAMI,UAAUd,OAAOL,KAAK;gBAC5B,MAAM,EAAEoB,MAAM,EAAE,GAAGJ;gBACnB,IAAI,CAACK,IAAAA,kBAAW,EAACF,SAASC,SAAS;oBACjC,MAAM,IAAIE,MACR,CAAC,EAAEJ,OAAO,oCAAoC,EAAEE,OAAO,MAAM,CAAC;gBAElE;gBACA,OAAO,MAAMN,OAAOC;YACtB;QACF;IACF;AACF"}

package/dist/cjs/restricted/dialog.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    dialogBuilder: function() {
-        return dialogBuilder;
-    },
-    getDialogImplementation: function() {
-        return getDialogImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapssdk = require("@metamask/snaps-sdk");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-const methodName = 'snap_dialog';
-const PlaceholderStruct = (0, _superstruct.optional)((0, _superstruct.size)((0, _superstruct.string)(), 1, 40));
-/**
- * The specification builder for the `snap_dialog` permission. `snap_dialog`
- * lets the Snap display one of the following dialogs to the user:
- * - An alert, for displaying information.
- * - A confirmation, for accepting or rejecting some action.
- * - A prompt, for inputting some information.
- *
- * @param options - The specification builder options.
- * @param options.allowedCaveats - The optional allowed caveats for the
- * permission.
- * @param options.methodHooks - The RPC method hooks needed by the method
- * implementation.
- * @returns The specification for the `snap_dialog` permission.
- */ const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getDialogImplementation(methodHooks),
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    showDialog: true,
-    createInterface: true,
-    getInterface: true
-};
-const dialogBuilder = Object.freeze({
-    targetName: methodName,
-    specificationBuilder,
-    methodHooks
-});
-// Note: We use `type` here instead of `object` because `type` does not validate
-// the keys of the object, which is what we want.
-const BaseParamsStruct = (0, _superstruct.type)({
-    type: (0, _superstruct.enums)([
-        _snapssdk.DialogType.Alert,
-        _snapssdk.DialogType.Confirmation,
-        _snapssdk.DialogType.Prompt
-    ])
-});
-const AlertParametersWithContentStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Alert),
-    content: _snapssdk.ComponentStruct
-});
-const AlertParametersWithIdStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Alert),
-    id: (0, _superstruct.string)()
-});
-const AlertParametersStruct = (0, _snapssdk.union)([
-    AlertParametersWithContentStruct,
-    AlertParametersWithIdStruct
-]);
-const ConfirmationParametersWithContentStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Confirmation),
-    content: _snapssdk.ComponentStruct
-});
-const ConfirmationParametersWithIdStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Confirmation),
-    id: (0, _superstruct.string)()
-});
-const ConfirmationParametersStruct = (0, _snapssdk.union)([
-    ConfirmationParametersWithContentStruct,
-    ConfirmationParametersWithIdStruct
-]);
-const PromptParametersWithContentStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Prompt),
-    content: _snapssdk.ComponentStruct,
-    placeholder: PlaceholderStruct
-});
-const PromptParametersWithIdStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Prompt),
-    id: (0, _superstruct.string)(),
-    placeholder: PlaceholderStruct
-});
-const PromptParametersStruct = (0, _snapssdk.union)([
-    PromptParametersWithContentStruct,
-    PromptParametersWithIdStruct
-]);
-const DialogParametersStruct = (0, _snapssdk.union)([
-    AlertParametersStruct,
-    ConfirmationParametersStruct,
-    PromptParametersStruct
-]);
-const 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 : undefined;
-        if ((0, _utils.hasProperty)(validatedParams, 'content')) {
-            const id = await createInterface(origin, validatedParams.content);
-            return showDialog(origin, validatedType, id, placeholder);
-        }
-        // Verify that the passed interface ID is valid.
-        // This will throw if the interface ID is invalid (not created by the snap or doesn't exist)
-        try {
-            getInterface(origin, validatedParams.id);
-        } catch (error) {
-            throw _rpcerrors.rpcErrors.invalidParams({
-                message: `Invalid params: ${error.message}`
-            });
-        }
-        return showDialog(origin, validatedType, validatedParams.id, placeholder);
-    };
-}
-/**
- * Get the validated type of the dialog parameters. Throws an error if the type
- * is invalid.
- *
- * @param params - The parameters to validate.
- * @returns The validated type of the dialog parameters.
- */ function getValidatedType(params) {
-    try {
-        return (0, _superstruct.create)(params, BaseParamsStruct).type;
-    } catch (error) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: `The "type" property must be one of: ${Object.values(_snapssdk.DialogType).join(', ')}.`
-        });
-    }
-}
-/**
- * Validates the confirm method `params` and returns them cast to the correct
- * type. Throws if validation fails.
- *
- * @param params - The unvalidated params object from the method request.
- * @param struct - The struct to validate the params against.
- * @returns The validated confirm method parameter object.
- */ function getValidatedParams(params, struct) {
-    try {
-        return (0, _snapsutils.createUnion)(params, struct, 'type');
-    } catch (error) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: `Invalid params: ${error.message}`
-        });
-    }
-}
-
-//# sourceMappingURL=dialog.js.map

package/dist/cjs/restricted/dialog.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/dialog.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 {\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"],"names":["dialogBuilder","getDialogImplementation","methodName","PlaceholderStruct","optional","size","string","specificationBuilder","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","showDialog","createInterface","getInterface","Object","freeze","BaseParamsStruct","type","enums","DialogType","Alert","Confirmation","Prompt","AlertParametersWithContentStruct","object","enumValue","content","ComponentStruct","AlertParametersWithIdStruct","id","AlertParametersStruct","union","ConfirmationParametersWithContentStruct","ConfirmationParametersWithIdStruct","ConfirmationParametersStruct","PromptParametersWithContentStruct","placeholder","PromptParametersWithIdStruct","PromptParametersStruct","DialogParametersStruct","structs","dialogImplementation","args","params","context","origin","validatedType","getValidatedType","validatedParams","getValidatedParams","undefined","hasProperty","error","rpcErrors","invalidParams","message","create","values","join","struct","createUnion"],"mappings":"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"}

package/dist/cjs/restricted/getBip32Entropy.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getBip32EntropyBuilder: function() {
-        return getBip32EntropyBuilder;
-    },
-    getBip32EntropyImplementation: function() {
-        return getBip32EntropyImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _utils1 = require("../utils");
-const targetName = 'snap_getBip32Entropy';
-/**
- * The specification builder for the `snap_getBip32Entropy` permission.
- * `snap_getBip32Entropy` lets the Snap control private keys for a particular
- * BIP-32 node.
- *
- * @param options - The specification builder options.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `snap_getBip32Entropy` permission.
- */ const specificationBuilder = ({ methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            _snapsutils.SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32EntropyImplementation(methodHooks),
-        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
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-const getBip32EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-function getBip32EntropyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip32Entropy(args) {
-        await getUnlockPromise(true);
-        const { params } = args;
-        (0, _utils.assert)(params);
-        const node = await (0, _utils1.getNode)({
-            curve: params.curve,
-            path: params.path,
-            secretRecoveryPhrase: await getMnemonic()
-        });
-        return node.toJSON();
-    };
-}
-
-//# sourceMappingURL=getBip32Entropy.js.map

package/dist/cjs/restricted/getBip32Entropy.js.map

@@ -1 +0,0 @@
-{"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"],"names":["getBip32EntropyBuilder","getBip32EntropyImplementation","targetName","specificationBuilder","methodHooks","permissionType","PermissionType","RestrictedMethod","allowedCaveats","SnapCaveatType","PermittedDerivationPaths","methodImplementation","validator","caveats","length","type","rpcErrors","invalidParams","message","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","Object","freeze","getBip32Entropy","args","params","assert","node","getNode","curve","path","secretRecoveryPhrase","toJSON"],"mappings":";;;;;;;;;;;IAqFaA,sBAAsB;eAAtBA;;IAgBGC,6BAA6B;eAA7BA;;;sCA/F4B;2BAClB;4BAKK;uBAER;wBAGC;AAExB,MAAMC,aAAa;AA4BnB;;;;;;;;CAQC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CL;QACAM,gBAAgB;YAACC,0BAAc,CAACC,wBAAwB;SAAC;QACzDC,sBAAsBV,8BAA8BG;QACpDQ,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKN,0BAAc,CAACC,wBAAwB,EAC3D;gBACA,MAAMM,oBAAS,CAACC,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAET,0BAAc,CAACC,wBAAwB,CAAC,SAAS,CAAC;gBACnF;YACF;QACF;QACAS,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMjB,cAA6D;IACjEkB,aAAa;IACbC,kBAAkB;AACpB;AAEO,MAAMvB,yBAAyBwB,OAAOC,MAAM,CAAC;IAClDvB;IACAC;IACAC;AACF;AAYO,SAASH,8BAA8B,EAC5CqB,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeG,gBACpBC,IAAoD;QAEpD,MAAMJ,iBAAiB;QAEvB,MAAM,EAAEK,MAAM,EAAE,GAAGD;QACnBE,IAAAA,aAAM,EAACD;QAEP,MAAME,OAAO,MAAMC,IAAAA,eAAO,EAAC;YACzBC,OAAOJ,OAAOI,KAAK;YACnBC,MAAML,OAAOK,IAAI;YACjBC,sBAAsB,MAAMZ;QAC9B;QAEA,OAAOQ,KAAKK,MAAM;IACpB;AACF"}

package/dist/cjs/restricted/getBip32PublicKey.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    Bip32PublicKeyArgsStruct: function() {
-        return Bip32PublicKeyArgsStruct;
-    },
-    getBip32PublicKeyBuilder: function() {
-        return getBip32PublicKeyBuilder;
-    },
-    getBip32PublicKeyImplementation: function() {
-        return getBip32PublicKeyImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-const _utils1 = require("../utils");
-const targetName = 'snap_getBip32PublicKey';
-const Bip32PublicKeyArgsStruct = (0, _snapsutils.bip32entropy)((0, _superstruct.object)({
-    path: _snapsutils.Bip32PathStruct,
-    curve: (0, _superstruct.enums)([
-        'ed25519',
-        'secp256k1'
-    ]),
-    compressed: (0, _superstruct.optional)((0, _superstruct.boolean)())
-}));
-/**
- * The specification builder for the `snap_getBip32PublicKey` permission.
- * `snap_getBip32PublicKey` lets the Snap retrieve public keys for a particular
- * BIP-32 node.
- *
- * @param options - The specification builder options.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `snap_getBip32PublicKey` permission.
- */ const specificationBuilder = ({ methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            _snapsutils.SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32PublicKeyImplementation(methodHooks),
-        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
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-const getBip32PublicKeyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-function getBip32PublicKeyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip32PublicKey(args) {
-        await getUnlockPromise(true);
-        (0, _utils.assertStruct)(args.params, Bip32PublicKeyArgsStruct, 'Invalid BIP-32 public key params', _rpcerrors.rpcErrors.invalidParams);
-        const { params } = args;
-        const node = await (0, _utils1.getNode)({
-            curve: params.curve,
-            path: params.path,
-            secretRecoveryPhrase: await getMnemonic()
-        });
-        if (params.compressed) {
-            return node.compressedPublicKey;
-        }
-        return node.publicKey;
-    };
-}
-
-//# sourceMappingURL=getBip32PublicKey.js.map

package/dist/cjs/restricted/getBip44Entropy.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getBip44EntropyBuilder: function() {
-        return getBip44EntropyBuilder;
-    },
-    getBip44EntropyImplementation: function() {
-        return getBip44EntropyImplementation;
-    }
-});
-const _keytree = require("@metamask/key-tree");
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const targetName = 'snap_getBip44Entropy';
-/**
- * The specification builder for the `snap_getBip44Entropy` permission.
- * `snap_getBip44Entropy_*` lets the Snap control private keys for a particular
- * BIP-32 coin type.
- *
- * @param options - The specification builder options.
- * @param options.methodHooks - The RPC method hooks needed by the method
- * implementation.
- * @returns The specification for the `snap_getBip44Entropy` permission.
- */ const specificationBuilder = ({ methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            _snapsutils.SnapCaveatType.PermittedCoinTypes
-        ],
-        methodImplementation: getBip44EntropyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.PermittedCoinTypes) {
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: `Expected a single "${_snapsutils.SnapCaveatType.PermittedCoinTypes}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-const getBip44EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-function getBip44EntropyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip44Entropy(args) {
-        await getUnlockPromise(true);
-        // `args.params` is validated by the decorator, so it's safe to assert here.
-        const params = args.params;
-        const node = await _keytree.BIP44CoinTypeNode.fromDerivationPath([
-            await getMnemonic(),
-            `bip32:44'`,
-            `bip32:${params.coinType}'`
-        ]);
-        return node.toJSON();
-    };
-}
-
-//# sourceMappingURL=getBip44Entropy.js.map

package/dist/cjs/restricted/getBip44Entropy.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getBip44Entropy.ts"],"sourcesContent":["import { BIP44CoinTypeNode } from '@metamask/key-tree';\nimport 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  GetBip44EntropyParams,\n  GetBip44EntropyResult,\n} from '@metamask/snaps-sdk';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst targetName = 'snap_getBip44Entropy';\n\nexport type GetBip44EntropyMethodHooks = {\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 GetBip44EntropySpecificationBuilderOptions = {\n  methodHooks: GetBip44EntropyMethodHooks;\n};\n\ntype GetBip44EntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip44EntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * The specification builder for the `snap_getBip44Entropy` permission.\n * `snap_getBip44Entropy_*` lets the Snap control private keys for a particular\n * BIP-32 coin type.\n *\n * @param options - The specification builder options.\n * @param options.methodHooks - The RPC method hooks needed by the method\n * implementation.\n * @returns The specification for the `snap_getBip44Entropy` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip44EntropySpecificationBuilderOptions,\n  GetBip44EntropySpecification\n> = ({ methodHooks }: GetBip44EntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedCoinTypes],\n    methodImplementation: getBip44EntropyImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (\n        caveats?.length !== 1 ||\n        caveats[0].type !== SnapCaveatType.PermittedCoinTypes\n      ) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.PermittedCoinTypes}\" caveat.`,\n        });\n      }\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetBip44EntropyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip44EntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip44Entropy`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase\n * of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @returns The method implementation which returns a `BIP44CoinTypeNode`.\n * @throws If the params are invalid.\n */\nexport function getBip44EntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip44EntropyMethodHooks) {\n  return async function getBip44Entropy(\n    args: RestrictedMethodOptions<GetBip44EntropyParams>,\n  ): Promise<GetBip44EntropyResult> {\n    await getUnlockPromise(true);\n\n    // `args.params` is validated by the decorator, so it's safe to assert here.\n    const params = args.params as GetBip44EntropyParams;\n\n    const node = await BIP44CoinTypeNode.fromDerivationPath([\n      await getMnemonic(),\n      `bip32:44'`,\n      `bip32:${params.coinType}'`,\n    ]);\n\n    return node.toJSON();\n  };\n}\n"],"names":["getBip44EntropyBuilder","getBip44EntropyImplementation","targetName","specificationBuilder","methodHooks","permissionType","PermissionType","RestrictedMethod","allowedCaveats","SnapCaveatType","PermittedCoinTypes","methodImplementation","validator","caveats","length","type","rpcErrors","invalidParams","message","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","Object","freeze","getBip44Entropy","args","params","node","BIP44CoinTypeNode","fromDerivationPath","coinType","toJSON"],"mappings":";;;;;;;;;;;IAqFaA,sBAAsB;eAAtBA;;IAkBGC,6BAA6B;eAA7BA;;;yBAvGkB;sCAOU;2BAClB;4BAKK;AAK/B,MAAMC,aAAa;AA4BnB;;;;;;;;;CASC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CL;QACAM,gBAAgB;YAACC,0BAAc,CAACC,kBAAkB;SAAC;QACnDC,sBAAsBV,8BAA8BG;QACpDQ,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKN,0BAAc,CAACC,kBAAkB,EACrD;gBACA,MAAMM,oBAAS,CAACC,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAET,0BAAc,CAACC,kBAAkB,CAAC,SAAS,CAAC;gBAC7E;YACF;QACF;QACAS,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMjB,cAA6D;IACjEkB,aAAa;IACbC,kBAAkB;AACpB;AAEO,MAAMvB,yBAAyBwB,OAAOC,MAAM,CAAC;IAClDvB;IACAC;IACAC;AACF;AAcO,SAASH,8BAA8B,EAC5CqB,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeG,gBACpBC,IAAoD;QAEpD,MAAMJ,iBAAiB;QAEvB,4EAA4E;QAC5E,MAAMK,SAASD,KAAKC,MAAM;QAE1B,MAAMC,OAAO,MAAMC,0BAAiB,CAACC,kBAAkB,CAAC;YACtD,MAAMT;YACN,CAAC,SAAS,CAAC;YACX,CAAC,MAAM,EAAEM,OAAOI,QAAQ,CAAC,CAAC,CAAC;SAC5B;QAED,OAAOH,KAAKI,MAAM;IACpB;AACF"}