smoldot 1.0.3 → 1.0.4

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

@@ -22,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;
 }
 /**

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) => {
@@ -90,7 +93,7 @@ function default_1(config) {
             }
         },
         // 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;
@@ -108,7 +111,7 @@ function default_1(config) {
                     if (killedTracked.killed)
                         return;
                     try {
-                        instance.exports.timer_finished(id);
+                        instance.exports.timer_finished();
                     }
                     catch (_error) { }
                 });
@@ -118,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.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/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,23 +25,23 @@ 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, 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 = {
@@ -59,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
@@ -82,14 +82,11 @@ export function start(options, platformBindings) {
     // All the functions of the public API check if this contains a value.
     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 {

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);

package/dist/mjs/index-deno.js

@@ -22,6 +22,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import { start as innerStart } from './client.js';
 import { ConnectionError } from './instance/instance.js';
+import { default as wasmBase64 } from './instance/autogen/wasm.js';
 export { AddChainError, AlreadyDestroyedError, CrashError, MalformedJsonRpcError, QueueFullError, JsonRpcDisabledError } from './client.js';
 /**
  * Initializes a new client. This is a pre-requisite to connecting to a blockchain.
@@ -32,33 +33,12 @@ export { AddChainError, AlreadyDestroyedError, CrashError, MalformedJsonRpcError
  */
 export function start(options) {
     options = options || {};
-    return innerStart(options || {}, {
-        trustedBase64DecodeAndZlibInflate: (input) => __awaiter(this, void 0, void 0, function* () {
-            const buffer = trustedBase64Decode(input);
-            // This code has been copy-pasted from the official streams draft specification.
-            // At the moment, it is found here: https://wicg.github.io/compression/#example-deflate-compress
-            const ds = new DecompressionStream('deflate');
-            const writer = ds.writable.getWriter();
-            writer.write(buffer);
-            writer.close();
-            const output = [];
-            const reader = ds.readable.getReader();
-            let totalSize = 0;
-            while (true) {
-                const { value, done } = yield reader.read();
-                if (done)
-                    break;
-                output.push(value);
-                totalSize += value.byteLength;
-            }
-            const concatenated = new Uint8Array(totalSize);
-            let offset = 0;
-            for (const array of output) {
-                concatenated.set(array, offset);
-                offset += array.byteLength;
-            }
-            return concatenated;
-        }),
+    // 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 = zlibInflate(trustedBase64Decode(wasmBase64)).then(((bytecode) => WebAssembly.compile(bytecode)));
+    return innerStart(options || {}, wasmModule, {
         registerShouldPeriodicallyYield: (_callback) => {
             return [true, () => { }];
         },
@@ -76,6 +56,36 @@ export function start(options) {
         }
     });
 }
+/**
+ * Applies the zlib inflate algorithm on the buffer.
+ */
+function zlibInflate(buffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // This code has been copy-pasted from the official streams draft specification.
+        // At the moment, it is found here: https://wicg.github.io/compression/#example-deflate-compress
+        const ds = new DecompressionStream('deflate');
+        const writer = ds.writable.getWriter();
+        writer.write(buffer);
+        writer.close();
+        const output = [];
+        const reader = ds.readable.getReader();
+        let totalSize = 0;
+        while (true) {
+            const { value, done } = yield reader.read();
+            if (done)
+                break;
+            output.push(value);
+            totalSize += value.byteLength;
+        }
+        const concatenated = new Uint8Array(totalSize);
+        let offset = 0;
+        for (const array of output) {
+            concatenated.set(array, offset);
+            offset += array.byteLength;
+        }
+        return concatenated;
+    });
+}
 /**
  * Decodes a base64 string.
  *
@@ -227,7 +237,7 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
                 config.onMessage(readBuffer.slice(0, outcome));
                 return read(readBuffer);
             });
-            read(new Uint8Array(1024));
+            read(new Uint8Array(32768));
             return established;
         });
         return {

package/dist/mjs/index-nodejs.js

@@ -16,6 +16,7 @@
 // with both at the same time.
 import { start as innerStart } from './client.js';
 import { ConnectionError } from './instance/instance.js';
+import { default as wasmBase64 } from './instance/autogen/wasm.js';
 import { WebSocket } from 'ws';
 import { inflate } from 'pako';
 import { performance } from 'node:perf_hooks';
@@ -31,10 +32,12 @@ export { AddChainError, AlreadyDestroyedError, CrashError, MalformedJsonRpcError
  */
 export function start(options) {
     options = options || {};
-    return innerStart(options || {}, {
-        trustedBase64DecodeAndZlibInflate: (input) => {
-            return Promise.resolve(inflate(Buffer.from(input, 'base64')));
-        },
+    // 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(Buffer.from(wasmBase64, 'base64')));
+    return innerStart(options || {}, wasmModule, {
         registerShouldPeriodicallyYield: (_callback) => {
             return [true, () => { }];
         },