@metamask/snaps-execution-environments 1.0.1 → 2.0.0

package/dist/cjs/node-thread/ThreadSnapExecutor.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ThreadSnapExecutor", {
+    enumerable: true,
+    get: function() {
+        return ThreadSnapExecutor;
+    }
+});
+const _objectmultiplex = /*#__PURE__*/ _interop_require_default(require("@metamask/object-multiplex"));
+const _postmessagestream = require("@metamask/post-message-stream");
+const _snapsutils = require("@metamask/snaps-utils");
+const _stream = require("stream");
+const _BaseSnapExecutor = require("../common/BaseSnapExecutor");
+const _logging = require("../logging");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class ThreadSnapExecutor extends _BaseSnapExecutor.BaseSnapExecutor {
+    static initialize() {
+        (0, _logging.log)('Worker: Connecting to parent.');
+        const parentStream = new _postmessagestream.ThreadMessageStream();
+        const mux = new _objectmultiplex.default();
+        (0, _stream.pipeline)(parentStream, mux, parentStream, (error)=>{
+            if (error) {
+                (0, _snapsutils.logError)(`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 ThreadSnapExecutor(commandStream, rpcStream);
+    }
+}
+
+//# sourceMappingURL=ThreadSnapExecutor.js.map

package/dist/cjs/node-thread/ThreadSnapExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node-thread/ThreadSnapExecutor.ts"],"sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport { ThreadMessageStream } from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport { pipeline } from 'stream';\n\nimport { BaseSnapExecutor } from '../common/BaseSnapExecutor';\nimport { log } from '../logging';\n\nexport class ThreadSnapExecutor extends BaseSnapExecutor {\n  static initialize() {\n    log('Worker: Connecting to parent.');\n\n    const parentStream = new ThreadMessageStream();\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 ThreadSnapExecutor(commandStream, rpcStream);\n  }\n}\n"],"names":["ThreadSnapExecutor","BaseSnapExecutor","initialize","log","parentStream","ThreadMessageStream","mux","ObjectMultiplex","pipeline","error","logError","self","close","commandStream","createStream","SNAP_STREAM_NAMES","COMMAND","rpcStream","JSON_RPC"],"mappings":";;;;+BAQaA;;;eAAAA;;;wEARe;mCACQ;4BACQ;wBACnB;kCAEQ;yBACb;;;;;;AAEb,MAAMA,2BAA2BC,kCAAgB;IACtD,OAAOC,aAAa;QAClBC,IAAAA,YAAG,EAAC;QAEJ,MAAMC,eAAe,IAAIC,sCAAmB;QAC5C,MAAMC,MAAM,IAAIC,wBAAe;QAC/BC,IAAAA,gBAAQ,EAACJ,cAAcE,KAAYF,cAAc,CAACK;YAChD,IAAIA,OAAO;gBACTC,IAAAA,oBAAQ,EAAC,CAAC,sCAAsC,CAAC,EAAED;YACrD;YACAE,KAAKC,KAAK;QACZ;QAEA,MAAMC,gBAAgBP,IAAIQ,YAAY,CAACC,6BAAiB,CAACC,OAAO;QAChE,MAAMC,YAAYX,IAAIQ,YAAY,CAACC,6BAAiB,CAACG,QAAQ;QAC7D,OAAO,IAAIlB,mBAAmBa,eAAeI;IAC/C;AACF"}

package/dist/cjs/node-thread/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _lockdownmore = require("../common/lockdown/lockdown-more");
+const _ThreadSnapExecutor = require("./ThreadSnapExecutor");
+// Lockdown is already applied in LavaMoat
+(0, _lockdownmore.executeLockdownMore)();
+_ThreadSnapExecutor.ThreadSnapExecutor.initialize();
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/node-thread/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node-thread/index.ts"],"sourcesContent":["import { executeLockdownMore } from '../common/lockdown/lockdown-more';\nimport { ThreadSnapExecutor } from './ThreadSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\n\nThreadSnapExecutor.initialize();\n"],"names":["executeLockdownMore","ThreadSnapExecutor","initialize"],"mappings":";;;;8BAAoC;oCACD;AAEnC,0CAA0C;AAC1CA,IAAAA,iCAAmB;AAEnBC,sCAAkB,CAACC,UAAU"}

package/dist/cjs/offscreen/OffscreenSnapExecutor.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "OffscreenSnapExecutor", {
+    enumerable: true,
+    get: function() {
+        return OffscreenSnapExecutor;
+    }
+});
+const _postmessagestream = require("@metamask/post-message-stream");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var _stream = /*#__PURE__*/ new WeakMap(), /**
+   * Handle an incoming message from the `OffscreenExecutionService`. 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.
+   * @param data.extra - Extra data.
+   * @param data.extra.frameUrl - The URL to load in the iframe.
+   */ _onData = /*#__PURE__*/ new WeakSet(), _initializeJob = /*#__PURE__*/ new WeakSet(), /**
+   * 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.
+   */ _terminateJob = /*#__PURE__*/ new WeakSet();
+class OffscreenSnapExecutor {
+    /**
+   * Initialize the executor with the given stream. This is a wrapper around the
+   * constructor.
+   *
+   * @param stream - The stream to use for communication.
+   * @returns The initialized executor.
+   */ static initialize(stream) {
+        return new OffscreenSnapExecutor(stream);
+    }
+    constructor(stream){
+        _class_private_method_init(this, _onData);
+        /**
+   * Create a new iframe and set up a stream to communicate with it.
+   *
+   * @param jobId - The job ID.
+   * @param frameUrl - The URL to load in the iframe.
+   */ _class_private_method_init(this, _initializeJob);
+        _class_private_method_init(this, _terminateJob);
+        _class_private_field_init(this, _stream, {
+            writable: true,
+            value: void 0
+        });
+        _define_property(this, "jobs", {});
+        _class_private_field_set(this, _stream, stream);
+        _class_private_field_get(this, _stream).on('data', _class_private_method_get(this, _onData, onData).bind(this));
+    }
+}
+function onData(data) {
+    const { jobId, extra: { frameUrl }, data: request } = data;
+    if (!this.jobs[jobId]) {
+        // This ensures that a job is initialized before it is used. To avoid
+        // code duplication, we call the `#onData` method again, which will
+        // run the rest of the logic after initialization.
+        _class_private_method_get(this, _initializeJob, initializeJob).call(this, jobId, frameUrl).then(()=>{
+            _class_private_method_get(this, _onData, onData).call(this, data);
+        }).catch((error)=>{
+            (0, _snapsutils.logError)('[Worker] Error initializing job:', error);
+        });
+        return;
+    }
+    // This is a method specific to the `OffscreenSnapExecutor`, as the service
+    // itself does not have access to the iframes directly.
+    if (request.method === 'terminateJob') {
+        _class_private_method_get(this, _terminateJob, terminateJob).call(this, jobId);
+        return;
+    }
+    this.jobs[jobId].stream.write(request);
+}
+async function initializeJob(jobId, frameUrl) {
+    const window = await (0, _snapsutils.createWindow)(frameUrl, jobId);
+    const jobStream = new _postmessagestream.WindowPostMessageStream({
+        name: 'parent',
+        target: 'child',
+        targetWindow: window,
+        targetOrigin: '*'
+    });
+    // Write messages from the iframe to the parent, wrapped with the job ID.
+    jobStream.on('data', (data)=>{
+        _class_private_field_get(this, _stream).write({
+            data,
+            jobId
+        });
+    });
+    this.jobs[jobId] = {
+        id: jobId,
+        window,
+        stream: jobStream
+    };
+    return this.jobs[jobId];
+}
+function terminateJob(jobId) {
+    (0, _utils.assert)(this.jobs[jobId], `Job "${jobId}" not found.`);
+    const iframe = document.getElementById(jobId);
+    (0, _utils.assert)(iframe, `Iframe with ID "${jobId}" not found.`);
+    iframe.remove();
+    this.jobs[jobId].stream.destroy();
+    delete this.jobs[jobId];
+}
+
+//# sourceMappingURL=OffscreenSnapExecutor.js.map

package/dist/cjs/offscreen/OffscreenSnapExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/offscreen/OffscreenSnapExecutor.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { WindowPostMessageStream } from '@metamask/post-message-stream';\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\n/**\n * A snap executor using the Offscreen Documents API.\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 * Extensions can only have a single offscreen document, so this executor is\n * persisted between snap executions. The offscreen snap executor essentially\n * acts as a proxy between the extension and the iframe execution environment.\n *\n * @see https://developer.chrome.com/docs/extensions/reference/offscreen/\n */\nexport class OffscreenSnapExecutor {\n  readonly #stream: BasePostMessageStream;\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   * @returns The initialized executor.\n   */\n  static initialize(stream: BasePostMessageStream) {\n    return new OffscreenSnapExecutor(stream);\n  }\n\n  constructor(stream: BasePostMessageStream) {\n    this.#stream = stream;\n    this.#stream.on('data', this.#onData.bind(this));\n  }\n\n  /**\n   * Handle an incoming message from the `OffscreenExecutionService`. 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   * @param data.extra - Extra data.\n   * @param data.extra.frameUrl - The URL to load in the iframe.\n   */\n  #onData(data: {\n    data: JsonRpcRequest;\n    jobId: string;\n    extra: { frameUrl: string };\n  }) {\n    const {\n      jobId,\n      extra: { frameUrl },\n      data: request,\n    } = 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, frameUrl)\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   * @param frameUrl - The URL to load in the iframe.\n   */\n  async #initializeJob(jobId: string, frameUrl: string): Promise<ExecutorJob> {\n    const window = await createWindow(frameUrl, jobId);\n    const jobStream = new WindowPostMessageStream({\n      name: 'parent',\n      target: 'child',\n      targetWindow: 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"],"names":["OffscreenSnapExecutor","initialize","stream","constructor","jobs","on","onData","bind","data","jobId","extra","frameUrl","request","initializeJob","then","catch","error","logError","method","terminateJob","write","window","createWindow","jobStream","WindowPostMessageStream","name","target","targetWindow","targetOrigin","id","assert","iframe","document","getElementById","remove","destroy"],"mappings":";;;;+BA0BaA;;;eAAAA;;;mCAzB2B;4BACD;uBAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuBZ,uCAoBT;;;;;;;;;;GAUC,GACD,uCA0CM,8CAkBN;;;;;GAKC,GACD;AAlGK,MAAMA;IAKX;;;;;;GAMC,GACD,OAAOC,WAAWC,MAA6B,EAAE;QAC/C,OAAO,IAAIF,sBAAsBE;IACnC;IAEAC,YAAYD,MAA6B,CAAE;QAgB3C,iCAAA;QAoCA;;;;;GAKC,GACD,iCAAM;QAwBN,iCAAA;QAjGA,gCAAS;;mBAAT,KAAA;;QAEA,uBAASE,QAAoC,CAAC;uCActCF,SAASA;QACf,yBAAA,IAAI,EAAEA,SAAOG,EAAE,CAAC,QAAQ,0BAAA,IAAI,EAAEC,SAAAA,QAAOC,IAAI,CAAC,IAAI;IAChD;AAyFF;AA5EE,SAAA,OAAQC,IAIP;IACC,MAAM,EACJC,KAAK,EACLC,OAAO,EAAEC,QAAQ,EAAE,EACnBH,MAAMI,OAAO,EACd,GAAGJ;IAEJ,IAAI,CAAC,IAAI,CAACJ,IAAI,CAACK,MAAM,EAAE;QACrB,qEAAqE;QACrE,mEAAmE;QACnE,kDAAkD;QAClD,0BAAA,IAAI,EAAEI,gBAAAA,oBAAN,IAAI,EAAgBJ,OAAOE,UACxBG,IAAI,CAAC;YACJ,0BAAA,IAAI,EAAER,SAAAA,aAAN,IAAI,EAASE;QACf,GACCO,KAAK,CAAC,CAACC;YACNC,IAAAA,oBAAQ,EAAC,oCAAoCD;QAC/C;QAEF;IACF;IAEA,2EAA2E;IAC3E,uDAAuD;IACvD,IAAIJ,QAAQM,MAAM,KAAK,gBAAgB;QACrC,0BAAA,IAAI,EAAEC,eAAAA,mBAAN,IAAI,EAAeV;QACnB;IACF;IAEA,IAAI,CAACL,IAAI,CAACK,MAAM,CAACP,MAAM,CAACkB,KAAK,CAACR;AAChC;AAQA,eAAA,cAAqBH,KAAa,EAAEE,QAAgB;IAClD,MAAMU,SAAS,MAAMC,IAAAA,wBAAY,EAACX,UAAUF;IAC5C,MAAMc,YAAY,IAAIC,0CAAuB,CAAC;QAC5CC,MAAM;QACNC,QAAQ;QACRC,cAAcN;QACdO,cAAc;IAChB;IAEA,yEAAyE;IACzEL,UAAUlB,EAAE,CAAC,QAAQ,CAACG;QACpB,yBAAA,IAAI,EAAEN,SAAOkB,KAAK,CAAC;YAAEZ;YAAMC;QAAM;IACnC;IAEA,IAAI,CAACL,IAAI,CAACK,MAAM,GAAG;QAAEoB,IAAIpB;QAAOY;QAAQnB,QAAQqB;IAAU;IAC1D,OAAO,IAAI,CAACnB,IAAI,CAACK,MAAM;AACzB;AAQA,SAAA,aAAcA,KAAa;IACzBqB,IAAAA,aAAM,EAAC,IAAI,CAAC1B,IAAI,CAACK,MAAM,EAAE,CAAC,KAAK,EAAEA,MAAM,YAAY,CAAC;IAEpD,MAAMsB,SAASC,SAASC,cAAc,CAACxB;IACvCqB,IAAAA,aAAM,EAACC,QAAQ,CAAC,gBAAgB,EAAEtB,MAAM,YAAY,CAAC;IAErDsB,OAAOG,MAAM;IACb,IAAI,CAAC9B,IAAI,CAACK,MAAM,CAACP,MAAM,CAACiC,OAAO;IAC/B,OAAO,IAAI,CAAC/B,IAAI,CAACK,MAAM;AACzB"}

package/dist/cjs/offscreen/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _postmessagestream = require("@metamask/post-message-stream");
+const _lockdownevents = require("../common/lockdown/lockdown-events");
+const _lockdownmore = require("../common/lockdown/lockdown-more");
+const _OffscreenSnapExecutor = require("./OffscreenSnapExecutor");
+// Lockdown is already applied in LavaMoat
+(0, _lockdownmore.executeLockdownMore)();
+(0, _lockdownevents.executeLockdownEvents)();
+// The stream from the offscreen document to the execution service.
+const parentStream = new _postmessagestream.BrowserRuntimePostMessageStream({
+    name: 'child',
+    target: 'parent'
+});
+_OffscreenSnapExecutor.OffscreenSnapExecutor.initialize(parentStream);
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/offscreen/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/offscreen/index.ts"],"sourcesContent":["import { BrowserRuntimePostMessageStream } from '@metamask/post-message-stream';\n\nimport { executeLockdownEvents } from '../common/lockdown/lockdown-events';\nimport { executeLockdownMore } from '../common/lockdown/lockdown-more';\nimport { OffscreenSnapExecutor } from './OffscreenSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\nexecuteLockdownEvents();\n\n// The stream from the offscreen document to the execution service.\nconst parentStream = new BrowserRuntimePostMessageStream({\n  name: 'child',\n  target: 'parent',\n});\n\nOffscreenSnapExecutor.initialize(parentStream);\n"],"names":["executeLockdownMore","executeLockdownEvents","parentStream","BrowserRuntimePostMessageStream","name","target","OffscreenSnapExecutor","initialize"],"mappings":";;;;mCAAgD;gCAEV;8BACF;uCACE;AAEtC,0CAA0C;AAC1CA,IAAAA,iCAAmB;AACnBC,IAAAA,qCAAqB;AAErB,mEAAmE;AACnE,MAAMC,eAAe,IAAIC,kDAA+B,CAAC;IACvDC,MAAM;IACNC,QAAQ;AACV;AAEAC,4CAAqB,CAACC,UAAU,CAACL"}

package/dist/cjs/webworker/executor/WebWorkerSnapExecutor.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebWorkerSnapExecutor", {
+    enumerable: true,
+    get: function() {
+        return WebWorkerSnapExecutor;
+    }
+});
+const _objectmultiplex = /*#__PURE__*/ _interop_require_default(require("@metamask/object-multiplex"));
+const _postmessagestream = require("@metamask/post-message-stream");
+const _snapsutils = require("@metamask/snaps-utils");
+const _stream = require("stream");
+const _BaseSnapExecutor = require("../../common/BaseSnapExecutor");
+const _logging = require("../../logging");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class WebWorkerSnapExecutor extends _BaseSnapExecutor.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 _postmessagestream.WebWorkerPostMessageStream()) {
+        (0, _logging.log)('Worker: Connecting to parent.');
+        const mux = new _objectmultiplex.default();
+        (0, _stream.pipeline)(stream, mux, stream, (error)=>{
+            if (error) {
+                (0, _snapsutils.logError)(`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);
+    }
+}
+
+//# sourceMappingURL=WebWorkerSnapExecutor.js.map

package/dist/cjs/webworker/executor/WebWorkerSnapExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webworker/executor/WebWorkerSnapExecutor.ts"],"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 '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"],"names":["WebWorkerSnapExecutor","BaseSnapExecutor","initialize","stream","WebWorkerPostMessageStream","log","mux","ObjectMultiplex","pipeline","error","logError","self","close","commandStream","createStream","SNAP_STREAM_NAMES","COMMAND","rpcStream","JSON_RPC"],"mappings":";;;;+BASaA;;;eAAAA;;;wEATe;mCAEe;4BACC;wBACnB;kCAEQ;yBACb;;;;;;AAEb,MAAMA,8BAA8BC,kCAAgB;IACzD;;;;;;;GAOC,GACD,OAAOC,WACLC,SAAgC,IAAIC,6CAA0B,EAAE,EAChE;QACAC,IAAAA,YAAG,EAAC;QAEJ,MAAMC,MAAM,IAAIC,wBAAe;QAC/BC,IAAAA,gBAAQ,EAACL,QAAQG,KAAKH,QAAQ,CAACM;YAC7B,IAAIA,OAAO;gBACTC,IAAAA,oBAAQ,EAAC,CAAC,sCAAsC,CAAC,EAAED;YACrD;YACAE,KAAKC,KAAK;QACZ;QAEA,MAAMC,gBAAgBP,IAAIQ,YAAY,CAACC,6BAAiB,CAACC,OAAO;QAChE,MAAMC,YAAYX,IAAIQ,YAAY,CAACC,6BAAiB,CAACG,QAAQ;QAE7D,OAAO,IAAIlB,sBAAsBa,eAAeI;IAClD;AACF"}

package/dist/cjs/webworker/executor/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _lockdownevents = require("../../common/lockdown/lockdown-events");
+const _lockdownmore = require("../../common/lockdown/lockdown-more");
+const _WebWorkerSnapExecutor = require("./WebWorkerSnapExecutor");
+// Lockdown is already applied in LavaMoat
+(0, _lockdownmore.executeLockdownMore)();
+(0, _lockdownevents.executeLockdownEvents)();
+_WebWorkerSnapExecutor.WebWorkerSnapExecutor.initialize();
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/webworker/executor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webworker/executor/index.ts"],"sourcesContent":["import { executeLockdownEvents } from '../../common/lockdown/lockdown-events';\nimport { executeLockdownMore } from '../../common/lockdown/lockdown-more';\nimport { WebWorkerSnapExecutor } from './WebWorkerSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\nexecuteLockdownEvents();\n\nWebWorkerSnapExecutor.initialize();\n"],"names":["executeLockdownMore","executeLockdownEvents","WebWorkerSnapExecutor","initialize"],"mappings":";;;;gCAAsC;8BACF;uCACE;AAEtC,0CAA0C;AAC1CA,IAAAA,iCAAmB;AACnBC,IAAAA,qCAAqB;AAErBC,4CAAqB,CAACC,UAAU"}

package/dist/cjs/webworker/pool/WebWorkerPool.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebWorkerPool", {
+    enumerable: true,
+    get: function() {
+        return WebWorkerPool;
+    }
+});
+const _postmessagestream = require("@metamask/post-message-stream");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _nonsecure = require("nanoid/non-secure");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var _poolSize = /*#__PURE__*/ new WeakMap(), _stream = /*#__PURE__*/ new WeakMap(), _url = /*#__PURE__*/ new WeakMap(), _workerSourceURL = /*#__PURE__*/ new WeakMap(), /**
+   * Handle an incoming message from the `WebWorkerExecutionService`. 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.
+   */ _onData = /*#__PURE__*/ new WeakSet(), _initializeJob = /*#__PURE__*/ new WeakSet(), /**
+   * Terminate the job with the given ID. This will close the worker and delete
+   * the job from the internal job map.
+   *
+   * @param jobId - The job ID.
+   */ _terminateJob = /*#__PURE__*/ new WeakSet(), _getWorker = /*#__PURE__*/ new WeakSet(), _updatePool = /*#__PURE__*/ new WeakSet(), _createWorker = /*#__PURE__*/ new WeakSet(), _getWorkerURL = /*#__PURE__*/ new WeakSet();
+class WebWorkerPool {
+    /* istanbul ignore next - Constructor arguments. */ static initialize(stream = new _postmessagestream.WindowPostMessageStream({
+        name: 'child',
+        target: 'parent',
+        targetWindow: self.parent,
+        targetOrigin: '*'
+    }), url = '../executor/bundle.js', poolSize) {
+        return new WebWorkerPool(stream, url, poolSize);
+    }
+    constructor(stream, url, poolSize = 3){
+        _class_private_method_init(this, _onData);
+        /**
+   * Create a new worker and set up a stream to communicate with it.
+   *
+   * @param jobId - The job ID.
+   * @returns The job.
+   */ _class_private_method_init(this, _initializeJob);
+        _class_private_method_init(this, _terminateJob);
+        /**
+   * Get a worker from the pool. A new worker will be created automatically.
+   *
+   * @returns The worker.
+   */ _class_private_method_init(this, _getWorker);
+        /**
+   * Update the pool of workers. This will create new workers if the pool is
+   * below the minimum size.
+   */ _class_private_method_init(this, _updatePool);
+        /**
+   * Create a new worker. This will fetch the worker source if it has not
+   * already been fetched.
+   *
+   * @returns The worker.
+   */ _class_private_method_init(this, _createWorker);
+        /**
+   * Get the URL of the worker source. This will fetch the worker source if it
+   * has not already been fetched.
+   *
+   * @returns The worker source URL, as a `blob:` URL.
+   */ _class_private_method_init(this, _getWorkerURL);
+        _class_private_field_init(this, _poolSize, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _stream, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _url, {
+            writable: true,
+            value: void 0
+        });
+        _define_property(this, "pool", []);
+        _define_property(this, "jobs", new Map());
+        _class_private_field_init(this, _workerSourceURL, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _stream, stream);
+        _class_private_field_set(this, _url, url);
+        _class_private_field_set(this, _poolSize, poolSize);
+        _class_private_field_get(this, _stream).on('data', _class_private_method_get(this, _onData, onData).bind(this));
+    }
+}
+function onData(data) {
+    const { jobId, data: request } = data;
+    const job = this.jobs.get(jobId);
+    if (!job) {
+        // This ensures that a job is initialized before it is used. To avoid
+        // code duplication, we call the `#onData` method again, which will
+        // run the rest of the logic after initialization.
+        _class_private_method_get(this, _initializeJob, initializeJob).call(this, jobId).then(()=>{
+            _class_private_method_get(this, _onData, onData).call(this, data);
+        }).catch((error)=>{
+            (0, _snapsutils.logError)('[Worker] Error initializing job:', error.toString());
+            _class_private_field_get(this, _stream).write({
+                jobId,
+                data: {
+                    name: 'command',
+                    data: {
+                        jsonrpc: '2.0',
+                        id: request.id ?? null,
+                        error: {
+                            code: -32000,
+                            message: 'Internal error'
+                        }
+                    }
+                }
+            });
+        });
+        return;
+    }
+    // This is a method specific to the `WebWorkerPool`, as the service itself
+    // does not have access to the workers directly.
+    if (request.method === 'terminateJob') {
+        _class_private_method_get(this, _terminateJob, terminateJob).call(this, jobId);
+        return;
+    }
+    job.stream.write(request);
+}
+async function initializeJob(jobId) {
+    const worker = await _class_private_method_get(this, _getWorker, getWorker).call(this);
+    const jobStream = new _postmessagestream.WebWorkerParentPostMessageStream({
+        worker
+    });
+    // Write messages from the worker to the parent, wrapped with the job ID.
+    jobStream.on('data', (data)=>{
+        _class_private_field_get(this, _stream).write({
+            data,
+            jobId
+        });
+    });
+    const job = {
+        id: jobId,
+        worker,
+        stream: jobStream
+    };
+    this.jobs.set(jobId, job);
+    return job;
+}
+function terminateJob(jobId) {
+    const job = this.jobs.get(jobId);
+    (0, _utils.assert)(job, `Job "${jobId}" not found.`);
+    job.stream.destroy();
+    job.worker.terminate();
+    this.jobs.delete(jobId);
+}
+async function getWorker() {
+    // Lazily create the pool of workers.
+    if (this.pool.length === 0) {
+        await _class_private_method_get(this, _updatePool, updatePool).call(this);
+    }
+    const worker = this.pool.shift();
+    (0, _utils.assert)(worker, 'Worker not found.');
+    await _class_private_method_get(this, _updatePool, updatePool).call(this);
+    return worker;
+}
+async function updatePool() {
+    while(this.pool.length < _class_private_field_get(this, _poolSize)){
+        const worker = await _class_private_method_get(this, _createWorker, createWorker).call(this);
+        this.pool.push(worker);
+    }
+}
+async function createWorker() {
+    return new Worker(await _class_private_method_get(this, _getWorkerURL, getWorkerURL).call(this), {
+        name: `worker-${(0, _nonsecure.nanoid)()}`
+    });
+}
+async function getWorkerURL() {
+    if (_class_private_field_get(this, _workerSourceURL)) {
+        return _class_private_field_get(this, _workerSourceURL);
+    }
+    const blob = await fetch(_class_private_field_get(this, _url)).then(async (response)=>response.blob()).then(URL.createObjectURL.bind(URL));
+    _class_private_field_set(this, _workerSourceURL, blob);
+    return blob;
+}
+
+//# sourceMappingURL=WebWorkerPool.js.map

package/dist/cjs/webworker/pool/WebWorkerPool.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webworker/pool/WebWorkerPool.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport {\n  WebWorkerParentPostMessageStream,\n  WindowPostMessageStream,\n} from '@metamask/post-message-stream';\nimport { logError } from '@metamask/snaps-utils';\nimport type { JsonRpcRequest } from '@metamask/utils';\nimport { assert } from '@metamask/utils';\nimport { nanoid } from 'nanoid/non-secure';\n\ntype ExecutorJob = {\n  id: string;\n  worker: Worker;\n  stream: WebWorkerParentPostMessageStream;\n};\n\n/**\n * A snap executor using the WebWorker API.\n *\n * This is not a traditional snap executor, as it does not execute snaps itself.\n * Instead, it creates a pool of webworkers for each snap execution, and sends\n * the snap execution request to the webworker. The webworker is responsible for\n * executing the snap.\n */\nexport class WebWorkerPool {\n  readonly #poolSize;\n\n  readonly #stream: BasePostMessageStream;\n\n  readonly #url: string;\n\n  readonly pool: Worker[] = [];\n\n  readonly jobs: Map<string, ExecutorJob> = new Map();\n\n  #workerSourceURL?: string;\n\n  /* istanbul ignore next - Constructor arguments. */\n  static initialize(\n    stream: BasePostMessageStream = new WindowPostMessageStream({\n      name: 'child',\n      target: 'parent',\n      targetWindow: self.parent,\n      targetOrigin: '*',\n    }),\n    url = '../executor/bundle.js',\n    poolSize?: number,\n  ) {\n    return new WebWorkerPool(stream, url, poolSize);\n  }\n\n  constructor(stream: BasePostMessageStream, url: string, poolSize = 3) {\n    this.#stream = stream;\n    this.#url = url;\n    this.#poolSize = poolSize;\n\n    this.#stream.on('data', this.#onData.bind(this));\n  }\n\n  /**\n   * Handle an incoming message from the `WebWorkerExecutionService`. 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    const job = this.jobs.get(jobId);\n    if (!job) {\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.toString());\n\n          this.#stream.write({\n            jobId,\n            data: {\n              name: 'command',\n              data: {\n                jsonrpc: '2.0',\n                id: request.id ?? null,\n                error: {\n                  code: -32000,\n                  message: 'Internal error',\n                },\n              },\n            },\n          });\n        });\n\n      return;\n    }\n\n    // This is a method specific to the `WebWorkerPool`, as the service itself\n    // does not have access to the workers directly.\n    if (request.method === 'terminateJob') {\n      this.#terminateJob(jobId);\n      return;\n    }\n\n    job.stream.write(request);\n  }\n\n  /**\n   * Create a new worker and set up a stream to communicate with it.\n   *\n   * @param jobId - The job ID.\n   * @returns The job.\n   */\n  async #initializeJob(jobId: string): Promise<ExecutorJob> {\n    const worker = await this.#getWorker();\n    const jobStream = new WebWorkerParentPostMessageStream({\n      worker,\n    });\n\n    // Write messages from the worker to the parent, wrapped with the job ID.\n    jobStream.on('data', (data) => {\n      this.#stream.write({ data, jobId });\n    });\n\n    const job = { id: jobId, worker, stream: jobStream };\n    this.jobs.set(jobId, job);\n    return job;\n  }\n\n  /**\n   * Terminate the job with the given ID. This will close the worker and delete\n   * the job from the internal job map.\n   *\n   * @param jobId - The job ID.\n   */\n  #terminateJob(jobId: string) {\n    const job = this.jobs.get(jobId);\n    assert(job, `Job \"${jobId}\" not found.`);\n\n    job.stream.destroy();\n    job.worker.terminate();\n\n    this.jobs.delete(jobId);\n  }\n\n  /**\n   * Get a worker from the pool. A new worker will be created automatically.\n   *\n   * @returns The worker.\n   */\n  async #getWorker() {\n    // Lazily create the pool of workers.\n    if (this.pool.length === 0) {\n      await this.#updatePool();\n    }\n\n    const worker = this.pool.shift();\n    assert(worker, 'Worker not found.');\n\n    await this.#updatePool();\n\n    return worker;\n  }\n\n  /**\n   * Update the pool of workers. This will create new workers if the pool is\n   * below the minimum size.\n   */\n  async #updatePool() {\n    while (this.pool.length < this.#poolSize) {\n      const worker = await this.#createWorker();\n      this.pool.push(worker);\n    }\n  }\n\n  /**\n   * Create a new worker. This will fetch the worker source if it has not\n   * already been fetched.\n   *\n   * @returns The worker.\n   */\n  async #createWorker() {\n    return new Worker(await this.#getWorkerURL(), {\n      name: `worker-${nanoid()}`,\n    });\n  }\n\n  /**\n   * Get the URL of the worker source. This will fetch the worker source if it\n   * has not already been fetched.\n   *\n   * @returns The worker source URL, as a `blob:` URL.\n   */\n  async #getWorkerURL() {\n    if (this.#workerSourceURL) {\n      return this.#workerSourceURL;\n    }\n\n    const blob = await fetch(this.#url)\n      .then(async (response) => response.blob())\n      .then(URL.createObjectURL.bind(URL));\n\n    this.#workerSourceURL = blob;\n    return blob;\n  }\n}\n"],"names":["WebWorkerPool","initialize","stream","WindowPostMessageStream","name","target","targetWindow","self","parent","targetOrigin","url","poolSize","constructor","pool","jobs","Map","on","onData","bind","data","jobId","request","job","get","initializeJob","then","catch","error","logError","toString","write","jsonrpc","id","code","message","method","terminateJob","worker","getWorker","jobStream","WebWorkerParentPostMessageStream","set","assert","destroy","terminate","delete","length","updatePool","shift","createWorker","push","Worker","getWorkerURL","nanoid","workerSourceURL","blob","fetch","response","URL","createObjectURL"],"mappings":"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"}

package/dist/cjs/webworker/pool/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _lockdownevents = require("../../common/lockdown/lockdown-events");
+const _lockdownmore = require("../../common/lockdown/lockdown-more");
+const _WebWorkerPool = require("./WebWorkerPool");
+// Lockdown is already applied in LavaMoat
+(0, _lockdownmore.executeLockdownMore)();
+(0, _lockdownevents.executeLockdownEvents)();
+_WebWorkerPool.WebWorkerPool.initialize();
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/webworker/pool/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webworker/pool/index.ts"],"sourcesContent":["import { executeLockdownEvents } from '../../common/lockdown/lockdown-events';\nimport { executeLockdownMore } from '../../common/lockdown/lockdown-more';\nimport { WebWorkerPool } from './WebWorkerPool';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\nexecuteLockdownEvents();\n\nWebWorkerPool.initialize();\n"],"names":["executeLockdownMore","executeLockdownEvents","WebWorkerPool","initialize"],"mappings":";;;;gCAAsC;8BACF;+BACN;AAE9B,0CAA0C;AAC1CA,IAAAA,iCAAmB;AACnBC,IAAAA,qCAAqB;AAErBC,4BAAa,CAACC,UAAU"}