@metamask/snaps-rpc-methods 4.1.0 → 6.0.0

package/dist/cjs/permitted/updateInterface.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "updateInterfaceHandler", {
+    enumerable: true,
+    get: function() {
+        return updateInterfaceHandler;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _snapssdk = require("@metamask/snaps-sdk");
+const _superstruct = require("superstruct");
+const hookNames = {
+    updateInterface: true
+};
+const updateInterfaceHandler = {
+    methodNames: [
+        'snap_updateInterface'
+    ],
+    implementation: getUpdateInterfaceImplementation,
+    hookNames
+};
+const UpdateInterfaceParametersStruct = (0, _superstruct.object)({
+    id: (0, _superstruct.string)(),
+    ui: _snapssdk.ComponentStruct
+});
+/**
+ * The `snap_updateInterface` method implementation.
+ *
+ * @param req - The JSON-RPC request object.
+ * @param res - The JSON-RPC response object.
+ * @param _next - The `json-rpc-engine` "next" callback. Not used by this
+ * function.
+ * @param end - The `json-rpc-engine` "end" callback.
+ * @param hooks - The RPC method hooks.
+ * @param hooks.updateInterface - The function to update the interface.
+ * @returns Nothing.
+ */ async function getUpdateInterfaceImplementation(req, res, _next, end, { updateInterface }) {
+    const { params } = req;
+    try {
+        const validatedParams = getValidatedParams(params);
+        const { id, ui } = validatedParams;
+        await updateInterface(id, ui);
+        res.result = null;
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+/**
+ * Validate the updateInterface method `params` and returns them cast to the correct
+ * type. Throws if validation fails.
+ *
+ * @param params - The unvalidated params object from the method request.
+ * @returns The validated updateInterface method parameter object.
+ */ function getValidatedParams(params) {
+    try {
+        return (0, _superstruct.create)(params, UpdateInterfaceParametersStruct);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw _rpcerrors.rpcErrors.invalidParams({
+                message: `Invalid params: ${error.message}.`
+            });
+        }
+        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
+    }
+}
+
+//# sourceMappingURL=updateInterface.js.map

package/dist/cjs/permitted/updateInterface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/updateInterface.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  Component,\n  UpdateInterfaceParams,\n  UpdateInterfaceResult,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { ComponentStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<UpdateInterfaceMethodHooks> = {\n  updateInterface: true,\n};\n\nexport type UpdateInterfaceMethodHooks = {\n  /**\n   * @param id - The interface ID.\n   * @param ui - The UI components.\n   */\n  updateInterface: (id: string, ui: Component) => Promise<void>;\n};\n\nexport const updateInterfaceHandler: PermittedHandlerExport<\n  UpdateInterfaceMethodHooks,\n  UpdateInterfaceParameters,\n  UpdateInterfaceResult\n> = {\n  methodNames: ['snap_updateInterface'],\n  implementation: getUpdateInterfaceImplementation,\n  hookNames,\n};\n\nconst UpdateInterfaceParametersStruct = object({\n  id: string(),\n  ui: ComponentStruct,\n});\n\nexport type UpdateInterfaceParameters = InferMatching<\n  typeof UpdateInterfaceParametersStruct,\n  UpdateInterfaceParams\n>;\n\n/**\n * The `snap_updateInterface` method implementation.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.updateInterface - The function to update the interface.\n * @returns Nothing.\n */\nasync function getUpdateInterfaceImplementation(\n  req: JsonRpcRequest<UpdateInterfaceParameters>,\n  res: PendingJsonRpcResponse<UpdateInterfaceResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { updateInterface }: UpdateInterfaceMethodHooks,\n): Promise<void> {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id, ui } = validatedParams;\n\n    await updateInterface(id, ui);\n    res.result = null;\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the updateInterface method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated updateInterface method parameter object.\n */\nfunction getValidatedParams(params: unknown): UpdateInterfaceParameters {\n  try {\n    return create(params, UpdateInterfaceParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["updateInterfaceHandler","hookNames","updateInterface","methodNames","implementation","getUpdateInterfaceImplementation","UpdateInterfaceParametersStruct","object","id","string","ui","ComponentStruct","req","res","_next","end","params","validatedParams","getValidatedParams","result","error","create","StructError","rpcErrors","invalidParams","message","internal"],"mappings":";;;;+BA4BaA;;;eAAAA;;;2BA1Ba;0BAOM;6BAGoB;AAIpD,MAAMC,YAA2D;IAC/DC,iBAAiB;AACnB;AAUO,MAAMF,yBAIT;IACFG,aAAa;QAAC;KAAuB;IACrCC,gBAAgBC;IAChBJ;AACF;AAEA,MAAMK,kCAAkCC,IAAAA,mBAAM,EAAC;IAC7CC,IAAIC,IAAAA,mBAAM;IACVC,IAAIC,yBAAe;AACrB;AAOA;;;;;;;;;;;CAWC,GACD,eAAeN,iCACbO,GAA8C,EAC9CC,GAAkD,EAClDC,KAAc,EACdC,GAA6B,EAC7B,EAAEb,eAAe,EAA8B;IAE/C,MAAM,EAAEc,MAAM,EAAE,GAAGJ;IAEnB,IAAI;QACF,MAAMK,kBAAkBC,mBAAmBF;QAE3C,MAAM,EAAER,EAAE,EAAEE,EAAE,EAAE,GAAGO;QAEnB,MAAMf,gBAAgBM,IAAIE;QAC1BG,IAAIM,MAAM,GAAG;IACf,EAAE,OAAOC,OAAO;QACd,OAAOL,IAAIK;IACb;IAEA,OAAOL;AACT;AAEA;;;;;;CAMC,GACD,SAASG,mBAAmBF,MAAe;IACzC,IAAI;QACF,OAAOK,IAAAA,mBAAM,EAACL,QAAQV;IACxB,EAAE,OAAOc,OAAO;QACd,IAAIA,iBAAiBE,wBAAW,EAAE;YAChC,MAAMC,oBAAS,CAACC,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEL,MAAMK,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QACA,wBAAwB,GACxB,MAAMF,oBAAS,CAACG,QAAQ;IAC1B;AACF"}

package/dist/cjs/restricted/dialog.js

@@ -20,6 +20,7 @@ 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));
@@ -49,8 +50,8 @@ const PlaceholderStruct = (0, _superstruct.optional)((0, _superstruct.size)((0,
 };
 const methodHooks = {
     showDialog: true,
-    isOnPhishingList: true,
-    maybeUpdatePhishingList: true
+    createInterface: true,
+    getInterface: true
 };
 const dialogBuilder = Object.freeze({
     targetName: methodName,
@@ -66,20 +67,45 @@ const BaseParamsStruct = (0, _superstruct.type)({
         _snapssdk.DialogType.Prompt
     ])
 });
-const AlertParametersStruct = (0, _superstruct.object)({
+const AlertParametersWithContentStruct = (0, _superstruct.object)({
     type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Alert),
     content: _snapssdk.ComponentStruct
 });
-const ConfirmationParametersStruct = (0, _superstruct.object)({
+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 PromptParametersStruct = (0, _superstruct.object)({
+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 DialogParametersStruct = (0, _superstruct.union)([
+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
@@ -89,16 +115,26 @@ const structs = {
     [_snapssdk.DialogType.Confirmation]: ConfirmationParametersStruct,
     [_snapssdk.DialogType.Prompt]: PromptParametersStruct
 };
-function getDialogImplementation({ showDialog, isOnPhishingList, maybeUpdatePhishingList }) {
+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 { content } = validatedParams;
-        await maybeUpdatePhishingList();
-        (0, _snapsutils.validateComponentLinks)(content, isOnPhishingList);
         const placeholder = validatedParams.type === _snapssdk.DialogType.Prompt ? validatedParams.placeholder : undefined;
-        return showDialog(origin, validatedType, content, placeholder);
+        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);
     };
 }
 /**
@@ -125,20 +161,11 @@ function getDialogImplementation({ showDialog, isOnPhishingList, maybeUpdatePhis
  * @returns The validated confirm method parameter object.
  */ function getValidatedParams(params, struct) {
     try {
-        return (0, _superstruct.create)(params, struct);
+        return (0, _snapsutils.createUnion)(params, struct, 'type');
     } catch (error) {
-        if (error instanceof _superstruct.StructError) {
-            const { key, type: errorType } = error;
-            if (key === 'placeholder' && errorType === 'never') {
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: 'Invalid params: Alerts or confirmations may not specify a "placeholder" field.'
-                });
-            }
-            throw _rpcerrors.rpcErrors.invalidParams({
-                message: `Invalid params: ${error.message}.`
-            });
-        }
-        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
+        throw _rpcerrors.rpcErrors.invalidParams({
+            message: `Invalid params: ${error.message}`
+        });
     }
 }
 

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

@@ -1 +1 @@
-{"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":["dialogBuilder","getDialogImplementation","methodName","PlaceholderStruct","optional","size","string","specificationBuilder","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","showDialog","isOnPhishingList","maybeUpdatePhishingList","Object","freeze","BaseParamsStruct","type","enums","DialogType","Alert","Confirmation","Prompt","AlertParametersStruct","object","enumValue","content","ComponentStruct","ConfirmationParametersStruct","PromptParametersStruct","placeholder","DialogParametersStruct","union","structs","dialogImplementation","args","params","context","origin","validatedType","getValidatedType","validatedParams","getValidatedParams","validateComponentLinks","undefined","create","error","rpcErrors","invalidParams","message","values","join","struct","StructError","key","errorType","internal"],"mappings":"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"}
+{"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/index.js

@@ -12,6 +12,9 @@ _export(exports, {
     WALLET_SNAP_PERMISSION_KEY: function() {
         return _invokeSnap.WALLET_SNAP_PERMISSION_KEY;
     },
+    getEncryptionKey: function() {
+        return _manageState.getEncryptionKey;
+    },
     restrictedMethodPermissionBuilders: function() {
         return restrictedMethodPermissionBuilders;
     }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/restricted/index.ts"],"sourcesContent":["import type { DialogMethodHooks } from './dialog';\nimport { dialogBuilder } from './dialog';\nimport type { GetBip32EntropyMethodHooks } from './getBip32Entropy';\nimport { getBip32EntropyBuilder } from './getBip32Entropy';\nimport type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';\nimport { getBip32PublicKeyBuilder } from './getBip32PublicKey';\nimport type { GetBip44EntropyMethodHooks } from './getBip44Entropy';\nimport { getBip44EntropyBuilder } from './getBip44Entropy';\nimport type { GetEntropyHooks } from './getEntropy';\nimport { getEntropyBuilder } from './getEntropy';\nimport type { GetLocaleMethodHooks } from './getLocale';\nimport { getLocaleBuilder } from './getLocale';\nimport type { InvokeSnapMethodHooks } from './invokeSnap';\nimport { invokeSnapBuilder } from './invokeSnap';\nimport type { ManageAccountsMethodHooks } from './manageAccounts';\nimport { manageAccountsBuilder } from './manageAccounts';\nimport type { ManageStateMethodHooks } from './manageState';\nimport { manageStateBuilder } from './manageState';\nimport type { NotifyMethodHooks } from './notify';\nimport { notifyBuilder } from './notify';\n\nexport { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';\n\nexport type RestrictedMethodHooks = DialogMethodHooks &\n  GetBip32EntropyMethodHooks &\n  GetBip32PublicKeyMethodHooks &\n  GetBip44EntropyMethodHooks &\n  GetEntropyHooks &\n  InvokeSnapMethodHooks &\n  ManageStateMethodHooks &\n  NotifyMethodHooks &\n  ManageAccountsMethodHooks &\n  GetLocaleMethodHooks;\n\nexport const restrictedMethodPermissionBuilders = {\n  [dialogBuilder.targetName]: dialogBuilder,\n  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,\n  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,\n  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,\n  [getEntropyBuilder.targetName]: getEntropyBuilder,\n  [invokeSnapBuilder.targetName]: invokeSnapBuilder,\n  [manageStateBuilder.targetName]: manageStateBuilder,\n  [notifyBuilder.targetName]: notifyBuilder,\n  [manageAccountsBuilder.targetName]: manageAccountsBuilder,\n  [getLocaleBuilder.targetName]: getLocaleBuilder,\n} as const;\n\nexport * from './caveats';\n"],"names":["WALLET_SNAP_PERMISSION_KEY","restrictedMethodPermissionBuilders","dialogBuilder","targetName","getBip32EntropyBuilder","getBip32PublicKeyBuilder","getBip44EntropyBuilder","getEntropyBuilder","invokeSnapBuilder","manageStateBuilder","notifyBuilder","manageAccountsBuilder","getLocaleBuilder"],"mappings":";;;;;;;;;;;IAqBSA,0BAA0B;eAA1BA,sCAA0B;;IAatBC,kCAAkC;eAAlCA;;;wBAjCiB;iCAES;mCAEE;iCAEF;4BAEL;2BAED;4BAEC;gCAEI;6BAEH;wBAEL;qBA4BhB;;;;;;;;;;;;;;AAbP,MAAMA,qCAAqC;IAChD,CAACC,qBAAa,CAACC,UAAU,CAAC,EAAED,qBAAa;IACzC,CAACE,uCAAsB,CAACD,UAAU,CAAC,EAAEC,uCAAsB;IAC3D,CAACC,2CAAwB,CAACF,UAAU,CAAC,EAAEE,2CAAwB;IAC/D,CAACC,uCAAsB,CAACH,UAAU,CAAC,EAAEG,uCAAsB;IAC3D,CAACC,6BAAiB,CAACJ,UAAU,CAAC,EAAEI,6BAAiB;IACjD,CAACC,6BAAiB,CAACL,UAAU,CAAC,EAAEK,6BAAiB;IACjD,CAACC,+BAAkB,CAACN,UAAU,CAAC,EAAEM,+BAAkB;IACnD,CAACC,qBAAa,CAACP,UAAU,CAAC,EAAEO,qBAAa;IACzC,CAACC,qCAAqB,CAACR,UAAU,CAAC,EAAEQ,qCAAqB;IACzD,CAACC,2BAAgB,CAACT,UAAU,CAAC,EAAES,2BAAgB;AACjD"}
+{"version":3,"sources":["../../../src/restricted/index.ts"],"sourcesContent":["import type { DialogMethodHooks } from './dialog';\nimport { dialogBuilder } from './dialog';\nimport type { GetBip32EntropyMethodHooks } from './getBip32Entropy';\nimport { getBip32EntropyBuilder } from './getBip32Entropy';\nimport type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';\nimport { getBip32PublicKeyBuilder } from './getBip32PublicKey';\nimport type { GetBip44EntropyMethodHooks } from './getBip44Entropy';\nimport { getBip44EntropyBuilder } from './getBip44Entropy';\nimport type { GetEntropyHooks } from './getEntropy';\nimport { getEntropyBuilder } from './getEntropy';\nimport type { GetLocaleMethodHooks } from './getLocale';\nimport { getLocaleBuilder } from './getLocale';\nimport type { InvokeSnapMethodHooks } from './invokeSnap';\nimport { invokeSnapBuilder } from './invokeSnap';\nimport type { ManageAccountsMethodHooks } from './manageAccounts';\nimport { manageAccountsBuilder } from './manageAccounts';\nimport type { ManageStateMethodHooks } from './manageState';\nimport { manageStateBuilder } from './manageState';\nimport type { NotifyMethodHooks } from './notify';\nimport { notifyBuilder } from './notify';\n\nexport { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';\nexport { getEncryptionKey } from './manageState';\n\nexport type RestrictedMethodHooks = DialogMethodHooks &\n  GetBip32EntropyMethodHooks &\n  GetBip32PublicKeyMethodHooks &\n  GetBip44EntropyMethodHooks &\n  GetEntropyHooks &\n  InvokeSnapMethodHooks &\n  ManageStateMethodHooks &\n  NotifyMethodHooks &\n  ManageAccountsMethodHooks &\n  GetLocaleMethodHooks;\n\nexport const restrictedMethodPermissionBuilders = {\n  [dialogBuilder.targetName]: dialogBuilder,\n  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,\n  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,\n  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,\n  [getEntropyBuilder.targetName]: getEntropyBuilder,\n  [invokeSnapBuilder.targetName]: invokeSnapBuilder,\n  [manageStateBuilder.targetName]: manageStateBuilder,\n  [notifyBuilder.targetName]: notifyBuilder,\n  [manageAccountsBuilder.targetName]: manageAccountsBuilder,\n  [getLocaleBuilder.targetName]: getLocaleBuilder,\n} as const;\n\nexport * from './caveats';\n"],"names":["WALLET_SNAP_PERMISSION_KEY","getEncryptionKey","restrictedMethodPermissionBuilders","dialogBuilder","targetName","getBip32EntropyBuilder","getBip32PublicKeyBuilder","getBip44EntropyBuilder","getEntropyBuilder","invokeSnapBuilder","manageStateBuilder","notifyBuilder","manageAccountsBuilder","getLocaleBuilder"],"mappings":";;;;;;;;;;;IAqBSA,0BAA0B;eAA1BA,sCAA0B;;IAC1BC,gBAAgB;eAAhBA,6BAAgB;;IAaZC,kCAAkC;eAAlCA;;;wBAlCiB;iCAES;mCAEE;iCAEF;4BAEL;2BAED;4BAEC;gCAEI;6BAEH;wBAEL;qBA6BhB;;;;;;;;;;;;;;AAbP,MAAMA,qCAAqC;IAChD,CAACC,qBAAa,CAACC,UAAU,CAAC,EAAED,qBAAa;IACzC,CAACE,uCAAsB,CAACD,UAAU,CAAC,EAAEC,uCAAsB;IAC3D,CAACC,2CAAwB,CAACF,UAAU,CAAC,EAAEE,2CAAwB;IAC/D,CAACC,uCAAsB,CAACH,UAAU,CAAC,EAAEG,uCAAsB;IAC3D,CAACC,6BAAiB,CAACJ,UAAU,CAAC,EAAEI,6BAAiB;IACjD,CAACC,6BAAiB,CAACL,UAAU,CAAC,EAAEK,6BAAiB;IACjD,CAACC,+BAAkB,CAACN,UAAU,CAAC,EAAEM,+BAAkB;IACnD,CAACC,qBAAa,CAACP,UAAU,CAAC,EAAEO,qBAAa;IACzC,CAACC,qCAAqB,CAACR,UAAU,CAAC,EAAEQ,qCAAqB;IACzD,CAACC,2BAAgB,CAACT,UAAU,CAAC,EAAES,2BAAgB;AACjD"}

package/dist/cjs/restricted/manageState.js

@@ -21,6 +21,9 @@ _export(exports, {
     STORAGE_SIZE_LIMIT: function() {
         return STORAGE_SIZE_LIMIT;
     },
+    getEncryptionKey: function() {
+        return getEncryptionKey;
+    },
     getManageStateImplementation: function() {
         return getManageStateImplementation;
     },
@@ -62,19 +65,7 @@ const manageStateBuilder = Object.freeze({
     methodHooks
 });
 const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)
-/**
- * Get a deterministic encryption key to use for encrypting and decrypting the
- * state.
- *
- * This key should only be used for state encryption using `snap_manageState`.
- * To get other encryption keys, a different salt can be used.
- *
- * @param args - The encryption key args.
- * @param args.snapId - The ID of the snap to get the encryption key for.
- * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key
- * from.
- * @returns The state encryption key.
- */ async function getEncryptionKey({ mnemonicPhrase, snapId }) {
+async function getEncryptionKey({ mnemonicPhrase, snapId }) {
     return await (0, _utils1.deriveEntropy)({
         mnemonicPhrase,
         input: snapId,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/restricted/manageState.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 { ManageStateParams, ManageStateResult } from '@metamask/snaps-sdk';\nimport { ManageStateOperation } from '@metamask/snaps-sdk';\nimport { STATE_ENCRYPTION_MAGIC_VALUE, parseJson } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray, Hex } from '@metamask/utils';\nimport { isObject, getJsonSize, assert, isValidJson } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\n// The salt used for SIP-6-based entropy derivation.\nexport const STATE_ENCRYPTION_SALT = 'snap_manageState encryption';\n\nconst methodName = 'snap_manageState';\n\nexport type ManageStateMethodHooks = {\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   * A function that clears the state of the requesting Snap.\n   */\n  clearSnapState: (snapId: string, encrypted: boolean) => void;\n\n  /**\n   * A function that gets the encrypted state of the requesting Snap.\n   *\n   * @returns The current state of the Snap.\n   */\n  getSnapState: (snapId: string, encrypted: boolean) => string;\n\n  /**\n   * A function that updates the state of the requesting Snap.\n   *\n   * @param newState - The new state of the Snap.\n   */\n  updateSnapState: (\n    snapId: string,\n    newState: string,\n    encrypted: boolean,\n  ) => void;\n\n  /**\n   * Encrypts data with a key. This is assumed to perform symmetric encryption.\n   *\n   * @param key - The key to use for encryption, in hexadecimal format.\n   * @param data - The JSON data to encrypt.\n   * @returns The ciphertext as a string. The format for this string is\n   * dependent on the implementation, but MUST be a string.\n   */\n  encrypt: (key: string, data: Json) => Promise<string>;\n\n  /**\n   * Decrypts data with a key. This is assumed to perform symmetric decryption.\n   *\n   * @param key - The key to use for decryption, in hexadecimal format.\n   * @param cipherText - The ciphertext to decrypt. The format for this string\n   * is dependent on the implementation, but MUST be a string.\n   * @returns The decrypted data as a JSON object.\n   */\n  decrypt: (key: Hex, cipherText: string) => Promise<unknown>;\n};\n\ntype ManageStateSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageStateMethodHooks;\n};\n\ntype ManageStateSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getManageStateImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageState` permission.\n * `snap_manageState` lets the Snap store and manage some of its state on\n * your device.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_manageState` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageStateSpecificationBuilderOptions,\n  ManageStateSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageStateSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getManageStateImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<ManageStateMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n  clearSnapState: true,\n  getSnapState: true,\n  updateSnapState: true,\n  encrypt: true,\n  decrypt: true,\n};\n\nexport const manageStateBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)\n\ntype GetEncryptionKeyArgs = {\n  snapId: string;\n  mnemonicPhrase: Uint8Array;\n};\n\n/**\n * Get a deterministic encryption key to use for encrypting and decrypting the\n * state.\n *\n * This key should only be used for state encryption using `snap_manageState`.\n * To get other encryption keys, a different salt can be used.\n *\n * @param args - The encryption key args.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The state encryption key.\n */\nasync function getEncryptionKey({\n  mnemonicPhrase,\n  snapId,\n}: GetEncryptionKeyArgs) {\n  return await deriveEntropy({\n    mnemonicPhrase,\n    input: snapId,\n    salt: STATE_ENCRYPTION_SALT,\n    magic: STATE_ENCRYPTION_MAGIC_VALUE,\n  });\n}\n\ntype EncryptStateArgs = GetEncryptionKeyArgs & {\n  state: Json;\n  encryptFunction: ManageStateMethodHooks['encrypt'];\n};\n\n/**\n * Encrypt the state using a deterministic encryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to encrypt.\n * @param args.encryptFunction - The function to use for encrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function encryptState({\n  state,\n  encryptFunction,\n  ...keyArgs\n}: EncryptStateArgs) {\n  const encryptionKey = await getEncryptionKey(keyArgs);\n  return await encryptFunction(encryptionKey, state);\n}\n\ntype DecryptStateArgs = GetEncryptionKeyArgs & {\n  state: string;\n  decryptFunction: ManageStateMethodHooks['decrypt'];\n};\n\n/**\n * Decrypt the state using a deterministic decryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to decrypt.\n * @param args.decryptFunction - The function to use for decrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function decryptState({\n  state,\n  decryptFunction,\n  ...keyArgs\n}: DecryptStateArgs) {\n  try {\n    const encryptionKey = await getEncryptionKey(keyArgs);\n    const decryptedState = await decryptFunction(encryptionKey, state);\n\n    assert(isValidJson(decryptedState));\n\n    return decryptedState as Record<string, Json>;\n  } catch {\n    throw rpcErrors.internal({\n      message: 'Failed to decrypt snap state, the state must be corrupted.',\n    });\n  }\n}\n\n/**\n * Builds the method implementation for `snap_manageState`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.clearSnapState - A function that clears the state stored for a\n * snap.\n * @param hooks.getSnapState - A function that fetches the persisted decrypted\n * state for a snap.\n * @param hooks.updateSnapState - A function that updates the state stored for a\n * snap.\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 * @param hooks.encrypt - A function that encrypts the given state.\n * @param hooks.decrypt - A function that decrypts the given state.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function getManageStateImplementation({\n  getMnemonic,\n  getUnlockPromise,\n  clearSnapState,\n  getSnapState,\n  updateSnapState,\n  encrypt,\n  decrypt,\n}: ManageStateMethodHooks) {\n  return async function manageState(\n    options: RestrictedMethodOptions<ManageStateParams>,\n  ): Promise<ManageStateResult> {\n    const {\n      params = {},\n      method,\n      context: { origin },\n    } = options;\n    const validatedParams = getValidatedParams(params, method);\n\n    // If the encrypted param is undefined or null we default to true.\n    const shouldEncrypt = validatedParams.encrypted ?? true;\n\n    // We only need to prompt the user when the mnemonic is needed\n    // which it isn't for the clear operation or unencrypted storage.\n    if (\n      shouldEncrypt &&\n      validatedParams.operation !== ManageStateOperation.ClearState\n    ) {\n      await getUnlockPromise(true);\n    }\n\n    switch (validatedParams.operation) {\n      case ManageStateOperation.ClearState:\n        clearSnapState(origin, shouldEncrypt);\n        return null;\n\n      case ManageStateOperation.GetState: {\n        const state = getSnapState(origin, shouldEncrypt);\n        if (state === null) {\n          return state;\n        }\n        return shouldEncrypt\n          ? await decryptState({\n              state,\n              decryptFunction: decrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : parseJson<Record<string, Json>>(state);\n      }\n\n      case ManageStateOperation.UpdateState: {\n        const finalizedState = shouldEncrypt\n          ? await encryptState({\n              state: validatedParams.newState,\n              encryptFunction: encrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : JSON.stringify(validatedParams.newState);\n\n        updateSnapState(origin, finalizedState, shouldEncrypt);\n        return null;\n      }\n\n      default:\n        throw rpcErrors.invalidParams(\n          `Invalid ${method} operation: \"${\n            validatedParams.operation as string\n          }\"`,\n        );\n    }\n  };\n}\n\n/**\n * Validates the manageState 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 method - RPC method name used for debugging errors.\n * @param storageSizeLimit - Maximum allowed size (in bytes) of a new state object.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(\n  params: unknown,\n  method: string,\n  storageSizeLimit = STORAGE_SIZE_LIMIT,\n): ManageStateParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { operation, newState, encrypted } = params;\n\n  if (\n    !operation ||\n    typeof operation !== 'string' ||\n    !Object.values(ManageStateOperation).includes(\n      operation as ManageStateOperation,\n    )\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid manage state \"operation\".',\n    });\n  }\n\n  if (encrypted !== undefined && typeof encrypted !== 'boolean') {\n    throw rpcErrors.invalidParams({\n      message: '\"encrypted\" parameter must be a boolean if specified.',\n    });\n  }\n\n  if (operation === ManageStateOperation.UpdateState) {\n    if (!isObject(newState)) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be a plain object.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    let size;\n    try {\n      // `getJsonSize` will throw if the state is not JSON serializable.\n      size = getJsonSize(newState);\n    } catch {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be JSON serializable.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    if (size > storageSizeLimit) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n  }\n\n  return params as ManageStateParams;\n}\n"],"names":["STATE_ENCRYPTION_SALT","specificationBuilder","manageStateBuilder","STORAGE_SIZE_LIMIT","getManageStateImplementation","getValidatedParams","methodName","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","clearSnapState","getSnapState","updateSnapState","encrypt","decrypt","Object","freeze","getEncryptionKey","mnemonicPhrase","snapId","deriveEntropy","input","salt","magic","STATE_ENCRYPTION_MAGIC_VALUE","encryptState","state","encryptFunction","keyArgs","encryptionKey","decryptState","decryptFunction","decryptedState","assert","isValidJson","rpcErrors","internal","message","manageState","options","params","method","context","origin","validatedParams","shouldEncrypt","encrypted","operation","ManageStateOperation","ClearState","GetState","parseJson","UpdateState","finalizedState","newState","JSON","stringify","invalidParams","storageSizeLimit","isObject","values","includes","undefined","data","receivedNewState","size","getJsonSize"],"mappings":"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"}
+{"version":3,"sources":["../../../src/restricted/manageState.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 { ManageStateParams, ManageStateResult } from '@metamask/snaps-sdk';\nimport { ManageStateOperation } from '@metamask/snaps-sdk';\nimport { STATE_ENCRYPTION_MAGIC_VALUE, parseJson } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray, Hex } from '@metamask/utils';\nimport { isObject, getJsonSize, assert, isValidJson } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\n// The salt used for SIP-6-based entropy derivation.\nexport const STATE_ENCRYPTION_SALT = 'snap_manageState encryption';\n\nconst methodName = 'snap_manageState';\n\nexport type ManageStateMethodHooks = {\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   * A function that clears the state of the requesting Snap.\n   */\n  clearSnapState: (snapId: string, encrypted: boolean) => void;\n\n  /**\n   * A function that gets the encrypted state of the requesting Snap.\n   *\n   * @returns The current state of the Snap.\n   */\n  getSnapState: (snapId: string, encrypted: boolean) => string;\n\n  /**\n   * A function that updates the state of the requesting Snap.\n   *\n   * @param newState - The new state of the Snap.\n   */\n  updateSnapState: (\n    snapId: string,\n    newState: string,\n    encrypted: boolean,\n  ) => void;\n\n  /**\n   * Encrypts data with a key. This is assumed to perform symmetric encryption.\n   *\n   * @param key - The key to use for encryption, in hexadecimal format.\n   * @param data - The JSON data to encrypt.\n   * @returns The ciphertext as a string. The format for this string is\n   * dependent on the implementation, but MUST be a string.\n   */\n  encrypt: (key: string, data: Json) => Promise<string>;\n\n  /**\n   * Decrypts data with a key. This is assumed to perform symmetric decryption.\n   *\n   * @param key - The key to use for decryption, in hexadecimal format.\n   * @param cipherText - The ciphertext to decrypt. The format for this string\n   * is dependent on the implementation, but MUST be a string.\n   * @returns The decrypted data as a JSON object.\n   */\n  decrypt: (key: Hex, cipherText: string) => Promise<unknown>;\n};\n\ntype ManageStateSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageStateMethodHooks;\n};\n\ntype ManageStateSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getManageStateImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageState` permission.\n * `snap_manageState` lets the Snap store and manage some of its state on\n * your device.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_manageState` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageStateSpecificationBuilderOptions,\n  ManageStateSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageStateSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getManageStateImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<ManageStateMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n  clearSnapState: true,\n  getSnapState: true,\n  updateSnapState: true,\n  encrypt: true,\n  decrypt: true,\n};\n\nexport const manageStateBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)\n\ntype GetEncryptionKeyArgs = {\n  snapId: string;\n  mnemonicPhrase: Uint8Array;\n};\n\n/**\n * Get a deterministic encryption key to use for encrypting and decrypting the\n * state.\n *\n * This key should only be used for state encryption using `snap_manageState`.\n * To get other encryption keys, a different salt can be used.\n *\n * @param args - The encryption key args.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The state encryption key.\n */\nexport async function getEncryptionKey({\n  mnemonicPhrase,\n  snapId,\n}: GetEncryptionKeyArgs) {\n  return await deriveEntropy({\n    mnemonicPhrase,\n    input: snapId,\n    salt: STATE_ENCRYPTION_SALT,\n    magic: STATE_ENCRYPTION_MAGIC_VALUE,\n  });\n}\n\ntype EncryptStateArgs = GetEncryptionKeyArgs & {\n  state: Json;\n  encryptFunction: ManageStateMethodHooks['encrypt'];\n};\n\n/**\n * Encrypt the state using a deterministic encryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to encrypt.\n * @param args.encryptFunction - The function to use for encrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function encryptState({\n  state,\n  encryptFunction,\n  ...keyArgs\n}: EncryptStateArgs) {\n  const encryptionKey = await getEncryptionKey(keyArgs);\n  return await encryptFunction(encryptionKey, state);\n}\n\ntype DecryptStateArgs = GetEncryptionKeyArgs & {\n  state: string;\n  decryptFunction: ManageStateMethodHooks['decrypt'];\n};\n\n/**\n * Decrypt the state using a deterministic decryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to decrypt.\n * @param args.decryptFunction - The function to use for decrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function decryptState({\n  state,\n  decryptFunction,\n  ...keyArgs\n}: DecryptStateArgs) {\n  try {\n    const encryptionKey = await getEncryptionKey(keyArgs);\n    const decryptedState = await decryptFunction(encryptionKey, state);\n\n    assert(isValidJson(decryptedState));\n\n    return decryptedState as Record<string, Json>;\n  } catch {\n    throw rpcErrors.internal({\n      message: 'Failed to decrypt snap state, the state must be corrupted.',\n    });\n  }\n}\n\n/**\n * Builds the method implementation for `snap_manageState`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.clearSnapState - A function that clears the state stored for a\n * snap.\n * @param hooks.getSnapState - A function that fetches the persisted decrypted\n * state for a snap.\n * @param hooks.updateSnapState - A function that updates the state stored for a\n * snap.\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 * @param hooks.encrypt - A function that encrypts the given state.\n * @param hooks.decrypt - A function that decrypts the given state.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function getManageStateImplementation({\n  getMnemonic,\n  getUnlockPromise,\n  clearSnapState,\n  getSnapState,\n  updateSnapState,\n  encrypt,\n  decrypt,\n}: ManageStateMethodHooks) {\n  return async function manageState(\n    options: RestrictedMethodOptions<ManageStateParams>,\n  ): Promise<ManageStateResult> {\n    const {\n      params = {},\n      method,\n      context: { origin },\n    } = options;\n    const validatedParams = getValidatedParams(params, method);\n\n    // If the encrypted param is undefined or null we default to true.\n    const shouldEncrypt = validatedParams.encrypted ?? true;\n\n    // We only need to prompt the user when the mnemonic is needed\n    // which it isn't for the clear operation or unencrypted storage.\n    if (\n      shouldEncrypt &&\n      validatedParams.operation !== ManageStateOperation.ClearState\n    ) {\n      await getUnlockPromise(true);\n    }\n\n    switch (validatedParams.operation) {\n      case ManageStateOperation.ClearState:\n        clearSnapState(origin, shouldEncrypt);\n        return null;\n\n      case ManageStateOperation.GetState: {\n        const state = getSnapState(origin, shouldEncrypt);\n        if (state === null) {\n          return state;\n        }\n        return shouldEncrypt\n          ? await decryptState({\n              state,\n              decryptFunction: decrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : parseJson<Record<string, Json>>(state);\n      }\n\n      case ManageStateOperation.UpdateState: {\n        const finalizedState = shouldEncrypt\n          ? await encryptState({\n              state: validatedParams.newState,\n              encryptFunction: encrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : JSON.stringify(validatedParams.newState);\n\n        updateSnapState(origin, finalizedState, shouldEncrypt);\n        return null;\n      }\n\n      default:\n        throw rpcErrors.invalidParams(\n          `Invalid ${method} operation: \"${\n            validatedParams.operation as string\n          }\"`,\n        );\n    }\n  };\n}\n\n/**\n * Validates the manageState 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 method - RPC method name used for debugging errors.\n * @param storageSizeLimit - Maximum allowed size (in bytes) of a new state object.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(\n  params: unknown,\n  method: string,\n  storageSizeLimit = STORAGE_SIZE_LIMIT,\n): ManageStateParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { operation, newState, encrypted } = params;\n\n  if (\n    !operation ||\n    typeof operation !== 'string' ||\n    !Object.values(ManageStateOperation).includes(\n      operation as ManageStateOperation,\n    )\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid manage state \"operation\".',\n    });\n  }\n\n  if (encrypted !== undefined && typeof encrypted !== 'boolean') {\n    throw rpcErrors.invalidParams({\n      message: '\"encrypted\" parameter must be a boolean if specified.',\n    });\n  }\n\n  if (operation === ManageStateOperation.UpdateState) {\n    if (!isObject(newState)) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be a plain object.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    let size;\n    try {\n      // `getJsonSize` will throw if the state is not JSON serializable.\n      size = getJsonSize(newState);\n    } catch {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be JSON serializable.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    if (size > storageSizeLimit) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n  }\n\n  return params as ManageStateParams;\n}\n"],"names":["STATE_ENCRYPTION_SALT","specificationBuilder","manageStateBuilder","STORAGE_SIZE_LIMIT","getEncryptionKey","getManageStateImplementation","getValidatedParams","methodName","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","clearSnapState","getSnapState","updateSnapState","encrypt","decrypt","Object","freeze","mnemonicPhrase","snapId","deriveEntropy","input","salt","magic","STATE_ENCRYPTION_MAGIC_VALUE","encryptState","state","encryptFunction","keyArgs","encryptionKey","decryptState","decryptFunction","decryptedState","assert","isValidJson","rpcErrors","internal","message","manageState","options","params","method","context","origin","validatedParams","shouldEncrypt","encrypted","operation","ManageStateOperation","ClearState","GetState","parseJson","UpdateState","finalizedState","newState","JSON","stringify","invalidParams","storageSizeLimit","isObject","values","includes","undefined","data","receivedNewState","size","getJsonSize"],"mappings":"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"}

package/dist/esm/endowments/caveats/generic.js

@@ -0,0 +1,40 @@
+import { rpcErrors } from '@metamask/rpc-errors';
+/**
+ * Create a generic permission validator that validates the presence of certain caveats.
+ *
+ * This validator only validates the types of the caveats, not the values.
+ *
+ * @param caveatsToValidate - A list of objects that represent caveats.
+ * @param caveatsToValidate.type - The string defining the caveat type.
+ * @param caveatsToValidate.optional - An optional boolean flag that defines
+ * whether the caveat is optional or not.
+ * @returns A function that validates a permission.
+ */ export function createGenericPermissionValidator(caveatsToValidate) {
+    const validCaveatTypes = new Set(caveatsToValidate.map((caveat)=>caveat.type));
+    const requiredCaveats = caveatsToValidate.filter((caveat)=>!caveat.optional);
+    return function({ caveats }) {
+        const actualCaveats = caveats ?? [];
+        const passedCaveatTypes = actualCaveats.map((caveat)=>caveat.type);
+        const passedCaveatsSet = new Set(passedCaveatTypes);
+        // Disallow duplicates
+        if (passedCaveatsSet.size !== passedCaveatTypes.length) {
+            throw rpcErrors.invalidParams({
+                message: 'Duplicate caveats are not allowed.'
+            });
+        }
+        // Disallow caveats that don't match expected types
+        if (!actualCaveats.every((caveat)=>validCaveatTypes.has(caveat.type))) {
+            throw rpcErrors.invalidParams({
+                message: `Expected the following caveats: ${caveatsToValidate.map((caveat)=>`"${caveat.type}"`).join(', ')}, received ${actualCaveats.map((caveat)=>`"${caveat.type}"`).join(', ')}.`
+            });
+        }
+        // Fail if not all required caveats are specified
+        if (!requiredCaveats.every((caveat)=>passedCaveatsSet.has(caveat.type))) {
+            throw rpcErrors.invalidParams({
+                message: `Expected the following caveats: ${requiredCaveats.map((caveat)=>`"${caveat.type}"`).join(', ')}.`
+            });
+        }
+    };
+}
+
+//# sourceMappingURL=generic.js.map

package/dist/esm/endowments/caveats/generic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/endowments/caveats/generic.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionValidatorConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { Json } from '@metamask/utils';\n\nexport type CaveatMapperReturnValue = Pick<PermissionConstraint, 'caveats'>;\n\nexport type CaveatMapperFunction = (value: Json) => CaveatMapperReturnValue;\n\n/**\n * Create a generic permission validator that validates the presence of certain caveats.\n *\n * This validator only validates the types of the caveats, not the values.\n *\n * @param caveatsToValidate - A list of objects that represent caveats.\n * @param caveatsToValidate.type - The string defining the caveat type.\n * @param caveatsToValidate.optional - An optional boolean flag that defines\n * whether the caveat is optional or not.\n * @returns A function that validates a permission.\n */\nexport function createGenericPermissionValidator(\n  caveatsToValidate: {\n    type: string;\n    optional?: boolean;\n  }[],\n): PermissionValidatorConstraint {\n  const validCaveatTypes = new Set(\n    caveatsToValidate.map((caveat) => caveat.type),\n  );\n  const requiredCaveats = caveatsToValidate.filter(\n    (caveat) => !caveat.optional,\n  );\n\n  return function ({ caveats }) {\n    const actualCaveats = caveats ?? [];\n    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);\n    const passedCaveatsSet = new Set(passedCaveatTypes);\n\n    // Disallow duplicates\n    if (passedCaveatsSet.size !== passedCaveatTypes.length) {\n      throw rpcErrors.invalidParams({\n        message: 'Duplicate caveats are not allowed.',\n      });\n    }\n\n    // Disallow caveats that don't match expected types\n    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${caveatsToValidate\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}, received ${actualCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n\n    // Fail if not all required caveats are specified\n    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${requiredCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n  };\n}\n"],"names":["rpcErrors","createGenericPermissionValidator","caveatsToValidate","validCaveatTypes","Set","map","caveat","type","requiredCaveats","filter","optional","caveats","actualCaveats","passedCaveatTypes","passedCaveatsSet","size","length","invalidParams","message","every","has","join"],"mappings":"AAIA,SAASA,SAAS,QAAQ,uBAAuB;AAOjD;;;;;;;;;;CAUC,GACD,OAAO,SAASC,iCACdC,iBAGG;IAEH,MAAMC,mBAAmB,IAAIC,IAC3BF,kBAAkBG,GAAG,CAAC,CAACC,SAAWA,OAAOC,IAAI;IAE/C,MAAMC,kBAAkBN,kBAAkBO,MAAM,CAC9C,CAACH,SAAW,CAACA,OAAOI,QAAQ;IAG9B,OAAO,SAAU,EAAEC,OAAO,EAAE;QAC1B,MAAMC,gBAAgBD,WAAW,EAAE;QACnC,MAAME,oBAAoBD,cAAcP,GAAG,CAAC,CAACC,SAAWA,OAAOC,IAAI;QACnE,MAAMO,mBAAmB,IAAIV,IAAIS;QAEjC,sBAAsB;QACtB,IAAIC,iBAAiBC,IAAI,KAAKF,kBAAkBG,MAAM,EAAE;YACtD,MAAMhB,UAAUiB,aAAa,CAAC;gBAC5BC,SAAS;YACX;QACF;QAEA,mDAAmD;QACnD,IAAI,CAACN,cAAcO,KAAK,CAAC,CAACb,SAAWH,iBAAiBiB,GAAG,CAACd,OAAOC,IAAI,IAAI;YACvE,MAAMP,UAAUiB,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gCAAgC,EAAEhB,kBACzCG,GAAG,CAAC,CAACC,SAAW,CAAC,CAAC,EAAEA,OAAOC,IAAI,CAAC,CAAC,CAAC,EAClCc,IAAI,CAAC,MAAM,WAAW,EAAET,cACxBP,GAAG,CAAC,CAACC,SAAW,CAAC,CAAC,EAAEA,OAAOC,IAAI,CAAC,CAAC,CAAC,EAClCc,IAAI,CAAC,MAAM,CAAC,CAAC;YAClB;QACF;QAEA,iDAAiD;QACjD,IAAI,CAACb,gBAAgBW,KAAK,CAAC,CAACb,SAAWQ,iBAAiBM,GAAG,CAACd,OAAOC,IAAI,IAAI;YACzE,MAAMP,UAAUiB,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gCAAgC,EAAEV,gBACzCH,GAAG,CAAC,CAACC,SAAW,CAAC,CAAC,EAAEA,OAAOC,IAAI,CAAC,CAAC,CAAC,EAClCc,IAAI,CAAC,MAAM,CAAC,CAAC;YAClB;QACF;IACF;AACF"}

package/dist/esm/endowments/caveats/index.js

@@ -0,0 +1,4 @@
+export * from './generic';
+export * from './requestTime';
+
+//# sourceMappingURL=index.js.map

package/dist/esm/endowments/caveats/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/endowments/caveats/index.ts"],"sourcesContent":["export * from './generic';\nexport * from './requestTime';\n"],"names":[],"mappings":"AAAA,cAAc,YAAY;AAC1B,cAAc,gBAAgB"}

package/dist/esm/endowments/caveats/requestTime.js

@@ -0,0 +1,93 @@
+import { rpcErrors } from '@metamask/rpc-errors';
+import { MaxRequestTimeStruct, SnapCaveatType } from '@metamask/snaps-utils';
+import { assertStruct, hasProperty, isObject } from '@metamask/utils';
+/**
+ * Asserts that the given value is a valid `maxRequestTime` value.
+ *
+ * @param value - The value to assert.
+ * @param ErrorWrapper - An optional error wrapper to use. Defaults to
+ * {@link AssertionError}.
+ * @throws If the value is not a valid `maxRequestTime` value.
+ */ function assertIsMaxRequestTime(value, ErrorWrapper) {
+    assertStruct(value, MaxRequestTimeStruct, 'Invalid maxRequestTime', ErrorWrapper);
+}
+/**
+ * Validate the value of a caveat. This does not validate the type of the
+ * caveat itself, only the value of the caveat.
+ *
+ * @param caveat - The caveat to validate.
+ * @throws If the caveat value is invalid.
+ */ function validateMaxRequestTimeCaveat(caveat) {
+    if (!hasProperty(caveat, 'value')) {
+        throw rpcErrors.invalidParams({
+            message: 'Invalid maxRequestTime caveat.'
+        });
+    }
+    const { value } = caveat;
+    assertIsMaxRequestTime(value, rpcErrors.invalidParams);
+}
+/**
+ * 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 getMaxRequestTimeCaveatMapper(value) {
+    if (!value || !isObject(value) || isObject(value) && !hasProperty(value, 'maxRequestTime')) {
+        return {
+            caveats: null
+        };
+    }
+    return {
+        caveats: [
+            {
+                type: SnapCaveatType.MaxRequestTime,
+                value: value.maxRequestTime
+            }
+        ]
+    };
+}
+/**
+ * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat
+ * and merges it with any other caveats created by the mapper function.
+ *
+ * @param mapper - Another caveat mapper function.
+ * @returns The caveat specification.
+ */ export function createMaxRequestTimeMapper(mapper) {
+    return function(value) {
+        // We assume this to be used only with caveats of this type
+        const { maxRequestTime, ...rest } = value;
+        const mapperResult = mapper(rest);
+        if (!maxRequestTime) {
+            return mapperResult;
+        }
+        return {
+            ...mapperResult,
+            caveats: [
+                ...mapperResult.caveats ?? [],
+                {
+                    type: SnapCaveatType.MaxRequestTime,
+                    value: maxRequestTime
+                }
+            ]
+        };
+    };
+}
+/**
+ * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.
+ *
+ * @param permission - The permission to get the caveat value from.
+ * @returns The caveat value if present, otherwise null.
+ */ export function getMaxRequestTimeCaveat(permission) {
+    const foundCaveat = permission?.caveats?.find((caveat)=>caveat.type === SnapCaveatType.MaxRequestTime);
+    return (foundCaveat?.value) ?? null;
+}
+export const maxRequestTimeCaveatSpecifications = {
+    [SnapCaveatType.MaxRequestTime]: Object.freeze({
+        type: SnapCaveatType.MaxRequestTime,
+        validator: (caveat)=>validateMaxRequestTimeCaveat(caveat)
+    })
+};
+
+//# sourceMappingURL=requestTime.js.map

package/dist/esm/endowments/caveats/requestTime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/endowments/caveats/requestTime.ts"],"sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { MaxRequestTimeStruct, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { AssertionErrorConstructor, Json } from '@metamask/utils';\nimport { assertStruct, hasProperty, isObject } from '@metamask/utils';\n\nimport type { CaveatMapperFunction, CaveatMapperReturnValue } from './generic';\n\n/**\n * Asserts that the given value is a valid `maxRequestTime` value.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid `maxRequestTime` value.\n */\nfunction assertIsMaxRequestTime(\n  value: unknown, // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is number {\n  assertStruct(\n    value,\n    MaxRequestTimeStruct,\n    'Invalid maxRequestTime',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Validate the value of a caveat. This does not validate the type of the\n * caveat itself, only the value of the caveat.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateMaxRequestTimeCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value')) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid maxRequestTime caveat.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsMaxRequestTime(value, rpcErrors.invalidParams);\n}\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getMaxRequestTimeCaveatMapper(\n  value: Json,\n): CaveatMapperReturnValue {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && !hasProperty(value, 'maxRequestTime'))\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.MaxRequestTime,\n        value: value.maxRequestTime,\n      },\n    ],\n  };\n}\n\n/**\n * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat\n * and merges it with any other caveats created by the mapper function.\n *\n * @param mapper - Another caveat mapper function.\n * @returns The caveat specification.\n */\nexport function createMaxRequestTimeMapper(\n  mapper: CaveatMapperFunction,\n): CaveatMapperFunction {\n  return function (value: Json) {\n    // We assume this to be used only with caveats of this type\n    const { maxRequestTime, ...rest } = value as Record<string, Json>;\n\n    const mapperResult = mapper(rest);\n\n    if (!maxRequestTime) {\n      return mapperResult;\n    }\n\n    return {\n      ...mapperResult,\n      caveats: [\n        ...(mapperResult.caveats ?? []),\n        {\n          type: SnapCaveatType.MaxRequestTime,\n          value: maxRequestTime,\n        },\n      ],\n    };\n  };\n}\n\n/**\n * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value if present, otherwise null.\n */\nexport function getMaxRequestTimeCaveat(\n  permission?: PermissionConstraint,\n): number | null {\n  const foundCaveat = permission?.caveats?.find(\n    (caveat) => caveat.type === SnapCaveatType.MaxRequestTime,\n  );\n  return (foundCaveat?.value as number) ?? null;\n}\n\nexport const maxRequestTimeCaveatSpecifications: Record<\n  SnapCaveatType.MaxRequestTime,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.MaxRequestTime]: Object.freeze({\n    type: SnapCaveatType.MaxRequestTime,\n    validator: (caveat: Caveat<string, any>) =>\n      validateMaxRequestTimeCaveat(caveat),\n  }),\n};\n"],"names":["rpcErrors","MaxRequestTimeStruct","SnapCaveatType","assertStruct","hasProperty","isObject","assertIsMaxRequestTime","value","ErrorWrapper","validateMaxRequestTimeCaveat","caveat","invalidParams","message","getMaxRequestTimeCaveatMapper","caveats","type","MaxRequestTime","maxRequestTime","createMaxRequestTimeMapper","mapper","rest","mapperResult","getMaxRequestTimeCaveat","permission","foundCaveat","find","maxRequestTimeCaveatSpecifications","Object","freeze","validator"],"mappings":"AAKA,SAASA,SAAS,QAAQ,uBAAuB;AACjD,SAASC,oBAAoB,EAAEC,cAAc,QAAQ,wBAAwB;AAE7E,SAASC,YAAY,EAAEC,WAAW,EAAEC,QAAQ,QAAQ,kBAAkB;AAItE;;;;;;;CAOC,GACD,SAASC,uBACPC,KAAc,EACdC,YAAwC;IAExCL,aACEI,OACAN,sBACA,0BACAO;AAEJ;AAEA;;;;;;CAMC,GACD,SAASC,6BAA6BC,MAA2B;IAC/D,IAAI,CAACN,YAAYM,QAAQ,UAAU;QACjC,MAAMV,UAAUW,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEL,KAAK,EAAE,GAAGG;IAClBJ,uBAAuBC,OAAOP,UAAUW,aAAa;AACvD;AAEA;;;;;;;CAOC,GACD,OAAO,SAASE,8BACdN,KAAW;IAEX,IACE,CAACA,SACD,CAACF,SAASE,UACTF,SAASE,UAAU,CAACH,YAAYG,OAAO,mBACxC;QACA,OAAO;YAAEO,SAAS;QAAK;IACzB;IACA,OAAO;QACLA,SAAS;YACP;gBACEC,MAAMb,eAAec,cAAc;gBACnCT,OAAOA,MAAMU,cAAc;YAC7B;SACD;IACH;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,2BACdC,MAA4B;IAE5B,OAAO,SAAUZ,KAAW;QAC1B,2DAA2D;QAC3D,MAAM,EAAEU,cAAc,EAAE,GAAGG,MAAM,GAAGb;QAEpC,MAAMc,eAAeF,OAAOC;QAE5B,IAAI,CAACH,gBAAgB;YACnB,OAAOI;QACT;QAEA,OAAO;YACL,GAAGA,YAAY;YACfP,SAAS;mBACHO,aAAaP,OAAO,IAAI,EAAE;gBAC9B;oBACEC,MAAMb,eAAec,cAAc;oBACnCT,OAAOU;gBACT;aACD;QACH;IACF;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASK,wBACdC,UAAiC;IAEjC,MAAMC,cAAcD,YAAYT,SAASW,KACvC,CAACf,SAAWA,OAAOK,IAAI,KAAKb,eAAec,cAAc;IAE3D,OAAO,CAACQ,aAAajB,KAAe,KAAK;AAC3C;AAEA,OAAO,MAAMmB,qCAGT;IACF,CAACxB,eAAec,cAAc,CAAC,EAAEW,OAAOC,MAAM,CAAC;QAC7Cb,MAAMb,eAAec,cAAc;QACnCa,WAAW,CAACnB,SACVD,6BAA6BC;IACjC;AACF,EAAE"}