@metamask/snaps-execution-environments 1.0.2 → 2.0.1

package/dist/esm/offscreen/OffscreenSnapExecutor.js

@@ -0,0 +1,176 @@
+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;
+}
+import { WindowPostMessageStream } from '@metamask/post-message-stream';
+import { createWindow, logError } from '@metamask/snaps-utils';
+import { assert } from '@metamask/utils';
+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();
+/**
+ * A snap executor using the Offscreen Documents API.
+ *
+ * This is not a traditional snap executor, as it does not execute snaps itself.
+ * Instead, it creates an iframe window for each snap execution, and sends the
+ * snap execution request to the iframe window. The iframe window is responsible
+ * for executing the snap.
+ *
+ * Extensions can only have a single offscreen document, so this executor is
+ * persisted between snap executions. The offscreen snap executor essentially
+ * acts as a proxy between the extension and the iframe execution environment.
+ *
+ * @see https://developer.chrome.com/docs/extensions/reference/offscreen/
+ */ export 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)=>{
+            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 createWindow(frameUrl, jobId);
+    const jobStream = new 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) {
+    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];
+}
+
+//# sourceMappingURL=OffscreenSnapExecutor.js.map

package/dist/esm/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":["WindowPostMessageStream","createWindow","logError","assert","OffscreenSnapExecutor","initialize","stream","constructor","jobs","on","onData","bind","data","jobId","extra","frameUrl","request","initializeJob","then","catch","error","method","terminateJob","write","window","jobStream","name","target","targetWindow","targetOrigin","id","iframe","document","getElementById","remove","destroy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAASA,uBAAuB,QAAQ,gCAAgC;AACxE,SAASC,YAAY,EAAEC,QAAQ,QAAQ,wBAAwB;AAE/D,SAASC,MAAM,QAAQ,kBAAkB;IAuB9B,uCAoBT;;;;;;;;;;GAUC,GACD,uCA0CM,8CAkBN;;;;;GAKC,GACD;AAhHF;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMC;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;YACNlB,SAAS,oCAAoCkB;QAC/C;QAEF;IACF;IAEA,2EAA2E;IAC3E,uDAAuD;IACvD,IAAIJ,QAAQK,MAAM,KAAK,gBAAgB;QACrC,0BAAA,IAAI,EAAEC,eAAAA,mBAAN,IAAI,EAAeT;QACnB;IACF;IAEA,IAAI,CAACL,IAAI,CAACK,MAAM,CAACP,MAAM,CAACiB,KAAK,CAACP;AAChC;AAQA,eAAA,cAAqBH,KAAa,EAAEE,QAAgB;IAClD,MAAMS,SAAS,MAAMvB,aAAac,UAAUF;IAC5C,MAAMY,YAAY,IAAIzB,wBAAwB;QAC5C0B,MAAM;QACNC,QAAQ;QACRC,cAAcJ;QACdK,cAAc;IAChB;IAEA,yEAAyE;IACzEJ,UAAUhB,EAAE,CAAC,QAAQ,CAACG;QACpB,yBAAA,IAAI,EAAEN,SAAOiB,KAAK,CAAC;YAAEX;YAAMC;QAAM;IACnC;IAEA,IAAI,CAACL,IAAI,CAACK,MAAM,GAAG;QAAEiB,IAAIjB;QAAOW;QAAQlB,QAAQmB;IAAU;IAC1D,OAAO,IAAI,CAACjB,IAAI,CAACK,MAAM;AACzB;AAQA,SAAA,aAAcA,KAAa;IACzBV,OAAO,IAAI,CAACK,IAAI,CAACK,MAAM,EAAE,CAAC,KAAK,EAAEA,MAAM,YAAY,CAAC;IAEpD,MAAMkB,SAASC,SAASC,cAAc,CAACpB;IACvCV,OAAO4B,QAAQ,CAAC,gBAAgB,EAAElB,MAAM,YAAY,CAAC;IAErDkB,OAAOG,MAAM;IACb,IAAI,CAAC1B,IAAI,CAACK,MAAM,CAACP,MAAM,CAAC6B,OAAO;IAC/B,OAAO,IAAI,CAAC3B,IAAI,CAACK,MAAM;AACzB"}

package/dist/esm/offscreen/index.js

@@ -0,0 +1,15 @@
+import { BrowserRuntimePostMessageStream } from '@metamask/post-message-stream';
+import { executeLockdownEvents } from '../common/lockdown/lockdown-events';
+import { executeLockdownMore } from '../common/lockdown/lockdown-more';
+import { OffscreenSnapExecutor } from './OffscreenSnapExecutor';
+// Lockdown is already applied in LavaMoat
+executeLockdownMore();
+executeLockdownEvents();
+// The stream from the offscreen document to the execution service.
+const parentStream = new BrowserRuntimePostMessageStream({
+    name: 'child',
+    target: 'parent'
+});
+OffscreenSnapExecutor.initialize(parentStream);
+
+//# sourceMappingURL=index.js.map

package/dist/esm/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":["BrowserRuntimePostMessageStream","executeLockdownEvents","executeLockdownMore","OffscreenSnapExecutor","parentStream","name","target","initialize"],"mappings":"AAAA,SAASA,+BAA+B,QAAQ,gCAAgC;AAEhF,SAASC,qBAAqB,QAAQ,qCAAqC;AAC3E,SAASC,mBAAmB,QAAQ,mCAAmC;AACvE,SAASC,qBAAqB,QAAQ,0BAA0B;AAEhE,0CAA0C;AAC1CD;AACAD;AAEA,mEAAmE;AACnE,MAAMG,eAAe,IAAIJ,gCAAgC;IACvDK,MAAM;IACNC,QAAQ;AACV;AAEAH,sBAAsBI,UAAU,CAACH"}

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

@@ -0,0 +1,30 @@
+import ObjectMultiplex from '@metamask/object-multiplex';
+import { WebWorkerPostMessageStream } from '@metamask/post-message-stream';
+import { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';
+import { pipeline } from 'stream';
+import { BaseSnapExecutor } from '../../common/BaseSnapExecutor';
+import { log } from '../../logging';
+export class WebWorkerSnapExecutor extends 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 WebWorkerPostMessageStream()) {
+        log('Worker: Connecting to parent.');
+        const mux = new ObjectMultiplex();
+        pipeline(stream, mux, stream, (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 WebWorkerSnapExecutor(commandStream, rpcStream);
+    }
+}
+
+//# sourceMappingURL=WebWorkerSnapExecutor.js.map

package/dist/esm/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":["ObjectMultiplex","WebWorkerPostMessageStream","logError","SNAP_STREAM_NAMES","pipeline","BaseSnapExecutor","log","WebWorkerSnapExecutor","initialize","stream","mux","error","self","close","commandStream","createStream","COMMAND","rpcStream","JSON_RPC"],"mappings":"AAAA,OAAOA,qBAAqB,6BAA6B;AAEzD,SAASC,0BAA0B,QAAQ,gCAAgC;AAC3E,SAASC,QAAQ,EAAEC,iBAAiB,QAAQ,wBAAwB;AACpE,SAASC,QAAQ,QAAQ,SAAS;AAElC,SAASC,gBAAgB,QAAQ,gCAAgC;AACjE,SAASC,GAAG,QAAQ,gBAAgB;AAEpC,OAAO,MAAMC,8BAA8BF;IACzC;;;;;;;GAOC,GACD,OAAOG,WACLC,SAAgC,IAAIR,4BAA4B,EAChE;QACAK,IAAI;QAEJ,MAAMI,MAAM,IAAIV;QAChBI,SAASK,QAAQC,KAAKD,QAAQ,CAACE;YAC7B,IAAIA,OAAO;gBACTT,SAAS,CAAC,sCAAsC,CAAC,EAAES;YACrD;YACAC,KAAKC,KAAK;QACZ;QAEA,MAAMC,gBAAgBJ,IAAIK,YAAY,CAACZ,kBAAkBa,OAAO;QAChE,MAAMC,YAAYP,IAAIK,YAAY,CAACZ,kBAAkBe,QAAQ;QAE7D,OAAO,IAAIX,sBAAsBO,eAAeG;IAClD;AACF"}

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

@@ -0,0 +1,9 @@
+import { executeLockdownEvents } from '../../common/lockdown/lockdown-events';
+import { executeLockdownMore } from '../../common/lockdown/lockdown-more';
+import { WebWorkerSnapExecutor } from './WebWorkerSnapExecutor';
+// Lockdown is already applied in LavaMoat
+executeLockdownMore();
+executeLockdownEvents();
+WebWorkerSnapExecutor.initialize();
+
+//# sourceMappingURL=index.js.map

package/dist/esm/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":["executeLockdownEvents","executeLockdownMore","WebWorkerSnapExecutor","initialize"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ,wCAAwC;AAC9E,SAASC,mBAAmB,QAAQ,sCAAsC;AAC1E,SAASC,qBAAqB,QAAQ,0BAA0B;AAEhE,0CAA0C;AAC1CD;AACAD;AAEAE,sBAAsBC,UAAU"}

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

@@ -0,0 +1,245 @@
+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;
+}
+import { WebWorkerParentPostMessageStream, WindowPostMessageStream } from '@metamask/post-message-stream';
+import { logError } from '@metamask/snaps-utils';
+import { assert } from '@metamask/utils';
+import { nanoid } from 'nanoid/non-secure';
+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();
+/**
+ * A snap executor using the WebWorker API.
+ *
+ * This is not a traditional snap executor, as it does not execute snaps itself.
+ * Instead, it creates a pool of webworkers for each snap execution, and sends
+ * the snap execution request to the webworker. The webworker is responsible for
+ * executing the snap.
+ */ export class WebWorkerPool {
+    /* istanbul ignore next - Constructor arguments. */ static initialize(stream = new 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)=>{
+            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 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);
+    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();
+    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-${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/esm/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":["WebWorkerParentPostMessageStream","WindowPostMessageStream","logError","assert","nanoid","WebWorkerPool","initialize","stream","name","target","targetWindow","self","parent","targetOrigin","url","poolSize","constructor","pool","jobs","Map","on","onData","bind","data","jobId","request","job","get","initializeJob","then","catch","error","toString","write","jsonrpc","id","code","message","method","terminateJob","worker","getWorker","jobStream","set","destroy","terminate","delete","length","updatePool","shift","createWorker","push","Worker","getWorkerURL","workerSourceURL","blob","fetch","response","URL","createObjectURL"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import { executeLockdownEvents } from '../../common/lockdown/lockdown-events';
+import { executeLockdownMore } from '../../common/lockdown/lockdown-more';
+import { WebWorkerPool } from './WebWorkerPool';
+// Lockdown is already applied in LavaMoat
+executeLockdownMore();
+executeLockdownEvents();
+WebWorkerPool.initialize();
+
+//# sourceMappingURL=index.js.map

package/dist/esm/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":["executeLockdownEvents","executeLockdownMore","WebWorkerPool","initialize"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ,wCAAwC;AAC9E,SAASC,mBAAmB,QAAQ,sCAAsC;AAC1E,SAASC,aAAa,QAAQ,kBAAkB;AAEhD,0CAA0C;AAC1CD;AACAD;AAEAE,cAAcC,UAAU"}

package/dist/{common → types/common}/BaseSnapExecutor.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 /// <reference types="ses" />
-import { HandlerType, SnapExportsParameters } from '@metamask/snaps-utils';
-import { JsonRpcNotification, JsonRpcId, Json } from '@metamask/utils';
-import { Duplex } from 'stream';
+import type { HandlerType, SnapExportsParameters } from '@metamask/snaps-utils';
+import type { JsonRpcNotification, JsonRpcId, Json } from '@metamask/utils';
+import type { Duplex } from 'stream';
 export declare type InvokeSnapArgs = Omit<SnapExportsParameters[0], 'chainId'>;
 export declare type InvokeSnap = (target: string, handler: HandlerType, args: InvokeSnapArgs | undefined) => Promise<Json>;
 export declare class BaseSnapExecutor {
@@ -22,11 +22,11 @@ export declare class BaseSnapExecutor {
      * Attempts to evaluate a snap in SES. Generates APIs for the snap. May throw
      * on errors.
      *
-     * @param snapName - The name of the snap.
+     * @param snapId - The id of the snap.
      * @param sourceCode - The source code of the snap, in IIFE format.
      * @param _endowments - An array of the names of the endowments.
      */
-    protected startSnap(snapName: string, sourceCode: string, _endowments?: string[]): Promise<void>;
+    protected startSnap(snapId: string, sourceCode: string, _endowments?: string[]): Promise<void>;
     /**
      * Cancels all running evaluations of all snaps and clears all snap data.
      * NOTE:** Should only be called in response to the `terminate` RPC command.
@@ -50,7 +50,7 @@ export declare class BaseSnapExecutor {
     /**
      * Removes the snap with the given name.
      *
-     * @param snapName - The name of the snap to remove.
+     * @param snapId - The id of the snap to remove.
      */
     private removeSnap;
     /**
@@ -59,7 +59,7 @@ export declare class BaseSnapExecutor {
      * counted as an evaluation of the specified snap. When the count of running
      * evaluations of a snap reaches zero, its endowments are torn down.
      *
-     * @param snapName - The name of the snap whose context to execute in.
+     * @param snapId - The id of the snap whose context to execute in.
      * @param executor - The function that will be executed in the snap's context.
      * @returns The executor's return value.
      * @template Result - The return value of the executor.

package/dist/{common → types/common}/commands.d.ts

@@ -1,6 +1,6 @@
 import { HandlerType } from '@metamask/snaps-utils';
-import { InvokeSnap, InvokeSnapArgs } from './BaseSnapExecutor';
-import { ExecuteSnap, JsonRpcRequestWithoutId, Ping, SnapRpc, Terminate } from './validation';
+import type { InvokeSnap, InvokeSnapArgs } from './BaseSnapExecutor';
+import type { ExecuteSnap, JsonRpcRequestWithoutId, Ping, SnapRpc, Terminate } from './validation';
 export declare type CommandMethodsMapping = {
     ping: Ping;
     terminate: Terminate;

package/dist/{common → types/common}/endowments/commonEndowmentFactory.d.ts

@@ -1,6 +1,10 @@
+import type { SnapId } from '@metamask/snaps-utils';
+export declare type EndowmentFactoryOptions = {
+    snapId?: SnapId;
+};
 export declare type EndowmentFactory = {
     names: readonly string[];
-    factory: () => {
+    factory: (options?: EndowmentFactoryOptions) => {
         [key: string]: unknown;
     };
 };