@metamask/snaps-rpc-methods 6.0.0 → 7.0.1

package/dist/chunk-CH5O2YCX.mjs.map

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

package/dist/chunk-CVK2TYJX.mjs

@@ -0,0 +1,54 @@
+// src/restricted/caveats/snapIds.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { SnapCaveatType, SnapIdsStruct } from "@metamask/snaps-utils";
+import { hasProperty, assertStruct } from "@metamask/utils";
+import { type } from "superstruct";
+function snapIdsCaveatMapper(value) {
+  return {
+    caveats: [
+      {
+        type: SnapCaveatType.SnapIds,
+        value
+      }
+    ]
+  };
+}
+function validateSnapIdsCaveat(caveat) {
+  assertStruct(
+    caveat,
+    type({
+      value: SnapIdsStruct
+    }),
+    "Expected caveat to have a value property of a non-empty object of snap IDs.",
+    rpcErrors.invalidParams
+  );
+}
+var SnapIdsCaveatSpecification = {
+  [SnapCaveatType.SnapIds]: Object.freeze({
+    type: SnapCaveatType.SnapIds,
+    validator: (caveat) => validateSnapIdsCaveat(caveat),
+    decorator: (method, caveat) => {
+      return async (args) => {
+        const {
+          params,
+          context: { origin }
+        } = args;
+        const snapIds = caveat.value;
+        const { snapId } = params;
+        if (!hasProperty(snapIds, snapId)) {
+          throw new Error(
+            `${origin} does not have permission to invoke ${snapId} snap.`
+          );
+        }
+        return await method(args);
+      };
+    }
+  })
+};
+
+export {
+  snapIdsCaveatMapper,
+  validateSnapIdsCaveat,
+  SnapIdsCaveatSpecification
+};
+//# sourceMappingURL=chunk-CVK2TYJX.mjs.map

package/dist/chunk-CVK2TYJX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/caveats/snapIds.ts"],"sourcesContent":["import type {\n  Caveat,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n  RestrictedMethodCaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { SnapIds } from '@metamask/snaps-utils';\nimport { SnapCaveatType, SnapIdsStruct } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, assertStruct } from '@metamask/utils';\nimport { type } from 'superstruct';\n\nimport type { InvokeSnapParams } from '../invokeSnap';\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 snapIdsCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapIds,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validates that the caveat value exists and is a non-empty object.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateSnapIdsCaveat(\n  caveat: Caveat<string, any>,\n): asserts caveat is Caveat<string, SnapIds> {\n  assertStruct(\n    caveat,\n    type({\n      value: SnapIdsStruct,\n    }),\n    'Expected caveat to have a value property of a non-empty object of snap IDs.',\n    rpcErrors.invalidParams,\n  );\n}\n\nexport const SnapIdsCaveatSpecification: Record<\n  SnapCaveatType.SnapIds,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SnapIds]: Object.freeze({\n    type: SnapCaveatType.SnapIds,\n    validator: (caveat) => validateSnapIdsCaveat(caveat),\n    decorator: (method, caveat) => {\n      return async (args) => {\n        const {\n          params,\n          context: { origin },\n        }: RestrictedMethodOptions<RestrictedMethodParameters> = args;\n        const snapIds = caveat.value;\n        const { snapId } = params as InvokeSnapParams;\n        if (!hasProperty(snapIds, snapId)) {\n          throw new Error(\n            `${origin} does not have permission to invoke ${snapId} snap.`,\n          );\n        }\n        return await method(args);\n      };\n    },\n  }),\n};\n"],"mappings":";AAOA,SAAS,iBAAiB;AAE1B,SAAS,gBAAgB,qBAAqB;AAE9C,SAAS,aAAa,oBAAoB;AAC1C,SAAS,YAAY;AAYd,SAAS,oBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,sBACd,QAC2C;AAC3C;AAAA,IACE;AAAA,IACA,KAAK;AAAA,MACH,OAAO;AAAA,IACT,CAAC;AAAA,IACD;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAEO,IAAM,6BAGT;AAAA,EACF,CAAC,eAAe,OAAO,GAAG,OAAO,OAAO;AAAA,IACtC,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAW,sBAAsB,MAAM;AAAA,IACnD,WAAW,CAAC,QAAQ,WAAW;AAC7B,aAAO,OAAO,SAAS;AACrB,cAAM;AAAA,UACJ;AAAA,UACA,SAAS,EAAE,OAAO;AAAA,QACpB,IAAyD;AACzD,cAAM,UAAU,OAAO;AACvB,cAAM,EAAE,OAAO,IAAI;AACnB,YAAI,CAAC,YAAY,SAAS,MAAM,GAAG;AACjC,gBAAM,IAAI;AAAA,YACR,GAAG,MAAM,uCAAuC,MAAM;AAAA,UACxD;AAAA,QACF;AACA,eAAO,MAAM,OAAO,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-D6MUXDVI.js

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkAOWUGDERjs = require('./chunk-AOWUGDER.js');
+
+
+var _chunkIDZGMGIBjs = require('./chunk-IDZGMGIB.js');
+
+
+var _chunkPS6OEQXLjs = require('./chunk-PS6OEQXL.js');
+
+
+var _chunkGP5KW5FUjs = require('./chunk-GP5KW5FU.js');
+
+
+var _chunk3LPBU737js = require('./chunk-3LPBU737.js');
+
+
+var _chunk4LSOS7SMjs = require('./chunk-4LSOS7SM.js');
+
+
+var _chunk3UAWEHMFjs = require('./chunk-3UAWEHMF.js');
+
+
+var _chunkNP3KGMVCjs = require('./chunk-NP3KGMVC.js');
+
+
+var _chunk4W7U4OH6js = require('./chunk-4W7U4OH6.js');
+
+
+var _chunkNWT2EXFDjs = require('./chunk-NWT2EXFD.js');
+
+// src/permitted/handlers.ts
+var methodHandlers = {
+  wallet_getAllSnaps: _chunk4LSOS7SMjs.getAllSnapsHandler,
+  wallet_getSnaps: _chunkNWT2EXFDjs.getSnapsHandler,
+  wallet_requestSnaps: _chunkPS6OEQXLjs.requestSnapsHandler,
+  wallet_invokeSnap: _chunkIDZGMGIBjs.invokeSnapSugarHandler,
+  wallet_invokeKeyring: _chunkAOWUGDERjs.invokeKeyringHandler,
+  snap_getClientStatus: _chunk3UAWEHMFjs.getClientStatusHandler,
+  snap_getFile: _chunkNP3KGMVCjs.getFileHandler,
+  snap_createInterface: _chunk3LPBU737js.createInterfaceHandler,
+  snap_updateInterface: _chunkGP5KW5FUjs.updateInterfaceHandler,
+  snap_getInterfaceState: _chunk4W7U4OH6js.getInterfaceStateHandler
+};
+var handlers = Object.values(methodHandlers);
+
+
+
+
+exports.methodHandlers = methodHandlers; exports.handlers = handlers;
+//# sourceMappingURL=chunk-D6MUXDVI.js.map

package/dist/chunk-D6MUXDVI.js.map

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

package/dist/chunk-E6WUMFQT.mjs

@@ -0,0 +1,54 @@
+// src/restricted/manageAccounts.ts
+import { SubjectType, PermissionType } from "@metamask/permission-controller";
+import { JsonStruct } from "@metamask/utils";
+import { assert, string, object, union, array, record } from "superstruct";
+var SnapMessageStruct = union([
+  object({
+    method: string()
+  }),
+  object({
+    method: string(),
+    params: union([array(JsonStruct), record(string(), JsonStruct)])
+  })
+]);
+var methodName = "snap_manageAccounts";
+var specificationBuilder = ({
+  allowedCaveats = null,
+  methodHooks
+}) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName: methodName,
+    allowedCaveats,
+    methodImplementation: manageAccountsImplementation(methodHooks),
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+function manageAccountsImplementation({
+  getSnapKeyring
+}) {
+  return async function manageAccounts(options) {
+    const {
+      context: { origin },
+      params
+    } = options;
+    assert(params, SnapMessageStruct);
+    const keyring = await getSnapKeyring(origin);
+    return await keyring.handleKeyringSnapMessage(origin, params);
+  };
+}
+var manageAccountsBuilder = Object.freeze({
+  targetName: methodName,
+  specificationBuilder,
+  methodHooks: {
+    getSnapKeyring: true
+  }
+});
+
+export {
+  methodName,
+  specificationBuilder,
+  manageAccountsImplementation,
+  manageAccountsBuilder
+};
+//# sourceMappingURL=chunk-E6WUMFQT.mjs.map

package/dist/chunk-E6WUMFQT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/manageAccounts.ts"],"sourcesContent":["import type {\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n  PermissionSpecificationBuilder,\n} from '@metamask/permission-controller';\nimport { SubjectType, PermissionType } from '@metamask/permission-controller';\nimport type {\n  ManageAccountsParams,\n  ManageAccountsResult,\n} from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { JsonStruct } from '@metamask/utils';\nimport { assert, string, object, union, array, record } from 'superstruct';\n\nconst SnapMessageStruct = union([\n  object({\n    method: string(),\n  }),\n  object({\n    method: string(),\n    params: union([array(JsonStruct), record(string(), JsonStruct)]),\n  }),\n]);\n\ntype Message = InferMatching<typeof SnapMessageStruct, ManageAccountsParams>;\n\nexport const methodName = 'snap_manageAccounts';\n\nexport type ManageAccountsMethodHooks = {\n  /**\n   * Gets the snap keyring implementation.\n   */\n  getSnapKeyring: (snapOrigin: string) => Promise<{\n    handleKeyringSnapMessage: (\n      snapId: string,\n      message: Message,\n    ) => Promise<Json>;\n  }>;\n};\n\ntype ManageAccountsSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageAccountsMethodHooks;\n};\n\ntype ManageAccountsSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof manageAccountsImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageAccounts` permission.\n * `snap_manageAccounts` lets the Snap manage a set of accounts via a custom keyring.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_manageAccounts` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageAccountsSpecificationBuilderOptions,\n  ManageAccountsSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageAccountsSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: manageAccountsImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\n/**\n * Builds the method implementation for `snap_manageAccounts`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getSnapKeyring - A function to get the snap keyring.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function manageAccountsImplementation({\n  getSnapKeyring,\n}: ManageAccountsMethodHooks) {\n  return async function manageAccounts(\n    options: RestrictedMethodOptions<ManageAccountsParams>,\n  ): Promise<ManageAccountsResult> {\n    const {\n      context: { origin },\n      params,\n    } = options;\n\n    assert(params, SnapMessageStruct);\n    const keyring = await getSnapKeyring(origin);\n    return await keyring.handleKeyringSnapMessage(origin, params);\n  };\n}\n\nexport const manageAccountsBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks: {\n    getSnapKeyring: true,\n  },\n} as const);\n"],"mappings":";AAKA,SAAS,aAAa,sBAAsB;AAO5C,SAAS,kBAAkB;AAC3B,SAAS,QAAQ,QAAQ,QAAQ,OAAO,OAAO,cAAc;AAE7D,IAAM,oBAAoB,MAAM;AAAA,EAC9B,OAAO;AAAA,IACL,QAAQ,OAAO;AAAA,EACjB,CAAC;AAAA,EACD,OAAO;AAAA,IACL,QAAQ,OAAO;AAAA,IACf,QAAQ,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,OAAO,GAAG,UAAU,CAAC,CAAC;AAAA,EACjE,CAAC;AACH,CAAC;AAIM,IAAM,aAAa;AAmCnB,IAAM,uBAIT,CAAC;AAAA,EACH,iBAAiB;AAAA,EACjB;AACF,MAAiD;AAC/C,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ;AAAA,IACA,sBAAsB,6BAA6B,WAAW;AAAA,IAC9D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAWO,SAAS,6BAA6B;AAAA,EAC3C;AACF,GAA8B;AAC5B,SAAO,eAAe,eACpB,SAC+B;AAC/B,UAAM;AAAA,MACJ,SAAS,EAAE,OAAO;AAAA,MAClB;AAAA,IACF,IAAI;AAEJ,WAAO,QAAQ,iBAAiB;AAChC,UAAM,UAAU,MAAM,eAAe,MAAM;AAC3C,WAAO,MAAM,QAAQ,yBAAyB,QAAQ,MAAM;AAAA,EAC9D;AACF;AAEO,IAAM,wBAAwB,OAAO,OAAO;AAAA,EACjD,YAAY;AAAA,EACZ;AAAA,EACA,aAAa;AAAA,IACX,gBAAgB;AAAA,EAClB;AACF,CAAU;","names":[]}

package/dist/chunk-EEVEVBK6.mjs

@@ -0,0 +1,78 @@
+import {
+  createGenericPermissionValidator
+} from "./chunk-TT4DP2YW.mjs";
+
+// src/endowments/transaction-insight.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { SnapCaveatType } from "@metamask/snaps-utils";
+import { assert, hasProperty, isObject, isPlainObject } from "@metamask/utils";
+var permissionName = "endowment:transaction-insight" /* TransactionInsight */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: [
+      SnapCaveatType.TransactionOrigin,
+      SnapCaveatType.MaxRequestTime
+    ],
+    endowmentGetter: (_getterOptions) => void 0,
+    validator: createGenericPermissionValidator([
+      { type: SnapCaveatType.TransactionOrigin, optional: true },
+      { type: SnapCaveatType.MaxRequestTime, optional: true }
+    ]),
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var transactionInsightEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+function validateCaveat(caveat) {
+  if (!hasProperty(caveat, "value") || !isPlainObject(caveat)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected a plain object."
+    });
+  }
+  const { value } = caveat;
+  assert(
+    typeof value === "boolean",
+    'Expected caveat value to have type "boolean"'
+  );
+}
+function getTransactionInsightCaveatMapper(value) {
+  if (!value || !isObject(value) || isObject(value) && Object.keys(value).length === 0) {
+    return { caveats: null };
+  }
+  return {
+    caveats: [
+      {
+        type: SnapCaveatType.TransactionOrigin,
+        value: hasProperty(value, "allowTransactionOrigin") && value.allowTransactionOrigin
+      }
+    ]
+  };
+}
+function getTransactionOriginCaveat(permission) {
+  if (!permission?.caveats) {
+    return null;
+  }
+  assert(permission.caveats.length === 1);
+  assert(permission.caveats[0].type === SnapCaveatType.TransactionOrigin);
+  const caveat = permission.caveats[0];
+  return caveat.value ?? null;
+}
+var transactionInsightCaveatSpecifications = {
+  [SnapCaveatType.TransactionOrigin]: Object.freeze({
+    type: SnapCaveatType.TransactionOrigin,
+    validator: (caveat) => validateCaveat(caveat)
+  })
+};
+
+export {
+  transactionInsightEndowmentBuilder,
+  getTransactionInsightCaveatMapper,
+  getTransactionOriginCaveat,
+  transactionInsightCaveatSpecifications
+};
+//# sourceMappingURL=chunk-EEVEVBK6.mjs.map

package/dist/chunk-EEVEVBK6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/transaction-insight.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n  PermissionValidatorConstraint,\n  PermissionConstraint,\n  CaveatSpecificationConstraint,\n  Caveat,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isObject, isPlainObject } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.TransactionInsight;\n\ntype TransactionInsightEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * `endowment:transaction-insight` returns nothing; it is intended to be used as a flag\n * by the extension to detect whether the snap has the capability to show information on the transaction confirmation screen.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the transaction-insight endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  TransactionInsightEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.TransactionOrigin,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.TransactionOrigin, optional: true },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const transactionInsightEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Validates the type of the caveat value.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateCaveat(caveat: Caveat<string, any>): void {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n\n  assert(\n    typeof value === 'boolean',\n    'Expected caveat value to have type \"boolean\"',\n  );\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 getTransactionInsightCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && Object.keys(value).length === 0)\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.TransactionOrigin,\n        value:\n          hasProperty(value, 'allowTransactionOrigin') &&\n          (value.allowTransactionOrigin as boolean),\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the transaction origin caveat 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 transaction origin caveat from.\n * @returns The transaction origin, or `null` if the permission does not have a\n * transaction origin caveat.\n */\nexport function getTransactionOriginCaveat(\n  permission?: PermissionConstraint,\n): boolean | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.TransactionOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, boolean>;\n\n  return caveat.value ?? null;\n}\n\nexport const transactionInsightCaveatSpecifications: Record<\n  SnapCaveatType.TransactionOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.TransactionOrigin]: Object.freeze({\n    type: SnapCaveatType.TransactionOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveat(caveat),\n  }),\n};\n"],"mappings":";;;;;AASA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAC1B,SAAS,sBAAsB;AAE/B,SAAS,QAAQ,aAAa,UAAU,qBAAqB;AAK7D,IAAM;AAiBN,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,mBAAmB,UAAU,KAAK;AAAA,MACzD,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,qCAAqC,OAAO,OAAO;AAAA,EAC9D,YAAY;AAAA,EACZ;AACF,CAAU;AAQV,SAAS,eAAe,QAAmC;AACzD,MAAI,CAAC,YAAY,QAAQ,OAAO,KAAK,CAAC,cAAc,MAAM,GAAG;AAC3D,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAElB;AAAA,IACE,OAAO,UAAU;AAAA,IACjB;AAAA,EACF;AACF;AAUO,SAAS,kCACd,OACuC;AACvC,MACE,CAAC,SACD,CAAC,SAAS,KAAK,KACd,SAAS,KAAK,KAAK,OAAO,KAAK,KAAK,EAAE,WAAW,GAClD;AACA,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AACA,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB,OACE,YAAY,OAAO,wBAAwB,KAC1C,MAAM;AAAA,MACX;AAAA,IACF;AAAA,EACF;AACF;AAaO,SAAS,2BACd,YACgB;AAChB,MAAI,CAAC,YAAY,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,iBAAiB;AAEtE,QAAM,SAAS,WAAW,QAAQ,CAAC;AAEnC,SAAO,OAAO,SAAS;AACzB;AAEO,IAAM,yCAGT;AAAA,EACF,CAAC,eAAe,iBAAiB,GAAG,OAAO,OAAO;AAAA,IAChD,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,eAAe,MAAM;AAAA,EACnE,CAAC;AACH;","names":[]}

package/dist/chunk-EKXDFYIX.mjs

@@ -0,0 +1,68 @@
+// src/restricted/caveats/permittedCoinTypes.ts
+import { providerErrors, rpcErrors } from "@metamask/rpc-errors";
+import { FORBIDDEN_COIN_TYPES, SnapCaveatType } from "@metamask/snaps-utils";
+import { hasProperty, isPlainObject } from "@metamask/utils";
+function permittedCoinTypesCaveatMapper(value) {
+  return {
+    caveats: [
+      {
+        type: SnapCaveatType.PermittedCoinTypes,
+        value
+      }
+    ]
+  };
+}
+function validateBIP44Params(value) {
+  if (!isPlainObject(value) || !hasProperty(value, "coinType")) {
+    throw rpcErrors.invalidParams({
+      message: "Expected a plain object containing a coin type."
+    });
+  }
+  if (typeof value.coinType !== "number" || !Number.isInteger(value.coinType) || value.coinType < 0 || value.coinType > 2147483647) {
+    throw rpcErrors.invalidParams({
+      message: 'Invalid "coinType" parameter. Coin type must be a non-negative integer.'
+    });
+  }
+  if (FORBIDDEN_COIN_TYPES.includes(value.coinType)) {
+    throw rpcErrors.invalidParams({
+      message: `Coin type ${value.coinType} is forbidden.`
+    });
+  }
+}
+function validateBIP44Caveat(caveat) {
+  if (!hasProperty(caveat, "value") || !Array.isArray(caveat.value) || caveat.value.length === 0) {
+    throw rpcErrors.invalidParams({
+      message: "Expected non-empty array of coin types."
+    });
+  }
+  caveat.value.forEach(validateBIP44Params);
+}
+var PermittedCoinTypesCaveatSpecification = {
+  [SnapCaveatType.PermittedCoinTypes]: Object.freeze({
+    type: SnapCaveatType.PermittedCoinTypes,
+    decorator: (method, caveat) => {
+      return async (args) => {
+        const { params } = args;
+        validateBIP44Params(params);
+        const coinType = caveat.value.find(
+          (caveatValue) => caveatValue.coinType === params.coinType
+        );
+        if (!coinType) {
+          throw providerErrors.unauthorized({
+            message: "The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest."
+          });
+        }
+        return await method(args);
+      };
+    },
+    validator: (caveat) => validateBIP44Caveat(caveat)
+  })
+};
+
+export {
+  permittedCoinTypesCaveatMapper,
+  validateBIP44Params,
+  validateBIP44Caveat,
+  PermittedCoinTypesCaveatSpecification
+};
+//# sourceMappingURL=chunk-EKXDFYIX.mjs.map

package/dist/chunk-EKXDFYIX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/caveats/permittedCoinTypes.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  RestrictedMethodCaveatSpecificationConstraint,\n  Caveat,\n} from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport type { GetBip44EntropyParams } from '@metamask/snaps-sdk';\nimport { FORBIDDEN_COIN_TYPES, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, isPlainObject } from '@metamask/utils';\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 permittedCoinTypesCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.PermittedCoinTypes,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validate the params for `snap_getBip44Entropy`.\n *\n * @param value - The params to validate.\n * @throws If the params are invalid.\n */\nexport function validateBIP44Params(\n  value: unknown,\n): asserts value is GetBip44EntropyParams {\n  if (!isPlainObject(value) || !hasProperty(value, 'coinType')) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object containing a coin type.',\n    });\n  }\n\n  if (\n    typeof value.coinType !== 'number' ||\n    !Number.isInteger(value.coinType) ||\n    value.coinType < 0 ||\n    value.coinType > 0x7fffffff\n  ) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Invalid \"coinType\" parameter. Coin type must be a non-negative integer.',\n    });\n  }\n\n  if (FORBIDDEN_COIN_TYPES.includes(value.coinType)) {\n    throw rpcErrors.invalidParams({\n      message: `Coin type ${value.coinType} is forbidden.`,\n    });\n  }\n}\n\n/**\n * Validate the coin types values associated with a caveat. This checks if the\n * values are non-negative integers (>= 0).\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateBIP44Caveat(caveat: Caveat<string, any>) {\n  if (\n    !hasProperty(caveat, 'value') ||\n    !Array.isArray(caveat.value) ||\n    caveat.value.length === 0\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected non-empty array of coin types.',\n    });\n  }\n\n  caveat.value.forEach(validateBIP44Params);\n}\n\nexport const PermittedCoinTypesCaveatSpecification: Record<\n  SnapCaveatType.PermittedCoinTypes,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.PermittedCoinTypes]: Object.freeze({\n    type: SnapCaveatType.PermittedCoinTypes,\n    decorator: (\n      method,\n      caveat: Caveat<\n        SnapCaveatType.PermittedCoinTypes,\n        GetBip44EntropyParams[]\n      >,\n    ) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP44Params(params);\n\n        const coinType = caveat.value.find(\n          (caveatValue) => caveatValue.coinType === params.coinType,\n        );\n\n        if (!coinType) {\n          throw providerErrors.unauthorized({\n            message:\n              'The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest.',\n          });\n        }\n\n        return await method(args);\n      };\n    },\n    validator: (caveat) => validateBIP44Caveat(caveat),\n  }),\n};\n"],"mappings":";AAKA,SAAS,gBAAgB,iBAAiB;AAE1C,SAAS,sBAAsB,sBAAsB;AAErD,SAAS,aAAa,qBAAqB;AAUpC,SAAS,+BACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,oBACd,OACwC;AACxC,MAAI,CAAC,cAAc,KAAK,KAAK,CAAC,YAAY,OAAO,UAAU,GAAG;AAC5D,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,MACE,OAAO,MAAM,aAAa,YAC1B,CAAC,OAAO,UAAU,MAAM,QAAQ,KAChC,MAAM,WAAW,KACjB,MAAM,WAAW,YACjB;AACA,UAAM,UAAU,cAAc;AAAA,MAC5B,SACE;AAAA,IACJ,CAAC;AAAA,EACH;AAEA,MAAI,qBAAqB,SAAS,MAAM,QAAQ,GAAG;AACjD,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS,aAAa,MAAM,QAAQ;AAAA,IACtC,CAAC;AAAA,EACH;AACF;AASO,SAAS,oBAAoB,QAA6B;AAC/D,MACE,CAAC,YAAY,QAAQ,OAAO,KAC5B,CAAC,MAAM,QAAQ,OAAO,KAAK,KAC3B,OAAO,MAAM,WAAW,GACxB;AACA,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,SAAO,MAAM,QAAQ,mBAAmB;AAC1C;AAEO,IAAM,wCAGT;AAAA,EACF,CAAC,eAAe,kBAAkB,GAAG,OAAO,OAAO;AAAA,IACjD,MAAM,eAAe;AAAA,IACrB,WAAW,CACT,QACA,WAIG;AACH,aAAO,OAAO,SAAS;AACrB,cAAM,EAAE,OAAO,IAAI;AACnB,4BAAoB,MAAM;AAE1B,cAAM,WAAW,OAAO,MAAM;AAAA,UAC5B,CAAC,gBAAgB,YAAY,aAAa,OAAO;AAAA,QACnD;AAEA,YAAI,CAAC,UAAU;AACb,gBAAM,eAAe,aAAa;AAAA,YAChC,SACE;AAAA,UACJ,CAAC;AAAA,QACH;AAEA,eAAO,MAAM,OAAO,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,IACA,WAAW,CAAC,WAAW,oBAAoB,MAAM;AAAA,EACnD,CAAC;AACH;","names":[]}

package/dist/chunk-FBOZCV3C.js

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkLVTN25J2js = require('./chunk-LVTN25J2.js');
+
+
+var _chunkAYJK7MSHjs = require('./chunk-AYJK7MSH.js');
+
+
+var _chunkYG7W4CDTjs = require('./chunk-YG7W4CDT.js');
+
+
+
+var _chunkJRSPKOFGjs = require('./chunk-JRSPKOFG.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, _chunkAYJK7MSHjs.caveatMappers, initialPermission)) {
+        return [initialPermission, _chunkAYJK7MSHjs.caveatMappers[initialPermission](value)];
+      } else if (_utils.hasProperty.call(void 0, _chunkJRSPKOFGjs.endowmentCaveatMappers, initialPermission)) {
+        return [
+          initialPermission,
+          _chunkJRSPKOFGjs.endowmentCaveatMappers[initialPermission](value)
+        ];
+      }
+      return [
+        initialPermission,
+        value
+      ];
+    })
+  );
+}
+var buildSnapEndowmentSpecifications = (excludedEndowments) => Object.values(_chunkJRSPKOFGjs.endowmentPermissionBuilders).reduce((allSpecifications, { targetName, specificationBuilder }) => {
+  if (!excludedEndowments.includes(targetName)) {
+    allSpecifications[targetName] = specificationBuilder({});
+  }
+  return allSpecifications;
+}, {});
+var buildSnapRestrictedMethodSpecifications = (excludedPermissions, hooks) => Object.values(_chunkLVTN25J2js.restrictedMethodPermissionBuilders).reduce((specifications, { targetName, specificationBuilder, methodHooks }) => {
+  if (!excludedPermissions.includes(targetName)) {
+    specifications[targetName] = specificationBuilder({
+      // @ts-expect-error The selectHooks type is wonky
+      methodHooks: _chunkYG7W4CDTjs.selectHooks.call(void 0, 
+        hooks,
+        methodHooks
+      )
+    });
+  }
+  return specifications;
+}, {});
+
+
+
+
+
+exports.processSnapPermissions = processSnapPermissions; exports.buildSnapEndowmentSpecifications = buildSnapEndowmentSpecifications; exports.buildSnapRestrictedMethodSpecifications = buildSnapRestrictedMethodSpecifications;
+//# sourceMappingURL=chunk-FBOZCV3C.js.map

package/dist/chunk-FBOZCV3C.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-FCVWU5XH.js

@@ -0,0 +1,73 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/caveats/requestTime.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+function assertIsMaxRequestTime(value, ErrorWrapper) {
+  _utils.assertStruct.call(void 0, 
+    value,
+    _snapsutils.MaxRequestTimeStruct,
+    "Invalid maxRequestTime",
+    ErrorWrapper
+  );
+}
+function validateMaxRequestTimeCaveat(caveat) {
+  if (!_utils.hasProperty.call(void 0, caveat, "value")) {
+    throw _rpcerrors.rpcErrors.invalidParams({
+      message: "Invalid maxRequestTime caveat."
+    });
+  }
+  const { value } = caveat;
+  assertIsMaxRequestTime(value, _rpcerrors.rpcErrors.invalidParams);
+}
+function getMaxRequestTimeCaveatMapper(value) {
+  if (!value || !_utils.isObject.call(void 0, value) || _utils.isObject.call(void 0, value) && !_utils.hasProperty.call(void 0, value, "maxRequestTime")) {
+    return { caveats: null };
+  }
+  return {
+    caveats: [
+      {
+        type: _snapsutils.SnapCaveatType.MaxRequestTime,
+        value: value.maxRequestTime
+      }
+    ]
+  };
+}
+function createMaxRequestTimeMapper(mapper) {
+  return function(value) {
+    const { maxRequestTime, ...rest } = value;
+    const mapperResult = mapper(rest);
+    if (!maxRequestTime) {
+      return mapperResult;
+    }
+    return {
+      ...mapperResult,
+      caveats: [
+        ...mapperResult.caveats ?? [],
+        {
+          type: _snapsutils.SnapCaveatType.MaxRequestTime,
+          value: maxRequestTime
+        }
+      ]
+    };
+  };
+}
+function getMaxRequestTimeCaveat(permission) {
+  const foundCaveat = permission?.caveats?.find(
+    (caveat) => caveat.type === _snapsutils.SnapCaveatType.MaxRequestTime
+  );
+  return foundCaveat?.value ?? null;
+}
+var maxRequestTimeCaveatSpecifications = {
+  [_snapsutils.SnapCaveatType.MaxRequestTime]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.MaxRequestTime,
+    validator: (caveat) => validateMaxRequestTimeCaveat(caveat)
+  })
+};
+
+
+
+
+
+
+exports.getMaxRequestTimeCaveatMapper = getMaxRequestTimeCaveatMapper; exports.createMaxRequestTimeMapper = createMaxRequestTimeMapper; exports.getMaxRequestTimeCaveat = getMaxRequestTimeCaveat; exports.maxRequestTimeCaveatSpecifications = maxRequestTimeCaveatSpecifications;
+//# sourceMappingURL=chunk-FCVWU5XH.js.map

package/dist/chunk-FCVWU5XH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/caveats/requestTime.ts"],"names":[],"mappings":";AAKA,SAAS,iBAAiB;AAC1B,SAAS,sBAAsB,sBAAsB;AAErD,SAAS,cAAc,aAAa,gBAAgB;AAYpD,SAAS,uBACP,OACA,cACyB;AACzB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AASA,SAAS,6BAA6B,QAA6B;AACjE,MAAI,CAAC,YAAY,QAAQ,OAAO,GAAG;AACjC,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAClB,yBAAuB,OAAO,UAAU,aAAa;AACvD;AAUO,SAAS,8BACd,OACyB;AACzB,MACE,CAAC,SACD,CAAC,SAAS,KAAK,KACd,SAAS,KAAK,KAAK,CAAC,YAAY,OAAO,gBAAgB,GACxD;AACA,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AACA,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB,OAAO,MAAM;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACF;AASO,SAAS,2BACd,QACsB;AACtB,SAAO,SAAU,OAAa;AAE5B,UAAM,EAAE,gBAAgB,GAAG,KAAK,IAAI;AAEpC,UAAM,eAAe,OAAO,IAAI;AAEhC,QAAI,CAAC,gBAAgB;AACnB,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,MACL,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAI,aAAa,WAAW,CAAC;AAAA,QAC7B;AAAA,UACE,MAAM,eAAe;AAAA,UACrB,OAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,wBACd,YACe;AACf,QAAM,cAAc,YAAY,SAAS;AAAA,IACvC,CAAC,WAAW,OAAO,SAAS,eAAe;AAAA,EAC7C;AACA,SAAQ,aAAa,SAAoB;AAC3C;AAEO,IAAM,qCAGT;AAAA,EACF,CAAC,eAAe,cAAc,GAAG,OAAO,OAAO;AAAA,IAC7C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WACV,6BAA6B,MAAM;AAAA,EACvC,CAAC;AACH","sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { MaxRequestTimeStruct, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { AssertionErrorConstructor, Json } from '@metamask/utils';\nimport { assertStruct, hasProperty, isObject } from '@metamask/utils';\n\nimport type { CaveatMapperFunction, CaveatMapperReturnValue } from './generic';\n\n/**\n * Asserts that the given value is a valid `maxRequestTime` value.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid `maxRequestTime` value.\n */\nfunction assertIsMaxRequestTime(\n  value: unknown, // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is number {\n  assertStruct(\n    value,\n    MaxRequestTimeStruct,\n    'Invalid maxRequestTime',\n    ErrorWrapper,\n  );\n}\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 validateMaxRequestTimeCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value')) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid maxRequestTime caveat.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsMaxRequestTime(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 getMaxRequestTimeCaveatMapper(\n  value: Json,\n): CaveatMapperReturnValue {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && !hasProperty(value, 'maxRequestTime'))\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.MaxRequestTime,\n        value: value.maxRequestTime,\n      },\n    ],\n  };\n}\n\n/**\n * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat\n * and merges it with any other caveats created by the mapper function.\n *\n * @param mapper - Another caveat mapper function.\n * @returns The caveat specification.\n */\nexport function createMaxRequestTimeMapper(\n  mapper: CaveatMapperFunction,\n): CaveatMapperFunction {\n  return function (value: Json) {\n    // We assume this to be used only with caveats of this type\n    const { maxRequestTime, ...rest } = value as Record<string, Json>;\n\n    const mapperResult = mapper(rest);\n\n    if (!maxRequestTime) {\n      return mapperResult;\n    }\n\n    return {\n      ...mapperResult,\n      caveats: [\n        ...(mapperResult.caveats ?? []),\n        {\n          type: SnapCaveatType.MaxRequestTime,\n          value: maxRequestTime,\n        },\n      ],\n    };\n  };\n}\n\n/**\n * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value if present, otherwise null.\n */\nexport function getMaxRequestTimeCaveat(\n  permission?: PermissionConstraint,\n): number | null {\n  const foundCaveat = permission?.caveats?.find(\n    (caveat) => caveat.type === SnapCaveatType.MaxRequestTime,\n  );\n  return (foundCaveat?.value as number) ?? null;\n}\n\nexport const maxRequestTimeCaveatSpecifications: Record<\n  SnapCaveatType.MaxRequestTime,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.MaxRequestTime]: Object.freeze({\n    type: SnapCaveatType.MaxRequestTime,\n    validator: (caveat: Caveat<string, any>) =>\n      validateMaxRequestTimeCaveat(caveat),\n  }),\n};\n"]}

package/dist/chunk-FFHVA6PP.js

@@ -0,0 +1,82 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/invokeSnap.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapsutils = require('@metamask/snaps-utils');
+var WALLET_SNAP_PERMISSION_KEY = "wallet_snap";
+var handleSnapInstall = async ({ requestData, messagingSystem }) => {
+  const snaps = requestData.permissions[WALLET_SNAP_PERMISSION_KEY].caveats?.[0].value;
+  const permittedSnaps = messagingSystem.call(
+    `SnapController:getPermitted`,
+    requestData.metadata.origin
+  );
+  const dedupedSnaps = Object.keys(snaps).reduce(
+    (filteredSnaps, snap) => {
+      if (!permittedSnaps[snap]) {
+        filteredSnaps[snap] = snaps[snap];
+      }
+      return filteredSnaps;
+    },
+    {}
+  );
+  return messagingSystem.call(
+    `SnapController:install`,
+    requestData.metadata.origin,
+    dedupedSnaps
+  );
+};
+var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
+    targetName: WALLET_SNAP_PERMISSION_KEY,
+    allowedCaveats: [_snapsutils.SnapCaveatType.SnapIds],
+    methodImplementation: getInvokeSnapImplementation(methodHooks2),
+    validator: ({ caveats }) => {
+      if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.SnapIds) {
+        throw _rpcerrors.rpcErrors.invalidParams({
+          message: `Expected a single "${_snapsutils.SnapCaveatType.SnapIds}" caveat.`
+        });
+      }
+    },
+    sideEffect: {
+      onPermitted: handleSnapInstall
+    }
+  };
+};
+var methodHooks = {
+  getSnap: true,
+  handleSnapRpcRequest: true
+};
+var invokeSnapBuilder = Object.freeze({
+  targetName: WALLET_SNAP_PERMISSION_KEY,
+  specificationBuilder,
+  methodHooks
+});
+function getInvokeSnapImplementation({
+  getSnap,
+  handleSnapRpcRequest
+}) {
+  return async function invokeSnap(options) {
+    const { params = {}, context } = options;
+    const { snapId, request } = params;
+    if (!getSnap(snapId)) {
+      throw _rpcerrors.rpcErrors.invalidRequest({
+        message: `The snap "${snapId}" is not installed. Please install it first, before invoking the snap.`
+      });
+    }
+    const { origin } = context;
+    return await handleSnapRpcRequest({
+      snapId,
+      origin,
+      request,
+      handler: _snapsutils.HandlerType.OnRpcRequest
+    });
+  };
+}
+
+
+
+
+
+
+exports.WALLET_SNAP_PERMISSION_KEY = WALLET_SNAP_PERMISSION_KEY; exports.handleSnapInstall = handleSnapInstall; exports.invokeSnapBuilder = invokeSnapBuilder; exports.getInvokeSnapImplementation = getInvokeSnapImplementation;
+//# sourceMappingURL=chunk-FFHVA6PP.js.map

package/dist/chunk-FFHVA6PP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/invokeSnap.ts"],"names":["methodHooks"],"mappings":";AAOA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAO1B,SAAS,aAAa,sBAAsB;AAKrC,IAAM,6BAA6B;AAwDnC,IAAM,oBAGM,OAAO,EAAE,aAAa,gBAAgB,MAAM;AAC7D,QAAM,QAAQ,YAAY,YAAY,0BAA0B,EAAE,UAAU,CAAC,EAC1E;AAEH,QAAM,iBAAiB,gBAAgB;AAAA,IACrC;AAAA,IACA,YAAY,SAAS;AAAA,EACvB;AAEA,QAAM,eAAe,OAAO,KAAK,KAAK,EAAE;AAAA,IACtC,CAAC,eAAe,SAAS;AACvB,UAAI,CAAC,eAAe,IAAI,GAAG;AACzB,sBAAc,IAAI,IAAI,MAAM,IAAI;AAAA,MAClC;AACA,aAAO;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH;AAEA,SAAO,gBAAgB;AAAA,IACrB;AAAA,IACA,YAAY,SAAS;AAAA,IACrB;AAAA,EACF;AACF;AAaA,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAA6C;AAC9D,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB,CAAC,eAAe,OAAO;AAAA,IACvC,sBAAsB,4BAA4BA,YAAW;AAAA,IAC7D,WAAW,CAAC,EAAE,QAAQ,MAAM;AAC1B,UAAI,SAAS,WAAW,KAAK,QAAQ,CAAC,EAAE,SAAS,eAAe,SAAS;AACvE,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS,sBAAsB,eAAe,OAAO;AAAA,QACvD,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,YAAY;AAAA,MACV,aAAa;AAAA,IACf;AAAA,EACF;AACF;AAEA,IAAM,cAAwD;AAAA,EAC5D,SAAS;AAAA,EACT,sBAAsB;AACxB;AAEO,IAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AAWH,SAAS,4BAA4B;AAAA,EAC1C;AAAA,EACA;AACF,GAA0B;AACxB,SAAO,eAAe,WACpB,SAC2B;AAC3B,UAAM,EAAE,SAAS,CAAC,GAAG,QAAQ,IAAI;AAEjC,UAAM,EAAE,QAAQ,QAAQ,IAAI;AAE5B,QAAI,CAAC,QAAQ,MAAM,GAAG;AACpB,YAAM,UAAU,eAAe;AAAA,QAC7B,SAAS,aAAa,MAAM;AAAA,MAC9B,CAAC;AAAA,IACH;AAEA,UAAM,EAAE,OAAO,IAAI;AAEnB,WAAQ,MAAM,qBAAqB;AAAA,MACjC;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,YAAY;AAAA,IACvB,CAAC;AAAA,EACH;AACF","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n  PermissionValidatorConstraint,\n  PermissionSideEffect,\n} from '@metamask/permission-controller';\nimport { PermissionType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  InvokeSnapResult,\n  RequestSnapsParams,\n  RequestSnapsResult,\n} from '@metamask/snaps-sdk';\nimport type { Snap, SnapRpcHookArgs } from '@metamask/snaps-utils';\nimport { HandlerType, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';\n\n// Redeclare installSnaps action type to avoid circular dependencies\nexport type InstallSnaps = {\n  type: `SnapController:install`;\n  handler: (\n    origin: string,\n    requestedSnaps: RequestSnapsParams,\n  ) => Promise<RequestSnapsResult>;\n};\n\nexport type GetPermittedSnaps = {\n  type: `SnapController:getPermitted`;\n  handler: (origin: string) => RequestSnapsResult;\n};\n\ntype AllowedActions = InstallSnaps | GetPermittedSnaps;\n\nexport type InvokeSnapMethodHooks = {\n  getSnap: (snapId: string) => Snap | undefined;\n  handleSnapRpcRequest: ({\n    snapId,\n    origin,\n    handler,\n    request,\n  }: SnapRpcHookArgs & { snapId: string }) => Promise<unknown>;\n};\n\ntype InvokeSnapSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: InvokeSnapMethodHooks;\n};\n\ntype InvokeSnapSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof WALLET_SNAP_PERMISSION_KEY;\n  methodImplementation: ReturnType<typeof getInvokeSnapImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  sideEffect: {\n    onPermitted: PermissionSideEffect<AllowedActions, never>['onPermitted'];\n  };\n}>;\n\nexport type InvokeSnapParams = {\n  snapId: string;\n  request: Record<string, Json>;\n};\n\n/**\n * The side-effect method to handle the snap install.\n *\n * @param params - The side-effect params.\n * @param params.requestData - The request data associated to the requested permission.\n * @param params.messagingSystem - The messenger to call an action.\n */\nexport const handleSnapInstall: PermissionSideEffect<\n  AllowedActions,\n  never\n>['onPermitted'] = async ({ requestData, messagingSystem }) => {\n  const snaps = requestData.permissions[WALLET_SNAP_PERMISSION_KEY].caveats?.[0]\n    .value as RequestSnapsParams;\n\n  const permittedSnaps = messagingSystem.call(\n    `SnapController:getPermitted`,\n    requestData.metadata.origin,\n  );\n\n  const dedupedSnaps = Object.keys(snaps).reduce<RequestSnapsParams>(\n    (filteredSnaps, snap) => {\n      if (!permittedSnaps[snap]) {\n        filteredSnaps[snap] = snaps[snap];\n      }\n      return filteredSnaps;\n    },\n    {},\n  );\n\n  return messagingSystem.call(\n    `SnapController:install`,\n    requestData.metadata.origin,\n    dedupedSnaps,\n  );\n};\n/**\n * The specification builder for the `wallet_snap_*` permission.\n *\n * `wallet_snap_*` attempts to invoke an RPC method of the specified Snap.\n *\n * Requesting its corresponding permission will attempt to connect to the Snap,\n * and install it if it's not available yet.\n *\n * @param options - The specification builder options.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `wallet_snap_*` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  InvokeSnapSpecificationBuilderOptions,\n  InvokeSnapSpecification\n> = ({ methodHooks }: InvokeSnapSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: WALLET_SNAP_PERMISSION_KEY,\n    allowedCaveats: [SnapCaveatType.SnapIds],\n    methodImplementation: getInvokeSnapImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.SnapIds) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.SnapIds}\" caveat.`,\n        });\n      }\n    },\n    sideEffect: {\n      onPermitted: handleSnapInstall,\n    },\n  };\n};\n\nconst methodHooks: MethodHooksObject<InvokeSnapMethodHooks> = {\n  getSnap: true,\n  handleSnapRpcRequest: true,\n};\n\nexport const invokeSnapBuilder = Object.freeze({\n  targetName: WALLET_SNAP_PERMISSION_KEY,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `wallet_snap_*`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getSnap - A function that retrieves all information stored about a snap.\n * @param hooks.handleSnapRpcRequest - A function that sends an RPC request to a snap's RPC handler or throws if that fails.\n * @returns The method implementation which returns the result of `handleSnapRpcRequest`.\n * @throws If the params are invalid.\n */\nexport function getInvokeSnapImplementation({\n  getSnap,\n  handleSnapRpcRequest,\n}: InvokeSnapMethodHooks) {\n  return async function invokeSnap(\n    options: RestrictedMethodOptions<InvokeSnapParams>,\n  ): Promise<InvokeSnapResult> {\n    const { params = {}, context } = options;\n\n    const { snapId, request } = params as InvokeSnapParams;\n\n    if (!getSnap(snapId)) {\n      throw rpcErrors.invalidRequest({\n        message: `The snap \"${snapId}\" is not installed. Please install it first, before invoking the snap.`,\n      });\n    }\n\n    const { origin } = context;\n\n    return (await handleSnapRpcRequest({\n      snapId,\n      origin,\n      request,\n      handler: HandlerType.OnRpcRequest,\n    })) as Json;\n  };\n}\n"]}

package/dist/chunk-FMDV3RFT.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/home-page.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var permissionName = "endowment:page-home" /* HomePage */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: null,
+    endowmentGetter: (_getterOptions) => void 0,
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var homePageEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+
+
+
+exports.homePageEndowmentBuilder = homePageEndowmentBuilder;
+//# sourceMappingURL=chunk-FMDV3RFT.js.map