@metamask/snaps-rpc-methods 10.0.1 → 11.1.0

package/dist/chunk-33LLA2MH.mjs

@@ -1,75 +0,0 @@
-import {
-  createGenericPermissionValidator
-} from "./chunk-TT4DP2YW.mjs";
-
-// src/endowments/signature-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:signature-insight" /* SignatureInsight */;
-var specificationBuilder = (_builderOptions) => {
-  return {
-    permissionType: PermissionType.Endowment,
-    targetName: permissionName,
-    allowedCaveats: [SnapCaveatType.SignatureOrigin],
-    endowmentGetter: (_getterOptions) => null,
-    validator: createGenericPermissionValidator([
-      { type: SnapCaveatType.SignatureOrigin, optional: true },
-      { type: SnapCaveatType.MaxRequestTime, optional: true }
-    ]),
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var signatureInsightEndowmentBuilder = 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 getSignatureInsightCaveatMapper(value) {
-  if (!value || !isObject(value) || isObject(value) && Object.keys(value).length === 0) {
-    return { caveats: null };
-  }
-  return {
-    caveats: [
-      {
-        type: SnapCaveatType.SignatureOrigin,
-        value: hasProperty(value, "allowSignatureOrigin") && value.allowSignatureOrigin
-      }
-    ]
-  };
-}
-function getSignatureOriginCaveat(permission) {
-  if (!permission?.caveats) {
-    return null;
-  }
-  assert(permission.caveats.length === 1);
-  assert(permission.caveats[0].type === SnapCaveatType.SignatureOrigin);
-  const caveat = permission.caveats[0];
-  return caveat.value ?? null;
-}
-var signatureInsightCaveatSpecifications = {
-  [SnapCaveatType.SignatureOrigin]: Object.freeze({
-    type: SnapCaveatType.SignatureOrigin,
-    validator: (caveat) => validateCaveat(caveat)
-  })
-};
-
-export {
-  signatureInsightEndowmentBuilder,
-  getSignatureInsightCaveatMapper,
-  getSignatureOriginCaveat,
-  signatureInsightCaveatSpecifications
-};
-//# sourceMappingURL=chunk-33LLA2MH.mjs.map

package/dist/chunk-33LLA2MH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endowments/signature-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.SignatureInsight;\n\ntype SignatureInsightEndowmentSpecification = 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:signature-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 signature confirmation screen.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the signature-insight endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  SignatureInsightEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [SnapCaveatType.SignatureOrigin],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => null,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.SignatureOrigin, optional: true },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const signatureInsightEndowmentBuilder = 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 * PermissionController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getSignatureInsightCaveatMapper(\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.SignatureOrigin,\n        value:\n          hasProperty(value, 'allowSignatureOrigin') &&\n          (value.allowSignatureOrigin as boolean),\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the signature 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 signature origin caveat from.\n * @returns The signature origin, or `null` if the permission does not have a\n * signature origin caveat.\n */\nexport function getSignatureOriginCaveat(\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.SignatureOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, boolean>;\n\n  return caveat.value ?? null;\n}\n\nexport const signatureInsightCaveatSpecifications: Record<\n  SnapCaveatType.SignatureOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SignatureOrigin]: Object.freeze({\n    type: SnapCaveatType.SignatureOrigin,\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,CAAC,eAAe,eAAe;AAAA,IAC/C,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,WAAW,iCAAiC;AAAA,MAC1C,EAAE,MAAM,eAAe,iBAAiB,UAAU,KAAK;AAAA,MACvD,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,mCAAmC,OAAO,OAAO;AAAA,EAC5D,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,gCACd,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,sBAAsB,KACxC,MAAM;AAAA,MACX;AAAA,IACF;AAAA,EACF;AACF;AAaO,SAAS,yBACd,YACgB;AAChB,MAAI,CAAC,YAAY,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,eAAe;AAEpE,QAAM,SAAS,WAAW,QAAQ,CAAC;AAEnC,SAAO,OAAO,SAAS;AACzB;AAEO,IAAM,uCAGT;AAAA,EACF,CAAC,eAAe,eAAe,GAAG,OAAO,OAAO;AAAA,IAC9C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,eAAe,MAAM;AAAA,EACnE,CAAC;AACH;","names":[]}

package/dist/chunk-33MTKZ4H.js

@@ -1,90 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils.ts
-var _keytree = require('@metamask/key-tree');
-
-
-
-
-
-
-
-var _utils = require('@metamask/utils');
-var _sha3 = require('@noble/hashes/sha3');
-var HARDENED_VALUE = 2147483648;
-function selectHooks(hooks, hookNames) {
-  if (hookNames) {
-    return Object.keys(hookNames).reduce(
-      (hookSubset, _hookName) => {
-        const hookName = _hookName;
-        hookSubset[hookName] = hooks[hookName];
-        return hookSubset;
-      },
-      {}
-    );
-  }
-  return void 0;
-}
-function getDerivationPathArray(hash) {
-  const array = [];
-  const view = _utils.createDataView.call(void 0, hash);
-  for (let index = 0; index < 8; index++) {
-    const uint32 = view.getUint32(index * 4);
-    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;
-    array.push(`bip32:${pathIndex - HARDENED_VALUE}'`);
-  }
-  return array;
-}
-async function deriveEntropy({
-  input,
-  salt = "",
-  mnemonicPhrase,
-  magic
-}) {
-  const inputBytes = _utils.stringToBytes.call(void 0, input);
-  const saltBytes = _utils.stringToBytes.call(void 0, salt);
-  const hash = _sha3.keccak_256.call(void 0, _utils.concatBytes.call(void 0, [inputBytes, _sha3.keccak_256.call(void 0, saltBytes)]));
-  const computedDerivationPath = getDerivationPathArray(hash);
-  const { privateKey } = await _keytree.SLIP10Node.fromDerivationPath({
-    derivationPath: [
-      mnemonicPhrase,
-      `bip32:${magic}`,
-      ...computedDerivationPath
-    ],
-    curve: "secp256k1"
-  });
-  _utils.assert.call(void 0, privateKey, "Failed to derive the entropy.");
-  return _utils.add0x.call(void 0, privateKey);
-}
-function getPathPrefix(curve) {
-  switch (curve) {
-    case "secp256k1":
-      return "bip32";
-    case "ed25519":
-      return "slip10";
-    case "ed25519Bip32":
-      return "cip3";
-    default:
-      return _utils.assertExhaustive.call(void 0, curve);
-  }
-}
-async function getNode({
-  curve,
-  secretRecoveryPhrase,
-  path
-}) {
-  const prefix = getPathPrefix(curve);
-  return await _keytree.SLIP10Node.fromDerivationPath({
-    curve,
-    derivationPath: [
-      secretRecoveryPhrase,
-      ...path.slice(1).map((index) => `${prefix}:${index}`)
-    ]
-  });
-}
-
-
-
-
-
-
-exports.selectHooks = selectHooks; exports.deriveEntropy = deriveEntropy; exports.getPathPrefix = getPathPrefix; exports.getNode = getNode;
-//# sourceMappingURL=chunk-33MTKZ4H.js.map

package/dist/chunk-33MTKZ4H.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils.ts"],"names":[],"mappings":";AAMA,SAAS,kBAAkB;AAG3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc,iBAAiB;AAExC,IAAM,iBAAiB;AAuBhB,SAAS,YAId,OACA,WACmC;AACnC,MAAI,WAAW;AACb,WAAO,OAAO,KAAK,SAAS,EAAE;AAAA,MAC5B,CAAC,YAAY,cAAc;AACzB,cAAM,WAAW;AACjB,mBAAW,QAAQ,IAAI,MAAM,QAAQ;AACrC,eAAO;AAAA,MACT;AAAA,MACA,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO;AACT;AASA,SAAS,uBAAuB,MAAuC;AACrE,QAAM,QAA6B,CAAC;AACpC,QAAM,OAAO,eAAe,IAAI;AAEhC,WAAS,QAAQ,GAAG,QAAQ,GAAG,SAAS;AACtC,UAAM,SAAS,KAAK,UAAU,QAAQ,CAAC;AAMvC,UAAM,aAAa,SAAS,oBAAoB;AAChD,UAAM,KAAK,SAAS,YAAY,cAAc,GAAY;AAAA,EAC5D;AAEA,SAAO;AACT;AAwCA,eAAsB,cAAc;AAAA,EAClC;AAAA,EACA,OAAO;AAAA,EACP;AAAA,EACA;AACF,GAAuC;AACrC,QAAM,aAAa,cAAc,KAAK;AACtC,QAAM,YAAY,cAAc,IAAI;AAGpC,QAAM,OAAO,UAAU,YAAY,CAAC,YAAY,UAAU,SAAS,CAAC,CAAC,CAAC;AACtE,QAAM,yBAAyB,uBAAuB,IAAI;AAG1D,QAAM,EAAE,WAAW,IAAI,MAAM,WAAW,mBAAmB;AAAA,IACzD,gBAAgB;AAAA,MACd;AAAA,MACA,SAAS,KAAK;AAAA,MACd,GAAG;AAAA,IACL;AAAA,IACA,OAAO;AAAA,EACT,CAAC;AAGD,SAAO,YAAY,+BAA+B;AAElD,SAAO,MAAM,UAAU;AACzB;AAiBO,SAAS,cACd,OAC6B;AAC7B,UAAQ,OAAO;AAAA,IACb,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT;AACE,aAAO,iBAAiB,KAAK;AAAA,EACjC;AACF;AAqBA,eAAsB,QAAQ;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AACF,GAAgB;AACd,QAAM,SAAS,cAAc,KAAK;AAElC,SAAO,MAAM,WAAW,mBAAmB;AAAA,IACzC;AAAA,IACA,gBAAgB;AAAA,MACd;AAAA,MACA,GAAI,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,UAAU,GAAG,MAAM,IAAI,KAAK,EAAE;AAAA,IAGvD;AAAA,EACF,CAAC;AACH","sourcesContent":["import type {\n  HardenedBIP32Node,\n  BIP32Node,\n  SLIP10PathNode,\n  SupportedCurve,\n} from '@metamask/key-tree';\nimport { SLIP10Node } from '@metamask/key-tree';\nimport type { MagicValue } from '@metamask/snaps-utils';\nimport type { Hex } from '@metamask/utils';\nimport {\n  assertExhaustive,\n  add0x,\n  assert,\n  concatBytes,\n  createDataView,\n  stringToBytes,\n} from '@metamask/utils';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\n\nconst HARDENED_VALUE = 0x80000000;\n\n/**\n * Maps an interface with method hooks to an object, using the keys of the\n * interface, and `true` as value. This ensures that the `methodHooks` object\n * has the same values as the interface.\n */\nexport type MethodHooksObject<HooksType extends Record<string, unknown>> = {\n  [Key in keyof HooksType]: true;\n};\n\n/**\n * Returns the subset of the specified `hooks` that are included in the\n * `hookNames` object. This is a Principle of Least Authority (POLA) measure\n * to ensure that each RPC method implementation only has access to the\n * API \"hooks\" it needs to do its job.\n *\n * @param hooks - The hooks to select from.\n * @param hookNames - The names of the hooks to select.\n * @returns The selected hooks.\n * @template Hooks - The hooks to select from.\n * @template HookName - The names of the hooks to select.\n */\nexport function selectHooks<\n  Hooks extends Record<string, unknown>,\n  HookName extends keyof Hooks,\n>(\n  hooks: Hooks,\n  hookNames?: Record<HookName, boolean>,\n): Pick<Hooks, HookName> | undefined {\n  if (hookNames) {\n    return Object.keys(hookNames).reduce<Partial<Pick<Hooks, HookName>>>(\n      (hookSubset, _hookName) => {\n        const hookName = _hookName as HookName;\n        hookSubset[hookName] = hooks[hookName];\n        return hookSubset;\n      },\n      {},\n    ) as Pick<Hooks, HookName>;\n  }\n  return undefined;\n}\n\n/**\n * Get a BIP-32 derivation path array from a hash, which is compatible with\n * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.\n *\n * @param hash - The hash to derive indices from.\n * @returns The derived indices as a {@link HardenedBIP32Node} array.\n */\nfunction getDerivationPathArray(hash: Uint8Array): HardenedBIP32Node[] {\n  const array: HardenedBIP32Node[] = [];\n  const view = createDataView(hash);\n\n  for (let index = 0; index < 8; index++) {\n    const uint32 = view.getUint32(index * 4);\n\n    // This is essentially `index | 0x80000000`. Because JavaScript numbers are\n    // signed, we use the bitwise unsigned right shift operator to ensure that\n    // the result is a positive number.\n    // eslint-disable-next-line no-bitwise\n    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;\n    array.push(`bip32:${pathIndex - HARDENED_VALUE}'` as const);\n  }\n\n  return array;\n}\n\ntype DeriveEntropyOptions = {\n  /**\n   * The input value to derive entropy from.\n   */\n  input: string;\n\n  /**\n   * An optional salt to use when deriving entropy.\n   */\n  salt?: string;\n\n  /**\n   * The mnemonic phrase to use for entropy derivation.\n   */\n  mnemonicPhrase: Uint8Array;\n\n  /**\n   * A hardened BIP-32 index, which is used to derive the root key from the\n   * mnemonic phrase.\n   */\n  magic: MagicValue;\n};\n\n/**\n * Derive entropy from the given mnemonic phrase and salt.\n *\n * This is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param options - The options for entropy derivation.\n * @param options.input - The input value to derive entropy from.\n * @param options.salt - An optional salt to use when deriving entropy.\n * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy\n * derivation.\n * @param options.magic - A hardened BIP-32 index, which is used to derive the\n * root key from the mnemonic phrase.\n * @returns The derived entropy.\n */\nexport async function deriveEntropy({\n  input,\n  salt = '',\n  mnemonicPhrase,\n  magic,\n}: DeriveEntropyOptions): Promise<Hex> {\n  const inputBytes = stringToBytes(input);\n  const saltBytes = stringToBytes(salt);\n\n  // Get the derivation path from the snap ID.\n  const hash = keccak256(concatBytes([inputBytes, keccak256(saltBytes)]));\n  const computedDerivationPath = getDerivationPathArray(hash);\n\n  // Derive the private key using BIP-32.\n  const { privateKey } = await SLIP10Node.fromDerivationPath({\n    derivationPath: [\n      mnemonicPhrase,\n      `bip32:${magic}`,\n      ...computedDerivationPath,\n    ],\n    curve: 'secp256k1',\n  });\n\n  // This should never happen, but this keeps TypeScript happy.\n  assert(privateKey, 'Failed to derive the entropy.');\n\n  return add0x(privateKey);\n}\n\n/**\n * Get the path prefix to use for key derivation in `key-tree`. This assumes the\n * following:\n *\n * - The Secp256k1 curve always uses the BIP-32 specification.\n * - The Ed25519 curve always uses the SLIP-10 specification.\n * - The BIP-32-Ed25519 curve always uses the CIP-3 specification.\n *\n * While this does not matter in most situations (no known case at the time of\n * writing), `key-tree` requires a specific specification to be used.\n *\n * @param curve - The curve to get the path prefix for. The curve is NOT\n * validated by this function.\n * @returns The path prefix, i.e., `bip32` or `slip10`.\n */\nexport function getPathPrefix(\n  curve: SupportedCurve,\n): 'bip32' | 'slip10' | 'cip3' {\n  switch (curve) {\n    case 'secp256k1':\n      return 'bip32';\n    case 'ed25519':\n      return 'slip10';\n    case 'ed25519Bip32':\n      return 'cip3';\n    default:\n      return assertExhaustive(curve);\n  }\n}\n\ntype GetNodeArgs = {\n  curve: SupportedCurve;\n  secretRecoveryPhrase: Uint8Array;\n  path: string[];\n};\n\n/**\n * Get a `key-tree`-compatible node.\n *\n * Note: This function assumes that all the parameters have been validated\n * beforehand.\n *\n * @param options - The derivation options.\n * @param options.curve - The curve to use for derivation.\n * @param options.secretRecoveryPhrase - The secret recovery phrase to use for\n * derivation.\n * @param options.path - The derivation path to use as array, starting with an\n * \"m\" as the first item.\n */\nexport async function getNode({\n  curve,\n  secretRecoveryPhrase,\n  path,\n}: GetNodeArgs) {\n  const prefix = getPathPrefix(curve);\n\n  return await SLIP10Node.fromDerivationPath({\n    curve,\n    derivationPath: [\n      secretRecoveryPhrase,\n      ...(path.slice(1).map((index) => `${prefix}:${index}`) as\n        | BIP32Node[]\n        | SLIP10PathNode[]),\n    ],\n  });\n}\n"]}

package/dist/chunk-3UAWEHMF.js

@@ -1,18 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/getClientStatus.ts
-var hookNames = {
-  getIsLocked: true
-};
-var getClientStatusHandler = {
-  methodNames: ["snap_getClientStatus"],
-  implementation: getClientStatusImplementation,
-  hookNames
-};
-async function getClientStatusImplementation(_request, response, _next, end, { getIsLocked }) {
-  response.result = { locked: getIsLocked() };
-  return end();
-}
-
-
-
-exports.getClientStatusHandler = getClientStatusHandler;
-//# sourceMappingURL=chunk-3UAWEHMF.js.map

package/dist/chunk-3UAWEHMF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/getClientStatus.ts"],"names":[],"mappings":";AAWA,IAAM,YAAqD;AAAA,EACzD,aAAa;AACf;AAKO,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,sBAAsB;AAAA,EACpC,gBAAgB;AAAA,EAChB;AACF;AAsBA,eAAe,8BACb,UACA,UACA,OACA,KACA,EAAE,YAAY,GACC;AACf,WAAS,SAAS,EAAE,QAAQ,YAAY,EAAE;AAC1C,SAAO,IAAI;AACb","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport type { GetClientStatusResult } from '@metamask/snaps-sdk';\nimport type {\n  JsonRpcParams,\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetClientStatusHooks> = {\n  getIsLocked: true,\n};\n\n/**\n * `snap_getClientStatus` returns useful information about the client running the snap.\n */\nexport const getClientStatusHandler: PermittedHandlerExport<\n  GetClientStatusHooks,\n  JsonRpcParams,\n  GetClientStatusResult\n> = {\n  methodNames: ['snap_getClientStatus'],\n  implementation: getClientStatusImplementation,\n  hookNames,\n};\n\nexport type GetClientStatusHooks = {\n  /**\n   * @returns Whether the client is locked or not.\n   */\n  getIsLocked: () => boolean;\n};\n\n/**\n * The `snap_getClientStatus` method implementation.\n * Returns useful information about the client running the snap.\n *\n * @param _request - The JSON-RPC request object. Not used by this function.\n * @param response - 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.getIsLocked - A function that returns whether the client is locked or not.\n * @returns Nothing.\n */\nasync function getClientStatusImplementation(\n  _request: JsonRpcRequest,\n  response: PendingJsonRpcResponse<GetClientStatusResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getIsLocked }: GetClientStatusHooks,\n): Promise<void> {\n  response.result = { locked: getIsLocked() };\n  return end();\n}\n"]}

package/dist/chunk-3WCLDJAS.mjs

@@ -1,74 +0,0 @@
-// src/endowments/cronjob.ts
-import { PermissionType, SubjectType } from "@metamask/permission-controller";
-import { rpcErrors } from "@metamask/rpc-errors";
-import {
-  SnapCaveatType,
-  isCronjobSpecificationArray
-} from "@metamask/snaps-utils";
-import { assert, hasProperty, isPlainObject } from "@metamask/utils";
-var permissionName = "endowment:cronjob" /* Cronjob */;
-var specificationBuilder = (_builderOptions) => {
-  return {
-    permissionType: PermissionType.Endowment,
-    targetName: permissionName,
-    allowedCaveats: [SnapCaveatType.SnapCronjob],
-    endowmentGetter: (_getterOptions) => null,
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var cronjobEndowmentBuilder = Object.freeze({
-  targetName: permissionName,
-  specificationBuilder
-});
-function getCronjobCaveatMapper(value) {
-  return {
-    caveats: [
-      {
-        type: SnapCaveatType.SnapCronjob,
-        value
-      }
-    ]
-  };
-}
-function getCronjobCaveatJobs(permission) {
-  if (!permission?.caveats) {
-    return null;
-  }
-  assert(permission.caveats.length === 1);
-  assert(permission.caveats[0].type === SnapCaveatType.SnapCronjob);
-  const caveat = permission.caveats[0];
-  return caveat.value?.jobs ?? null;
-}
-function validateCronjobCaveat(caveat) {
-  if (!hasProperty(caveat, "value") || !isPlainObject(caveat.value)) {
-    throw rpcErrors.invalidParams({
-      message: "Expected a plain object."
-    });
-  }
-  const { value } = caveat;
-  if (!hasProperty(value, "jobs") || !isPlainObject(value)) {
-    throw rpcErrors.invalidParams({
-      message: "Expected a plain object."
-    });
-  }
-  if (!isCronjobSpecificationArray(value.jobs)) {
-    throw rpcErrors.invalidParams({
-      message: "Expected a valid cronjob specification array."
-    });
-  }
-}
-var cronjobCaveatSpecifications = {
-  [SnapCaveatType.SnapCronjob]: Object.freeze({
-    type: SnapCaveatType.SnapCronjob,
-    validator: (caveat) => validateCronjobCaveat(caveat)
-  })
-};
-
-export {
-  cronjobEndowmentBuilder,
-  getCronjobCaveatMapper,
-  getCronjobCaveatJobs,
-  validateCronjobCaveat,
-  cronjobCaveatSpecifications
-};
-//# sourceMappingURL=chunk-3WCLDJAS.mjs.map

package/dist/chunk-3WCLDJAS.mjs.map

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

package/dist/chunk-3WKIKYUH.js

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

package/dist/chunk-3WKIKYUH.js.map

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

package/dist/chunk-4D2B2UQ6.mjs

@@ -1,23 +0,0 @@
-// src/endowments/network-access.ts
-import { PermissionType, SubjectType } from "@metamask/permission-controller";
-var permissionName = "endowment:network-access" /* NetworkAccess */;
-var specificationBuilder = (_builderOptions) => {
-  return {
-    permissionType: PermissionType.Endowment,
-    targetName: permissionName,
-    allowedCaveats: null,
-    endowmentGetter: (_getterOptions) => {
-      return ["fetch", "Request", "Headers", "Response"];
-    },
-    subjectTypes: [SubjectType.Snap]
-  };
-};
-var networkAccessEndowmentBuilder = Object.freeze({
-  targetName: permissionName,
-  specificationBuilder
-});
-
-export {
-  networkAccessEndowmentBuilder
-};
-//# sourceMappingURL=chunk-4D2B2UQ6.mjs.map

package/dist/chunk-4D2B2UQ6.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/endowments/network-access.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.NetworkAccess;\n\ntype NetworkAccessEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (\n    _options?: any,\n  ) => ['fetch', 'Request', 'Headers', 'Response'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:network-access` returns the name of global browser API(s) that\n * enable network access. This is intended to populate the endowments of the\n * SES Compartment in which a Snap executes.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the network endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  NetworkAccessEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['fetch', 'Request', 'Headers', 'Response'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const networkAccessEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAI5C,IAAM;AAmBN,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,SAAS,WAAW,WAAW,UAAU;AAAA,IACnD;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,gCAAgC,OAAO,OAAO;AAAA,EACzD,YAAY;AAAA,EACZ;AACF,CAAU;","names":[]}

package/dist/chunk-4LSOS7SM.js

@@ -1,23 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/getAllSnaps.ts
-var _rpcerrors = require('@metamask/rpc-errors');
-var hookNames = {
-  getAllSnaps: true
-};
-var getAllSnapsHandler = {
-  methodNames: ["wallet_getAllSnaps"],
-  implementation: getAllSnapsImplementation,
-  hookNames
-};
-async function getAllSnapsImplementation(request, response, _next, end, { getAllSnaps }) {
-  const { origin } = request;
-  if (origin !== "https://snaps.metamask.io") {
-    return end(_rpcerrors.rpcErrors.methodNotFound());
-  }
-  response.result = await getAllSnaps();
-  return end();
-}
-
-
-
-exports.getAllSnapsHandler = getAllSnapsHandler;
-//# sourceMappingURL=chunk-4LSOS7SM.js.map

package/dist/chunk-4LSOS7SM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/permitted/getAllSnaps.ts"],"names":[],"mappings":";AAEA,SAAS,iBAAiB;AAU1B,IAAM,YAAiD;AAAA,EACrD,aAAa;AACf;AAMO,IAAM,qBAIT;AAAA,EACF,aAAa,CAAC,oBAAoB;AAAA,EAClC,gBAAgB;AAAA,EAChB;AACF;AAsBA,eAAe,0BACb,SACA,UACA,OACA,KACA,EAAE,YAAY,GACC;AAEf,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI,WAAW,6BAA6B;AAC1C,WAAO,IAAI,UAAU,eAAe,CAAC;AAAA,EACvC;AAEA,WAAS,SAAS,MAAM,YAAY;AACpC,SAAO,IAAI;AACb","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { GetSnapsResult } from '@metamask/snaps-sdk';\nimport type {\n  JsonRpcParams,\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetAllSnapsHooks> = {\n  getAllSnaps: true,\n};\n\n/**\n * `wallet_getAllSnaps` gets all installed Snaps. Currently, this can only be\n * called from `https://snaps.metamask.io`.\n */\nexport const getAllSnapsHandler: PermittedHandlerExport<\n  GetAllSnapsHooks,\n  JsonRpcParams,\n  GetSnapsResult\n> = {\n  methodNames: ['wallet_getAllSnaps'],\n  implementation: getAllSnapsImplementation,\n  hookNames,\n};\n\nexport type GetAllSnapsHooks = {\n  /**\n   * @returns All installed Snaps.\n   */\n  getAllSnaps: () => Promise<GetSnapsResult>;\n};\n\n/**\n * The `wallet_getAllSnaps` method implementation.\n * Fetches all installed snaps and adds them to the JSON-RPC response.\n *\n * @param request - The JSON-RPC request object.\n * @param response - 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.getAllSnaps - A function that returns all installed snaps.\n * @returns Nothing.\n */\nasync function getAllSnapsImplementation(\n  request: JsonRpcRequest,\n  response: PendingJsonRpcResponse<GetSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getAllSnaps }: GetAllSnapsHooks,\n): Promise<void> {\n  // The origin is added by the MetaMask middleware stack.\n  const { origin } = request as JsonRpcRequest & { origin: string };\n\n  if (origin !== 'https://snaps.metamask.io') {\n    return end(rpcErrors.methodNotFound());\n  }\n\n  response.result = await getAllSnaps();\n  return end();\n}\n"]}

package/dist/chunk-4PWFZPJC.js

@@ -1,79 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunk33MTKZ4Hjs = require('./chunk-33MTKZ4H.js');
-
-// src/restricted/getBip32PublicKey.ts
-var _permissioncontroller = require('@metamask/permission-controller');
-var _rpcerrors = require('@metamask/rpc-errors');
-
-
-
-
-
-var _snapsutils = require('@metamask/snaps-utils');
-var _superstruct = require('@metamask/superstruct');
-var _utils = require('@metamask/utils');
-var targetName = "snap_getBip32PublicKey";
-var Bip32PublicKeyArgsStruct = _snapsutils.bip32entropy.call(void 0, 
-  _superstruct.object.call(void 0, {
-    path: _snapsutils.Bip32PathStruct,
-    curve: _snapsutils.CurveStruct,
-    compressed: _superstruct.optional.call(void 0, _superstruct.boolean.call(void 0, ))
-  })
-);
-var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
-  return {
-    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-    targetName,
-    allowedCaveats: [_snapsutils.SnapCaveatType.PermittedDerivationPaths],
-    methodImplementation: getBip32PublicKeyImplementation(methodHooks2),
-    validator: ({ caveats }) => {
-      if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.PermittedDerivationPaths) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-          message: `Expected a single "${_snapsutils.SnapCaveatType.PermittedDerivationPaths}" caveat.`
-        });
-      }
-    },
-    subjectTypes: [_permissioncontroller.SubjectType.Snap]
-  };
-};
-var methodHooks = {
-  getMnemonic: true,
-  getUnlockPromise: true
-};
-var getBip32PublicKeyBuilder = Object.freeze({
-  targetName,
-  specificationBuilder,
-  methodHooks
-});
-function getBip32PublicKeyImplementation({
-  getMnemonic,
-  getUnlockPromise
-}) {
-  return async function getBip32PublicKey(args) {
-    await getUnlockPromise(true);
-    _utils.assertStruct.call(void 0, 
-      args.params,
-      Bip32PublicKeyArgsStruct,
-      "Invalid BIP-32 public key params",
-      _rpcerrors.rpcErrors.invalidParams
-    );
-    const { params } = args;
-    const node = await _chunk33MTKZ4Hjs.getNode.call(void 0, {
-      curve: params.curve,
-      path: params.path,
-      secretRecoveryPhrase: await getMnemonic()
-    });
-    if (params.compressed) {
-      return node.compressedPublicKey;
-    }
-    return node.publicKey;
-  };
-}
-
-
-
-
-
-exports.Bip32PublicKeyArgsStruct = Bip32PublicKeyArgsStruct; exports.getBip32PublicKeyBuilder = getBip32PublicKeyBuilder; exports.getBip32PublicKeyImplementation = getBip32PublicKeyImplementation;
-//# sourceMappingURL=chunk-4PWFZPJC.js.map

package/dist/chunk-4PWFZPJC.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/restricted/getBip32PublicKey.ts"],"names":["methodHooks"],"mappings":";;;;;AAMA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAK1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,SAAS,QAAQ,gBAAgB;AAE1C,SAAS,oBAAoB;AAK7B,IAAM,aAAa;AA4BZ,IAAM,2BAA2B;AAAA,EACtC,OAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO;AAAA,IACP,YAAY,SAAS,QAAQ,CAAC;AAAA,EAChC,CAAC;AACH;AAWA,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAAoD;AACrE,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,gBAAgB,CAAC,eAAe,wBAAwB;AAAA,IACxD,sBAAsB,gCAAgCA,YAAW;AAAA,IACjE,WAAW,CAAC,EAAE,QAAQ,MAAM;AAC1B,UACE,SAAS,WAAW,KACpB,QAAQ,CAAC,EAAE,SAAS,eAAe,0BACnC;AACA,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS,sBAAsB,eAAe,wBAAwB;AAAA,QACxE,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAA+D;AAAA,EACnE,aAAa;AAAA,EACb,kBAAkB;AACpB;AAEO,IAAM,2BAA2B,OAAO,OAAO;AAAA,EACpD;AAAA,EACA;AAAA,EACA;AACF,CAAU;AAYH,SAAS,gCAAgC;AAAA,EAC9C;AAAA,EACA;AACF,GAAiC;AAC/B,SAAO,eAAe,kBACpB,MACkC;AAClC,UAAM,iBAAiB,IAAI;AAE3B;AAAA,MACE,KAAK;AAAA,MACL;AAAA,MACA;AAAA,MACA,UAAU;AAAA,IACZ;AAEA,UAAM,EAAE,OAAO,IAAI;AACnB,UAAM,OAAO,MAAM,QAAQ;AAAA,MACzB,OAAO,OAAO;AAAA,MACd,MAAM,OAAO;AAAA,MACb,sBAAsB,MAAM,YAAY;AAAA,IAC1C,CAAC;AAED,QAAI,OAAO,YAAY;AACrB,aAAO,KAAK;AAAA,IACd;AAEA,WAAO,KAAK;AAAA,EACd;AACF","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  GetBip32PublicKeyParams,\n  GetBip32PublicKeyResult,\n} from '@metamask/snaps-sdk';\nimport {\n  bip32entropy,\n  Bip32PathStruct,\n  CurveStruct,\n  SnapCaveatType,\n} from '@metamask/snaps-utils';\nimport { boolean, object, optional } from '@metamask/superstruct';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { getNode } from '../utils';\n\nconst targetName = 'snap_getBip32PublicKey';\n\nexport type GetBip32PublicKeyMethodHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\ntype GetBip32PublicKeySpecificationBuilderOptions = {\n  methodHooks: GetBip32PublicKeyMethodHooks;\n};\n\ntype GetBip32PublicKeySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip32PublicKeyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\nexport const Bip32PublicKeyArgsStruct = bip32entropy(\n  object({\n    path: Bip32PathStruct,\n    curve: CurveStruct,\n    compressed: optional(boolean()),\n  }),\n);\n\n/**\n * The specification builder for the `snap_getBip32PublicKey` permission.\n * `snap_getBip32PublicKey` lets the Snap retrieve public keys for a particular\n * BIP-32 node.\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 `snap_getBip32PublicKey` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip32PublicKeySpecificationBuilderOptions,\n  GetBip32PublicKeySpecification\n> = ({ methodHooks }: GetBip32PublicKeySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],\n    methodImplementation: getBip32PublicKeyImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (\n        caveats?.length !== 1 ||\n        caveats[0].type !== SnapCaveatType.PermittedDerivationPaths\n      ) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.PermittedDerivationPaths}\" caveat.`,\n        });\n      }\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetBip32PublicKeyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip32PublicKeyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip32PublicKey`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked\n * and prompts the user to unlock their MetaMask if it is locked.\n * @returns The method implementation which returns a public key.\n * @throws If the params are invalid.\n */\nexport function getBip32PublicKeyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip32PublicKeyMethodHooks) {\n  return async function getBip32PublicKey(\n    args: RestrictedMethodOptions<GetBip32PublicKeyParams>,\n  ): Promise<GetBip32PublicKeyResult> {\n    await getUnlockPromise(true);\n\n    assertStruct(\n      args.params,\n      Bip32PublicKeyArgsStruct,\n      'Invalid BIP-32 public key params',\n      rpcErrors.invalidParams,\n    );\n\n    const { params } = args;\n    const node = await getNode({\n      curve: params.curve,\n      path: params.path,\n      secretRecoveryPhrase: await getMnemonic(),\n    });\n\n    if (params.compressed) {\n      return node.compressedPublicKey;\n    }\n\n    return node.publicKey;\n  };\n}\n"]}

package/dist/chunk-4TUORIA6.js

@@ -1,59 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkHZQ34FQTjs = require('./chunk-HZQ34FQT.js');
-
-
-var _chunk6VJVURH5js = require('./chunk-6VJVURH5.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, _chunk6VJVURH5js.caveatMappers, initialPermission)) {
-        return [initialPermission, _chunk6VJVURH5js.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(_chunkHZQ34FQTjs.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-4TUORIA6.js.map

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