@metamask/snaps-execution-environments 0.24.0

package/dist/common/endowments/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConstructor = exports.createEndowments = void 0;
+const utils_1 = require("@metamask/utils");
+const globalObject_1 = require("../globalObject");
+const interval_1 = __importDefault(require("./interval"));
+const network_1 = __importDefault(require("./network"));
+const timeout_1 = __importDefault(require("./timeout"));
+const crypto_1 = __importDefault(require("./crypto"));
+const math_1 = __importDefault(require("./math"));
+/**
+ * A map of endowment names to their factory functions. Some endowments share
+ * the same factory function, but we only call each factory once for each snap.
+ * See {@link createEndowments} for details.
+ */
+const endowmentFactories = [timeout_1.default, interval_1.default, network_1.default, crypto_1.default, math_1.default].reduce((factories, builder) => {
+    builder.names.forEach((name) => {
+        factories.set(name, builder.factory);
+    });
+    return factories;
+}, new Map());
+/**
+ * Gets the endowments for a particular Snap. Some endowments, like `setTimeout`
+ * and `clearTimeout`, must be attenuated so that they can only affect behavior
+ * within the Snap's own realm. Therefore, we use factory functions to create
+ * such attenuated / modified endowments. Otherwise, the value that's on the
+ * root realm global will be used.
+ *
+ * @param snap - The Snaps global API object.
+ * @param ethereum - The Snap's EIP-1193 provider object.
+ * @param endowments - The list of endowments to provide to the snap.
+ * @returns An object containing the Snap's endowments.
+ */
+function createEndowments(snap, ethereum, endowments = []) {
+    const attenuatedEndowments = {};
+    // TODO: All endowments should be hardened to prevent covert communication
+    // channels. Hardening the returned objects breaks tests elsewhere in the
+    // monorepo, so further research is needed.
+    const result = endowments.reduce(({ allEndowments, teardowns }, endowmentName) => {
+        // First, check if the endowment has a factory, and default to that.
+        if (endowmentFactories.has(endowmentName)) {
+            if (!(0, utils_1.hasProperty)(attenuatedEndowments, endowmentName)) {
+                // Call the endowment factory for the current endowment. If the factory
+                // creates multiple endowments, they will all be assigned to the
+                // `attenuatedEndowments` object, but will only be passed on to the snap
+                // if explicitly listed among its endowment.
+                // This may not have an actual use case, but, safety first.
+                // We just confirmed that endowmentFactories has the specified key.
+                const _a = 
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                endowmentFactories.get(endowmentName)(), { teardownFunction } = _a, endowment = __rest(_a, ["teardownFunction"]);
+                Object.assign(attenuatedEndowments, endowment);
+                if (teardownFunction) {
+                    teardowns.push(teardownFunction);
+                }
+            }
+            allEndowments[endowmentName] = attenuatedEndowments[endowmentName];
+        }
+        else if (endowmentName in globalObject_1.rootRealmGlobal) {
+            // If the endowment doesn't have a factory, just use whatever is on the
+            // global object.
+            const globalValue = globalObject_1.rootRealmGlobal[endowmentName];
+            allEndowments[endowmentName] =
+                typeof globalValue === 'function' && !isConstructor(globalValue)
+                    ? globalValue.bind(globalObject_1.rootRealmGlobal)
+                    : globalValue;
+        }
+        else if (endowmentName === 'ethereum') {
+            // Special case for adding the EIP-1193 provider.
+            allEndowments[endowmentName] = ethereum;
+        }
+        else {
+            // If we get to this point, we've been passed an endowment that doesn't
+            // exist in our current environment.
+            throw new Error(`Unknown endowment: "${endowmentName}".`);
+        }
+        return { allEndowments, teardowns };
+    }, {
+        allEndowments: { snap },
+        teardowns: [],
+    });
+    const teardown = async () => {
+        await Promise.all(result.teardowns.map((teardownFunction) => teardownFunction()));
+    };
+    return { endowments: result.allEndowments, teardown };
+}
+exports.createEndowments = createEndowments;
+/**
+ * Checks whether the specified function is a constructor.
+ *
+ * @param value - Any function value.
+ * @returns Whether the specified function is a constructor.
+ */
+// `Function` is exactly what we want here.
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isConstructor(value) {
+    var _a, _b;
+    // In our current usage, the string `prototype.constructor.name` should never
+    // be empty, because you can't create a class with no name, and the
+    // `prototype.constructor.name` property is configurable but not writable.
+    // Nevertheless, that property was the empty string for `Date` in the iframe
+    // execution environment during local testing. We have no idea why, but we
+    // have to handle that case.
+    // TODO: Does the `prototype` object always have a `constructor` property?
+    return Boolean(typeof ((_b = (_a = value.prototype) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) === 'string');
+}
+exports.isConstructor = isConstructor;
+//# sourceMappingURL=index.js.map

package/dist/common/endowments/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/endowments/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { SnapsGlobalObject } from '@metamask/snaps-types';\nimport { hasProperty } from '@metamask/utils';\nimport { StreamProvider } from '@metamask/providers';\nimport { rootRealmGlobal } from '../globalObject';\nimport interval from './interval';\nimport network from './network';\nimport timeout from './timeout';\nimport crypto from './crypto';\nimport math from './math';\n\ntype EndowmentFactoryResult = {\n  /**\n   * A function that performs any necessary teardown when the snap becomes idle.\n   *\n   * NOTE:** The endowments are not reconstructed if the snap is re-invoked\n   * before being terminated, so the teardown operation must not render the\n   * endowments unusable; it should simply restore the endowments to their\n   * original state.\n   */\n  teardownFunction?: () => Promise<void> | void;\n  [key: string]: unknown;\n};\n\n/**\n * A map of endowment names to their factory functions. Some endowments share\n * the same factory function, but we only call each factory once for each snap.\n * See {@link createEndowments} for details.\n */\nconst endowmentFactories = [timeout, interval, network, crypto, math].reduce(\n  (factories, builder) => {\n    builder.names.forEach((name) => {\n      factories.set(name, builder.factory);\n    });\n    return factories;\n  },\n  new Map<string, () => EndowmentFactoryResult>(),\n);\n\n/**\n * Gets the endowments for a particular Snap. Some endowments, like `setTimeout`\n * and `clearTimeout`, must be attenuated so that they can only affect behavior\n * within the Snap's own realm. Therefore, we use factory functions to create\n * such attenuated / modified endowments. Otherwise, the value that's on the\n * root realm global will be used.\n *\n * @param snap - The Snaps global API object.\n * @param ethereum - The Snap's EIP-1193 provider object.\n * @param endowments - The list of endowments to provide to the snap.\n * @returns An object containing the Snap's endowments.\n */\nexport function createEndowments(\n  snap: SnapsGlobalObject,\n  ethereum: StreamProvider,\n  endowments: string[] = [],\n): { endowments: Record<string, unknown>; teardown: () => Promise<void> } {\n  const attenuatedEndowments: Record<string, unknown> = {};\n\n  // TODO: All endowments should be hardened to prevent covert communication\n  // channels. Hardening the returned objects breaks tests elsewhere in the\n  // monorepo, so further research is needed.\n  const result = endowments.reduce(\n    ({ allEndowments, teardowns }, endowmentName) => {\n      // First, check if the endowment has a factory, and default to that.\n      if (endowmentFactories.has(endowmentName)) {\n        if (!hasProperty(attenuatedEndowments, endowmentName)) {\n          // Call the endowment factory for the current endowment. If the factory\n          // creates multiple endowments, they will all be assigned to the\n          // `attenuatedEndowments` object, but will only be passed on to the snap\n          // if explicitly listed among its endowment.\n          // This may not have an actual use case, but, safety first.\n\n          // We just confirmed that endowmentFactories has the specified key.\n          const { teardownFunction, ...endowment } =\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            endowmentFactories.get(endowmentName)!();\n          Object.assign(attenuatedEndowments, endowment);\n          if (teardownFunction) {\n            teardowns.push(teardownFunction);\n          }\n        }\n\n        allEndowments[endowmentName] = attenuatedEndowments[endowmentName];\n      } else if (endowmentName in rootRealmGlobal) {\n        // If the endowment doesn't have a factory, just use whatever is on the\n        // global object.\n        const globalValue = (rootRealmGlobal as Record<string, unknown>)[\n          endowmentName\n        ];\n        allEndowments[endowmentName] =\n          typeof globalValue === 'function' && !isConstructor(globalValue)\n            ? globalValue.bind(rootRealmGlobal)\n            : globalValue;\n      } else if (endowmentName === 'ethereum') {\n        // Special case for adding the EIP-1193 provider.\n        allEndowments[endowmentName] = ethereum;\n      } else {\n        // If we get to this point, we've been passed an endowment that doesn't\n        // exist in our current environment.\n        throw new Error(`Unknown endowment: \"${endowmentName}\".`);\n      }\n      return { allEndowments, teardowns };\n    },\n    {\n      allEndowments: { snap } as Record<string, unknown>,\n      teardowns: [] as (() => void)[],\n    },\n  );\n\n  const teardown = async () => {\n    await Promise.all(\n      result.teardowns.map((teardownFunction) => teardownFunction()),\n    );\n  };\n  return { endowments: result.allEndowments, teardown };\n}\n\n/**\n * Checks whether the specified function is a constructor.\n *\n * @param value - Any function value.\n * @returns Whether the specified function is a constructor.\n */\n// `Function` is exactly what we want here.\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isConstructor<T extends Function>(value: T): boolean {\n  // In our current usage, the string `prototype.constructor.name` should never\n  // be empty, because you can't create a class with no name, and the\n  // `prototype.constructor.name` property is configurable but not writable.\n  // Nevertheless, that property was the empty string for `Date` in the iframe\n  // execution environment during local testing. We have no idea why, but we\n  // have to handle that case.\n  // TODO: Does the `prototype` object always have a `constructor` property?\n  return Boolean(typeof value.prototype?.constructor?.name === 'string');\n}\n"]}

package/dist/common/endowments/interval.d.ts

@@ -0,0 +1,9 @@
+declare const endowmentModule: {
+    names: readonly ["setInterval", "clearInterval"];
+    factory: () => {
+        readonly setInterval: (handler: TimerHandler, timeout?: number | undefined) => unknown;
+        readonly clearInterval: (handle: unknown) => void;
+        readonly teardownFunction: () => void;
+    };
+};
+export default endowmentModule;

package/dist/common/endowments/interval.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Creates a pair of `setInterval` and `clearInterval` functions attenuated such
+ * that:
+ * - `setInterval` throws if its "handler" parameter is not a function.
+ * - `clearInterval` only clears timeouts created by its sibling `setInterval`,
+ * or else no-ops.
+ *
+ * @returns An object with the attenuated `setInterval` and `clearInterval`
+ * functions.
+ */
+const createInterval = () => {
+    const registeredHandles = new Map();
+    const _setInterval = (handler, timeout) => {
+        if (typeof handler !== 'function') {
+            throw new Error(`The interval handler must be a function. Received: ${typeof handler}`);
+        }
+        const handle = Object.freeze({});
+        const platformHandle = setInterval(handler, timeout);
+        registeredHandles.set(handle, platformHandle);
+        return handle;
+    };
+    const _clearInterval = (handle) => {
+        const platformHandle = registeredHandles.get(handle);
+        if (platformHandle !== undefined) {
+            clearInterval(platformHandle);
+            registeredHandles.delete(handle);
+        }
+    };
+    const teardownFunction = () => {
+        for (const handle of registeredHandles.keys()) {
+            _clearInterval(handle);
+        }
+    };
+    return {
+        setInterval: _setInterval,
+        clearInterval: _clearInterval,
+        teardownFunction,
+    };
+};
+const endowmentModule = {
+    names: ['setInterval', 'clearInterval'],
+    factory: createInterval,
+};
+exports.default = endowmentModule;
+//# sourceMappingURL=interval.js.map

package/dist/common/endowments/interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.js","sourceRoot":"","sources":["../../../src/common/endowments/interval.ts"],"names":[],"mappings":";;AAAA;;;;;;;;;GASG;AACH,MAAM,cAAc,GAAG,GAAG,EAAE;IAC1B,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAoB,CAAC;IAEtD,MAAM,YAAY,GAAG,CAAC,OAAqB,EAAE,OAAgB,EAAW,EAAE;QACxE,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;YACjC,MAAM,IAAI,KAAK,CACb,sDAAsD,OAAO,OAAO,EAAE,CACvE,CAAC;SACH;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACjC,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACrD,iBAAiB,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAC9C,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF,MAAM,cAAc,GAAG,CAAC,MAAe,EAAQ,EAAE;QAC/C,MAAM,cAAc,GAAG,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACrD,IAAI,cAAc,KAAK,SAAS,EAAE;YAChC,aAAa,CAAC,cAAqB,CAAC,CAAC;YACrC,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SAClC;IACH,CAAC,CAAC;IAEF,MAAM,gBAAgB,GAAG,GAAS,EAAE;QAClC,KAAK,MAAM,MAAM,IAAI,iBAAiB,CAAC,IAAI,EAAE,EAAE;YAC7C,cAAc,CAAC,MAAM,CAAC,CAAC;SACxB;IACH,CAAC,CAAC;IAEF,OAAO;QACL,WAAW,EAAE,YAAY;QACzB,aAAa,EAAE,cAAc;QAC7B,gBAAgB;KACR,CAAC;AACb,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG;IACtB,KAAK,EAAE,CAAC,aAAa,EAAE,eAAe,CAAU;IAChD,OAAO,EAAE,cAAc;CACxB,CAAC;AACF,kBAAe,eAAe,CAAC","sourcesContent":["/**\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 new Error(\n        `The interval handler must be a function. Received: ${typeof handler}`,\n      );\n    }\n    const handle = Object.freeze({});\n    const platformHandle = setInterval(handler, timeout);\n    registeredHandles.set(handle, platformHandle);\n    return handle;\n  };\n\n  const _clearInterval = (handle: unknown): void => {\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: _setInterval,\n    clearInterval: _clearInterval,\n    teardownFunction,\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['setInterval', 'clearInterval'] as const,\n  factory: createInterval,\n};\nexport default endowmentModule;\n"]}

package/dist/common/endowments/math.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Create a {@link Math} object, with the same properties as the global
+ * {@link Math} object, but with the {@link Math.random} method replaced.
+ *
+ * @returns The {@link Math} object with the {@link Math.random} method
+ * replaced.
+ */
+declare function createMath(): {
+    Math: {
+        random: () => number;
+        E: number;
+        LN10: number;
+        LN2: number;
+        LOG2E: number;
+        LOG10E: number;
+        PI: number;
+        SQRT1_2: number;
+        SQRT2: number;
+        abs(x: number): number;
+        acos(x: number): number;
+        asin(x: number): number;
+        atan(x: number): number;
+        atan2(y: number, x: number): number;
+        ceil(x: number): number;
+        cos(x: number): number;
+        exp(x: number): number;
+        floor(x: number): number;
+        log(x: number): number;
+        max(...values: number[]): number;
+        min(...values: number[]): number;
+        pow(x: number, y: number): number;
+        round(x: number): number;
+        sin(x: number): number;
+        sqrt(x: number): number;
+        tan(x: number): number;
+        clz32(x: number): number;
+        imul(x: number, y: number): number;
+        sign(x: number): number;
+        log10(x: number): number;
+        log2(x: number): number;
+        log1p(x: number): number;
+        expm1(x: number): number;
+        cosh(x: number): number;
+        sinh(x: number): number;
+        tanh(x: number): number;
+        acosh(x: number): number;
+        asinh(x: number): number;
+        atanh(x: number): number;
+        hypot(...values: number[]): number;
+        trunc(x: number): number;
+        fround(x: number): number;
+        cbrt(x: number): number;
+        [Symbol.toStringTag]: string;
+    };
+};
+declare const endowmentModule: {
+    names: readonly ["Math"];
+    factory: typeof createMath;
+};
+export default endowmentModule;

package/dist/common/endowments/math.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globalObject_1 = require("../globalObject");
+/**
+ * Create a {@link Math} object, with the same properties as the global
+ * {@link Math} object, but with the {@link Math.random} method replaced.
+ *
+ * @returns The {@link Math} object with the {@link Math.random} method
+ * replaced.
+ */
+function createMath() {
+    // `Math` does not work with `Object.keys`, `Object.entries`, etc., so we
+    // need to create a new object with the same properties.
+    const keys = Object.getOwnPropertyNames(globalObject_1.rootRealmGlobal.Math);
+    const math = keys.reduce((target, key) => {
+        if (key === 'random') {
+            return target;
+        }
+        return Object.assign(Object.assign({}, target), { [key]: globalObject_1.rootRealmGlobal.Math[key] });
+    }, {});
+    return {
+        Math: Object.assign(Object.assign({}, math), { random: () => {
+                // NOTE: This is not intended to be a secure replacement for the weak
+                // random number generator used by `Math.random`. It is only intended to
+                // prevent side channel attacks of `Math.random` by replacing it with an
+                // alternative implementation that is not vulnerable to the same
+                // attacks.
+                //
+                // This does not mean that this implementation is secure. It is not
+                // intended to be used in a security context, and this implementation
+                // may change at any time.
+                //
+                // To securely generate random numbers, use a cryptographically secure
+                // random number generator, such as the one provided by the Web Crypto
+                // API:
+                //
+                // - https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey
+                // - https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+                return crypto.getRandomValues(new Uint32Array(1))[0] / 2 ** 32;
+            } }),
+    };
+}
+const endowmentModule = {
+    names: ['Math'],
+    factory: createMath,
+};
+exports.default = endowmentModule;
+//# sourceMappingURL=math.js.map

package/dist/common/endowments/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","sourceRoot":"","sources":["../../../src/common/endowments/math.ts"],"names":[],"mappings":";;AAAA,kDAAkD;AAElD;;;;;;GAMG;AACH,SAAS,UAAU;IACjB,yEAAyE;IACzE,wDAAwD;IACxD,MAAM,IAAI,GAAG,MAAM,CAAC,mBAAmB,CACrC,8BAAe,CAAC,IAAI,CACI,CAAC;IAE3B,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAO,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;QAC7C,IAAI,GAAG,KAAK,QAAQ,EAAE;YACpB,OAAO,MAAM,CAAC;SACf;QAED,uCAAY,MAAM,KAAE,CAAC,GAAG,CAAC,EAAE,8BAAe,CAAC,IAAI,CAAC,GAAG,CAAC,IAAG;IACzD,CAAC,EAAE,EAAU,CAAC,CAAC;IAEf,OAAO;QACL,IAAI,kCACC,IAAI,KACP,MAAM,EAAE,GAAG,EAAE;gBACX,qEAAqE;gBACrE,wEAAwE;gBACxE,wEAAwE;gBACxE,gEAAgE;gBAChE,WAAW;gBACX,EAAE;gBACF,mEAAmE;gBACnE,qEAAqE;gBACrE,0BAA0B;gBAC1B,EAAE;gBACF,sEAAsE;gBACtE,sEAAsE;gBACtE,OAAO;gBACP,EAAE;gBACF,8EAA8E;gBAC9E,4EAA4E;gBAC5E,OAAO,MAAM,CAAC,eAAe,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACjE,CAAC,GACF;KACF,CAAC;AACJ,CAAC;AAED,MAAM,eAAe,GAAG;IACtB,KAAK,EAAE,CAAC,MAAM,CAAU;IACxB,OAAO,EAAE,UAAU;CACpB,CAAC;AAEF,kBAAe,eAAe,CAAC","sourcesContent":["import { rootRealmGlobal } from '../globalObject';\n\n/**\n * Create a {@link Math} object, with the same properties as the global\n * {@link Math} object, but with the {@link Math.random} method replaced.\n *\n * @returns The {@link Math} object with the {@link Math.random} method\n * replaced.\n */\nfunction createMath() {\n  // `Math` does not work with `Object.keys`, `Object.entries`, etc., so we\n  // need to create a new object with the same properties.\n  const keys = Object.getOwnPropertyNames(\n    rootRealmGlobal.Math,\n  ) as (keyof typeof Math)[];\n\n  const math = keys.reduce<Math>((target, key) => {\n    if (key === 'random') {\n      return target;\n    }\n\n    return { ...target, [key]: rootRealmGlobal.Math[key] };\n  }, {} as Math);\n\n  return {\n    Math: {\n      ...math,\n      random: () => {\n        // NOTE: This is not intended to be a secure replacement for the weak\n        // random number generator used by `Math.random`. It is only intended to\n        // prevent side channel attacks of `Math.random` by replacing it with an\n        // alternative implementation that is not vulnerable to the same\n        // attacks.\n        //\n        // This does not mean that this implementation is secure. It is not\n        // intended to be used in a security context, and this implementation\n        // may change at any time.\n        //\n        // To securely generate random numbers, use a cryptographically secure\n        // random number generator, such as the one provided by the Web Crypto\n        // API:\n        //\n        // - https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey\n        // - https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues\n        return crypto.getRandomValues(new Uint32Array(1))[0] / 2 ** 32;\n      },\n    },\n  };\n}\n\nconst endowmentModule = {\n  names: ['Math'] as const,\n  factory: createMath,\n};\n\nexport default endowmentModule;\n"]}

package/dist/common/endowments/network.d.ts

@@ -0,0 +1,48 @@
+declare type WebSocketCallback = (this: WebSocket, ev: any) => any;
+declare const endowmentModule: {
+    names: readonly ["fetch", "WebSocket"];
+    factory: () => {
+        fetch: typeof fetch;
+        WebSocket: {
+            new (url: string | URL, protocols?: string | string[] | undefined): {
+                onclose: WebSocketCallback | null;
+                onerror: ((this: WebSocket, ev: Event) => any) | null;
+                onmessage: ((this: WebSocket, ev: MessageEvent<any>) => any) | null;
+                onopen: ((this: WebSocket, ev: Event) => any) | null;
+                close(code?: number | undefined, reason?: string | undefined): void;
+                send(data: string | Blob | ArrayBufferView | ArrayBufferLike): void;
+                readonly CLOSED: number;
+                readonly CLOSING: number;
+                readonly CONNECTING: number;
+                readonly OPEN: number;
+                binaryType: BinaryType;
+                readonly bufferedAmount: number;
+                readonly extensions: string;
+                readonly protocol: string;
+                readonly readyState: number;
+                readonly url: string;
+                addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                removeEventListener<K_1 extends keyof WebSocketEventMap>(type: K_1, listener: (this: WebSocket, ev: WebSocketEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                dispatchEvent(event: Event): boolean;
+                "__#4@#teardownClose"(): Promise<void>;
+                "__#4@#createWrapped"(listener: WebSocketCallback): WebSocketCallback;
+                "__#4@#createWrapped"(listener: null): null;
+                "__#4@#createWrapped"(listener: WebSocketCallback | null): WebSocketCallback | null;
+                "__#4@#socket": WebSocket;
+                /**
+                 * After this is set to true, no new event listeners can be added
+                 */
+                "__#4@#isTornDown": boolean;
+                "__#4@#events": Record<string, Map<WebSocketCallback, WebSocketCallback>>;
+                "__#4@#onopenOriginal": WebSocketCallback | null;
+                "__#4@#onmessageOriginal": WebSocketCallback | null;
+                "__#4@#onerrorOriginal": WebSocketCallback | null;
+                "__#4@#oncloseOriginal": WebSocketCallback | null;
+            };
+        };
+        teardownFunction: () => Promise<void>;
+    };
+};
+export default endowmentModule;