@metamask/snaps-rpc-methods 5.0.0 → 7.0.0

package/dist/chunk-TRB2LS4N.js

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/manageAccounts.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var _utils = require('@metamask/utils');
+var _superstruct = require('superstruct');
+var SnapMessageStruct = _superstruct.union.call(void 0, [
+  _superstruct.object.call(void 0, {
+    method: _superstruct.string.call(void 0, )
+  }),
+  _superstruct.object.call(void 0, {
+    method: _superstruct.string.call(void 0, ),
+    params: _superstruct.union.call(void 0, [_superstruct.array.call(void 0, _utils.JsonStruct), _superstruct.record.call(void 0, _superstruct.string.call(void 0, ), _utils.JsonStruct)])
+  })
+]);
+var methodName = "snap_manageAccounts";
+var specificationBuilder = ({
+  allowedCaveats = null,
+  methodHooks
+}) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
+    targetName: methodName,
+    allowedCaveats,
+    methodImplementation: manageAccountsImplementation(methodHooks),
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+function manageAccountsImplementation({
+  getSnapKeyring
+}) {
+  return async function manageAccounts(options) {
+    const {
+      context: { origin },
+      params
+    } = options;
+    _superstruct.assert.call(void 0, params, SnapMessageStruct);
+    const keyring = await getSnapKeyring(origin);
+    return await keyring.handleKeyringSnapMessage(origin, params);
+  };
+}
+var manageAccountsBuilder = Object.freeze({
+  targetName: methodName,
+  specificationBuilder,
+  methodHooks: {
+    getSnapKeyring: true
+  }
+});
+
+
+
+
+
+
+exports.methodName = methodName; exports.specificationBuilder = specificationBuilder; exports.manageAccountsImplementation = manageAccountsImplementation; exports.manageAccountsBuilder = manageAccountsBuilder;
+//# sourceMappingURL=chunk-TRB2LS4N.js.map

package/dist/chunk-TRB2LS4N.js.map

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

package/dist/chunk-TZRCALSV.mjs

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

package/dist/chunk-TZRCALSV.mjs.map

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

package/dist/chunk-UJZ3HNXS.mjs

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

package/dist/chunk-UJZ3HNXS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/ethereum-provider.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.EthereumProvider;\n\ntype EthereumProviderEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => ['ethereum'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:ethereum-provider` returns the name of the ethereum global browser API.\n * This is intended to populate the endowments of the\n * SES Compartment in which a Snap executes.\n *\n * This populates the global scope with an EIP-1193 provider, which DOES NOT implement all legacy functionality exposed to dapps.\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  EthereumProviderEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['ethereum'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const ethereumProviderEndowmentBuilder = 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,UAAU;AAAA,IACpB;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,mCAAmC,OAAO,OAAO;AAAA,EAC5D,YAAY;AAAA,EACZ;AACF,CAAU;","names":[]}

package/dist/chunk-UXVJ7HYO.js

@@ -0,0 +1,78 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk632BZ6JYjs = require('./chunk-632BZ6JY.js');
+
+// src/restricted/getBip32PublicKey.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 _superstruct = require('superstruct');
+var targetName = "snap_getBip32PublicKey";
+var Bip32PublicKeyArgsStruct = _snapsutils.bip32entropy.call(void 0, 
+  _superstruct.object.call(void 0, {
+    path: _snapsutils.Bip32PathStruct,
+    curve: _superstruct.enums.call(void 0, ["ed25519", "secp256k1"]),
+    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 (_optionalChain([caveats, 'optionalAccess', _ => _.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 _chunk632BZ6JYjs.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-UXVJ7HYO.js.map

package/dist/{cjs/restricted/getBip32PublicKey.js.map → chunk-UXVJ7HYO.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/restricted/getBip32PublicKey.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  GetBip32PublicKeyParams,\n  GetBip32PublicKeyResult,\n} from '@metamask/snaps-sdk';\nimport {\n  bip32entropy,\n  Bip32PathStruct,\n  SnapCaveatType,\n} from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { boolean, enums, object, optional } from 'superstruct';\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: enums(['ed25519', 'secp256k1']),\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"],"names":["Bip32PublicKeyArgsStruct","getBip32PublicKeyBuilder","getBip32PublicKeyImplementation","targetName","bip32entropy","object","path","Bip32PathStruct","curve","enums","compressed","optional","boolean","specificationBuilder","methodHooks","permissionType","PermissionType","RestrictedMethod","allowedCaveats","SnapCaveatType","PermittedDerivationPaths","methodImplementation","validator","caveats","length","type","rpcErrors","invalidParams","message","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","Object","freeze","getBip32PublicKey","args","assertStruct","params","node","getNode","secretRecoveryPhrase","compressedPublicKey","publicKey"],"mappings":";;;;;;;;;;;IAoDaA,wBAAwB;eAAxBA;;IA8CAC,wBAAwB;eAAxBA;;IAgBGC,+BAA+B;eAA/BA;;;sCA5G4B;2BAClB;4BASnB;uBAEsB;6BACoB;wBAGzB;AAExB,MAAMC,aAAa;AA4BZ,MAAMH,2BAA2BI,IAAAA,wBAAY,EAClDC,IAAAA,mBAAM,EAAC;IACLC,MAAMC,2BAAe;IACrBC,OAAOC,IAAAA,kBAAK,EAAC;QAAC;QAAW;KAAY;IACrCC,YAAYC,IAAAA,qBAAQ,EAACC,IAAAA,oBAAO;AAC9B;AAGF;;;;;;;;CAQC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAAgD;IAChE,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/Cd;QACAe,gBAAgB;YAACC,0BAAc,CAACC,wBAAwB;SAAC;QACzDC,sBAAsBnB,gCAAgCY;QACtDQ,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKN,0BAAc,CAACC,wBAAwB,EAC3D;gBACA,MAAMM,oBAAS,CAACC,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAET,0BAAc,CAACC,wBAAwB,CAAC,SAAS,CAAC;gBACnF;YACF;QACF;QACAS,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMjB,cAA+D;IACnEkB,aAAa;IACbC,kBAAkB;AACpB;AAEO,MAAMhC,2BAA2BiC,OAAOC,MAAM,CAAC;IACpDhC;IACAU;IACAC;AACF;AAYO,SAASZ,gCAAgC,EAC9C8B,WAAW,EACXC,gBAAgB,EACa;IAC7B,OAAO,eAAeG,kBACpBC,IAAsD;QAEtD,MAAMJ,iBAAiB;QAEvBK,IAAAA,mBAAY,EACVD,KAAKE,MAAM,EACXvC,0BACA,oCACA0B,oBAAS,CAACC,aAAa;QAGzB,MAAM,EAAEY,MAAM,EAAE,GAAGF;QACnB,MAAMG,OAAO,MAAMC,IAAAA,eAAO,EAAC;YACzBjC,OAAO+B,OAAO/B,KAAK;YACnBF,MAAMiC,OAAOjC,IAAI;YACjBoC,sBAAsB,MAAMV;QAC9B;QAEA,IAAIO,OAAO7B,UAAU,EAAE;YACrB,OAAO8B,KAAKG,mBAAmB;QACjC;QAEA,OAAOH,KAAKI,SAAS;IACvB;AACF"}
+{"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,OACK;AAEP,SAAS,oBAAoB;AAC7B,SAAS,SAAS,OAAO,QAAQ,gBAAgB;AAKjD,IAAM,aAAa;AA4BZ,IAAM,2BAA2B;AAAA,EACtC,OAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO,MAAM,CAAC,WAAW,WAAW,CAAC;AAAA,IACrC,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  SnapCaveatType,\n} from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { boolean, enums, object, optional } from 'superstruct';\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: enums(['ed25519', 'secp256k1']),\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-UYSXSKML.js

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

package/dist/chunk-UYSXSKML.js.map

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

package/dist/chunk-VFI5FR5U.mjs

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

package/dist/chunk-VFI5FR5U.mjs.map

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

package/dist/chunk-VRDGSBXX.mjs

@@ -0,0 +1,78 @@
+import {
+  getValidatedParams
+} from "./chunk-MDJZ4K3U.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-VRDGSBXX.mjs.map

package/dist/chunk-VRDGSBXX.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-VSVVWO3W.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-VSVVWO3W.mjs.map