@metamask/snaps-rpc-methods 6.0.0 → 7.0.1

package/dist/chunk-LIWV3FMY.js

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkQMULJEYNjs = require('./chunk-QMULJEYN.js');
+
+// src/endowments/rpc.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 targetName = "endowment:rpc" /* Rpc */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.Endowment,
+    targetName,
+    allowedCaveats: [_snapsutils.SnapCaveatType.RpcOrigin, _snapsutils.SnapCaveatType.MaxRequestTime],
+    endowmentGetter: (_getterOptions) => void 0,
+    validator: _chunkQMULJEYNjs.createGenericPermissionValidator.call(void 0, [
+      { type: _snapsutils.SnapCaveatType.RpcOrigin },
+      { type: _snapsutils.SnapCaveatType.MaxRequestTime, optional: true }
+    ]),
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var rpcEndowmentBuilder = Object.freeze({
+  targetName,
+  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 JSON-RPC origins: Expected a plain object."
+    });
+  }
+  const { value } = caveat;
+  _snapsutils.assertIsRpcOrigins.call(void 0, value, _rpcerrors.rpcErrors.invalidParams);
+}
+function getRpcCaveatMapper(value) {
+  return {
+    caveats: [
+      {
+        type: _snapsutils.SnapCaveatType.RpcOrigin,
+        value
+      }
+    ]
+  };
+}
+function getRpcCaveatOrigins(permission) {
+  const caveats = permission?.caveats?.filter(
+    (caveat2) => caveat2.type === _snapsutils.SnapCaveatType.RpcOrigin
+  );
+  _utils.assert.call(void 0, caveats);
+  _utils.assert.call(void 0, caveats.length === 1);
+  const caveat = caveats[0];
+  return caveat.value;
+}
+var rpcCaveatSpecifications = {
+  [_snapsutils.SnapCaveatType.RpcOrigin]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.RpcOrigin,
+    validator: (caveat) => validateCaveatOrigins(caveat)
+  })
+};
+
+
+
+
+
+
+exports.rpcEndowmentBuilder = rpcEndowmentBuilder; exports.getRpcCaveatMapper = getRpcCaveatMapper; exports.getRpcCaveatOrigins = getRpcCaveatOrigins; exports.rpcCaveatSpecifications = rpcCaveatSpecifications;
+//# sourceMappingURL=chunk-LIWV3FMY.js.map

package/dist/chunk-LIWV3FMY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/rpc.ts"],"names":["caveat"],"mappings":";;;;;AASA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAE1B,SAAS,oBAAoB,sBAAsB;AAEnD,SAAS,aAAa,eAAe,cAAc;AAKnD,IAAM;AAqBN,IAAM,uBAIF,CAAC,oBAA4C;AAC/C,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,gBAAgB,CAAC,eAAe,WAAW,eAAe,cAAc;AAAA,IACxE,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,WAAW,iCAAiC;AAAA,MAC1C,EAAE,MAAM,eAAe,UAAU;AAAA,MACjC,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,sBAAsB,OAAO,OAAO;AAAA,EAC/C;AAAA,EACA;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,qBAAmB,OAAO,UAAU,aAAa;AACnD;AAUO,SAAS,mBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AASO,SAAS,oBACd,YACmB;AACnB,QAAM,UAAU,YAAY,SAAS;AAAA,IACnC,CAACA,YAAWA,QAAO,SAAS,eAAe;AAAA,EAC7C;AACA,SAAO,OAAO;AACd,SAAO,QAAQ,WAAW,CAAC;AAE3B,QAAM,SAAS,QAAQ,CAAC;AACxB,SAAO,OAAO;AAChB;AAEO,IAAM,0BAGT;AAAA,EACF,CAAC,eAAe,SAAS,GAAG,OAAO,OAAO;AAAA,IACxC,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 { RpcOrigins } from '@metamask/snaps-utils';\nimport { assertIsRpcOrigins, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { hasProperty, isPlainObject, assert } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst targetName = SnapEndowments.Rpc;\n\ntype RpcSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof targetName;\n  endowmentGetter: (_options?: any) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  subjectTypes: readonly SubjectType[];\n}>;\n\ntype RpcSpecificationBuilderOptions = {\n  // Empty for now.\n};\n\n/**\n * The specification builder for the JSON-RPC endowment permission.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the JSON-RPC endowment permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  RpcSpecificationBuilderOptions,\n  RpcSpecification\n> = (_builderOptions?: any): RpcSpecification => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName,\n    allowedCaveats: [SnapCaveatType.RpcOrigin, SnapCaveatType.MaxRequestTime],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.RpcOrigin },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const rpcEndowmentBuilder = Object.freeze({\n  targetName,\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 JSON-RPC origins: Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsRpcOrigins(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 getRpcCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.RpcOrigin,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the {@link RpcOrigins} caveat value from a 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 RpcOrigins} caveat.\n */\nexport function getRpcCaveatOrigins(\n  permission?: PermissionConstraint,\n): RpcOrigins | null {\n  const caveats = permission?.caveats?.filter(\n    (caveat) => caveat.type === SnapCaveatType.RpcOrigin,\n  );\n  assert(caveats);\n  assert(caveats.length === 1);\n\n  const caveat = caveats[0] as Caveat<string, RpcOrigins>;\n  return caveat.value;\n}\n\nexport const rpcCaveatSpecifications: Record<\n  SnapCaveatType.RpcOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.RpcOrigin]: Object.freeze({\n    type: SnapCaveatType.RpcOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveatOrigins(caveat),\n  }),\n};\n"]}

package/dist/chunk-LR7UR4YU.mjs

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

package/dist/chunk-LR7UR4YU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getBip44Entropy.ts"],"sourcesContent":["import { BIP44CoinTypeNode } from '@metamask/key-tree';\nimport type {\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  GetBip44EntropyParams,\n  GetBip44EntropyResult,\n} from '@metamask/snaps-sdk';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst targetName = 'snap_getBip44Entropy';\n\nexport type GetBip44EntropyMethodHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\ntype GetBip44EntropySpecificationBuilderOptions = {\n  methodHooks: GetBip44EntropyMethodHooks;\n};\n\ntype GetBip44EntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip44EntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * The specification builder for the `snap_getBip44Entropy` permission.\n * `snap_getBip44Entropy_*` lets the Snap control private keys for a particular\n * BIP-32 coin type.\n *\n * @param options - The specification builder options.\n * @param options.methodHooks - The RPC method hooks needed by the method\n * implementation.\n * @returns The specification for the `snap_getBip44Entropy` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip44EntropySpecificationBuilderOptions,\n  GetBip44EntropySpecification\n> = ({ methodHooks }: GetBip44EntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedCoinTypes],\n    methodImplementation: getBip44EntropyImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (\n        caveats?.length !== 1 ||\n        caveats[0].type !== SnapCaveatType.PermittedCoinTypes\n      ) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.PermittedCoinTypes}\" caveat.`,\n        });\n      }\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetBip44EntropyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip44EntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip44Entropy`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase\n * of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @returns The method implementation which returns a `BIP44CoinTypeNode`.\n * @throws If the params are invalid.\n */\nexport function getBip44EntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip44EntropyMethodHooks) {\n  return async function getBip44Entropy(\n    args: RestrictedMethodOptions<GetBip44EntropyParams>,\n  ): Promise<GetBip44EntropyResult> {\n    await getUnlockPromise(true);\n\n    // `args.params` is validated by the decorator, so it's safe to assert here.\n    const params = args.params as GetBip44EntropyParams;\n\n    const node = await BIP44CoinTypeNode.fromDerivationPath([\n      await getMnemonic(),\n      `bip32:44'`,\n      `bip32:${params.coinType}'`,\n    ]);\n\n    return node.toJSON();\n  };\n}\n"],"mappings":";AAAA,SAAS,yBAAyB;AAOlC,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAK1B,SAAS,sBAAsB;AAK/B,IAAM,aAAa;AAsCnB,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAAkD;AACnE,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,gBAAgB,CAAC,eAAe,kBAAkB;AAAA,IAClD,sBAAsB,8BAA8BA,YAAW;AAAA,IAC/D,WAAW,CAAC,EAAE,QAAQ,MAAM;AAC1B,UACE,SAAS,WAAW,KACpB,QAAQ,CAAC,EAAE,SAAS,eAAe,oBACnC;AACA,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS,sBAAsB,eAAe,kBAAkB;AAAA,QAClE,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAA6D;AAAA,EACjE,aAAa;AAAA,EACb,kBAAkB;AACpB;AAEO,IAAM,yBAAyB,OAAO,OAAO;AAAA,EAClD;AAAA,EACA;AAAA,EACA;AACF,CAAU;AAcH,SAAS,8BAA8B;AAAA,EAC5C;AAAA,EACA;AACF,GAA+B;AAC7B,SAAO,eAAe,gBACpB,MACgC;AAChC,UAAM,iBAAiB,IAAI;AAG3B,UAAM,SAAS,KAAK;AAEpB,UAAM,OAAO,MAAM,kBAAkB,mBAAmB;AAAA,MACtD,MAAM,YAAY;AAAA,MAClB;AAAA,MACA,SAAS,OAAO,QAAQ;AAAA,IAC1B,CAAC;AAED,WAAO,KAAK,OAAO;AAAA,EACrB;AACF;","names":["methodHooks"]}

package/dist/chunk-LVTN25J2.js

@@ -0,0 +1,49 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkVUA6ICJOjs = require('./chunk-VUA6ICJO.js');
+
+
+var _chunkQ5W3YGEBjs = require('./chunk-Q5W3YGEB.js');
+
+
+var _chunkSYUGPLEPjs = require('./chunk-SYUGPLEP.js');
+
+
+var _chunkP74WXDY4js = require('./chunk-P74WXDY4.js');
+
+
+var _chunkKO4MKRYZjs = require('./chunk-KO4MKRYZ.js');
+
+
+var _chunkQDZAWH6Fjs = require('./chunk-QDZAWH6F.js');
+
+
+var _chunkGYZV5UBDjs = require('./chunk-GYZV5UBD.js');
+
+
+var _chunkS7AR3ROHjs = require('./chunk-S7AR3ROH.js');
+
+
+var _chunkLGUJMQC7js = require('./chunk-LGUJMQC7.js');
+
+
+var _chunkFFHVA6PPjs = require('./chunk-FFHVA6PP.js');
+
+// src/restricted/index.ts
+var restrictedMethodPermissionBuilders = {
+  [_chunkGYZV5UBDjs.dialogBuilder.targetName]: _chunkGYZV5UBDjs.dialogBuilder,
+  [_chunkS7AR3ROHjs.getBip32EntropyBuilder.targetName]: _chunkS7AR3ROHjs.getBip32EntropyBuilder,
+  [_chunkLGUJMQC7js.getBip32PublicKeyBuilder.targetName]: _chunkLGUJMQC7js.getBip32PublicKeyBuilder,
+  [_chunkVUA6ICJOjs.getBip44EntropyBuilder.targetName]: _chunkVUA6ICJOjs.getBip44EntropyBuilder,
+  [_chunkQ5W3YGEBjs.getEntropyBuilder.targetName]: _chunkQ5W3YGEBjs.getEntropyBuilder,
+  [_chunkFFHVA6PPjs.invokeSnapBuilder.targetName]: _chunkFFHVA6PPjs.invokeSnapBuilder,
+  [_chunkKO4MKRYZjs.manageStateBuilder.targetName]: _chunkKO4MKRYZjs.manageStateBuilder,
+  [_chunkQDZAWH6Fjs.notifyBuilder.targetName]: _chunkQDZAWH6Fjs.notifyBuilder,
+  [_chunkP74WXDY4js.manageAccountsBuilder.targetName]: _chunkP74WXDY4js.manageAccountsBuilder,
+  [_chunkSYUGPLEPjs.getLocaleBuilder.targetName]: _chunkSYUGPLEPjs.getLocaleBuilder
+};
+
+
+
+exports.restrictedMethodPermissionBuilders = restrictedMethodPermissionBuilders;
+//# sourceMappingURL=chunk-LVTN25J2.js.map

package/dist/chunk-LVTN25J2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/index.ts"],"names":[],"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","sourcesContent":["import type { DialogMethodHooks } from './dialog';\nimport { dialogBuilder } from './dialog';\nimport type { GetBip32EntropyMethodHooks } from './getBip32Entropy';\nimport { getBip32EntropyBuilder } from './getBip32Entropy';\nimport type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';\nimport { getBip32PublicKeyBuilder } from './getBip32PublicKey';\nimport type { GetBip44EntropyMethodHooks } from './getBip44Entropy';\nimport { getBip44EntropyBuilder } from './getBip44Entropy';\nimport type { GetEntropyHooks } from './getEntropy';\nimport { getEntropyBuilder } from './getEntropy';\nimport type { GetLocaleMethodHooks } from './getLocale';\nimport { getLocaleBuilder } from './getLocale';\nimport type { InvokeSnapMethodHooks } from './invokeSnap';\nimport { invokeSnapBuilder } from './invokeSnap';\nimport type { ManageAccountsMethodHooks } from './manageAccounts';\nimport { manageAccountsBuilder } from './manageAccounts';\nimport type { ManageStateMethodHooks } from './manageState';\nimport { manageStateBuilder } from './manageState';\nimport type { NotifyMethodHooks } from './notify';\nimport { notifyBuilder } from './notify';\n\nexport { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';\nexport { getEncryptionKey } from './manageState';\n\nexport type RestrictedMethodHooks = DialogMethodHooks &\n  GetBip32EntropyMethodHooks &\n  GetBip32PublicKeyMethodHooks &\n  GetBip44EntropyMethodHooks &\n  GetEntropyHooks &\n  InvokeSnapMethodHooks &\n  ManageStateMethodHooks &\n  NotifyMethodHooks &\n  ManageAccountsMethodHooks &\n  GetLocaleMethodHooks;\n\nexport const restrictedMethodPermissionBuilders = {\n  [dialogBuilder.targetName]: dialogBuilder,\n  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,\n  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,\n  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,\n  [getEntropyBuilder.targetName]: getEntropyBuilder,\n  [invokeSnapBuilder.targetName]: invokeSnapBuilder,\n  [manageStateBuilder.targetName]: manageStateBuilder,\n  [notifyBuilder.targetName]: notifyBuilder,\n  [manageAccountsBuilder.targetName]: manageAccountsBuilder,\n  [getLocaleBuilder.targetName]: getLocaleBuilder,\n} as const;\n\nexport * from './caveats';\n"]}

package/dist/chunk-MVG4B2HM.mjs

@@ -0,0 +1,21 @@
+// src/endowments/home-page.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+var permissionName = "endowment:page-home" /* HomePage */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: null,
+    endowmentGetter: (_getterOptions) => void 0,
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var homePageEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+
+export {
+  homePageEndowmentBuilder
+};
+//# sourceMappingURL=chunk-MVG4B2HM.mjs.map

package/dist/chunk-MVG4B2HM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/home-page.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.HomePage;\n\ntype HomePageEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:page-home` returns nothing; it is intended to be used as a\n * flag by the snap controller to detect whether the snap has the capability to\n * use the snap home page feature.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the `snap-pages` endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  HomePageEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const homePageEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAK5C,IAAM;AAiBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,2BAA2B,OAAO,OAAO;AAAA,EACpD,YAAY;AAAA,EACZ;AACF,CAAU;","names":[]}

package/dist/chunk-MXCJWR45.mjs

@@ -0,0 +1,45 @@
+// src/permitted/invokeSnapSugar.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { isObject } from "@metamask/utils";
+var invokeSnapSugarHandler = {
+  methodNames: ["wallet_invokeSnap"],
+  implementation: invokeSnapSugar,
+  hookNames: void 0
+};
+function invokeSnapSugar(req, _res, next, end) {
+  let params;
+  try {
+    params = getValidatedParams(req.params);
+  } catch (error) {
+    return end(error);
+  }
+  req.method = "wallet_snap";
+  req.params = params;
+  return next();
+}
+function getValidatedParams(params) {
+  if (!isObject(params)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected params to be a single object."
+    });
+  }
+  const { snapId, request } = params;
+  if (!snapId || typeof snapId !== "string" || snapId === "") {
+    throw rpcErrors.invalidParams({
+      message: "Must specify a valid snap ID."
+    });
+  }
+  if (!isObject(request)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected request to be a single object."
+    });
+  }
+  return params;
+}
+
+export {
+  invokeSnapSugarHandler,
+  invokeSnapSugar,
+  getValidatedParams
+};
+//# sourceMappingURL=chunk-MXCJWR45.mjs.map

package/dist/chunk-MXCJWR45.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/invokeSnapSugar.ts"],"sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  JsonRpcEngineNextCallback,\n} from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { InvokeSnapParams, InvokeSnapResult } from '@metamask/snaps-sdk';\nimport type { JsonRpcRequest } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\n/**\n * `wallet_invokeSnap` attempts to invoke an RPC method of the specified Snap.\n */\nexport const invokeSnapSugarHandler: PermittedHandlerExport<\n  void,\n  InvokeSnapParams,\n  InvokeSnapResult\n> = {\n  methodNames: ['wallet_invokeSnap'],\n  implementation: invokeSnapSugar,\n  hookNames: undefined,\n};\n\n/**\n * The `wallet_invokeSnap` method implementation.\n * Reroutes incoming JSON-RPC requests that are targeting snaps, by modifying the method and params.\n *\n * @param req - The JSON-RPC request object.\n * @param _res - The JSON-RPC response object. Not used by this\n * function.\n * @param next - The `json-rpc-engine` \"next\" callback.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @returns Nothing.\n * @throws If the params are invalid.\n */\nexport function invokeSnapSugar(\n  req: JsonRpcRequest<InvokeSnapParams>,\n  _res: unknown,\n  next: JsonRpcEngineNextCallback,\n  end: JsonRpcEngineEndCallback,\n): void {\n  let params: InvokeSnapParams;\n  try {\n    params = getValidatedParams(req.params);\n  } catch (error) {\n    return end(error);\n  }\n\n  req.method = 'wallet_snap';\n  req.params = params;\n  return next();\n}\n\n/**\n * Validates the wallet_invokeSnap 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 method parameter object.\n */\nexport function getValidatedParams(params: unknown): InvokeSnapParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { snapId, request } = params;\n\n  if (!snapId || typeof snapId !== 'string' || snapId === '') {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid snap ID.',\n    });\n  }\n\n  if (!isObject(request)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected request to be a single object.',\n    });\n  }\n\n  return params as InvokeSnapParams;\n}\n"],"mappings":";AAKA,SAAS,iBAAiB;AAG1B,SAAS,gBAAgB;AAKlB,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,mBAAmB;AAAA,EACjC,gBAAgB;AAAA,EAChB,WAAW;AACb;AAcO,SAAS,gBACd,KACA,MACA,MACA,KACM;AACN,MAAI;AACJ,MAAI;AACF,aAAS,mBAAmB,IAAI,MAAM;AAAA,EACxC,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,MAAI,SAAS;AACb,MAAI,SAAS;AACb,SAAO,KAAK;AACd;AASO,SAAS,mBAAmB,QAAmC;AACpE,MAAI,CAAC,SAAS,MAAM,GAAG;AACrB,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,QAAQ,QAAQ,IAAI;AAE5B,MAAI,CAAC,UAAU,OAAO,WAAW,YAAY,WAAW,IAAI;AAC1D,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,MAAI,CAAC,SAAS,OAAO,GAAG;AACtB,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-MXPVC2XP.mjs

@@ -0,0 +1,105 @@
+import {
+  WALLET_SNAP_PERMISSION_KEY
+} from "./chunk-VVBTXSID.mjs";
+
+// src/permitted/requestSnaps.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import {
+  SnapCaveatType,
+  verifyRequestedSnapPermissions
+} from "@metamask/snaps-utils";
+import { hasProperty, isObject } from "@metamask/utils";
+var hookNames = {
+  installSnaps: true,
+  requestPermissions: true,
+  getPermissions: true
+};
+var requestSnapsHandler = {
+  methodNames: ["wallet_requestSnaps"],
+  implementation: requestSnapsImplementation,
+  hookNames
+};
+function hasRequestedSnaps(existingPermissions, requestedSnaps) {
+  const snapIdCaveat = existingPermissions[WALLET_SNAP_PERMISSION_KEY]?.caveats?.find(
+    (caveat) => caveat.type === SnapCaveatType.SnapIds
+  );
+  const permittedSnaps = snapIdCaveat?.value;
+  if (isObject(permittedSnaps)) {
+    return Object.keys(requestedSnaps).every(
+      (requestedSnap) => hasProperty(permittedSnaps, requestedSnap)
+    );
+  }
+  return false;
+}
+function getSnapPermissionsRequest(existingPermissions, requestedPermissions) {
+  verifyRequestedSnapPermissions(requestedPermissions);
+  if (!existingPermissions[WALLET_SNAP_PERMISSION_KEY]) {
+    return requestedPermissions;
+  }
+  const snapIdCaveat = existingPermissions[WALLET_SNAP_PERMISSION_KEY].caveats?.find(
+    (caveat) => caveat.type === SnapCaveatType.SnapIds
+  );
+  const permittedSnaps = snapIdCaveat?.value ?? {};
+  const requestedSnaps = requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value;
+  const snapIdSet = /* @__PURE__ */ new Set([
+    ...Object.keys(permittedSnaps),
+    ...Object.keys(requestedSnaps)
+  ]);
+  const mergedCaveatValue = [...snapIdSet].reduce(
+    (request, snapId) => {
+      request[snapId] = requestedSnaps[snapId] ?? permittedSnaps[snapId];
+      return request;
+    },
+    {}
+  );
+  requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value = mergedCaveatValue;
+  return requestedPermissions;
+}
+async function requestSnapsImplementation(req, res, _next, end, { installSnaps, requestPermissions, getPermissions }) {
+  const requestedSnaps = req.params;
+  if (!isObject(requestedSnaps)) {
+    return end(
+      rpcErrors.invalidParams({
+        message: '"params" must be an object.'
+      })
+    );
+  }
+  try {
+    if (Object.keys(requestedSnaps).length === 0) {
+      return end(
+        rpcErrors.invalidParams({
+          message: "Request must have at least one requested snap."
+        })
+      );
+    }
+    const requestedPermissions = {
+      [WALLET_SNAP_PERMISSION_KEY]: {
+        caveats: [{ type: SnapCaveatType.SnapIds, value: requestedSnaps }]
+      }
+    };
+    const existingPermissions = await getPermissions();
+    if (!existingPermissions) {
+      const [, metadata] = await requestPermissions(requestedPermissions);
+      res.result = metadata.data[WALLET_SNAP_PERMISSION_KEY];
+    } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {
+      res.result = await installSnaps(requestedSnaps);
+    } else {
+      const mergedPermissionsRequest = getSnapPermissionsRequest(
+        existingPermissions,
+        requestedPermissions
+      );
+      const [, metadata] = await requestPermissions(mergedPermissionsRequest);
+      res.result = metadata.data[WALLET_SNAP_PERMISSION_KEY];
+    }
+  } catch (error) {
+    res.error = error;
+  }
+  return end();
+}
+
+export {
+  requestSnapsHandler,
+  hasRequestedSnaps,
+  getSnapPermissionsRequest
+};
+//# sourceMappingURL=chunk-MXPVC2XP.mjs.map

package/dist/chunk-MXPVC2XP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/requestSnaps.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type {\n  PermissionConstraint,\n  RequestedPermissions,\n  Caveat,\n  PermittedHandlerExport,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  RequestSnapsParams,\n  RequestSnapsResult,\n} from '@metamask/snaps-sdk';\nimport type { SnapsPermissionRequest } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  verifyRequestedSnapPermissions,\n} from '@metamask/snaps-utils';\nimport type {\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n  Json,\n} from '@metamask/utils';\nimport { hasProperty, isObject } from '@metamask/utils';\n\nimport { WALLET_SNAP_PERMISSION_KEY } from '../restricted/invokeSnap';\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<RequestSnapsHooks> = {\n  installSnaps: true,\n  requestPermissions: true,\n  getPermissions: true,\n};\n\n/**\n * `wallet_requestSnaps` installs the requested Snaps and requests permission to use them if necessary.\n */\nexport const requestSnapsHandler: PermittedHandlerExport<\n  RequestSnapsHooks,\n  RequestSnapsParams,\n  RequestSnapsResult\n> = {\n  methodNames: ['wallet_requestSnaps'],\n  implementation: requestSnapsImplementation,\n  hookNames,\n};\n\nexport type RequestSnapsHooks = {\n  /**\n   * Installs the requested snaps if they are permitted.\n   */\n  installSnaps: (\n    requestedSnaps: RequestSnapsParams,\n  ) => Promise<RequestSnapsResult>;\n\n  /**\n   * Initiates a permission request for the requesting origin.\n   *\n   * @returns The result of the permissions request.\n   */\n  requestPermissions: (\n    permissions: RequestedPermissions,\n  ) => Promise<\n    [\n      Record<string, PermissionConstraint>,\n      { data: Record<string, unknown>; id: string; origin: string },\n    ]\n  >;\n\n  /**\n   * Gets the current permissions for the requesting origin.\n   *\n   * @returns The current permissions of the requesting origin.\n   */\n  getPermissions: () => Promise<\n    Record<string, PermissionConstraint> | undefined\n  >;\n};\n\n/**\n * Checks whether an origin has existing `wallet_snap` permission and\n * whether or not it has the requested snapIds caveat.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedSnaps - The requested snaps.\n * @returns True if the existing permissions satisfy the requested snaps, otherwise false.\n */\nexport function hasRequestedSnaps(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedSnaps: Record<string, unknown>,\n): boolean {\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ]?.caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = snapIdCaveat?.value;\n  if (isObject(permittedSnaps)) {\n    return Object.keys(requestedSnaps).every((requestedSnap) =>\n      hasProperty(permittedSnaps, requestedSnap),\n    );\n  }\n  return false;\n}\n\n/**\n * Constructs a valid permission request with merged caveats based on existing permissions\n * and the requested snaps.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedPermissions - The permission request passed into `requestPermissions`.\n * @returns `requestedPermissions`.\n */\nexport function getSnapPermissionsRequest(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedPermissions: unknown,\n): SnapsPermissionRequest {\n  verifyRequestedSnapPermissions(requestedPermissions);\n\n  if (!existingPermissions[WALLET_SNAP_PERMISSION_KEY]) {\n    return requestedPermissions;\n  }\n\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ].caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = (snapIdCaveat?.value as Record<string, Json>) ?? {};\n\n  const requestedSnaps =\n    requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value;\n\n  const snapIdSet = new Set([\n    ...Object.keys(permittedSnaps),\n    ...Object.keys(requestedSnaps),\n  ]);\n\n  const mergedCaveatValue = [...snapIdSet].reduce<Record<string, Json>>(\n    (request, snapId) => {\n      request[snapId] = requestedSnaps[snapId] ?? permittedSnaps[snapId];\n      return request;\n    },\n    {},\n  );\n\n  requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value =\n    mergedCaveatValue;\n\n  return requestedPermissions;\n}\n\n/**\n * The `wallet_requestSnaps` method implementation.\n * Tries to install the requested snaps and adds them to the JSON-RPC response.\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.installSnaps - A function that tries to install a given snap, prompting the user if necessary.\n * @param hooks.requestPermissions - A function that requests permissions on\n * behalf of a subject.\n * @param hooks.getPermissions - A function that gets the current permissions.\n * @returns A promise that resolves once the JSON-RPC response has been modified.\n * @throws If the params are invalid.\n */\nasync function requestSnapsImplementation(\n  req: JsonRpcRequest<RequestSnapsParams>,\n  res: PendingJsonRpcResponse<RequestSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { installSnaps, requestPermissions, getPermissions }: RequestSnapsHooks,\n): Promise<void> {\n  const requestedSnaps = req.params;\n  if (!isObject(requestedSnaps)) {\n    return end(\n      rpcErrors.invalidParams({\n        message: '\"params\" must be an object.',\n      }),\n    );\n  }\n\n  try {\n    if (Object.keys(requestedSnaps).length === 0) {\n      return end(\n        rpcErrors.invalidParams({\n          message: 'Request must have at least one requested snap.',\n        }),\n      );\n    }\n\n    const requestedPermissions = {\n      [WALLET_SNAP_PERMISSION_KEY]: {\n        caveats: [{ type: SnapCaveatType.SnapIds, value: requestedSnaps }],\n      },\n    } as RequestedPermissions;\n    const existingPermissions = await getPermissions();\n\n    if (!existingPermissions) {\n      const [, metadata] = await requestPermissions(requestedPermissions);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as RequestSnapsResult;\n    } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {\n      res.result = await installSnaps(requestedSnaps);\n    } else {\n      const mergedPermissionsRequest = getSnapPermissionsRequest(\n        existingPermissions,\n        requestedPermissions,\n      );\n\n      const [, metadata] = await requestPermissions(mergedPermissionsRequest);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as RequestSnapsResult;\n    }\n  } catch (error) {\n    res.error = error;\n  }\n\n  return end();\n}\n"],"mappings":";;;;;AAOA,SAAS,iBAAiB;AAM1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP,SAAS,aAAa,gBAAgB;AAKtC,IAAM,YAAkD;AAAA,EACtD,cAAc;AAAA,EACd,oBAAoB;AAAA,EACpB,gBAAgB;AAClB;AAKO,IAAM,sBAIT;AAAA,EACF,aAAa,CAAC,qBAAqB;AAAA,EACnC,gBAAgB;AAAA,EAChB;AACF;AA0CO,SAAS,kBACd,qBACA,gBACS;AACT,QAAM,eAAe,oBACnB,0BACF,GAAG,SAAS;AAAA,IACV,CAAC,WAAiC,OAAO,SAAS,eAAe;AAAA,EACnE;AAEA,QAAM,iBAAiB,cAAc;AACrC,MAAI,SAAS,cAAc,GAAG;AAC5B,WAAO,OAAO,KAAK,cAAc,EAAE;AAAA,MAAM,CAAC,kBACxC,YAAY,gBAAgB,aAAa;AAAA,IAC3C;AAAA,EACF;AACA,SAAO;AACT;AAUO,SAAS,0BACd,qBACA,sBACwB;AACxB,iCAA+B,oBAAoB;AAEnD,MAAI,CAAC,oBAAoB,0BAA0B,GAAG;AACpD,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,oBACnB,0BACF,EAAE,SAAS;AAAA,IACT,CAAC,WAAiC,OAAO,SAAS,eAAe;AAAA,EACnE;AAEA,QAAM,iBAAkB,cAAc,SAAkC,CAAC;AAEzE,QAAM,iBACJ,qBAAqB,0BAA0B,EAAE,QAAQ,CAAC,EAAE;AAE9D,QAAM,YAAY,oBAAI,IAAI;AAAA,IACxB,GAAG,OAAO,KAAK,cAAc;AAAA,IAC7B,GAAG,OAAO,KAAK,cAAc;AAAA,EAC/B,CAAC;AAED,QAAM,oBAAoB,CAAC,GAAG,SAAS,EAAE;AAAA,IACvC,CAAC,SAAS,WAAW;AACnB,cAAQ,MAAM,IAAI,eAAe,MAAM,KAAK,eAAe,MAAM;AACjE,aAAO;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH;AAEA,uBAAqB,0BAA0B,EAAE,QAAQ,CAAC,EAAE,QAC1D;AAEF,SAAO;AACT;AAmBA,eAAe,2BACb,KACA,KACA,OACA,KACA,EAAE,cAAc,oBAAoB,eAAe,GACpC;AACf,QAAM,iBAAiB,IAAI;AAC3B,MAAI,CAAC,SAAS,cAAc,GAAG;AAC7B,WAAO;AAAA,MACL,UAAU,cAAc;AAAA,QACtB,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI;AACF,QAAI,OAAO,KAAK,cAAc,EAAE,WAAW,GAAG;AAC5C,aAAO;AAAA,QACL,UAAU,cAAc;AAAA,UACtB,SAAS;AAAA,QACX,CAAC;AAAA,MACH;AAAA,IACF;AAEA,UAAM,uBAAuB;AAAA,MAC3B,CAAC,0BAA0B,GAAG;AAAA,QAC5B,SAAS,CAAC,EAAE,MAAM,eAAe,SAAS,OAAO,eAAe,CAAC;AAAA,MACnE;AAAA,IACF;AACA,UAAM,sBAAsB,MAAM,eAAe;AAEjD,QAAI,CAAC,qBAAqB;AACxB,YAAM,CAAC,EAAE,QAAQ,IAAI,MAAM,mBAAmB,oBAAoB;AAClE,UAAI,SAAS,SAAS,KACpB,0BACF;AAAA,IACF,WAAW,kBAAkB,qBAAqB,cAAc,GAAG;AACjE,UAAI,SAAS,MAAM,aAAa,cAAc;AAAA,IAChD,OAAO;AACL,YAAM,2BAA2B;AAAA,QAC/B;AAAA,QACA;AAAA,MACF;AAEA,YAAM,CAAC,EAAE,QAAQ,IAAI,MAAM,mBAAmB,wBAAwB;AACtE,UAAI,SAAS,SAAS,KACpB,0BACF;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,QAAI,QAAQ;AAAA,EACd;AAEA,SAAO,IAAI;AACb;","names":[]}

package/dist/chunk-NP3KGMVC.js

@@ -0,0 +1,47 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/getFile.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapssdk = require('@metamask/snaps-sdk');
+var _utils = require('@metamask/utils');
+var _superstruct = require('superstruct');
+var GetFileArgsStruct = _superstruct.object.call(void 0, {
+  path: _superstruct.string.call(void 0, ),
+  encoding: _superstruct.optional.call(void 0, 
+    _superstruct.union.call(void 0, [
+      _snapssdk.enumValue.call(void 0, _snapssdk.AuxiliaryFileEncoding.Base64),
+      _snapssdk.enumValue.call(void 0, _snapssdk.AuxiliaryFileEncoding.Hex),
+      _snapssdk.enumValue.call(void 0, _snapssdk.AuxiliaryFileEncoding.Utf8)
+    ])
+  )
+});
+var hookNames = {
+  getSnapFile: true
+};
+var getFileHandler = {
+  methodNames: ["snap_getFile"],
+  implementation,
+  hookNames
+};
+async function implementation(req, res, _next, end, { getSnapFile }) {
+  const { params } = req;
+  _utils.assertStruct.call(void 0, 
+    params,
+    GetFileArgsStruct,
+    'Invalid "snap_getFile" parameters',
+    _rpcerrors.rpcErrors.invalidParams
+  );
+  try {
+    res.result = await getSnapFile(
+      params.path,
+      params.encoding ?? _snapssdk.AuxiliaryFileEncoding.Base64
+    );
+  } catch (error) {
+    return end(error);
+  }
+  return end();
+}
+
+
+
+
+exports.GetFileArgsStruct = GetFileArgsStruct; exports.getFileHandler = getFileHandler;
+//# sourceMappingURL=chunk-NP3KGMVC.js.map

package/dist/chunk-NP3KGMVC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/getFile.ts"],"names":[],"mappings":";AAEA,SAAS,iBAAiB;AAE1B,SAAS,uBAAuB,iBAAiB;AAGjD,SAAS,oBAAoB;AAC7B,SAAS,QAAQ,UAAU,QAAQ,aAAa;AAIzC,IAAM,oBAAoB,OAAO;AAAA,EACtC,MAAM,OAAO;AAAA,EACb,UAAU;AAAA,IACR,MAAM;AAAA,MACJ,UAAU,sBAAsB,MAAM;AAAA,MACtC,UAAU,sBAAsB,GAAG;AAAA,MACnC,UAAU,sBAAsB,IAAI;AAAA,IACtC,CAAC;AAAA,EACH;AACF,CAAC;AAOD,IAAM,YAA6C;AAAA,EACjD,aAAa;AACf;AAEO,IAAM,iBAIT;AAAA,EACF,aAAa,CAAC,cAAc;AAAA,EAC5B;AAAA,EACA;AACF;AAqBA,eAAe,eACb,KACA,KACA,OACA,KACA,EAAE,YAAY,GACC;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AAEA,MAAI;AACF,QAAI,SAAS,MAAM;AAAA,MACjB,OAAO;AAAA,MACP,OAAO,YAAY,sBAAsB;AAAA,IAC3C;AAAA,EACF,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { GetFileParams, GetFileResult } from '@metamask/snaps-sdk';\nimport { AuxiliaryFileEncoding, enumValue } from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { object, optional, string, union } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const GetFileArgsStruct = object({\n  path: string(),\n  encoding: optional(\n    union([\n      enumValue(AuxiliaryFileEncoding.Base64),\n      enumValue(AuxiliaryFileEncoding.Hex),\n      enumValue(AuxiliaryFileEncoding.Utf8),\n    ]),\n  ),\n});\n\nexport type InferredGetFileParams = InferMatching<\n  typeof GetFileArgsStruct,\n  GetFileParams\n>;\n\nconst hookNames: MethodHooksObject<GetFileHooks> = {\n  getSnapFile: true,\n};\n\nexport const getFileHandler: PermittedHandlerExport<\n  GetFileHooks,\n  InferredGetFileParams,\n  string\n> = {\n  methodNames: ['snap_getFile'],\n  implementation,\n  hookNames,\n};\n\nexport type GetFileHooks = {\n  getSnapFile: (\n    path: InferredGetFileParams['path'],\n    encoding: InferredGetFileParams['encoding'],\n  ) => Promise<string>;\n};\n\n/**\n * The `snap_getFile` 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.getSnapFile - The function to load a static snap file.\n * @returns Nothing.\n */\nasync function implementation(\n  req: JsonRpcRequest<InferredGetFileParams>,\n  res: PendingJsonRpcResponse<GetFileResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnapFile }: GetFileHooks,\n): Promise<void> {\n  const { params } = req;\n\n  assertStruct(\n    params,\n    GetFileArgsStruct,\n    'Invalid \"snap_getFile\" parameters',\n    rpcErrors.invalidParams,\n  );\n\n  try {\n    res.result = await getSnapFile(\n      params.path,\n      params.encoding ?? AuxiliaryFileEncoding.Base64,\n    );\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n"]}

package/dist/chunk-NU4NAAFG.js

@@ -0,0 +1 @@
+"use strict";//# sourceMappingURL=chunk-NU4NAAFG.js.map

package/dist/chunk-NU4NAAFG.js.map

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

package/dist/chunk-NWT2EXFD.js

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/getSnaps.ts
+var hookNames = {
+  getSnaps: true
+};
+var getSnapsHandler = {
+  methodNames: ["wallet_getSnaps"],
+  implementation: getSnapsImplementation,
+  hookNames
+};
+async function getSnapsImplementation(_req, res, _next, end, { getSnaps }) {
+  res.result = await getSnaps();
+  return end();
+}
+
+
+
+exports.getSnapsHandler = getSnapsHandler;
+//# sourceMappingURL=chunk-NWT2EXFD.js.map

package/dist/chunk-NWT2EXFD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/getSnaps.ts"],"names":[],"mappings":";AAOA,IAAM,YAA8C;AAAA,EAClD,UAAU;AACZ;AAKO,IAAM,kBAIT;AAAA,EACF,aAAa,CAAC,iBAAiB;AAAA,EAC/B,gBAAgB;AAAA,EAChB;AACF;AAsBA,eAAe,uBACb,MACA,KACA,OACA,KACA,EAAE,SAAS,GACI;AAEf,MAAI,SAAS,MAAM,SAAS;AAC5B,SAAO,IAAI;AACb","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport type { GetSnapsResult } from '@metamask/snaps-sdk';\nimport type { JsonRpcParams, PendingJsonRpcResponse } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetSnapsHooks> = {\n  getSnaps: true,\n};\n\n/**\n * `wallet_getSnaps` gets the requester's permitted and installed Snaps.\n */\nexport const getSnapsHandler: PermittedHandlerExport<\n  GetSnapsHooks,\n  JsonRpcParams,\n  GetSnapsResult\n> = {\n  methodNames: ['wallet_getSnaps'],\n  implementation: getSnapsImplementation,\n  hookNames,\n};\n\nexport type GetSnapsHooks = {\n  /**\n   * @returns The permitted and installed snaps for the requesting origin.\n   */\n  getSnaps: () => Promise<GetSnapsResult>;\n};\n\n/**\n * The `wallet_getSnaps` method implementation.\n * Fetches available snaps for the requesting origin and adds them to the JSON-RPC response.\n *\n * @param _req - The JSON-RPC request object. Not used by this function.\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.getSnaps - A function that returns the snaps available for the requesting origin.\n * @returns Nothing.\n */\nasync function getSnapsImplementation(\n  _req: unknown,\n  res: PendingJsonRpcResponse<GetSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnaps }: GetSnapsHooks,\n): Promise<void> {\n  // getSnaps is already bound to the origin\n  res.result = await getSnaps();\n  return end();\n}\n"]}

package/dist/chunk-O66NZFSD.mjs

@@ -0,0 +1,23 @@
+// src/endowments/web-assembly.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+var permissionName = "endowment:webassembly" /* WebAssemblyAccess */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: null,
+    endowmentGetter: (_getterOptions) => {
+      return ["WebAssembly"];
+    },
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var webAssemblyEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+
+export {
+  webAssemblyEndowmentBuilder
+};
+//# sourceMappingURL=chunk-O66NZFSD.mjs.map

package/dist/chunk-O66NZFSD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/web-assembly.ts"],"sourcesContent":["import type {\n  EndowmentGetterParams,\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.WebAssemblyAccess;\n\ntype WebAssemblyEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => ['WebAssembly'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:webassembly` returns the name of global browser API(s) that\n * enable access to the WebAssembly API.\n * This is intended to populate the endowments of the SES Compartment\n * in which a Snap executes.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the WebAssembly endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  WebAssemblyEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['WebAssembly'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const webAssemblyEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAI5C,IAAM;AAkBN,IAAM,uBAIF,CAAC,oBAA0B;AAC7B,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,iBAAiB,CAAC,mBAA2C;AAC3D,aAAO,CAAC,aAAa;AAAA,IACvB;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,8BAA8B,OAAO,OAAO;AAAA,EACvD,YAAY;AAAA,EACZ;AACF,CAAU;","names":[]}

package/dist/chunk-OQOTJFFV.js

@@ -0,0 +1,74 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/cronjob.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:cronjob" /* Cronjob */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: [_snapsutils.SnapCaveatType.SnapCronjob],
+    endowmentGetter: (_getterOptions) => void 0,
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var cronjobEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+function getCronjobCaveatMapper(value) {
+  return {
+    caveats: [
+      {
+        type: _snapsutils.SnapCaveatType.SnapCronjob,
+        value
+      }
+    ]
+  };
+}
+function getCronjobCaveatJobs(permission) {
+  if (!permission?.caveats) {
+    return null;
+  }
+  _utils.assert.call(void 0, permission.caveats.length === 1);
+  _utils.assert.call(void 0, permission.caveats[0].type === _snapsutils.SnapCaveatType.SnapCronjob);
+  const caveat = permission.caveats[0];
+  return caveat.value?.jobs ?? null;
+}
+function validateCronjobCaveat(caveat) {
+  if (!_utils.hasProperty.call(void 0, caveat, "value") || !_utils.isPlainObject.call(void 0, caveat.value)) {
+    throw _rpcerrors.rpcErrors.invalidParams({
+      message: "Expected a plain object."
+    });
+  }
+  const { value } = caveat;
+  if (!_utils.hasProperty.call(void 0, value, "jobs") || !_utils.isPlainObject.call(void 0, value)) {
+    throw _rpcerrors.rpcErrors.invalidParams({
+      message: "Expected a plain object."
+    });
+  }
+  if (!_snapsutils.isCronjobSpecificationArray.call(void 0, value.jobs)) {
+    throw _rpcerrors.rpcErrors.invalidParams({
+      message: "Expected a valid cronjob specification array."
+    });
+  }
+}
+var cronjobCaveatSpecifications = {
+  [_snapsutils.SnapCaveatType.SnapCronjob]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.SnapCronjob,
+    validator: (caveat) => validateCronjobCaveat(caveat)
+  })
+};
+
+
+
+
+
+
+
+exports.cronjobEndowmentBuilder = cronjobEndowmentBuilder; exports.getCronjobCaveatMapper = getCronjobCaveatMapper; exports.getCronjobCaveatJobs = getCronjobCaveatJobs; exports.validateCronjobCaveat = validateCronjobCaveat; exports.cronjobCaveatSpecifications = cronjobCaveatSpecifications;
+//# sourceMappingURL=chunk-OQOTJFFV.js.map

package/dist/chunk-OQOTJFFV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/cronjob.ts"],"names":[],"mappings":";AAQA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAE1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,QAAQ,aAAa,qBAAqB;AAInD,IAAM;AAeN,IAAM,uBAIF,CAAC,oBAA0B;AAC7B,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB,CAAC,eAAe,WAAW;AAAA,IAC3C,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,0BAA0B,OAAO,OAAO;AAAA,EACnD,YAAY;AAAA,EACZ;AACF,CAAU;AAUH,SAAS,uBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAaO,SAAS,qBACd,YAC+B;AAC/B,MAAI,CAAC,YAAY,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,WAAW;AAEhE,QAAM,SAAS,WAAW,QAAQ,CAAC;AAEnC,SAAQ,OAAO,OAAO,QAAmC;AAC3D;AAUO,SAAS,sBAAsB,QAA6B;AACjE,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;AAElB,MAAI,CAAC,YAAY,OAAO,MAAM,KAAK,CAAC,cAAc,KAAK,GAAG;AACxD,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,MAAI,CAAC,4BAA4B,MAAM,IAAI,GAAG;AAC5C,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AACF;AAKO,IAAM,8BAGT;AAAA,EACF,CAAC,eAAe,WAAW,GAAG,OAAO,OAAO;AAAA,IAC1C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAW,sBAAsB,MAAM;AAAA,EACrD,CAAC;AACH","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n  PermissionConstraint,\n  Caveat,\n  CaveatSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { CronjobSpecification } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  isCronjobSpecificationArray,\n} from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isPlainObject } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.Cronjob;\n\ntype CronjobEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:cronjob` returns nothing; it is intended to be used as a flag to determine whether the snap wants to run cronjobs.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the cronjob endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  CronjobEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [SnapCaveatType.SnapCronjob],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const cronjobEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\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 getCronjobCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapCronjob,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the cronjobs from a permission.\n *\n * This does basic validation of the caveat, but does not validate the type or\n * value of the namespaces object itself, as this is handled by the\n * `PermissionsController` when the permission is requested.\n *\n * @param permission - The permission to get the keyring namespaces from.\n * @returns The cronjobs, or `null` if the permission does not have a\n * cronjob caveat.\n */\nexport function getCronjobCaveatJobs(\n  permission?: PermissionConstraint,\n): CronjobSpecification[] | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.SnapCronjob);\n\n  const caveat = permission.caveats[0] as Caveat<string, { jobs: Json[] }>;\n\n  return (caveat.value?.jobs as CronjobSpecification[]) ?? null;\n}\n\n/**\n * Validate the cronjob specification values associated with a caveat.\n * This validates that the value is a non-empty array with valid\n * cronjob expression and request object.\n *\n * @param caveat - The caveat to validate.\n * @throws If the value is invalid.\n */\nexport function validateCronjobCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n\n  if (!hasProperty(value, 'jobs') || !isPlainObject(value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  if (!isCronjobSpecificationArray(value.jobs)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a valid cronjob specification array.',\n    });\n  }\n}\n\n/**\n * Caveat specification for the Cronjob.\n */\nexport const cronjobCaveatSpecifications: Record<\n  SnapCaveatType.SnapCronjob,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SnapCronjob]: Object.freeze({\n    type: SnapCaveatType.SnapCronjob,\n    validator: (caveat) => validateCronjobCaveat(caveat),\n  }),\n};\n"]}