@metamask/snaps-rpc-methods 5.0.0 → 7.0.0

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

@@ -1,64 +0,0 @@
-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';
-/**
- * Map a raw value from the `initialPermissions` to a caveat specification.
- * Note that this function does not do any validation, that's handled by the
- * PermissionsController when the permission is requested.
- *
- * @param value - The raw value from the `initialPermissions`.
- * @returns The caveat specification.
- */ export function permittedDerivationPathsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.PermittedDerivationPaths,
-                value
-            }
-        ]
-    };
-}
-/**
- * Validate a caveat path object. The object must consist of a `path` array and
- * a `curve` string. Paths must start with `m`, and must contain at
- * least two indices. If `ed25519` is used, this checks if all the path indices
- * are hardened.
- *
- * @param value - The value to validate.
- * @throws If the value is invalid.
- */ export function validateBIP32Path(value) {
-    assertStruct(value, Bip32EntropyStruct, 'Invalid BIP-32 entropy path definition', rpcErrors.invalidParams);
-}
-/**
- * Validate the path values associated with a caveat. This validates that the
- * value is a non-empty array with valid derivation paths and curves.
- *
- * @param caveat - The caveat to validate.
- * @throws If the value is invalid.
- */ export function validateBIP32CaveatPaths(caveat) {
-    assertStruct(caveat, type({
-        value: size(array(Bip32EntropyStruct), 1, Infinity)
-    }), 'Invalid BIP-32 entropy caveat', rpcErrors.internal);
-}
-export const 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)
-    })
-};
-
-//# sourceMappingURL=permittedDerivationPaths.js.map

package/dist/esm/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":["providerErrors","rpcErrors","SnapCaveatType","Bip32EntropyStruct","isEqual","assertStruct","array","size","type","permittedDerivationPathsCaveatMapper","value","caveats","PermittedDerivationPaths","validateBIP32Path","invalidParams","validateBIP32CaveatPaths","caveat","Infinity","internal","PermittedDerivationPathsCaveatSpecification","Object","freeze","decorator","method","args","params","path","find","caveatPath","slice","length","curve","unauthorized","message","validator"],"mappings":"AAKA,SAASA,cAAc,EAAEC,SAAS,QAAQ,uBAAuB;AAEjE,SACEC,cAAc,EACdC,kBAAkB,EAClBC,OAAO,QACF,wBAAwB;AAE/B,SAASC,YAAY,QAAQ,kBAAkB;AAC/C,SAASC,KAAK,EAAEC,IAAI,EAAEC,IAAI,QAAQ,cAAc;AAEhD;;;;;;;CAOC,GACD,OAAO,SAASC,qCACdC,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEH,MAAMN,eAAeU,wBAAwB;gBAC7CF;YACF;SACD;IACH;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASG,kBACdH,KAAc;IAEdL,aACEK,OACAP,oBACA,0CACAF,UAAUa,aAAa;AAE3B;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,yBACdC,MAA2B;IAE3BX,aACEW,QACAR,KAAK;QAAEE,OAAOH,KAAKD,MAAMH,qBAAqB,GAAGc;IAAU,IAC3D,iCACAhB,UAAUiB,QAAQ;AAEtB;AAEA,OAAO,MAAMC,8CAGT;IACF,CAACjB,eAAeU,wBAAwB,CAAC,EAAEQ,OAAOC,MAAM,CAAC;QACvDb,MAAMN,eAAeU,wBAAwB;QAC7CU,WAAW,CACTC,QACAP;YAEA,OAAO,OAAOQ;gBACZ,MAAM,EAAEC,MAAM,EAAE,GAAGD;gBACnBX,kBAAkBY;gBAElB,MAAMC,OAAOV,OAAON,KAAK,CAACiB,IAAI,CAC5B,CAACC,aACCxB,QACEqB,OAAOC,IAAI,CAACG,KAAK,CAAC,GAAGD,WAAWF,IAAI,CAACI,MAAM,GAC3CF,WAAWF,IAAI,KACZE,WAAWG,KAAK,KAAKN,OAAOM,KAAK;gBAG1C,IAAI,CAACL,MAAM;oBACT,MAAM1B,eAAegC,YAAY,CAAC;wBAChCC,SACE;oBACJ;gBACF;gBAEA,OAAO,MAAMV,OAAOC;YACtB;QACF;QACAU,WAAW,CAAClB,SAAWD,yBAAyBC;IAClD;AACF,EAAE"}

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

@@ -1,50 +0,0 @@
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType, SnapIdsStruct } from '@metamask/snaps-utils';
-import { hasProperty, assertStruct } from '@metamask/utils';
-import { type } from 'superstruct';
-/**
- * Map a raw value from the `initialPermissions` to a caveat specification.
- * Note that this function does not do any validation, that's handled by the
- * PermissionsController when the permission is requested.
- *
- * @param value - The raw value from the `initialPermissions`.
- * @returns The caveat specification.
- */ export function snapIdsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.SnapIds,
-                value
-            }
-        ]
-    };
-}
-/**
- * Validates that the caveat value exists and is a non-empty object.
- *
- * @param caveat - The caveat to validate.
- * @throws If the caveat is invalid.
- */ export function validateSnapIdsCaveat(caveat) {
-    assertStruct(caveat, type({
-        value: SnapIdsStruct
-    }), 'Expected caveat to have a value property of a non-empty object of snap IDs.', rpcErrors.invalidParams);
-}
-export const SnapIdsCaveatSpecification = {
-    [SnapCaveatType.SnapIds]: Object.freeze({
-        type: SnapCaveatType.SnapIds,
-        validator: (caveat)=>validateSnapIdsCaveat(caveat),
-        decorator: (method, caveat)=>{
-            return async (args)=>{
-                const { params, context: { origin } } = args;
-                const snapIds = caveat.value;
-                const { snapId } = params;
-                if (!hasProperty(snapIds, snapId)) {
-                    throw new Error(`${origin} does not have permission to invoke ${snapId} snap.`);
-                }
-                return await method(args);
-            };
-        }
-    })
-};
-
-//# sourceMappingURL=snapIds.js.map

package/dist/esm/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":["rpcErrors","SnapCaveatType","SnapIdsStruct","hasProperty","assertStruct","type","snapIdsCaveatMapper","value","caveats","SnapIds","validateSnapIdsCaveat","caveat","invalidParams","SnapIdsCaveatSpecification","Object","freeze","validator","decorator","method","args","params","context","origin","snapIds","snapId","Error"],"mappings":"AAOA,SAASA,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,cAAc,EAAEC,aAAa,QAAQ,wBAAwB;AAEtE,SAASC,WAAW,EAAEC,YAAY,QAAQ,kBAAkB;AAC5D,SAASC,IAAI,QAAQ,cAAc;AAInC;;;;;;;CAOC,GACD,OAAO,SAASC,oBACdC,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEH,MAAMJ,eAAeQ,OAAO;gBAC5BF;YACF;SACD;IACH;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASG,sBACdC,MAA2B;IAE3BP,aACEO,QACAN,KAAK;QACHE,OAAOL;IACT,IACA,+EACAF,UAAUY,aAAa;AAE3B;AAEA,OAAO,MAAMC,6BAGT;IACF,CAACZ,eAAeQ,OAAO,CAAC,EAAEK,OAAOC,MAAM,CAAC;QACtCV,MAAMJ,eAAeQ,OAAO;QAC5BO,WAAW,CAACL,SAAWD,sBAAsBC;QAC7CM,WAAW,CAACC,QAAQP;YAClB,OAAO,OAAOQ;gBACZ,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAwDH;gBACzD,MAAMI,UAAUZ,OAAOJ,KAAK;gBAC5B,MAAM,EAAEiB,MAAM,EAAE,GAAGJ;gBACnB,IAAI,CAACjB,YAAYoB,SAASC,SAAS;oBACjC,MAAM,IAAIC,MACR,CAAC,EAAEH,OAAO,oCAAoC,EAAEE,OAAO,MAAM,CAAC;gBAElE;gBACA,OAAO,MAAMN,OAAOC;YACtB;QACF;IACF;AACF,EAAE"}

package/dist/esm/restricted/dialog.js

@@ -1,138 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { DialogType, ComponentStruct, enumValue } from '@metamask/snaps-sdk';
-import { validateComponentLinks } from '@metamask/snaps-utils';
-import { create, enums, object, optional, size, string, StructError, type, union } from 'superstruct';
-const methodName = 'snap_dialog';
-const PlaceholderStruct = optional(size(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: PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getDialogImplementation(methodHooks),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    showDialog: true,
-    isOnPhishingList: true,
-    maybeUpdatePhishingList: true
-};
-export 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 = type({
-    type: enums([
-        DialogType.Alert,
-        DialogType.Confirmation,
-        DialogType.Prompt
-    ])
-});
-const AlertParametersStruct = object({
-    type: enumValue(DialogType.Alert),
-    content: ComponentStruct
-});
-const ConfirmationParametersStruct = object({
-    type: enumValue(DialogType.Confirmation),
-    content: ComponentStruct
-});
-const PromptParametersStruct = object({
-    type: enumValue(DialogType.Prompt),
-    content: ComponentStruct,
-    placeholder: PlaceholderStruct
-});
-const DialogParametersStruct = union([
-    AlertParametersStruct,
-    ConfirmationParametersStruct,
-    PromptParametersStruct
-]);
-const structs = {
-    [DialogType.Alert]: AlertParametersStruct,
-    [DialogType.Confirmation]: ConfirmationParametersStruct,
-    [DialogType.Prompt]: PromptParametersStruct
-};
-/**
- * Builds the method implementation for `snap_dialog`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.showDialog - A function that shows the specified dialog in the
- * MetaMask UI and returns the appropriate value for the dialog type.
- * @param hooks.isOnPhishingList - A function that checks a link against the
- * phishing list and return true if it's in, otherwise false.
- * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.
- * @returns The method implementation which return value depends on the dialog
- * type, valid return types are: string, boolean, null.
- */ export function getDialogImplementation({ showDialog, isOnPhishingList, maybeUpdatePhishingList }) {
-    return async function dialogImplementation(args) {
-        const { params, context: { origin } } = args;
-        const validatedType = getValidatedType(params);
-        const validatedParams = getValidatedParams(params, structs[validatedType]);
-        const { content } = validatedParams;
-        await maybeUpdatePhishingList();
-        validateComponentLinks(content, isOnPhishingList);
-        const placeholder = validatedParams.type === DialogType.Prompt ? validatedParams.placeholder : undefined;
-        return showDialog(origin, validatedType, content, 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 create(params, BaseParamsStruct).type;
-    } catch (error) {
-        throw rpcErrors.invalidParams({
-            message: `The "type" property must be one of: ${Object.values(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 create(params, struct);
-    } catch (error) {
-        if (error instanceof StructError) {
-            const { key, type: errorType } = error;
-            if (key === 'placeholder' && errorType === 'never') {
-                throw rpcErrors.invalidParams({
-                    message: 'Invalid params: Alerts or confirmations may not specify a "placeholder" field.'
-                });
-            }
-            throw rpcErrors.invalidParams({
-                message: `Invalid params: ${error.message}.`
-            });
-        }
-        /* istanbul ignore next */ throw rpcErrors.internal();
-    }
-}
-
-//# sourceMappingURL=dialog.js.map

package/dist/esm/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 { DialogType, ComponentStruct, enumValue } from '@metamask/snaps-sdk';\nimport type { DialogParams, EnumToUnion, Component } from '@metamask/snaps-sdk';\nimport { validateComponentLinks } from '@metamask/snaps-utils';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport 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  StructError,\n  type,\n  union,\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  content: Component,\n  placeholder?: Placeholder,\n) => Promise<null | boolean | string>;\n\ntype MaybeUpdatePhisingList = () => Promise<void>;\ntype IsOnPhishingList = (url: string) => boolean;\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 content - The dialog custom UI.\n   * @param placeholder - The placeholder for the Prompt dialog input.\n   */\n  showDialog: ShowDialog;\n\n  maybeUpdatePhishingList: MaybeUpdatePhisingList;\n\n  /**\n   * @param url - The URL to check against the phishing list.\n   */\n  isOnPhishingList: IsOnPhishingList;\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  isOnPhishingList: true,\n  maybeUpdatePhishingList: 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 AlertParametersStruct = object({\n  type: enumValue(DialogType.Alert),\n  content: ComponentStruct,\n});\n\nconst ConfirmationParametersStruct = object({\n  type: enumValue(DialogType.Confirmation),\n  content: ComponentStruct,\n});\n\nconst PromptParametersStruct = object({\n  type: enumValue(DialogType.Prompt),\n  content: ComponentStruct,\n  placeholder: PlaceholderStruct,\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.isOnPhishingList - A function that checks a link against the\n * phishing list and return true if it's in, otherwise false.\n * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.\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  isOnPhishingList,\n  maybeUpdatePhishingList,\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 { content } = validatedParams;\n\n    await maybeUpdatePhishingList();\n\n    validateComponentLinks(content, isOnPhishingList);\n\n    const placeholder =\n      validatedParams.type === DialogType.Prompt\n        ? validatedParams.placeholder\n        : undefined;\n\n    return showDialog(origin, validatedType, content, 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>,\n): DialogParameters {\n  try {\n    return create(params, struct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      const { key, type: errorType } = error;\n\n      if (key === 'placeholder' && errorType === 'never') {\n        throw rpcErrors.invalidParams({\n          message:\n            'Invalid params: Alerts or confirmations may not specify a \"placeholder\" field.',\n        });\n      }\n\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","DialogType","ComponentStruct","enumValue","validateComponentLinks","create","enums","object","optional","size","string","StructError","type","union","methodName","PlaceholderStruct","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getDialogImplementation","subjectTypes","Snap","showDialog","isOnPhishingList","maybeUpdatePhishingList","dialogBuilder","Object","freeze","BaseParamsStruct","Alert","Confirmation","Prompt","AlertParametersStruct","content","ConfirmationParametersStruct","PromptParametersStruct","placeholder","DialogParametersStruct","structs","dialogImplementation","args","params","context","origin","validatedType","getValidatedType","validatedParams","getValidatedParams","undefined","error","invalidParams","message","values","join","struct","key","errorType","internal"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AACjD,SAASC,UAAU,EAAEC,eAAe,EAAEC,SAAS,QAAQ,sBAAsB;AAE7E,SAASC,sBAAsB,QAAQ,wBAAwB;AAI/D,SACEC,MAAM,EACNC,KAAK,EACLC,MAAM,EACNC,QAAQ,EACRC,IAAI,EACJC,MAAM,EACNC,WAAW,EACXC,IAAI,EACJC,KAAK,QACA,cAAc;AAIrB,MAAMC,aAAa;AAEnB,MAAMC,oBAAoBP,SAASC,KAAKC,UAAU,GAAG;AA2CrD;;;;;;;;;;;;;CAaC,GACD,MAAMM,uBAIF,CAAC,EACHC,iBAAiB,IAAI,EACrBC,WAAW,EACuB;IAClC,OAAO;QACLC,gBAAgBrB,eAAesB,gBAAgB;QAC/CC,YAAYP;QACZG;QACAK,sBAAsBC,wBAAwBL;QAC9CM,cAAc;YAACzB,YAAY0B,IAAI;SAAC;IAClC;AACF;AAEA,MAAMP,cAAoD;IACxDQ,YAAY;IACZC,kBAAkB;IAClBC,yBAAyB;AAC3B;AAEA,OAAO,MAAMC,gBAAgBC,OAAOC,MAAM,CAAC;IACzCV,YAAYP;IACZE;IACAE;AACF,GAAY;AAEZ,gFAAgF;AAChF,iDAAiD;AACjD,MAAMc,mBAAmBpB,KAAK;IAC5BA,MAAMN,MAAM;QAACL,WAAWgC,KAAK;QAAEhC,WAAWiC,YAAY;QAAEjC,WAAWkC,MAAM;KAAC;AAC5E;AAEA,MAAMC,wBAAwB7B,OAAO;IACnCK,MAAMT,UAAUF,WAAWgC,KAAK;IAChCI,SAASnC;AACX;AAEA,MAAMoC,+BAA+B/B,OAAO;IAC1CK,MAAMT,UAAUF,WAAWiC,YAAY;IACvCG,SAASnC;AACX;AAEA,MAAMqC,yBAAyBhC,OAAO;IACpCK,MAAMT,UAAUF,WAAWkC,MAAM;IACjCE,SAASnC;IACTsC,aAAazB;AACf;AAEA,MAAM0B,yBAAyB5B,MAAM;IACnCuB;IACAE;IACAC;CACD;AAOD,MAAMG,UAAU;IACd,CAACzC,WAAWgC,KAAK,CAAC,EAAEG;IACpB,CAACnC,WAAWiC,YAAY,CAAC,EAAEI;IAC3B,CAACrC,WAAWkC,MAAM,CAAC,EAAEI;AACvB;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAAShB,wBAAwB,EACtCG,UAAU,EACVC,gBAAgB,EAChBC,uBAAuB,EACL;IAClB,OAAO,eAAee,qBACpBC,IAA+C;QAE/C,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJ,MAAMI,gBAAgBC,iBAAiBJ;QACvC,MAAMK,kBAAkBC,mBAAmBN,QAAQH,OAAO,CAACM,cAAc;QAEzE,MAAM,EAAEX,OAAO,EAAE,GAAGa;QAEpB,MAAMtB;QAENxB,uBAAuBiC,SAASV;QAEhC,MAAMa,cACJU,gBAAgBtC,IAAI,KAAKX,WAAWkC,MAAM,GACtCe,gBAAgBV,WAAW,GAC3BY;QAEN,OAAO1B,WAAWqB,QAAQC,eAAeX,SAASG;IACpD;AACF;AAEA;;;;;;CAMC,GACD,SAASS,iBAAiBJ,MAAe;IACvC,IAAI;QACF,OAAOxC,OAAOwC,QAAQb,kBAAkBpB,IAAI;IAC9C,EAAE,OAAOyC,OAAO;QACd,MAAMrD,UAAUsD,aAAa,CAAC;YAC5BC,SAAS,CAAC,oCAAoC,EAAEzB,OAAO0B,MAAM,CAC3DvD,YACAwD,IAAI,CAAC,MAAM,CAAC,CAAC;QACjB;IACF;AACF;AAEA;;;;;;;CAOC,GACD,SAASN,mBACPN,MAAe,EACfa,MAAmB;IAEnB,IAAI;QACF,OAAOrD,OAAOwC,QAAQa;IACxB,EAAE,OAAOL,OAAO;QACd,IAAIA,iBAAiB1C,aAAa;YAChC,MAAM,EAAEgD,GAAG,EAAE/C,MAAMgD,SAAS,EAAE,GAAGP;YAEjC,IAAIM,QAAQ,iBAAiBC,cAAc,SAAS;gBAClD,MAAM5D,UAAUsD,aAAa,CAAC;oBAC5BC,SACE;gBACJ;YACF;YAEA,MAAMvD,UAAUsD,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEF,MAAME,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QAEA,wBAAwB,GACxB,MAAMvD,UAAU6D,QAAQ;IAC1B;AACF"}

package/dist/esm/restricted/getBip32Entropy.js

@@ -1,67 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType } from '@metamask/snaps-utils';
-import { assert } from '@metamask/utils';
-import { getNode } from '../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: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32EntropyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
-                throw rpcErrors.invalidParams({
-                    message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getBip32EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getBip32Entropy`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.
- * @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked
- * and prompts the user to unlock their MetaMask if it is locked.
- * @returns The method implementation which returns a `JsonSLIP10Node`.
- * @throws If the params are invalid.
- */ export 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();
-    };
-}
-
-//# sourceMappingURL=getBip32Entropy.js.map

package/dist/esm/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":["PermissionType","SubjectType","rpcErrors","SnapCaveatType","assert","getNode","targetName","specificationBuilder","methodHooks","permissionType","RestrictedMethod","allowedCaveats","PermittedDerivationPaths","methodImplementation","getBip32EntropyImplementation","validator","caveats","length","type","invalidParams","message","subjectTypes","Snap","getMnemonic","getUnlockPromise","getBip32EntropyBuilder","Object","freeze","getBip32Entropy","args","params","node","curve","path","secretRecoveryPhrase","toJSON"],"mappings":"AAMA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAKjD,SAASC,cAAc,QAAQ,wBAAwB;AAEvD,SAASC,MAAM,QAAQ,kBAAkB;AAGzC,SAASC,OAAO,QAAQ,WAAW;AAEnC,MAAMC,aAAa;AA4BnB;;;;;;;;CAQC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBT,eAAeU,gBAAgB;QAC/CJ;QACAK,gBAAgB;YAACR,eAAeS,wBAAwB;SAAC;QACzDC,sBAAsBC,8BAA8BN;QACpDO,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKf,eAAeS,wBAAwB,EAC3D;gBACA,MAAMV,UAAUiB,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAEjB,eAAeS,wBAAwB,CAAC,SAAS,CAAC;gBACnF;YACF;QACF;QACAS,cAAc;YAACpB,YAAYqB,IAAI;SAAC;IAClC;AACF;AAEA,MAAMd,cAA6D;IACjEe,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,yBAAyBC,OAAOC,MAAM,CAAC;IAClDrB;IACAC;IACAC;AACF,GAAY;AAEZ;;;;;;;;;CASC,GACD,OAAO,SAASM,8BAA8B,EAC5CS,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeI,gBACpBC,IAAoD;QAEpD,MAAML,iBAAiB;QAEvB,MAAM,EAAEM,MAAM,EAAE,GAAGD;QACnBzB,OAAO0B;QAEP,MAAMC,OAAO,MAAM1B,QAAQ;YACzB2B,OAAOF,OAAOE,KAAK;YACnBC,MAAMH,OAAOG,IAAI;YACjBC,sBAAsB,MAAMX;QAC9B;QAEA,OAAOQ,KAAKI,MAAM;IACpB;AACF"}

package/dist/esm/restricted/getBip32PublicKey.js

@@ -1,79 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { bip32entropy, Bip32PathStruct, SnapCaveatType } from '@metamask/snaps-utils';
-import { assertStruct } from '@metamask/utils';
-import { boolean, enums, object, optional } from 'superstruct';
-import { getNode } from '../utils';
-const targetName = 'snap_getBip32PublicKey';
-export const Bip32PublicKeyArgsStruct = bip32entropy(object({
-    path: Bip32PathStruct,
-    curve: enums([
-        'ed25519',
-        'secp256k1'
-    ]),
-    compressed: optional(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: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32PublicKeyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
-                throw rpcErrors.invalidParams({
-                    message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getBip32PublicKeyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getBip32PublicKey`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.
- * @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked
- * and prompts the user to unlock their MetaMask if it is locked.
- * @returns The method implementation which returns a public key.
- * @throws If the params are invalid.
- */ export function getBip32PublicKeyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip32PublicKey(args) {
-        await getUnlockPromise(true);
-        assertStruct(args.params, Bip32PublicKeyArgsStruct, 'Invalid BIP-32 public key params', rpcErrors.invalidParams);
-        const { params } = args;
-        const node = await 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/esm/restricted/getBip32PublicKey.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getBip32PublicKey.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  GetBip32PublicKeyParams,\n  GetBip32PublicKeyResult,\n} from '@metamask/snaps-sdk';\nimport {\n  bip32entropy,\n  Bip32PathStruct,\n  SnapCaveatType,\n} from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { boolean, enums, object, optional } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\nimport { getNode } from '../utils';\n\nconst targetName = 'snap_getBip32PublicKey';\n\nexport type GetBip32PublicKeyMethodHooks = {\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 GetBip32PublicKeySpecificationBuilderOptions = {\n  methodHooks: GetBip32PublicKeyMethodHooks;\n};\n\ntype GetBip32PublicKeySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip32PublicKeyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\nexport const Bip32PublicKeyArgsStruct = bip32entropy(\n  object({\n    path: Bip32PathStruct,\n    curve: enums(['ed25519', 'secp256k1']),\n    compressed: optional(boolean()),\n  }),\n);\n\n/**\n * The specification builder for the `snap_getBip32PublicKey` permission.\n * `snap_getBip32PublicKey` lets the Snap retrieve public 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_getBip32PublicKey` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip32PublicKeySpecificationBuilderOptions,\n  GetBip32PublicKeySpecification\n> = ({ methodHooks }: GetBip32PublicKeySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],\n    methodImplementation: getBip32PublicKeyImplementation(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<GetBip32PublicKeyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip32PublicKeyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip32PublicKey`.\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 public key.\n * @throws If the params are invalid.\n */\nexport function getBip32PublicKeyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip32PublicKeyMethodHooks) {\n  return async function getBip32PublicKey(\n    args: RestrictedMethodOptions<GetBip32PublicKeyParams>,\n  ): Promise<GetBip32PublicKeyResult> {\n    await getUnlockPromise(true);\n\n    assertStruct(\n      args.params,\n      Bip32PublicKeyArgsStruct,\n      'Invalid BIP-32 public key params',\n      rpcErrors.invalidParams,\n    );\n\n    const { params } = args;\n    const node = await getNode({\n      curve: params.curve,\n      path: params.path,\n      secretRecoveryPhrase: await getMnemonic(),\n    });\n\n    if (params.compressed) {\n      return node.compressedPublicKey;\n    }\n\n    return node.publicKey;\n  };\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","bip32entropy","Bip32PathStruct","SnapCaveatType","assertStruct","boolean","enums","object","optional","getNode","targetName","Bip32PublicKeyArgsStruct","path","curve","compressed","specificationBuilder","methodHooks","permissionType","RestrictedMethod","allowedCaveats","PermittedDerivationPaths","methodImplementation","getBip32PublicKeyImplementation","validator","caveats","length","type","invalidParams","message","subjectTypes","Snap","getMnemonic","getUnlockPromise","getBip32PublicKeyBuilder","Object","freeze","getBip32PublicKey","args","params","node","secretRecoveryPhrase","compressedPublicKey","publicKey"],"mappings":"AAMA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAKjD,SACEC,YAAY,EACZC,eAAe,EACfC,cAAc,QACT,wBAAwB;AAE/B,SAASC,YAAY,QAAQ,kBAAkB;AAC/C,SAASC,OAAO,EAAEC,KAAK,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,cAAc;AAG/D,SAASC,OAAO,QAAQ,WAAW;AAEnC,MAAMC,aAAa;AA4BnB,OAAO,MAAMC,2BAA2BV,aACtCM,OAAO;IACLK,MAAMV;IACNW,OAAOP,MAAM;QAAC;QAAW;KAAY;IACrCQ,YAAYN,SAASH;AACvB,IACA;AAEF;;;;;;;;CAQC,GACD,MAAMU,uBAIF,CAAC,EAAEC,WAAW,EAAgD;IAChE,OAAO;QACLC,gBAAgBnB,eAAeoB,gBAAgB;QAC/CR;QACAS,gBAAgB;YAAChB,eAAeiB,wBAAwB;SAAC;QACzDC,sBAAsBC,gCAAgCN;QACtDO,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKvB,eAAeiB,wBAAwB,EAC3D;gBACA,MAAMpB,UAAU2B,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAEzB,eAAeiB,wBAAwB,CAAC,SAAS,CAAC;gBACnF;YACF;QACF;QACAS,cAAc;YAAC9B,YAAY+B,IAAI;SAAC;IAClC;AACF;AAEA,MAAMd,cAA+D;IACnEe,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,2BAA2BC,OAAOC,MAAM,CAAC;IACpDzB;IACAK;IACAC;AACF,GAAY;AAEZ;;;;;;;;;CASC,GACD,OAAO,SAASM,gCAAgC,EAC9CS,WAAW,EACXC,gBAAgB,EACa;IAC7B,OAAO,eAAeI,kBACpBC,IAAsD;QAEtD,MAAML,iBAAiB;QAEvB5B,aACEiC,KAAKC,MAAM,EACX3B,0BACA,oCACAX,UAAU2B,aAAa;QAGzB,MAAM,EAAEW,MAAM,EAAE,GAAGD;QACnB,MAAME,OAAO,MAAM9B,QAAQ;YACzBI,OAAOyB,OAAOzB,KAAK;YACnBD,MAAM0B,OAAO1B,IAAI;YACjB4B,sBAAsB,MAAMT;QAC9B;QAEA,IAAIO,OAAOxB,UAAU,EAAE;YACrB,OAAOyB,KAAKE,mBAAmB;QACjC;QAEA,OAAOF,KAAKG,SAAS;IACvB;AACF"}

package/dist/esm/restricted/getBip44Entropy.js

@@ -1,69 +0,0 @@
-import { BIP44CoinTypeNode } from '@metamask/key-tree';
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType } from '@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: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            SnapCaveatType.PermittedCoinTypes
-        ],
-        methodImplementation: getBip44EntropyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedCoinTypes) {
-                throw rpcErrors.invalidParams({
-                    message: `Expected a single "${SnapCaveatType.PermittedCoinTypes}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getBip44EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getBip44Entropy`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase
- * of the user.
- * @param hooks.getUnlockPromise - A function that resolves once the MetaMask
- * extension is unlocked and prompts the user to unlock their MetaMask if it is
- * locked.
- * @returns The method implementation which returns a `BIP44CoinTypeNode`.
- * @throws If the params are invalid.
- */ export 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 BIP44CoinTypeNode.fromDerivationPath([
-            await getMnemonic(),
-            `bip32:44'`,
-            `bip32:${params.coinType}'`
-        ]);
-        return node.toJSON();
-    };
-}
-
-//# sourceMappingURL=getBip44Entropy.js.map

package/dist/esm/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":["BIP44CoinTypeNode","PermissionType","SubjectType","rpcErrors","SnapCaveatType","targetName","specificationBuilder","methodHooks","permissionType","RestrictedMethod","allowedCaveats","PermittedCoinTypes","methodImplementation","getBip44EntropyImplementation","validator","caveats","length","type","invalidParams","message","subjectTypes","Snap","getMnemonic","getUnlockPromise","getBip44EntropyBuilder","Object","freeze","getBip44Entropy","args","params","node","fromDerivationPath","coinType","toJSON"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAOvD,SAASC,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAKjD,SAASC,cAAc,QAAQ,wBAAwB;AAKvD,MAAMC,aAAa;AA4BnB;;;;;;;;;CASC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBP,eAAeQ,gBAAgB;QAC/CJ;QACAK,gBAAgB;YAACN,eAAeO,kBAAkB;SAAC;QACnDC,sBAAsBC,8BAA8BN;QACpDO,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKb,eAAeO,kBAAkB,EACrD;gBACA,MAAMR,UAAUe,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAEf,eAAeO,kBAAkB,CAAC,SAAS,CAAC;gBAC7E;YACF;QACF;QACAS,cAAc;YAAClB,YAAYmB,IAAI;SAAC;IAClC;AACF;AAEA,MAAMd,cAA6D;IACjEe,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,yBAAyBC,OAAOC,MAAM,CAAC;IAClDrB;IACAC;IACAC;AACF,GAAY;AAEZ;;;;;;;;;;;CAWC,GACD,OAAO,SAASM,8BAA8B,EAC5CS,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeI,gBACpBC,IAAoD;QAEpD,MAAML,iBAAiB;QAEvB,4EAA4E;QAC5E,MAAMM,SAASD,KAAKC,MAAM;QAE1B,MAAMC,OAAO,MAAM9B,kBAAkB+B,kBAAkB,CAAC;YACtD,MAAMT;YACN,CAAC,SAAS,CAAC;YACX,CAAC,MAAM,EAAEO,OAAOG,QAAQ,CAAC,CAAC,CAAC;SAC5B;QAED,OAAOF,KAAKG,MAAM;IACpB;AACF"}

package/dist/esm/restricted/getEntropy.js

@@ -1,58 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SIP_6_MAGIC_VALUE } from '@metamask/snaps-utils';
-import { assertStruct } from '@metamask/utils';
-import { literal, object, optional, string } from 'superstruct';
-import { deriveEntropy } from '../utils';
-const targetName = 'snap_getEntropy';
-export const GetEntropyArgsStruct = object({
-    version: literal(1),
-    salt: optional(string())
-});
-const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats,
-        methodImplementation: getEntropyImplementation(methodHooks),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getEntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getEntropy`. The implementation
- * is based on the reference implementation of
- * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getMnemonic - The method to get the mnemonic of the user's
- * primary keyring.
- * @param hooks.getUnlockPromise - The method to get a promise that resolves
- * once the extension is unlocked.
- * @returns The method implementation.
- */ function getEntropyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getEntropy(options) {
-        const { params, context: { origin } } = options;
-        assertStruct(params, GetEntropyArgsStruct, 'Invalid "snap_getEntropy" parameters', rpcErrors.invalidParams);
-        await getUnlockPromise(true);
-        const mnemonicPhrase = await getMnemonic();
-        return deriveEntropy({
-            input: origin,
-            salt: params.salt,
-            mnemonicPhrase,
-            magic: SIP_6_MAGIC_VALUE
-        });
-    };
-}
-
-//# sourceMappingURL=getEntropy.js.map

package/dist/esm/restricted/getEntropy.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getEntropy.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 type { GetEntropyParams, GetEntropyResult } from '@metamask/snaps-sdk';\nimport { SIP_6_MAGIC_VALUE } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport type { Infer } from 'superstruct';\nimport { literal, object, optional, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\nconst targetName = 'snap_getEntropy';\n\ntype GetEntropySpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: GetEntropyHooks;\n};\n\ntype GetEntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getEntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\nexport const GetEntropyArgsStruct = object({\n  version: literal(1),\n  salt: optional(string()),\n});\n\n/**\n * @property version - The version of the `snap_getEntropy` method. This must be\n * the numeric literal `1`.\n * @property salt - A string to use as the salt when deriving the entropy. If\n * omitted, the salt will be an empty string.\n */\nexport type GetEntropyArgs = Infer<typeof GetEntropyArgsStruct>;\n\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetEntropySpecificationBuilderOptions,\n  GetEntropySpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: GetEntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats,\n    methodImplementation: getEntropyImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetEntropyHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getEntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport type GetEntropyHooks = {\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\n/**\n * Builds the method implementation for `snap_getEntropy`. The implementation\n * is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - The method to get the mnemonic of the user's\n * primary keyring.\n * @param hooks.getUnlockPromise - The method to get a promise that resolves\n * once the extension is unlocked.\n * @returns The method implementation.\n */\nfunction getEntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetEntropyHooks) {\n  return async function getEntropy(\n    options: RestrictedMethodOptions<GetEntropyParams>,\n  ): Promise<GetEntropyResult> {\n    const {\n      params,\n      context: { origin },\n    } = options;\n\n    assertStruct(\n      params,\n      GetEntropyArgsStruct,\n      'Invalid \"snap_getEntropy\" parameters',\n      rpcErrors.invalidParams,\n    );\n\n    await getUnlockPromise(true);\n    const mnemonicPhrase = await getMnemonic();\n\n    return deriveEntropy({\n      input: origin,\n      salt: params.salt,\n      mnemonicPhrase,\n      magic: SIP_6_MAGIC_VALUE,\n    });\n  };\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","SIP_6_MAGIC_VALUE","assertStruct","literal","object","optional","string","deriveEntropy","targetName","GetEntropyArgsStruct","version","salt","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","methodImplementation","getEntropyImplementation","subjectTypes","Snap","getMnemonic","getUnlockPromise","getEntropyBuilder","Object","freeze","getEntropy","options","params","context","origin","invalidParams","mnemonicPhrase","input","magic"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,iBAAiB,QAAQ,wBAAwB;AAE1D,SAASC,YAAY,QAAQ,kBAAkB;AAE/C,SAASC,OAAO,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,MAAM,QAAQ,cAAc;AAGhE,SAASC,aAAa,QAAQ,WAAW;AAEzC,MAAMC,aAAa;AAcnB,OAAO,MAAMC,uBAAuBL,OAAO;IACzCM,SAASP,QAAQ;IACjBQ,MAAMN,SAASC;AACjB,GAAG;AAUH,MAAMM,uBAIF,CAAC,EACHC,iBAAiB,IAAI,EACrBC,WAAW,EAC2B;IACtC,OAAO;QACLC,gBAAgBjB,eAAekB,gBAAgB;QAC/CR;QACAK;QACAI,sBAAsBC,yBAAyBJ;QAC/CK,cAAc;YAACpB,YAAYqB,IAAI;SAAC;IAClC;AACF;AAEA,MAAMN,cAAkD;IACtDO,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,oBAAoBC,OAAOC,MAAM,CAAC;IAC7CjB;IACAI;IACAE;AACF,GAAY;AAgBZ;;;;;;;;;;;CAWC,GACD,SAASI,yBAAyB,EAChCG,WAAW,EACXC,gBAAgB,EACA;IAChB,OAAO,eAAeI,WACpBC,OAAkD;QAElD,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJzB,aACE0B,QACAnB,sBACA,wCACAT,UAAU+B,aAAa;QAGzB,MAAMT,iBAAiB;QACvB,MAAMU,iBAAiB,MAAMX;QAE7B,OAAOd,cAAc;YACnB0B,OAAOH;YACPnB,MAAMiB,OAAOjB,IAAI;YACjBqB;YACAE,OAAOjC;QACT;IACF;AACF"}