smoldot 1.0.2 → 1.0.4

package/dist/cjs/instance/bindings-smoldot-light.d.ts

@@ -7,10 +7,6 @@ export interface Config {
      * When `buffer_size` or `buffer_index` are called, the buffer is found here.
      */
     bufferIndices: Array<Uint8Array>;
-    /**
-     * Returns the number of milliseconds since an arbitrary epoch.
-     */
-    performanceNow: () => number;
     /**
      * Tries to open a new connection using the given configuration.
      *
@@ -26,6 +22,7 @@ export interface Config {
     onPanic: (message: string) => never;
     logCallback: (level: number, target: string, message: string) => void;
     jsonRpcResponsesNonEmptyCallback: (chainId: number) => void;
+    advanceExecutionReadyCallback: () => void;
     currentTaskCallback?: (taskName: string | null) => void;
 }
 /**
@@ -71,7 +68,7 @@ export interface Connection {
      *
      * The connection and stream must currently be in the `Open` state.
      *
-     * The number of bytes most never exceed the number of "writable bytes" of the stream.
+     * The number of bytes must never exceed the number of "writable bytes" of the stream.
      * `onWritableBytes` can be used in order to notify that more writable bytes are available.
      *
      * The `streamId` must be provided if and only if the connection is of type "multi-stream".
@@ -160,7 +157,8 @@ export interface ConnectionConfig {
      */
     onStreamReset: (streamId: number) => void;
     /**
-     * Callback called when more data can be written on the stream.
+     * Callback called when some data sent using {@link Connection.send} has effectively been
+     * written on the stream, meaning that some buffer space is now free.
      *
      * Can only happen while the connection is in the `Open` state.
      *
@@ -168,6 +166,9 @@ export interface ConnectionConfig {
      *
      * The `streamId` parameter must be provided if and only if the connection is of type
      * "multi-stream".
+     *
+     * Only a number of bytes equal to the size of the data provided to {@link Connection.send}
+     * must be reported. In other words, the `initialWritableBytes` must never be exceeded.
      */
     onWritableBytes: (numExtra: number, streamId?: number) => void;
     /**

package/dist/cjs/instance/bindings-smoldot-light.js

@@ -65,6 +65,9 @@ function default_1(config) {
             const buf = config.bufferIndices[bufferIndex];
             new Uint8Array(instance.exports.memory.buffer).set(buf, targetPtr);
         },
+        advance_execution_ready: () => {
+            config.advanceExecutionReadyCallback();
+        },
         // Used by the Rust side to notify that a JSON-RPC response or subscription notification
         // is available in the queue of JSON-RPC responses.
         json_rpc_responses_non_empty: (chainId) => {
@@ -89,12 +92,8 @@ function default_1(config) {
                 config.logCallback(level, target, message);
             }
         },
-        // Must return the UNIX time in milliseconds.
-        unix_time_ms: () => Date.now(),
-        // Must return the value of a monotonic clock in milliseconds.
-        monotonic_clock_ms: () => config.performanceNow(),
         // Must call `timer_finished` after the given number of milliseconds has elapsed.
-        start_timer: (id, ms) => {
+        start_timer: (ms) => {
             if (killedTracked.killed)
                 return;
             const instance = config.instance;
@@ -112,7 +111,7 @@ function default_1(config) {
                     if (killedTracked.killed)
                         return;
                     try {
-                        instance.exports.timer_finished(id);
+                        instance.exports.timer_finished();
                     }
                     catch (_error) { }
                 });
@@ -122,7 +121,7 @@ function default_1(config) {
                     if (killedTracked.killed)
                         return;
                     try {
-                        instance.exports.timer_finished(id);
+                        instance.exports.timer_finished();
                     }
                     catch (_error) { }
                 }, ms);

package/dist/cjs/instance/bindings-wasi.d.ts

@@ -5,6 +5,10 @@ export interface Config {
      * Fills the given buffer with randomly-generated bytes.
      */
     getRandomValues: (buffer: Uint8Array) => void;
+    /**
+     * Returns the number of milliseconds since an arbitrary epoch.
+     */
+    performanceNow: () => number;
     /**
      * List of environment variables to feed to the Rust program. An array of strings.
      * Example: `["RUST_BACKTRACE=1", "RUST_LOG=foo"];`

package/dist/cjs/instance/bindings-wasi.js

@@ -41,6 +41,36 @@ exports.default = (config) => {
             }
             return 0;
         },
+        clock_time_get: (clockId, _precision, outPtr) => {
+            // See <https://github.com/rust-lang/rust/blob/master/library/std/src/sys/wasi/time.rs>
+            // and <docs.rs/wasi/> for help.
+            const instance = config.instance;
+            const mem = new Uint8Array(instance.exports.memory.buffer);
+            outPtr >>>= 0;
+            // We ignore the precision, as it can't be implemented anyway.
+            switch (clockId) {
+                case 0: {
+                    // Realtime clock.
+                    const now = BigInt(Math.floor(Date.now())) * BigInt(1000000);
+                    buffer.writeUInt64LE(mem, outPtr, now);
+                    // Success.
+                    return 0;
+                }
+                case 1: {
+                    // Monotonic clock.
+                    const nowMs = config.performanceNow();
+                    const nowMsInt = Math.floor(nowMs);
+                    const now = BigInt(nowMsInt) * BigInt(1000000) +
+                        BigInt(Math.floor(((nowMs - nowMsInt) * 1000000)));
+                    buffer.writeUInt64LE(mem, outPtr, now);
+                    // Success.
+                    return 0;
+                }
+                default:
+                    // Return an `EINVAL` error.
+                    return 28;
+            }
+        },
         // Writing to a file descriptor is used in order to write to stdout/stderr.
         fd_write: (fd, addr, num, outPtr) => {
             const instance = config.instance;

package/dist/cjs/instance/bindings.d.ts

@@ -6,8 +6,8 @@
  */
 export interface SmoldotWasmExports extends WebAssembly.Exports {
     memory: WebAssembly.Memory;
-    init: (maxLogLevel: number, enableCurrentTask: number, cpuRateLimit: number, periodicallyYield: number) => void;
-    set_periodically_yield: (periodicallyYield: number) => void;
+    init: (maxLogLevel: number) => void;
+    advance_execution: () => number;
     start_shutdown: () => void;
     add_chain: (chainSpecBufferIndex: number, databaseContentBufferIndex: number, jsonRpcRunning: number, potentialRelayChainsBufferIndex: number) => number;
     remove_chain: (chainId: number) => void;
@@ -17,7 +17,7 @@ export interface SmoldotWasmExports extends WebAssembly.Exports {
     json_rpc_send: (textBufferIndex: number, chainId: number) => number;
     json_rpc_responses_peek: (chainId: number) => number;
     json_rpc_responses_pop: (chainId: number) => void;
-    timer_finished: (timerId: number) => void;
+    timer_finished: () => void;
     connection_open_single_stream: (connectionId: number, handshakeTy: number, initialWritableBytes: number, writeClosable: number) => void;
     connection_open_multi_stream: (connectionId: number, handshakeTyBufferIndex: number) => void;
     stream_writable_bytes: (connectionId: number, streamId: number, numBytes: number) => void;

package/dist/cjs/instance/buffer.d.ts

@@ -8,3 +8,4 @@ export declare function readUInt32LE(buffer: Uint8Array, offset: number): number
  */
 export declare function writeUInt8(buffer: Uint8Array, offset: number, value: number): void;
 export declare function writeUInt32LE(buffer: Uint8Array, offset: number, value: number): void;
+export declare function writeUInt64LE(buffer: Uint8Array, offset: number, value: bigint): void;

package/dist/cjs/instance/buffer.js

@@ -3,7 +3,7 @@
 // Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeUInt32LE = exports.writeUInt8 = exports.readUInt32LE = exports.utf8BytesToString = void 0;
+exports.writeUInt64LE = exports.writeUInt32LE = exports.writeUInt8 = exports.readUInt32LE = exports.utf8BytesToString = void 0;
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
@@ -45,6 +45,18 @@ function writeUInt32LE(buffer, offset, value) {
     buffer[offset] = value & 0xff;
 }
 exports.writeUInt32LE = writeUInt32LE;
+function writeUInt64LE(buffer, offset, value) {
+    checkRange(buffer, offset, 8);
+    buffer[offset + 7] = Number((value >> BigInt(56)) & BigInt(0xff));
+    buffer[offset + 6] = Number((value >> BigInt(48)) & BigInt(0xff));
+    buffer[offset + 5] = Number((value >> BigInt(40)) & BigInt(0xff));
+    buffer[offset + 4] = Number((value >> BigInt(32)) & BigInt(0xff));
+    buffer[offset + 3] = Number((value >> BigInt(24)) & BigInt(0xff));
+    buffer[offset + 2] = Number((value >> BigInt(16)) & BigInt(0xff));
+    buffer[offset + 1] = Number((value >> BigInt(8)) & BigInt(0xff));
+    buffer[offset] = Number(value & BigInt(0xff));
+}
+exports.writeUInt64LE = writeUInt64LE;
 function checkRange(buffer, offset, length) {
     if (!Number.isInteger(offset) || offset < 0)
         throw new RangeError();

package/dist/cjs/instance/instance.d.ts

@@ -24,9 +24,9 @@ export declare class QueueFullError extends Error {
  * Contains the configuration of the instance.
  */
 export interface Config {
+    wasmModule: Promise<WebAssembly.Module>;
     logCallback: (level: number, target: string, message: string) => void;
     maxLogLevel: number;
-    enableCurrentTask: boolean;
     cpuRateLimit: number;
 }
 export interface Instance {

package/dist/cjs/instance/instance.js

@@ -69,65 +69,49 @@ function start(configMessage, platformBindings) {
     const printError = { printError: true };
     // Contains the information of each chain that is currently alive.
     let chains = new Map();
-    // Start initialization of the Wasm VM.
-    const config = {
-        onWasmPanic: (message) => {
-            // TODO: consider obtaining a backtrace here
-            crashError.error = new CrashError(message);
-            if (!printError.printError)
-                return;
-            console.error("Smoldot has panicked" +
-                (currentTask.name ? (" while executing task `" + currentTask.name + "`") : "") +
-                ". This is a bug in smoldot. Please open an issue at " +
-                "https://github.com/smol-dot/smoldot/issues with the following message:\n" +
-                message);
-            for (const chain of Array.from(chains.values())) {
-                for (const promise of chain.jsonRpcResponsesPromises) {
-                    promise.reject(crashError.error);
-                }
-                chain.jsonRpcResponsesPromises = [];
-            }
-        },
-        logCallback: (level, target, message) => {
-            configMessage.logCallback(level, target, message);
-        },
-        jsonRpcResponsesNonEmptyCallback: (chainId) => {
-            // Notify every single promise found in `jsonRpcResponsesPromises`.
-            const promises = chains.get(chainId).jsonRpcResponsesPromises;
-            while (promises.length !== 0) {
-                promises.shift().resolve();
-            }
-        },
-        currentTaskCallback: (taskName) => {
-            currentTask.name = taskName;
-        },
-        cpuRateLimit: configMessage.cpuRateLimit,
-    };
-    state = {
-        initialized: false, promise: instance.startInstance(config, platformBindings).then(([instance, bufferIndices]) => {
-            // `config.cpuRateLimit` is a floating point that should be between 0 and 1, while the value
-            // to pass as parameter must be between `0` and `2^32-1`.
-            // The few lines of code below should handle all possible values of `number`, including
-            // infinites and NaN.
-            let cpuRateLimit = Math.round(config.cpuRateLimit * 4294967295); // `2^32 - 1`
-            if (cpuRateLimit < 0)
-                cpuRateLimit = 0;
-            if (cpuRateLimit > 4294967295)
-                cpuRateLimit = 4294967295;
-            if (!Number.isFinite(cpuRateLimit))
-                cpuRateLimit = 4294967295; // User might have passed NaN
-            // Smoldot requires an initial call to the `init` function in order to do its internal
-            // configuration.
-            const [periodicallyYield, unregisterCallback] = platformBindings.registerShouldPeriodicallyYield((newValue) => {
-                if (state.initialized && !crashError.error) {
-                    try {
-                        state.instance.exports.set_periodically_yield(newValue ? 1 : 0);
+    const initPromise = (() => __awaiter(this, void 0, void 0, function* () {
+        const module = yield configMessage.wasmModule;
+        // Start initialization of the Wasm VM.
+        const config = {
+            onWasmPanic: (message) => {
+                // TODO: consider obtaining a backtrace here
+                crashError.error = new CrashError(message);
+                if (!printError.printError)
+                    return;
+                console.error("Smoldot has panicked" +
+                    (currentTask.name ? (" while executing task `" + currentTask.name + "`") : "") +
+                    ". This is a bug in smoldot. Please open an issue at " +
+                    "https://github.com/smol-dot/smoldot/issues with the following message:\n" +
+                    message);
+                for (const chain of Array.from(chains.values())) {
+                    for (const promise of chain.jsonRpcResponsesPromises) {
+                        promise.reject(crashError.error);
                     }
-                    catch (_error) { }
+                    chain.jsonRpcResponsesPromises = [];
                 }
-            });
-            instance.exports.init(configMessage.maxLogLevel, configMessage.enableCurrentTask ? 1 : 0, cpuRateLimit, periodicallyYield ? 1 : 0);
-            state = { initialized: true, instance, bufferIndices, unregisterCallback };
+            },
+            logCallback: (level, target, message) => {
+                configMessage.logCallback(level, target, message);
+            },
+            wasmModule: module,
+            jsonRpcResponsesNonEmptyCallback: (chainId) => {
+                // Notify every single promise found in `jsonRpcResponsesPromises`.
+                const promises = chains.get(chainId).jsonRpcResponsesPromises;
+                while (promises.length !== 0) {
+                    promises.shift().resolve();
+                }
+            },
+            currentTaskCallback: (taskName) => {
+                currentTask.name = taskName;
+            },
+            cpuRateLimit: configMessage.cpuRateLimit,
+            maxLogLevel: configMessage.maxLogLevel,
+        };
+        return yield instance.startInstance(config, platformBindings);
+    }))();
+    state = {
+        initialized: false, promise: initPromise.then(([instance, bufferIndices]) => {
+            state = { initialized: true, instance, bufferIndices };
             return [instance, bufferIndices];
         })
     };
@@ -280,8 +264,6 @@ function start(configMessage, platformBindings) {
                 // exception when the user wants the shutdown to happen.
                 if (crashError.error)
                     return;
-                if (state.initialized)
-                    state.unregisterCallback();
                 try {
                     printError.printError = false;
                     instance.exports.start_shutdown();

package/dist/cjs/instance/raw-instance.d.ts

@@ -15,25 +15,16 @@ export interface Config {
      */
     onWasmPanic: (message: string) => void;
     logCallback: (level: number, target: string, message: string) => void;
+    wasmModule: WebAssembly.Module;
     jsonRpcResponsesNonEmptyCallback: (chainId: number) => void;
     currentTaskCallback?: (taskName: string | null) => void;
+    maxLogLevel: number;
     cpuRateLimit: number;
 }
 /**
  * Contains functions that the client will use when it needs to leverage the platform.
  */
 export interface PlatformBindings {
-    /**
-     * Base64-decode the given buffer then decompress its content using the inflate algorithm
-     * with zlib header.
-     *
-     * The input is considered trusted. In other words, the implementation doesn't have to
-     * resist malicious input.
-     *
-     * This function is asynchronous because implementations might use the compression streams
-     * Web API, which for whatever reason is asynchronous.
-     */
-    trustedBase64DecodeAndZlibInflate: (input: string) => Promise<Uint8Array>;
     /**
      * Returns the number of milliseconds since an arbitrary epoch.
      */

package/dist/cjs/instance/raw-instance.js

@@ -25,28 +25,29 @@ exports.startInstance = exports.ConnectionError = void 0;
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 const bindings_smoldot_light_js_1 = require("./bindings-smoldot-light.js");
 const bindings_wasi_js_1 = require("./bindings-wasi.js");
-const wasm_js_1 = require("./autogen/wasm.js");
 var bindings_smoldot_light_js_2 = require("./bindings-smoldot-light.js");
 Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return bindings_smoldot_light_js_2.ConnectionError; } });
 function startInstance(config, platformBindings) {
     return __awaiter(this, void 0, void 0, function* () {
-        // The actual Wasm bytecode is base64-decoded then deflate-decoded from a constant found in a
-        // different file.
-        // This is suboptimal compared to using `instantiateStreaming`, but it is the most
-        // cross-platform cross-bundler approach.
-        const wasmBytecode = yield platformBindings.trustedBase64DecodeAndZlibInflate(wasm_js_1.default);
         let killAll;
         const bufferIndices = new Array;
+        // Callback called when `advance_execution_ready` is called by the Rust code, if any.
+        const advanceExecutionPromise = { value: null };
         // Used to bind with the smoldot-light bindings. See the `bindings-smoldot-light.js` file.
-        const smoldotJsConfig = Object.assign({ bufferIndices, performanceNow: platformBindings.performanceNow, connect: platformBindings.connect, onPanic: (message) => {
+        const smoldotJsConfig = Object.assign({ bufferIndices, connect: platformBindings.connect, onPanic: (message) => {
                 killAll();
                 config.onWasmPanic(message);
                 throw new Error();
+            }, advanceExecutionReadyCallback: () => {
+                if (advanceExecutionPromise.value)
+                    advanceExecutionPromise.value();
+                advanceExecutionPromise.value = null;
             } }, config);
         // Used to bind with the Wasi bindings. See the `bindings-wasi.js` file.
         const wasiConfig = {
             envVars: [],
             getRandomValues: platformBindings.getRandomValues,
+            performanceNow: platformBindings.performanceNow,
             onProcExit: (retCode) => {
                 killAll();
                 config.onWasmPanic(`proc_exit called: ${retCode}`);
@@ -58,15 +59,70 @@ function startInstance(config, platformBindings) {
         // Start the Wasm virtual machine.
         // The Rust code defines a list of imports that must be fulfilled by the environment. The second
         // parameter provides their implementations.
-        const result = yield WebAssembly.instantiate(wasmBytecode, {
+        const result = yield WebAssembly.instantiate(config.wasmModule, {
             // The functions with the "smoldot" prefix are specific to smoldot.
             "smoldot": smoldotBindings,
             // As the Rust code is compiled for wasi, some more wasi-specific imports exist.
             "wasi_snapshot_preview1": (0, bindings_wasi_js_1.default)(wasiConfig),
         });
-        const instance = result.instance;
+        const instance = result;
         smoldotJsConfig.instance = instance;
         wasiConfig.instance = instance;
+        // Smoldot requires an initial call to the `init` function in order to do its internal
+        // configuration.
+        instance.exports.init(config.maxLogLevel);
+        (() => __awaiter(this, void 0, void 0, function* () {
+            // In order to avoid calling `setTimeout` too often, we accumulate sleep up until
+            // a certain threshold.
+            let missingSleep = 0;
+            // Extract (to make sure the value doesn't change) and sanitize `cpuRateLimit`.
+            let cpuRateLimit = config.cpuRateLimit;
+            if (isNaN(cpuRateLimit))
+                cpuRateLimit = 1.0;
+            if (cpuRateLimit > 1.0)
+                cpuRateLimit = 1.0;
+            if (cpuRateLimit < 0.0)
+                cpuRateLimit = 0.0;
+            const periodicallyYield = { value: false };
+            const [periodicallyYieldInit, unregisterCallback] = platformBindings.registerShouldPeriodicallyYield((newValue) => {
+                periodicallyYield.value = newValue;
+            });
+            periodicallyYield.value = periodicallyYieldInit;
+            let now = platformBindings.performanceNow();
+            while (true) {
+                const whenReadyAgain = new Promise((resolve) => advanceExecutionPromise.value = resolve);
+                const outcome = instance.exports.advance_execution();
+                if (outcome === 0) {
+                    unregisterCallback();
+                    break;
+                }
+                const afterExec = platformBindings.performanceNow();
+                const elapsed = afterExec - now;
+                now = afterExec;
+                // In order to enforce the rate limiting, we stop executing for a certain
+                // amount of time.
+                // The base equation here is: `(sleep + elapsed) * rateLimit == elapsed`,
+                // from which the calculation below is derived.
+                const sleep = elapsed * (1.0 / cpuRateLimit - 1.0);
+                missingSleep += sleep;
+                if (missingSleep > (periodicallyYield ? 5 : 1000)) {
+                    // `setTimeout` has a maximum value, after which it will overflow. 🤦
+                    // See <https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#maximum_delay_value>
+                    // While adding a cap technically skews the CPU rate limiting algorithm, we don't
+                    // really care for such extreme values.
+                    if (missingSleep > 2147483646) // Doc says `> 2147483647`, but I don't really trust their pedanticism so let's be safe
+                        missingSleep = 2147483646;
+                    yield new Promise((resolve) => setTimeout(resolve, missingSleep));
+                    missingSleep = 0;
+                }
+                yield whenReadyAgain;
+                const afterWait = platformBindings.performanceNow();
+                missingSleep -= (afterWait - now);
+                if (missingSleep < 0)
+                    missingSleep = 0;
+                now = afterWait;
+            }
+        }))();
         return [instance, bufferIndices];
     });
 }

package/dist/mjs/client.d.ts

@@ -317,4 +317,4 @@ export interface AddChainOptions {
      */
     disableJsonRpc?: boolean;
 }
-export declare function start(options: ClientOptions, platformBindings: PlatformBindings): Client;
+export declare function start(options: ClientOptions, wasmModule: Promise<WebAssembly.Module>, platformBindings: PlatformBindings): Client;

package/dist/mjs/client.js

@@ -53,7 +53,7 @@ export class JsonRpcDisabledError extends Error {
 // This function is similar to the `start` function found in `index.ts`, except with an extra
 // parameter containing the platform-specific bindings.
 // Contrary to the one within `index.js`, this function is not supposed to be directly used.
-export function start(options, platformBindings) {
+export function start(options, wasmModule, platformBindings) {
     const logCallback = options.logCallback || ((level, target, message) => {
         // The first parameter of the methods of `console` has some printf-like substitution
         // capabilities. We don't really need to use this, but not using it means that the logs might
@@ -77,25 +77,22 @@ export function start(options, platformBindings) {
     // For each chain object returned by `addChain`, the associated internal chain id.
     //
     // Immediately cleared when `remove()` is called on a chain.
-    let chainIds = new WeakMap();
+    const chainIds = new WeakMap();
     // If `Client.terminate()̀  is called, this error is set to a value.
     // All the functions of the public API check if this contains a value.
-    let alreadyDestroyedError = null;
+    const alreadyDestroyedError = { value: null };
     const instance = startInstance({
+        wasmModule,
         // Maximum level of log entries sent by the client.
         // 0 = Logging disabled, 1 = Error, 2 = Warn, 3 = Info, 4 = Debug, 5 = Trace
         maxLogLevel: options.maxLogLevel || 3,
         logCallback,
-        // `enableCurrentTask` adds a small performance hit, but adds some additional information to
-        // crash reports. Whether this should be enabled is very opiniated and not that important. At
-        // the moment, we enable it all the time, except if the user has logging disabled altogether.
-        enableCurrentTask: options.maxLogLevel ? options.maxLogLevel >= 1 : true,
         cpuRateLimit: options.cpuRateLimit || 1.0,
     }, platformBindings);
     return {
         addChain: (options) => __awaiter(this, void 0, void 0, function* () {
-            if (alreadyDestroyedError)
-                throw alreadyDestroyedError;
+            if (alreadyDestroyedError.value)
+                throw alreadyDestroyedError.value;
             // Passing a JSON object for the chain spec is an easy mistake, so we provide a more
             // readable error.
             if (!(typeof options.chainSpec === 'string'))
@@ -120,8 +117,8 @@ export function start(options, platformBindings) {
             // Resolve the promise that `addChain` returned to the user.
             const newChain = {
                 sendJsonRpc: (request) => {
-                    if (alreadyDestroyedError)
-                        throw alreadyDestroyedError;
+                    if (alreadyDestroyedError.value)
+                        throw alreadyDestroyedError.value;
                     if (wasDestroyed.destroyed)
                         throw new AlreadyDestroyedError();
                     if (options.disableJsonRpc)
@@ -133,8 +130,8 @@ export function start(options, platformBindings) {
                     instance.request(request, chainId);
                 },
                 nextJsonRpcResponse: () => {
-                    if (alreadyDestroyedError)
-                        return Promise.reject(alreadyDestroyedError);
+                    if (alreadyDestroyedError.value)
+                        return Promise.reject(alreadyDestroyedError.value);
                     if (wasDestroyed.destroyed)
                         return Promise.reject(new AlreadyDestroyedError());
                     if (options.disableJsonRpc)
@@ -142,8 +139,8 @@ export function start(options, platformBindings) {
                     return instance.nextJsonRpcResponse(chainId);
                 },
                 remove: () => {
-                    if (alreadyDestroyedError)
-                        throw alreadyDestroyedError;
+                    if (alreadyDestroyedError.value)
+                        throw alreadyDestroyedError.value;
                     if (wasDestroyed.destroyed)
                         throw new AlreadyDestroyedError();
                     wasDestroyed.destroyed = true;
@@ -156,9 +153,9 @@ export function start(options, platformBindings) {
             return newChain;
         }),
         terminate: () => __awaiter(this, void 0, void 0, function* () {
-            if (alreadyDestroyedError)
-                throw alreadyDestroyedError;
-            alreadyDestroyedError = new AlreadyDestroyedError();
+            if (alreadyDestroyedError.value)
+                throw alreadyDestroyedError.value;
+            alreadyDestroyedError.value = new AlreadyDestroyedError();
             instance.startShutdown();
         })
     };

package/dist/mjs/index-browser.js

@@ -25,6 +25,7 @@ import { start as innerStart } from './client.js';
 import { ConnectionError } from './instance/instance.js';
 import { classicDecode, multibaseBase64Decode } from './base64.js';
 import { inflate } from 'pako';
+import { default as wasmBase64 } from './instance/autogen/wasm.js';
 export { AddChainError, AlreadyDestroyedError, CrashError, JsonRpcDisabledError, MalformedJsonRpcError, QueueFullError } from './client.js';
 /**
  * Initializes a new client. This is a pre-requisite to connecting to a blockchain.
@@ -35,10 +36,12 @@ export { AddChainError, AlreadyDestroyedError, CrashError, JsonRpcDisabledError,
  */
 export function start(options) {
     options = options || {};
-    return innerStart(options, {
-        trustedBase64DecodeAndZlibInflate: (input) => {
-            return Promise.resolve(inflate(classicDecode(input)));
-        },
+    // The actual Wasm bytecode is base64-decoded then deflate-decoded from a constant found in a
+    // different file.
+    // This is suboptimal compared to using `instantiateStreaming`, but it is the most
+    // cross-platform cross-bundler approach.
+    const wasmModule = WebAssembly.compile(inflate(classicDecode(wasmBase64)));
+    return innerStart(options, wasmModule, {
         registerShouldPeriodicallyYield: (callback) => {
             if (typeof document === 'undefined') // We might be in a web worker.
                 return [false, () => { }];
@@ -53,7 +56,16 @@ export function start(options) {
             const crypto = globalThis.crypto;
             if (!crypto)
                 throw new Error('randomness not available');
-            crypto.getRandomValues(buffer);
+            // Browsers have this completely undocumented behavior (it's not even part of a spec)
+            // that for some reason `getRandomValues` can't be called on arrayviews back by
+            // `SharedArrayBuffer`s and they throw an exception if you try.
+            if (buffer.buffer instanceof ArrayBuffer)
+                crypto.getRandomValues(buffer);
+            else {
+                const tmpArray = new Uint8Array(buffer.length);
+                crypto.getRandomValues(tmpArray);
+                buffer.set(tmpArray);
+            }
         },
         connect: (config) => {
             return connect(config, (options === null || options === void 0 ? void 0 : options.forbidWs) || false, (options === null || options === void 0 ? void 0 : options.forbidNonLocalWs) || false, (options === null || options === void 0 ? void 0 : options.forbidWss) || false, (options === null || options === void 0 ? void 0 : options.forbidWebRtc) || false);