@metamask/snaps-rpc-methods 10.0.1 → 11.1.0

package/dist/chunk-TQCUJQHY.mjs

@@ -1,196 +0,0 @@
-// src/restricted/dialog.ts
-import { PermissionType, SubjectType } from "@metamask/permission-controller";
-import { rpcErrors } from "@metamask/rpc-errors";
-import {
-  DialogType,
-  enumValue,
-  union,
-  ComponentOrElementStruct
-} from "@metamask/snaps-sdk";
-import { createUnion } from "@metamask/snaps-utils";
-import {
-  create,
-  enums,
-  object,
-  optional,
-  size,
-  string,
-  type
-} from "@metamask/superstruct";
-import { hasProperty, isObject } from "@metamask/utils";
-var methodName = "snap_dialog";
-var DIALOG_APPROVAL_TYPES = {
-  [DialogType.Alert]: `${methodName}:alert`,
-  [DialogType.Confirmation]: `${methodName}:confirmation`,
-  [DialogType.Prompt]: `${methodName}:prompt`,
-  default: methodName
-};
-var PlaceholderStruct = optional(size(string(), 1, 40));
-var specificationBuilder = ({
-  allowedCaveats = null,
-  methodHooks: methodHooks2
-}) => {
-  return {
-    permissionType: PermissionType.RestrictedMethod,
-    targetName: methodName,
-    allowedCaveats,
-    methodImplementation: getDialogImplementation(methodHooks2),
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var methodHooks = {
-  requestUserApproval: true,
-  createInterface: true,
-  getInterface: true
-};
-var dialogBuilder = Object.freeze({
-  targetName: methodName,
-  specificationBuilder,
-  methodHooks
-});
-var BaseParamsStruct = type({
-  type: optional(
-    enums([DialogType.Alert, DialogType.Confirmation, DialogType.Prompt])
-  )
-});
-var AlertParametersWithContentStruct = object({
-  type: enumValue(DialogType.Alert),
-  content: ComponentOrElementStruct
-});
-var AlertParametersWithIdStruct = object({
-  type: enumValue(DialogType.Alert),
-  id: string()
-});
-var AlertParametersStruct = union([
-  AlertParametersWithContentStruct,
-  AlertParametersWithIdStruct
-]);
-var ConfirmationParametersWithContentStruct = object({
-  type: enumValue(DialogType.Confirmation),
-  content: ComponentOrElementStruct
-});
-var ConfirmationParametersWithIdStruct = object({
-  type: enumValue(DialogType.Confirmation),
-  id: string()
-});
-var ConfirmationParametersStruct = union([
-  ConfirmationParametersWithContentStruct,
-  ConfirmationParametersWithIdStruct
-]);
-var PromptParametersWithContentStruct = object({
-  type: enumValue(DialogType.Prompt),
-  content: ComponentOrElementStruct,
-  placeholder: PlaceholderStruct
-});
-var PromptParametersWithIdStruct = object({
-  type: enumValue(DialogType.Prompt),
-  id: string(),
-  placeholder: PlaceholderStruct
-});
-var PromptParametersStruct = union([
-  PromptParametersWithContentStruct,
-  PromptParametersWithIdStruct
-]);
-var DefaultParametersWithContentStruct = object({
-  content: ComponentOrElementStruct
-});
-var DefaultParametersWithIdStruct = object({
-  id: string()
-});
-var DefaultParametersStruct = union([
-  DefaultParametersWithContentStruct,
-  DefaultParametersWithIdStruct
-]);
-var DialogParametersStruct = union([
-  AlertParametersStruct,
-  ConfirmationParametersStruct,
-  PromptParametersStruct,
-  DefaultParametersStruct
-]);
-var structs = {
-  [DialogType.Alert]: AlertParametersStruct,
-  [DialogType.Confirmation]: ConfirmationParametersStruct,
-  [DialogType.Prompt]: PromptParametersStruct
-};
-function getDialogImplementation({
-  requestUserApproval,
-  createInterface,
-  getInterface
-}) {
-  return async function dialogImplementation(args) {
-    const {
-      params,
-      context: { origin }
-    } = args;
-    if (!isObject(params)) {
-      throw rpcErrors.invalidParams({
-        message: "Invalid params: Expected params to be a single object."
-      });
-    }
-    const validatedType = getValidatedType(params);
-    const approvalType = validatedType ? DIALOG_APPROVAL_TYPES[validatedType] : DIALOG_APPROVAL_TYPES.default;
-    const validatedParams = getValidatedParams(params, validatedType);
-    const placeholder = isPromptDialog(validatedParams) ? validatedParams.placeholder : void 0;
-    if (hasProperty(validatedParams, "content")) {
-      const id = await createInterface(
-        origin,
-        validatedParams.content
-      );
-      return requestUserApproval({
-        id: validatedType ? void 0 : id,
-        origin,
-        type: approvalType,
-        requestData: { id, placeholder }
-      });
-    }
-    validateInterface(origin, validatedParams.id, getInterface);
-    return requestUserApproval({
-      id: validatedType ? void 0 : validatedParams.id,
-      origin,
-      type: approvalType,
-      requestData: { id: validatedParams.id, placeholder }
-    });
-  };
-}
-function validateInterface(origin, id, getInterface) {
-  try {
-    getInterface(origin, id);
-  } catch (error) {
-    throw rpcErrors.invalidParams({
-      message: `Invalid params: ${error.message}`
-    });
-  }
-}
-function getDialogType(params) {
-  return hasProperty(params, "type") ? params.type : void 0;
-}
-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(", ")}.`
-    });
-  }
-}
-function isPromptDialog(params) {
-  return getDialogType(params) === DialogType.Prompt;
-}
-function getValidatedParams(params, validatedType) {
-  try {
-    return validatedType ? createUnion(params, structs[validatedType], "type") : create(params, DefaultParametersStruct);
-  } catch (error) {
-    throw rpcErrors.invalidParams({
-      message: `Invalid params: ${error.message}`
-    });
-  }
-}
-
-export {
-  DIALOG_APPROVAL_TYPES,
-  dialogBuilder,
-  getDialogImplementation
-};
-//# sourceMappingURL=chunk-TQCUJQHY.mjs.map

package/dist/chunk-TQCUJQHY.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/dialog.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport {\n  DialogType,\n  enumValue,\n  union,\n  ComponentOrElementStruct,\n} from '@metamask/snaps-sdk';\nimport type {\n  DialogParams,\n  Component,\n  InterfaceState,\n  SnapId,\n  PromptDialog,\n  ComponentOrElement,\n} from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport { createUnion } from '@metamask/snaps-utils';\nimport type { Infer, Struct } from '@metamask/superstruct';\nimport {\n  create,\n  enums,\n  object,\n  optional,\n  size,\n  string,\n  type,\n} from '@metamask/superstruct';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { hasProperty, isObject } from '@metamask/utils';\n\nimport { type MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_dialog';\n\nexport type DialogApprovalTypes = Record<DialogType, string> & {\n  default: string;\n};\n\nexport const DIALOG_APPROVAL_TYPES = {\n  [DialogType.Alert]: `${methodName}:alert`,\n  [DialogType.Confirmation]: `${methodName}:confirmation`,\n  [DialogType.Prompt]: `${methodName}:prompt`,\n  default: methodName,\n};\n\nconst PlaceholderStruct = optional(size(string(), 1, 40));\n\nexport type Placeholder = Infer<typeof PlaceholderStruct>;\n\ntype RequestUserApprovalOptions = {\n  id?: string;\n  origin: string;\n  type: string;\n  requestData: {\n    id: string;\n    placeholder?: string;\n  };\n};\n\ntype RequestUserApproval = (\n  opts: RequestUserApprovalOptions,\n) => Promise<boolean | null | string | Json>;\n\ntype CreateInterface = (\n  snapId: string,\n  content: ComponentOrElement,\n) => Promise<string>;\n\ntype GetInterface = (\n  snapId: string,\n  id: string,\n) => { content: ComponentOrElement; snapId: SnapId; state: InterfaceState };\n\nexport type DialogMethodHooks = {\n  /**\n   * @param opts - The `requestUserApproval` options.\n   * @param opts.id - The approval ID. If not provided, a new approval ID will be generated.\n   * @param opts.origin - The origin of the request. In this case, the Snap ID.\n   * @param opts.type - The type of the approval request.\n   * @param opts.requestData - The data of the approval request.\n   * @param opts.requestData.id - The ID of the interface.\n   * @param opts.requestData.placeholder - The placeholder of the `Prompt` dialog.\n   */\n  requestUserApproval: RequestUserApproval;\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  requestUserApproval: 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: optional(\n    enums([DialogType.Alert, DialogType.Confirmation, DialogType.Prompt]),\n  ),\n});\n\nconst AlertParametersWithContentStruct = object({\n  type: enumValue(DialogType.Alert),\n  content: ComponentOrElementStruct,\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: ComponentOrElementStruct,\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: ComponentOrElementStruct,\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 DefaultParametersWithContentStruct = object({\n  content: ComponentOrElementStruct,\n});\n\nconst DefaultParametersWithIdStruct = object({\n  id: string(),\n});\n\nconst DefaultParametersStruct = union([\n  DefaultParametersWithContentStruct,\n  DefaultParametersWithIdStruct,\n]);\n\nconst DialogParametersStruct = union([\n  AlertParametersStruct,\n  ConfirmationParametersStruct,\n  PromptParametersStruct,\n  DefaultParametersStruct,\n]);\n\nexport type DialogParameters = InferMatching<\n  typeof DialogParametersStruct,\n  DialogParams\n>;\n\nconst structs: Record<DialogType, Struct<any, any>> = {\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.requestUserApproval - A function that creates a new Approval in the ApprovalController.\n * This function should return a Promise that resolves with the appropriate value when the user has approved or rejected the request.\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  requestUserApproval,\n  createInterface,\n  getInterface,\n}: DialogMethodHooks) {\n  return async function dialogImplementation(\n    args: RestrictedMethodOptions<DialogParameters>,\n  ): Promise<boolean | null | string | Json> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    if (!isObject(params)) {\n      throw rpcErrors.invalidParams({\n        message: 'Invalid params: Expected params to be a single object.',\n      });\n    }\n\n    const validatedType = getValidatedType(params);\n\n    const approvalType = validatedType\n      ? DIALOG_APPROVAL_TYPES[validatedType]\n      : DIALOG_APPROVAL_TYPES.default;\n\n    const validatedParams = getValidatedParams(params, validatedType);\n    const placeholder = isPromptDialog(validatedParams)\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\n      return requestUserApproval({\n        id: validatedType ? undefined : id,\n        origin,\n        type: approvalType,\n        requestData: { id, placeholder },\n      });\n    }\n\n    validateInterface(origin, validatedParams.id, getInterface);\n\n    return requestUserApproval({\n      id: validatedType ? undefined : validatedParams.id,\n      origin,\n      type: approvalType,\n      requestData: { id: validatedParams.id, placeholder },\n    });\n  };\n}\n/**\n * Validate that the interface ID is valid.\n *\n * @param origin - The origin of the request.\n * @param id - The interface ID.\n * @param getInterface - The function to get the interface.\n */\nfunction validateInterface(\n  origin: string,\n  id: string,\n  getInterface: GetInterface,\n) {\n  try {\n    getInterface(origin, id);\n  } catch (error) {\n    throw rpcErrors.invalidParams({\n      message: `Invalid params: ${error.message}`,\n    });\n  }\n}\n\n/**\n * Gets the dialog type from the dialog parameters.\n *\n * @param params - The dialog parameters.\n * @returns The dialog type.\n */\nfunction getDialogType(params: DialogParameters): DialogType | undefined {\n  return hasProperty(params, 'type') ? (params.type as DialogType) : undefined;\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 | undefined {\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 * Checks if the dialog parameters are for a prompt dialog.\n *\n * @param params - The dialog parameters.\n * @returns `true` if the dialog parameters are for a prompt dialog, `false` otherwise.\n */\nfunction isPromptDialog(params: DialogParameters): params is PromptDialog {\n  return getDialogType(params) === DialogType.Prompt;\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 validatedType - The validated dialog type.\n * @returns The validated confirm method parameter object.\n */\nfunction getValidatedParams(\n  params: unknown,\n  validatedType: DialogType | undefined,\n): DialogParameters {\n  try {\n    return validatedType\n      ? createUnion(params, structs[validatedType], 'type')\n      : create(params, DefaultParametersStruct);\n  } catch (error) {\n    throw rpcErrors.invalidParams({\n      message: `Invalid params: ${error.message}`,\n    });\n  }\n}\n"],"mappings":"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","names":["methodHooks"]}

package/dist/chunk-TT4DP2YW.mjs

@@ -1,35 +0,0 @@
-// src/endowments/caveats/generic.ts
-import { rpcErrors } from "@metamask/rpc-errors";
-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);
-    if (passedCaveatsSet.size !== passedCaveatTypes.length) {
-      throw rpcErrors.invalidParams({
-        message: "Duplicate caveats are not allowed."
-      });
-    }
-    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(", ")}.`
-      });
-    }
-    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {
-      throw rpcErrors.invalidParams({
-        message: `Expected the following caveats: ${requiredCaveats.map((caveat) => `"${caveat.type}"`).join(", ")}.`
-      });
-    }
-  };
-}
-
-export {
-  createGenericPermissionValidator
-};
-//# sourceMappingURL=chunk-TT4DP2YW.mjs.map

package/dist/chunk-TT4DP2YW.mjs.map

@@ -1 +0,0 @@
-{"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"],"mappings":";AAIA,SAAS,iBAAiB;AAkBnB,SAAS,iCACd,mBAI+B;AAC/B,QAAM,mBAAmB,IAAI;AAAA,IAC3B,kBAAkB,IAAI,CAAC,WAAW,OAAO,IAAI;AAAA,EAC/C;AACA,QAAM,kBAAkB,kBAAkB;AAAA,IACxC,CAAC,WAAW,CAAC,OAAO;AAAA,EACtB;AAEA,SAAO,SAAU,EAAE,QAAQ,GAAG;AAC5B,UAAM,gBAAgB,WAAW,CAAC;AAClC,UAAM,oBAAoB,cAAc,IAAI,CAAC,WAAW,OAAO,IAAI;AACnE,UAAM,mBAAmB,IAAI,IAAI,iBAAiB;AAGlD,QAAI,iBAAiB,SAAS,kBAAkB,QAAQ;AACtD,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,cAAc,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACvE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,kBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC,cAAc,cACxB,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,gBAAgB,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACzE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,gBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-TVC3E5LI.mjs

@@ -1,42 +0,0 @@
-// src/permitted/getInterfaceState.ts
-import { rpcErrors } from "@metamask/rpc-errors";
-import { StructError, create, object, string } from "@metamask/superstruct";
-var hookNames = {
-  getInterfaceState: true
-};
-var getInterfaceStateHandler = {
-  methodNames: ["snap_getInterfaceState"],
-  implementation: getGetInterfaceStateImplementation,
-  hookNames
-};
-var GetInterfaceStateParametersStruct = object({
-  id: string()
-});
-function getGetInterfaceStateImplementation(req, res, _next, end, { getInterfaceState }) {
-  const { params } = req;
-  try {
-    const validatedParams = getValidatedParams(params);
-    const { id } = validatedParams;
-    res.result = getInterfaceState(id);
-  } catch (error) {
-    return end(error);
-  }
-  return end();
-}
-function getValidatedParams(params) {
-  try {
-    return create(params, GetInterfaceStateParametersStruct);
-  } catch (error) {
-    if (error instanceof StructError) {
-      throw rpcErrors.invalidParams({
-        message: `Invalid params: ${error.message}.`
-      });
-    }
-    throw rpcErrors.internal();
-  }
-}
-
-export {
-  getInterfaceStateHandler
-};
-//# sourceMappingURL=chunk-TVC3E5LI.mjs.map

package/dist/chunk-TVC3E5LI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/getInterfaceState.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  GetInterfaceStateParams,\n  GetInterfaceStateResult,\n  InterfaceState,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport { StructError, create, object, string } from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetInterfaceStateMethodHooks> = {\n  getInterfaceState: true,\n};\n\nexport type GetInterfaceStateMethodHooks = {\n  /**\n   * @param id - The interface ID.\n   * @returns The interface state.\n   */\n  getInterfaceState: (id: string) => InterfaceState;\n};\n\nexport const getInterfaceStateHandler: PermittedHandlerExport<\n  GetInterfaceStateMethodHooks,\n  GetInterfaceStateParameters,\n  GetInterfaceStateResult\n> = {\n  methodNames: ['snap_getInterfaceState'],\n  implementation: getGetInterfaceStateImplementation,\n  hookNames,\n};\n\nconst GetInterfaceStateParametersStruct = object({\n  id: string(),\n});\n\nexport type GetInterfaceStateParameters = InferMatching<\n  typeof GetInterfaceStateParametersStruct,\n  GetInterfaceStateParams\n>;\n\n/**\n * The `snap_getInterfaceState` 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.getInterfaceState - The function to get the interface state.\n * @returns Noting.\n */\nfunction getGetInterfaceStateImplementation(\n  req: JsonRpcRequest<GetInterfaceStateParameters>,\n  res: PendingJsonRpcResponse<GetInterfaceStateResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getInterfaceState }: GetInterfaceStateMethodHooks,\n): void {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id } = validatedParams;\n\n    res.result = getInterfaceState(id);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the getInterfaceState 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 getInterfaceState method parameter object.\n */\nfunction getValidatedParams(params: unknown): GetInterfaceStateParameters {\n  try {\n    return create(params, GetInterfaceStateParametersStruct);\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"],"mappings":";AAEA,SAAS,iBAAiB;AAQ1B,SAAS,aAAa,QAAQ,QAAQ,cAAc;AAKpD,IAAM,YAA6D;AAAA,EACjE,mBAAmB;AACrB;AAUO,IAAM,2BAIT;AAAA,EACF,aAAa,CAAC,wBAAwB;AAAA,EACtC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,oCAAoC,OAAO;AAAA,EAC/C,IAAI,OAAO;AACb,CAAC;AAmBD,SAAS,mCACP,KACA,KACA,OACA,KACA,EAAE,kBAAkB,GACd;AACN,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI;AACF,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,EAAE,GAAG,IAAI;AAEf,QAAI,SAAS,kBAAkB,EAAE;AAAA,EACnC,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;AASA,SAAS,mBAAmB,QAA8C;AACxE,MAAI;AACF,WAAO,OAAO,QAAQ,iCAAiC;AAAA,EACzD,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,SAAS;AAAA,EAC3B;AACF;","names":[]}

package/dist/chunk-U6TJQLNV.js

@@ -1,45 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/updateInterface.ts
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapssdk = require('@metamask/snaps-sdk');
-var _superstruct = require('@metamask/superstruct');
-var hookNames = {
-  updateInterface: true
-};
-var updateInterfaceHandler = {
-  methodNames: ["snap_updateInterface"],
-  implementation: getUpdateInterfaceImplementation,
-  hookNames
-};
-var UpdateInterfaceParametersStruct = _superstruct.object.call(void 0, {
-  id: _superstruct.string.call(void 0, ),
-  ui: _snapssdk.ComponentOrElementStruct
-});
-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();
-}
-function getValidatedParams(params) {
-  try {
-    return _superstruct.create.call(void 0, params, UpdateInterfaceParametersStruct);
-  } catch (error) {
-    if (error instanceof _superstruct.StructError) {
-      throw _rpcerrors.rpcErrors.invalidParams({
-        message: `Invalid params: ${error.message}.`
-      });
-    }
-    throw _rpcerrors.rpcErrors.internal();
-  }
-}
-
-
-
-exports.updateInterfaceHandler = updateInterfaceHandler;
-//# sourceMappingURL=chunk-U6TJQLNV.js.map

package/dist/chunk-U6TJQLNV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/updateInterface.ts"],"names":[],"mappings":";AAEA,SAAS,iBAAiB;AAO1B,SAAS,gCAAgC;AAEzC,SAAS,aAAa,QAAQ,QAAQ,cAAc;AAKpD,IAAM,YAA2D;AAAA,EAC/D,iBAAiB;AACnB;AAUO,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,sBAAsB;AAAA,EACpC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,kCAAkC,OAAO;AAAA,EAC7C,IAAI,OAAO;AAAA,EACX,IAAI;AACN,CAAC;AAmBD,eAAe,iCACb,KACA,KACA,OACA,KACA,EAAE,gBAAgB,GACH;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI;AACF,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,EAAE,IAAI,GAAG,IAAI;AAEnB,UAAM,gBAAgB,IAAI,EAAE;AAC5B,QAAI,SAAS;AAAA,EACf,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;AASA,SAAS,mBAAmB,QAA4C;AACtE,MAAI;AACF,WAAO,OAAO,QAAQ,+BAA+B;AAAA,EACvD,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,SAAS;AAAA,EAC3B;AACF","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  UpdateInterfaceParams,\n  UpdateInterfaceResult,\n  JsonRpcRequest,\n  ComponentOrElement,\n} from '@metamask/snaps-sdk';\nimport { ComponentOrElementStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport { StructError, create, object, string } from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\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: ComponentOrElement) => 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: ComponentOrElementStruct,\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"]}

package/dist/chunk-UB3733UY.mjs

@@ -1,23 +0,0 @@
-// src/permitted/getAllSnaps.ts
-import { rpcErrors } from "@metamask/rpc-errors";
-var hookNames = {
-  getAllSnaps: true
-};
-var getAllSnapsHandler = {
-  methodNames: ["wallet_getAllSnaps"],
-  implementation: getAllSnapsImplementation,
-  hookNames
-};
-async function getAllSnapsImplementation(request, response, _next, end, { getAllSnaps }) {
-  const { origin } = request;
-  if (origin !== "https://snaps.metamask.io") {
-    return end(rpcErrors.methodNotFound());
-  }
-  response.result = await getAllSnaps();
-  return end();
-}
-
-export {
-  getAllSnapsHandler
-};
-//# sourceMappingURL=chunk-UB3733UY.mjs.map

package/dist/chunk-UB3733UY.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/getAllSnaps.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 { GetSnapsResult } from '@metamask/snaps-sdk';\nimport type {\n  JsonRpcParams,\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetAllSnapsHooks> = {\n  getAllSnaps: true,\n};\n\n/**\n * `wallet_getAllSnaps` gets all installed Snaps. Currently, this can only be\n * called from `https://snaps.metamask.io`.\n */\nexport const getAllSnapsHandler: PermittedHandlerExport<\n  GetAllSnapsHooks,\n  JsonRpcParams,\n  GetSnapsResult\n> = {\n  methodNames: ['wallet_getAllSnaps'],\n  implementation: getAllSnapsImplementation,\n  hookNames,\n};\n\nexport type GetAllSnapsHooks = {\n  /**\n   * @returns All installed Snaps.\n   */\n  getAllSnaps: () => Promise<GetSnapsResult>;\n};\n\n/**\n * The `wallet_getAllSnaps` method implementation.\n * Fetches all installed snaps and adds them to the JSON-RPC response.\n *\n * @param request - The JSON-RPC request object.\n * @param response - 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.getAllSnaps - A function that returns all installed snaps.\n * @returns Nothing.\n */\nasync function getAllSnapsImplementation(\n  request: JsonRpcRequest,\n  response: PendingJsonRpcResponse<GetSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getAllSnaps }: GetAllSnapsHooks,\n): Promise<void> {\n  // The origin is added by the MetaMask middleware stack.\n  const { origin } = request as JsonRpcRequest & { origin: string };\n\n  if (origin !== 'https://snaps.metamask.io') {\n    return end(rpcErrors.methodNotFound());\n  }\n\n  response.result = await getAllSnaps();\n  return end();\n}\n"],"mappings":";AAEA,SAAS,iBAAiB;AAU1B,IAAM,YAAiD;AAAA,EACrD,aAAa;AACf;AAMO,IAAM,qBAIT;AAAA,EACF,aAAa,CAAC,oBAAoB;AAAA,EAClC,gBAAgB;AAAA,EAChB;AACF;AAsBA,eAAe,0BACb,SACA,UACA,OACA,KACA,EAAE,YAAY,GACC;AAEf,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI,WAAW,6BAA6B;AAC1C,WAAO,IAAI,UAAU,eAAe,CAAC;AAAA,EACvC;AAEA,WAAS,SAAS,MAAM,YAAY;AACpC,SAAO,IAAI;AACb;","names":[]}

package/dist/chunk-UCWANXBZ.js

@@ -1,45 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/resolveInterface.ts
-var _rpcerrors = require('@metamask/rpc-errors');
-var _superstruct = require('@metamask/superstruct');
-var _utils = require('@metamask/utils');
-var hookNames = {
-  resolveInterface: true
-};
-var resolveInterfaceHandler = {
-  methodNames: ["snap_resolveInterface"],
-  implementation: getResolveInterfaceImplementation,
-  hookNames
-};
-var ResolveInterfaceParametersStruct = _superstruct.object.call(void 0, {
-  id: _superstruct.string.call(void 0, ),
-  value: _utils.JsonStruct
-});
-async function getResolveInterfaceImplementation(req, res, _next, end, { resolveInterface }) {
-  const { params } = req;
-  try {
-    const validatedParams = getValidatedParams(params);
-    const { id, value } = validatedParams;
-    await resolveInterface(id, value);
-    res.result = null;
-  } catch (error) {
-    return end(error);
-  }
-  return end();
-}
-function getValidatedParams(params) {
-  try {
-    return _superstruct.create.call(void 0, params, ResolveInterfaceParametersStruct);
-  } catch (error) {
-    if (error instanceof _superstruct.StructError) {
-      throw _rpcerrors.rpcErrors.invalidParams({
-        message: `Invalid params: ${error.message}.`
-      });
-    }
-    throw _rpcerrors.rpcErrors.internal();
-  }
-}
-
-
-
-exports.resolveInterfaceHandler = resolveInterfaceHandler;
-//# sourceMappingURL=chunk-UCWANXBZ.js.map

package/dist/chunk-UCWANXBZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/resolveInterface.ts"],"names":[],"mappings":";AAEA,SAAS,iBAAiB;AAO1B,SAAS,aAAa,QAAQ,QAAQ,cAAc;AAEpD,SAAS,kBAA6B;AAItC,IAAM,YAA4D;AAAA,EAChE,kBAAkB;AACpB;AAUO,IAAM,0BAIT;AAAA,EACF,aAAa,CAAC,uBAAuB;AAAA,EACrC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,mCAAmC,OAAO;AAAA,EAC9C,IAAI,OAAO;AAAA,EACX,OAAO;AACT,CAAC;AAmBD,eAAe,kCACb,KACA,KACA,OACA,KACA,EAAE,iBAAiB,GACJ;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI;AACF,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,EAAE,IAAI,MAAM,IAAI;AAEtB,UAAM,iBAAiB,IAAI,KAAK;AAChC,QAAI,SAAS;AAAA,EACf,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;AASA,SAAS,mBAAmB,QAA6C;AACvE,MAAI;AACF,WAAO,OAAO,QAAQ,gCAAgC;AAAA,EACxD,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,SAAS;AAAA,EAC3B;AACF","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  JsonRpcRequest,\n  ResolveInterfaceParams,\n  ResolveInterfaceResult,\n} from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport { StructError, create, object, string } from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { JsonStruct, type Json } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<ResolveInterfaceMethodHooks> = {\n  resolveInterface: true,\n};\n\nexport type ResolveInterfaceMethodHooks = {\n  /**\n   * @param id - The interface id.\n   * @param value - The value to resolve the interface with.\n   */\n  resolveInterface: (id: string, value: Json) => Promise<void>;\n};\n\nexport const resolveInterfaceHandler: PermittedHandlerExport<\n  ResolveInterfaceMethodHooks,\n  ResolveInterfaceParameters,\n  ResolveInterfaceResult\n> = {\n  methodNames: ['snap_resolveInterface'],\n  implementation: getResolveInterfaceImplementation,\n  hookNames,\n};\n\nconst ResolveInterfaceParametersStruct = object({\n  id: string(),\n  value: JsonStruct,\n});\n\nexport type ResolveInterfaceParameters = InferMatching<\n  typeof ResolveInterfaceParametersStruct,\n  ResolveInterfaceParams\n>;\n\n/**\n * The `snap_resolveInterface` 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.resolveInterface - The function to resolve the interface.\n * @returns Nothing.\n */\nasync function getResolveInterfaceImplementation(\n  req: JsonRpcRequest<ResolveInterfaceParameters>,\n  res: PendingJsonRpcResponse<ResolveInterfaceResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { resolveInterface }: ResolveInterfaceMethodHooks,\n): Promise<void> {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id, value } = validatedParams;\n\n    await resolveInterface(id, value);\n    res.result = null;\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the resolveInterface 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 resolveInterface method parameter object.\n */\nfunction getValidatedParams(params: unknown): ResolveInterfaceParameters {\n  try {\n    return create(params, ResolveInterfaceParametersStruct);\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"]}

package/dist/chunk-UF3UJTY3.js

@@ -1,55 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkE27BGHCRjs = require('./chunk-E27BGHCR.js');
-
-
-var _chunkDLVPMPRZjs = require('./chunk-DLVPMPRZ.js');
-
-
-var _chunkPS6OEQXLjs = require('./chunk-PS6OEQXL.js');
-
-
-var _chunkUCWANXBZjs = require('./chunk-UCWANXBZ.js');
-
-
-var _chunkU6TJQLNVjs = require('./chunk-U6TJQLNV.js');
-
-
-var _chunkOI33OL7Kjs = require('./chunk-OI33OL7K.js');
-
-
-var _chunk4LSOS7SMjs = require('./chunk-4LSOS7SM.js');
-
-
-var _chunk3UAWEHMFjs = require('./chunk-3UAWEHMF.js');
-
-
-var _chunkEOXTZF5Ujs = require('./chunk-EOXTZF5U.js');
-
-
-var _chunk7CV677MMjs = require('./chunk-7CV677MM.js');
-
-
-var _chunkNWT2EXFDjs = require('./chunk-NWT2EXFD.js');
-
-// src/permitted/handlers.ts
-var methodHandlers = {
-  wallet_getAllSnaps: _chunk4LSOS7SMjs.getAllSnapsHandler,
-  wallet_getSnaps: _chunkNWT2EXFDjs.getSnapsHandler,
-  wallet_requestSnaps: _chunkPS6OEQXLjs.requestSnapsHandler,
-  wallet_invokeSnap: _chunkDLVPMPRZjs.invokeSnapSugarHandler,
-  wallet_invokeKeyring: _chunkE27BGHCRjs.invokeKeyringHandler,
-  snap_getClientStatus: _chunk3UAWEHMFjs.getClientStatusHandler,
-  snap_getFile: _chunkEOXTZF5Ujs.getFileHandler,
-  snap_createInterface: _chunkOI33OL7Kjs.createInterfaceHandler,
-  snap_updateInterface: _chunkU6TJQLNVjs.updateInterfaceHandler,
-  snap_getInterfaceState: _chunk7CV677MMjs.getInterfaceStateHandler,
-  snap_resolveInterface: _chunkUCWANXBZjs.resolveInterfaceHandler
-};
-var handlers = Object.values(methodHandlers);
-
-
-
-
-exports.methodHandlers = methodHandlers; exports.handlers = handlers;
-//# sourceMappingURL=chunk-UF3UJTY3.js.map

package/dist/chunk-UF3UJTY3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/handlers.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaO,IAAM,iBAAiB;AAAA,EAC5B,oBAAoB;AAAA,EACpB,iBAAiB;AAAA,EACjB,qBAAqB;AAAA,EACrB,mBAAmB;AAAA,EACnB,sBAAsB;AAAA,EACtB,sBAAsB;AAAA,EACtB,cAAc;AAAA,EACd,sBAAsB;AAAA,EACtB,sBAAsB;AAAA,EACtB,wBAAwB;AAAA,EACxB,uBAAuB;AACzB;AAGO,IAAM,WAAW,OAAO,OAAO,cAAc","sourcesContent":["import { createInterfaceHandler } from './createInterface';\nimport { getAllSnapsHandler } from './getAllSnaps';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getInterfaceStateHandler } from './getInterfaceState';\nimport { getSnapsHandler } from './getSnaps';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { requestSnapsHandler } from './requestSnaps';\nimport { resolveInterfaceHandler } from './resolveInterface';\nimport { updateInterfaceHandler } from './updateInterface';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n  snap_createInterface: createInterfaceHandler,\n  snap_updateInterface: updateInterfaceHandler,\n  snap_getInterfaceState: getInterfaceStateHandler,\n  snap_resolveInterface: resolveInterfaceHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport const handlers = Object.values(methodHandlers);\n"]}

package/dist/chunk-UY4DUF53.mjs

@@ -1,45 +0,0 @@
-// src/permitted/updateInterface.ts
-import { rpcErrors } from "@metamask/rpc-errors";
-import { ComponentOrElementStruct } from "@metamask/snaps-sdk";
-import { StructError, create, object, string } from "@metamask/superstruct";
-var hookNames = {
-  updateInterface: true
-};
-var updateInterfaceHandler = {
-  methodNames: ["snap_updateInterface"],
-  implementation: getUpdateInterfaceImplementation,
-  hookNames
-};
-var UpdateInterfaceParametersStruct = object({
-  id: string(),
-  ui: ComponentOrElementStruct
-});
-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();
-}
-function getValidatedParams(params) {
-  try {
-    return create(params, UpdateInterfaceParametersStruct);
-  } catch (error) {
-    if (error instanceof StructError) {
-      throw rpcErrors.invalidParams({
-        message: `Invalid params: ${error.message}.`
-      });
-    }
-    throw rpcErrors.internal();
-  }
-}
-
-export {
-  updateInterfaceHandler
-};
-//# sourceMappingURL=chunk-UY4DUF53.mjs.map

package/dist/chunk-UY4DUF53.mjs.map

@@ -1 +0,0 @@
-{"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  UpdateInterfaceParams,\n  UpdateInterfaceResult,\n  JsonRpcRequest,\n  ComponentOrElement,\n} from '@metamask/snaps-sdk';\nimport { ComponentOrElementStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport { StructError, create, object, string } from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\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: ComponentOrElement) => 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: ComponentOrElementStruct,\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"],"mappings":";AAEA,SAAS,iBAAiB;AAO1B,SAAS,gCAAgC;AAEzC,SAAS,aAAa,QAAQ,QAAQ,cAAc;AAKpD,IAAM,YAA2D;AAAA,EAC/D,iBAAiB;AACnB;AAUO,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,sBAAsB;AAAA,EACpC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,kCAAkC,OAAO;AAAA,EAC7C,IAAI,OAAO;AAAA,EACX,IAAI;AACN,CAAC;AAmBD,eAAe,iCACb,KACA,KACA,OACA,KACA,EAAE,gBAAgB,GACH;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI;AACF,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,EAAE,IAAI,GAAG,IAAI;AAEnB,UAAM,gBAAgB,IAAI,EAAE;AAC5B,QAAI,SAAS;AAAA,EACf,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;AASA,SAAS,mBAAmB,QAA4C;AACtE,MAAI;AACF,WAAO,OAAO,QAAQ,+BAA+B;AAAA,EACvD,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,SAAS;AAAA,EAC3B;AACF;","names":[]}

package/dist/chunk-VUA6ICJO.js

@@ -1,52 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/getBip44Entropy.ts
-var _keytree = require('@metamask/key-tree');
-var _permissioncontroller = require('@metamask/permission-controller');
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapsutils = require('@metamask/snaps-utils');
-var targetName = "snap_getBip44Entropy";
-var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
-  return {
-    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-    targetName,
-    allowedCaveats: [_snapsutils.SnapCaveatType.PermittedCoinTypes],
-    methodImplementation: getBip44EntropyImplementation(methodHooks2),
-    validator: ({ caveats }) => {
-      if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.PermittedCoinTypes) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-          message: `Expected a single "${_snapsutils.SnapCaveatType.PermittedCoinTypes}" caveat.`
-        });
-      }
-    },
-    subjectTypes: [_permissioncontroller.SubjectType.Snap]
-  };
-};
-var methodHooks = {
-  getMnemonic: true,
-  getUnlockPromise: true
-};
-var getBip44EntropyBuilder = Object.freeze({
-  targetName,
-  specificationBuilder,
-  methodHooks
-});
-function getBip44EntropyImplementation({
-  getMnemonic,
-  getUnlockPromise
-}) {
-  return async function getBip44Entropy(args) {
-    await getUnlockPromise(true);
-    const params = args.params;
-    const node = await _keytree.BIP44CoinTypeNode.fromDerivationPath([
-      await getMnemonic(),
-      `bip32:44'`,
-      `bip32:${params.coinType}'`
-    ]);
-    return node.toJSON();
-  };
-}
-
-
-
-
-exports.getBip44EntropyBuilder = getBip44EntropyBuilder; exports.getBip44EntropyImplementation = getBip44EntropyImplementation;
-//# sourceMappingURL=chunk-VUA6ICJO.js.map