smoldot 1.0.4 → 1.0.6

package/dist/mjs/no-auto-bytecode-deno.js

@@ -0,0 +1,210 @@
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { start as innerStart } from './internals/client.js';
+export { AddChainError, AlreadyDestroyedError, CrashError, MalformedJsonRpcError, QueueFullError, JsonRpcDisabledError } from './public-types.js';
+/**
+ * Initializes a new client. This is a pre-requisite to connecting to a blockchain.
+ *
+ * Can never fail.
+ *
+ * @param options Configuration of the client.
+ */
+export function startWithBytecode(options) {
+    options.forbidWebRtc = true;
+    return innerStart(options || {}, options.bytecode, {
+        performanceNow: () => {
+            return performance.now();
+        },
+        getRandomValues: (buffer) => {
+            const crypto = globalThis.crypto;
+            if (!crypto)
+                throw new Error('randomness not available');
+            crypto.getRandomValues(buffer);
+        },
+        connect: (config) => {
+            return connect(config);
+        }
+    });
+}
+/**
+ * Tries to open a new connection using the given configuration.
+ *
+ * @see Connection
+ * @throws {@link ConnectionError} If the multiaddress couldn't be parsed or contains an invalid protocol.
+ */
+function connect(config) {
+    if (config.address.ty === "websocket") {
+        const socket = new WebSocket(config.address.url);
+        socket.binaryType = 'arraybuffer';
+        const bufferedAmountCheck = { quenedUnreportedBytes: 0, nextTimeout: 10 };
+        const checkBufferedAmount = () => {
+            if (socket.readyState != 1)
+                return;
+            // Note that we might expect `bufferedAmount` to always be <= the sum of the lengths
+            // of all the data that has been sent, but that might not be the case. For this
+            // reason, we use `bufferedAmount` as a hint rather than a correct value.
+            const bufferedAmount = socket.bufferedAmount;
+            let wasSent = bufferedAmountCheck.quenedUnreportedBytes - bufferedAmount;
+            if (wasSent < 0)
+                wasSent = 0;
+            bufferedAmountCheck.quenedUnreportedBytes -= wasSent;
+            if (bufferedAmountCheck.quenedUnreportedBytes != 0) {
+                setTimeout(checkBufferedAmount, bufferedAmountCheck.nextTimeout);
+                bufferedAmountCheck.nextTimeout *= 2;
+                if (bufferedAmountCheck.nextTimeout > 500)
+                    bufferedAmountCheck.nextTimeout = 500;
+            }
+            // Note: it is important to call `onWritableBytes` at the very end, as it might
+            // trigger a call to `send`.
+            if (wasSent != 0)
+                config.onWritableBytes(wasSent);
+        };
+        socket.onopen = () => {
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: false });
+        };
+        socket.onclose = (event) => {
+            const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
+            config.onConnectionReset(message);
+        };
+        socket.onmessage = (msg) => {
+            config.onMessage(new Uint8Array(msg.data));
+        };
+        return {
+            reset: () => {
+                // We can't set these fields to null because the TypeScript definitions don't
+                // allow it, but we can set them to dummy values.
+                socket.onopen = () => { };
+                socket.onclose = () => { };
+                socket.onmessage = () => { };
+                socket.onerror = () => { };
+                socket.close();
+            },
+            send: (data) => {
+                // The WebSocket library that we use seems to spontaneously transition connections
+                // to the "closed" state but not call the `onclosed` callback immediately. Calling
+                // `send` on that object throws an exception. In order to avoid panicking smoldot,
+                // we thus absorb any exception thrown here.
+                // See also <https://github.com/paritytech/smoldot/issues/2937>.
+                try {
+                    socket.send(data);
+                    if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
+                        bufferedAmountCheck.nextTimeout = 10;
+                        setTimeout(checkBufferedAmount, 10);
+                    }
+                    bufferedAmountCheck.quenedUnreportedBytes += data.length;
+                }
+                catch (_error) { }
+            },
+            closeSend: () => { throw new Error('Wrong connection type'); },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
+    }
+    else if (config.address.ty === "tcp") {
+        const socket = {
+            destroyed: false,
+            inner: Deno.connect({
+                hostname: config.address.hostname,
+                port: config.address.port,
+            }).catch((error) => {
+                socket.destroyed = true;
+                config.onConnectionReset(error.toString());
+                return null;
+            })
+        };
+        socket.inner = socket.inner.then((established) => {
+            // TODO: at the time of writing of this comment, `setNoDelay` is still unstable
+            //established.setNoDelay();
+            if (socket.destroyed)
+                return established;
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: true });
+            // Spawns an asynchronous task that continuously reads from the socket.
+            // Every time data is read, the task re-executes itself in order to continue reading.
+            // The task ends automatically if an EOF or error is detected, which should also happen
+            // if the user calls `close()`.
+            const read = (readBuffer) => __awaiter(this, void 0, void 0, function* () {
+                if (socket.destroyed || established === null)
+                    return;
+                let outcome = null;
+                try {
+                    outcome = yield established.read(readBuffer);
+                }
+                catch (error) {
+                    // The type of `error` is unclear, but we assume that it implements `Error`
+                    outcome = error.toString();
+                }
+                if (socket.destroyed)
+                    return;
+                if (typeof outcome !== 'number' || outcome === null) {
+                    // The socket is reported closed, but `socket.destroyed` is still `false` (see
+                    // check above). As such, we must inform the inner layers.
+                    socket.destroyed = true;
+                    config.onConnectionReset(outcome === null ? "EOF when reading socket" : outcome);
+                    return;
+                }
+                console.assert(outcome !== 0); // `read` guarantees to return a non-zero value.
+                config.onMessage(readBuffer.slice(0, outcome));
+                return read(readBuffer);
+            });
+            read(new Uint8Array(32768));
+            return established;
+        });
+        return {
+            reset: () => {
+                socket.destroyed = true;
+                socket.inner.then((connec) => connec.close());
+            },
+            send: (data) => {
+                let dataCopy = Uint8Array.from(data); // Deep copy of the data
+                socket.inner = socket.inner.then((c) => __awaiter(this, void 0, void 0, function* () {
+                    while (dataCopy.length > 0) {
+                        if (socket.destroyed || c === null)
+                            return c;
+                        let outcome;
+                        try {
+                            outcome = yield c.write(dataCopy);
+                            config.onWritableBytes(dataCopy.length);
+                        }
+                        catch (error) {
+                            // The type of `error` is unclear, but we assume that it implements `Error`
+                            outcome = error.toString();
+                        }
+                        if (typeof outcome !== 'number') {
+                            // The socket is reported closed, but `socket.destroyed` is still
+                            // `false` (see check above). As such, we must inform the inner layers.
+                            socket.destroyed = true;
+                            config.onConnectionReset(outcome);
+                            return c;
+                        }
+                        // Note that, contrary to `read`, it is possible for `outcome` to be 0.
+                        // This happen if the write had to be interrupted, and the only thing
+                        // we have to do is try writing again.
+                        dataCopy = dataCopy.slice(outcome);
+                    }
+                    return c;
+                }));
+            },
+            closeSend: () => {
+                socket.inner = socket.inner.then((c) => __awaiter(this, void 0, void 0, function* () {
+                    yield (c === null || c === void 0 ? void 0 : c.closeWrite());
+                    return c;
+                }));
+            },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
+    }
+    else {
+        // Should never happen, as we tweak the options to refuse connection types that
+        // we don't support.
+        throw new Error();
+    }
+}

package/dist/mjs/no-auto-bytecode-nodejs.d.ts

@@ -0,0 +1,10 @@
+import { Client, ClientOptionsWithBytecode } from './public-types.js';
+export { AddChainError, AddChainOptions, AlreadyDestroyedError, Chain, Client, ClientOptions, ClientOptionsWithBytecode, SmoldotBytecode, CrashError, MalformedJsonRpcError, QueueFullError, JsonRpcDisabledError, LogCallback } from './public-types.js';
+/**
+ * Initializes a new client. This is a pre-requisite to connecting to a blockchain.
+ *
+ * Can never fail.
+ *
+ * @param options Configuration of the client.
+ */
+export declare function startWithBytecode(options: ClientOptionsWithBytecode): Client;

package/dist/mjs/no-auto-bytecode-nodejs.js

@@ -0,0 +1,179 @@
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+import { start as innerStart } from './internals/client.js';
+import { WebSocket } from 'ws';
+import { performance } from 'node:perf_hooks';
+import { createConnection as nodeCreateConnection } from 'node:net';
+import { randomFillSync } from 'node:crypto';
+export { AddChainError, AlreadyDestroyedError, CrashError, MalformedJsonRpcError, QueueFullError, JsonRpcDisabledError } from './public-types.js';
+/**
+ * Initializes a new client. This is a pre-requisite to connecting to a blockchain.
+ *
+ * Can never fail.
+ *
+ * @param options Configuration of the client.
+ */
+export function startWithBytecode(options) {
+    options.forbidWebRtc = true;
+    return innerStart(options || {}, options.bytecode, {
+        performanceNow: () => {
+            return performance.now();
+        },
+        getRandomValues: (buffer) => {
+            if (buffer.length >= 1024 * 1024)
+                throw new Error('getRandomValues buffer too large');
+            randomFillSync(buffer);
+        },
+        connect: (config) => {
+            return connect(config);
+        }
+    });
+}
+/**
+ * Tries to open a new connection using the given configuration.
+ *
+ * @see Connection
+ * @throws {@link ConnectionError} If the multiaddress couldn't be parsed or contains an invalid protocol.
+ */
+function connect(config) {
+    if (config.address.ty === "websocket") {
+        const socket = new WebSocket(config.address.url);
+        socket.binaryType = 'arraybuffer';
+        const bufferedAmountCheck = { quenedUnreportedBytes: 0, nextTimeout: 10 };
+        const checkBufferedAmount = () => {
+            if (socket.readyState != 1)
+                return;
+            // Note that we might expect `bufferedAmount` to always be <= the sum of the lengths
+            // of all the data that has been sent, but that seems to not be the case. It is
+            // unclear whether this is intended or a bug, but is is likely that `bufferedAmount`
+            // also includes WebSocket headers. For this reason, we use `bufferedAmount` as a hint
+            // rather than a correct value.
+            const bufferedAmount = socket.bufferedAmount;
+            let wasSent = bufferedAmountCheck.quenedUnreportedBytes - bufferedAmount;
+            if (wasSent < 0)
+                wasSent = 0;
+            bufferedAmountCheck.quenedUnreportedBytes -= wasSent;
+            if (bufferedAmountCheck.quenedUnreportedBytes != 0) {
+                setTimeout(checkBufferedAmount, bufferedAmountCheck.nextTimeout);
+                bufferedAmountCheck.nextTimeout *= 2;
+                if (bufferedAmountCheck.nextTimeout > 500)
+                    bufferedAmountCheck.nextTimeout = 500;
+            }
+            // Note: it is important to call `onWritableBytes` at the very end, as it might
+            // trigger a call to `send`.
+            if (wasSent != 0)
+                config.onWritableBytes(wasSent);
+        };
+        socket.onopen = () => {
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: false });
+        };
+        socket.onclose = (event) => {
+            const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
+            config.onConnectionReset(message);
+            socket.onopen = () => { };
+            socket.onclose = () => { };
+            socket.onmessage = () => { };
+            socket.onerror = () => { };
+        };
+        socket.onerror = (event) => {
+            config.onConnectionReset(event.message);
+            socket.onopen = () => { };
+            socket.onclose = () => { };
+            socket.onmessage = () => { };
+            socket.onerror = () => { };
+        };
+        socket.onmessage = (msg) => {
+            config.onMessage(new Uint8Array(msg.data));
+        };
+        return {
+            reset: () => {
+                // We can't set these fields to null because the TypeScript definitions don't
+                // allow it, but we can set them to dummy values.
+                socket.onopen = () => { };
+                socket.onclose = () => { };
+                socket.onmessage = () => { };
+                socket.onerror = () => { };
+                socket.close();
+            },
+            send: (data) => {
+                socket.send(data);
+                if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
+                    bufferedAmountCheck.nextTimeout = 10;
+                    setTimeout(checkBufferedAmount, 10);
+                }
+                bufferedAmountCheck.quenedUnreportedBytes += data.length;
+            },
+            closeSend: () => { throw new Error('Wrong connection type'); },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
+    }
+    else if (config.address.ty === "tcp") {
+        const socket = nodeCreateConnection({
+            host: config.address.hostname,
+            port: config.address.port,
+        });
+        // Number of bytes queued using `socket.write` and where `write` has returned false.
+        const drainingBytes = { num: 0 };
+        socket.setNoDelay();
+        socket.on('connect', () => {
+            if (socket.destroyed)
+                return;
+            config.onOpen({
+                type: 'single-stream', handshake: 'multistream-select-noise-yamux',
+                initialWritableBytes: socket.writableHighWaterMark, writeClosable: true
+            });
+        });
+        socket.on('close', (hasError) => {
+            if (socket.destroyed)
+                return;
+            // NodeJS doesn't provide a reason why the closing happened, but only
+            // whether it was caused by an error.
+            const message = hasError ? "Error" : "Closed gracefully";
+            config.onConnectionReset(message);
+        });
+        socket.on('error', () => { });
+        socket.on('data', (message) => {
+            if (socket.destroyed)
+                return;
+            config.onMessage(new Uint8Array(message.buffer));
+        });
+        socket.on('drain', () => {
+            // The bytes queued using `socket.write` and where `write` has returned false have now
+            // been sent. Notify the API that it can write more data.
+            if (socket.destroyed)
+                return;
+            const val = drainingBytes.num;
+            drainingBytes.num = 0;
+            config.onWritableBytes(val);
+        });
+        return {
+            reset: () => {
+                socket.destroy();
+            },
+            send: (data) => {
+                const dataLen = data.length;
+                const allWritten = socket.write(data);
+                if (allWritten) {
+                    setImmediate(() => {
+                        if (!socket.writable)
+                            return;
+                        config.onWritableBytes(dataLen);
+                    });
+                }
+                else {
+                    drainingBytes.num += dataLen;
+                }
+            },
+            closeSend: () => {
+                socket.end();
+            },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
+    }
+    else {
+        // Should never happen, as we tweak the options to refuse connection types that
+        // we don't support.
+        throw new Error();
+    }
+}

package/dist/mjs/{client.d.ts → public-types.d.ts}

@@ -1,5 +1,3 @@
-import { PlatformBindings } from './instance/instance.js';
-export { MalformedJsonRpcError, QueueFullError, CrashError } from './instance/instance.js';
 /**
  * Thrown in case of a problem when initializing the chain.
  */
@@ -19,6 +17,32 @@ export declare class AlreadyDestroyedError extends Error {
 export declare class JsonRpcDisabledError extends Error {
     constructor();
 }
+/**
+ * Thrown in case the underlying client encounters an unexpected crash.
+ *
+ * This is always an internal bug in smoldot and is never supposed to happen.
+ */
+export declare class CrashError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown in case a malformed JSON-RPC request is sent.
+ */
+export declare class MalformedJsonRpcError extends Error {
+    constructor();
+}
+/**
+ * Thrown in case the buffer of JSON-RPC requests is full and cannot accept any more request.
+ */
+export declare class QueueFullError extends Error {
+    constructor();
+}
+/**
+ * Bytecode of the smoldot client.
+ */
+export interface SmoldotBytecode {
+    readonly wasm: WebAssembly.Module;
+}
 /**
  * Client with zero or more active connections to blockchains.
  */
@@ -150,6 +174,19 @@ export type LogCallback = (level: number, target: string, message: string) => vo
  * Configuration of a client.
  */
 export interface ClientOptions {
+    /**
+     * One end of a port (created using `new MessageChannel`). The other end must be passed to the
+     * `run` function found in `smoldot/worker`.
+     *
+     * If this option isn't set then the smoldot light client will run entirely on the "current
+     * thread", which might slow down other components that also run on this thread.
+     * If this option is set, then the {@link Client} that is created is merely a frontend that
+     * sends messages on the provided port.
+     *
+     * It is intended that the other end of this port is sent to a background worker, and the
+     * `run` function be called in this background worker. However this is in no way mandatory.
+     */
+    portToWorker?: MessagePort;
     /**
      * Callback that the client will invoke in order to report a log event.
      *
@@ -176,6 +213,9 @@ export interface ClientOptions {
      * Note that this is implemented by sleeping for certain amounts of time in order for the average
      * CPU consumption to not go beyond the given limit. It is therefore still possible for the
      * client to use high amounts of CPU for short amounts of time.
+     *
+     * If {@link ClientOptions.portToWorker} is set, then the CPU rate limit applies to the
+     * worker.
      */
     cpuRateLimit?: number;
     /**
@@ -233,6 +273,15 @@ export interface ClientOptions {
      */
     forbidWebRtc?: boolean;
 }
+/**
+ * Configuration of a client.
+ */
+export interface ClientOptionsWithBytecode extends ClientOptions {
+    /**
+     * Smoldot bytecode. Can be either fully loaded or a `Promise`.
+     */
+    bytecode: SmoldotBytecode | Promise<SmoldotBytecode>;
+}
 /**
  * Configuration of a blockchain.
  */
@@ -317,4 +366,3 @@ export interface AddChainOptions {
      */
     disableJsonRpc?: boolean;
 }
-export declare function start(options: ClientOptions, wasmModule: Promise<WebAssembly.Module>, platformBindings: PlatformBindings): Client;

package/dist/mjs/public-types.js

@@ -0,0 +1,67 @@
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.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
+// (at your option) any later version.
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+/**
+ * Thrown in case of a problem when initializing the chain.
+ */
+export class AddChainError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AddChainError";
+    }
+}
+/**
+ * Thrown in case the API user tries to use a chain or client that has already been destroyed.
+ */
+export class AlreadyDestroyedError extends Error {
+    constructor() {
+        super();
+        this.name = "AlreadyDestroyedError";
+    }
+}
+/**
+ * Thrown when trying to send a JSON-RPC message to a chain whose JSON-RPC system hasn't been
+ * enabled.
+ */
+export class JsonRpcDisabledError extends Error {
+    constructor() {
+        super();
+        this.name = "JsonRpcDisabledError";
+    }
+}
+/**
+ * Thrown in case the underlying client encounters an unexpected crash.
+ *
+ * This is always an internal bug in smoldot and is never supposed to happen.
+ */
+export class CrashError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+/**
+ * Thrown in case a malformed JSON-RPC request is sent.
+ */
+export class MalformedJsonRpcError extends Error {
+    constructor() {
+        super("JSON-RPC request is malformed");
+    }
+}
+/**
+ * Thrown in case the buffer of JSON-RPC requests is full and cannot accept any more request.
+ */
+export class QueueFullError extends Error {
+    constructor() {
+        super("JSON-RPC requests queue is full");
+    }
+}

package/dist/mjs/worker-browser.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Runs the CPU-heavy parts of smoldot. Must be passed a port whose other end is passed to
+ * `ClientOptions.portToWorker`.
+ *
+ * Returns a `Promise` that is ready when the smoldot client is shut down (either because it
+ * crashes or intentionally with a call to `Client.terminate`).
+ * Since this function is asynchronous, this `Promise` is wrapped around another `Promise`. In
+ * other words, the outer `Promise` is ready when execution starts, and the inner `Promise` is
+ * ready when execution ends.
+ */
+export declare function run(messagePort: MessagePort): Promise<Promise<void>>;

package/dist/mjs/worker-browser.js

@@ -0,0 +1,59 @@
+// Smoldot
+// Copyright (C) 2023  Pierre Krieger
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// 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
+// (at your option) any later version.
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import * as instance from './internals/remote-instance.js';
+/**
+ * Runs the CPU-heavy parts of smoldot. Must be passed a port whose other end is passed to
+ * `ClientOptions.portToWorker`.
+ *
+ * Returns a `Promise` that is ready when the smoldot client is shut down (either because it
+ * crashes or intentionally with a call to `Client.terminate`).
+ * Since this function is asynchronous, this `Promise` is wrapped around another `Promise`. In
+ * other words, the outer `Promise` is ready when execution starts, and the inner `Promise` is
+ * ready when execution ends.
+ */
+export function run(messagePort) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const whenShutdown = yield instance.startInstanceServer({
+            envVars: [],
+            performanceNow: () => {
+                return performance.now();
+            },
+            getRandomValues: (buffer) => {
+                const crypto = globalThis.crypto;
+                if (!crypto)
+                    throw new Error('randomness not available');
+                // 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);
+                }
+            },
+        }, messagePort);
+        return whenShutdown;
+    });
+}

package/dist/mjs/worker-deno.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Runs the CPU-heavy parts of smoldot. Must be passed a port whose other end is passed to
+ * `ClientOptions.portToWorker`.
+ *
+ * Returns a `Promise` that is ready when the smoldot client is shut down (either because it
+ * crashes or intentionally with a call to `Client.terminate`).
+ * Since this function is asynchronous, this `Promise` is wrapped around another `Promise`. In
+ * other words, the outer `Promise` is ready when execution starts, and the inner `Promise` is
+ * ready when execution ends.
+ */
+export declare function run(messagePort: MessagePort): Promise<Promise<void>>;