@metamask/snaps-rpc-methods 11.0.0 → 11.1.0

package/dist/chunk-TAXLFFV4.mjs

@@ -1,115 +0,0 @@
-import {
-  getKeyringCaveatMapper,
-  keyringCaveatSpecifications,
-  keyringEndowmentBuilder
-} from "./chunk-HOECEYMT.mjs";
-import {
-  lifecycleHooksEndowmentBuilder
-} from "./chunk-DTZF746A.mjs";
-import {
-  getNameLookupCaveatMapper,
-  nameLookupCaveatSpecifications,
-  nameLookupEndowmentBuilder
-} from "./chunk-ODN35VOK.mjs";
-import {
-  networkAccessEndowmentBuilder
-} from "./chunk-4D2B2UQ6.mjs";
-import {
-  getRpcCaveatMapper,
-  rpcCaveatSpecifications,
-  rpcEndowmentBuilder
-} from "./chunk-57BL7O2P.mjs";
-import {
-  getSignatureInsightCaveatMapper,
-  signatureInsightCaveatSpecifications,
-  signatureInsightEndowmentBuilder
-} from "./chunk-33LLA2MH.mjs";
-import {
-  getTransactionInsightCaveatMapper,
-  transactionInsightCaveatSpecifications,
-  transactionInsightEndowmentBuilder
-} from "./chunk-PIRQCNBJ.mjs";
-import {
-  createMaxRequestTimeMapper,
-  getMaxRequestTimeCaveatMapper,
-  maxRequestTimeCaveatSpecifications
-} from "./chunk-23XDKQW2.mjs";
-import {
-  webAssemblyEndowmentBuilder
-} from "./chunk-O66NZFSD.mjs";
-import {
-  cronjobCaveatSpecifications,
-  cronjobEndowmentBuilder,
-  getCronjobCaveatMapper
-} from "./chunk-3WCLDJAS.mjs";
-import {
-  ethereumProviderEndowmentBuilder
-} from "./chunk-KSTF5JYB.mjs";
-import {
-  homePageEndowmentBuilder
-} from "./chunk-ZH3FC55E.mjs";
-
-// src/endowments/index.ts
-import { HandlerType } from "@metamask/snaps-utils";
-var endowmentPermissionBuilders = {
-  [networkAccessEndowmentBuilder.targetName]: networkAccessEndowmentBuilder,
-  [transactionInsightEndowmentBuilder.targetName]: transactionInsightEndowmentBuilder,
-  [cronjobEndowmentBuilder.targetName]: cronjobEndowmentBuilder,
-  [ethereumProviderEndowmentBuilder.targetName]: ethereumProviderEndowmentBuilder,
-  [rpcEndowmentBuilder.targetName]: rpcEndowmentBuilder,
-  [webAssemblyEndowmentBuilder.targetName]: webAssemblyEndowmentBuilder,
-  [nameLookupEndowmentBuilder.targetName]: nameLookupEndowmentBuilder,
-  [lifecycleHooksEndowmentBuilder.targetName]: lifecycleHooksEndowmentBuilder,
-  [keyringEndowmentBuilder.targetName]: keyringEndowmentBuilder,
-  [homePageEndowmentBuilder.targetName]: homePageEndowmentBuilder,
-  [signatureInsightEndowmentBuilder.targetName]: signatureInsightEndowmentBuilder
-};
-var endowmentCaveatSpecifications = {
-  ...cronjobCaveatSpecifications,
-  ...transactionInsightCaveatSpecifications,
-  ...rpcCaveatSpecifications,
-  ...nameLookupCaveatSpecifications,
-  ...keyringCaveatSpecifications,
-  ...signatureInsightCaveatSpecifications,
-  ...maxRequestTimeCaveatSpecifications
-};
-var endowmentCaveatMappers = {
-  [cronjobEndowmentBuilder.targetName]: createMaxRequestTimeMapper(
-    getCronjobCaveatMapper
-  ),
-  [transactionInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(
-    getTransactionInsightCaveatMapper
-  ),
-  [rpcEndowmentBuilder.targetName]: createMaxRequestTimeMapper(getRpcCaveatMapper),
-  [nameLookupEndowmentBuilder.targetName]: createMaxRequestTimeMapper(
-    getNameLookupCaveatMapper
-  ),
-  [keyringEndowmentBuilder.targetName]: createMaxRequestTimeMapper(
-    getKeyringCaveatMapper
-  ),
-  [signatureInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(
-    getSignatureInsightCaveatMapper
-  ),
-  [lifecycleHooksEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper,
-  [homePageEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper
-};
-var handlerEndowments = {
-  [HandlerType.OnRpcRequest]: rpcEndowmentBuilder.targetName,
-  [HandlerType.OnTransaction]: transactionInsightEndowmentBuilder.targetName,
-  [HandlerType.OnCronjob]: cronjobEndowmentBuilder.targetName,
-  [HandlerType.OnNameLookup]: nameLookupEndowmentBuilder.targetName,
-  [HandlerType.OnInstall]: lifecycleHooksEndowmentBuilder.targetName,
-  [HandlerType.OnUpdate]: lifecycleHooksEndowmentBuilder.targetName,
-  [HandlerType.OnKeyringRequest]: keyringEndowmentBuilder.targetName,
-  [HandlerType.OnHomePage]: homePageEndowmentBuilder.targetName,
-  [HandlerType.OnSignature]: signatureInsightEndowmentBuilder.targetName,
-  [HandlerType.OnUserInput]: null
-};
-
-export {
-  endowmentPermissionBuilders,
-  endowmentCaveatSpecifications,
-  endowmentCaveatMappers,
-  handlerEndowments
-};
-//# sourceMappingURL=chunk-TAXLFFV4.mjs.map

package/dist/chunk-TAXLFFV4.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endowments/index.ts"],"sourcesContent":["import type { PermissionConstraint } from '@metamask/permission-controller';\nimport { HandlerType } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\n\nimport {\n  createMaxRequestTimeMapper,\n  getMaxRequestTimeCaveatMapper,\n  maxRequestTimeCaveatSpecifications,\n} from './caveats';\nimport {\n  cronjobCaveatSpecifications,\n  cronjobEndowmentBuilder,\n  getCronjobCaveatMapper,\n} from './cronjob';\nimport { ethereumProviderEndowmentBuilder } from './ethereum-provider';\nimport { homePageEndowmentBuilder } from './home-page';\nimport {\n  getKeyringCaveatMapper,\n  keyringCaveatSpecifications,\n  keyringEndowmentBuilder,\n} from './keyring';\nimport { lifecycleHooksEndowmentBuilder } from './lifecycle-hooks';\nimport {\n  getNameLookupCaveatMapper,\n  nameLookupCaveatSpecifications,\n  nameLookupEndowmentBuilder,\n} from './name-lookup';\nimport { networkAccessEndowmentBuilder } from './network-access';\nimport {\n  getRpcCaveatMapper,\n  rpcCaveatSpecifications,\n  rpcEndowmentBuilder,\n} from './rpc';\nimport {\n  getSignatureInsightCaveatMapper,\n  signatureInsightCaveatSpecifications,\n  signatureInsightEndowmentBuilder,\n} from './signature-insight';\nimport {\n  getTransactionInsightCaveatMapper,\n  transactionInsightCaveatSpecifications,\n  transactionInsightEndowmentBuilder,\n} from './transaction-insight';\nimport { webAssemblyEndowmentBuilder } from './web-assembly';\n\nexport const endowmentPermissionBuilders = {\n  [networkAccessEndowmentBuilder.targetName]: networkAccessEndowmentBuilder,\n  [transactionInsightEndowmentBuilder.targetName]:\n    transactionInsightEndowmentBuilder,\n  [cronjobEndowmentBuilder.targetName]: cronjobEndowmentBuilder,\n  [ethereumProviderEndowmentBuilder.targetName]:\n    ethereumProviderEndowmentBuilder,\n  [rpcEndowmentBuilder.targetName]: rpcEndowmentBuilder,\n  [webAssemblyEndowmentBuilder.targetName]: webAssemblyEndowmentBuilder,\n  [nameLookupEndowmentBuilder.targetName]: nameLookupEndowmentBuilder,\n  [lifecycleHooksEndowmentBuilder.targetName]: lifecycleHooksEndowmentBuilder,\n  [keyringEndowmentBuilder.targetName]: keyringEndowmentBuilder,\n  [homePageEndowmentBuilder.targetName]: homePageEndowmentBuilder,\n  [signatureInsightEndowmentBuilder.targetName]:\n    signatureInsightEndowmentBuilder,\n} as const;\n\nexport const endowmentCaveatSpecifications = {\n  ...cronjobCaveatSpecifications,\n  ...transactionInsightCaveatSpecifications,\n  ...rpcCaveatSpecifications,\n  ...nameLookupCaveatSpecifications,\n  ...keyringCaveatSpecifications,\n  ...signatureInsightCaveatSpecifications,\n  ...maxRequestTimeCaveatSpecifications,\n};\n\nexport const endowmentCaveatMappers: Record<\n  string,\n  (value: Json) => Pick<PermissionConstraint, 'caveats'>\n> = {\n  [cronjobEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getCronjobCaveatMapper,\n  ),\n  [transactionInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getTransactionInsightCaveatMapper,\n  ),\n  [rpcEndowmentBuilder.targetName]:\n    createMaxRequestTimeMapper(getRpcCaveatMapper),\n  [nameLookupEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getNameLookupCaveatMapper,\n  ),\n  [keyringEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getKeyringCaveatMapper,\n  ),\n  [signatureInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getSignatureInsightCaveatMapper,\n  ),\n  [lifecycleHooksEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper,\n  [homePageEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper,\n};\n\n// We allow null because a permitted handler does not have an endowment\nexport const handlerEndowments: Record<HandlerType, string | null> = {\n  [HandlerType.OnRpcRequest]: rpcEndowmentBuilder.targetName,\n  [HandlerType.OnTransaction]: transactionInsightEndowmentBuilder.targetName,\n  [HandlerType.OnCronjob]: cronjobEndowmentBuilder.targetName,\n  [HandlerType.OnNameLookup]: nameLookupEndowmentBuilder.targetName,\n  [HandlerType.OnInstall]: lifecycleHooksEndowmentBuilder.targetName,\n  [HandlerType.OnUpdate]: lifecycleHooksEndowmentBuilder.targetName,\n  [HandlerType.OnKeyringRequest]: keyringEndowmentBuilder.targetName,\n  [HandlerType.OnHomePage]: homePageEndowmentBuilder.targetName,\n  [HandlerType.OnSignature]: signatureInsightEndowmentBuilder.targetName,\n  [HandlerType.OnUserInput]: null,\n};\n\nexport * from './enum';\nexport { getRpcCaveatOrigins } from './rpc';\nexport { getSignatureOriginCaveat } from './signature-insight';\nexport { getTransactionOriginCaveat } from './transaction-insight';\nexport { getChainIdsCaveat, getLookupMatchersCaveat } from './name-lookup';\nexport { getKeyringCaveatOrigins } from './keyring';\nexport { getMaxRequestTimeCaveat } from './caveats';\nexport { getCronjobCaveatJobs } from './cronjob';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,mBAAmB;AA4CrB,IAAM,8BAA8B;AAAA,EACzC,CAAC,8BAA8B,UAAU,GAAG;AAAA,EAC5C,CAAC,mCAAmC,UAAU,GAC5C;AAAA,EACF,CAAC,wBAAwB,UAAU,GAAG;AAAA,EACtC,CAAC,iCAAiC,UAAU,GAC1C;AAAA,EACF,CAAC,oBAAoB,UAAU,GAAG;AAAA,EAClC,CAAC,4BAA4B,UAAU,GAAG;AAAA,EAC1C,CAAC,2BAA2B,UAAU,GAAG;AAAA,EACzC,CAAC,+BAA+B,UAAU,GAAG;AAAA,EAC7C,CAAC,wBAAwB,UAAU,GAAG;AAAA,EACtC,CAAC,yBAAyB,UAAU,GAAG;AAAA,EACvC,CAAC,iCAAiC,UAAU,GAC1C;AACJ;AAEO,IAAM,gCAAgC;AAAA,EAC3C,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AACL;AAEO,IAAM,yBAGT;AAAA,EACF,CAAC,wBAAwB,UAAU,GAAG;AAAA,IACpC;AAAA,EACF;AAAA,EACA,CAAC,mCAAmC,UAAU,GAAG;AAAA,IAC/C;AAAA,EACF;AAAA,EACA,CAAC,oBAAoB,UAAU,GAC7B,2BAA2B,kBAAkB;AAAA,EAC/C,CAAC,2BAA2B,UAAU,GAAG;AAAA,IACvC;AAAA,EACF;AAAA,EACA,CAAC,wBAAwB,UAAU,GAAG;AAAA,IACpC;AAAA,EACF;AAAA,EACA,CAAC,iCAAiC,UAAU,GAAG;AAAA,IAC7C;AAAA,EACF;AAAA,EACA,CAAC,+BAA+B,UAAU,GAAG;AAAA,EAC7C,CAAC,yBAAyB,UAAU,GAAG;AACzC;AAGO,IAAM,oBAAwD;AAAA,EACnE,CAAC,YAAY,YAAY,GAAG,oBAAoB;AAAA,EAChD,CAAC,YAAY,aAAa,GAAG,mCAAmC;AAAA,EAChE,CAAC,YAAY,SAAS,GAAG,wBAAwB;AAAA,EACjD,CAAC,YAAY,YAAY,GAAG,2BAA2B;AAAA,EACvD,CAAC,YAAY,SAAS,GAAG,+BAA+B;AAAA,EACxD,CAAC,YAAY,QAAQ,GAAG,+BAA+B;AAAA,EACvD,CAAC,YAAY,gBAAgB,GAAG,wBAAwB;AAAA,EACxD,CAAC,YAAY,UAAU,GAAG,yBAAyB;AAAA,EACnD,CAAC,YAAY,WAAW,GAAG,iCAAiC;AAAA,EAC5D,CAAC,YAAY,WAAW,GAAG;AAC7B;","names":[]}

package/dist/chunk-TE4W25CA.mjs

@@ -1,143 +0,0 @@
-import {
-  deriveEntropy
-} from "./chunk-W33UWNA2.mjs";
-
-// src/restricted/manageState.ts
-import { PermissionType, SubjectType } from "@metamask/permission-controller";
-import { rpcErrors } from "@metamask/rpc-errors";
-import { ManageStateOperation } from "@metamask/snaps-sdk";
-import { STATE_ENCRYPTION_MAGIC_VALUE } from "@metamask/snaps-utils";
-import { isObject, getJsonSize } from "@metamask/utils";
-var STATE_ENCRYPTION_SALT = "snap_manageState encryption";
-var methodName = "snap_manageState";
-var specificationBuilder = ({
-  allowedCaveats = null,
-  methodHooks: methodHooks2
-}) => {
-  return {
-    permissionType: PermissionType.RestrictedMethod,
-    targetName: methodName,
-    allowedCaveats,
-    methodImplementation: getManageStateImplementation(methodHooks2),
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var methodHooks = {
-  getUnlockPromise: true,
-  clearSnapState: true,
-  getSnapState: true,
-  updateSnapState: true
-};
-var manageStateBuilder = Object.freeze({
-  targetName: methodName,
-  specificationBuilder,
-  methodHooks
-});
-var STORAGE_SIZE_LIMIT = 104857600;
-async function getEncryptionEntropy({
-  mnemonicPhrase,
-  snapId
-}) {
-  return await deriveEntropy({
-    mnemonicPhrase,
-    input: snapId,
-    salt: STATE_ENCRYPTION_SALT,
-    magic: STATE_ENCRYPTION_MAGIC_VALUE
-  });
-}
-function getManageStateImplementation({
-  getUnlockPromise,
-  clearSnapState,
-  getSnapState,
-  updateSnapState
-}) {
-  return async function manageState(options) {
-    const {
-      params = {},
-      method,
-      context: { origin }
-    } = options;
-    const validatedParams = getValidatedParams(params, method);
-    const shouldEncrypt = validatedParams.encrypted ?? true;
-    if (shouldEncrypt && validatedParams.operation !== ManageStateOperation.ClearState) {
-      await getUnlockPromise(true);
-    }
-    switch (validatedParams.operation) {
-      case ManageStateOperation.ClearState:
-        clearSnapState(origin, shouldEncrypt);
-        return null;
-      case ManageStateOperation.GetState: {
-        return await getSnapState(origin, shouldEncrypt);
-      }
-      case ManageStateOperation.UpdateState: {
-        await updateSnapState(origin, validatedParams.newState, shouldEncrypt);
-        return null;
-      }
-      default:
-        throw rpcErrors.invalidParams(
-          `Invalid ${method} operation: "${validatedParams.operation}"`
-        );
-    }
-  };
-}
-function getValidatedParams(params, method, storageSizeLimit = STORAGE_SIZE_LIMIT) {
-  if (!isObject(params)) {
-    throw rpcErrors.invalidParams({
-      message: "Expected params to be a single object."
-    });
-  }
-  const { operation, newState, encrypted } = params;
-  if (!operation || typeof operation !== "string" || !Object.values(ManageStateOperation).includes(
-    operation
-  )) {
-    throw rpcErrors.invalidParams({
-      message: 'Must specify a valid manage state "operation".'
-    });
-  }
-  if (encrypted !== void 0 && typeof encrypted !== "boolean") {
-    throw rpcErrors.invalidParams({
-      message: '"encrypted" parameter must be a boolean if specified.'
-    });
-  }
-  if (operation === ManageStateOperation.UpdateState) {
-    if (!isObject(newState)) {
-      throw rpcErrors.invalidParams({
-        message: `Invalid ${method} "updateState" parameter: The new state must be a plain object.`,
-        data: {
-          receivedNewState: typeof newState === "undefined" ? "undefined" : newState
-        }
-      });
-    }
-    let size;
-    try {
-      size = getJsonSize(newState);
-    } catch {
-      throw rpcErrors.invalidParams({
-        message: `Invalid ${method} "updateState" parameter: The new state must be JSON serializable.`,
-        data: {
-          receivedNewState: typeof newState === "undefined" ? "undefined" : newState
-        }
-      });
-    }
-    if (size > storageSizeLimit) {
-      throw rpcErrors.invalidParams({
-        message: `Invalid ${method} "updateState" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,
-        data: {
-          receivedNewState: typeof newState === "undefined" ? "undefined" : newState
-        }
-      });
-    }
-  }
-  return params;
-}
-
-export {
-  STATE_ENCRYPTION_SALT,
-  specificationBuilder,
-  manageStateBuilder,
-  STORAGE_SIZE_LIMIT,
-  getEncryptionEntropy,
-  getManageStateImplementation,
-  getValidatedParams
-};
-//# sourceMappingURL=chunk-TE4W25CA.mjs.map

package/dist/chunk-TE4W25CA.mjs.map

@@ -1 +0,0 @@
-{"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 } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { isObject, getJsonSize } 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   * 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: (\n    snapId: string,\n    encrypted: boolean,\n  ) => Promise<Record<string, Json>>;\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: Record<string, Json>,\n    encrypted: boolean,\n  ) => Promise<void>;\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  getUnlockPromise: true,\n  clearSnapState: true,\n  getSnapState: true,\n  updateSnapState: 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 getEncryptionEntropy({\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\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.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @returns The method implementation which 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  getUnlockPromise,\n  clearSnapState,\n  getSnapState,\n  updateSnapState,\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        return await getSnapState(origin, shouldEncrypt);\n      }\n\n      case ManageStateOperation.UpdateState: {\n        await updateSnapState(origin, validatedParams.newState, 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"],"mappings":"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","names":["methodHooks"]}

package/dist/chunk-TG63GBK3.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-TG63GBK3.mjs.map

package/dist/chunk-TG63GBK3.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-TNENASGX.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-TNENASGX.mjs.map

package/dist/chunk-TNENASGX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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":[]}