@metamask/snaps-execution-environments 4.0.0 → 5.0.0

package/dist/chunk-VZS2LXDP.mjs

@@ -0,0 +1,108 @@
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk-YRZVIDCF.mjs";
+
+// src/proxy/ProxySnapExecutor.ts
+import { WindowPostMessageStream } from "@metamask/post-message-stream";
+import packageJson from "@metamask/snaps-execution-environments/package.json";
+import { createWindow, logError } from "@metamask/snaps-utils";
+import { assert } from "@metamask/utils";
+var IFRAME_URL = `https://execution.metamask.io/iframe/${packageJson.version}/index.html`;
+var _stream, _frameUrl, _onData, onData_fn, _initializeJob, initializeJob_fn, _terminateJob, terminateJob_fn;
+var _ProxySnapExecutor = class _ProxySnapExecutor {
+  constructor(stream, frameUrl) {
+    /**
+     * Handle an incoming message from a `ProxyExecutionService`. This
+     * assumes that the message contains a `jobId` property, and a JSON-RPC
+     * request in the `data` property.
+     *
+     * @param data - The message data.
+     * @param data.data - The JSON-RPC request.
+     * @param data.jobId - The job ID.
+     */
+    __privateAdd(this, _onData);
+    /**
+     * Create a new iframe and set up a stream to communicate with it.
+     *
+     * @param jobId - The job ID.
+     */
+    __privateAdd(this, _initializeJob);
+    /**
+     * Terminate the job with the given ID. This will close the iframe and delete
+     * the job from the internal job map.
+     *
+     * @param jobId - The job ID.
+     */
+    __privateAdd(this, _terminateJob);
+    __privateAdd(this, _stream, void 0);
+    __privateAdd(this, _frameUrl, void 0);
+    this.jobs = {};
+    __privateSet(this, _stream, stream);
+    __privateGet(this, _stream).on("data", __privateMethod(this, _onData, onData_fn).bind(this));
+    __privateSet(this, _frameUrl, frameUrl);
+  }
+  /**
+   * Initialize the executor with the given stream. This is a wrapper around the
+   * constructor.
+   *
+   * @param stream - The stream to use for communication.
+   * @param frameUrl - An optional URL for the iframe to use.
+   * @returns The initialized executor.
+   */
+  static initialize(stream, frameUrl = IFRAME_URL) {
+    return new _ProxySnapExecutor(stream, frameUrl);
+  }
+};
+_stream = new WeakMap();
+_frameUrl = new WeakMap();
+_onData = new WeakSet();
+onData_fn = function(data) {
+  const { jobId, data: request } = data;
+  if (!this.jobs[jobId]) {
+    __privateMethod(this, _initializeJob, initializeJob_fn).call(this, jobId).then(() => {
+      __privateMethod(this, _onData, onData_fn).call(this, data);
+    }).catch((error) => {
+      logError("[Worker] Error initializing job:", error);
+    });
+    return;
+  }
+  if (request.method === "terminateJob") {
+    __privateMethod(this, _terminateJob, terminateJob_fn).call(this, jobId);
+    return;
+  }
+  this.jobs[jobId].stream.write(request);
+};
+_initializeJob = new WeakSet();
+initializeJob_fn = async function(jobId) {
+  const window = await createWindow(__privateGet(this, _frameUrl), jobId);
+  const jobStream = new WindowPostMessageStream({
+    name: "parent",
+    target: "child",
+    targetWindow: window,
+    // iframe's internal window
+    targetOrigin: "*"
+  });
+  jobStream.on("data", (data) => {
+    __privateGet(this, _stream).write({ data, jobId });
+  });
+  this.jobs[jobId] = { id: jobId, window, stream: jobStream };
+  return this.jobs[jobId];
+};
+_terminateJob = new WeakSet();
+terminateJob_fn = function(jobId) {
+  assert(this.jobs[jobId], `Job "${jobId}" not found.`);
+  const iframe = document.getElementById(jobId);
+  assert(iframe, `Iframe with ID "${jobId}" not found.`);
+  iframe.remove();
+  this.jobs[jobId].stream.destroy();
+  delete this.jobs[jobId];
+};
+var ProxySnapExecutor = _ProxySnapExecutor;
+
+export {
+  ProxySnapExecutor
+};
+//# sourceMappingURL=chunk-VZS2LXDP.mjs.map

package/dist/chunk-VZS2LXDP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/proxy/ProxySnapExecutor.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { WindowPostMessageStream } from '@metamask/post-message-stream';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport packageJson from '@metamask/snaps-execution-environments/package.json';\nimport { createWindow, logError } from '@metamask/snaps-utils';\nimport type { JsonRpcRequest } from '@metamask/utils';\nimport { assert } from '@metamask/utils';\n\ntype ExecutorJob = {\n  id: string;\n  window: Window;\n  stream: WindowPostMessageStream;\n};\n\nconst IFRAME_URL = `https://execution.metamask.io/iframe/${packageJson.version}/index.html`;\n\n/**\n * A \"proxy\" snap executor that uses a level of indirection to execute snaps.\n *\n * Useful for multiple execution environments.\n *\n * This is not a traditional snap executor, as it does not execute snaps itself.\n * Instead, it creates an iframe window for each snap execution, and sends the\n * snap execution request to the iframe window. The iframe window is responsible\n * for executing the snap.\n *\n * This executor is persisted between snap executions. The executor essentially\n * acts as a proxy between the client and the iframe execution environment.\n */\nexport class ProxySnapExecutor {\n  readonly #stream: BasePostMessageStream;\n\n  readonly #frameUrl: string;\n\n  readonly jobs: Record<string, ExecutorJob> = {};\n\n  /**\n   * Initialize the executor with the given stream. This is a wrapper around the\n   * constructor.\n   *\n   * @param stream - The stream to use for communication.\n   * @param frameUrl - An optional URL for the iframe to use.\n   * @returns The initialized executor.\n   */\n  static initialize(stream: BasePostMessageStream, frameUrl = IFRAME_URL) {\n    return new ProxySnapExecutor(stream, frameUrl);\n  }\n\n  constructor(stream: BasePostMessageStream, frameUrl: string) {\n    this.#stream = stream;\n    this.#stream.on('data', this.#onData.bind(this));\n    this.#frameUrl = frameUrl;\n  }\n\n  /**\n   * Handle an incoming message from a `ProxyExecutionService`. This\n   * assumes that the message contains a `jobId` property, and a JSON-RPC\n   * request in the `data` property.\n   *\n   * @param data - The message data.\n   * @param data.data - The JSON-RPC request.\n   * @param data.jobId - The job ID.\n   */\n  #onData(data: { data: JsonRpcRequest; jobId: string }) {\n    const { jobId, data: request } = data;\n\n    if (!this.jobs[jobId]) {\n      // This ensures that a job is initialized before it is used. To avoid\n      // code duplication, we call the `#onData` method again, which will\n      // run the rest of the logic after initialization.\n      this.#initializeJob(jobId)\n        .then(() => {\n          this.#onData(data);\n        })\n        .catch((error) => {\n          logError('[Worker] Error initializing job:', error);\n        });\n\n      return;\n    }\n\n    // This is a method specific to the `OffscreenSnapExecutor`, as the service\n    // itself does not have access to the iframes directly.\n    if (request.method === 'terminateJob') {\n      this.#terminateJob(jobId);\n      return;\n    }\n\n    this.jobs[jobId].stream.write(request);\n  }\n\n  /**\n   * Create a new iframe and set up a stream to communicate with it.\n   *\n   * @param jobId - The job ID.\n   */\n  async #initializeJob(jobId: string): Promise<ExecutorJob> {\n    const window = await createWindow(this.#frameUrl, jobId);\n    const jobStream = new WindowPostMessageStream({\n      name: 'parent',\n      target: 'child',\n      targetWindow: window, // iframe's internal window\n      targetOrigin: '*',\n    });\n\n    // Write messages from the iframe to the parent, wrapped with the job ID.\n    jobStream.on('data', (data) => {\n      this.#stream.write({ data, jobId });\n    });\n\n    this.jobs[jobId] = { id: jobId, window, stream: jobStream };\n    return this.jobs[jobId];\n  }\n\n  /**\n   * Terminate the job with the given ID. This will close the iframe and delete\n   * the job from the internal job map.\n   *\n   * @param jobId - The job ID.\n   */\n  #terminateJob(jobId: string) {\n    assert(this.jobs[jobId], `Job \"${jobId}\" not found.`);\n\n    const iframe = document.getElementById(jobId);\n    assert(iframe, `Iframe with ID \"${jobId}\" not found.`);\n\n    iframe.remove();\n    this.jobs[jobId].stream.destroy();\n    delete this.jobs[jobId];\n  }\n}\n"],"mappings":";;;;;;;;AACA,SAAS,+BAA+B;AAExC,OAAO,iBAAiB;AACxB,SAAS,cAAc,gBAAgB;AAEvC,SAAS,cAAc;AAQvB,IAAM,aAAa,wCAAwC,YAAY,OAAO;AAd9E;AA6BO,IAAM,qBAAN,MAAM,mBAAkB;AAAA,EAmB7B,YAAY,QAA+B,UAAkB;AAe7D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAM;AAwBN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA1FA,uBAAS,SAAT;AAEA,uBAAS,WAAT;AAEA,SAAS,OAAoC,CAAC;AAe5C,uBAAK,SAAU;AACf,uBAAK,SAAQ,GAAG,QAAQ,sBAAK,oBAAQ,KAAK,IAAI,CAAC;AAC/C,uBAAK,WAAY;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EARA,OAAO,WAAW,QAA+B,WAAW,YAAY;AACtE,WAAO,IAAI,mBAAkB,QAAQ,QAAQ;AAAA,EAC/C;AAoFF;AApGW;AAEA;AA+BT;AAAA,YAAO,SAAC,MAA+C;AACrD,QAAM,EAAE,OAAO,MAAM,QAAQ,IAAI;AAEjC,MAAI,CAAC,KAAK,KAAK,KAAK,GAAG;AAIrB,0BAAK,kCAAL,WAAoB,OACjB,KAAK,MAAM;AACV,4BAAK,oBAAL,WAAa;AAAA,IACf,CAAC,EACA,MAAM,CAAC,UAAU;AAChB,eAAS,oCAAoC,KAAK;AAAA,IACpD,CAAC;AAEH;AAAA,EACF;AAIA,MAAI,QAAQ,WAAW,gBAAgB;AACrC,0BAAK,gCAAL,WAAmB;AACnB;AAAA,EACF;AAEA,OAAK,KAAK,KAAK,EAAE,OAAO,MAAM,OAAO;AACvC;AAOM;AAAA,mBAAc,eAAC,OAAqC;AACxD,QAAM,SAAS,MAAM,aAAa,mBAAK,YAAW,KAAK;AACvD,QAAM,YAAY,IAAI,wBAAwB;AAAA,IAC5C,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,cAAc;AAAA;AAAA,IACd,cAAc;AAAA,EAChB,CAAC;AAGD,YAAU,GAAG,QAAQ,CAAC,SAAS;AAC7B,uBAAK,SAAQ,MAAM,EAAE,MAAM,MAAM,CAAC;AAAA,EACpC,CAAC;AAED,OAAK,KAAK,KAAK,IAAI,EAAE,IAAI,OAAO,QAAQ,QAAQ,UAAU;AAC1D,SAAO,KAAK,KAAK,KAAK;AACxB;AAQA;AAAA,kBAAa,SAAC,OAAe;AAC3B,SAAO,KAAK,KAAK,KAAK,GAAG,QAAQ,KAAK,cAAc;AAEpD,QAAM,SAAS,SAAS,eAAe,KAAK;AAC5C,SAAO,QAAQ,mBAAmB,KAAK,cAAc;AAErD,SAAO,OAAO;AACd,OAAK,KAAK,KAAK,EAAE,OAAO,QAAQ;AAChC,SAAO,KAAK,KAAK,KAAK;AACxB;AApGK,IAAM,oBAAN;","names":[]}

package/dist/chunk-WA7K3P4D.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkL4G6IIWGjs = require('./chunk-L4G6IIWG.js');
+
+
+var _chunkXKY46YTJjs = require('./chunk-XKY46YTJ.js');
+
+// src/webworker/executor/WebWorkerSnapExecutor.ts
+var _objectmultiplex = require('@metamask/object-multiplex'); var _objectmultiplex2 = _interopRequireDefault(_objectmultiplex);
+var _postmessagestream = require('@metamask/post-message-stream');
+var _snapsutils = require('@metamask/snaps-utils');
+var _readablestream = require('readable-stream');
+var WebWorkerSnapExecutor = class _WebWorkerSnapExecutor extends _chunkL4G6IIWGjs.BaseSnapExecutor {
+  /**
+   * Initialize the WebWorkerSnapExecutor. This creates a post message stream
+   * from and to the parent window, for two-way communication with the iframe.
+   *
+   * @param stream - The stream to use for communication.
+   * @returns An instance of `WebWorkerSnapExecutor`, with the initialized post
+   * message streams.
+   */
+  static initialize(stream = new (0, _postmessagestream.WebWorkerPostMessageStream)()) {
+    _chunkXKY46YTJjs.log.call(void 0, "Worker: Connecting to parent.");
+    const mux = new (0, _objectmultiplex2.default)();
+    _readablestream.pipeline.call(void 0, stream, mux, stream, (error) => {
+      if (error) {
+        _snapsutils.logError.call(void 0, `Parent stream failure, closing worker.`, error);
+      }
+      self.close();
+    });
+    const commandStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.COMMAND);
+    const rpcStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.JSON_RPC);
+    return new _WebWorkerSnapExecutor(commandStream, rpcStream);
+  }
+};
+
+
+
+exports.WebWorkerSnapExecutor = WebWorkerSnapExecutor;
+//# sourceMappingURL=chunk-WA7K3P4D.js.map

package/dist/chunk-WA7K3P4D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/webworker/executor/WebWorkerSnapExecutor.ts"],"names":[],"mappings":";;;;;;;;AAAA,OAAO,qBAAqB;AAE5B,SAAS,kCAAkC;AAC3C,SAAS,UAAU,yBAAyB;AAC5C,SAAS,gBAAgB;AAKlB,IAAM,wBAAN,MAAM,+BAA8B,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAS1D,OAAO,WACL,SAAgC,IAAI,2BAA2B,GAC/D;AACA,QAAI,+BAA+B;AAEnC,UAAM,MAAM,IAAI,gBAAgB;AAChC,aAAS,QAAQ,KAAK,QAAQ,CAAC,UAAU;AACvC,UAAI,OAAO;AACT,iBAAS,0CAA0C,KAAK;AAAA,MAC1D;AACA,WAAK,MAAM;AAAA,IACb,CAAC;AAED,UAAM,gBAAgB,IAAI,aAAa,kBAAkB,OAAO;AAChE,UAAM,YAAY,IAAI,aAAa,kBAAkB,QAAQ;AAE7D,WAAO,IAAI,uBAAsB,eAAe,SAAS;AAAA,EAC3D;AACF","sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { WebWorkerPostMessageStream } from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport { pipeline } from 'readable-stream';\n\nimport { BaseSnapExecutor } from '../../common/BaseSnapExecutor';\nimport { log } from '../../logging';\n\nexport class WebWorkerSnapExecutor extends BaseSnapExecutor {\n  /**\n   * Initialize the WebWorkerSnapExecutor. This creates a post message stream\n   * from and to the parent window, for two-way communication with the iframe.\n   *\n   * @param stream - The stream to use for communication.\n   * @returns An instance of `WebWorkerSnapExecutor`, with the initialized post\n   * message streams.\n   */\n  static initialize(\n    stream: BasePostMessageStream = new WebWorkerPostMessageStream(),\n  ) {\n    log('Worker: Connecting to parent.');\n\n    const mux = new ObjectMultiplex();\n    pipeline(stream, mux, stream, (error) => {\n      if (error) {\n        logError(`Parent stream failure, closing worker.`, error);\n      }\n      self.close();\n    });\n\n    const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);\n    const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC);\n\n    return new WebWorkerSnapExecutor(commandStream, rpcStream);\n  }\n}\n"]}

package/dist/chunk-XBKAIK2K.mjs

@@ -0,0 +1,67 @@
+import {
+  commonEndowmentFactory_default
+} from "./chunk-ETXAWW65.mjs";
+import {
+  rootRealmGlobal
+} from "./chunk-Y7IEFWZU.mjs";
+
+// src/common/endowments/index.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { logWarning } from "@metamask/snaps-utils";
+import { hasProperty } from "@metamask/utils";
+var registeredEndowments = commonEndowmentFactory_default();
+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 (!hasProperty(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 rootRealmGlobal) {
+        logWarning(`Access to unhardened global ${endowmentName}.`);
+        const globalValue = rootRealmGlobal[endowmentName];
+        allEndowments[endowmentName] = globalValue;
+      } else {
+        throw 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 };
+}
+
+export {
+  createEndowments
+};
+//# sourceMappingURL=chunk-XBKAIK2K.mjs.map

package/dist/chunk-XBKAIK2K.mjs.map

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

package/dist/chunk-XGCWN6ZD.mjs

@@ -0,0 +1,262 @@
+import {
+  withTeardown
+} from "./chunk-GH6FPDY5.mjs";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-YRZVIDCF.mjs";
+
+// src/common/endowments/network.ts
+import { assert } from "@metamask/utils";
+var _teardownRef, _ogResponse, _onStart, _onFinish;
+var _ResponseWrapper = class _ResponseWrapper {
+  constructor(ogResponse, teardownRef, onStart, onFinish) {
+    __privateAdd(this, _teardownRef, void 0);
+    __privateAdd(this, _ogResponse, void 0);
+    __privateAdd(this, _onStart, void 0);
+    __privateAdd(this, _onFinish, void 0);
+    __privateSet(this, _ogResponse, ogResponse);
+    __privateSet(this, _teardownRef, teardownRef);
+    __privateSet(this, _onStart, onStart);
+    __privateSet(this, _onFinish, onFinish);
+  }
+  get body() {
+    return __privateGet(this, _ogResponse).body;
+  }
+  get bodyUsed() {
+    return __privateGet(this, _ogResponse).bodyUsed;
+  }
+  get headers() {
+    return __privateGet(this, _ogResponse).headers;
+  }
+  get ok() {
+    return __privateGet(this, _ogResponse).ok;
+  }
+  get redirected() {
+    return __privateGet(this, _ogResponse).redirected;
+  }
+  get status() {
+    return __privateGet(this, _ogResponse).status;
+  }
+  get statusText() {
+    return __privateGet(this, _ogResponse).statusText;
+  }
+  get type() {
+    return __privateGet(this, _ogResponse).type;
+  }
+  get url() {
+    return __privateGet(this, _ogResponse).url;
+  }
+  async text() {
+    return await withTeardown(
+      (async () => {
+        await __privateGet(this, _onStart).call(this);
+        try {
+          return await __privateGet(this, _ogResponse).text();
+        } finally {
+          await __privateGet(this, _onFinish).call(this);
+        }
+      })(),
+      __privateGet(this, _teardownRef)
+    );
+  }
+  async arrayBuffer() {
+    return await withTeardown(
+      (async () => {
+        await __privateGet(this, _onStart).call(this);
+        try {
+          return await __privateGet(this, _ogResponse).arrayBuffer();
+        } finally {
+          await __privateGet(this, _onFinish).call(this);
+        }
+      })(),
+      __privateGet(this, _teardownRef)
+    );
+  }
+  async blob() {
+    return await withTeardown(
+      (async () => {
+        await __privateGet(this, _onStart).call(this);
+        try {
+          return await __privateGet(this, _ogResponse).blob();
+        } finally {
+          await __privateGet(this, _onFinish).call(this);
+        }
+      })(),
+      __privateGet(this, _teardownRef)
+    );
+  }
+  clone() {
+    const newResponse = __privateGet(this, _ogResponse).clone();
+    return new _ResponseWrapper(
+      newResponse,
+      __privateGet(this, _teardownRef),
+      __privateGet(this, _onStart),
+      __privateGet(this, _onFinish)
+    );
+  }
+  async formData() {
+    return await withTeardown(
+      (async () => {
+        await __privateGet(this, _onStart).call(this);
+        try {
+          return await __privateGet(this, _ogResponse).formData();
+        } finally {
+          await __privateGet(this, _onFinish).call(this);
+        }
+      })(),
+      __privateGet(this, _teardownRef)
+    );
+  }
+  async json() {
+    return await withTeardown(
+      (async () => {
+        await __privateGet(this, _onStart).call(this);
+        try {
+          return await __privateGet(this, _ogResponse).json();
+        } finally {
+          await __privateGet(this, _onFinish).call(this);
+        }
+      })(),
+      __privateGet(this, _teardownRef)
+    );
+  }
+};
+_teardownRef = new WeakMap();
+_ogResponse = new WeakMap();
+_onStart = new WeakMap();
+_onFinish = new WeakMap();
+var ResponseWrapper = _ResponseWrapper;
+var createNetwork = ({ notify } = {}) => {
+  assert(notify, "Notify must be passed to network endowment factory");
+  const openConnections = /* @__PURE__ */ new Set();
+  const teardownRef = { lastTeardown: 0 };
+  const cleanup = new FinalizationRegistry(
+    /* istanbul ignore next: can't test garbage collection without modifying node parameters */
+    (callback) => callback()
+  );
+  const _fetch = async (input, init) => {
+    const abortController = new AbortController();
+    if (init?.signal !== null && init?.signal !== void 0) {
+      const originalSignal = init.signal;
+      originalSignal.addEventListener(
+        "abort",
+        () => {
+          abortController.abort(originalSignal.reason);
+        },
+        { once: true }
+      );
+    }
+    let started = false;
+    const onStart = async () => {
+      if (!started) {
+        started = true;
+        await notify({
+          method: "OutboundRequest",
+          params: { source: "fetch" }
+        });
+      }
+    };
+    let finished = false;
+    const onFinish = async () => {
+      if (!finished) {
+        finished = true;
+        await notify({
+          method: "OutboundResponse",
+          params: { source: "fetch" }
+        });
+      }
+    };
+    let res;
+    let openFetchConnection;
+    return await withTeardown(
+      (async () => {
+        try {
+          await notify({
+            method: "OutboundRequest",
+            params: { source: "fetch" }
+          });
+          const fetchPromise = fetch(input, {
+            ...init,
+            signal: abortController.signal
+          });
+          openFetchConnection = {
+            cancel: async () => {
+              abortController.abort();
+              try {
+                await fetchPromise;
+              } catch {
+              }
+            }
+          };
+          openConnections.add(openFetchConnection);
+          res = new ResponseWrapper(
+            await fetchPromise,
+            teardownRef,
+            onStart,
+            onFinish
+          );
+        } finally {
+          if (openFetchConnection !== void 0) {
+            openConnections.delete(openFetchConnection);
+          }
+          await notify({
+            method: "OutboundResponse",
+            params: { source: "fetch" }
+          });
+        }
+        if (res.body !== null) {
+          const body = new WeakRef(res.body);
+          const openBodyConnection = {
+            cancel: (
+              /* istanbul ignore next: see it.todo('can be torn down during body read') test */
+              async () => {
+                try {
+                  await body.deref()?.cancel();
+                } catch {
+                }
+              }
+            )
+          };
+          openConnections.add(openBodyConnection);
+          cleanup.register(
+            res.body,
+            /* istanbul ignore next: can't test garbage collection without modifying node parameters */
+            () => openConnections.delete(openBodyConnection)
+          );
+        }
+        return harden(res);
+      })(),
+      teardownRef
+    );
+  };
+  const teardownFunction = async () => {
+    teardownRef.lastTeardown += 1;
+    const promises = [];
+    openConnections.forEach(({ cancel }) => promises.push(cancel()));
+    openConnections.clear();
+    await Promise.all(promises);
+  };
+  return {
+    fetch: harden(_fetch),
+    // Request, Headers and Response are the endowments injected alongside fetch
+    // only when 'endowment:network-access' permission is requested,
+    // therefore these are hardened as part of fetch dependency injection within its factory.
+    // These endowments are not (and should never be) available by default.
+    Request: harden(Request),
+    Headers: harden(Headers),
+    Response: harden(Response),
+    teardownFunction
+  };
+};
+var endowmentModule = {
+  names: ["fetch", "Request", "Headers", "Response"],
+  factory: createNetwork
+};
+var network_default = endowmentModule;
+
+export {
+  network_default
+};
+//# sourceMappingURL=chunk-XGCWN6ZD.mjs.map

package/dist/chunk-XGCWN6ZD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/network.ts"],"sourcesContent":["import { assert } from '@metamask/utils';\n\nimport { withTeardown } from '../utils';\nimport type { EndowmentFactoryOptions } from './commonEndowmentFactory';\n\n/**\n * This class wraps a Response object.\n * That way, a teardown process can stop any processes left.\n */\nclass ResponseWrapper implements Response {\n  readonly #teardownRef: { lastTeardown: number };\n\n  #ogResponse: Response;\n\n  #onStart: () => Promise<void>;\n\n  #onFinish: () => Promise<void>;\n\n  constructor(\n    ogResponse: Response,\n    teardownRef: { lastTeardown: number },\n    onStart: () => Promise<void>,\n    onFinish: () => Promise<void>,\n  ) {\n    this.#ogResponse = ogResponse;\n    this.#teardownRef = teardownRef;\n    this.#onStart = onStart;\n    this.#onFinish = onFinish;\n  }\n\n  get body(): ReadableStream<Uint8Array> | null {\n    return this.#ogResponse.body;\n  }\n\n  get bodyUsed() {\n    return this.#ogResponse.bodyUsed;\n  }\n\n  get headers() {\n    return this.#ogResponse.headers;\n  }\n\n  get ok() {\n    return this.#ogResponse.ok;\n  }\n\n  get redirected() {\n    return this.#ogResponse.redirected;\n  }\n\n  get status() {\n    return this.#ogResponse.status;\n  }\n\n  get statusText() {\n    return this.#ogResponse.statusText;\n  }\n\n  get type() {\n    return this.#ogResponse.type;\n  }\n\n  get url() {\n    return this.#ogResponse.url;\n  }\n\n  async text() {\n    return await withTeardown<string>(\n      (async () => {\n        await this.#onStart();\n        try {\n          return await this.#ogResponse.text();\n        } finally {\n          await this.#onFinish();\n        }\n      })(),\n      this.#teardownRef,\n    );\n  }\n\n  async arrayBuffer(): Promise<ArrayBuffer> {\n    return await withTeardown<ArrayBuffer>(\n      (async () => {\n        await this.#onStart();\n        try {\n          return await this.#ogResponse.arrayBuffer();\n        } finally {\n          await this.#onFinish();\n        }\n      })(),\n      this.#teardownRef,\n    );\n  }\n\n  async blob(): Promise<Blob> {\n    return await withTeardown<Blob>(\n      (async () => {\n        await this.#onStart();\n        try {\n          return await this.#ogResponse.blob();\n        } finally {\n          await this.#onFinish();\n        }\n      })(),\n      this.#teardownRef,\n    );\n  }\n\n  clone(): Response {\n    const newResponse = this.#ogResponse.clone();\n    return new ResponseWrapper(\n      newResponse,\n      this.#teardownRef,\n      this.#onStart,\n      this.#onFinish,\n    );\n  }\n\n  async formData(): Promise<FormData> {\n    return await withTeardown<FormData>(\n      (async () => {\n        await this.#onStart();\n        try {\n          return await this.#ogResponse.formData();\n        } finally {\n          await this.#onFinish();\n        }\n      })(),\n      this.#teardownRef,\n    );\n  }\n\n  async json(): Promise<any> {\n    return await withTeardown(\n      (async () => {\n        await this.#onStart();\n        try {\n          return await this.#ogResponse.json();\n        } finally {\n          await this.#onFinish();\n        }\n      })(),\n      this.#teardownRef,\n    );\n  }\n}\n\n/**\n * Create a network endowment, consisting of a `fetch` function.\n * This allows us to provide a teardown function, so that we can cancel\n * any pending requests, connections, streams, etc. that may be open when a snap\n * is terminated.\n *\n * This wraps the original implementation of `fetch`,\n * to ensure that a bad actor cannot get access to the original function, thus\n * potentially preventing the network requests from being torn down.\n *\n * @param options - An options bag.\n * @param options.notify - A reference to the notify function of the snap executor.\n * @returns An object containing a wrapped `fetch`\n * function, as well as a teardown function.\n */\nconst createNetwork = ({ notify }: EndowmentFactoryOptions = {}) => {\n  assert(notify, 'Notify must be passed to network endowment factory');\n  // Open fetch calls or open body streams\n  const openConnections = new Set<{ cancel: () => Promise<void> }>();\n  // Track last teardown count\n  const teardownRef = { lastTeardown: 0 };\n\n  // Remove items from openConnections after they were garbage collected\n  const cleanup = new FinalizationRegistry<() => void>(\n    /* istanbul ignore next: can't test garbage collection without modifying node parameters */\n    (callback) => callback(),\n  );\n\n  const _fetch: typeof fetch = async (\n    input: RequestInfo | URL,\n    init?: RequestInit,\n  ): Promise<Response> => {\n    const abortController = new AbortController();\n    if (init?.signal !== null && init?.signal !== undefined) {\n      const originalSignal = init.signal;\n      // Merge abort controllers\n      originalSignal.addEventListener(\n        'abort',\n        () => {\n          abortController.abort((originalSignal as any).reason);\n        },\n        { once: true },\n      );\n    }\n\n    let started = false;\n    const onStart = async () => {\n      if (!started) {\n        started = true;\n        await notify({\n          method: 'OutboundRequest',\n          params: { source: 'fetch' },\n        });\n      }\n    };\n\n    let finished = false;\n    const onFinish = async () => {\n      if (!finished) {\n        finished = true;\n        await notify({\n          method: 'OutboundResponse',\n          params: { source: 'fetch' },\n        });\n      }\n    };\n\n    let res: Response;\n    let openFetchConnection: { cancel: () => Promise<void> } | undefined;\n    return await withTeardown(\n      (async () => {\n        try {\n          await notify({\n            method: 'OutboundRequest',\n            params: { source: 'fetch' },\n          });\n          const fetchPromise = fetch(input, {\n            ...init,\n            signal: abortController.signal,\n          });\n\n          openFetchConnection = {\n            cancel: async () => {\n              abortController.abort();\n              try {\n                await fetchPromise;\n              } catch {\n                /* do nothing */\n              }\n            },\n          };\n          openConnections.add(openFetchConnection);\n\n          res = new ResponseWrapper(\n            await fetchPromise,\n            teardownRef,\n            onStart,\n            onFinish,\n          );\n        } finally {\n          if (openFetchConnection !== undefined) {\n            openConnections.delete(openFetchConnection);\n          }\n          await notify({\n            method: 'OutboundResponse',\n            params: { source: 'fetch' },\n          });\n        }\n\n        if (res.body !== null) {\n          const body = new WeakRef<ReadableStream>(res.body);\n\n          const openBodyConnection = {\n            cancel:\n              /* istanbul ignore next: see it.todo('can be torn down during body read') test */\n              async () => {\n                try {\n                  await body.deref()?.cancel();\n                } catch {\n                  /* do nothing */\n                }\n              },\n          };\n          openConnections.add(openBodyConnection);\n          cleanup.register(\n            res.body,\n            /* istanbul ignore next: can't test garbage collection without modifying node parameters */\n            () => openConnections.delete(openBodyConnection),\n          );\n        }\n        return harden(res);\n      })(),\n      teardownRef,\n    );\n  };\n\n  const teardownFunction = async () => {\n    teardownRef.lastTeardown += 1;\n    const promises: Promise<void>[] = [];\n    openConnections.forEach(({ cancel }) => promises.push(cancel()));\n    openConnections.clear();\n    await Promise.all(promises);\n  };\n\n  return {\n    fetch: harden(_fetch),\n    // Request, Headers and Response are the endowments injected alongside fetch\n    // only when 'endowment:network-access' permission is requested,\n    // therefore these are hardened as part of fetch dependency injection within its factory.\n    // These endowments are not (and should never be) available by default.\n    Request: harden(Request),\n    Headers: harden(Headers),\n    Response: harden(Response),\n    teardownFunction,\n  };\n};\n\nconst endowmentModule = {\n  names: ['fetch', 'Request', 'Headers', 'Response'] as const,\n  factory: createNetwork,\n};\nexport default endowmentModule;\n"],"mappings":"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","names":[]}

package/dist/chunk-XKY46YTJ.js

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/logging.ts
+var _snapsutils = require('@metamask/snaps-utils');
+var _utils = require('@metamask/utils');
+var log = _utils.createModuleLogger.call(void 0, 
+  _snapsutils.snapsLogger,
+  "snaps-execution-environments"
+);
+
+
+
+exports.log = log;
+//# sourceMappingURL=chunk-XKY46YTJ.js.map

package/dist/chunk-XKY46YTJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/logging.ts"],"names":[],"mappings":";AAAA,SAAS,mBAAmB;AAC5B,SAAS,0BAA0B;AAQ5B,IAAM,MAAM;AAAA,EACjB;AAAA,EACA;AACF","sourcesContent":["import { snapsLogger } from '@metamask/snaps-utils';\nimport { createModuleLogger } from '@metamask/utils';\n\n/**\n * A logging function specific to this package. The log messages don't show up\n * by default, but they can be enabled by setting the environment variable:\n * - `DEBUG=metamask:snaps:snaps-execution-environments`, or\n * - `DEBUG=metamask:snaps:*` to enable all logs from `@metamask/snaps-*`.\n */\nexport const log = createModuleLogger(\n  snapsLogger,\n  'snaps-execution-environments',\n);\n"]}

package/dist/chunk-XL5BQOEI.mjs

@@ -0,0 +1,33 @@
+import {
+  BaseSnapExecutor
+} from "./chunk-OW4IXJ5J.mjs";
+import {
+  log
+} from "./chunk-VL3VNUT4.mjs";
+
+// src/node-process/ChildProcessSnapExecutor.ts
+import ObjectMultiplex from "@metamask/object-multiplex";
+import { ProcessMessageStream } from "@metamask/post-message-stream";
+import { logError, SNAP_STREAM_NAMES } from "@metamask/snaps-utils";
+import { pipeline } from "readable-stream";
+var ChildProcessSnapExecutor = class _ChildProcessSnapExecutor extends BaseSnapExecutor {
+  static initialize() {
+    log("Worker: Connecting to parent.");
+    const parentStream = new ProcessMessageStream();
+    const mux = new ObjectMultiplex();
+    pipeline(parentStream, mux, parentStream, (error) => {
+      if (error) {
+        logError(`Parent stream failure, closing worker.`, error);
+      }
+      self.close();
+    });
+    const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);
+    const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC);
+    return new _ChildProcessSnapExecutor(commandStream, rpcStream);
+  }
+};
+
+export {
+  ChildProcessSnapExecutor
+};
+//# sourceMappingURL=chunk-XL5BQOEI.mjs.map

package/dist/chunk-XL5BQOEI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node-process/ChildProcessSnapExecutor.ts"],"sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport { ProcessMessageStream } from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport { pipeline } from 'readable-stream';\n\nimport { BaseSnapExecutor } from '../common/BaseSnapExecutor';\nimport { log } from '../logging';\n\nexport class ChildProcessSnapExecutor extends BaseSnapExecutor {\n  static initialize() {\n    log('Worker: Connecting to parent.');\n\n    const parentStream = new ProcessMessageStream();\n    const mux = new ObjectMultiplex();\n    pipeline(parentStream, mux as any, parentStream, (error) => {\n      if (error) {\n        logError(`Parent stream failure, closing worker.`, error);\n      }\n      self.close();\n    });\n\n    const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);\n    const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC) as any;\n    return new ChildProcessSnapExecutor(commandStream, rpcStream);\n  }\n}\n"],"mappings":";;;;;;;;AAAA,OAAO,qBAAqB;AAC5B,SAAS,4BAA4B;AACrC,SAAS,UAAU,yBAAyB;AAC5C,SAAS,gBAAgB;AAKlB,IAAM,2BAAN,MAAM,kCAAiC,iBAAiB;AAAA,EAC7D,OAAO,aAAa;AAClB,QAAI,+BAA+B;AAEnC,UAAM,eAAe,IAAI,qBAAqB;AAC9C,UAAM,MAAM,IAAI,gBAAgB;AAChC,aAAS,cAAc,KAAY,cAAc,CAAC,UAAU;AAC1D,UAAI,OAAO;AACT,iBAAS,0CAA0C,KAAK;AAAA,MAC1D;AACA,WAAK,MAAM;AAAA,IACb,CAAC;AAED,UAAM,gBAAgB,IAAI,aAAa,kBAAkB,OAAO;AAChE,UAAM,YAAY,IAAI,aAAa,kBAAkB,QAAQ;AAC7D,WAAO,IAAI,0BAAyB,eAAe,SAAS;AAAA,EAC9D;AACF;","names":[]}

package/dist/chunk-XMCETCVM.js

@@ -0,0 +1,48 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/common/endowments/timeout.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var MINIMUM_TIMEOUT = 10;
+var createTimeout = () => {
+  const registeredHandles = /* @__PURE__ */ new Map();
+  const _setTimeout = (handler, timeout) => {
+    if (typeof handler !== "function") {
+      throw _rpcerrors.rpcErrors.internal(
+        `The timeout handler must be a function. Received: ${typeof handler}.`
+      );
+    }
+    harden(handler);
+    const handle = Object.freeze(/* @__PURE__ */ Object.create(null));
+    const platformHandle = setTimeout(() => {
+      registeredHandles.delete(handle);
+      handler();
+    }, Math.max(MINIMUM_TIMEOUT, _nullishCoalesce(timeout, () => ( 0))));
+    registeredHandles.set(handle, platformHandle);
+    return handle;
+  };
+  const _clearTimeout = (handle) => {
+    const platformHandle = registeredHandles.get(handle);
+    if (platformHandle !== void 0) {
+      clearTimeout(platformHandle);
+      registeredHandles.delete(handle);
+    }
+  };
+  const teardownFunction = () => {
+    for (const handle of registeredHandles.keys()) {
+      _clearTimeout(handle);
+    }
+  };
+  return {
+    setTimeout: harden(_setTimeout),
+    clearTimeout: harden(_clearTimeout),
+    teardownFunction
+  };
+};
+var endowmentModule = {
+  names: ["setTimeout", "clearTimeout"],
+  factory: createTimeout
+};
+var timeout_default = endowmentModule;
+
+
+
+exports.timeout_default = timeout_default;
+//# sourceMappingURL=chunk-XMCETCVM.js.map

package/dist/chunk-XMCETCVM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/timeout.ts"],"names":[],"mappings":";AAAA,SAAS,iBAAiB;AAE1B,IAAM,kBAAkB;AAYxB,IAAM,gBAAgB,MAAM;AAC1B,QAAM,oBAAoB,oBAAI,IAAsB;AACpD,QAAM,cAAc,CAAC,SAAuB,YAA8B;AACxE,QAAI,OAAO,YAAY,YAAY;AACjC,YAAM,UAAU;AAAA,QACd,qDAAqD,OAAO,OAAO;AAAA,MACrE;AAAA,IACF;AACA,WAAO,OAAO;AACd,UAAM,SAAS,OAAO,OAAO,uBAAO,OAAO,IAAI,CAAC;AAChD,UAAM,iBAAiB,WAAW,MAAM;AACtC,wBAAkB,OAAO,MAAM;AAC/B,cAAQ;AAAA,IACV,GAAG,KAAK,IAAI,iBAAiB,WAAW,CAAC,CAAC;AAE1C,sBAAkB,IAAI,QAAQ,cAAc;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB,CAAC,WAA0B;AAC/C,UAAM,iBAAiB,kBAAkB,IAAI,MAAM;AACnD,QAAI,mBAAmB,QAAW;AAChC,mBAAa,cAAqB;AAClC,wBAAkB,OAAO,MAAM;AAAA,IACjC;AAAA,EACF;AAEA,QAAM,mBAAmB,MAAY;AACnC,eAAW,UAAU,kBAAkB,KAAK,GAAG;AAC7C,oBAAc,MAAM;AAAA,IACtB;AAAA,EACF;AAEA,SAAO;AAAA,IACL,YAAY,OAAO,WAAW;AAAA,IAC9B,cAAc,OAAO,aAAa;AAAA,IAClC;AAAA,EACF;AACF;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,cAAc,cAAc;AAAA,EACpC,SAAS;AACX;AACA,IAAO,kBAAQ","sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\n\nconst MINIMUM_TIMEOUT = 10;\n\n/**\n * Creates a pair of `setTimeout` and `clearTimeout` functions attenuated such\n * that:\n * - `setTimeout` throws if its \"handler\" parameter is not a function.\n * - `clearTimeout` only clears timeouts created by its sibling `setTimeout`,\n * or else no-ops.\n *\n * @returns An object with the attenuated `setTimeout` and `clearTimeout`\n * functions.\n */\nconst createTimeout = () => {\n  const registeredHandles = new Map<unknown, unknown>();\n  const _setTimeout = (handler: TimerHandler, timeout?: number): unknown => {\n    if (typeof handler !== 'function') {\n      throw rpcErrors.internal(\n        `The timeout handler must be a function. Received: ${typeof handler}.`,\n      );\n    }\n    harden(handler);\n    const handle = Object.freeze(Object.create(null));\n    const platformHandle = setTimeout(() => {\n      registeredHandles.delete(handle);\n      handler();\n    }, Math.max(MINIMUM_TIMEOUT, timeout ?? 0));\n\n    registeredHandles.set(handle, platformHandle);\n    return handle;\n  };\n\n  const _clearTimeout = (handle: unknown): void => {\n    const platformHandle = registeredHandles.get(handle);\n    if (platformHandle !== undefined) {\n      clearTimeout(platformHandle as any);\n      registeredHandles.delete(handle);\n    }\n  };\n\n  const teardownFunction = (): void => {\n    for (const handle of registeredHandles.keys()) {\n      _clearTimeout(handle);\n    }\n  };\n\n  return {\n    setTimeout: harden(_setTimeout),\n    clearTimeout: harden(_clearTimeout),\n    teardownFunction,\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['setTimeout', 'clearTimeout'] as const,\n  factory: createTimeout,\n};\nexport default endowmentModule;\n"]}