@metamask/snaps-rpc-methods 6.0.0 → 7.0.1

package/dist/chunk-SGQXD5K7.mjs

@@ -0,0 +1,83 @@
+// src/utils.ts
+import { SLIP10Node } from "@metamask/key-tree";
+import {
+  add0x,
+  assert,
+  concatBytes,
+  createDataView,
+  stringToBytes
+} from "@metamask/utils";
+import { keccak_256 as keccak256 } from "@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 = createDataView(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 = stringToBytes(input);
+  const saltBytes = stringToBytes(salt);
+  const hash = keccak256(concatBytes([inputBytes, keccak256(saltBytes)]));
+  const computedDerivationPath = getDerivationPathArray(hash);
+  const { privateKey } = await SLIP10Node.fromDerivationPath({
+    derivationPath: [
+      mnemonicPhrase,
+      `bip32:${magic}`,
+      ...computedDerivationPath
+    ],
+    curve: "secp256k1"
+  });
+  assert(privateKey, "Failed to derive the entropy.");
+  return add0x(privateKey);
+}
+function getPathPrefix(curve) {
+  if (curve === "secp256k1") {
+    return "bip32";
+  }
+  return "slip10";
+}
+async function getNode({
+  curve,
+  secretRecoveryPhrase,
+  path
+}) {
+  const prefix = getPathPrefix(curve);
+  return await SLIP10Node.fromDerivationPath({
+    curve,
+    derivationPath: [
+      secretRecoveryPhrase,
+      ...path.slice(1).map((index) => `${prefix}:${index}`)
+    ]
+  });
+}
+
+export {
+  selectHooks,
+  deriveEntropy,
+  getPathPrefix,
+  getNode
+};
+//# sourceMappingURL=chunk-SGQXD5K7.mjs.map

package/dist/chunk-SGQXD5K7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import type {\n  HardenedBIP32Node,\n  BIP32Node,\n  SLIP10PathNode,\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  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 use the BIP-32 specification.\n * - The Ed25519 curve always use the SLIP-10 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., `secp256k1` or `ed25519`.\n */\nexport function getPathPrefix(\n  curve: 'secp256k1' | 'ed25519',\n): 'bip32' | 'slip10' {\n  if (curve === 'secp256k1') {\n    return 'bip32';\n  }\n\n  return 'slip10';\n}\n\ntype GetNodeArgs = {\n  curve: 'secp256k1' | 'ed25519';\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  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"],"mappings":";AAKA,SAAS,kBAAkB;AAG3B;AAAA,EACE;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;AAgBO,SAAS,cACd,OACoB;AACpB,MAAI,UAAU,aAAa;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAqBA,eAAsB,QAAQ;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AACF,GAAgB;AACd,QAAM,SAAS,cAAc,KAAK;AAClC,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;","names":[]}

package/dist/chunk-SYUGPLEP.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/getLocale.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var methodName = "snap_getLocale";
+var specificationBuilder = ({ allowedCaveats = null, methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
+    targetName: methodName,
+    allowedCaveats,
+    methodImplementation: getImplementation(methodHooks2),
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  getLocale: true
+};
+var getLocaleBuilder = Object.freeze({
+  targetName: methodName,
+  specificationBuilder,
+  methodHooks
+});
+function getImplementation({ getLocale }) {
+  return async function implementation(_args) {
+    return getLocale();
+  };
+}
+
+
+
+
+
+exports.specificationBuilder = specificationBuilder; exports.getLocaleBuilder = getLocaleBuilder; exports.getImplementation = getImplementation;
+//# sourceMappingURL=chunk-SYUGPLEP.js.map

package/dist/chunk-SYUGPLEP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getLocale.ts"],"names":["methodHooks"],"mappings":";AAMA,SAAS,gBAAgB,mBAAmB;AAM5C,IAAM,aAAa;AA2BZ,IAAM,uBAIT,CAAC,EAAE,iBAAiB,MAAM,aAAAA,aAAY,MAAmC;AAC3E,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ;AAAA,IACA,sBAAsB,kBAAkBA,YAAW;AAAA,IACnD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAAuD;AAAA,EAC3D,WAAW;AACb;AAEO,IAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AASH,SAAS,kBAAkB,EAAE,UAAU,GAAyB;AACrE,SAAO,eAAe,eACpB,OAC0B;AAC1B,WAAO,UAAU;AAAA,EACnB;AACF","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { GetLocaleResult } from '@metamask/snaps-sdk';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_getLocale';\n\nexport type GetLocaleMethodHooks = {\n  getLocale: () => Promise<string>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: GetLocaleMethodHooks;\n};\n\ntype Specification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_getLocale` permission.\n * `snap_getLocale` allows snaps to get the user selected locale.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_getLocale` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  SpecificationBuilderOptions,\n  Specification\n> = ({ allowedCaveats = null, methodHooks }: SpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetLocaleMethodHooks> = {\n  getLocale: true,\n};\n\nexport const getLocaleBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getLocale`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getLocale - A function that returns the user selected locale.\n * @returns The user selected locale.\n */\nexport function getImplementation({ getLocale }: GetLocaleMethodHooks) {\n  return async function implementation(\n    _args: RestrictedMethodOptions<RestrictedMethodParameters>,\n  ): Promise<GetLocaleResult> {\n    return getLocale();\n  };\n}\n"]}

package/dist/chunk-TEXEQGNZ.js

@@ -0,0 +1,75 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkQMULJEYNjs = require('./chunk-QMULJEYN.js');
+
+// src/endowments/signature-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:signature-insight" /* SignatureInsight */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: [_snapsutils.SnapCaveatType.SignatureOrigin],
+    endowmentGetter: (_getterOptions) => void 0,
+    validator: _chunkQMULJEYNjs.createGenericPermissionValidator.call(void 0, [
+      { type: _snapsutils.SnapCaveatType.SignatureOrigin, optional: true },
+      { type: _snapsutils.SnapCaveatType.MaxRequestTime, optional: true }
+    ]),
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var signatureInsightEndowmentBuilder = 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 getSignatureInsightCaveatMapper(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.SignatureOrigin,
+        value: _utils.hasProperty.call(void 0, value, "allowSignatureOrigin") && value.allowSignatureOrigin
+      }
+    ]
+  };
+}
+function getSignatureOriginCaveat(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.SignatureOrigin);
+  const caveat = permission.caveats[0];
+  return caveat.value ?? null;
+}
+var signatureInsightCaveatSpecifications = {
+  [_snapsutils.SnapCaveatType.SignatureOrigin]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.SignatureOrigin,
+    validator: (caveat) => validateCaveat(caveat)
+  })
+};
+
+
+
+
+
+
+exports.signatureInsightEndowmentBuilder = signatureInsightEndowmentBuilder; exports.getSignatureInsightCaveatMapper = getSignatureInsightCaveatMapper; exports.getSignatureOriginCaveat = getSignatureOriginCaveat; exports.signatureInsightCaveatSpecifications = signatureInsightCaveatSpecifications;
+//# sourceMappingURL=chunk-TEXEQGNZ.js.map

package/dist/chunk-TEXEQGNZ.js.map

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

package/dist/chunk-TG63GBK3.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-TG63GBK3.mjs.map

package/dist/chunk-TG63GBK3.mjs.map

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

package/dist/chunk-TJYMYQAB.mjs

@@ -0,0 +1,42 @@
+// src/permitted/getInterfaceState.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { StructError, create, object, string } from "superstruct";
+var hookNames = {
+  getInterfaceState: true
+};
+var getInterfaceStateHandler = {
+  methodNames: ["snap_getInterfaceState"],
+  implementation: getGetInterfaceStateImplementation,
+  hookNames
+};
+var GetInterfaceStateParametersStruct = object({
+  id: string()
+});
+function getGetInterfaceStateImplementation(req, res, _next, end, { getInterfaceState }) {
+  const { params } = req;
+  try {
+    const validatedParams = getValidatedParams(params);
+    const { id } = validatedParams;
+    res.result = getInterfaceState(id);
+  } catch (error) {
+    return end(error);
+  }
+  return end();
+}
+function getValidatedParams(params) {
+  try {
+    return create(params, GetInterfaceStateParametersStruct);
+  } catch (error) {
+    if (error instanceof StructError) {
+      throw rpcErrors.invalidParams({
+        message: `Invalid params: ${error.message}.`
+      });
+    }
+    throw rpcErrors.internal();
+  }
+}
+
+export {
+  getInterfaceStateHandler
+};
+//# sourceMappingURL=chunk-TJYMYQAB.mjs.map

package/dist/chunk-TJYMYQAB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/getInterfaceState.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  GetInterfaceStateParams,\n  GetInterfaceStateResult,\n  InterfaceState,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetInterfaceStateMethodHooks> = {\n  getInterfaceState: true,\n};\n\nexport type GetInterfaceStateMethodHooks = {\n  /**\n   * @param id - The interface ID.\n   * @returns The interface state.\n   */\n  getInterfaceState: (id: string) => InterfaceState;\n};\n\nexport const getInterfaceStateHandler: PermittedHandlerExport<\n  GetInterfaceStateMethodHooks,\n  GetInterfaceStateParameters,\n  GetInterfaceStateResult\n> = {\n  methodNames: ['snap_getInterfaceState'],\n  implementation: getGetInterfaceStateImplementation,\n  hookNames,\n};\n\nconst GetInterfaceStateParametersStruct = object({\n  id: string(),\n});\n\nexport type GetInterfaceStateParameters = InferMatching<\n  typeof GetInterfaceStateParametersStruct,\n  GetInterfaceStateParams\n>;\n\n/**\n * The `snap_getInterfaceState` 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.getInterfaceState - The function to get the interface state.\n * @returns Noting.\n */\nfunction getGetInterfaceStateImplementation(\n  req: JsonRpcRequest<GetInterfaceStateParameters>,\n  res: PendingJsonRpcResponse<GetInterfaceStateResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getInterfaceState }: GetInterfaceStateMethodHooks,\n): void {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id } = validatedParams;\n\n    res.result = getInterfaceState(id);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the getInterfaceState 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 getInterfaceState method parameter object.\n */\nfunction getValidatedParams(params: unknown): GetInterfaceStateParameters {\n  try {\n    return create(params, GetInterfaceStateParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"mappings":";AAEA,SAAS,iBAAiB;AAS1B,SAAS,aAAa,QAAQ,QAAQ,cAAc;AAIpD,IAAM,YAA6D;AAAA,EACjE,mBAAmB;AACrB;AAUO,IAAM,2BAIT;AAAA,EACF,aAAa,CAAC,wBAAwB;AAAA,EACtC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,oCAAoC,OAAO;AAAA,EAC/C,IAAI,OAAO;AACb,CAAC;AAmBD,SAAS,mCACP,KACA,KACA,OACA,KACA,EAAE,kBAAkB,GACd;AACN,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI;AACF,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,EAAE,GAAG,IAAI;AAEf,QAAI,SAAS,kBAAkB,EAAE;AAAA,EACnC,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;AASA,SAAS,mBAAmB,QAA8C;AACxE,MAAI;AACF,WAAO,OAAO,QAAQ,iCAAiC;AAAA,EACzD,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,SAAS;AAAA,EAC3B;AACF;","names":[]}

package/dist/chunk-TKXU7ZXP.mjs

@@ -0,0 +1,78 @@
+import {
+  getValidatedParams
+} from "./chunk-MXCJWR45.mjs";
+
+// src/permitted/invokeKeyring.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { HandlerType, WALLET_SNAP_PERMISSION_KEY } from "@metamask/snaps-utils";
+import { hasProperty } from "@metamask/utils";
+var hookNames = {
+  hasPermission: true,
+  handleSnapRpcRequest: true,
+  getSnap: true,
+  getAllowedKeyringMethods: true
+};
+var invokeKeyringHandler = {
+  methodNames: ["wallet_invokeKeyring"],
+  implementation: invokeKeyringImplementation,
+  hookNames
+};
+async function invokeKeyringImplementation(req, res, _next, end, {
+  handleSnapRpcRequest,
+  hasPermission,
+  getSnap,
+  getAllowedKeyringMethods
+}) {
+  let params;
+  try {
+    params = getValidatedParams(req.params);
+  } catch (error) {
+    return end(error);
+  }
+  const { origin } = req;
+  const { snapId, request } = params;
+  if (!origin || !hasPermission(WALLET_SNAP_PERMISSION_KEY)) {
+    return end(
+      rpcErrors.invalidRequest({
+        message: `The snap "${snapId}" is not connected to "${origin}". Please connect before invoking the snap.`
+      })
+    );
+  }
+  if (!getSnap(snapId)) {
+    return end(
+      rpcErrors.invalidRequest({
+        message: `The snap "${snapId}" is not installed. Please install it first, before invoking the snap.`
+      })
+    );
+  }
+  if (!hasProperty(request, "method") || typeof request.method !== "string") {
+    return end(
+      rpcErrors.invalidRequest({
+        message: "The request must have a method."
+      })
+    );
+  }
+  const allowedMethods = getAllowedKeyringMethods();
+  if (!allowedMethods.includes(request.method)) {
+    return end(
+      rpcErrors.invalidRequest({
+        message: `The origin "${origin}" is not allowed to invoke the method "${request.method}".`
+      })
+    );
+  }
+  try {
+    res.result = await handleSnapRpcRequest({
+      snapId,
+      request,
+      handler: HandlerType.OnKeyringRequest
+    });
+  } catch (error) {
+    return end(error);
+  }
+  return end();
+}
+
+export {
+  invokeKeyringHandler
+};
+//# sourceMappingURL=chunk-TKXU7ZXP.mjs.map

package/dist/chunk-TKXU7ZXP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/invokeKeyring.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  InvokeKeyringParams,\n  InvokeKeyringResult,\n  InvokeSnapParams,\n} from '@metamask/snaps-sdk';\nimport type { Snap, SnapRpcHookArgs } from '@metamask/snaps-utils';\nimport { HandlerType, WALLET_SNAP_PERMISSION_KEY } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { hasProperty, type Json } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { getValidatedParams } from './invokeSnapSugar';\n\nconst hookNames: MethodHooksObject<InvokeKeyringHooks> = {\n  hasPermission: true,\n  handleSnapRpcRequest: true,\n  getSnap: true,\n  getAllowedKeyringMethods: true,\n};\n\n/**\n * `wallet_invokeKeyring` gets the requester's permitted and installed Snaps.\n */\nexport const invokeKeyringHandler: PermittedHandlerExport<\n  InvokeKeyringHooks,\n  InvokeSnapParams,\n  InvokeKeyringResult\n> = {\n  methodNames: ['wallet_invokeKeyring'],\n  implementation: invokeKeyringImplementation,\n  hookNames,\n};\n\nexport type InvokeKeyringHooks = {\n  hasPermission: (permissionName: string) => boolean;\n\n  handleSnapRpcRequest: ({\n    snapId,\n    handler,\n    request,\n  }: Omit<SnapRpcHookArgs, 'origin'> & { snapId: string }) => Promise<unknown>;\n\n  getSnap: (snapId: string) => Snap | undefined;\n\n  getAllowedKeyringMethods: () => string[];\n};\n\n/**\n * The `wallet_invokeKeyring` method implementation.\n * Invokes onKeyringRequest if the snap requested is installed and connected to the dapp.\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.handleSnapRpcRequest - Invokes a snap with a given RPC request.\n * @param hooks.hasPermission - Checks whether a given origin has a given permission.\n * @param hooks.getSnap - Gets information about a given snap.\n * @param hooks.getAllowedKeyringMethods - Get the list of allowed Keyring\n * methods for a given origin.\n * @returns Nothing.\n */\nasync function invokeKeyringImplementation(\n  req: JsonRpcRequest<InvokeKeyringParams>,\n  res: PendingJsonRpcResponse<InvokeKeyringResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  {\n    handleSnapRpcRequest,\n    hasPermission,\n    getSnap,\n    getAllowedKeyringMethods,\n  }: InvokeKeyringHooks,\n): Promise<void> {\n  let params: InvokeSnapParams;\n  try {\n    params = getValidatedParams(req.params);\n  } catch (error) {\n    return end(error);\n  }\n\n  // We expect the MM middleware stack to always add the origin to requests\n  const { origin } = req as JsonRpcRequest & { origin: string };\n  const { snapId, request } = params;\n\n  if (!origin || !hasPermission(WALLET_SNAP_PERMISSION_KEY)) {\n    return end(\n      rpcErrors.invalidRequest({\n        message: `The snap \"${snapId}\" is not connected to \"${origin}\". Please connect before invoking the snap.`,\n      }),\n    );\n  }\n\n  if (!getSnap(snapId)) {\n    return end(\n      rpcErrors.invalidRequest({\n        message: `The snap \"${snapId}\" is not installed. Please install it first, before invoking the snap.`,\n      }),\n    );\n  }\n\n  if (!hasProperty(request, 'method') || typeof request.method !== 'string') {\n    return end(\n      rpcErrors.invalidRequest({\n        message: 'The request must have a method.',\n      }),\n    );\n  }\n\n  const allowedMethods = getAllowedKeyringMethods();\n  if (!allowedMethods.includes(request.method)) {\n    return end(\n      rpcErrors.invalidRequest({\n        message: `The origin \"${origin}\" is not allowed to invoke the method \"${request.method}\".`,\n      }),\n    );\n  }\n\n  try {\n    res.result = (await handleSnapRpcRequest({\n      snapId,\n      request,\n      handler: HandlerType.OnKeyringRequest,\n    })) as Json;\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n"],"mappings":";;;;;AAEA,SAAS,iBAAiB;AAO1B,SAAS,aAAa,kCAAkC;AAExD,SAAS,mBAA8B;AAKvC,IAAM,YAAmD;AAAA,EACvD,eAAe;AAAA,EACf,sBAAsB;AAAA,EACtB,SAAS;AAAA,EACT,0BAA0B;AAC5B;AAKO,IAAM,uBAIT;AAAA,EACF,aAAa,CAAC,sBAAsB;AAAA,EACpC,gBAAgB;AAAA,EAChB;AACF;AAiCA,eAAe,4BACb,KACA,KACA,OACA,KACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GACe;AACf,MAAI;AACJ,MAAI;AACF,aAAS,mBAAmB,IAAI,MAAM;AAAA,EACxC,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAGA,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,EAAE,QAAQ,QAAQ,IAAI;AAE5B,MAAI,CAAC,UAAU,CAAC,cAAc,0BAA0B,GAAG;AACzD,WAAO;AAAA,MACL,UAAU,eAAe;AAAA,QACvB,SAAS,aAAa,MAAM,0BAA0B,MAAM;AAAA,MAC9D,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,CAAC,QAAQ,MAAM,GAAG;AACpB,WAAO;AAAA,MACL,UAAU,eAAe;AAAA,QACvB,SAAS,aAAa,MAAM;AAAA,MAC9B,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,CAAC,YAAY,SAAS,QAAQ,KAAK,OAAO,QAAQ,WAAW,UAAU;AACzE,WAAO;AAAA,MACL,UAAU,eAAe;AAAA,QACvB,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,EACF;AAEA,QAAM,iBAAiB,yBAAyB;AAChD,MAAI,CAAC,eAAe,SAAS,QAAQ,MAAM,GAAG;AAC5C,WAAO;AAAA,MACL,UAAU,eAAe;AAAA,QACvB,SAAS,eAAe,MAAM,0CAA0C,QAAQ,MAAM;AAAA,MACxF,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI;AACF,QAAI,SAAU,MAAM,qBAAqB;AAAA,MACvC;AAAA,MACA;AAAA,MACA,SAAS,YAAY;AAAA,IACvB,CAAC;AAAA,EACH,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;","names":[]}

package/dist/chunk-TNENASGX.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-TNENASGX.mjs.map

package/dist/chunk-TNENASGX.mjs.map

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

package/dist/chunk-TNRH2LRU.mjs

@@ -0,0 +1,57 @@
+import {
+  getNode
+} from "./chunk-SGQXD5K7.mjs";
+
+// src/restricted/getBip32Entropy.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { SnapCaveatType } from "@metamask/snaps-utils";
+import { assert } from "@metamask/utils";
+var targetName = "snap_getBip32Entropy";
+var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName,
+    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],
+    methodImplementation: getBip32EntropyImplementation(methodHooks2),
+    validator: ({ caveats }) => {
+      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
+        throw rpcErrors.invalidParams({
+          message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`
+        });
+      }
+    },
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  getMnemonic: true,
+  getUnlockPromise: true
+};
+var getBip32EntropyBuilder = Object.freeze({
+  targetName,
+  specificationBuilder,
+  methodHooks
+});
+function getBip32EntropyImplementation({
+  getMnemonic,
+  getUnlockPromise
+}) {
+  return async function getBip32Entropy(args) {
+    await getUnlockPromise(true);
+    const { params } = args;
+    assert(params);
+    const node = await getNode({
+      curve: params.curve,
+      path: params.path,
+      secretRecoveryPhrase: await getMnemonic()
+    });
+    return node.toJSON();
+  };
+}
+
+export {
+  getBip32EntropyBuilder,
+  getBip32EntropyImplementation
+};
+//# sourceMappingURL=chunk-TNRH2LRU.mjs.map

package/dist/chunk-TNRH2LRU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getBip32Entropy.ts"],"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  GetBip32EntropyParams,\n  GetBip32EntropyResult,\n} from '@metamask/snaps-sdk';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assert } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { getNode } from '../utils';\n\nconst targetName = 'snap_getBip32Entropy';\n\nexport type GetBip32EntropyMethodHooks = {\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 GetBip32EntropySpecificationBuilderOptions = {\n  methodHooks: GetBip32EntropyMethodHooks;\n};\n\ntype GetBip32EntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip32EntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * The specification builder for the `snap_getBip32Entropy` permission.\n * `snap_getBip32Entropy` lets the Snap control private 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_getBip32Entropy` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip32EntropySpecificationBuilderOptions,\n  GetBip32EntropySpecification\n> = ({ methodHooks }: GetBip32EntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],\n    methodImplementation: getBip32EntropyImplementation(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<GetBip32EntropyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip32EntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip32Entropy`.\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 `JsonSLIP10Node`.\n * @throws If the params are invalid.\n */\nexport function getBip32EntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip32EntropyMethodHooks) {\n  return async function getBip32Entropy(\n    args: RestrictedMethodOptions<GetBip32EntropyParams>,\n  ): Promise<GetBip32EntropyResult> {\n    await getUnlockPromise(true);\n\n    const { params } = args;\n    assert(params);\n\n    const node = await getNode({\n      curve: params.curve,\n      path: params.path,\n      secretRecoveryPhrase: await getMnemonic(),\n    });\n\n    return node.toJSON();\n  };\n}\n"],"mappings":";;;;;AAMA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAK1B,SAAS,sBAAsB;AAE/B,SAAS,cAAc;AAKvB,IAAM,aAAa;AAqCnB,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAAkD;AACnE,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,gBAAgB,CAAC,eAAe,wBAAwB;AAAA,IACxD,sBAAsB,8BAA8BA,YAAW;AAAA,IAC/D,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,cAA6D;AAAA,EACjE,aAAa;AAAA,EACb,kBAAkB;AACpB;AAEO,IAAM,yBAAyB,OAAO,OAAO;AAAA,EAClD;AAAA,EACA;AAAA,EACA;AACF,CAAU;AAYH,SAAS,8BAA8B;AAAA,EAC5C;AAAA,EACA;AACF,GAA+B;AAC7B,SAAO,eAAe,gBACpB,MACgC;AAChC,UAAM,iBAAiB,IAAI;AAE3B,UAAM,EAAE,OAAO,IAAI;AACnB,WAAO,MAAM;AAEb,UAAM,OAAO,MAAM,QAAQ;AAAA,MACzB,OAAO,OAAO;AAAA,MACd,MAAM,OAAO;AAAA,MACb,sBAAsB,MAAM,YAAY;AAAA,IAC1C,CAAC;AAED,WAAO,KAAK,OAAO;AAAA,EACrB;AACF;","names":["methodHooks"]}

package/dist/chunk-TOYWHUAS.mjs

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

package/dist/chunk-TOYWHUAS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/keyring.ts"],"sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  EndowmentGetterParams,\n  PermissionConstraint,\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { KeyringOrigins } from '@metamask/snaps-utils';\nimport { assertIsKeyringOrigins, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isPlainObject } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.Keyring;\n\ntype KeyringEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  subjectTypes: readonly SubjectType[];\n}>;\n\n/**\n * `endowment:keyring` returns nothing; it is intended to be used as a flag\n * by the client to detect whether the snap has keyring capabilities.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the keyring endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  KeyringEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.KeyringOrigin,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.KeyringOrigin },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const keyringEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Validate the value of a caveat. This does not validate the type of the\n * caveat itself, only the value of the caveat.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateCaveatOrigins(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid keyring origins: Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsKeyringOrigins(value, rpcErrors.invalidParams);\n}\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getKeyringCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.KeyringOrigin,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the {@link KeyringOrigins} caveat value from a\n * permission.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value.\n * @throws If the permission does not have a valid {@link KeyringOrigins}\n * caveat.\n */\nexport function getKeyringCaveatOrigins(\n  permission?: PermissionConstraint,\n): KeyringOrigins | null {\n  assert(permission?.caveats);\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.KeyringOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, KeyringOrigins>;\n  return caveat.value;\n}\n\nexport const keyringCaveatSpecifications: Record<\n  SnapCaveatType.KeyringOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.KeyringOrigin]: Object.freeze({\n    type: SnapCaveatType.KeyringOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveatOrigins(caveat),\n  }),\n};\n"],"mappings":";;;;;AASA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAE1B,SAAS,wBAAwB,sBAAsB;AAEvD,SAAS,QAAQ,aAAa,qBAAqB;AAKnD,IAAM;AAkBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,MACd,eAAe;AAAA,MACf,eAAe;AAAA,IACjB;AAAA,IACA,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,WAAW,iCAAiC;AAAA,MAC1C,EAAE,MAAM,eAAe,cAAc;AAAA,MACrC,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,0BAA0B,OAAO,OAAO;AAAA,EACnD,YAAY;AAAA,EACZ;AACF,CAAU;AASV,SAAS,sBAAsB,QAA6B;AAC1D,MAAI,CAAC,YAAY,QAAQ,OAAO,KAAK,CAAC,cAAc,OAAO,KAAK,GAAG;AACjE,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAClB,yBAAuB,OAAO,UAAU,aAAa;AACvD;AAUO,SAAS,uBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAWO,SAAS,wBACd,YACuB;AACvB,SAAO,YAAY,OAAO;AAC1B,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,aAAa;AAElE,QAAM,SAAS,WAAW,QAAQ,CAAC;AACnC,SAAO,OAAO;AAChB;AAEO,IAAM,8BAGT;AAAA,EACF,CAAC,eAAe,aAAa,GAAG,OAAO,OAAO;AAAA,IAC5C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,sBAAsB,MAAM;AAAA,EAC1E,CAAC;AACH;","names":[]}

package/dist/chunk-TT4DP2YW.mjs

@@ -0,0 +1,35 @@
+// src/endowments/caveats/generic.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+function createGenericPermissionValidator(caveatsToValidate) {
+  const validCaveatTypes = new Set(
+    caveatsToValidate.map((caveat) => caveat.type)
+  );
+  const requiredCaveats = caveatsToValidate.filter(
+    (caveat) => !caveat.optional
+  );
+  return function({ caveats }) {
+    const actualCaveats = caveats ?? [];
+    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);
+    const passedCaveatsSet = new Set(passedCaveatTypes);
+    if (passedCaveatsSet.size !== passedCaveatTypes.length) {
+      throw rpcErrors.invalidParams({
+        message: "Duplicate caveats are not allowed."
+      });
+    }
+    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {
+      throw rpcErrors.invalidParams({
+        message: `Expected the following caveats: ${caveatsToValidate.map((caveat) => `"${caveat.type}"`).join(", ")}, received ${actualCaveats.map((caveat) => `"${caveat.type}"`).join(", ")}.`
+      });
+    }
+    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {
+      throw rpcErrors.invalidParams({
+        message: `Expected the following caveats: ${requiredCaveats.map((caveat) => `"${caveat.type}"`).join(", ")}.`
+      });
+    }
+  };
+}
+
+export {
+  createGenericPermissionValidator
+};
+//# sourceMappingURL=chunk-TT4DP2YW.mjs.map

package/dist/chunk-TT4DP2YW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/caveats/generic.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionValidatorConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { Json } from '@metamask/utils';\n\nexport type CaveatMapperReturnValue = Pick<PermissionConstraint, 'caveats'>;\n\nexport type CaveatMapperFunction = (value: Json) => CaveatMapperReturnValue;\n\n/**\n * Create a generic permission validator that validates the presence of certain caveats.\n *\n * This validator only validates the types of the caveats, not the values.\n *\n * @param caveatsToValidate - A list of objects that represent caveats.\n * @param caveatsToValidate.type - The string defining the caveat type.\n * @param caveatsToValidate.optional - An optional boolean flag that defines\n * whether the caveat is optional or not.\n * @returns A function that validates a permission.\n */\nexport function createGenericPermissionValidator(\n  caveatsToValidate: {\n    type: string;\n    optional?: boolean;\n  }[],\n): PermissionValidatorConstraint {\n  const validCaveatTypes = new Set(\n    caveatsToValidate.map((caveat) => caveat.type),\n  );\n  const requiredCaveats = caveatsToValidate.filter(\n    (caveat) => !caveat.optional,\n  );\n\n  return function ({ caveats }) {\n    const actualCaveats = caveats ?? [];\n    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);\n    const passedCaveatsSet = new Set(passedCaveatTypes);\n\n    // Disallow duplicates\n    if (passedCaveatsSet.size !== passedCaveatTypes.length) {\n      throw rpcErrors.invalidParams({\n        message: 'Duplicate caveats are not allowed.',\n      });\n    }\n\n    // Disallow caveats that don't match expected types\n    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${caveatsToValidate\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}, received ${actualCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n\n    // Fail if not all required caveats are specified\n    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${requiredCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n  };\n}\n"],"mappings":";AAIA,SAAS,iBAAiB;AAkBnB,SAAS,iCACd,mBAI+B;AAC/B,QAAM,mBAAmB,IAAI;AAAA,IAC3B,kBAAkB,IAAI,CAAC,WAAW,OAAO,IAAI;AAAA,EAC/C;AACA,QAAM,kBAAkB,kBAAkB;AAAA,IACxC,CAAC,WAAW,CAAC,OAAO;AAAA,EACtB;AAEA,SAAO,SAAU,EAAE,QAAQ,GAAG;AAC5B,UAAM,gBAAgB,WAAW,CAAC;AAClC,UAAM,oBAAoB,cAAc,IAAI,CAAC,WAAW,OAAO,IAAI;AACnE,UAAM,mBAAmB,IAAI,IAAI,iBAAiB;AAGlD,QAAI,iBAAiB,SAAS,kBAAkB,QAAQ;AACtD,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,cAAc,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACvE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,kBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC,cAAc,cACxB,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,gBAAgB,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACzE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,gBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-UB3733UY.mjs

@@ -0,0 +1,23 @@
+// src/permitted/getAllSnaps.ts
+import { rpcErrors } from "@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.methodNotFound());
+  }
+  response.result = await getAllSnaps();
+  return end();
+}
+
+export {
+  getAllSnapsHandler
+};
+//# sourceMappingURL=chunk-UB3733UY.mjs.map

package/dist/chunk-UB3733UY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/getAllSnaps.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { 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"],"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;","names":[]}