@metamask/snaps-rpc-methods 10.0.1 → 11.1.0

package/dist/chunk-SYB5TG5O.mjs

@@ -1,49 +0,0 @@
-import {
-  notifyBuilder
-} from "./chunk-JWDQUKKU.mjs";
-import {
-  getBip32PublicKeyBuilder
-} from "./chunk-VYII7C3J.mjs";
-import {
-  getBip44EntropyBuilder
-} from "./chunk-LR7UR4YU.mjs";
-import {
-  getEntropyBuilder
-} from "./chunk-2RDYC42U.mjs";
-import {
-  getLocaleBuilder
-} from "./chunk-IZYMBIBD.mjs";
-import {
-  manageAccountsBuilder
-} from "./chunk-Z6YFGWHN.mjs";
-import {
-  manageStateBuilder
-} from "./chunk-TE4W25CA.mjs";
-import {
-  dialogBuilder
-} from "./chunk-TQCUJQHY.mjs";
-import {
-  getBip32EntropyBuilder
-} from "./chunk-LXJBBRQ4.mjs";
-import {
-  invokeSnapBuilder
-} from "./chunk-VVBTXSID.mjs";
-
-// src/restricted/index.ts
-var restrictedMethodPermissionBuilders = {
-  [dialogBuilder.targetName]: dialogBuilder,
-  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,
-  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,
-  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,
-  [getEntropyBuilder.targetName]: getEntropyBuilder,
-  [invokeSnapBuilder.targetName]: invokeSnapBuilder,
-  [manageStateBuilder.targetName]: manageStateBuilder,
-  [notifyBuilder.targetName]: notifyBuilder,
-  [manageAccountsBuilder.targetName]: manageAccountsBuilder,
-  [getLocaleBuilder.targetName]: getLocaleBuilder
-};
-
-export {
-  restrictedMethodPermissionBuilders
-};
-//# sourceMappingURL=chunk-SYB5TG5O.mjs.map

package/dist/chunk-SYB5TG5O.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/index.ts"],"sourcesContent":["import type { DialogMethodHooks } from './dialog';\nimport { dialogBuilder } from './dialog';\nimport type { GetBip32EntropyMethodHooks } from './getBip32Entropy';\nimport { getBip32EntropyBuilder } from './getBip32Entropy';\nimport type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';\nimport { getBip32PublicKeyBuilder } from './getBip32PublicKey';\nimport type { GetBip44EntropyMethodHooks } from './getBip44Entropy';\nimport { getBip44EntropyBuilder } from './getBip44Entropy';\nimport type { GetEntropyHooks } from './getEntropy';\nimport { getEntropyBuilder } from './getEntropy';\nimport type { GetLocaleMethodHooks } from './getLocale';\nimport { getLocaleBuilder } from './getLocale';\nimport type { InvokeSnapMethodHooks } from './invokeSnap';\nimport { invokeSnapBuilder } from './invokeSnap';\nimport type { ManageAccountsMethodHooks } from './manageAccounts';\nimport { manageAccountsBuilder } from './manageAccounts';\nimport type { ManageStateMethodHooks } from './manageState';\nimport { manageStateBuilder } from './manageState';\nimport type { NotifyMethodHooks } from './notify';\nimport { notifyBuilder } from './notify';\n\nexport { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';\nexport { getEncryptionEntropy } from './manageState';\n\nexport type RestrictedMethodHooks = DialogMethodHooks &\n  GetBip32EntropyMethodHooks &\n  GetBip32PublicKeyMethodHooks &\n  GetBip44EntropyMethodHooks &\n  GetEntropyHooks &\n  InvokeSnapMethodHooks &\n  ManageStateMethodHooks &\n  NotifyMethodHooks &\n  ManageAccountsMethodHooks &\n  GetLocaleMethodHooks;\n\nexport const restrictedMethodPermissionBuilders = {\n  [dialogBuilder.targetName]: dialogBuilder,\n  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,\n  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,\n  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,\n  [getEntropyBuilder.targetName]: getEntropyBuilder,\n  [invokeSnapBuilder.targetName]: invokeSnapBuilder,\n  [manageStateBuilder.targetName]: manageStateBuilder,\n  [notifyBuilder.targetName]: notifyBuilder,\n  [manageAccountsBuilder.targetName]: manageAccountsBuilder,\n  [getLocaleBuilder.targetName]: getLocaleBuilder,\n} as const;\n\nexport * from './caveats';\nexport type { DialogApprovalTypes } from './dialog';\nexport { DIALOG_APPROVAL_TYPES } from './dialog';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCO,IAAM,qCAAqC;AAAA,EAChD,CAAC,cAAc,UAAU,GAAG;AAAA,EAC5B,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,yBAAyB,UAAU,GAAG;AAAA,EACvC,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,kBAAkB,UAAU,GAAG;AAAA,EAChC,CAAC,kBAAkB,UAAU,GAAG;AAAA,EAChC,CAAC,mBAAmB,UAAU,GAAG;AAAA,EACjC,CAAC,cAAc,UAAU,GAAG;AAAA,EAC5B,CAAC,sBAAsB,UAAU,GAAG;AAAA,EACpC,CAAC,iBAAiB,UAAU,GAAG;AACjC;","names":[]}

package/dist/chunk-SYUGPLEP.js

@@ -1,32 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/getLocale.ts
-var _permissioncontroller = require('@metamask/permission-controller');
-var methodName = "snap_getLocale";
-var specificationBuilder = ({ allowedCaveats = null, methodHooks: methodHooks2 }) => {
-  return {
-    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-    targetName: methodName,
-    allowedCaveats,
-    methodImplementation: getImplementation(methodHooks2),
-    subjectTypes: [_permissioncontroller.SubjectType.Snap]
-  };
-};
-var methodHooks = {
-  getLocale: true
-};
-var getLocaleBuilder = Object.freeze({
-  targetName: methodName,
-  specificationBuilder,
-  methodHooks
-});
-function getImplementation({ getLocale }) {
-  return async function implementation(_args) {
-    return getLocale();
-  };
-}
-
-
-
-
-
-exports.specificationBuilder = specificationBuilder; exports.getLocaleBuilder = getLocaleBuilder; exports.getImplementation = getImplementation;
-//# sourceMappingURL=chunk-SYUGPLEP.js.map

package/dist/chunk-SYUGPLEP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/getLocale.ts"],"names":["methodHooks"],"mappings":";AAMA,SAAS,gBAAgB,mBAAmB;AAM5C,IAAM,aAAa;AA2BZ,IAAM,uBAIT,CAAC,EAAE,iBAAiB,MAAM,aAAAA,aAAY,MAAmC;AAC3E,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ;AAAA,IACA,sBAAsB,kBAAkBA,YAAW;AAAA,IACnD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAAuD;AAAA,EAC3D,WAAW;AACb;AAEO,IAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AASH,SAAS,kBAAkB,EAAE,UAAU,GAAyB;AACrE,SAAO,eAAe,eACpB,OAC0B;AAC1B,WAAO,UAAU;AAAA,EACnB;AACF","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { GetLocaleResult } from '@metamask/snaps-sdk';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_getLocale';\n\nexport type GetLocaleMethodHooks = {\n  getLocale: () => Promise<string>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: GetLocaleMethodHooks;\n};\n\ntype Specification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_getLocale` permission.\n * `snap_getLocale` allows snaps to get the user selected locale.\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_getLocale` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  SpecificationBuilderOptions,\n  Specification\n> = ({ allowedCaveats = null, methodHooks }: SpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetLocaleMethodHooks> = {\n  getLocale: true,\n};\n\nexport const getLocaleBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getLocale`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getLocale - A function that returns the user selected locale.\n * @returns The user selected locale.\n */\nexport function getImplementation({ getLocale }: GetLocaleMethodHooks) {\n  return async function implementation(\n    _args: RestrictedMethodOptions<RestrictedMethodParameters>,\n  ): Promise<GetLocaleResult> {\n    return getLocale();\n  };\n}\n"]}

package/dist/chunk-T56DKVFS.js

@@ -1,70 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkQMULJEYNjs = require('./chunk-QMULJEYN.js');
-
-// src/endowments/keyring.ts
-var _permissioncontroller = require('@metamask/permission-controller');
-var _rpcerrors = require('@metamask/rpc-errors');
-var _snapsutils = require('@metamask/snaps-utils');
-var _utils = require('@metamask/utils');
-var permissionName = "endowment:keyring" /* Keyring */;
-var specificationBuilder = (_builderOptions) => {
-  return {
-    permissionType: _permissioncontroller.PermissionType.Endowment,
-    targetName: permissionName,
-    allowedCaveats: [
-      _snapsutils.SnapCaveatType.KeyringOrigin,
-      _snapsutils.SnapCaveatType.MaxRequestTime
-    ],
-    endowmentGetter: (_getterOptions) => null,
-    validator: _chunkQMULJEYNjs.createGenericPermissionValidator.call(void 0, [
-      { type: _snapsutils.SnapCaveatType.KeyringOrigin },
-      { type: _snapsutils.SnapCaveatType.MaxRequestTime, optional: true }
-    ]),
-    subjectTypes: [_permissioncontroller.SubjectType.Snap]
-  };
-};
-var keyringEndowmentBuilder = Object.freeze({
-  targetName: permissionName,
-  specificationBuilder
-});
-function validateCaveatOrigins(caveat) {
-  if (!_utils.hasProperty.call(void 0, caveat, "value") || !_utils.isPlainObject.call(void 0, caveat.value)) {
-    throw _rpcerrors.rpcErrors.invalidParams({
-      message: "Invalid keyring origins: Expected a plain object."
-    });
-  }
-  const { value } = caveat;
-  _snapsutils.assertIsKeyringOrigins.call(void 0, value, _rpcerrors.rpcErrors.invalidParams);
-}
-function getKeyringCaveatMapper(value) {
-  return {
-    caveats: [
-      {
-        type: _snapsutils.SnapCaveatType.KeyringOrigin,
-        value
-      }
-    ]
-  };
-}
-function getKeyringCaveatOrigins(permission) {
-  _utils.assert.call(void 0, permission?.caveats);
-  _utils.assert.call(void 0, permission.caveats.length === 1);
-  _utils.assert.call(void 0, permission.caveats[0].type === _snapsutils.SnapCaveatType.KeyringOrigin);
-  const caveat = permission.caveats[0];
-  return caveat.value;
-}
-var keyringCaveatSpecifications = {
-  [_snapsutils.SnapCaveatType.KeyringOrigin]: Object.freeze({
-    type: _snapsutils.SnapCaveatType.KeyringOrigin,
-    validator: (caveat) => validateCaveatOrigins(caveat)
-  })
-};
-
-
-
-
-
-
-exports.keyringEndowmentBuilder = keyringEndowmentBuilder; exports.getKeyringCaveatMapper = getKeyringCaveatMapper; exports.getKeyringCaveatOrigins = getKeyringCaveatOrigins; exports.keyringCaveatSpecifications = keyringCaveatSpecifications;
-//# sourceMappingURL=chunk-T56DKVFS.js.map

package/dist/chunk-T56DKVFS.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endowments/keyring.ts"],"names":[],"mappings":";;;;;AASA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAE1B,SAAS,wBAAwB,sBAAsB;AAEvD,SAAS,QAAQ,aAAa,qBAAqB;AAKnD,IAAM;AAkBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,MACd,eAAe;AAAA,MACf,eAAe;AAAA,IACjB;AAAA,IACA,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,WAAW,iCAAiC;AAAA,MAC1C,EAAE,MAAM,eAAe,cAAc;AAAA,MACrC,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,0BAA0B,OAAO,OAAO;AAAA,EACnD,YAAY;AAAA,EACZ;AACF,CAAU;AASV,SAAS,sBAAsB,QAA6B;AAC1D,MAAI,CAAC,YAAY,QAAQ,OAAO,KAAK,CAAC,cAAc,OAAO,KAAK,GAAG;AACjE,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAClB,yBAAuB,OAAO,UAAU,aAAa;AACvD;AAUO,SAAS,uBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAWO,SAAS,wBACd,YACuB;AACvB,SAAO,YAAY,OAAO;AAC1B,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,aAAa;AAElE,QAAM,SAAS,WAAW,QAAQ,CAAC;AACnC,SAAO,OAAO;AAChB;AAEO,IAAM,8BAGT;AAAA,EACF,CAAC,eAAe,aAAa,GAAG,OAAO,OAAO;AAAA,IAC5C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,sBAAsB,MAAM;AAAA,EAC1E,CAAC;AACH","sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  EndowmentGetterParams,\n  PermissionConstraint,\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { KeyringOrigins } from '@metamask/snaps-utils';\nimport { assertIsKeyringOrigins, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isPlainObject } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.Keyring;\n\ntype KeyringEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => null;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  subjectTypes: readonly SubjectType[];\n}>;\n\n/**\n * `endowment:keyring` returns nothing; it is intended to be used as a flag\n * by the client to detect whether the snap has keyring capabilities.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the keyring endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  KeyringEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.KeyringOrigin,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => null,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.KeyringOrigin },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const keyringEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Validate the value of a caveat. This does not validate the type of the\n * caveat itself, only the value of the caveat.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateCaveatOrigins(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid keyring origins: Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsKeyringOrigins(value, rpcErrors.invalidParams);\n}\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getKeyringCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.KeyringOrigin,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the {@link KeyringOrigins} caveat value from a\n * permission.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value.\n * @throws If the permission does not have a valid {@link KeyringOrigins}\n * caveat.\n */\nexport function getKeyringCaveatOrigins(\n  permission?: PermissionConstraint,\n): KeyringOrigins | null {\n  assert(permission?.caveats);\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.KeyringOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, KeyringOrigins>;\n  return caveat.value;\n}\n\nexport const keyringCaveatSpecifications: Record<\n  SnapCaveatType.KeyringOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.KeyringOrigin]: Object.freeze({\n    type: SnapCaveatType.KeyringOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveatOrigins(caveat),\n  }),\n};\n"]}

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