@metamask/snaps-rpc-methods 6.0.0 → 7.0.0

package/dist/chunk-E2G25QVG.js

@@ -0,0 +1,119 @@
+"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 _chunkRC7LBS3Hjs = require('./chunk-RC7LBS3H.js');
+
+// src/endowments/name-lookup.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:name-lookup" /* NameLookup */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: [
+      _snapsutils.SnapCaveatType.ChainIds,
+      _snapsutils.SnapCaveatType.LookupMatchers,
+      _snapsutils.SnapCaveatType.MaxRequestTime
+    ],
+    endowmentGetter: (_getterOptions) => void 0,
+    validator: _chunkRC7LBS3Hjs.createGenericPermissionValidator.call(void 0, [
+      { type: _snapsutils.SnapCaveatType.ChainIds, optional: true },
+      { type: _snapsutils.SnapCaveatType.LookupMatchers, optional: true },
+      { type: _snapsutils.SnapCaveatType.MaxRequestTime, optional: true }
+    ]),
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var nameLookupEndowmentBuilder = 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;
+  switch (caveat.type) {
+    case _snapsutils.SnapCaveatType.ChainIds:
+      _utils.assertStruct.call(void 0, value, _snapsutils.ChainIdsStruct);
+      break;
+    case _snapsutils.SnapCaveatType.LookupMatchers:
+      _utils.assertStruct.call(void 0, value, _snapsutils.LookupMatchersStruct);
+      break;
+    default:
+      throw _rpcerrors.rpcErrors.invalidParams({
+        message: 'Invalid caveat type, must be one of the following: "chainIds", "matchers".'
+      });
+  }
+}
+function getNameLookupCaveatMapper(value) {
+  if (!value || !_utils.isObject.call(void 0, value) || Object.keys(value).length === 0) {
+    return { caveats: null };
+  }
+  const caveats = [];
+  if (value.chains) {
+    caveats.push({
+      type: _snapsutils.SnapCaveatType.ChainIds,
+      value: value.chains
+    });
+  }
+  if (value.matchers) {
+    caveats.push({
+      type: _snapsutils.SnapCaveatType.LookupMatchers,
+      value: value.matchers
+    });
+  }
+  _utils.assert.call(void 0, caveats.length > 0);
+  return { caveats };
+}
+function getChainIdsCaveat(permission) {
+  if (!_optionalChain([permission, 'optionalAccess', _ => _.caveats])) {
+    return null;
+  }
+  const caveat = permission.caveats.find(
+    (permCaveat) => permCaveat.type === _snapsutils.SnapCaveatType.ChainIds
+  );
+  return caveat ? caveat.value : null;
+}
+function getLookupMatchersCaveat(permission) {
+  if (!_optionalChain([permission, 'optionalAccess', _2 => _2.caveats])) {
+    return null;
+  }
+  const caveat = permission.caveats.find(
+    (permCaveat) => permCaveat.type === _snapsutils.SnapCaveatType.LookupMatchers
+  );
+  return caveat ? caveat.value : null;
+}
+var nameLookupCaveatSpecifications = {
+  [_snapsutils.SnapCaveatType.ChainIds]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.ChainIds,
+    validator: (caveat) => validateCaveat(caveat)
+  }),
+  [_snapsutils.SnapCaveatType.LookupMatchers]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.LookupMatchers,
+    validator: (caveat) => validateCaveat(caveat)
+  })
+};
+
+
+
+
+
+
+
+exports.nameLookupEndowmentBuilder = nameLookupEndowmentBuilder; exports.getNameLookupCaveatMapper = getNameLookupCaveatMapper; exports.getChainIdsCaveat = getChainIdsCaveat; exports.getLookupMatchersCaveat = getLookupMatchersCaveat; exports.nameLookupCaveatSpecifications = nameLookupCaveatSpecifications;
+//# sourceMappingURL=chunk-E2G25QVG.js.map

package/dist/chunk-E2G25QVG.js.map

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

package/dist/chunk-E4HGQWSS.js

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkABFJRV6Qjs = require('./chunk-ABFJRV6Q.js');
+
+
+
+var _chunkEAL6AH74js = require('./chunk-EAL6AH74.js');
+
+
+
+var _chunkW2VJ5TWLjs = require('./chunk-W2VJ5TWL.js');
+
+
+var _chunkJV26U22Gjs = require('./chunk-JV26U22G.js');
+
+
+var _chunkFMUQOZIOjs = require('./chunk-FMUQOZIO.js');
+
+
+var _chunkUXVJ7HYOjs = require('./chunk-UXVJ7HYO.js');
+
+
+var _chunkUYSXSKMLjs = require('./chunk-UYSXSKML.js');
+
+// src/restricted/caveats/index.ts
+var caveatSpecifications = {
+  ..._chunkEAL6AH74js.PermittedDerivationPathsCaveatSpecification,
+  ..._chunkABFJRV6Qjs.PermittedCoinTypesCaveatSpecification,
+  ..._chunkW2VJ5TWLjs.SnapIdsCaveatSpecification
+};
+var caveatMappers = {
+  [_chunkFMUQOZIOjs.getBip32EntropyBuilder.targetName]: _chunkEAL6AH74js.permittedDerivationPathsCaveatMapper,
+  [_chunkUXVJ7HYOjs.getBip32PublicKeyBuilder.targetName]: _chunkEAL6AH74js.permittedDerivationPathsCaveatMapper,
+  [_chunkJV26U22Gjs.getBip44EntropyBuilder.targetName]: _chunkABFJRV6Qjs.permittedCoinTypesCaveatMapper,
+  [_chunkUYSXSKMLjs.invokeSnapBuilder.targetName]: _chunkW2VJ5TWLjs.snapIdsCaveatMapper
+};
+
+
+
+
+exports.caveatSpecifications = caveatSpecifications; exports.caveatMappers = caveatMappers;
+//# sourceMappingURL=chunk-E4HGQWSS.js.map

package/dist/chunk-E4HGQWSS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/caveats/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAiBO,IAAM,uBAAuB;AAAA,EAClC,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AACL;AAEO,IAAM,gBAGT;AAAA,EACF,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,yBAAyB,UAAU,GAAG;AAAA,EACvC,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,kBAAkB,UAAU,GAAG;AAClC","sourcesContent":["import type { PermissionConstraint } from '@metamask/permission-controller';\nimport type { Json } from '@metamask/utils';\n\nimport { getBip32EntropyBuilder } from '../getBip32Entropy';\nimport { getBip32PublicKeyBuilder } from '../getBip32PublicKey';\nimport { getBip44EntropyBuilder } from '../getBip44Entropy';\nimport { invokeSnapBuilder } from '../invokeSnap';\nimport {\n  permittedCoinTypesCaveatMapper,\n  PermittedCoinTypesCaveatSpecification,\n} from './permittedCoinTypes';\nimport {\n  permittedDerivationPathsCaveatMapper,\n  PermittedDerivationPathsCaveatSpecification,\n} from './permittedDerivationPaths';\nimport { snapIdsCaveatMapper, SnapIdsCaveatSpecification } from './snapIds';\n\nexport const caveatSpecifications = {\n  ...PermittedDerivationPathsCaveatSpecification,\n  ...PermittedCoinTypesCaveatSpecification,\n  ...SnapIdsCaveatSpecification,\n} as const;\n\nexport const caveatMappers: Record<\n  string,\n  (value: Json) => Pick<PermissionConstraint, 'caveats'>\n> = {\n  [getBip32EntropyBuilder.targetName]: permittedDerivationPathsCaveatMapper,\n  [getBip32PublicKeyBuilder.targetName]: permittedDerivationPathsCaveatMapper,\n  [getBip44EntropyBuilder.targetName]: permittedCoinTypesCaveatMapper,\n  [invokeSnapBuilder.targetName]: snapIdsCaveatMapper,\n};\n"]}

package/dist/chunk-EAL6AH74.js

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/caveats/permittedDerivationPaths.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+
+
+
+
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+var _superstruct = require('superstruct');
+function permittedDerivationPathsCaveatMapper(value) {
+  return {
+    caveats: [
+      {
+        type: _snapsutils.SnapCaveatType.PermittedDerivationPaths,
+        value
+      }
+    ]
+  };
+}
+function validateBIP32Path(value) {
+  _utils.assertStruct.call(void 0, 
+    value,
+    _snapsutils.Bip32EntropyStruct,
+    "Invalid BIP-32 entropy path definition",
+    _rpcerrors.rpcErrors.invalidParams
+  );
+}
+function validateBIP32CaveatPaths(caveat) {
+  _utils.assertStruct.call(void 0, 
+    caveat,
+    _superstruct.type.call(void 0, { value: _superstruct.size.call(void 0, _superstruct.array.call(void 0, _snapsutils.Bip32EntropyStruct), 1, Infinity) }),
+    "Invalid BIP-32 entropy caveat",
+    _rpcerrors.rpcErrors.internal
+  );
+}
+var PermittedDerivationPathsCaveatSpecification = {
+  [_snapsutils.SnapCaveatType.PermittedDerivationPaths]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.PermittedDerivationPaths,
+    decorator: (method, caveat) => {
+      return async (args) => {
+        const { params } = args;
+        validateBIP32Path(params);
+        const path = caveat.value.find(
+          (caveatPath) => _snapsutils.isEqual.call(void 0, 
+            params.path.slice(0, caveatPath.path.length),
+            caveatPath.path
+          ) && caveatPath.curve === params.curve
+        );
+        if (!path) {
+          throw _rpcerrors.providerErrors.unauthorized({
+            message: "The requested path is not permitted. Allowed paths must be specified in the snap manifest."
+          });
+        }
+        return await method(args);
+      };
+    },
+    validator: (caveat) => validateBIP32CaveatPaths(caveat)
+  })
+};
+
+
+
+
+
+
+exports.permittedDerivationPathsCaveatMapper = permittedDerivationPathsCaveatMapper; exports.validateBIP32Path = validateBIP32Path; exports.validateBIP32CaveatPaths = validateBIP32CaveatPaths; exports.PermittedDerivationPathsCaveatSpecification = PermittedDerivationPathsCaveatSpecification;
+//# sourceMappingURL=chunk-EAL6AH74.js.map

package/dist/chunk-EAL6AH74.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/caveats/permittedDerivationPaths.ts"],"names":[],"mappings":";AAKA,SAAS,gBAAgB,iBAAiB;AAE1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,oBAAoB;AAC7B,SAAS,OAAO,MAAM,YAAY;AAU3B,SAAS,qCACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAWO,SAAS,kBACd,OAC+B;AAC/B;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AASO,SAAS,yBACd,QACkD;AAClD;AAAA,IACE;AAAA,IACA,KAAK,EAAE,OAAO,KAAK,MAAM,kBAAkB,GAAG,GAAG,QAAQ,EAAE,CAAC;AAAA,IAC5D;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAEO,IAAM,8CAGT;AAAA,EACF,CAAC,eAAe,wBAAwB,GAAG,OAAO,OAAO;AAAA,IACvD,MAAM,eAAe;AAAA,IACrB,WAAW,CACT,QACA,WACG;AACH,aAAO,OAAO,SAAS;AACrB,cAAM,EAAE,OAAO,IAAI;AACnB,0BAAkB,MAAM;AAExB,cAAM,OAAO,OAAO,MAAM;AAAA,UACxB,CAAC,eACC;AAAA,YACE,OAAO,KAAK,MAAM,GAAG,WAAW,KAAK,MAAM;AAAA,YAC3C,WAAW;AAAA,UACb,KAAK,WAAW,UAAU,OAAO;AAAA,QACrC;AAEA,YAAI,CAAC,MAAM;AACT,gBAAM,eAAe,aAAa;AAAA,YAChC,SACE;AAAA,UACJ,CAAC;AAAA,QACH;AAEA,eAAO,MAAM,OAAO,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,IACA,WAAW,CAAC,WAAW,yBAAyB,MAAM;AAAA,EACxD,CAAC;AACH","sourcesContent":["import type {\n  Caveat,\n  PermissionConstraint,\n  RestrictedMethodCaveatSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport type { Bip32Entropy } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  Bip32EntropyStruct,\n  isEqual,\n} from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { array, size, type } from 'superstruct';\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 permittedDerivationPathsCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.PermittedDerivationPaths,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validate a caveat path object. The object must consist of a `path` array and\n * a `curve` string. Paths must start with `m`, and must contain at\n * least two indices. If `ed25519` is used, this checks if all the path indices\n * are hardened.\n *\n * @param value - The value to validate.\n * @throws If the value is invalid.\n */\nexport function validateBIP32Path(\n  value: unknown,\n): asserts value is Bip32Entropy {\n  assertStruct(\n    value,\n    Bip32EntropyStruct,\n    'Invalid BIP-32 entropy path definition',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Validate the path values associated with a caveat. This validates that the\n * value is a non-empty array with valid derivation paths and curves.\n *\n * @param caveat - The caveat to validate.\n * @throws If the value is invalid.\n */\nexport function validateBIP32CaveatPaths(\n  caveat: Caveat<string, any>,\n): asserts caveat is Caveat<string, Bip32Entropy[]> {\n  assertStruct(\n    caveat,\n    type({ value: size(array(Bip32EntropyStruct), 1, Infinity) }),\n    'Invalid BIP-32 entropy caveat',\n    rpcErrors.internal,\n  );\n}\n\nexport const PermittedDerivationPathsCaveatSpecification: Record<\n  SnapCaveatType.PermittedDerivationPaths,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.PermittedDerivationPaths]: Object.freeze({\n    type: SnapCaveatType.PermittedDerivationPaths,\n    decorator: (\n      method,\n      caveat: Caveat<SnapCaveatType.PermittedDerivationPaths, Bip32Entropy[]>,\n    ) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP32Path(params);\n\n        const path = caveat.value.find(\n          (caveatPath) =>\n            isEqual(\n              params.path.slice(0, caveatPath.path.length),\n              caveatPath.path,\n            ) && caveatPath.curve === params.curve,\n        );\n\n        if (!path) {\n          throw providerErrors.unauthorized({\n            message:\n              'The requested path is not permitted. Allowed paths must be specified in the snap manifest.',\n          });\n        }\n\n        return await method(args);\n      };\n    },\n    validator: (caveat) => validateBIP32CaveatPaths(caveat),\n  }),\n};\n"]}

package/dist/chunk-EB6OXVFN.mjs

@@ -0,0 +1,52 @@
+// src/restricted/getBip44Entropy.ts
+import { BIP44CoinTypeNode } from "@metamask/key-tree";
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { SnapCaveatType } from "@metamask/snaps-utils";
+var targetName = "snap_getBip44Entropy";
+var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName,
+    allowedCaveats: [SnapCaveatType.PermittedCoinTypes],
+    methodImplementation: getBip44EntropyImplementation(methodHooks2),
+    validator: ({ caveats }) => {
+      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedCoinTypes) {
+        throw rpcErrors.invalidParams({
+          message: `Expected a single "${SnapCaveatType.PermittedCoinTypes}" caveat.`
+        });
+      }
+    },
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  getMnemonic: true,
+  getUnlockPromise: true
+};
+var getBip44EntropyBuilder = Object.freeze({
+  targetName,
+  specificationBuilder,
+  methodHooks
+});
+function getBip44EntropyImplementation({
+  getMnemonic,
+  getUnlockPromise
+}) {
+  return async function getBip44Entropy(args) {
+    await getUnlockPromise(true);
+    const params = args.params;
+    const node = await BIP44CoinTypeNode.fromDerivationPath([
+      await getMnemonic(),
+      `bip32:44'`,
+      `bip32:${params.coinType}'`
+    ]);
+    return node.toJSON();
+  };
+}
+
+export {
+  getBip44EntropyBuilder,
+  getBip44EntropyImplementation
+};
+//# sourceMappingURL=chunk-EB6OXVFN.mjs.map

package/dist/chunk-EB6OXVFN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getBip44Entropy.ts"],"sourcesContent":["import { BIP44CoinTypeNode } from '@metamask/key-tree';\nimport 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  GetBip44EntropyParams,\n  GetBip44EntropyResult,\n} from '@metamask/snaps-sdk';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst targetName = 'snap_getBip44Entropy';\n\nexport type GetBip44EntropyMethodHooks = {\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 GetBip44EntropySpecificationBuilderOptions = {\n  methodHooks: GetBip44EntropyMethodHooks;\n};\n\ntype GetBip44EntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip44EntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * The specification builder for the `snap_getBip44Entropy` permission.\n * `snap_getBip44Entropy_*` lets the Snap control private keys for a particular\n * BIP-32 coin type.\n *\n * @param options - The specification builder options.\n * @param options.methodHooks - The RPC method hooks needed by the method\n * implementation.\n * @returns The specification for the `snap_getBip44Entropy` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip44EntropySpecificationBuilderOptions,\n  GetBip44EntropySpecification\n> = ({ methodHooks }: GetBip44EntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedCoinTypes],\n    methodImplementation: getBip44EntropyImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (\n        caveats?.length !== 1 ||\n        caveats[0].type !== SnapCaveatType.PermittedCoinTypes\n      ) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.PermittedCoinTypes}\" caveat.`,\n        });\n      }\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetBip44EntropyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip44EntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip44Entropy`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase\n * of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @returns The method implementation which returns a `BIP44CoinTypeNode`.\n * @throws If the params are invalid.\n */\nexport function getBip44EntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip44EntropyMethodHooks) {\n  return async function getBip44Entropy(\n    args: RestrictedMethodOptions<GetBip44EntropyParams>,\n  ): Promise<GetBip44EntropyResult> {\n    await getUnlockPromise(true);\n\n    // `args.params` is validated by the decorator, so it's safe to assert here.\n    const params = args.params as GetBip44EntropyParams;\n\n    const node = await BIP44CoinTypeNode.fromDerivationPath([\n      await getMnemonic(),\n      `bip32:44'`,\n      `bip32:${params.coinType}'`,\n    ]);\n\n    return node.toJSON();\n  };\n}\n"],"mappings":";AAAA,SAAS,yBAAyB;AAOlC,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAK1B,SAAS,sBAAsB;AAK/B,IAAM,aAAa;AAsCnB,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAAkD;AACnE,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,gBAAgB,CAAC,eAAe,kBAAkB;AAAA,IAClD,sBAAsB,8BAA8BA,YAAW;AAAA,IAC/D,WAAW,CAAC,EAAE,QAAQ,MAAM;AAC1B,UACE,SAAS,WAAW,KACpB,QAAQ,CAAC,EAAE,SAAS,eAAe,oBACnC;AACA,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS,sBAAsB,eAAe,kBAAkB;AAAA,QAClE,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;AAcH,SAAS,8BAA8B;AAAA,EAC5C;AAAA,EACA;AACF,GAA+B;AAC7B,SAAO,eAAe,gBACpB,MACgC;AAChC,UAAM,iBAAiB,IAAI;AAG3B,UAAM,SAAS,KAAK;AAEpB,UAAM,OAAO,MAAM,kBAAkB,mBAAmB;AAAA,MACtD,MAAM,YAAY;AAAA,MAClB;AAAA,MACA,SAAS,OAAO,QAAQ;AAAA,IAC1B,CAAC;AAED,WAAO,KAAK,OAAO;AAAA,EACrB;AACF;","names":["methodHooks"]}

package/dist/chunk-EKB7QNFO.mjs

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

package/dist/chunk-EKB7QNFO.mjs.map

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

package/dist/chunk-EPNGNDRH.mjs

@@ -0,0 +1,80 @@
+// src/restricted/notify.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { NotificationType } from "@metamask/snaps-sdk";
+import { validateTextLinks } from "@metamask/snaps-utils";
+import { isObject } from "@metamask/utils";
+var methodName = "snap_notify";
+var specificationBuilder = ({ allowedCaveats = null, methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName: methodName,
+    allowedCaveats,
+    methodImplementation: getImplementation(methodHooks2),
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  showNativeNotification: true,
+  showInAppNotification: true,
+  isOnPhishingList: true,
+  maybeUpdatePhishingList: true
+};
+var notifyBuilder = Object.freeze({
+  targetName: methodName,
+  specificationBuilder,
+  methodHooks
+});
+function getImplementation({
+  showNativeNotification,
+  showInAppNotification,
+  isOnPhishingList,
+  maybeUpdatePhishingList
+}) {
+  return async function implementation(args) {
+    const {
+      params,
+      context: { origin }
+    } = args;
+    const validatedParams = getValidatedParams(params);
+    await maybeUpdatePhishingList();
+    validateTextLinks(validatedParams.message, isOnPhishingList);
+    switch (validatedParams.type) {
+      case NotificationType.Native:
+        return await showNativeNotification(origin, validatedParams);
+      case NotificationType.InApp:
+        return await showInAppNotification(origin, validatedParams);
+      default:
+        throw rpcErrors.invalidParams({
+          message: 'Must specify a valid notification "type".'
+        });
+    }
+  };
+}
+function getValidatedParams(params) {
+  if (!isObject(params)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected params to be a single object."
+    });
+  }
+  const { type, message } = params;
+  if (!type || typeof type !== "string" || !Object.values(NotificationType).includes(type)) {
+    throw rpcErrors.invalidParams({
+      message: 'Must specify a valid notification "type".'
+    });
+  }
+  if (!message || typeof message !== "string" || message.length >= 50) {
+    throw rpcErrors.invalidParams({
+      message: 'Must specify a non-empty string "message" less than 50 characters long.'
+    });
+  }
+  return params;
+}
+
+export {
+  specificationBuilder,
+  notifyBuilder,
+  getImplementation,
+  getValidatedParams
+};
+//# sourceMappingURL=chunk-EPNGNDRH.mjs.map

package/dist/chunk-EPNGNDRH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/notify.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { NotificationType } from '@metamask/snaps-sdk';\nimport type {\n  NotifyParams,\n  NotifyResult,\n  EnumToUnion,\n} from '@metamask/snaps-sdk';\nimport { validateTextLinks } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\nimport { type MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_notify';\n\nexport type NotificationArgs = {\n  /**\n   * Enum type to determine notification type.\n   */\n  type: EnumToUnion<NotificationType>;\n\n  /**\n   * A message to show on the notification.\n   */\n  message: string;\n};\n\nexport type NotifyMethodHooks = {\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showNativeNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showInAppNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  isOnPhishingList: (url: string) => boolean;\n\n  maybeUpdatePhishingList: () => Promise<void>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: NotifyMethodHooks;\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_notify` permission.\n * `snap_notify` allows snaps to send multiple types of notifications to its users.\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_notify` 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<NotifyMethodHooks> = {\n  showNativeNotification: true,\n  showInAppNotification: true,\n  isOnPhishingList: true,\n  maybeUpdatePhishingList: true,\n};\n\nexport const notifyBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_notify`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.showNativeNotification - A function that shows a native browser notification.\n * @param hooks.showInAppNotification - A function that shows a notification in the MetaMask UI.\n * @param hooks.isOnPhishingList - A function that checks for links against the phishing list.\n * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.\n * @returns The method implementation which returns `null` on success.\n * @throws If the params are invalid.\n */\nexport function getImplementation({\n  showNativeNotification,\n  showInAppNotification,\n  isOnPhishingList,\n  maybeUpdatePhishingList,\n}: NotifyMethodHooks) {\n  return async function implementation(\n    args: RestrictedMethodOptions<NotifyParams>,\n  ): Promise<NotifyResult> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    const validatedParams = getValidatedParams(params);\n\n    await maybeUpdatePhishingList();\n\n    validateTextLinks(validatedParams.message, isOnPhishingList);\n\n    switch (validatedParams.type) {\n      case NotificationType.Native:\n        return await showNativeNotification(origin, validatedParams);\n      case NotificationType.InApp:\n        return await showInAppNotification(origin, validatedParams);\n      default:\n        throw rpcErrors.invalidParams({\n          message: 'Must specify a valid notification \"type\".',\n        });\n    }\n  };\n}\n\n/**\n * Validates the notify 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 method parameter object.\n */\nexport function getValidatedParams(params: unknown): NotifyParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { type, message } = params;\n\n  if (\n    !type ||\n    typeof type !== 'string' ||\n    !Object.values(NotificationType).includes(type as NotificationType)\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid notification \"type\".',\n    });\n  }\n\n  // Set to the max message length on a Mac notification for now.\n  if (!message || typeof message !== 'string' || message.length >= 50) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Must specify a non-empty string \"message\" less than 50 characters long.',\n    });\n  }\n\n  return params as NotificationArgs;\n}\n"],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAC1B,SAAS,wBAAwB;AAMjC,SAAS,yBAAyB;AAElC,SAAS,gBAAgB;AAIzB,IAAM,aAAa;AA2DZ,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,cAAoD;AAAA,EACxD,wBAAwB;AAAA,EACxB,uBAAuB;AAAA,EACvB,kBAAkB;AAAA,EAClB,yBAAyB;AAC3B;AAEO,IAAM,gBAAgB,OAAO,OAAO;AAAA,EACzC,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AAaH,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,SAAO,eAAe,eACpB,MACuB;AACvB,UAAM;AAAA,MACJ;AAAA,MACA,SAAS,EAAE,OAAO;AAAA,IACpB,IAAI;AAEJ,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,wBAAwB;AAE9B,sBAAkB,gBAAgB,SAAS,gBAAgB;AAE3D,YAAQ,gBAAgB,MAAM;AAAA,MAC5B,KAAK,iBAAiB;AACpB,eAAO,MAAM,uBAAuB,QAAQ,eAAe;AAAA,MAC7D,KAAK,iBAAiB;AACpB,eAAO,MAAM,sBAAsB,QAAQ,eAAe;AAAA,MAC5D;AACE,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS;AAAA,QACX,CAAC;AAAA,IACL;AAAA,EACF;AACF;AASO,SAAS,mBAAmB,QAA+B;AAChE,MAAI,CAAC,SAAS,MAAM,GAAG;AACrB,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,QAAQ,IAAI;AAE1B,MACE,CAAC,QACD,OAAO,SAAS,YAChB,CAAC,OAAO,OAAO,gBAAgB,EAAE,SAAS,IAAwB,GAClE;AACA,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAGA,MAAI,CAAC,WAAW,OAAO,YAAY,YAAY,QAAQ,UAAU,IAAI;AACnE,UAAM,UAAU,cAAc;AAAA,MAC5B,SACE;AAAA,IACJ,CAAC;AAAA,EACH;AAEA,SAAO;AACT;","names":["methodHooks"]}

package/dist/chunk-F5BEVZOB.js

@@ -0,0 +1,47 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/permitted/getFile.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapssdk = require('@metamask/snaps-sdk');
+var _utils = require('@metamask/utils');
+var _superstruct = require('superstruct');
+var GetFileArgsStruct = _superstruct.object.call(void 0, {
+  path: _superstruct.string.call(void 0, ),
+  encoding: _superstruct.optional.call(void 0, 
+    _superstruct.union.call(void 0, [
+      _snapssdk.enumValue.call(void 0, _snapssdk.AuxiliaryFileEncoding.Base64),
+      _snapssdk.enumValue.call(void 0, _snapssdk.AuxiliaryFileEncoding.Hex),
+      _snapssdk.enumValue.call(void 0, _snapssdk.AuxiliaryFileEncoding.Utf8)
+    ])
+  )
+});
+var hookNames = {
+  getSnapFile: true
+};
+var getFileHandler = {
+  methodNames: ["snap_getFile"],
+  implementation,
+  hookNames
+};
+async function implementation(req, res, _next, end, { getSnapFile }) {
+  const { params } = req;
+  _utils.assertStruct.call(void 0, 
+    params,
+    GetFileArgsStruct,
+    'Invalid "snap_getFile" parameters',
+    _rpcerrors.rpcErrors.invalidParams
+  );
+  try {
+    res.result = await getSnapFile(
+      params.path,
+      _nullishCoalesce(params.encoding, () => ( _snapssdk.AuxiliaryFileEncoding.Base64))
+    );
+  } catch (error) {
+    return end(error);
+  }
+  return end();
+}
+
+
+
+
+exports.GetFileArgsStruct = GetFileArgsStruct; exports.getFileHandler = getFileHandler;
+//# sourceMappingURL=chunk-F5BEVZOB.js.map

package/dist/chunk-F5BEVZOB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/getFile.ts"],"names":[],"mappings":";AAEA,SAAS,iBAAiB;AAE1B,SAAS,uBAAuB,iBAAiB;AAGjD,SAAS,oBAAoB;AAC7B,SAAS,QAAQ,UAAU,QAAQ,aAAa;AAIzC,IAAM,oBAAoB,OAAO;AAAA,EACtC,MAAM,OAAO;AAAA,EACb,UAAU;AAAA,IACR,MAAM;AAAA,MACJ,UAAU,sBAAsB,MAAM;AAAA,MACtC,UAAU,sBAAsB,GAAG;AAAA,MACnC,UAAU,sBAAsB,IAAI;AAAA,IACtC,CAAC;AAAA,EACH;AACF,CAAC;AAOD,IAAM,YAA6C;AAAA,EACjD,aAAa;AACf;AAEO,IAAM,iBAIT;AAAA,EACF,aAAa,CAAC,cAAc;AAAA,EAC5B;AAAA,EACA;AACF;AAqBA,eAAe,eACb,KACA,KACA,OACA,KACA,EAAE,YAAY,GACC;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AAEA,MAAI;AACF,QAAI,SAAS,MAAM;AAAA,MACjB,OAAO;AAAA,MACP,OAAO,YAAY,sBAAsB;AAAA,IAC3C;AAAA,EACF,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { GetFileParams, GetFileResult } from '@metamask/snaps-sdk';\nimport { AuxiliaryFileEncoding, enumValue } from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { object, optional, string, union } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const GetFileArgsStruct = object({\n  path: string(),\n  encoding: optional(\n    union([\n      enumValue(AuxiliaryFileEncoding.Base64),\n      enumValue(AuxiliaryFileEncoding.Hex),\n      enumValue(AuxiliaryFileEncoding.Utf8),\n    ]),\n  ),\n});\n\nexport type InferredGetFileParams = InferMatching<\n  typeof GetFileArgsStruct,\n  GetFileParams\n>;\n\nconst hookNames: MethodHooksObject<GetFileHooks> = {\n  getSnapFile: true,\n};\n\nexport const getFileHandler: PermittedHandlerExport<\n  GetFileHooks,\n  InferredGetFileParams,\n  string\n> = {\n  methodNames: ['snap_getFile'],\n  implementation,\n  hookNames,\n};\n\nexport type GetFileHooks = {\n  getSnapFile: (\n    path: InferredGetFileParams['path'],\n    encoding: InferredGetFileParams['encoding'],\n  ) => Promise<string>;\n};\n\n/**\n * The `snap_getFile` 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.getSnapFile - The function to load a static snap file.\n * @returns Nothing.\n */\nasync function implementation(\n  req: JsonRpcRequest<InferredGetFileParams>,\n  res: PendingJsonRpcResponse<GetFileResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnapFile }: GetFileHooks,\n): Promise<void> {\n  const { params } = req;\n\n  assertStruct(\n    params,\n    GetFileArgsStruct,\n    'Invalid \"snap_getFile\" parameters',\n    rpcErrors.invalidParams,\n  );\n\n  try {\n    res.result = await getSnapFile(\n      params.path,\n      params.encoding ?? AuxiliaryFileEncoding.Base64,\n    );\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n"]}

package/dist/chunk-FMUQOZIO.js

@@ -0,0 +1,57 @@
+"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/getBip32Entropy.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 targetName = "snap_getBip32Entropy";
+var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
+    targetName,
+    allowedCaveats: [_snapsutils.SnapCaveatType.PermittedDerivationPaths],
+    methodImplementation: getBip32EntropyImplementation(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 getBip32EntropyBuilder = Object.freeze({
+  targetName,
+  specificationBuilder,
+  methodHooks
+});
+function getBip32EntropyImplementation({
+  getMnemonic,
+  getUnlockPromise
+}) {
+  return async function getBip32Entropy(args) {
+    await getUnlockPromise(true);
+    const { params } = args;
+    _utils.assert.call(void 0, params);
+    const node = await _chunk632BZ6JYjs.getNode.call(void 0, {
+      curve: params.curve,
+      path: params.path,
+      secretRecoveryPhrase: await getMnemonic()
+    });
+    return node.toJSON();
+  };
+}
+
+
+
+
+exports.getBip32EntropyBuilder = getBip32EntropyBuilder; exports.getBip32EntropyImplementation = getBip32EntropyImplementation;
+//# sourceMappingURL=chunk-FMUQOZIO.js.map

package/dist/chunk-FMUQOZIO.js.map

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

package/dist/chunk-H45CGE4Z.js

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