smoldot 2.0.1 → 2.0.3

package/dist/cjs/internals/client.js

@@ -363,11 +363,16 @@ function start(options, wasmModule, platformBindings) {
             if (state.instance.status !== "ready")
                 throw new Error(); // Internal error. Never supposed to happen.
             state.instance.instance.shutdownExecutor();
-            state.instance = { status: "destroyed", error: new public_types_js_1.AlreadyDestroyedError() };
+            // Wait for the `executor-shutdown` event to be generated.
+            yield new Promise((resolve) => state.onExecutorShutdownOrWasmPanic = resolve);
+            // In case the instance crashes while we were waiting, we don't want to overwrite
+            // the error.
+            if (state.instance.status === "ready")
+                state.instance = { status: "destroyed", error: new public_types_js_1.AlreadyDestroyedError() };
             state.connections.forEach((connec) => connec.reset());
             state.connections.clear();
             for (const addChainResult of state.addChainResults) {
-                addChainResult({ success: false, error: "Smoldot has crashed" });
+                addChainResult({ success: false, error: "Client.terminate() has been called" });
             }
             state.addChainResults = [];
             for (const chain of Array.from(state.chains.values())) {
@@ -377,8 +382,6 @@ function start(options, wasmModule, platformBindings) {
                 chain.jsonRpcResponsesPromises = [];
             }
             state.chains.clear();
-            // Wait for the `executor-shutdown` event to be generated.
-            yield new Promise((resolve) => state.onExecutorShutdownOrWasmPanic = resolve);
         })
     };
 }

package/dist/cjs/internals/local-instance.js

@@ -61,6 +61,30 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                 state.onShutdownExecutorOrWasmPanic = () => { };
                 throw new Error();
             },
+            random_get: (ptr, len) => {
+                const instance = state.instance;
+                ptr >>>= 0;
+                len >>>= 0;
+                const baseBuffer = new Uint8Array(instance.exports.memory.buffer)
+                    .subarray(ptr, ptr + len);
+                for (let iter = 0; iter < len; iter += 65536) {
+                    // `baseBuffer.subarray` automatically saturates at the end of the buffer
+                    config.getRandomValues(baseBuffer.subarray(iter, iter + 65536));
+                }
+            },
+            unix_timestamp_us: () => {
+                const value = Math.floor(Date.now());
+                if (value < 0)
+                    throw new Error("UNIX timestamp inferior to 0");
+                return BigInt(value) * BigInt(1000);
+            },
+            monotonic_clock_us: () => {
+                const nowMs = config.performanceNow();
+                const nowMsInt = Math.floor(nowMs);
+                const now = BigInt(nowMsInt) * BigInt(1000) +
+                    BigInt(Math.floor(((nowMs - nowMsInt) * 1000)));
+                return now;
+            },
             buffer_size: (bufferIndex) => {
                 const buf = state.bufferIndices[bufferIndex];
                 return buf.byteLength;
@@ -248,165 +272,12 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                 state.currentTask = null;
             }
         };
-        const wasiBindings = {
-            // Need to fill the buffer described by `ptr` and `len` with random data.
-            // This data will be used in order to generate secrets. Do not use a dummy implementation!
-            random_get: (ptr, len) => {
-                const instance = state.instance;
-                ptr >>>= 0;
-                len >>>= 0;
-                const baseBuffer = new Uint8Array(instance.exports.memory.buffer)
-                    .subarray(ptr, ptr + len);
-                for (let iter = 0; iter < len; iter += 65536) {
-                    // `baseBuffer.subarray` automatically saturates at the end of the buffer
-                    config.getRandomValues(baseBuffer.subarray(iter, iter + 65536));
-                }
-                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 = state.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 = state.instance;
-                outPtr >>>= 0;
-                // Only stdout and stderr are open for writing.
-                if (fd != 1 && fd != 2) {
-                    return 8;
-                }
-                const mem = new Uint8Array(instance.exports.memory.buffer);
-                // `fd_write` passes a buffer containing itself a list of pointers and lengths to the
-                // actual buffers. See writev(2).
-                let toWrite = "";
-                let totalLength = 0;
-                for (let i = 0; i < num; i++) {
-                    const buf = buffer.readUInt32LE(mem, addr + 4 * i * 2);
-                    const bufLen = buffer.readUInt32LE(mem, addr + 4 * (i * 2 + 1));
-                    toWrite += buffer.utf8BytesToString(mem, buf, bufLen);
-                    totalLength += bufLen;
-                }
-                const flushBuffer = (string) => {
-                    // As documented in the documentation of `println!`, lines are always split by a
-                    // single `\n` in Rust.
-                    while (true) {
-                        const index = string.indexOf('\n');
-                        if (index != -1) {
-                            // Note that it is questionnable to use `console.log` from within a
-                            // library. However this simply reflects the usage of `println!` in the
-                            // Rust code. In other words, it is `println!` that shouldn't be used in
-                            // the first place. The harm of not showing text printed with `println!`
-                            // at all is greater than the harm possibly caused by accidentally leaving
-                            // a `println!` in the code.
-                            console.log(string.substring(0, index));
-                            string = string.substring(index + 1);
-                        }
-                        else {
-                            return string;
-                        }
-                    }
-                };
-                // Append the newly-written data to either `stdout_buffer` or `stderr_buffer`, and
-                // print their content if necessary.
-                if (fd == 1) {
-                    state.stdoutBuffer += toWrite;
-                    state.stdoutBuffer = flushBuffer(state.stdoutBuffer);
-                }
-                else if (fd == 2) {
-                    state.stderrBuffer += toWrite;
-                    state.stderrBuffer = flushBuffer(state.stderrBuffer);
-                }
-                // Need to write in `out_ptr` how much data was "written".
-                buffer.writeUInt32LE(mem, outPtr, totalLength);
-                return 0;
-            },
-            // It's unclear how to properly implement yielding, but a no-op works fine as well.
-            sched_yield: () => {
-                return 0;
-            },
-            // Used by Rust in catastrophic situations, such as a double panic.
-            proc_exit: (retCode) => {
-                state.instance = null;
-                eventCallback({
-                    ty: "wasm-panic",
-                    message: `proc_exit called: ${retCode}`,
-                    currentTask: state.currentTask
-                });
-                state.onShutdownExecutorOrWasmPanic();
-                state.onShutdownExecutorOrWasmPanic = () => { };
-                throw new Error();
-            },
-            // Return the number of environment variables and the total size of all environment
-            // variables. This is called in order to initialize buffers before `environ_get`.
-            environ_sizes_get: (argcOut, argvBufSizeOut) => {
-                const instance = state.instance;
-                argcOut >>>= 0;
-                argvBufSizeOut >>>= 0;
-                let totalLen = 0;
-                config.envVars.forEach(e => totalLen += new TextEncoder().encode(e).length + 1); // +1 for trailing \0
-                const mem = new Uint8Array(instance.exports.memory.buffer);
-                buffer.writeUInt32LE(mem, argcOut, config.envVars.length);
-                buffer.writeUInt32LE(mem, argvBufSizeOut, totalLen);
-                return 0;
-            },
-            // Write the environment variables to the given pointers.
-            // `argv` is a pointer to a buffer that must be overwritten with a list of pointers to
-            // environment variables, and `argvBuf` is a pointer to a buffer where to actually store
-            // the environment variables.
-            // The sizes of the buffers were determined by calling `environ_sizes_get`.
-            environ_get: (argv, argvBuf) => {
-                const instance = state.instance;
-                argv >>>= 0;
-                argvBuf >>>= 0;
-                const mem = new Uint8Array(instance.exports.memory.buffer);
-                let argvPos = 0;
-                let argvBufPos = 0;
-                config.envVars.forEach(envVar => {
-                    const encoded = new TextEncoder().encode(envVar);
-                    buffer.writeUInt32LE(mem, argv + argvPos, argvBuf + argvBufPos);
-                    argvPos += 4;
-                    mem.set(encoded, argvBuf + argvBufPos);
-                    argvBufPos += encoded.length;
-                    buffer.writeUInt8(mem, argvBuf + argvBufPos, 0);
-                    argvBufPos += 1;
-                });
-                return 0;
-            },
-        };
         // 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(wasmModule, {
             // The functions with the "smoldot" prefix are specific to smoldot.
             "smoldot": smoldotJsBindings,
-            // As the Rust code is compiled for wasi, some more wasi-specific imports exist.
-            "wasi_snapshot_preview1": wasiBindings,
         });
         state.instance = result;
         // Smoldot requires an initial call to the `init` function in order to do its internal

package/dist/cjs/public-types.d.ts

@@ -142,12 +142,20 @@ export interface Chain {
      * The JSON-RPC callback will no longer be called. This is the case immediately after this
      * function is called. Any on-going JSON-RPC request is instantaneously aborted.
      *
-     * Trying to use the chain again will lead to an exception being thrown.
+     * Trying to use the chain again will lead to a {@link AlreadyDestroyedError} exception
+     * being thrown.
      *
-     * If this chain is a relay chain, then all parachains that use it will continue to work. Smoldot
-     * automatically keeps alive all relay chains that have an active parachains. There is no need
-     * to track parachains and relay chains, or to destroy them in the correct order, as this is
-     * handled automatically internally.
+     * While the chain instantaneously disappears from the public API as soon as this function is
+     * called, its shutdown process actually happens asynchronously in the background. This means
+     * for example that networking connections to the chain will remain open for a little bit even
+     * after this function returns.
+     *
+     * If the chain is a relay chain, and that there exists {@link Chain} instances corresponding
+     * to parachains that are using this relay chain, then these parachains will continue to work
+     * and the relay chain will actually remain connected in the background.
+     * Smoldot automatically keeps alive all relay chains that have an active parachains. There
+     * is no need to track parachains and relay chains, or to destroy them in the correct order,
+     * as this is handled automatically internally.
      *
      * @throws {@link AlreadyDestroyedError} If the chain has already been removed or the client has been terminated.
      * @throws {@link CrashError} If the background client has crashed.