@metamask/snaps-rpc-methods 6.0.0 → 7.0.0

package/dist/chunk-JEEKFTAL.mjs

@@ -0,0 +1,59 @@
+import {
+  restrictedMethodPermissionBuilders
+} from "./chunk-3DWRS3YG.mjs";
+import {
+  caveatMappers
+} from "./chunk-3CSLIOIY.mjs";
+import {
+  selectHooks
+} from "./chunk-DR63Z4PV.mjs";
+import {
+  endowmentCaveatMappers,
+  endowmentPermissionBuilders
+} from "./chunk-2WCLK3LN.mjs";
+
+// src/permissions.ts
+import { hasProperty } from "@metamask/utils";
+function processSnapPermissions(initialPermissions) {
+  return Object.fromEntries(
+    Object.entries(initialPermissions).map(([initialPermission, value]) => {
+      if (hasProperty(caveatMappers, initialPermission)) {
+        return [initialPermission, caveatMappers[initialPermission](value)];
+      } else if (hasProperty(endowmentCaveatMappers, initialPermission)) {
+        return [
+          initialPermission,
+          endowmentCaveatMappers[initialPermission](value)
+        ];
+      }
+      return [
+        initialPermission,
+        value
+      ];
+    })
+  );
+}
+var buildSnapEndowmentSpecifications = (excludedEndowments) => Object.values(endowmentPermissionBuilders).reduce((allSpecifications, { targetName, specificationBuilder }) => {
+  if (!excludedEndowments.includes(targetName)) {
+    allSpecifications[targetName] = specificationBuilder({});
+  }
+  return allSpecifications;
+}, {});
+var buildSnapRestrictedMethodSpecifications = (excludedPermissions, hooks) => Object.values(restrictedMethodPermissionBuilders).reduce((specifications, { targetName, specificationBuilder, methodHooks }) => {
+  if (!excludedPermissions.includes(targetName)) {
+    specifications[targetName] = specificationBuilder({
+      // @ts-expect-error The selectHooks type is wonky
+      methodHooks: selectHooks(
+        hooks,
+        methodHooks
+      )
+    });
+  }
+  return specifications;
+}, {});
+
+export {
+  processSnapPermissions,
+  buildSnapEndowmentSpecifications,
+  buildSnapRestrictedMethodSpecifications
+};
+//# sourceMappingURL=chunk-JEEKFTAL.mjs.map

package/dist/chunk-JEEKFTAL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permissions.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport type { SnapPermissions } from '@metamask/snaps-utils';\nimport { hasProperty } from '@metamask/utils';\n\nimport {\n  endowmentCaveatMappers,\n  endowmentPermissionBuilders,\n} from './endowments';\nimport {\n  caveatMappers,\n  restrictedMethodPermissionBuilders,\n} from './restricted';\nimport { selectHooks } from './utils';\n\n/**\n * Map initial permissions as defined in a Snap manifest to something that can\n * be processed by the PermissionsController. Each caveat mapping function\n * should return a valid permission caveat value.\n *\n * This function does not validate the caveat values, since that is done by\n * the PermissionsController itself, upon requesting the permissions.\n *\n * @param initialPermissions - The initial permissions to process.\n * @returns The processed permissions.\n */\nexport function processSnapPermissions(\n  initialPermissions: SnapPermissions,\n): Record<string, Pick<PermissionConstraint, 'caveats'>> {\n  return Object.fromEntries(\n    Object.entries(initialPermissions).map(([initialPermission, value]) => {\n      if (hasProperty(caveatMappers, initialPermission)) {\n        return [initialPermission, caveatMappers[initialPermission](value)];\n      } else if (hasProperty(endowmentCaveatMappers, initialPermission)) {\n        return [\n          initialPermission,\n          endowmentCaveatMappers[initialPermission](value),\n        ];\n      }\n\n      // If we have no mapping, this may be a non-snap permission, return as-is\n      return [\n        initialPermission,\n        value as Pick<PermissionConstraint, 'caveats'>,\n      ];\n    }),\n  );\n}\n\nexport const buildSnapEndowmentSpecifications = (\n  excludedEndowments: string[],\n) =>\n  Object.values(endowmentPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((allSpecifications, { targetName, specificationBuilder }) => {\n    if (!excludedEndowments.includes(targetName)) {\n      allSpecifications[targetName] = specificationBuilder({});\n    }\n    return allSpecifications;\n  }, {});\n\nexport const buildSnapRestrictedMethodSpecifications = (\n  excludedPermissions: string[],\n  hooks: Record<string, unknown>,\n) =>\n  Object.values(restrictedMethodPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((specifications, { targetName, specificationBuilder, methodHooks }) => {\n    if (!excludedPermissions.includes(targetName)) {\n      specifications[targetName] = specificationBuilder({\n        // @ts-expect-error The selectHooks type is wonky\n        methodHooks: selectHooks<typeof hooks, keyof typeof methodHooks>(\n          hooks,\n          methodHooks,\n        ) as Pick<typeof hooks, keyof typeof methodHooks>,\n      });\n    }\n    return specifications;\n  }, {});\n"],"mappings":";;;;;;;;;;;;;;;AAKA,SAAS,mBAAmB;AAuBrB,SAAS,uBACd,oBACuD;AACvD,SAAO,OAAO;AAAA,IACZ,OAAO,QAAQ,kBAAkB,EAAE,IAAI,CAAC,CAAC,mBAAmB,KAAK,MAAM;AACrE,UAAI,YAAY,eAAe,iBAAiB,GAAG;AACjD,eAAO,CAAC,mBAAmB,cAAc,iBAAiB,EAAE,KAAK,CAAC;AAAA,MACpE,WAAW,YAAY,wBAAwB,iBAAiB,GAAG;AACjE,eAAO;AAAA,UACL;AAAA,UACA,uBAAuB,iBAAiB,EAAE,KAAK;AAAA,QACjD;AAAA,MACF;AAGA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEO,IAAM,mCAAmC,CAC9C,uBAEA,OAAO,OAAO,2BAA2B,EAAE,OAEzC,CAAC,mBAAmB,EAAE,YAAY,qBAAqB,MAAM;AAC7D,MAAI,CAAC,mBAAmB,SAAS,UAAU,GAAG;AAC5C,sBAAkB,UAAU,IAAI,qBAAqB,CAAC,CAAC;AAAA,EACzD;AACA,SAAO;AACT,GAAG,CAAC,CAAC;AAEA,IAAM,0CAA0C,CACrD,qBACA,UAEA,OAAO,OAAO,kCAAkC,EAAE,OAEhD,CAAC,gBAAgB,EAAE,YAAY,sBAAsB,YAAY,MAAM;AACvE,MAAI,CAAC,oBAAoB,SAAS,UAAU,GAAG;AAC7C,mBAAe,UAAU,IAAI,qBAAqB;AAAA;AAAA,MAEhD,aAAa;AAAA,QACX;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO;AACT,GAAG,CAAC,CAAC;","names":[]}

package/dist/chunk-JPUJWFBS.js

@@ -0,0 +1,115 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkIDRDPYANjs = require('./chunk-IDRDPYAN.js');
+
+
+var _chunk2A5M65V3js = require('./chunk-2A5M65V3.js');
+
+
+
+
+var _chunkE2G25QVGjs = require('./chunk-E2G25QVG.js');
+
+
+var _chunkDBYI25URjs = require('./chunk-DBYI25UR.js');
+
+
+
+
+var _chunkWHWFVRFHjs = require('./chunk-WHWFVRFH.js');
+
+
+
+
+var _chunkHODDBRLQjs = require('./chunk-HODDBRLQ.js');
+
+
+
+
+var _chunk2TYDIMR6js = require('./chunk-2TYDIMR6.js');
+
+
+
+
+var _chunkLITIVHN4js = require('./chunk-LITIVHN4.js');
+
+
+var _chunkRZDRHJXIjs = require('./chunk-RZDRHJXI.js');
+
+
+
+
+var _chunkKDLWQGV3js = require('./chunk-KDLWQGV3.js');
+
+
+var _chunkVZBSLVVAjs = require('./chunk-VZBSLVVA.js');
+
+
+var _chunkRHGOSBUTjs = require('./chunk-RHGOSBUT.js');
+
+// src/endowments/index.ts
+var _snapsutils = require('@metamask/snaps-utils');
+var endowmentPermissionBuilders = {
+  [_chunkDBYI25URjs.networkAccessEndowmentBuilder.targetName]: _chunkDBYI25URjs.networkAccessEndowmentBuilder,
+  [_chunk2TYDIMR6js.transactionInsightEndowmentBuilder.targetName]: _chunk2TYDIMR6js.transactionInsightEndowmentBuilder,
+  [_chunkKDLWQGV3js.cronjobEndowmentBuilder.targetName]: _chunkKDLWQGV3js.cronjobEndowmentBuilder,
+  [_chunkVZBSLVVAjs.ethereumProviderEndowmentBuilder.targetName]: _chunkVZBSLVVAjs.ethereumProviderEndowmentBuilder,
+  [_chunkWHWFVRFHjs.rpcEndowmentBuilder.targetName]: _chunkWHWFVRFHjs.rpcEndowmentBuilder,
+  [_chunkRZDRHJXIjs.webAssemblyEndowmentBuilder.targetName]: _chunkRZDRHJXIjs.webAssemblyEndowmentBuilder,
+  [_chunkE2G25QVGjs.nameLookupEndowmentBuilder.targetName]: _chunkE2G25QVGjs.nameLookupEndowmentBuilder,
+  [_chunk2A5M65V3js.lifecycleHooksEndowmentBuilder.targetName]: _chunk2A5M65V3js.lifecycleHooksEndowmentBuilder,
+  [_chunkIDRDPYANjs.keyringEndowmentBuilder.targetName]: _chunkIDRDPYANjs.keyringEndowmentBuilder,
+  [_chunkRHGOSBUTjs.homePageEndowmentBuilder.targetName]: _chunkRHGOSBUTjs.homePageEndowmentBuilder,
+  [_chunkHODDBRLQjs.signatureInsightEndowmentBuilder.targetName]: _chunkHODDBRLQjs.signatureInsightEndowmentBuilder
+};
+var endowmentCaveatSpecifications = {
+  ..._chunkKDLWQGV3js.cronjobCaveatSpecifications,
+  ..._chunk2TYDIMR6js.transactionInsightCaveatSpecifications,
+  ..._chunkWHWFVRFHjs.rpcCaveatSpecifications,
+  ..._chunkE2G25QVGjs.nameLookupCaveatSpecifications,
+  ..._chunkIDRDPYANjs.keyringCaveatSpecifications,
+  ..._chunkHODDBRLQjs.signatureInsightCaveatSpecifications,
+  ..._chunkLITIVHN4js.maxRequestTimeCaveatSpecifications
+};
+var endowmentCaveatMappers = {
+  [_chunkKDLWQGV3js.cronjobEndowmentBuilder.targetName]: _chunkLITIVHN4js.createMaxRequestTimeMapper.call(void 0, 
+    _chunkKDLWQGV3js.getCronjobCaveatMapper
+  ),
+  [_chunk2TYDIMR6js.transactionInsightEndowmentBuilder.targetName]: _chunkLITIVHN4js.createMaxRequestTimeMapper.call(void 0, 
+    _chunk2TYDIMR6js.getTransactionInsightCaveatMapper
+  ),
+  [_chunkWHWFVRFHjs.rpcEndowmentBuilder.targetName]: _chunkLITIVHN4js.createMaxRequestTimeMapper.call(void 0, _chunkWHWFVRFHjs.getRpcCaveatMapper),
+  [_chunkE2G25QVGjs.nameLookupEndowmentBuilder.targetName]: _chunkLITIVHN4js.createMaxRequestTimeMapper.call(void 0, 
+    _chunkE2G25QVGjs.getNameLookupCaveatMapper
+  ),
+  [_chunkIDRDPYANjs.keyringEndowmentBuilder.targetName]: _chunkLITIVHN4js.createMaxRequestTimeMapper.call(void 0, 
+    _chunkIDRDPYANjs.getKeyringCaveatMapper
+  ),
+  [_chunkHODDBRLQjs.signatureInsightEndowmentBuilder.targetName]: _chunkLITIVHN4js.createMaxRequestTimeMapper.call(void 0, 
+    _chunkHODDBRLQjs.getSignatureInsightCaveatMapper
+  ),
+  [_chunk2A5M65V3js.lifecycleHooksEndowmentBuilder.targetName]: _chunkLITIVHN4js.getMaxRequestTimeCaveatMapper,
+  [_chunkRHGOSBUTjs.homePageEndowmentBuilder.targetName]: _chunkLITIVHN4js.getMaxRequestTimeCaveatMapper
+};
+var handlerEndowments = {
+  [_snapsutils.HandlerType.OnRpcRequest]: _chunkWHWFVRFHjs.rpcEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnTransaction]: _chunk2TYDIMR6js.transactionInsightEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnCronjob]: _chunkKDLWQGV3js.cronjobEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnNameLookup]: _chunkE2G25QVGjs.nameLookupEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnInstall]: _chunk2A5M65V3js.lifecycleHooksEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnUpdate]: _chunk2A5M65V3js.lifecycleHooksEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnKeyringRequest]: _chunkIDRDPYANjs.keyringEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnHomePage]: _chunkRHGOSBUTjs.homePageEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnSignature]: _chunkHODDBRLQjs.signatureInsightEndowmentBuilder.targetName,
+  [_snapsutils.HandlerType.OnUserInput]: null
+};
+
+
+
+
+
+
+exports.endowmentPermissionBuilders = endowmentPermissionBuilders; exports.endowmentCaveatSpecifications = endowmentCaveatSpecifications; exports.endowmentCaveatMappers = endowmentCaveatMappers; exports.handlerEndowments = handlerEndowments;
+//# sourceMappingURL=chunk-JPUJWFBS.js.map

package/dist/chunk-JPUJWFBS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/index.ts"],"names":[],"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","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"]}

package/dist/chunk-JURJUHQB.mjs

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

package/dist/chunk-JURJUHQB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/keyring.ts"],"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) => undefined;\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) => undefined,\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"],"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;","names":[]}

package/dist/chunk-JV26U22G.js

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

package/dist/chunk-JV26U22G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getBip44Entropy.ts"],"names":["methodHooks"],"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","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"]}

package/dist/chunk-K73RKHXA.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/enum.ts
+var SnapEndowments = /* @__PURE__ */ ((SnapEndowments2) => {
+  SnapEndowments2["NetworkAccess"] = "endowment:network-access";
+  SnapEndowments2["SignatureInsight"] = "endowment:signature-insight";
+  SnapEndowments2["TransactionInsight"] = "endowment:transaction-insight";
+  SnapEndowments2["Cronjob"] = "endowment:cronjob";
+  SnapEndowments2["EthereumProvider"] = "endowment:ethereum-provider";
+  SnapEndowments2["Rpc"] = "endowment:rpc";
+  SnapEndowments2["WebAssemblyAccess"] = "endowment:webassembly";
+  SnapEndowments2["NameLookup"] = "endowment:name-lookup";
+  SnapEndowments2["LifecycleHooks"] = "endowment:lifecycle-hooks";
+  SnapEndowments2["Keyring"] = "endowment:keyring";
+  SnapEndowments2["HomePage"] = "endowment:page-home";
+  return SnapEndowments2;
+})(SnapEndowments || {});
+
+
+
+exports.SnapEndowments = SnapEndowments;
+//# sourceMappingURL=chunk-K73RKHXA.js.map

package/dist/chunk-K73RKHXA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/enum.ts"],"names":["SnapEndowments"],"mappings":";AAAO,IAAK,iBAAL,kBAAKA,oBAAL;AACL,EAAAA,gBAAA,mBAAgB;AAChB,EAAAA,gBAAA,sBAAmB;AACnB,EAAAA,gBAAA,wBAAqB;AACrB,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,sBAAmB;AACnB,EAAAA,gBAAA,SAAM;AACN,EAAAA,gBAAA,uBAAoB;AACpB,EAAAA,gBAAA,gBAAa;AACb,EAAAA,gBAAA,oBAAiB;AACjB,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,cAAW;AAXD,SAAAA;AAAA,GAAA","sourcesContent":["export enum SnapEndowments {\n  NetworkAccess = 'endowment:network-access',\n  SignatureInsight = 'endowment:signature-insight',\n  TransactionInsight = 'endowment:transaction-insight',\n  Cronjob = 'endowment:cronjob',\n  EthereumProvider = 'endowment:ethereum-provider',\n  Rpc = 'endowment:rpc',\n  WebAssemblyAccess = 'endowment:webassembly',\n  NameLookup = 'endowment:name-lookup',\n  LifecycleHooks = 'endowment:lifecycle-hooks',\n  Keyring = 'endowment:keyring',\n  HomePage = 'endowment:page-home',\n}\n"]}

package/dist/chunk-KDLWQGV3.js

@@ -0,0 +1,74 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// 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 (!_optionalChain([permission, 'optionalAccess', _ => _.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 _nullishCoalesce(_optionalChain([caveat, 'access', _2 => _2.value, 'optionalAccess', _3 => _3.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-KDLWQGV3.js.map

package/dist/chunk-KDLWQGV3.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"]}

package/dist/chunk-KE74K2JM.js

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkSCXW3FQOjs = require('./chunk-SCXW3FQO.js');
+
+
+var _chunkE4HGQWSSjs = require('./chunk-E4HGQWSS.js');
+
+
+var _chunk632BZ6JYjs = require('./chunk-632BZ6JY.js');
+
+
+
+var _chunkJPUJWFBSjs = require('./chunk-JPUJWFBS.js');
+
+// src/permissions.ts
+var _utils = require('@metamask/utils');
+function processSnapPermissions(initialPermissions) {
+  return Object.fromEntries(
+    Object.entries(initialPermissions).map(([initialPermission, value]) => {
+      if (_utils.hasProperty.call(void 0, _chunkE4HGQWSSjs.caveatMappers, initialPermission)) {
+        return [initialPermission, _chunkE4HGQWSSjs.caveatMappers[initialPermission](value)];
+      } else if (_utils.hasProperty.call(void 0, _chunkJPUJWFBSjs.endowmentCaveatMappers, initialPermission)) {
+        return [
+          initialPermission,
+          _chunkJPUJWFBSjs.endowmentCaveatMappers[initialPermission](value)
+        ];
+      }
+      return [
+        initialPermission,
+        value
+      ];
+    })
+  );
+}
+var buildSnapEndowmentSpecifications = (excludedEndowments) => Object.values(_chunkJPUJWFBSjs.endowmentPermissionBuilders).reduce((allSpecifications, { targetName, specificationBuilder }) => {
+  if (!excludedEndowments.includes(targetName)) {
+    allSpecifications[targetName] = specificationBuilder({});
+  }
+  return allSpecifications;
+}, {});
+var buildSnapRestrictedMethodSpecifications = (excludedPermissions, hooks) => Object.values(_chunkSCXW3FQOjs.restrictedMethodPermissionBuilders).reduce((specifications, { targetName, specificationBuilder, methodHooks }) => {
+  if (!excludedPermissions.includes(targetName)) {
+    specifications[targetName] = specificationBuilder({
+      // @ts-expect-error The selectHooks type is wonky
+      methodHooks: _chunk632BZ6JYjs.selectHooks.call(void 0, 
+        hooks,
+        methodHooks
+      )
+    });
+  }
+  return specifications;
+}, {});
+
+
+
+
+
+exports.processSnapPermissions = processSnapPermissions; exports.buildSnapEndowmentSpecifications = buildSnapEndowmentSpecifications; exports.buildSnapRestrictedMethodSpecifications = buildSnapRestrictedMethodSpecifications;
+//# sourceMappingURL=chunk-KE74K2JM.js.map

package/dist/chunk-KE74K2JM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permissions.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAKA,SAAS,mBAAmB;AAuBrB,SAAS,uBACd,oBACuD;AACvD,SAAO,OAAO;AAAA,IACZ,OAAO,QAAQ,kBAAkB,EAAE,IAAI,CAAC,CAAC,mBAAmB,KAAK,MAAM;AACrE,UAAI,YAAY,eAAe,iBAAiB,GAAG;AACjD,eAAO,CAAC,mBAAmB,cAAc,iBAAiB,EAAE,KAAK,CAAC;AAAA,MACpE,WAAW,YAAY,wBAAwB,iBAAiB,GAAG;AACjE,eAAO;AAAA,UACL;AAAA,UACA,uBAAuB,iBAAiB,EAAE,KAAK;AAAA,QACjD;AAAA,MACF;AAGA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEO,IAAM,mCAAmC,CAC9C,uBAEA,OAAO,OAAO,2BAA2B,EAAE,OAEzC,CAAC,mBAAmB,EAAE,YAAY,qBAAqB,MAAM;AAC7D,MAAI,CAAC,mBAAmB,SAAS,UAAU,GAAG;AAC5C,sBAAkB,UAAU,IAAI,qBAAqB,CAAC,CAAC;AAAA,EACzD;AACA,SAAO;AACT,GAAG,CAAC,CAAC;AAEA,IAAM,0CAA0C,CACrD,qBACA,UAEA,OAAO,OAAO,kCAAkC,EAAE,OAEhD,CAAC,gBAAgB,EAAE,YAAY,sBAAsB,YAAY,MAAM;AACvE,MAAI,CAAC,oBAAoB,SAAS,UAAU,GAAG;AAC7C,mBAAe,UAAU,IAAI,qBAAqB;AAAA;AAAA,MAEhD,aAAa;AAAA,QACX;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO;AACT,GAAG,CAAC,CAAC","sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport type { SnapPermissions } from '@metamask/snaps-utils';\nimport { hasProperty } from '@metamask/utils';\n\nimport {\n  endowmentCaveatMappers,\n  endowmentPermissionBuilders,\n} from './endowments';\nimport {\n  caveatMappers,\n  restrictedMethodPermissionBuilders,\n} from './restricted';\nimport { selectHooks } from './utils';\n\n/**\n * Map initial permissions as defined in a Snap manifest to something that can\n * be processed by the PermissionsController. Each caveat mapping function\n * should return a valid permission caveat value.\n *\n * This function does not validate the caveat values, since that is done by\n * the PermissionsController itself, upon requesting the permissions.\n *\n * @param initialPermissions - The initial permissions to process.\n * @returns The processed permissions.\n */\nexport function processSnapPermissions(\n  initialPermissions: SnapPermissions,\n): Record<string, Pick<PermissionConstraint, 'caveats'>> {\n  return Object.fromEntries(\n    Object.entries(initialPermissions).map(([initialPermission, value]) => {\n      if (hasProperty(caveatMappers, initialPermission)) {\n        return [initialPermission, caveatMappers[initialPermission](value)];\n      } else if (hasProperty(endowmentCaveatMappers, initialPermission)) {\n        return [\n          initialPermission,\n          endowmentCaveatMappers[initialPermission](value),\n        ];\n      }\n\n      // If we have no mapping, this may be a non-snap permission, return as-is\n      return [\n        initialPermission,\n        value as Pick<PermissionConstraint, 'caveats'>,\n      ];\n    }),\n  );\n}\n\nexport const buildSnapEndowmentSpecifications = (\n  excludedEndowments: string[],\n) =>\n  Object.values(endowmentPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((allSpecifications, { targetName, specificationBuilder }) => {\n    if (!excludedEndowments.includes(targetName)) {\n      allSpecifications[targetName] = specificationBuilder({});\n    }\n    return allSpecifications;\n  }, {});\n\nexport const buildSnapRestrictedMethodSpecifications = (\n  excludedPermissions: string[],\n  hooks: Record<string, unknown>,\n) =>\n  Object.values(restrictedMethodPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((specifications, { targetName, specificationBuilder, methodHooks }) => {\n    if (!excludedPermissions.includes(targetName)) {\n      specifications[targetName] = specificationBuilder({\n        // @ts-expect-error The selectHooks type is wonky\n        methodHooks: selectHooks<typeof hooks, keyof typeof methodHooks>(\n          hooks,\n          methodHooks,\n        ) as Pick<typeof hooks, keyof typeof methodHooks>,\n      });\n    }\n    return specifications;\n  }, {});\n"]}

package/dist/chunk-KVHYDTGR.js

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

package/dist/chunk-KVHYDTGR.js.map

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

package/dist/chunk-L7MGGL7Q.mjs

@@ -0,0 +1,43 @@
+// src/permitted/createInterface.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { ComponentStruct } from "@metamask/snaps-sdk";
+import { StructError, create, object } from "superstruct";
+var hookNames = {
+  createInterface: true
+};
+var createInterfaceHandler = {
+  methodNames: ["snap_createInterface"],
+  implementation: getCreateInterfaceImplementation,
+  hookNames
+};
+var CreateInterfaceParametersStruct = object({
+  ui: ComponentStruct
+});
+async function getCreateInterfaceImplementation(req, res, _next, end, { createInterface }) {
+  const { params } = req;
+  try {
+    const validatedParams = getValidatedParams(params);
+    const { ui } = validatedParams;
+    res.result = await createInterface(ui);
+  } catch (error) {
+    return end(error);
+  }
+  return end();
+}
+function getValidatedParams(params) {
+  try {
+    return create(params, CreateInterfaceParametersStruct);
+  } catch (error) {
+    if (error instanceof StructError) {
+      throw rpcErrors.invalidParams({
+        message: `Invalid params: ${error.message}.`
+      });
+    }
+    throw rpcErrors.internal();
+  }
+}
+
+export {
+  createInterfaceHandler
+};
+//# sourceMappingURL=chunk-L7MGGL7Q.mjs.map

package/dist/chunk-L7MGGL7Q.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/createInterface.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  Component,\n  CreateInterfaceParams,\n  CreateInterfaceResult,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { ComponentStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<CreateInterfaceMethodHooks> = {\n  createInterface: true,\n};\n\nexport type CreateInterfaceMethodHooks = {\n  /**\n   * @param ui - The UI components.\n   * @returns The unique identifier of the interface.\n   */\n  createInterface: (ui: Component) => Promise<string>;\n};\n\nexport const createInterfaceHandler: PermittedHandlerExport<\n  CreateInterfaceMethodHooks,\n  CreateInterfaceParameters,\n  CreateInterfaceResult\n> = {\n  methodNames: ['snap_createInterface'],\n  implementation: getCreateInterfaceImplementation,\n  hookNames,\n};\n\nconst CreateInterfaceParametersStruct = object({\n  ui: ComponentStruct,\n});\n\nexport type CreateInterfaceParameters = InferMatching<\n  typeof CreateInterfaceParametersStruct,\n  CreateInterfaceParams\n>;\n\n/**\n * The `snap_createInterface` 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.createInterface - The function to create the interface.\n * @returns Nothing.\n */\nasync function getCreateInterfaceImplementation(\n  req: JsonRpcRequest<CreateInterfaceParameters>,\n  res: PendingJsonRpcResponse<CreateInterfaceResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { createInterface }: CreateInterfaceMethodHooks,\n): Promise<void> {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { ui } = validatedParams;\n\n    res.result = await createInterface(ui);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the createInterface 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 createInterface method parameter object.\n */\nfunction getValidatedParams(params: unknown): CreateInterfaceParameters {\n  try {\n    return create(params, CreateInterfaceParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"mappings":";AAEA,SAAS,iBAAiB;AAO1B,SAAS,uBAAuB;AAGhC,SAAS,aAAa,QAAQ,cAAc;AAI5C,IAAM,YAA2D;AAAA,EAC/D,iBAAiB;AACnB;AAUO,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,sBAAsB;AAAA,EACpC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,kCAAkC,OAAO;AAAA,EAC7C,IAAI;AACN,CAAC;AAmBD,eAAe,iCACb,KACA,KACA,OACA,KACA,EAAE,gBAAgB,GACH;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI;AACF,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,EAAE,GAAG,IAAI;AAEf,QAAI,SAAS,MAAM,gBAAgB,EAAE;AAAA,EACvC,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;AASA,SAAS,mBAAmB,QAA4C;AACtE,MAAI;AACF,WAAO,OAAO,QAAQ,+BAA+B;AAAA,EACvD,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,SAAS;AAAA,EAC3B;AACF;","names":[]}