smoldot 1.0.2 → 1.0.4

package/dist/mjs/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/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) => {
@@ -85,12 +88,8 @@ export default function (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;
@@ -108,7 +107,7 @@ export default function (config) {
                     if (killedTracked.killed)
                         return;
                     try {
-                        instance.exports.timer_finished(id);
+                        instance.exports.timer_finished();
                     }
                     catch (_error) { }
                 });
@@ -118,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-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/mjs/instance/bindings-wasi.js

@@ -39,6 +39,36 @@ export 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/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/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/mjs/instance/buffer.js

@@ -38,6 +38,17 @@ export function writeUInt32LE(buffer, offset, value) {
     buffer[offset + 1] = (value >>> 8) & 0xff;
     buffer[offset] = value & 0xff;
 }
+export 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));
+}
 function checkRange(buffer, offset, length) {
     if (!Number.isInteger(offset) || offset < 0)
         throw new RangeError();

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,27 +22,28 @@ 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, 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}`);
@@ -54,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.2",
+  "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",
@@ -46,7 +46,7 @@
     "@types/ws": "^8.5.3",
     "ava": "^5.0.1",
     "dtslint": "^4.0.6",
-    "rimraf": "^4.1.2",
+    "rimraf": "^5.0.0",
     "typedoc": "^0.24.1",
     "typescript": "^5.0.2"
   }