smoldot 1.0.3 → 1.0.4

package/dist/mjs/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/mjs/instance/bindings-smoldot-light.js

@@ -61,6 +61,9 @@ export default function (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) => {
@@ -86,7 +89,7 @@ export default function (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;
@@ -104,7 +107,7 @@ export default function (config) {
                     if (killedTracked.killed)
                         return;
                     try {
-                        instance.exports.timer_finished(id);
+                        instance.exports.timer_finished();
                     }
                     catch (_error) { }
                 });
@@ -114,7 +117,7 @@ export default function (config) {
                     if (killedTracked.killed)
                         return;
                     try {
-                        instance.exports.timer_finished(id);
+                        instance.exports.timer_finished();
                     }
                     catch (_error) { }
                 }, ms);

package/dist/mjs/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/mjs/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/mjs/instance/instance.js

@@ -62,65 +62,49 @@ export 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];
         })
     };
@@ -273,8 +257,6 @@ export 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/mjs/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/mjs/instance/raw-instance.js

@@ -22,22 +22,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import { default as smoldotLightBindingsBuilder } from './bindings-smoldot-light.js';
 import { default as wasiBindingsBuilder } from './bindings-wasi.js';
-import { default as wasmBase64 } from './autogen/wasm.js';
 export { ConnectionError } from './bindings-smoldot-light.js';
 export 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(wasmBase64);
         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 = {
@@ -55,15 +55,70 @@ export 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": wasiBindingsBuilder(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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoldot",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Light client that connects to Polkadot and Substrate-based blockchains",
   "author": "Parity Technologies <admin@parity.io>",
   "license": "GPL-3.0-or-later WITH Classpath-exception-2.0",