@metamask/snaps-rpc-methods 11.0.0 → 11.1.1

package/dist/chunk-MXPVC2XP.mjs

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

package/dist/chunk-MXPVC2XP.mjs.map

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

package/dist/chunk-NU4NAAFG.js

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

package/dist/chunk-NU4NAAFG.js.map

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

package/dist/chunk-NWT2EXFD.js

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

package/dist/chunk-NWT2EXFD.js.map

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

package/dist/chunk-O66NZFSD.mjs

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

package/dist/chunk-O66NZFSD.mjs.map

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

package/dist/chunk-ODN35VOK.mjs

@@ -1,119 +0,0 @@
-import {
-  createGenericPermissionValidator
-} from "./chunk-TT4DP2YW.mjs";
-
-// src/endowments/name-lookup.ts
-import { PermissionType, SubjectType } from "@metamask/permission-controller";
-import { rpcErrors } from "@metamask/rpc-errors";
-import {
-  ChainIdsStruct,
-  LookupMatchersStruct,
-  SnapCaveatType
-} from "@metamask/snaps-utils";
-import {
-  assert,
-  assertStruct,
-  hasProperty,
-  isObject,
-  isPlainObject
-} from "@metamask/utils";
-var permissionName = "endowment:name-lookup" /* NameLookup */;
-var specificationBuilder = (_builderOptions) => {
-  return {
-    permissionType: PermissionType.Endowment,
-    targetName: permissionName,
-    allowedCaveats: [
-      SnapCaveatType.ChainIds,
-      SnapCaveatType.LookupMatchers,
-      SnapCaveatType.MaxRequestTime
-    ],
-    endowmentGetter: (_getterOptions) => null,
-    validator: createGenericPermissionValidator([
-      { type: SnapCaveatType.ChainIds, optional: true },
-      { type: SnapCaveatType.LookupMatchers, optional: true },
-      { type: SnapCaveatType.MaxRequestTime, optional: true }
-    ]),
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var nameLookupEndowmentBuilder = 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;
-  switch (caveat.type) {
-    case SnapCaveatType.ChainIds:
-      assertStruct(value, ChainIdsStruct);
-      break;
-    case SnapCaveatType.LookupMatchers:
-      assertStruct(value, LookupMatchersStruct);
-      break;
-    default:
-      throw rpcErrors.invalidParams({
-        message: 'Invalid caveat type, must be one of the following: "chainIds", "matchers".'
-      });
-  }
-}
-function getNameLookupCaveatMapper(value) {
-  if (!value || !isObject(value) || Object.keys(value).length === 0) {
-    return { caveats: null };
-  }
-  const caveats = [];
-  if (value.chains) {
-    caveats.push({
-      type: SnapCaveatType.ChainIds,
-      value: value.chains
-    });
-  }
-  if (value.matchers) {
-    caveats.push({
-      type: SnapCaveatType.LookupMatchers,
-      value: value.matchers
-    });
-  }
-  assert(caveats.length > 0);
-  return { caveats };
-}
-function getChainIdsCaveat(permission) {
-  if (!permission?.caveats) {
-    return null;
-  }
-  const caveat = permission.caveats.find(
-    (permCaveat) => permCaveat.type === SnapCaveatType.ChainIds
-  );
-  return caveat ? caveat.value : null;
-}
-function getLookupMatchersCaveat(permission) {
-  if (!permission?.caveats) {
-    return null;
-  }
-  const caveat = permission.caveats.find(
-    (permCaveat) => permCaveat.type === SnapCaveatType.LookupMatchers
-  );
-  return caveat ? caveat.value : null;
-}
-var nameLookupCaveatSpecifications = {
-  [SnapCaveatType.ChainIds]: Object.freeze({
-    type: SnapCaveatType.ChainIds,
-    validator: (caveat) => validateCaveat(caveat)
-  }),
-  [SnapCaveatType.LookupMatchers]: Object.freeze({
-    type: SnapCaveatType.LookupMatchers,
-    validator: (caveat) => validateCaveat(caveat)
-  })
-};
-
-export {
-  nameLookupEndowmentBuilder,
-  getNameLookupCaveatMapper,
-  getChainIdsCaveat,
-  getLookupMatchersCaveat,
-  nameLookupCaveatSpecifications
-};
-//# sourceMappingURL=chunk-ODN35VOK.mjs.map

package/dist/chunk-ODN35VOK.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endowments/name-lookup.ts"],"sourcesContent":["import type {\n  EndowmentGetterParams,\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  ValidPermissionSpecification,\n  Caveat,\n  CaveatSpecificationConstraint,\n  PermissionConstraint,\n  CaveatConstraint,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport {\n  ChainIdsStruct,\n  LookupMatchersStruct,\n  SnapCaveatType,\n} from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport {\n  assert,\n  assertStruct,\n  hasProperty,\n  isObject,\n  isPlainObject,\n} from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.NameLookup;\n\ntype NameLookupEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => null;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * `endowment:name-lookup` returns nothing; it is intended to be used as a flag\n * by the extension to detect whether the snap has the capability to resolve a domain/address.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the name-lookup endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  NameLookupEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.ChainIds,\n      SnapCaveatType.LookupMatchers,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => null,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.ChainIds, optional: true },\n      { type: SnapCaveatType.LookupMatchers, optional: true },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const nameLookupEndowmentBuilder = 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  switch (caveat.type) {\n    case SnapCaveatType.ChainIds:\n      assertStruct(value, ChainIdsStruct);\n      break;\n    case SnapCaveatType.LookupMatchers:\n      assertStruct(value, LookupMatchersStruct);\n      break;\n    default:\n      throw rpcErrors.invalidParams({\n        message:\n          'Invalid caveat type, must be one of the following: \"chainIds\", \"matchers\".',\n      });\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 getNameLookupCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  if (!value || !isObject(value) || Object.keys(value).length === 0) {\n    return { caveats: null };\n  }\n\n  const caveats = [];\n\n  if (value.chains) {\n    caveats.push({\n      type: SnapCaveatType.ChainIds,\n      value: value.chains,\n    });\n  }\n\n  if (value.matchers) {\n    caveats.push({\n      type: SnapCaveatType.LookupMatchers,\n      value: value.matchers,\n    });\n  }\n\n  assert(caveats.length > 0);\n\n  return { caveats: caveats as NonEmptyArray<CaveatConstraint> };\n}\n\n/**\n * Getter function to get the chainIds 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 `chainIds` caveat from.\n * @returns An array of `chainIds` that the snap supports.\n */\nexport function getChainIdsCaveat(\n  permission?: PermissionConstraint,\n): string[] | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  const caveat = permission.caveats.find(\n    (permCaveat) => permCaveat.type === SnapCaveatType.ChainIds,\n  ) as Caveat<string, string[]> | undefined;\n\n  return caveat ? caveat.value : null;\n}\n\n/**\n * Getter function to get the matchers 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 `matchers` caveat from.\n * @returns A `matchers` object that defines the input that the snap supports.\n */\nexport function getLookupMatchersCaveat(\n  permission?: PermissionConstraint,\n): Record<string, string[]> | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  const caveat = permission.caveats.find(\n    (permCaveat) => permCaveat.type === SnapCaveatType.LookupMatchers,\n  ) as Caveat<string, Record<string, string[]>> | undefined;\n\n  return caveat ? caveat.value : null;\n}\n\nexport const nameLookupCaveatSpecifications: Record<\n  SnapCaveatType.ChainIds | SnapCaveatType.LookupMatchers,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.ChainIds]: Object.freeze({\n    type: SnapCaveatType.ChainIds,\n    validator: (caveat: Caveat<string, any>) => validateCaveat(caveat),\n  }),\n  [SnapCaveatType.LookupMatchers]: Object.freeze({\n    type: SnapCaveatType.LookupMatchers,\n    validator: (caveat: Caveat<string, any>) => validateCaveat(caveat),\n  }),\n};\n"],"mappings":";;;;;AAUA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP,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,MACf,eAAe;AAAA,IACjB;AAAA,IACA,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,WAAW,iCAAiC;AAAA,MAC1C,EAAE,MAAM,eAAe,UAAU,UAAU,KAAK;AAAA,MAChD,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,MACtD,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,6BAA6B,OAAO,OAAO;AAAA,EACtD,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,UAAQ,OAAO,MAAM;AAAA,IACnB,KAAK,eAAe;AAClB,mBAAa,OAAO,cAAc;AAClC;AAAA,IACF,KAAK,eAAe;AAClB,mBAAa,OAAO,oBAAoB;AACxC;AAAA,IACF;AACE,YAAM,UAAU,cAAc;AAAA,QAC5B,SACE;AAAA,MACJ,CAAC;AAAA,EACL;AACF;AAUO,SAAS,0BACd,OACuC;AACvC,MAAI,CAAC,SAAS,CAAC,SAAS,KAAK,KAAK,OAAO,KAAK,KAAK,EAAE,WAAW,GAAG;AACjE,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AAEA,QAAM,UAAU,CAAC;AAEjB,MAAI,MAAM,QAAQ;AAChB,YAAQ,KAAK;AAAA,MACX,MAAM,eAAe;AAAA,MACrB,OAAO,MAAM;AAAA,IACf,CAAC;AAAA,EACH;AAEA,MAAI,MAAM,UAAU;AAClB,YAAQ,KAAK;AAAA,MACX,MAAM,eAAe;AAAA,MACrB,OAAO,MAAM;AAAA,IACf,CAAC;AAAA,EACH;AAEA,SAAO,QAAQ,SAAS,CAAC;AAEzB,SAAO,EAAE,QAAoD;AAC/D;AAYO,SAAS,kBACd,YACiB;AACjB,MAAI,CAAC,YAAY,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,WAAW,QAAQ;AAAA,IAChC,CAAC,eAAe,WAAW,SAAS,eAAe;AAAA,EACrD;AAEA,SAAO,SAAS,OAAO,QAAQ;AACjC;AAYO,SAAS,wBACd,YACiC;AACjC,MAAI,CAAC,YAAY,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,WAAW,QAAQ;AAAA,IAChC,CAAC,eAAe,WAAW,SAAS,eAAe;AAAA,EACrD;AAEA,SAAO,SAAS,OAAO,QAAQ;AACjC;AAEO,IAAM,iCAGT;AAAA,EACF,CAAC,eAAe,QAAQ,GAAG,OAAO,OAAO;AAAA,IACvC,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,eAAe,MAAM;AAAA,EACnE,CAAC;AAAA,EACD,CAAC,eAAe,cAAc,GAAG,OAAO,OAAO;AAAA,IAC7C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,eAAe,MAAM;AAAA,EACnE,CAAC;AACH;","names":[]}

package/dist/chunk-OI33OL7K.js

@@ -1,47 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/createInterface.ts
-var _rpcerrors = require('@metamask/rpc-errors');
-
-
-
-var _snapssdk = require('@metamask/snaps-sdk');
-var _superstruct = require('@metamask/superstruct');
-var hookNames = {
-  createInterface: true
-};
-var createInterfaceHandler = {
-  methodNames: ["snap_createInterface"],
-  implementation: getCreateInterfaceImplementation,
-  hookNames
-};
-var CreateInterfaceParametersStruct = _superstruct.object.call(void 0, {
-  ui: _snapssdk.ComponentOrElementStruct,
-  context: _superstruct.optional.call(void 0, _snapssdk.InterfaceContextStruct)
-});
-async function getCreateInterfaceImplementation(req, res, _next, end, { createInterface }) {
-  const { params } = req;
-  try {
-    const validatedParams = getValidatedParams(params);
-    const { ui, context } = validatedParams;
-    res.result = await createInterface(ui, context);
-  } catch (error) {
-    return end(error);
-  }
-  return end();
-}
-function getValidatedParams(params) {
-  try {
-    return _superstruct.create.call(void 0, params, CreateInterfaceParametersStruct);
-  } catch (error) {
-    if (error instanceof _superstruct.StructError) {
-      throw _rpcerrors.rpcErrors.invalidParams({
-        message: `Invalid params: ${error.message}.`
-      });
-    }
-    throw _rpcerrors.rpcErrors.internal();
-  }
-}
-
-
-
-exports.createInterfaceHandler = createInterfaceHandler;
-//# sourceMappingURL=chunk-OI33OL7K.js.map

package/dist/chunk-OI33OL7K.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/createInterface.ts"],"names":[],"mappings":";AAEA,SAAS,iBAAiB;AAQ1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,aAAa,QAAQ,QAAQ,gBAAgB;AAKtD,IAAM,YAA2D;AAAA,EAC/D,iBAAiB;AACnB;AAaO,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,sBAAsB;AAAA,EACpC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,kCAAkC,OAAO;AAAA,EAC7C,IAAI;AAAA,EACJ,SAAS,SAAS,sBAAsB;AAC1C,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,IAAI,QAAQ,IAAI;AAExB,QAAI,SAAS,MAAM,gBAAgB,IAAI,OAAO;AAAA,EAChD,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","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  CreateInterfaceParams,\n  CreateInterfaceResult,\n  JsonRpcRequest,\n  ComponentOrElement,\n  InterfaceContext,\n} from '@metamask/snaps-sdk';\nimport {\n  ComponentOrElementStruct,\n  InterfaceContextStruct,\n} from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport { StructError, create, object, optional } from '@metamask/superstruct';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\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: (\n    ui: ComponentOrElement,\n    context?: InterfaceContext,\n  ) => 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: ComponentOrElementStruct,\n  context: optional(InterfaceContextStruct),\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, context } = validatedParams;\n\n    res.result = await createInterface(ui, context);\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"]}

package/dist/chunk-PIAWDTWO.mjs

@@ -1,68 +0,0 @@
-// 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-PIAWDTWO.mjs.map

package/dist/chunk-PIAWDTWO.mjs.map

@@ -1 +0,0 @@
-{"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: (method, caveat) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP44Params(params);\n\n        const coinType = (caveat.value as GetBip44EntropyParams[]).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,CAAC,QAAQ,WAAW;AAC7B,aAAO,OAAO,SAAS;AACrB,cAAM,EAAE,OAAO,IAAI;AACnB,4BAAoB,MAAM;AAE1B,cAAM,WAAY,OAAO,MAAkC;AAAA,UACzD,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-PIRQCNBJ.mjs

@@ -1,78 +0,0 @@
-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) => null,
-    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-PIRQCNBJ.mjs.map

package/dist/chunk-PIRQCNBJ.mjs.map

@@ -1 +0,0 @@
-{"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) => null;\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) => null,\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-PK2RPAXI.js

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

package/dist/chunk-PK2RPAXI.js.map

@@ -1 +0,0 @@
-{"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"]}