@metamask/snaps-rpc-methods 5.0.0 → 7.0.0

package/dist/chunk-LITIVHN4.js

@@ -0,0 +1,73 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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/endowments/caveats/requestTime.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+function assertIsMaxRequestTime(value, ErrorWrapper) {
+  _utils.assertStruct.call(void 0, 
+    value,
+    _snapsutils.MaxRequestTimeStruct,
+    "Invalid maxRequestTime",
+    ErrorWrapper
+  );
+}
+function validateMaxRequestTimeCaveat(caveat) {
+  if (!_utils.hasProperty.call(void 0, caveat, "value")) {
+    throw _rpcerrors.rpcErrors.invalidParams({
+      message: "Invalid maxRequestTime caveat."
+    });
+  }
+  const { value } = caveat;
+  assertIsMaxRequestTime(value, _rpcerrors.rpcErrors.invalidParams);
+}
+function getMaxRequestTimeCaveatMapper(value) {
+  if (!value || !_utils.isObject.call(void 0, value) || _utils.isObject.call(void 0, value) && !_utils.hasProperty.call(void 0, value, "maxRequestTime")) {
+    return { caveats: null };
+  }
+  return {
+    caveats: [
+      {
+        type: _snapsutils.SnapCaveatType.MaxRequestTime,
+        value: value.maxRequestTime
+      }
+    ]
+  };
+}
+function createMaxRequestTimeMapper(mapper) {
+  return function(value) {
+    const { maxRequestTime, ...rest } = value;
+    const mapperResult = mapper(rest);
+    if (!maxRequestTime) {
+      return mapperResult;
+    }
+    return {
+      ...mapperResult,
+      caveats: [
+        ..._nullishCoalesce(mapperResult.caveats, () => ( [])),
+        {
+          type: _snapsutils.SnapCaveatType.MaxRequestTime,
+          value: maxRequestTime
+        }
+      ]
+    };
+  };
+}
+function getMaxRequestTimeCaveat(permission) {
+  const foundCaveat = _optionalChain([permission, 'optionalAccess', _ => _.caveats, 'optionalAccess', _2 => _2.find, 'call', _3 => _3(
+    (caveat) => caveat.type === _snapsutils.SnapCaveatType.MaxRequestTime
+  )]);
+  return _nullishCoalesce(_optionalChain([foundCaveat, 'optionalAccess', _4 => _4.value]), () => ( null));
+}
+var maxRequestTimeCaveatSpecifications = {
+  [_snapsutils.SnapCaveatType.MaxRequestTime]: Object.freeze({
+    type: _snapsutils.SnapCaveatType.MaxRequestTime,
+    validator: (caveat) => validateMaxRequestTimeCaveat(caveat)
+  })
+};
+
+
+
+
+
+
+exports.getMaxRequestTimeCaveatMapper = getMaxRequestTimeCaveatMapper; exports.createMaxRequestTimeMapper = createMaxRequestTimeMapper; exports.getMaxRequestTimeCaveat = getMaxRequestTimeCaveat; exports.maxRequestTimeCaveatSpecifications = maxRequestTimeCaveatSpecifications;
+//# sourceMappingURL=chunk-LITIVHN4.js.map

package/dist/chunk-LITIVHN4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/caveats/requestTime.ts"],"names":[],"mappings":";AAKA,SAAS,iBAAiB;AAC1B,SAAS,sBAAsB,sBAAsB;AAErD,SAAS,cAAc,aAAa,gBAAgB;AAYpD,SAAS,uBACP,OACA,cACyB;AACzB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AASA,SAAS,6BAA6B,QAA6B;AACjE,MAAI,CAAC,YAAY,QAAQ,OAAO,GAAG;AACjC,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAClB,yBAAuB,OAAO,UAAU,aAAa;AACvD;AAUO,SAAS,8BACd,OACyB;AACzB,MACE,CAAC,SACD,CAAC,SAAS,KAAK,KACd,SAAS,KAAK,KAAK,CAAC,YAAY,OAAO,gBAAgB,GACxD;AACA,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AACA,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB,OAAO,MAAM;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACF;AASO,SAAS,2BACd,QACsB;AACtB,SAAO,SAAU,OAAa;AAE5B,UAAM,EAAE,gBAAgB,GAAG,KAAK,IAAI;AAEpC,UAAM,eAAe,OAAO,IAAI;AAEhC,QAAI,CAAC,gBAAgB;AACnB,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,MACL,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAI,aAAa,WAAW,CAAC;AAAA,QAC7B;AAAA,UACE,MAAM,eAAe;AAAA,UACrB,OAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,wBACd,YACe;AACf,QAAM,cAAc,YAAY,SAAS;AAAA,IACvC,CAAC,WAAW,OAAO,SAAS,eAAe;AAAA,EAC7C;AACA,SAAQ,aAAa,SAAoB;AAC3C;AAEO,IAAM,qCAGT;AAAA,EACF,CAAC,eAAe,cAAc,GAAG,OAAO,OAAO;AAAA,IAC7C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WACV,6BAA6B,MAAM;AAAA,EACvC,CAAC;AACH","sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { MaxRequestTimeStruct, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { AssertionErrorConstructor, Json } from '@metamask/utils';\nimport { assertStruct, hasProperty, isObject } from '@metamask/utils';\n\nimport type { CaveatMapperFunction, CaveatMapperReturnValue } from './generic';\n\n/**\n * Asserts that the given value is a valid `maxRequestTime` value.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid `maxRequestTime` value.\n */\nfunction assertIsMaxRequestTime(\n  value: unknown, // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is number {\n  assertStruct(\n    value,\n    MaxRequestTimeStruct,\n    'Invalid maxRequestTime',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Validate the value of a caveat. This does not validate the type of the\n * caveat itself, only the value of the caveat.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateMaxRequestTimeCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value')) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid maxRequestTime caveat.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsMaxRequestTime(value, rpcErrors.invalidParams);\n}\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getMaxRequestTimeCaveatMapper(\n  value: Json,\n): CaveatMapperReturnValue {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && !hasProperty(value, 'maxRequestTime'))\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.MaxRequestTime,\n        value: value.maxRequestTime,\n      },\n    ],\n  };\n}\n\n/**\n * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat\n * and merges it with any other caveats created by the mapper function.\n *\n * @param mapper - Another caveat mapper function.\n * @returns The caveat specification.\n */\nexport function createMaxRequestTimeMapper(\n  mapper: CaveatMapperFunction,\n): CaveatMapperFunction {\n  return function (value: Json) {\n    // We assume this to be used only with caveats of this type\n    const { maxRequestTime, ...rest } = value as Record<string, Json>;\n\n    const mapperResult = mapper(rest);\n\n    if (!maxRequestTime) {\n      return mapperResult;\n    }\n\n    return {\n      ...mapperResult,\n      caveats: [\n        ...(mapperResult.caveats ?? []),\n        {\n          type: SnapCaveatType.MaxRequestTime,\n          value: maxRequestTime,\n        },\n      ],\n    };\n  };\n}\n\n/**\n * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value if present, otherwise null.\n */\nexport function getMaxRequestTimeCaveat(\n  permission?: PermissionConstraint,\n): number | null {\n  const foundCaveat = permission?.caveats?.find(\n    (caveat) => caveat.type === SnapCaveatType.MaxRequestTime,\n  );\n  return (foundCaveat?.value as number) ?? null;\n}\n\nexport const maxRequestTimeCaveatSpecifications: Record<\n  SnapCaveatType.MaxRequestTime,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.MaxRequestTime]: Object.freeze({\n    type: SnapCaveatType.MaxRequestTime,\n    validator: (caveat: Caveat<string, any>) =>\n      validateMaxRequestTimeCaveat(caveat),\n  }),\n};\n"]}

package/dist/chunk-LU3J2EYE.js

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkNUKEBOOLjs = require('./chunk-NUKEBOOL.js');
+
+
+var _chunkCIIMO4C2js = require('./chunk-CIIMO4C2.js');
+
+
+var _chunk4ALFLY5Djs = require('./chunk-4ALFLY5D.js');
+
+
+var _chunkDDGDVWAWjs = require('./chunk-DDGDVWAW.js');
+
+
+var _chunkZLLV3F4Gjs = require('./chunk-ZLLV3F4G.js');
+
+
+var _chunkH45CGE4Zjs = require('./chunk-H45CGE4Z.js');
+
+
+var _chunk2IL6T3EXjs = require('./chunk-2IL6T3EX.js');
+
+
+var _chunkF5BEVZOBjs = require('./chunk-F5BEVZOB.js');
+
+
+var _chunk7O63CIBTjs = require('./chunk-7O63CIBT.js');
+
+
+var _chunkSXSNJEE7js = require('./chunk-SXSNJEE7.js');
+
+// src/permitted/handlers.ts
+var methodHandlers = {
+  wallet_getAllSnaps: _chunkH45CGE4Zjs.getAllSnapsHandler,
+  wallet_getSnaps: _chunkSXSNJEE7js.getSnapsHandler,
+  wallet_requestSnaps: _chunk4ALFLY5Djs.requestSnapsHandler,
+  wallet_invokeSnap: _chunkCIIMO4C2js.invokeSnapSugarHandler,
+  wallet_invokeKeyring: _chunkNUKEBOOLjs.invokeKeyringHandler,
+  snap_getClientStatus: _chunk2IL6T3EXjs.getClientStatusHandler,
+  snap_getFile: _chunkF5BEVZOBjs.getFileHandler,
+  snap_createInterface: _chunkZLLV3F4Gjs.createInterfaceHandler,
+  snap_updateInterface: _chunkDDGDVWAWjs.updateInterfaceHandler,
+  snap_getInterfaceState: _chunk7O63CIBTjs.getInterfaceStateHandler
+};
+var handlers = Object.values(methodHandlers);
+
+
+
+
+exports.methodHandlers = methodHandlers; exports.handlers = handlers;
+//# sourceMappingURL=chunk-LU3J2EYE.js.map

package/dist/chunk-LU3J2EYE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/handlers.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYO,IAAM,iBAAiB;AAAA,EAC5B,oBAAoB;AAAA,EACpB,iBAAiB;AAAA,EACjB,qBAAqB;AAAA,EACrB,mBAAmB;AAAA,EACnB,sBAAsB;AAAA,EACtB,sBAAsB;AAAA,EACtB,cAAc;AAAA,EACd,sBAAsB;AAAA,EACtB,sBAAsB;AAAA,EACtB,wBAAwB;AAC1B;AAGO,IAAM,WAAW,OAAO,OAAO,cAAc","sourcesContent":["import { createInterfaceHandler } from './createInterface';\nimport { getAllSnapsHandler } from './getAllSnaps';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getInterfaceStateHandler } from './getInterfaceState';\nimport { getSnapsHandler } from './getSnaps';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { requestSnapsHandler } from './requestSnaps';\nimport { updateInterfaceHandler } from './updateInterface';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n  snap_createInterface: createInterfaceHandler,\n  snap_updateInterface: updateInterfaceHandler,\n  snap_getInterfaceState: getInterfaceStateHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport const handlers = Object.values(methodHandlers);\n"]}

package/dist/chunk-LX37AMSK.mjs

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

package/dist/chunk-LX37AMSK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/transaction-insight.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n  PermissionValidatorConstraint,\n  PermissionConstraint,\n  CaveatSpecificationConstraint,\n  Caveat,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isObject, isPlainObject } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.TransactionInsight;\n\ntype TransactionInsightEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * `endowment:transaction-insight` returns nothing; it is intended to be used as a flag\n * by the extension to detect whether the snap has the capability to show information on the transaction confirmation screen.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the transaction-insight endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  TransactionInsightEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.TransactionOrigin,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.TransactionOrigin, optional: true },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const transactionInsightEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Validates the type of the caveat value.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateCaveat(caveat: Caveat<string, any>): void {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n\n  assert(\n    typeof value === 'boolean',\n    'Expected caveat value to have type \"boolean\"',\n  );\n}\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getTransactionInsightCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && Object.keys(value).length === 0)\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.TransactionOrigin,\n        value:\n          hasProperty(value, 'allowTransactionOrigin') &&\n          (value.allowTransactionOrigin as boolean),\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the transaction origin caveat from a permission.\n *\n * This does basic validation of the caveat, but does not validate the type or\n * value of the namespaces object itself, as this is handled by the\n * `PermissionsController` when the permission is requested.\n *\n * @param permission - The permission to get the transaction origin caveat from.\n * @returns The transaction origin, or `null` if the permission does not have a\n * transaction origin caveat.\n */\nexport function getTransactionOriginCaveat(\n  permission?: PermissionConstraint,\n): boolean | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.TransactionOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, boolean>;\n\n  return caveat.value ?? null;\n}\n\nexport const transactionInsightCaveatSpecifications: Record<\n  SnapCaveatType.TransactionOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.TransactionOrigin]: Object.freeze({\n    type: SnapCaveatType.TransactionOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveat(caveat),\n  }),\n};\n"],"mappings":";;;;;AASA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAC1B,SAAS,sBAAsB;AAE/B,SAAS,QAAQ,aAAa,UAAU,qBAAqB;AAK7D,IAAM;AAiBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,MACd,eAAe;AAAA,MACf,eAAe;AAAA,IACjB;AAAA,IACA,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,WAAW,iCAAiC;AAAA,MAC1C,EAAE,MAAM,eAAe,mBAAmB,UAAU,KAAK;AAAA,MACzD,EAAE,MAAM,eAAe,gBAAgB,UAAU,KAAK;AAAA,IACxD,CAAC;AAAA,IACD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,qCAAqC,OAAO,OAAO;AAAA,EAC9D,YAAY;AAAA,EACZ;AACF,CAAU;AAQV,SAAS,eAAe,QAAmC;AACzD,MAAI,CAAC,YAAY,QAAQ,OAAO,KAAK,CAAC,cAAc,MAAM,GAAG;AAC3D,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAElB;AAAA,IACE,OAAO,UAAU;AAAA,IACjB;AAAA,EACF;AACF;AAUO,SAAS,kCACd,OACuC;AACvC,MACE,CAAC,SACD,CAAC,SAAS,KAAK,KACd,SAAS,KAAK,KAAK,OAAO,KAAK,KAAK,EAAE,WAAW,GAClD;AACA,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AACA,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB,OACE,YAAY,OAAO,wBAAwB,KAC1C,MAAM;AAAA,MACX;AAAA,IACF;AAAA,EACF;AACF;AAaO,SAAS,2BACd,YACgB;AAChB,MAAI,CAAC,YAAY,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,iBAAiB;AAEtE,QAAM,SAAS,WAAW,QAAQ,CAAC;AAEnC,SAAO,OAAO,SAAS;AACzB;AAEO,IAAM,yCAGT;AAAA,EACF,CAAC,eAAe,iBAAiB,GAAG,OAAO,OAAO;AAAA,IAChD,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAgC,eAAe,MAAM;AAAA,EACnE,CAAC;AACH;","names":[]}

package/dist/chunk-LYOKCYHO.mjs

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

package/dist/chunk-LYOKCYHO.mjs.map

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

package/dist/chunk-MDJZ4K3U.mjs

@@ -0,0 +1,45 @@
+// src/permitted/invokeSnapSugar.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { isObject } from "@metamask/utils";
+var invokeSnapSugarHandler = {
+  methodNames: ["wallet_invokeSnap"],
+  implementation: invokeSnapSugar,
+  hookNames: void 0
+};
+function invokeSnapSugar(req, _res, next, end) {
+  let params;
+  try {
+    params = getValidatedParams(req.params);
+  } catch (error) {
+    return end(error);
+  }
+  req.method = "wallet_snap";
+  req.params = params;
+  return next();
+}
+function getValidatedParams(params) {
+  if (!isObject(params)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected params to be a single object."
+    });
+  }
+  const { snapId, request } = params;
+  if (!snapId || typeof snapId !== "string" || snapId === "") {
+    throw rpcErrors.invalidParams({
+      message: "Must specify a valid snap ID."
+    });
+  }
+  if (!isObject(request)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected request to be a single object."
+    });
+  }
+  return params;
+}
+
+export {
+  invokeSnapSugarHandler,
+  invokeSnapSugar,
+  getValidatedParams
+};
+//# sourceMappingURL=chunk-MDJZ4K3U.mjs.map

package/dist/chunk-MDJZ4K3U.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/invokeSnapSugar.ts"],"sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  JsonRpcEngineNextCallback,\n} from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { InvokeSnapParams, InvokeSnapResult } from '@metamask/snaps-sdk';\nimport type { JsonRpcRequest } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\n/**\n * `wallet_invokeSnap` attempts to invoke an RPC method of the specified Snap.\n */\nexport const invokeSnapSugarHandler: PermittedHandlerExport<\n  void,\n  InvokeSnapParams,\n  InvokeSnapResult\n> = {\n  methodNames: ['wallet_invokeSnap'],\n  implementation: invokeSnapSugar,\n  hookNames: undefined,\n};\n\n/**\n * The `wallet_invokeSnap` method implementation.\n * Reroutes incoming JSON-RPC requests that are targeting snaps, by modifying the method and params.\n *\n * @param req - The JSON-RPC request object.\n * @param _res - The JSON-RPC response object. Not used by this\n * function.\n * @param next - The `json-rpc-engine` \"next\" callback.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @returns Nothing.\n * @throws If the params are invalid.\n */\nexport function invokeSnapSugar(\n  req: JsonRpcRequest<InvokeSnapParams>,\n  _res: unknown,\n  next: JsonRpcEngineNextCallback,\n  end: JsonRpcEngineEndCallback,\n): void {\n  let params: InvokeSnapParams;\n  try {\n    params = getValidatedParams(req.params);\n  } catch (error) {\n    return end(error);\n  }\n\n  req.method = 'wallet_snap';\n  req.params = params;\n  return next();\n}\n\n/**\n * Validates the wallet_invokeSnap 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): InvokeSnapParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { snapId, request } = params;\n\n  if (!snapId || typeof snapId !== 'string' || snapId === '') {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid snap ID.',\n    });\n  }\n\n  if (!isObject(request)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected request to be a single object.',\n    });\n  }\n\n  return params as InvokeSnapParams;\n}\n"],"mappings":";AAKA,SAAS,iBAAiB;AAG1B,SAAS,gBAAgB;AAKlB,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,mBAAmB;AAAA,EACjC,gBAAgB;AAAA,EAChB,WAAW;AACb;AAcO,SAAS,gBACd,KACA,MACA,MACA,KACM;AACN,MAAI;AACJ,MAAI;AACF,aAAS,mBAAmB,IAAI,MAAM;AAAA,EACxC,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,MAAI,SAAS;AACb,MAAI,SAAS;AACb,SAAO,KAAK;AACd;AASO,SAAS,mBAAmB,QAAmC;AACpE,MAAI,CAAC,SAAS,MAAM,GAAG;AACrB,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,QAAQ,QAAQ,IAAI;AAE5B,MAAI,CAAC,UAAU,OAAO,WAAW,YAAY,WAAW,IAAI;AAC1D,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,MAAI,CAAC,SAAS,OAAO,GAAG;AACtB,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-MVPKNRLA.mjs

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

package/dist/chunk-MVPKNRLA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/home-page.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.HomePage;\n\ntype HomePageEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:page-home` returns nothing; it is intended to be used as a\n * flag by the snap controller to detect whether the snap has the capability to\n * use the snap home page feature.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the `snap-pages` endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  HomePageEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const homePageEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAK5C,IAAM;AAiBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,2BAA2B,OAAO,OAAO;AAAA,EACpD,YAAY;AAAA,EACZ;AACF,CAAU;","names":[]}

package/dist/chunk-MYMH4S2N.mjs

@@ -0,0 +1,23 @@
+// src/permitted/getAllSnaps.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+var hookNames = {
+  getAllSnaps: true
+};
+var getAllSnapsHandler = {
+  methodNames: ["wallet_getAllSnaps"],
+  implementation: getAllSnapsImplementation,
+  hookNames
+};
+async function getAllSnapsImplementation(request, response, _next, end, { getAllSnaps }) {
+  const { origin } = request;
+  if (origin !== "https://snaps.metamask.io") {
+    return end(rpcErrors.methodNotFound());
+  }
+  response.result = await getAllSnaps();
+  return end();
+}
+
+export {
+  getAllSnapsHandler
+};
+//# sourceMappingURL=chunk-MYMH4S2N.mjs.map

package/dist/chunk-MYMH4S2N.mjs.map

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

package/dist/chunk-NE2GDZGZ.mjs

@@ -0,0 +1,67 @@
+import {
+  deriveEntropy
+} from "./chunk-DR63Z4PV.mjs";
+
+// src/restricted/getEntropy.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { SIP_6_MAGIC_VALUE } from "@metamask/snaps-utils";
+import { assertStruct } from "@metamask/utils";
+import { literal, object, optional, string } from "superstruct";
+var targetName = "snap_getEntropy";
+var GetEntropyArgsStruct = object({
+  version: literal(1),
+  salt: optional(string())
+});
+var specificationBuilder = ({
+  allowedCaveats = null,
+  methodHooks: methodHooks2
+}) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName,
+    allowedCaveats,
+    methodImplementation: getEntropyImplementation(methodHooks2),
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  getMnemonic: true,
+  getUnlockPromise: true
+};
+var getEntropyBuilder = Object.freeze({
+  targetName,
+  specificationBuilder,
+  methodHooks
+});
+function getEntropyImplementation({
+  getMnemonic,
+  getUnlockPromise
+}) {
+  return async function getEntropy(options) {
+    const {
+      params,
+      context: { origin }
+    } = options;
+    assertStruct(
+      params,
+      GetEntropyArgsStruct,
+      'Invalid "snap_getEntropy" parameters',
+      rpcErrors.invalidParams
+    );
+    await getUnlockPromise(true);
+    const mnemonicPhrase = await getMnemonic();
+    return deriveEntropy({
+      input: origin,
+      salt: params.salt,
+      mnemonicPhrase,
+      magic: SIP_6_MAGIC_VALUE
+    });
+  };
+}
+
+export {
+  GetEntropyArgsStruct,
+  getEntropyBuilder
+};
+//# sourceMappingURL=chunk-NE2GDZGZ.mjs.map

package/dist/chunk-NE2GDZGZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getEntropy.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 type { GetEntropyParams, GetEntropyResult } from '@metamask/snaps-sdk';\nimport { SIP_6_MAGIC_VALUE } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport type { Infer } from 'superstruct';\nimport { literal, object, optional, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\nconst targetName = 'snap_getEntropy';\n\ntype GetEntropySpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: GetEntropyHooks;\n};\n\ntype GetEntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getEntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\nexport const GetEntropyArgsStruct = object({\n  version: literal(1),\n  salt: optional(string()),\n});\n\n/**\n * @property version - The version of the `snap_getEntropy` method. This must be\n * the numeric literal `1`.\n * @property salt - A string to use as the salt when deriving the entropy. If\n * omitted, the salt will be an empty string.\n */\nexport type GetEntropyArgs = Infer<typeof GetEntropyArgsStruct>;\n\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetEntropySpecificationBuilderOptions,\n  GetEntropySpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: GetEntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats,\n    methodImplementation: getEntropyImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetEntropyHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getEntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport type GetEntropyHooks = {\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\n/**\n * Builds the method implementation for `snap_getEntropy`. The implementation\n * is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - The method to get the mnemonic of the user's\n * primary keyring.\n * @param hooks.getUnlockPromise - The method to get a promise that resolves\n * once the extension is unlocked.\n * @returns The method implementation.\n */\nfunction getEntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetEntropyHooks) {\n  return async function getEntropy(\n    options: RestrictedMethodOptions<GetEntropyParams>,\n  ): Promise<GetEntropyResult> {\n    const {\n      params,\n      context: { origin },\n    } = options;\n\n    assertStruct(\n      params,\n      GetEntropyArgsStruct,\n      'Invalid \"snap_getEntropy\" parameters',\n      rpcErrors.invalidParams,\n    );\n\n    await getUnlockPromise(true);\n    const mnemonicPhrase = await getMnemonic();\n\n    return deriveEntropy({\n      input: origin,\n      salt: params.salt,\n      mnemonicPhrase,\n      magic: SIP_6_MAGIC_VALUE,\n    });\n  };\n}\n"],"mappings":";;;;;AAKA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAE1B,SAAS,yBAAyB;AAElC,SAAS,oBAAoB;AAE7B,SAAS,SAAS,QAAQ,UAAU,cAAc;AAKlD,IAAM,aAAa;AAcZ,IAAM,uBAAuB,OAAO;AAAA,EACzC,SAAS,QAAQ,CAAC;AAAA,EAClB,MAAM,SAAS,OAAO,CAAC;AACzB,CAAC;AAUD,IAAM,uBAIF,CAAC;AAAA,EACH,iBAAiB;AAAA,EACjB,aAAAA;AACF,MAA6C;AAC3C,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA;AAAA,IACA,sBAAsB,yBAAyBA,YAAW;AAAA,IAC1D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAAkD;AAAA,EACtD,aAAa;AAAA,EACb,kBAAkB;AACpB;AAEO,IAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C;AAAA,EACA;AAAA,EACA;AACF,CAAU;AA4BV,SAAS,yBAAyB;AAAA,EAChC;AAAA,EACA;AACF,GAAoB;AAClB,SAAO,eAAe,WACpB,SAC2B;AAC3B,UAAM;AAAA,MACJ;AAAA,MACA,SAAS,EAAE,OAAO;AAAA,IACpB,IAAI;AAEJ;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA,UAAU;AAAA,IACZ;AAEA,UAAM,iBAAiB,IAAI;AAC3B,UAAM,iBAAiB,MAAM,YAAY;AAEzC,WAAO,cAAc;AAAA,MACnB,OAAO;AAAA,MACP,MAAM,OAAO;AAAA,MACb;AAAA,MACA,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;","names":["methodHooks"]}

package/dist/chunk-NTDD6M3B.mjs

@@ -0,0 +1,32 @@
+// src/restricted/getLocale.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+var methodName = "snap_getLocale";
+var specificationBuilder = ({ allowedCaveats = null, methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName: methodName,
+    allowedCaveats,
+    methodImplementation: getImplementation(methodHooks2),
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  getLocale: true
+};
+var getLocaleBuilder = Object.freeze({
+  targetName: methodName,
+  specificationBuilder,
+  methodHooks
+});
+function getImplementation({ getLocale }) {
+  return async function implementation(_args) {
+    return getLocale();
+  };
+}
+
+export {
+  specificationBuilder,
+  getLocaleBuilder,
+  getImplementation
+};
+//# sourceMappingURL=chunk-NTDD6M3B.mjs.map

package/dist/chunk-NTDD6M3B.mjs.map

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

package/dist/chunk-NUKEBOOL.js

@@ -0,0 +1,78 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkCIIMO4C2js = require('./chunk-CIIMO4C2.js');
+
+// src/permitted/invokeKeyring.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@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 = _chunkCIIMO4C2js.getValidatedParams.call(void 0, req.params);
+  } catch (error) {
+    return end(error);
+  }
+  const { origin } = req;
+  const { snapId, request } = params;
+  if (!origin || !hasPermission(_snapsutils.WALLET_SNAP_PERMISSION_KEY)) {
+    return end(
+      _rpcerrors.rpcErrors.invalidRequest({
+        message: `The snap "${snapId}" is not connected to "${origin}". Please connect before invoking the snap.`
+      })
+    );
+  }
+  if (!getSnap(snapId)) {
+    return end(
+      _rpcerrors.rpcErrors.invalidRequest({
+        message: `The snap "${snapId}" is not installed. Please install it first, before invoking the snap.`
+      })
+    );
+  }
+  if (!_utils.hasProperty.call(void 0, request, "method") || typeof request.method !== "string") {
+    return end(
+      _rpcerrors.rpcErrors.invalidRequest({
+        message: "The request must have a method."
+      })
+    );
+  }
+  const allowedMethods = getAllowedKeyringMethods();
+  if (!allowedMethods.includes(request.method)) {
+    return end(
+      _rpcerrors.rpcErrors.invalidRequest({
+        message: `The origin "${origin}" is not allowed to invoke the method "${request.method}".`
+      })
+    );
+  }
+  try {
+    res.result = await handleSnapRpcRequest({
+      snapId,
+      request,
+      handler: _snapsutils.HandlerType.OnKeyringRequest
+    });
+  } catch (error) {
+    return end(error);
+  }
+  return end();
+}
+
+
+
+exports.invokeKeyringHandler = invokeKeyringHandler;
+//# sourceMappingURL=chunk-NUKEBOOL.js.map

package/dist/chunk-NUKEBOOL.js.map

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

package/dist/chunk-OMP4SFLK.js

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

package/dist/chunk-OMP4SFLK.js.map

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

package/dist/chunk-OU3QPU6E.mjs

@@ -0,0 +1,45 @@
+// src/permitted/updateInterface.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { ComponentStruct } from "@metamask/snaps-sdk";
+import { StructError, create, object, string } from "superstruct";
+var hookNames = {
+  updateInterface: true
+};
+var updateInterfaceHandler = {
+  methodNames: ["snap_updateInterface"],
+  implementation: getUpdateInterfaceImplementation,
+  hookNames
+};
+var UpdateInterfaceParametersStruct = object({
+  id: string(),
+  ui: ComponentStruct
+});
+async function getUpdateInterfaceImplementation(req, res, _next, end, { updateInterface }) {
+  const { params } = req;
+  try {
+    const validatedParams = getValidatedParams(params);
+    const { id, ui } = validatedParams;
+    await updateInterface(id, ui);
+    res.result = null;
+  } catch (error) {
+    return end(error);
+  }
+  return end();
+}
+function getValidatedParams(params) {
+  try {
+    return create(params, UpdateInterfaceParametersStruct);
+  } catch (error) {
+    if (error instanceof StructError) {
+      throw rpcErrors.invalidParams({
+        message: `Invalid params: ${error.message}.`
+      });
+    }
+    throw rpcErrors.internal();
+  }
+}
+
+export {
+  updateInterfaceHandler
+};
+//# sourceMappingURL=chunk-OU3QPU6E.mjs.map

package/dist/chunk-OU3QPU6E.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/updateInterface.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  Component,\n  UpdateInterfaceParams,\n  UpdateInterfaceResult,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { ComponentStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<UpdateInterfaceMethodHooks> = {\n  updateInterface: true,\n};\n\nexport type UpdateInterfaceMethodHooks = {\n  /**\n   * @param id - The interface ID.\n   * @param ui - The UI components.\n   */\n  updateInterface: (id: string, ui: Component) => Promise<void>;\n};\n\nexport const updateInterfaceHandler: PermittedHandlerExport<\n  UpdateInterfaceMethodHooks,\n  UpdateInterfaceParameters,\n  UpdateInterfaceResult\n> = {\n  methodNames: ['snap_updateInterface'],\n  implementation: getUpdateInterfaceImplementation,\n  hookNames,\n};\n\nconst UpdateInterfaceParametersStruct = object({\n  id: string(),\n  ui: ComponentStruct,\n});\n\nexport type UpdateInterfaceParameters = InferMatching<\n  typeof UpdateInterfaceParametersStruct,\n  UpdateInterfaceParams\n>;\n\n/**\n * The `snap_updateInterface` 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.updateInterface - The function to update the interface.\n * @returns Nothing.\n */\nasync function getUpdateInterfaceImplementation(\n  req: JsonRpcRequest<UpdateInterfaceParameters>,\n  res: PendingJsonRpcResponse<UpdateInterfaceResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { updateInterface }: UpdateInterfaceMethodHooks,\n): Promise<void> {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id, ui } = validatedParams;\n\n    await updateInterface(id, ui);\n    res.result = null;\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the updateInterface 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 updateInterface method parameter object.\n */\nfunction getValidatedParams(params: unknown): UpdateInterfaceParameters {\n  try {\n    return create(params, UpdateInterfaceParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"mappings":";AAEA,SAAS,iBAAiB;AAO1B,SAAS,uBAAuB;AAGhC,SAAS,aAAa,QAAQ,QAAQ,cAAc;AAIpD,IAAM,YAA2D;AAAA,EAC/D,iBAAiB;AACnB;AAUO,IAAM,yBAIT;AAAA,EACF,aAAa,CAAC,sBAAsB;AAAA,EACpC,gBAAgB;AAAA,EAChB;AACF;AAEA,IAAM,kCAAkC,OAAO;AAAA,EAC7C,IAAI,OAAO;AAAA,EACX,IAAI;AACN,CAAC;AAmBD,eAAe,iCACb,KACA,KACA,OACA,KACA,EAAE,gBAAgB,GACH;AACf,QAAM,EAAE,OAAO,IAAI;AAEnB,MAAI;AACF,UAAM,kBAAkB,mBAAmB,MAAM;AAEjD,UAAM,EAAE,IAAI,GAAG,IAAI;AAEnB,UAAM,gBAAgB,IAAI,EAAE;AAC5B,QAAI,SAAS;AAAA,EACf,SAAS,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,SAAO,IAAI;AACb;AASA,SAAS,mBAAmB,QAA4C;AACtE,MAAI;AACF,WAAO,OAAO,QAAQ,+BAA+B;AAAA,EACvD,SAAS,OAAO;AACd,QAAI,iBAAiB,aAAa;AAChC,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mBAAmB,MAAM,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,SAAS;AAAA,EAC3B;AACF;","names":[]}