@metamask/snaps-execution-environments 4.0.1 → 5.0.1

package/dist/chunk-MOXNHXPG.js

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk44XYIN4Njs = require('./chunk-44XYIN4N.js');
+
+
+var _chunkDLLLH5HNjs = require('./chunk-DLLLH5HN.js');
+
+// src/common/endowments/index.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+var registeredEndowments = _chunk44XYIN4Njs.commonEndowmentFactory_default.call(void 0, );
+var endowmentFactories = registeredEndowments.reduce((factories, builder) => {
+  builder.names.forEach((name) => {
+    factories.set(name, builder.factory);
+  });
+  return factories;
+}, /* @__PURE__ */ new Map());
+function createEndowments({
+  snap,
+  ethereum,
+  snapId,
+  endowments,
+  notify
+}) {
+  const attenuatedEndowments = {};
+  const result = endowments.reduce(
+    ({ allEndowments, teardowns }, endowmentName) => {
+      if (endowmentFactories.has(endowmentName)) {
+        if (!_utils.hasProperty.call(void 0, attenuatedEndowments, endowmentName)) {
+          const { teardownFunction, ...endowment } = endowmentFactories.get(
+            endowmentName
+          )({ snapId, notify });
+          Object.assign(attenuatedEndowments, endowment);
+          if (teardownFunction) {
+            teardowns.push(teardownFunction);
+          }
+        }
+        allEndowments[endowmentName] = attenuatedEndowments[endowmentName];
+      } else if (endowmentName === "ethereum") {
+        allEndowments[endowmentName] = ethereum;
+      } else if (endowmentName in _chunkDLLLH5HNjs.rootRealmGlobal) {
+        _snapsutils.logWarning.call(void 0, `Access to unhardened global ${endowmentName}.`);
+        const globalValue = _chunkDLLLH5HNjs.rootRealmGlobal[endowmentName];
+        allEndowments[endowmentName] = globalValue;
+      } else {
+        throw _rpcerrors.rpcErrors.internal(`Unknown endowment: "${endowmentName}".`);
+      }
+      return { allEndowments, teardowns };
+    },
+    {
+      allEndowments: { snap },
+      teardowns: []
+    }
+  );
+  const teardown = async () => {
+    await Promise.all(
+      result.teardowns.map((teardownFunction) => teardownFunction())
+    );
+  };
+  return { endowments: result.allEndowments, teardown };
+}
+
+
+
+exports.createEndowments = createEndowments;
+//# sourceMappingURL=chunk-MOXNHXPG.js.map

package/dist/chunk-MOXNHXPG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/index.ts"],"names":[],"mappings":";;;;;;;;AACA,SAAS,iBAAiB;AAE1B,SAAS,kBAAkB;AAC3B,SAAS,mBAAmB;AAuB5B,IAAM,uBAAuB,+BAAsB;AAOnD,IAAM,qBAAqB,qBAAqB,OAAO,CAAC,WAAW,YAAY;AAC7E,UAAQ,MAAM,QAAQ,CAAC,SAAS;AAC9B,cAAU,IAAI,MAAM,QAAQ,OAAO;AAAA,EACrC,CAAC;AACD,SAAO;AACT,GAAG,oBAAI,IAA2E,CAAC;AAiB5E,SAAS,iBAAiB;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAM2E;AACzE,QAAM,uBAAgD,CAAC;AAKvD,QAAM,SAAS,WAAW;AAAA,IAIxB,CAAC,EAAE,eAAe,UAAU,GAAG,kBAAkB;AAE/C,UAAI,mBAAmB,IAAI,aAAa,GAAG;AACzC,YAAI,CAAC,YAAY,sBAAsB,aAAa,GAAG;AASrD,gBAAM,EAAE,kBAAkB,GAAG,UAAU,IAAI,mBAAmB;AAAA,YAC5D;AAAA,UACF,EAAG,EAAE,QAAQ,OAAO,CAAC;AACrB,iBAAO,OAAO,sBAAsB,SAAS;AAC7C,cAAI,kBAAkB;AACpB,sBAAU,KAAK,gBAAgB;AAAA,UACjC;AAAA,QACF;AACA,sBAAc,aAAa,IAAI,qBAAqB,aAAa;AAAA,MACnE,WAAW,kBAAkB,YAAY;AAEvC,sBAAc,aAAa,IAAI;AAAA,MACjC,WAAW,iBAAiB,iBAAiB;AAC3C,mBAAW,+BAA+B,aAAa,GAAG;AAG1D,cAAM,cAAe,gBACnB,aACF;AACA,sBAAc,aAAa,IAAI;AAAA,MACjC,OAAO;AAGL,cAAM,UAAU,SAAS,uBAAuB,aAAa,IAAI;AAAA,MACnE;AACA,aAAO,EAAE,eAAe,UAAU;AAAA,IACpC;AAAA,IACA;AAAA,MACE,eAAe,EAAE,KAAK;AAAA,MACtB,WAAW,CAAC;AAAA,IACd;AAAA,EACF;AAEA,QAAM,WAAW,YAAY;AAC3B,UAAM,QAAQ;AAAA,MACZ,OAAO,UAAU,IAAI,CAAC,qBAAqB,iBAAiB,CAAC;AAAA,IAC/D;AAAA,EACF;AACA,SAAO,EAAE,YAAY,OAAO,eAAe,SAAS;AACtD","sourcesContent":["import type { StreamProvider } from '@metamask/providers';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { SnapsProvider } from '@metamask/snaps-sdk';\nimport { logWarning } from '@metamask/snaps-utils';\nimport { hasProperty } from '@metamask/utils';\n\nimport type { NotifyFunction } from '../BaseSnapExecutor';\nimport { rootRealmGlobal } from '../globalObject';\nimport type { EndowmentFactoryOptions } from './commonEndowmentFactory';\nimport buildCommonEndowments from './commonEndowmentFactory';\n\ntype EndowmentFactoryResult = {\n  /**\n   * A function that performs any necessary teardown when the snap becomes idle.\n   *\n   * NOTE:** The endowments are not reconstructed if the snap is re-invoked\n   * before being terminated, so the teardown operation must not render the\n   * endowments unusable; it should simply restore the endowments to their\n   * original state.\n   */\n  teardownFunction?: () => Promise<void> | void;\n  [key: string]: unknown;\n};\n\n/**\n * Retrieve consolidated endowment factories for common endowments.\n */\nconst registeredEndowments = buildCommonEndowments();\n\n/**\n * A map of endowment names to their factory functions. Some endowments share\n * the same factory function, but we only call each factory once for each snap.\n * See {@link createEndowments} for details.\n */\nconst endowmentFactories = registeredEndowments.reduce((factories, builder) => {\n  builder.names.forEach((name) => {\n    factories.set(name, builder.factory);\n  });\n  return factories;\n}, new Map<string, (options?: EndowmentFactoryOptions) => EndowmentFactoryResult>());\n\n/**\n * Gets the endowments for a particular Snap. Some endowments, like `setTimeout`\n * and `clearTimeout`, must be attenuated so that they can only affect behavior\n * within the Snap's own realm. Therefore, we use factory functions to create\n * such attenuated / modified endowments. Otherwise, the value that's on the\n * root realm global will be used.\n *\n * @param options - An options bag.\n * @param options.snap - The Snaps global API object.\n * @param options.ethereum - The Snap's EIP-1193 provider object.\n * @param options.snapId - The id of the snap that will use the created endowments.\n * @param options.endowments - The list of endowments to provide to the snap.\n * @param options.notify - A reference to the notify function of the snap executor.\n * @returns An object containing the Snap's endowments.\n */\nexport function createEndowments({\n  snap,\n  ethereum,\n  snapId,\n  endowments,\n  notify,\n}: {\n  snap: SnapsProvider;\n  ethereum: StreamProvider;\n  snapId: string;\n  endowments: string[];\n  notify: NotifyFunction;\n}): { endowments: Record<string, unknown>; teardown: () => Promise<void> } {\n  const attenuatedEndowments: Record<string, unknown> = {};\n\n  // TODO: All endowments should be hardened to prevent covert communication\n  // channels. Hardening the returned objects breaks tests elsewhere in the\n  // monorepo, so further research is needed.\n  const result = endowments.reduce<{\n    allEndowments: Record<string, unknown>;\n    teardowns: (() => Promise<void> | void)[];\n  }>(\n    ({ allEndowments, teardowns }, endowmentName) => {\n      // First, check if the endowment has a factory, and default to that.\n      if (endowmentFactories.has(endowmentName)) {\n        if (!hasProperty(attenuatedEndowments, endowmentName)) {\n          // Call the endowment factory for the current endowment. If the factory\n          // creates multiple endowments, they will all be assigned to the\n          // `attenuatedEndowments` object, but will only be passed on to the snap\n          // if explicitly listed among its endowment.\n          // This may not have an actual use case, but, safety first.\n\n          // We just confirmed that endowmentFactories has the specified key.\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          const { teardownFunction, ...endowment } = endowmentFactories.get(\n            endowmentName,\n          )!({ snapId, notify });\n          Object.assign(attenuatedEndowments, endowment);\n          if (teardownFunction) {\n            teardowns.push(teardownFunction);\n          }\n        }\n        allEndowments[endowmentName] = attenuatedEndowments[endowmentName];\n      } else if (endowmentName === 'ethereum') {\n        // Special case for adding the EIP-1193 provider.\n        allEndowments[endowmentName] = ethereum;\n      } else if (endowmentName in rootRealmGlobal) {\n        logWarning(`Access to unhardened global ${endowmentName}.`);\n        // If the endowment doesn't have a factory, just use whatever is on the\n        // global object.\n        const globalValue = (rootRealmGlobal as Record<string, unknown>)[\n          endowmentName\n        ];\n        allEndowments[endowmentName] = globalValue;\n      } else {\n        // If we get to this point, we've been passed an endowment that doesn't\n        // exist in our current environment.\n        throw rpcErrors.internal(`Unknown endowment: \"${endowmentName}\".`);\n      }\n      return { allEndowments, teardowns };\n    },\n    {\n      allEndowments: { snap },\n      teardowns: [],\n    },\n  );\n\n  const teardown = async () => {\n    await Promise.all(\n      result.teardowns.map((teardownFunction) => teardownFunction()),\n    );\n  };\n  return { endowments: result.allEndowments, teardown };\n}\n"]}

package/dist/chunk-MS2LQQYH.js

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkHGLRZZ56js = require('./chunk-HGLRZZ56.js');
+
+
+var _chunkDLLLH5HNjs = require('./chunk-DLLLH5HN.js');
+
+// src/common/endowments/math.ts
+function createMath() {
+  const keys = Object.getOwnPropertyNames(
+    _chunkDLLLH5HNjs.rootRealmGlobal.Math
+  );
+  const math = keys.reduce((target, key) => {
+    if (key === "random") {
+      return target;
+    }
+    return { ...target, [key]: _chunkDLLLH5HNjs.rootRealmGlobal.Math[key] };
+  }, {});
+  const { crypto: hardenedCrypto } = _chunkHGLRZZ56js.createCrypto.call(void 0, );
+  return harden({
+    Math: {
+      ...math,
+      random: () => {
+        return hardenedCrypto.getRandomValues(new Uint32Array(1))[0] / 2 ** 32;
+      }
+    }
+  });
+}
+var endowmentModule = {
+  names: ["Math"],
+  factory: createMath
+};
+var math_default = endowmentModule;
+
+
+
+exports.math_default = math_default;
+//# sourceMappingURL=chunk-MS2LQQYH.js.map

package/dist/chunk-MS2LQQYH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/math.ts"],"names":[],"mappings":";;;;;;;;AAUA,SAAS,aAAa;AAGpB,QAAM,OAAO,OAAO;AAAA,IAClB,gBAAgB;AAAA,EAClB;AAEA,QAAM,OAAO,KAAK,OAAsB,CAAC,QAAQ,QAAQ;AACvD,QAAI,QAAQ,UAAU;AACpB,aAAO;AAAA,IACT;AAEA,WAAO,EAAE,GAAG,QAAQ,CAAC,GAAG,GAAG,gBAAgB,KAAK,GAAG,EAAE;AAAA,EACvD,GAAG,CAAC,CAAC;AAGL,QAAM,EAAE,QAAQ,eAAe,IAAI,aAAa;AAEhD,SAAO,OAAO;AAAA,IACZ,MAAM;AAAA,MACJ,GAAG;AAAA,MACH,QAAQ,MAAM;AAiBZ,eAAO,eAAe,gBAAgB,IAAI,YAAY,CAAC,CAAC,EAAE,CAAC,IAAI,KAAK;AAAA,MACtE;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,MAAM;AAAA,EACd,SAAS;AACX;AAEA,IAAO,eAAQ","sourcesContent":["import { rootRealmGlobal } from '../globalObject';\nimport { createCrypto } from './crypto';\n\n/**\n * Create a {@link Math} object, with the same properties as the global\n * {@link Math} object, but with the {@link Math.random} method replaced.\n *\n * @returns The {@link Math} object with the {@link Math.random} method\n * replaced.\n */\nfunction createMath() {\n  // `Math` does not work with `Object.keys`, `Object.entries`, etc., so we\n  // need to create a new object with the same properties.\n  const keys = Object.getOwnPropertyNames(\n    rootRealmGlobal.Math,\n  ) as (keyof typeof Math)[];\n\n  const math = keys.reduce<Partial<Math>>((target, key) => {\n    if (key === 'random') {\n      return target;\n    }\n\n    return { ...target, [key]: rootRealmGlobal.Math[key] };\n  }, {});\n\n  // Since the math endowment requires crypto, we can leverage the crypto endowment factory to get a hardened and platform agnostic instance of webcrypto\n  const { crypto: hardenedCrypto } = createCrypto();\n\n  return harden({\n    Math: {\n      ...math,\n      random: () => {\n        // NOTE: This is not intended to be a secure replacement for the weak\n        // random number generator used by `Math.random`. It is only intended to\n        // prevent side channel attacks of `Math.random` by replacing it with an\n        // alternative implementation that is not vulnerable to the same\n        // attacks.\n        //\n        // This does not mean that this implementation is secure. It is not\n        // intended to be used in a security context, and this implementation\n        // may change at any time.\n        //\n        // To securely generate random numbers, use a cryptographically secure\n        // random number generator, such as the one provided by the Web Crypto\n        // API:\n        //\n        // - https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey\n        // - https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues\n        return hardenedCrypto.getRandomValues(new Uint32Array(1))[0] / 2 ** 32;\n      },\n    },\n  });\n}\n\nconst endowmentModule = {\n  names: ['Math'] as const,\n  factory: createMath,\n};\n\nexport default endowmentModule;\n"]}

package/dist/chunk-MXNMMTJW.mjs

@@ -0,0 +1,51 @@
+// src/common/lockdown/lockdown-more.ts
+import { logError } from "@metamask/snaps-utils";
+function executeLockdownMore() {
+  try {
+    const namedIntrinsics = Reflect.ownKeys(new Compartment().globalThis);
+    const shouldHardenManually = /* @__PURE__ */ new Set(["eval", "Function"]);
+    const globalProperties = /* @__PURE__ */ new Set([
+      // universalPropertyNames is a constant added by lockdown to global scope
+      // at the time of writing, it is initialized in 'ses/src/whitelist'.
+      // These properties tend to be non-enumerable.
+      ...namedIntrinsics
+      // TODO: Also include the named platform globals
+      // This grabs every enumerable property on globalThis.
+      // ...Object.keys(globalThis),
+    ]);
+    globalProperties.forEach((propertyName) => {
+      const descriptor = Reflect.getOwnPropertyDescriptor(
+        globalThis,
+        propertyName
+      );
+      if (descriptor) {
+        if (descriptor.configurable) {
+          if (hasAccessor(descriptor)) {
+            Object.defineProperty(globalThis, propertyName, {
+              configurable: false
+            });
+          } else {
+            Object.defineProperty(globalThis, propertyName, {
+              configurable: false,
+              writable: false
+            });
+          }
+        }
+        if (shouldHardenManually.has(propertyName)) {
+          harden(globalThis[propertyName]);
+        }
+      }
+    });
+  } catch (error) {
+    logError("Protecting intrinsics failed:", error);
+    throw error;
+  }
+}
+function hasAccessor(descriptor) {
+  return "set" in descriptor || "get" in descriptor;
+}
+
+export {
+  executeLockdownMore
+};
+//# sourceMappingURL=chunk-MXNMMTJW.mjs.map

package/dist/chunk-MXNMMTJW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/lockdown/lockdown-more.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment\n/// <reference path=\"../../../../../node_modules/ses/types.d.ts\" />\n\nimport { logError } from '@metamask/snaps-utils';\n\n/**\n * The SES `lockdown` function only hardens the properties enumerated by the\n * universalPropertyNames constant specified in 'ses/src/whitelist'. This\n * function makes all function and object properties on the start compartment\n * global non-configurable and non-writable, unless they are already\n * non-configurable.\n *\n * It is critical that this function runs at the right time during\n * initialization, which should always be immediately after `lockdown` has been\n * called. At the time of writing, the modifications this function makes to the\n * runtime environment appear to be non-breaking, but that could change with\n * the addition of dependencies, or the order of our scripts in our HTML files.\n * Exercise caution.\n *\n * See inline comments for implementation details.\n *\n * We write this function in IIFE format to avoid polluting global scope.\n *\n * @throws If the lockdown failed.\n */\nexport function executeLockdownMore() {\n  // Make all \"object\" and \"function\" own properties of globalThis\n  // non-configurable and non-writable, when possible.\n  // We call a property that is non-configurable and non-writable,\n  // \"non-modifiable\".\n  try {\n    const namedIntrinsics = Reflect.ownKeys(new Compartment().globalThis);\n\n    // These named intrinsics are not automatically hardened by `lockdown`\n    const shouldHardenManually = new Set<symbol | string>(['eval', 'Function']);\n\n    const globalProperties = new Set([\n      // universalPropertyNames is a constant added by lockdown to global scope\n      // at the time of writing, it is initialized in 'ses/src/whitelist'.\n      // These properties tend to be non-enumerable.\n      ...namedIntrinsics,\n\n      // TODO: Also include the named platform globals\n      // This grabs every enumerable property on globalThis.\n      // ...Object.keys(globalThis),\n    ]);\n\n    globalProperties.forEach((propertyName) => {\n      const descriptor = Reflect.getOwnPropertyDescriptor(\n        globalThis,\n        propertyName,\n      );\n\n      if (descriptor) {\n        if (descriptor.configurable) {\n          // If the property on globalThis is configurable, make it\n          // non-configurable. If it has no accessor properties, also make it\n          // non-writable.\n          if (hasAccessor(descriptor)) {\n            Object.defineProperty(globalThis, propertyName, {\n              configurable: false,\n            });\n          } else {\n            Object.defineProperty(globalThis, propertyName, {\n              configurable: false,\n              writable: false,\n            });\n          }\n        }\n\n        if (shouldHardenManually.has(propertyName)) {\n          harden((globalThis as any)[propertyName]);\n        }\n      }\n    });\n  } catch (error) {\n    logError('Protecting intrinsics failed:', error);\n    throw error;\n  }\n}\n\n/**\n * Checks whether the given propertyName descriptor has any accessors, i.e. the\n * properties `get` or `set`.\n *\n * We want to make globals non-writable, and we can't set the `writable`\n * property and accessor properties at the same time.\n *\n * @param descriptor - The propertyName descriptor to check.\n * @returns Whether the propertyName descriptor has any accessors.\n */\nfunction hasAccessor(descriptor: any): boolean {\n  return 'set' in descriptor || 'get' in descriptor;\n}\n"],"mappings":";AAGA,SAAS,gBAAgB;AAsBlB,SAAS,sBAAsB;AAKpC,MAAI;AACF,UAAM,kBAAkB,QAAQ,QAAQ,IAAI,YAAY,EAAE,UAAU;AAGpE,UAAM,uBAAuB,oBAAI,IAAqB,CAAC,QAAQ,UAAU,CAAC;AAE1E,UAAM,mBAAmB,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA,MAI/B,GAAG;AAAA;AAAA;AAAA;AAAA,IAKL,CAAC;AAED,qBAAiB,QAAQ,CAAC,iBAAiB;AACzC,YAAM,aAAa,QAAQ;AAAA,QACzB;AAAA,QACA;AAAA,MACF;AAEA,UAAI,YAAY;AACd,YAAI,WAAW,cAAc;AAI3B,cAAI,YAAY,UAAU,GAAG;AAC3B,mBAAO,eAAe,YAAY,cAAc;AAAA,cAC9C,cAAc;AAAA,YAChB,CAAC;AAAA,UACH,OAAO;AACL,mBAAO,eAAe,YAAY,cAAc;AAAA,cAC9C,cAAc;AAAA,cACd,UAAU;AAAA,YACZ,CAAC;AAAA,UACH;AAAA,QACF;AAEA,YAAI,qBAAqB,IAAI,YAAY,GAAG;AAC1C,iBAAQ,WAAmB,YAAY,CAAC;AAAA,QAC1C;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,SAAS,OAAO;AACd,aAAS,iCAAiC,KAAK;AAC/C,UAAM;AAAA,EACR;AACF;AAYA,SAAS,YAAY,YAA0B;AAC7C,SAAO,SAAS,cAAc,SAAS;AACzC;","names":[]}

package/dist/chunk-OBT45IWW.js

@@ -0,0 +1,92 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkDLLLH5HNjs = require('./chunk-DLLLH5HN.js');
+
+// src/common/endowments/console.ts
+var _utils = require('@metamask/utils');
+var consoleAttenuatedMethods = /* @__PURE__ */ new Set([
+  "log",
+  "assert",
+  "error",
+  "debug",
+  "info",
+  "warn"
+]);
+var consoleMethods = /* @__PURE__ */ new Set([
+  "debug",
+  "error",
+  "info",
+  "log",
+  "warn",
+  "dir",
+  "dirxml",
+  "table",
+  "trace",
+  "group",
+  "groupCollapsed",
+  "groupEnd",
+  "clear",
+  "count",
+  "countReset",
+  "assert",
+  "profile",
+  "profileEnd",
+  "time",
+  "timeLog",
+  "timeEnd",
+  "timeStamp",
+  "context"
+]);
+var consoleFunctions = ["log", "error", "debug", "info", "warn"];
+function getMessage(snapId, message, ...args) {
+  const prefix = `[Snap: ${snapId}]`;
+  if (typeof message === "string") {
+    return [`${prefix} ${message}`, ...args];
+  }
+  return [prefix, message, ...args];
+}
+function createConsole({ snapId } = {}) {
+  _utils.assert.call(void 0, snapId !== void 0);
+  const keys = Object.getOwnPropertyNames(
+    _chunkDLLLH5HNjs.rootRealmGlobal.console
+  );
+  const attenuatedConsole = keys.reduce((target, key) => {
+    if (consoleMethods.has(key) && !consoleAttenuatedMethods.has(key)) {
+      return { ...target, [key]: _chunkDLLLH5HNjs.rootRealmGlobal.console[key] };
+    }
+    return target;
+  }, {});
+  return harden({
+    console: {
+      ...attenuatedConsole,
+      assert: (value, message, ...optionalParams) => {
+        _chunkDLLLH5HNjs.rootRealmGlobal.console.assert(
+          value,
+          ...getMessage(snapId, message, ...optionalParams)
+        );
+      },
+      ...consoleFunctions.reduce((target, key) => {
+        return {
+          ...target,
+          [key]: (message, ...optionalParams) => {
+            _chunkDLLLH5HNjs.rootRealmGlobal.console[key](
+              ...getMessage(snapId, message, ...optionalParams)
+            );
+          }
+        };
+      }, {})
+    }
+  });
+}
+var endowmentModule = {
+  names: ["console"],
+  factory: createConsole
+};
+var console_default = endowmentModule;
+
+
+
+
+
+exports.consoleAttenuatedMethods = consoleAttenuatedMethods; exports.consoleMethods = consoleMethods; exports.console_default = console_default;
+//# sourceMappingURL=chunk-OBT45IWW.js.map

package/dist/chunk-OBT45IWW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/console.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,cAAc;AAKhB,IAAM,2BAA2B,oBAAI,IAAI;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAMM,IAAM,iBAAiB,oBAAI,IAAI;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,IAAM,mBAAmB,CAAC,OAAO,SAAS,SAAS,QAAQ,MAAM;AAejE,SAAS,WAAW,QAAgB,YAAqB,MAAiB;AACxE,QAAM,SAAS,UAAU,MAAM;AAI/B,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,CAAC,GAAG,MAAM,IAAI,OAAO,IAAI,GAAG,IAAI;AAAA,EACzC;AAIA,SAAO,CAAC,QAAQ,SAAS,GAAG,IAAI;AAClC;AAUA,SAAS,cAAc,EAAE,OAAO,IAA6B,CAAC,GAAG;AAC/D,SAAO,WAAW,MAAS;AAC3B,QAAM,OAAO,OAAO;AAAA,IAClB,gBAAgB;AAAA,EAClB;AAEA,QAAM,oBAAoB,KAAK,OAAO,CAAC,QAAQ,QAAQ;AACrD,QAAI,eAAe,IAAI,GAAG,KAAK,CAAC,yBAAyB,IAAI,GAAG,GAAG;AACjE,aAAO,EAAE,GAAG,QAAQ,CAAC,GAAG,GAAG,gBAAgB,QAAQ,GAAG,EAAE;AAAA,IAC1D;AAEA,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO,OAAO;AAAA,IACZ,SAAS;AAAA,MACP,GAAG;AAAA,MACH,QAAQ,CACN,OACA,YACG,mBACA;AACH,wBAAgB,QAAQ;AAAA,UACtB;AAAA,UACA,GAAG,WAAW,QAAQ,SAAS,GAAG,cAAc;AAAA,QAClD;AAAA,MACF;AAAA,MACA,GAAG,iBAAiB,OAAyB,CAAC,QAAQ,QAAQ;AAC5D,eAAO;AAAA,UACL,GAAG;AAAA,UACH,CAAC,GAAG,GAAG,CAAC,YAAsB,mBAA0B;AACtD,4BAAgB,QAAQ,GAAG;AAAA,cACzB,GAAG,WAAW,QAAQ,SAAS,GAAG,cAAc;AAAA,YAClD;AAAA,UACF;AAAA,QACF;AAAA,MACF,GAAG,CAAC,CAAqB;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,SAAS;AAAA,EACjB,SAAS;AACX;AAEA,IAAO,kBAAQ","sourcesContent":["import { assert } from '@metamask/utils';\n\nimport { rootRealmGlobal } from '../globalObject';\nimport type { EndowmentFactoryOptions } from './commonEndowmentFactory';\n\nexport const consoleAttenuatedMethods = new Set([\n  'log',\n  'assert',\n  'error',\n  'debug',\n  'info',\n  'warn',\n]);\n\n/**\n * A set of all the `console` values that will be passed to the snap. This has\n * all the values that are available in both the browser and Node.js.\n */\nexport const consoleMethods = new Set([\n  'debug',\n  'error',\n  'info',\n  'log',\n  'warn',\n  'dir',\n  'dirxml',\n  'table',\n  'trace',\n  'group',\n  'groupCollapsed',\n  'groupEnd',\n  'clear',\n  'count',\n  'countReset',\n  'assert',\n  'profile',\n  'profileEnd',\n  'time',\n  'timeLog',\n  'timeEnd',\n  'timeStamp',\n  'context',\n]);\n\nconst consoleFunctions = ['log', 'error', 'debug', 'info', 'warn'] as const;\n\ntype ConsoleFunctions = {\n  [Key in (typeof consoleFunctions)[number]]: (typeof rootRealmGlobal.console)[Key];\n};\n\n/**\n * Gets the appropriate (prepended) message to pass to one of the attenuated\n * method calls.\n *\n * @param snapId - Id of the snap that we're getting a message for.\n * @param message - The id of the snap that will interact with the endowment.\n * @param args - The array of additional arguments.\n * @returns An array of arguments to be passed into an attenuated console method call.\n */\nfunction getMessage(snapId: string, message: unknown, ...args: unknown[]) {\n  const prefix = `[Snap: ${snapId}]`;\n\n  // If the first argument is a string, prepend the prefix to the message, and keep the\n  // rest of the arguments as-is.\n  if (typeof message === 'string') {\n    return [`${prefix} ${message}`, ...args];\n  }\n\n  // Otherwise, the `message` is an object, array, etc., so add the prefix as a separate\n  // message to the arguments.\n  return [prefix, message, ...args];\n}\n\n/**\n * Create a a {@link console} object, with the same properties as the global\n * {@link console} object, but with some methods replaced.\n *\n * @param options - Factory options used in construction of the endowment.\n * @param options.snapId - The id of the snap that will interact with the endowment.\n * @returns The {@link console} object with the replaced methods.\n */\nfunction createConsole({ snapId }: EndowmentFactoryOptions = {}) {\n  assert(snapId !== undefined);\n  const keys = Object.getOwnPropertyNames(\n    rootRealmGlobal.console,\n  ) as (keyof typeof console)[];\n\n  const attenuatedConsole = keys.reduce((target, key) => {\n    if (consoleMethods.has(key) && !consoleAttenuatedMethods.has(key)) {\n      return { ...target, [key]: rootRealmGlobal.console[key] };\n    }\n\n    return target;\n  }, {});\n\n  return harden({\n    console: {\n      ...attenuatedConsole,\n      assert: (\n        value: any,\n        message?: string | undefined,\n        ...optionalParams: any[]\n      ) => {\n        rootRealmGlobal.console.assert(\n          value,\n          ...getMessage(snapId, message, ...optionalParams),\n        );\n      },\n      ...consoleFunctions.reduce<ConsoleFunctions>((target, key) => {\n        return {\n          ...target,\n          [key]: (message?: unknown, ...optionalParams: any[]) => {\n            rootRealmGlobal.console[key](\n              ...getMessage(snapId, message, ...optionalParams),\n            );\n          },\n        };\n      }, {} as ConsoleFunctions),\n    },\n  });\n}\n\nconst endowmentModule = {\n  names: ['console'] as const,\n  factory: createConsole,\n};\n\nexport default endowmentModule;\n"]}

package/dist/chunk-OCNPLHS2.js

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/common/lockdown/lockdown-more.ts
+var _snapsutils = require('@metamask/snaps-utils');
+function executeLockdownMore() {
+  try {
+    const namedIntrinsics = Reflect.ownKeys(new Compartment().globalThis);
+    const shouldHardenManually = /* @__PURE__ */ new Set(["eval", "Function"]);
+    const globalProperties = /* @__PURE__ */ new Set([
+      // universalPropertyNames is a constant added by lockdown to global scope
+      // at the time of writing, it is initialized in 'ses/src/whitelist'.
+      // These properties tend to be non-enumerable.
+      ...namedIntrinsics
+      // TODO: Also include the named platform globals
+      // This grabs every enumerable property on globalThis.
+      // ...Object.keys(globalThis),
+    ]);
+    globalProperties.forEach((propertyName) => {
+      const descriptor = Reflect.getOwnPropertyDescriptor(
+        globalThis,
+        propertyName
+      );
+      if (descriptor) {
+        if (descriptor.configurable) {
+          if (hasAccessor(descriptor)) {
+            Object.defineProperty(globalThis, propertyName, {
+              configurable: false
+            });
+          } else {
+            Object.defineProperty(globalThis, propertyName, {
+              configurable: false,
+              writable: false
+            });
+          }
+        }
+        if (shouldHardenManually.has(propertyName)) {
+          harden(globalThis[propertyName]);
+        }
+      }
+    });
+  } catch (error) {
+    _snapsutils.logError.call(void 0, "Protecting intrinsics failed:", error);
+    throw error;
+  }
+}
+function hasAccessor(descriptor) {
+  return "set" in descriptor || "get" in descriptor;
+}
+
+
+
+exports.executeLockdownMore = executeLockdownMore;
+//# sourceMappingURL=chunk-OCNPLHS2.js.map

package/dist/chunk-OCNPLHS2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/lockdown/lockdown-more.ts"],"names":[],"mappings":";AAGA,SAAS,gBAAgB;AAsBlB,SAAS,sBAAsB;AAKpC,MAAI;AACF,UAAM,kBAAkB,QAAQ,QAAQ,IAAI,YAAY,EAAE,UAAU;AAGpE,UAAM,uBAAuB,oBAAI,IAAqB,CAAC,QAAQ,UAAU,CAAC;AAE1E,UAAM,mBAAmB,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA,MAI/B,GAAG;AAAA;AAAA;AAAA;AAAA,IAKL,CAAC;AAED,qBAAiB,QAAQ,CAAC,iBAAiB;AACzC,YAAM,aAAa,QAAQ;AAAA,QACzB;AAAA,QACA;AAAA,MACF;AAEA,UAAI,YAAY;AACd,YAAI,WAAW,cAAc;AAI3B,cAAI,YAAY,UAAU,GAAG;AAC3B,mBAAO,eAAe,YAAY,cAAc;AAAA,cAC9C,cAAc;AAAA,YAChB,CAAC;AAAA,UACH,OAAO;AACL,mBAAO,eAAe,YAAY,cAAc;AAAA,cAC9C,cAAc;AAAA,cACd,UAAU;AAAA,YACZ,CAAC;AAAA,UACH;AAAA,QACF;AAEA,YAAI,qBAAqB,IAAI,YAAY,GAAG;AAC1C,iBAAQ,WAAmB,YAAY,CAAC;AAAA,QAC1C;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,SAAS,OAAO;AACd,aAAS,iCAAiC,KAAK;AAC/C,UAAM;AAAA,EACR;AACF;AAYA,SAAS,YAAY,YAA0B;AAC7C,SAAO,SAAS,cAAc,SAAS;AACzC","sourcesContent":["// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment\n/// <reference path=\"../../../../../node_modules/ses/types.d.ts\" />\n\nimport { logError } from '@metamask/snaps-utils';\n\n/**\n * The SES `lockdown` function only hardens the properties enumerated by the\n * universalPropertyNames constant specified in 'ses/src/whitelist'. This\n * function makes all function and object properties on the start compartment\n * global non-configurable and non-writable, unless they are already\n * non-configurable.\n *\n * It is critical that this function runs at the right time during\n * initialization, which should always be immediately after `lockdown` has been\n * called. At the time of writing, the modifications this function makes to the\n * runtime environment appear to be non-breaking, but that could change with\n * the addition of dependencies, or the order of our scripts in our HTML files.\n * Exercise caution.\n *\n * See inline comments for implementation details.\n *\n * We write this function in IIFE format to avoid polluting global scope.\n *\n * @throws If the lockdown failed.\n */\nexport function executeLockdownMore() {\n  // Make all \"object\" and \"function\" own properties of globalThis\n  // non-configurable and non-writable, when possible.\n  // We call a property that is non-configurable and non-writable,\n  // \"non-modifiable\".\n  try {\n    const namedIntrinsics = Reflect.ownKeys(new Compartment().globalThis);\n\n    // These named intrinsics are not automatically hardened by `lockdown`\n    const shouldHardenManually = new Set<symbol | string>(['eval', 'Function']);\n\n    const globalProperties = new Set([\n      // universalPropertyNames is a constant added by lockdown to global scope\n      // at the time of writing, it is initialized in 'ses/src/whitelist'.\n      // These properties tend to be non-enumerable.\n      ...namedIntrinsics,\n\n      // TODO: Also include the named platform globals\n      // This grabs every enumerable property on globalThis.\n      // ...Object.keys(globalThis),\n    ]);\n\n    globalProperties.forEach((propertyName) => {\n      const descriptor = Reflect.getOwnPropertyDescriptor(\n        globalThis,\n        propertyName,\n      );\n\n      if (descriptor) {\n        if (descriptor.configurable) {\n          // If the property on globalThis is configurable, make it\n          // non-configurable. If it has no accessor properties, also make it\n          // non-writable.\n          if (hasAccessor(descriptor)) {\n            Object.defineProperty(globalThis, propertyName, {\n              configurable: false,\n            });\n          } else {\n            Object.defineProperty(globalThis, propertyName, {\n              configurable: false,\n              writable: false,\n            });\n          }\n        }\n\n        if (shouldHardenManually.has(propertyName)) {\n          harden((globalThis as any)[propertyName]);\n        }\n      }\n    });\n  } catch (error) {\n    logError('Protecting intrinsics failed:', error);\n    throw error;\n  }\n}\n\n/**\n * Checks whether the given propertyName descriptor has any accessors, i.e. the\n * properties `get` or `set`.\n *\n * We want to make globals non-writable, and we can't set the `writable`\n * property and accessor properties at the same time.\n *\n * @param descriptor - The propertyName descriptor to check.\n * @returns Whether the propertyName descriptor has any accessors.\n */\nfunction hasAccessor(descriptor: any): boolean {\n  return 'set' in descriptor || 'get' in descriptor;\n}\n"]}

package/dist/chunk-OLASO3O4.js

@@ -0,0 +1,81 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkDFPM46ZFjs = require('./chunk-DFPM46ZF.js');
+
+// src/common/commands.ts
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+function getHandlerArguments(origin, handler, request) {
+  switch (handler) {
+    case _snapsutils.HandlerType.OnTransaction: {
+      _chunkDFPM46ZFjs.assertIsOnTransactionRequestArguments.call(void 0, request.params);
+      const { transaction, chainId, transactionOrigin } = request.params;
+      return {
+        transaction,
+        chainId,
+        transactionOrigin
+      };
+    }
+    case _snapsutils.HandlerType.OnSignature: {
+      _chunkDFPM46ZFjs.assertIsOnSignatureRequestArguments.call(void 0, request.params);
+      const { signature, signatureOrigin } = request.params;
+      return { signature, signatureOrigin };
+    }
+    case _snapsutils.HandlerType.OnNameLookup: {
+      _chunkDFPM46ZFjs.assertIsOnNameLookupRequestArguments.call(void 0, request.params);
+      const { chainId, domain, address } = request.params;
+      return domain ? {
+        chainId,
+        domain
+      } : {
+        chainId,
+        address
+      };
+    }
+    case _snapsutils.HandlerType.OnRpcRequest:
+    case _snapsutils.HandlerType.OnKeyringRequest:
+      return { origin, request };
+    case _snapsutils.HandlerType.OnCronjob:
+    case _snapsutils.HandlerType.OnInstall:
+    case _snapsutils.HandlerType.OnUpdate:
+      return { request };
+    case _snapsutils.HandlerType.OnHomePage:
+      return {};
+    case _snapsutils.HandlerType.OnUserInput: {
+      _chunkDFPM46ZFjs.assertIsOnUserInputRequestArguments.call(void 0, request.params);
+      const { id, event } = request.params;
+      return { id, event };
+    }
+    default:
+      return _utils.assertExhaustive.call(void 0, handler);
+  }
+}
+function getCommandMethodImplementations(startSnap, invokeSnap, onTerminate) {
+  return {
+    ping: async () => Promise.resolve("OK"),
+    terminate: async () => {
+      onTerminate();
+      return Promise.resolve("OK");
+    },
+    executeSnap: async (snapId, sourceCode, endowments) => {
+      await startSnap(snapId, sourceCode, endowments);
+      return "OK";
+    },
+    snapRpc: async (target, handler, origin, request) => {
+      return await invokeSnap(
+        target,
+        handler,
+        getHandlerArguments(origin, handler, request)
+      ) ?? null;
+    }
+  };
+}
+
+
+
+
+exports.getHandlerArguments = getHandlerArguments; exports.getCommandMethodImplementations = getCommandMethodImplementations;
+//# sourceMappingURL=chunk-OLASO3O4.js.map

package/dist/chunk-OLASO3O4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/commands.ts"],"names":[],"mappings":";;;;;;;;AAAA,SAAS,mBAAmB;AAC5B,SAAS,wBAAwB;AAiC1B,SAAS,oBACd,QACA,SACA,SACgB;AAGhB,UAAQ,SAAS;AAAA,IACf,KAAK,YAAY,eAAe;AAC9B,4CAAsC,QAAQ,MAAM;AAEpD,YAAM,EAAE,aAAa,SAAS,kBAAkB,IAAI,QAAQ;AAC5D,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,IACA,KAAK,YAAY,aAAa;AAC5B,0CAAoC,QAAQ,MAAM;AAElD,YAAM,EAAE,WAAW,gBAAgB,IAAI,QAAQ;AAC/C,aAAO,EAAE,WAAW,gBAAgB;AAAA,IACtC;AAAA,IACA,KAAK,YAAY,cAAc;AAC7B,2CAAqC,QAAQ,MAAM;AAInD,YAAM,EAAE,SAAS,QAAQ,QAAQ,IAC/B,QAAQ;AAEV,aAAO,SACH;AAAA,QACE;AAAA,QACA;AAAA,MACF,IACA;AAAA,QACE;AAAA,QACA;AAAA,MACF;AAAA,IACN;AAAA,IACA,KAAK,YAAY;AAAA,IACjB,KAAK,YAAY;AACf,aAAO,EAAE,QAAQ,QAAQ;AAAA,IAE3B,KAAK,YAAY;AAAA,IACjB,KAAK,YAAY;AAAA,IACjB,KAAK,YAAY;AACf,aAAO,EAAE,QAAQ;AAAA,IAEnB,KAAK,YAAY;AACf,aAAO,CAAC;AAAA,IACV,KAAK,YAAY,aAAa;AAC5B,0CAAoC,QAAQ,MAAM;AAElD,YAAM,EAAE,IAAI,MAAM,IAAI,QAAQ;AAC9B,aAAO,EAAE,IAAI,MAAM;AAAA,IACrB;AAAA,IAEA;AACE,aAAO,iBAAiB,OAAO;AAAA,EACnC;AACF;AAaO,SAAS,gCACd,WACA,YACA,aACuB;AACvB,SAAO;AAAA,IACL,MAAM,YAAY,QAAQ,QAAQ,IAAI;AAAA,IACtC,WAAW,YAAY;AACrB,kBAAY;AACZ,aAAO,QAAQ,QAAQ,IAAI;AAAA,IAC7B;AAAA,IAEA,aAAa,OAAO,QAAQ,YAAY,eAAe;AACrD,YAAM,UAAU,QAAQ,YAAY,UAAU;AAC9C,aAAO;AAAA,IACT;AAAA,IAEA,SAAS,OAAO,QAAQ,SAAS,QAAQ,YAAY;AACnD,aACG,MAAM;AAAA,QACL;AAAA,QACA;AAAA,QACA,oBAAoB,QAAQ,SAAS,OAAO;AAAA,MAC9C,KAAM;AAAA,IAEV;AAAA,EACF;AACF","sourcesContent":["import { HandlerType } from '@metamask/snaps-utils';\nimport { assertExhaustive } from '@metamask/utils';\n\nimport type { InvokeSnap, InvokeSnapArgs } from './BaseSnapExecutor';\nimport type {\n  ExecuteSnap,\n  JsonRpcRequestWithoutId,\n  Ping,\n  PossibleLookupRequestArgs,\n  SnapRpc,\n  Terminate,\n} from './validation';\nimport {\n  assertIsOnTransactionRequestArguments,\n  assertIsOnSignatureRequestArguments,\n  assertIsOnNameLookupRequestArguments,\n  assertIsOnUserInputRequestArguments,\n} from './validation';\n\nexport type CommandMethodsMapping = {\n  ping: Ping;\n  terminate: Terminate;\n  executeSnap: ExecuteSnap;\n  snapRpc: SnapRpc;\n};\n\n/**\n * Formats the arguments for the given handler.\n *\n * @param origin - The origin of the request.\n * @param handler - The handler to pass the request to.\n * @param request - The request object.\n * @returns The formatted arguments.\n */\nexport function getHandlerArguments(\n  origin: string,\n  handler: HandlerType,\n  request: JsonRpcRequestWithoutId,\n): InvokeSnapArgs {\n  // `request` is already validated by the time this function is called.\n\n  switch (handler) {\n    case HandlerType.OnTransaction: {\n      assertIsOnTransactionRequestArguments(request.params);\n\n      const { transaction, chainId, transactionOrigin } = request.params;\n      return {\n        transaction,\n        chainId,\n        transactionOrigin,\n      };\n    }\n    case HandlerType.OnSignature: {\n      assertIsOnSignatureRequestArguments(request.params);\n\n      const { signature, signatureOrigin } = request.params;\n      return { signature, signatureOrigin };\n    }\n    case HandlerType.OnNameLookup: {\n      assertIsOnNameLookupRequestArguments(request.params);\n\n      // TS complains that domain/address are not part of the type\n      // casting here as we've already validated the request args in the above step.\n      const { chainId, domain, address } =\n        request.params as unknown as PossibleLookupRequestArgs;\n\n      return domain\n        ? {\n            chainId,\n            domain,\n          }\n        : {\n            chainId,\n            address,\n          };\n    }\n    case HandlerType.OnRpcRequest:\n    case HandlerType.OnKeyringRequest:\n      return { origin, request };\n\n    case HandlerType.OnCronjob:\n    case HandlerType.OnInstall:\n    case HandlerType.OnUpdate:\n      return { request };\n\n    case HandlerType.OnHomePage:\n      return {};\n    case HandlerType.OnUserInput: {\n      assertIsOnUserInputRequestArguments(request.params);\n\n      const { id, event } = request.params;\n      return { id, event };\n    }\n\n    default:\n      return assertExhaustive(handler);\n  }\n}\n\n/**\n * Gets an object mapping internal, \"command\" JSON-RPC method names to their\n * implementations.\n *\n * @param startSnap - A function that starts a snap.\n * @param invokeSnap - A function that invokes the RPC method handler of a\n * snap.\n * @param onTerminate - A function that will be called when this executor is\n * terminated in order to handle cleanup tasks.\n * @returns An object containing the \"command\" method implementations.\n */\nexport function getCommandMethodImplementations(\n  startSnap: (...args: Parameters<ExecuteSnap>) => Promise<void>,\n  invokeSnap: InvokeSnap,\n  onTerminate: () => void,\n): CommandMethodsMapping {\n  return {\n    ping: async () => Promise.resolve('OK'),\n    terminate: async () => {\n      onTerminate();\n      return Promise.resolve('OK');\n    },\n\n    executeSnap: async (snapId, sourceCode, endowments) => {\n      await startSnap(snapId, sourceCode, endowments);\n      return 'OK';\n    },\n\n    snapRpc: async (target, handler, origin, request) => {\n      return (\n        (await invokeSnap(\n          target,\n          handler,\n          getHandlerArguments(origin, handler, request),\n        )) ?? null\n      );\n    },\n  };\n}\n"]}

package/dist/chunk-PTCQ2I47.mjs

@@ -0,0 +1,147 @@
+import {
+  log
+} from "./chunk-5DEV3QQU.mjs";
+
+// src/common/utils.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import {
+  assert,
+  assertStruct,
+  getJsonSize,
+  getSafeJson,
+  isObject,
+  JsonStruct
+} from "@metamask/utils";
+var MAX_RESPONSE_JSON_SIZE = 64e6;
+async function withTeardown(originalPromise, teardownRef) {
+  const myTeardown = teardownRef.lastTeardown;
+  return new Promise((resolve, reject) => {
+    originalPromise.then((value) => {
+      if (teardownRef.lastTeardown === myTeardown) {
+        resolve(value);
+      } else {
+        log(
+          "Late promise received after Snap finished execution. Promise will be dropped."
+        );
+      }
+    }).catch((reason) => {
+      if (teardownRef.lastTeardown === myTeardown) {
+        reject(reason);
+      } else {
+        log(
+          "Late promise received after Snap finished execution. Promise will be dropped."
+        );
+      }
+    });
+  });
+}
+function proxyStreamProvider(provider, request) {
+  const proxy = new Proxy(
+    {},
+    {
+      has(_target, prop) {
+        return typeof prop === "string" && ["request", "on", "removeListener"].includes(prop);
+      },
+      get(_target, prop) {
+        if (prop === "request") {
+          return request;
+        } else if (["on", "removeListener"].includes(prop)) {
+          return provider[prop];
+        }
+        return void 0;
+      }
+    }
+  );
+  return proxy;
+}
+var BLOCKED_RPC_METHODS = Object.freeze([
+  "wallet_requestSnaps",
+  "wallet_requestPermissions",
+  "wallet_revokePermissions",
+  // We disallow all of these confirmations for now, since the screens are not ready for Snaps.
+  "eth_sendRawTransaction",
+  "eth_sendTransaction",
+  "eth_sign",
+  "eth_signTypedData",
+  "eth_signTypedData_v1",
+  "eth_signTypedData_v3",
+  "eth_signTypedData_v4",
+  "eth_decrypt",
+  "eth_getEncryptionPublicKey",
+  "wallet_addEthereumChain",
+  "wallet_switchEthereumChain",
+  "wallet_watchAsset",
+  "wallet_registerOnboarding",
+  "wallet_scanQRCode"
+]);
+function assertSnapOutboundRequest(args) {
+  assert(
+    String.prototype.startsWith.call(args.method, "wallet_") || String.prototype.startsWith.call(args.method, "snap_"),
+    "The global Snap API only allows RPC methods starting with `wallet_*` and `snap_*`.",
+    rpcErrors.methodNotSupported
+  );
+  assert(
+    !BLOCKED_RPC_METHODS.includes(args.method),
+    rpcErrors.methodNotFound({
+      data: {
+        method: args.method
+      }
+    })
+  );
+  assertStruct(
+    args,
+    JsonStruct,
+    "Provided value is not JSON-RPC compatible",
+    rpcErrors.invalidParams
+  );
+}
+function assertEthereumOutboundRequest(args) {
+  assert(
+    !String.prototype.startsWith.call(args.method, "snap_"),
+    rpcErrors.methodNotFound({
+      data: {
+        method: args.method
+      }
+    })
+  );
+  assert(
+    !BLOCKED_RPC_METHODS.includes(args.method),
+    rpcErrors.methodNotFound({
+      data: {
+        method: args.method
+      }
+    })
+  );
+  assertStruct(
+    args,
+    JsonStruct,
+    "Provided value is not JSON-RPC compatible",
+    rpcErrors.invalidParams
+  );
+}
+function sanitizeRequestArguments(value) {
+  const json = JSON.parse(JSON.stringify(value));
+  return getSafeJson(json);
+}
+function isValidResponse(response) {
+  if (!isObject(response)) {
+    return false;
+  }
+  try {
+    const size = getJsonSize(response);
+    return size < MAX_RESPONSE_JSON_SIZE;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  withTeardown,
+  proxyStreamProvider,
+  BLOCKED_RPC_METHODS,
+  assertSnapOutboundRequest,
+  assertEthereumOutboundRequest,
+  sanitizeRequestArguments,
+  isValidResponse
+};
+//# sourceMappingURL=chunk-PTCQ2I47.mjs.map

package/dist/chunk-PTCQ2I47.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/utils.ts"],"sourcesContent":["import type { StreamProvider } from '@metamask/providers';\nimport type { RequestArguments } from '@metamask/providers/dist/BaseProvider';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport {\n  assert,\n  assertStruct,\n  getJsonSize,\n  getSafeJson,\n  isObject,\n  JsonStruct,\n} from '@metamask/utils';\n\nimport { log } from '../logging';\n\n// 64 MB - we chose this number because it is the size limit for postMessage\n// between the extension and the dapp enforced by Chrome.\nconst MAX_RESPONSE_JSON_SIZE = 64_000_000;\n\n/**\n * Make proxy for Promise and handle the teardown process properly.\n * If the teardown is called in the meanwhile, Promise result will not be\n * exposed to the snap anymore and warning will be logged to the console.\n *\n * @param originalPromise - Original promise.\n * @param teardownRef - Reference containing teardown count.\n * @param teardownRef.lastTeardown - Number of the last teardown.\n * @returns New proxy promise.\n */\nexport async function withTeardown<Type>(\n  originalPromise: Promise<Type>,\n  teardownRef: { lastTeardown: number },\n): Promise<Type> {\n  const myTeardown = teardownRef.lastTeardown;\n  return new Promise<Type>((resolve, reject) => {\n    originalPromise\n      .then((value) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          resolve(value);\n        } else {\n          log(\n            'Late promise received after Snap finished execution. Promise will be dropped.',\n          );\n        }\n      })\n      .catch((reason) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          reject(reason);\n        } else {\n          log(\n            'Late promise received after Snap finished execution. Promise will be dropped.',\n          );\n        }\n      });\n  });\n}\n\n/**\n * Returns a Proxy that narrows down (attenuates) the fields available on\n * the StreamProvider and replaces the request implementation.\n *\n * @param provider - Instance of a StreamProvider to be limited.\n * @param request - Custom attenuated request object.\n * @returns Proxy to the StreamProvider instance.\n */\nexport function proxyStreamProvider(\n  provider: StreamProvider,\n  request: unknown,\n): StreamProvider {\n  // Proxy target is intentionally set to be an empty object, to ensure\n  // that access to the prototype chain is not possible.\n  const proxy = new Proxy(\n    {},\n    {\n      has(_target: object, prop: string | symbol) {\n        return (\n          typeof prop === 'string' &&\n          ['request', 'on', 'removeListener'].includes(prop)\n        );\n      },\n      get(_target, prop: keyof StreamProvider) {\n        if (prop === 'request') {\n          return request;\n        } else if (['on', 'removeListener'].includes(prop)) {\n          return provider[prop];\n        }\n\n        return undefined;\n      },\n    },\n  );\n\n  return proxy as StreamProvider;\n}\n\n// We're blocking these RPC methods for v1, will revisit later.\nexport const BLOCKED_RPC_METHODS = Object.freeze([\n  'wallet_requestSnaps',\n  'wallet_requestPermissions',\n  'wallet_revokePermissions',\n  // We disallow all of these confirmations for now, since the screens are not ready for Snaps.\n  'eth_sendRawTransaction',\n  'eth_sendTransaction',\n  'eth_sign',\n  'eth_signTypedData',\n  'eth_signTypedData_v1',\n  'eth_signTypedData_v3',\n  'eth_signTypedData_v4',\n  'eth_decrypt',\n  'eth_getEncryptionPublicKey',\n  'wallet_addEthereumChain',\n  'wallet_switchEthereumChain',\n  'wallet_watchAsset',\n  'wallet_registerOnboarding',\n  'wallet_scanQRCode',\n]);\n\n/**\n * Asserts the validity of request arguments for a snap outbound request using the `snap.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertSnapOutboundRequest(args: RequestArguments) {\n  // Disallow any non `wallet_` or `snap_` methods for separation of concerns.\n  assert(\n    String.prototype.startsWith.call(args.method, 'wallet_') ||\n      String.prototype.startsWith.call(args.method, 'snap_'),\n    'The global Snap API only allows RPC methods starting with `wallet_*` and `snap_*`.',\n    rpcErrors.methodNotSupported,\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(\n    args,\n    JsonStruct,\n    'Provided value is not JSON-RPC compatible',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Asserts the validity of request arguments for an ethereum outbound request using the `ethereum.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertEthereumOutboundRequest(args: RequestArguments) {\n  // Disallow snaps methods for separation of concerns.\n  assert(\n    !String.prototype.startsWith.call(args.method, 'snap_'),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(\n    args,\n    JsonStruct,\n    'Provided value is not JSON-RPC compatible',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Gets a sanitized value to be used for passing to the underlying MetaMask provider.\n *\n * @param value - An unsanitized value from a snap.\n * @returns A sanitized value ready to be passed to a MetaMask provider.\n */\nexport function sanitizeRequestArguments(value: unknown): RequestArguments {\n  // Before passing to getSafeJson we run the value through JSON serialization.\n  // This lets request arguments contain undefined which is normally disallowed.\n  const json = JSON.parse(JSON.stringify(value));\n  return getSafeJson(json) as RequestArguments;\n}\n\n/**\n * Check if the input is a valid response.\n *\n * @param response - The response.\n * @returns True if the response is valid, otherwise false.\n */\nexport function isValidResponse(response: Record<string, unknown>) {\n  if (!isObject(response)) {\n    return false;\n  }\n\n  try {\n    // If the JSON is invalid this will throw and we should return false.\n    const size = getJsonSize(response);\n    return size < MAX_RESPONSE_JSON_SIZE;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;;;AAEA,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,IAAM,yBAAyB;AAY/B,eAAsB,aACpB,iBACA,aACe;AACf,QAAM,aAAa,YAAY;AAC/B,SAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,oBACG,KAAK,CAAC,UAAU;AACf,UAAI,YAAY,iBAAiB,YAAY;AAC3C,gBAAQ,KAAK;AAAA,MACf,OAAO;AACL;AAAA,UACE;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC,EACA,MAAM,CAAC,WAAW;AACjB,UAAI,YAAY,iBAAiB,YAAY;AAC3C,eAAO,MAAM;AAAA,MACf,OAAO;AACL;AAAA,UACE;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACL,CAAC;AACH;AAUO,SAAS,oBACd,UACA,SACgB;AAGhB,QAAM,QAAQ,IAAI;AAAA,IAChB,CAAC;AAAA,IACD;AAAA,MACE,IAAI,SAAiB,MAAuB;AAC1C,eACE,OAAO,SAAS,YAChB,CAAC,WAAW,MAAM,gBAAgB,EAAE,SAAS,IAAI;AAAA,MAErD;AAAA,MACA,IAAI,SAAS,MAA4B;AACvC,YAAI,SAAS,WAAW;AACtB,iBAAO;AAAA,QACT,WAAW,CAAC,MAAM,gBAAgB,EAAE,SAAS,IAAI,GAAG;AAClD,iBAAO,SAAS,IAAI;AAAA,QACtB;AAEA,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAGO,IAAM,sBAAsB,OAAO,OAAO;AAAA,EAC/C;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAOM,SAAS,0BAA0B,MAAwB;AAEhE;AAAA,IACE,OAAO,UAAU,WAAW,KAAK,KAAK,QAAQ,SAAS,KACrD,OAAO,UAAU,WAAW,KAAK,KAAK,QAAQ,OAAO;AAAA,IACvD;AAAA,IACA,UAAU;AAAA,EACZ;AACA;AAAA,IACE,CAAC,oBAAoB,SAAS,KAAK,MAAM;AAAA,IACzC,UAAU,eAAe;AAAA,MACvB,MAAM;AAAA,QACJ,QAAQ,KAAK;AAAA,MACf;AAAA,IACF,CAAC;AAAA,EACH;AACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAOO,SAAS,8BAA8B,MAAwB;AAEpE;AAAA,IACE,CAAC,OAAO,UAAU,WAAW,KAAK,KAAK,QAAQ,OAAO;AAAA,IACtD,UAAU,eAAe;AAAA,MACvB,MAAM;AAAA,QACJ,QAAQ,KAAK;AAAA,MACf;AAAA,IACF,CAAC;AAAA,EACH;AACA;AAAA,IACE,CAAC,oBAAoB,SAAS,KAAK,MAAM;AAAA,IACzC,UAAU,eAAe;AAAA,MACvB,MAAM;AAAA,QACJ,QAAQ,KAAK;AAAA,MACf;AAAA,IACF,CAAC;AAAA,EACH;AACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAQO,SAAS,yBAAyB,OAAkC;AAGzE,QAAM,OAAO,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;AAC7C,SAAO,YAAY,IAAI;AACzB;AAQO,SAAS,gBAAgB,UAAmC;AACjE,MAAI,CAAC,SAAS,QAAQ,GAAG;AACvB,WAAO;AAAA,EACT;AAEA,MAAI;AAEF,UAAM,OAAO,YAAY,QAAQ;AACjC,WAAO,OAAO;AAAA,EAChB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-Q42NNJFY.mjs

@@ -0,0 +1,32 @@
+import {
+  rootRealmGlobal
+} from "./chunk-IX5S3V47.mjs";
+import {
+  __require
+} from "./chunk-YRZVIDCF.mjs";
+
+// src/common/endowments/crypto.ts
+var createCrypto = () => {
+  if ("crypto" in rootRealmGlobal && typeof rootRealmGlobal.crypto === "object" && "SubtleCrypto" in rootRealmGlobal && typeof rootRealmGlobal.SubtleCrypto === "function") {
+    return {
+      crypto: harden(rootRealmGlobal.crypto),
+      SubtleCrypto: harden(rootRealmGlobal.SubtleCrypto)
+    };
+  }
+  const crypto = __require("crypto").webcrypto;
+  return {
+    crypto: harden(crypto),
+    SubtleCrypto: harden(crypto.subtle.constructor)
+  };
+};
+var endowmentModule = {
+  names: ["crypto", "SubtleCrypto"],
+  factory: createCrypto
+};
+var crypto_default = endowmentModule;
+
+export {
+  createCrypto,
+  crypto_default
+};
+//# sourceMappingURL=chunk-Q42NNJFY.mjs.map