@metamask/snaps-execution-environments 4.0.0 → 5.0.0

package/dist/browserify/worker-pool/index.html

@@ -12741,8 +12741,207 @@ module.exports = {
   })()
   return module.exports
 })()
+    const { scuttle } = // define scuttle
+(function(){
+  const global = globalRef
+  const exports = {}
+  const module = { exports }
+  ;(function(){
+// START of injected code from scuttle
+/**
+ * @typedef {object} ScuttleOpts
+ * @property {boolean} enabled - Whether scuttling is enabled or not.
+ * @property {Array<string|RegExp>} exceptions - List of properties to exclude from scuttling.
+ * @property {string} scuttlerName - Name of the scuttler function to use which is expected to be found as a
+ * property on the global object (e.g. if scuttlerName is 'x', scuttler function is obtained from globalThis['x']).
+ */
+
+/**
+ * @typedef {object} GlobalRef
+ * @property {Record<string, any>} [globalThis] - Reference to the global object.
+ */
+
+const { Object, Array, Error, RegExp, Set, console, Proxy, Reflect } =
+  globalThis
+
+const {
+  assign,
+  getOwnPropertyNames,
+  getOwnPropertyDescriptor,
+  create,
+  defineProperty,
+} = Object
+
+const { isArray, from } = Array
+
+const { getPrototypeOf } = Reflect
+
+const { warn } = console
+
+function generateInvokers(prop) {
+  return { get, set }
+  function set() {
+    warn(
+      `LavaMoat - property "${prop}" of globalThis cannot be set under scuttling mode. ` +
+        'To learn more visit https://github.com/LavaMoat/LavaMoat/pull/360.'
+    )
+  }
+  function get() {
+    throw new Error(
+      `LavaMoat - property "${prop}" of globalThis is inaccessible under scuttling mode. ` +
+        'To learn more visit https://github.com/LavaMoat/LavaMoat/pull/360.'
+    )
+  }
+}
+
+/**
+ * Applies scuttling, with the default set of options, including using Snow if passed in as scuttlerFunc.
+ * Scuttle globalThis right after we used it to create the root package compartment.
+ *
+ * @param {GlobalRef} globalRef - Reference to the global object.
+ * @param {ScuttleOpts} opts - Scuttling options.
+ */
+function scuttle(globalRef, opts) {
+  const scuttleOpts = generateScuttleOpts(globalRef, opts)
+
+  if (scuttleOpts.enabled) {
+    if (!isArray(scuttleOpts.exceptions)) {
+      throw new Error(
+        `LavaMoat - exceptions must be an array, got ${typeof scuttleOpts.exceptions}`
+      )
+    }
+    scuttleOpts.scuttlerFunc(globalRef, (realm) =>
+      performScuttleGlobalThis(realm, scuttleOpts.exceptions)
+    )
+  }
+}
+
+/**
+ * @param {GlobalRef} globalRef - Reference to the global object.
+ * @param {ScuttleOpts|boolean} originalOpts - Scuttling options. Accepts `true` for backwards compatibility.
+ * @returns {ScuttleOpts} - Final scuttling options.
+ */
+function generateScuttleOpts(globalRef, originalOpts = create(null)) {
+  const defaultOpts = {
+    enabled: true,
+    exceptions: [],
+    scuttlerName: '',
+  }
+  const opts = assign(
+    create(null),
+    originalOpts === true ? defaultOpts : originalOpts,
+    {
+      scuttlerFunc: (globalRef, scuttle) => scuttle(globalRef),
+    },
+    {
+      exceptions: (originalOpts?.exceptions || defaultOpts.exceptions).map(
+        (e) => toRE(e)
+      ),
+    }
+  )
+  if (opts.scuttlerName) {
+    if (!globalRef[opts.scuttlerName]) {
+      throw new Error(
+        `LavaMoat - 'scuttlerName' function "${opts.scuttlerName}" expected on globalRef.` +
+          'To learn more visit https://github.com/LavaMoat/LavaMoat/pull/462.'
+      )
+    }
+    opts.scuttlerFunc = globalRef[opts.scuttlerName]
+  }
+  return opts
+
+  /**
+   * @param {string|RegExp} except - Exception to convert to RegExp.
+   * @returns {string|RegExp} - Converted exception.
+   */
+  function toRE(except) {
+    // turn scuttleGlobalThis.exceptions regexes strings to actual regexes
+    if (!except.startsWith('/')) {
+      return except
+    }
+    const parts = except.split('/')
+    const pattern = parts.slice(1, -1).join('/')
+    const flags = parts[parts.length - 1]
+    return new RegExp(pattern, flags)
+  }
+}
+
+/**
+ * Runs scuttling on the globalRef. Use applyDefaultScuttling for full scope of options.
+ *
+ * @param {GlobalRef} globalRef - Reference to the global object.
+ * @param {Array<string|RegExp>} extraPropsToAvoid - List of additional properties to exclude from scuttling beyond the default ones.
+ */
+function performScuttleGlobalThis(globalRef, extraPropsToAvoid = []) {
+  const props = []
+  getPrototypeChain(globalRef).forEach((proto) =>
+    props.push(...getOwnPropertyNames(proto))
+  )
+
+  // support LM,SES exported APIs and polyfills
+  const avoidForLavaMoatCompatibility = ['Compartment', 'Error', 'globalThis']
+  const propsToAvoid = new Set([
+    ...avoidForLavaMoatCompatibility,
+    ...extraPropsToAvoid,
+  ])
+
+  const obj = create(null)
+  props.forEach((prop) => {
+    const { get, set } = generateInvokers(prop)
+    if (shouldAvoidProp(propsToAvoid, prop)) {
+      return
+    }
+    let desc = getOwnPropertyDescriptor(globalRef, prop)
+    if (desc?.configurable === true) {
+      desc = { configurable: false, set, get }
+    } else if (desc?.writable === true) {
+      const p = new Proxy(obj, { getPrototypeOf: get, get, set })
+      desc = { configurable: false, writable: false, value: p }
+    } else {
+      return
+    }
+    defineProperty(globalRef, prop, desc)
+  })
+}
+
+/**
+ * @param {Set<string|RegExp>} propsToAvoid - List of properties to exclude from scuttling.
+ * @param {string} prop - Property to check.
+ * @returns {boolean} - Whether the property should be avoided or not.
+ */
+const shouldAvoidProp = (propsToAvoid, prop) =>
+  from(propsToAvoid).some(
+    (avoid) =>
+      (typeof avoid === 'string' && avoid === prop) ||
+      (avoid instanceof RegExp && avoid.test(prop))
+  )
+
+/**
+ * @param {object} value - object to get the prototype chain from.
+ * @returns {Array<object>} - Prototype chain as an array.
+ */
+function getPrototypeChain(value) {
+  const protoChain = []
+  let current = value
+  while (current) {
+    if (typeof current !== 'object' && typeof current !== 'function') {
+      break
+    }
+    protoChain.push(current)
+    current = getPrototypeOf(current)
+  }
+  return protoChain
+}
+
+module.exports = {
+  scuttle,
+}
+
+// END of injected code from scuttle
+  })()
+  return module.exports
+})()
 
-    const scuttleOpts = generateScuttleOpts(scuttleGlobalThis)
     const moduleCache = new Map()
     const packageCompartmentCache = new Map()
     const globalStore = new Map()
@@ -12750,13 +12949,7 @@ module.exports = {
     const rootPackageName = '$root$'
     const rootPackageCompartment = createRootPackageCompartment(globalRef)
 
-    // scuttle globalThis right after we used it to create the root package compartment
-    if (scuttleOpts.enabled) {
-      if (!Array.isArray(scuttleOpts.exceptions)) {
-        throw new Error(`LavaMoat - scuttleGlobalThis.exceptions must be an array, got "${typeof scuttleOpts.exceptions}"`)
-      }
-      scuttleOpts.scuttlerFunc(globalRef, realm => performScuttleGlobalThis(realm, scuttleOpts.exceptions))
-    }
+    scuttle(globalRef, scuttleGlobalThis)
 
     const kernel = {
       internalRequire,
@@ -12768,85 +12961,6 @@ module.exports = {
     Object.freeze(kernel)
     return kernel
 
-    // generate final scuttling options (1) by taking default
-    // options into consideration, (2) turning RE strings into
-    // actual REs and (3) without mutating original opts object
-    function generateScuttleOpts(originalOpts) {
-      const defaultOpts = {
-        enabled: true,
-        exceptions: [],
-        scuttlerName: '',
-      }
-      const opts = Object.assign({},
-        originalOpts === true ? { ... defaultOpts } : { ...originalOpts },
-        { scuttlerFunc: (globalRef, scuttle) => scuttle(globalRef) },
-        { exceptions: (originalOpts.exceptions || defaultOpts.exceptions).map(e => toRE(e)) },
-      )
-      if (opts.scuttlerName) {
-        if (!globalRef[opts.scuttlerName]) {
-          throw new Error(
-            `LavaMoat - 'scuttlerName' function "${opts.scuttlerName}" expected on globalRef.` +
-            'To learn more visit https://github.com/LavaMoat/LavaMoat/pull/462.',
-          )
-        }
-        opts.scuttlerFunc = globalRef[opts.scuttlerName]
-      }
-      return opts
-
-      function toRE(except) {
-        // turn scuttleGlobalThis.exceptions regexes strings to actual regexes
-        if (!except.startsWith('/')) {
-          return except
-        }
-        const parts = except.split('/')
-        const pattern = parts.slice(1, -1).join('/')
-        const flags = parts[parts.length - 1]
-        return new RegExp(pattern, flags)
-      }
-    }
-
-    function performScuttleGlobalThis (globalRef, extraPropsToAvoid = []) {
-      const props = []
-      getPrototypeChain(globalRef)
-        .forEach(proto =>
-          props.push(...Object.getOwnPropertyNames(proto)))
-
-      // support LM,SES exported APIs and polyfills
-      const avoidForLavaMoatCompatibility = ['Compartment', 'Error', 'globalThis']
-      const propsToAvoid = new Set([...avoidForLavaMoatCompatibility, ...extraPropsToAvoid])
-
-      const obj = Object.create(null)
-      for (const prop of props) {
-        // eslint-disable-next-line no-inner-declarations
-        function set() {
-          console.warn(
-            `LavaMoat - property "${prop}" of globalThis cannot be set under scuttling mode. ` +
-            'To learn more visit https://github.com/LavaMoat/LavaMoat/pull/360.',
-          )
-        }
-        // eslint-disable-next-line no-inner-declarations
-        function get() {
-          throw new Error(
-            `LavaMoat - property "${prop}" of globalThis is inaccessible under scuttling mode. ` +
-            'To learn more visit https://github.com/LavaMoat/LavaMoat/pull/360.',
-          )
-        }
-        if (shouldAvoidProp(propsToAvoid, prop)) {
-          continue
-        }
-        let desc = Object.getOwnPropertyDescriptor(globalRef, prop)
-        if (desc?.configurable === true) {
-          desc = { configurable: false, set, get }
-        } else if (desc?.writable === true) {
-          const p = new Proxy(obj, { getPrototypeOf: get, get, set } )
-          desc = { configurable: false, writable: false, value: p }
-        } else {
-          continue
-        }
-        Object.defineProperty(globalRef, prop, desc)
-      }
-    }
-
     // this function instantiaties a module from a moduleId.
     // 1. loads the module metadata and policy
     // 2. prepares the execution environment
@@ -13131,29 +13245,6 @@ module.exports = {
       return packageConfig
     }
 
-    // util for getting the prototype chain as an array
-    // includes the provided value in the result
-    function getPrototypeChain (value) {
-      const protoChain = []
-      let current = value
-      while (current && (typeof current === 'object' || typeof current === 'function')) {
-        protoChain.push(current)
-        current = Reflect.getPrototypeOf(current)
-      }
-      return protoChain
-    }
-
-    function shouldAvoidProp(propsToAvoid, prop) {
-      for (const avoid of propsToAvoid) {
-        if (avoid instanceof RegExp && avoid.test(prop)) {
-          return true
-        }
-        if (propsToAvoid.has(prop)) {
-          return true
-        }
-      }
-      return false
-    }
   }
 })()
 

package/dist/chunk-26EFJQDW.mjs

@@ -0,0 +1,49 @@
+// src/common/endowments/interval.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+var MINIMUM_INTERVAL = 10;
+var createInterval = () => {
+  const registeredHandles = /* @__PURE__ */ new Map();
+  const _setInterval = (handler, timeout) => {
+    if (typeof handler !== "function") {
+      throw rpcErrors.invalidInput(
+        `The interval handler must be a function. Received: ${typeof handler}.`
+      );
+    }
+    harden(handler);
+    const handle = Object.freeze(/* @__PURE__ */ Object.create(null));
+    const platformHandle = setInterval(
+      handler,
+      Math.max(MINIMUM_INTERVAL, timeout ?? 0)
+    );
+    registeredHandles.set(handle, platformHandle);
+    return handle;
+  };
+  const _clearInterval = (handle) => {
+    harden(handle);
+    const platformHandle = registeredHandles.get(handle);
+    if (platformHandle !== void 0) {
+      clearInterval(platformHandle);
+      registeredHandles.delete(handle);
+    }
+  };
+  const teardownFunction = () => {
+    for (const handle of registeredHandles.keys()) {
+      _clearInterval(handle);
+    }
+  };
+  return {
+    setInterval: harden(_setInterval),
+    clearInterval: harden(_clearInterval),
+    teardownFunction
+  };
+};
+var endowmentModule = {
+  names: ["setInterval", "clearInterval"],
+  factory: createInterval
+};
+var interval_default = endowmentModule;
+
+export {
+  interval_default
+};
+//# sourceMappingURL=chunk-26EFJQDW.mjs.map

package/dist/chunk-26EFJQDW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/interval.ts"],"sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\n\nconst MINIMUM_INTERVAL = 10;\n\n/**\n * Creates a pair of `setInterval` and `clearInterval` functions attenuated such\n * that:\n * - `setInterval` throws if its \"handler\" parameter is not a function.\n * - `clearInterval` only clears timeouts created by its sibling `setInterval`,\n * or else no-ops.\n *\n * @returns An object with the attenuated `setInterval` and `clearInterval`\n * functions.\n */\nconst createInterval = () => {\n  const registeredHandles = new Map<unknown, unknown>();\n\n  const _setInterval = (handler: TimerHandler, timeout?: number): unknown => {\n    if (typeof handler !== 'function') {\n      throw rpcErrors.invalidInput(\n        `The interval handler must be a function. Received: ${typeof handler}.`,\n      );\n    }\n    harden(handler);\n    const handle = Object.freeze(Object.create(null));\n    const platformHandle = setInterval(\n      handler,\n      Math.max(MINIMUM_INTERVAL, timeout ?? 0),\n    );\n    registeredHandles.set(handle, platformHandle);\n    return handle;\n  };\n\n  const _clearInterval = (handle: unknown): void => {\n    harden(handle);\n    const platformHandle = registeredHandles.get(handle);\n    if (platformHandle !== undefined) {\n      clearInterval(platformHandle as any);\n      registeredHandles.delete(handle);\n    }\n  };\n\n  const teardownFunction = (): void => {\n    for (const handle of registeredHandles.keys()) {\n      _clearInterval(handle);\n    }\n  };\n\n  return {\n    setInterval: harden(_setInterval),\n    clearInterval: harden(_clearInterval),\n    teardownFunction,\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['setInterval', 'clearInterval'] as const,\n  factory: createInterval,\n};\nexport default endowmentModule;\n"],"mappings":";AAAA,SAAS,iBAAiB;AAE1B,IAAM,mBAAmB;AAYzB,IAAM,iBAAiB,MAAM;AAC3B,QAAM,oBAAoB,oBAAI,IAAsB;AAEpD,QAAM,eAAe,CAAC,SAAuB,YAA8B;AACzE,QAAI,OAAO,YAAY,YAAY;AACjC,YAAM,UAAU;AAAA,QACd,sDAAsD,OAAO,OAAO;AAAA,MACtE;AAAA,IACF;AACA,WAAO,OAAO;AACd,UAAM,SAAS,OAAO,OAAO,uBAAO,OAAO,IAAI,CAAC;AAChD,UAAM,iBAAiB;AAAA,MACrB;AAAA,MACA,KAAK,IAAI,kBAAkB,WAAW,CAAC;AAAA,IACzC;AACA,sBAAkB,IAAI,QAAQ,cAAc;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,CAAC,WAA0B;AAChD,WAAO,MAAM;AACb,UAAM,iBAAiB,kBAAkB,IAAI,MAAM;AACnD,QAAI,mBAAmB,QAAW;AAChC,oBAAc,cAAqB;AACnC,wBAAkB,OAAO,MAAM;AAAA,IACjC;AAAA,EACF;AAEA,QAAM,mBAAmB,MAAY;AACnC,eAAW,UAAU,kBAAkB,KAAK,GAAG;AAC7C,qBAAe,MAAM;AAAA,IACvB;AAAA,EACF;AAEA,SAAO;AAAA,IACL,aAAa,OAAO,YAAY;AAAA,IAChC,eAAe,OAAO,cAAc;AAAA,IACpC;AAAA,EACF;AACF;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,eAAe,eAAe;AAAA,EACtC,SAAS;AACX;AACA,IAAO,mBAAQ;","names":[]}

package/dist/chunk-4NOF6TN6.js

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

package/dist/chunk-4NOF6TN6.js.map

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

package/dist/chunk-5DIRYAYO.js

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkL5U2LMZRjs = require('./chunk-L5U2LMZR.js');
+
+// src/common/globalEvents.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+function addEventListener(event, listener) {
+  if ("addEventListener" in _chunkL5U2LMZRjs.rootRealmGlobal && typeof _chunkL5U2LMZRjs.rootRealmGlobal.addEventListener === "function") {
+    return _chunkL5U2LMZRjs.rootRealmGlobal.addEventListener(event.toLowerCase(), listener);
+  }
+  if (_chunkL5U2LMZRjs.rootRealmGlobal.process && "on" in _chunkL5U2LMZRjs.rootRealmGlobal.process && typeof _chunkL5U2LMZRjs.rootRealmGlobal.process.on === "function") {
+    return _chunkL5U2LMZRjs.rootRealmGlobal.process.on(event, listener);
+  }
+  throw _rpcerrors.rpcErrors.internal("Platform agnostic addEventListener failed.");
+}
+function removeEventListener(event, listener) {
+  if ("removeEventListener" in _chunkL5U2LMZRjs.rootRealmGlobal && typeof _chunkL5U2LMZRjs.rootRealmGlobal.removeEventListener === "function") {
+    return _chunkL5U2LMZRjs.rootRealmGlobal.removeEventListener(event.toLowerCase(), listener);
+  }
+  if (_chunkL5U2LMZRjs.rootRealmGlobal.process && "removeListener" in _chunkL5U2LMZRjs.rootRealmGlobal.process && typeof _chunkL5U2LMZRjs.rootRealmGlobal.process.removeListener === "function") {
+    return _chunkL5U2LMZRjs.rootRealmGlobal.process.removeListener(event, listener);
+  }
+  throw new Error("Platform agnostic removeEventListener failed");
+}
+
+
+
+
+exports.addEventListener = addEventListener; exports.removeEventListener = removeEventListener;
+//# sourceMappingURL=chunk-5DIRYAYO.js.map

package/dist/chunk-5DIRYAYO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/globalEvents.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,iBAAiB;AAYnB,SAAS,iBACd,OACA,UACA;AACA,MACE,sBAAsB,mBACtB,OAAO,gBAAgB,qBAAqB,YAC5C;AACA,WAAO,gBAAgB,iBAAiB,MAAM,YAAY,GAAG,QAAQ;AAAA,EACvE;AAEA,MACE,gBAAgB,WAChB,QAAQ,gBAAgB,WACxB,OAAO,gBAAgB,QAAQ,OAAO,YACtC;AACA,WAAO,gBAAgB,QAAQ,GAAG,OAAO,QAAQ;AAAA,EACnD;AAEA,QAAM,UAAU,SAAS,4CAA4C;AACvE;AAUO,SAAS,oBACd,OACA,UACA;AACA,MACE,yBAAyB,mBACzB,OAAO,gBAAgB,wBAAwB,YAC/C;AACA,WAAO,gBAAgB,oBAAoB,MAAM,YAAY,GAAG,QAAQ;AAAA,EAC1E;AAEA,MACE,gBAAgB,WAChB,oBAAoB,gBAAgB,WACpC,OAAO,gBAAgB,QAAQ,mBAAmB,YAClD;AACA,WAAO,gBAAgB,QAAQ,eAAe,OAAO,QAAQ;AAAA,EAC/D;AAEA,QAAM,IAAI,MAAM,8CAA8C;AAChE","sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\n\nimport { rootRealmGlobal } from './globalObject';\n\n/**\n * Adds an event listener platform agnostically, trying both `globalThis.addEventListener` and `globalThis.process.on`\n *\n * @param event - The event to listen for.\n * @param listener - The listener to be triggered when the event occurs.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function addEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'addEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.addEventListener === 'function'\n  ) {\n    return rootRealmGlobal.addEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'on' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.on === 'function'\n  ) {\n    return rootRealmGlobal.process.on(event, listener);\n  }\n\n  throw rpcErrors.internal('Platform agnostic addEventListener failed.');\n}\n\n/**\n * Removes an event listener platform agnostically, trying both `globalThis.removeEventListener` and `globalThis.process.removeListener`\n *\n * @param event - The event to remove the listener for.\n * @param listener - The currently attached listener.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function removeEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'removeEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.removeEventListener === 'function'\n  ) {\n    return rootRealmGlobal.removeEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'removeListener' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.removeListener === 'function'\n  ) {\n    return rootRealmGlobal.process.removeListener(event, listener);\n  }\n\n  throw new Error('Platform agnostic removeEventListener failed');\n}\n"]}

package/dist/chunk-5RKYO2Y5.js

@@ -0,0 +1,33 @@
+"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/node-process/ChildProcessSnapExecutor.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 ChildProcessSnapExecutor = class _ChildProcessSnapExecutor extends _chunkL4G6IIWGjs.BaseSnapExecutor {
+  static initialize() {
+    _chunkXKY46YTJjs.log.call(void 0, "Worker: Connecting to parent.");
+    const parentStream = new (0, _postmessagestream.ProcessMessageStream)();
+    const mux = new (0, _objectmultiplex2.default)();
+    _readablestream.pipeline.call(void 0, parentStream, mux, parentStream, (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 _ChildProcessSnapExecutor(commandStream, rpcStream);
+  }
+};
+
+
+
+exports.ChildProcessSnapExecutor = ChildProcessSnapExecutor;
+//# sourceMappingURL=chunk-5RKYO2Y5.js.map

package/dist/chunk-5RKYO2Y5.js.map

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

package/dist/chunk-6GHFAQ54.mjs

@@ -0,0 +1,44 @@
+import {
+  rootRealmGlobal
+} from "./chunk-Y7IEFWZU.mjs";
+
+// src/common/endowments/date.ts
+function createDate() {
+  const keys = Object.getOwnPropertyNames(
+    rootRealmGlobal.Date
+  );
+  let currentTime = 0;
+  const now = () => {
+    const actual = rootRealmGlobal.Date.now();
+    const newTime = Math.round(actual + Math.random());
+    if (newTime > currentTime) {
+      currentTime = newTime;
+    }
+    return currentTime;
+  };
+  const NewDate = function(...args) {
+    return Reflect.construct(
+      rootRealmGlobal.Date,
+      args.length === 0 ? [now()] : args,
+      new.target
+    );
+  };
+  keys.forEach((key) => {
+    Reflect.defineProperty(NewDate, key, {
+      configurable: false,
+      writable: false,
+      value: key === "now" ? now : rootRealmGlobal.Date[key]
+    });
+  });
+  return { Date: harden(NewDate) };
+}
+var endowmentModule = {
+  names: ["Date"],
+  factory: createDate
+};
+var date_default = endowmentModule;
+
+export {
+  date_default
+};
+//# sourceMappingURL=chunk-6GHFAQ54.mjs.map

package/dist/chunk-6GHFAQ54.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/date.ts"],"sourcesContent":["import { rootRealmGlobal } from '../globalObject';\n\n/**\n * Creates a {@link Date} constructor, with most of the same properties as the global object.\n * The Date.now() function has added noise as to limit its precision and prevent potential timing attacks.\n * The Date constructor uses this now() function to seed itself if no arguments are given to the constructor.\n *\n * @returns A modified {@link Date} constructor with limited precision.\n */\nfunction createDate() {\n  const keys = Object.getOwnPropertyNames(\n    rootRealmGlobal.Date,\n  ) as (keyof typeof Date)[];\n\n  let currentTime = 0;\n  const now = () => {\n    const actual = rootRealmGlobal.Date.now();\n    const newTime = Math.round(actual + Math.random());\n    if (newTime > currentTime) {\n      currentTime = newTime;\n    }\n    return currentTime;\n  };\n\n  const NewDate = function (...args: unknown[]) {\n    return Reflect.construct(\n      rootRealmGlobal.Date,\n      args.length === 0 ? [now()] : args,\n      new.target,\n    );\n  } as DateConstructor;\n\n  keys.forEach((key) => {\n    Reflect.defineProperty(NewDate, key, {\n      configurable: false,\n      writable: false,\n      value: key === 'now' ? now : rootRealmGlobal.Date[key],\n    });\n  });\n\n  return { Date: harden(NewDate) };\n}\n\nconst endowmentModule = {\n  names: ['Date'] as const,\n  factory: createDate,\n};\n\nexport default endowmentModule;\n"],"mappings":";;;;;AASA,SAAS,aAAa;AACpB,QAAM,OAAO,OAAO;AAAA,IAClB,gBAAgB;AAAA,EAClB;AAEA,MAAI,cAAc;AAClB,QAAM,MAAM,MAAM;AAChB,UAAM,SAAS,gBAAgB,KAAK,IAAI;AACxC,UAAM,UAAU,KAAK,MAAM,SAAS,KAAK,OAAO,CAAC;AACjD,QAAI,UAAU,aAAa;AACzB,oBAAc;AAAA,IAChB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,YAAa,MAAiB;AAC5C,WAAO,QAAQ;AAAA,MACb,gBAAgB;AAAA,MAChB,KAAK,WAAW,IAAI,CAAC,IAAI,CAAC,IAAI;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AAEA,OAAK,QAAQ,CAAC,QAAQ;AACpB,YAAQ,eAAe,SAAS,KAAK;AAAA,MACnC,cAAc;AAAA,MACd,UAAU;AAAA,MACV,OAAO,QAAQ,QAAQ,MAAM,gBAAgB,KAAK,GAAG;AAAA,IACvD,CAAC;AAAA,EACH,CAAC;AAED,SAAO,EAAE,MAAM,OAAO,OAAO,EAAE;AACjC;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,MAAM;AAAA,EACd,SAAS;AACX;AAEA,IAAO,eAAQ;","names":[]}

package/dist/chunk-A7NJQLUA.mjs

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

package/dist/chunk-A7NJQLUA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/crypto.ts"],"sourcesContent":["import { rootRealmGlobal } from '../globalObject';\n\nexport const createCrypto = () => {\n  if (\n    'crypto' in rootRealmGlobal &&\n    typeof rootRealmGlobal.crypto === 'object' &&\n    'SubtleCrypto' in rootRealmGlobal &&\n    typeof rootRealmGlobal.SubtleCrypto === 'function'\n  ) {\n    return {\n      crypto: harden(rootRealmGlobal.crypto),\n      SubtleCrypto: harden(rootRealmGlobal.SubtleCrypto),\n    };\n  }\n  // For now, we expose the experimental webcrypto API for Node.js execution environments\n  // TODO: Figure out if this is enough long-term or if we should use a polyfill.\n  /* eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */\n  const crypto = require('crypto').webcrypto;\n  return {\n    crypto: harden(crypto),\n    SubtleCrypto: harden(crypto.subtle.constructor),\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['crypto', 'SubtleCrypto'] as const,\n  factory: createCrypto,\n};\nexport default endowmentModule;\n"],"mappings":";;;;;;;;AAEO,IAAM,eAAe,MAAM;AAChC,MACE,YAAY,mBACZ,OAAO,gBAAgB,WAAW,YAClC,kBAAkB,mBAClB,OAAO,gBAAgB,iBAAiB,YACxC;AACA,WAAO;AAAA,MACL,QAAQ,OAAO,gBAAgB,MAAM;AAAA,MACrC,cAAc,OAAO,gBAAgB,YAAY;AAAA,IACnD;AAAA,EACF;AAIA,QAAM,SAAS,UAAQ,QAAQ,EAAE;AACjC,SAAO;AAAA,IACL,QAAQ,OAAO,MAAM;AAAA,IACrB,cAAc,OAAO,OAAO,OAAO,WAAW;AAAA,EAChD;AACF;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,UAAU,cAAc;AAAA,EAChC,SAAS;AACX;AACA,IAAO,iBAAQ;","names":[]}