smoldot 1.0.4 → 1.0.6

package/dist/mjs/instance/bindings-smoldot-light.js

@@ -1,280 +0,0 @@
-// 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/>.
-//! Exports a function that provides bindings for the bindings found in the Rust part of the code.
-//!
-//! In order to use this code, call the function passing an object, then fill the `instance` field
-//! of that object with the Wasm instance.
-import * as buffer from './buffer.js';
-/**
- * Emitted by `connect` if the multiaddress couldn't be parsed or contains an invalid protocol.
- *
- * @see connect
- */
-export class ConnectionError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-export default function (config) {
-    // Used below to store the list of all connections.
-    // The indices within this array are chosen by the Rust code.
-    let connections = {};
-    // Object containing a boolean indicating whether the `killAll` function has been invoked by
-    // the user.
-    const killedTracked = { killed: false };
-    const killAll = () => {
-        killedTracked.killed = true;
-        // TODO: kill timers as well?
-        for (const connection in connections) {
-            connections[connection].reset();
-            delete connections[connection];
-        }
-    };
-    const imports = {
-        // Must exit with an error. A human-readable message can be found in the WebAssembly
-        // memory in the given buffer.
-        panic: (ptr, len) => {
-            const instance = config.instance;
-            ptr >>>= 0;
-            len >>>= 0;
-            const message = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), ptr, len);
-            config.onPanic(message);
-        },
-        buffer_size: (bufferIndex) => {
-            const buf = config.bufferIndices[bufferIndex];
-            return buf.byteLength;
-        },
-        buffer_copy: (bufferIndex, targetPtr) => {
-            const instance = config.instance;
-            targetPtr = targetPtr >>> 0;
-            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) => {
-            if (killedTracked.killed)
-                return;
-            config.jsonRpcResponsesNonEmptyCallback(chainId);
-        },
-        // Used by the Rust side to emit a log entry.
-        // See also the `max_log_level` parameter in the configuration.
-        log: (level, targetPtr, targetLen, messagePtr, messageLen) => {
-            if (killedTracked.killed)
-                return;
-            const instance = config.instance;
-            targetPtr >>>= 0;
-            targetLen >>>= 0;
-            messagePtr >>>= 0;
-            messageLen >>>= 0;
-            if (config.logCallback) {
-                const mem = new Uint8Array(instance.exports.memory.buffer);
-                let target = buffer.utf8BytesToString(mem, targetPtr, targetLen);
-                let message = buffer.utf8BytesToString(mem, messagePtr, messageLen);
-                config.logCallback(level, target, message);
-            }
-        },
-        // Must call `timer_finished` after the given number of milliseconds has elapsed.
-        start_timer: (ms) => {
-            if (killedTracked.killed)
-                return;
-            const instance = config.instance;
-            // In both NodeJS and browsers, if `setTimeout` is called with a value larger than
-            // 2147483647, the delay is for some reason instead set to 1.
-            // As mentioned in the documentation of `start_timer`, it is acceptable to end the
-            // timer before the given number of milliseconds has passed.
-            if (ms > 2147483647)
-                ms = 2147483647;
-            // In browsers, `setTimeout` works as expected when `ms` equals 0. However, NodeJS
-            // requires a minimum of 1 millisecond (if `0` is passed, it is automatically replaced
-            // with `1`) and wants you to use `setImmediate` instead.
-            if (ms < 1 && typeof setImmediate === "function") {
-                setImmediate(() => {
-                    if (killedTracked.killed)
-                        return;
-                    try {
-                        instance.exports.timer_finished();
-                    }
-                    catch (_error) { }
-                });
-            }
-            else {
-                setTimeout(() => {
-                    if (killedTracked.killed)
-                        return;
-                    try {
-                        instance.exports.timer_finished();
-                    }
-                    catch (_error) { }
-                }, ms);
-            }
-        },
-        // Must create a new connection object. This implementation stores the created object in
-        // `connections`.
-        connection_new: (connectionId, addrPtr, addrLen, errorBufferIndexPtr) => {
-            const instance = config.instance;
-            addrPtr >>>= 0;
-            addrLen >>>= 0;
-            errorBufferIndexPtr >>>= 0;
-            if (!!connections[connectionId]) {
-                throw new Error("internal error: connection already allocated");
-            }
-            try {
-                if (killedTracked.killed)
-                    throw new Error("killAll invoked");
-                const address = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), addrPtr, addrLen);
-                const connec = config.connect({
-                    address,
-                    onOpen: (info) => {
-                        if (killedTracked.killed)
-                            return;
-                        try {
-                            switch (info.type) {
-                                case 'single-stream': {
-                                    instance.exports.connection_open_single_stream(connectionId, 0, info.initialWritableBytes, info.writeClosable ? 1 : 0);
-                                    break;
-                                }
-                                case 'multi-stream': {
-                                    const handshakeTy = new Uint8Array(1 + info.localTlsCertificateMultihash.length + info.remoteTlsCertificateMultihash.length);
-                                    buffer.writeUInt8(handshakeTy, 0, 0);
-                                    handshakeTy.set(info.localTlsCertificateMultihash, 1);
-                                    handshakeTy.set(info.remoteTlsCertificateMultihash, 1 + info.localTlsCertificateMultihash.length);
-                                    config.bufferIndices[0] = handshakeTy;
-                                    instance.exports.connection_open_multi_stream(connectionId, 0);
-                                    delete config.bufferIndices[0];
-                                    break;
-                                }
-                            }
-                        }
-                        catch (_error) { }
-                    },
-                    onConnectionReset: (message) => {
-                        if (killedTracked.killed)
-                            return;
-                        try {
-                            config.bufferIndices[0] = new TextEncoder().encode(message);
-                            instance.exports.connection_reset(connectionId, 0);
-                            delete config.bufferIndices[0];
-                        }
-                        catch (_error) { }
-                    },
-                    onWritableBytes: (numExtra, streamId) => {
-                        if (killedTracked.killed)
-                            return;
-                        try {
-                            instance.exports.stream_writable_bytes(connectionId, streamId || 0, numExtra);
-                        }
-                        catch (_error) { }
-                    },
-                    onMessage: (message, streamId) => {
-                        if (killedTracked.killed)
-                            return;
-                        try {
-                            config.bufferIndices[0] = message;
-                            instance.exports.stream_message(connectionId, streamId || 0, 0);
-                            delete config.bufferIndices[0];
-                        }
-                        catch (_error) { }
-                    },
-                    onStreamOpened: (streamId, direction, initialWritableBytes) => {
-                        if (killedTracked.killed)
-                            return;
-                        try {
-                            instance.exports.connection_stream_opened(connectionId, streamId, direction === 'outbound' ? 1 : 0, initialWritableBytes);
-                        }
-                        catch (_error) { }
-                    },
-                    onStreamReset: (streamId) => {
-                        if (killedTracked.killed)
-                            return;
-                        try {
-                            instance.exports.stream_reset(connectionId, streamId);
-                        }
-                        catch (_error) { }
-                    }
-                });
-                connections[connectionId] = connec;
-                return 0;
-            }
-            catch (error) {
-                const isBadAddress = error instanceof ConnectionError;
-                let errorStr = "Unknown error";
-                if (error instanceof Error) {
-                    errorStr = error.toString();
-                }
-                const mem = new Uint8Array(instance.exports.memory.buffer);
-                config.bufferIndices[0] = new TextEncoder().encode(errorStr);
-                buffer.writeUInt32LE(mem, errorBufferIndexPtr, 0);
-                buffer.writeUInt8(mem, errorBufferIndexPtr + 4, isBadAddress ? 1 : 0);
-                return 1;
-            }
-        },
-        // Must close and destroy the connection object.
-        reset_connection: (connectionId) => {
-            if (killedTracked.killed)
-                return;
-            const connection = connections[connectionId];
-            connection.reset();
-            delete connections[connectionId];
-        },
-        // Opens a new substream on a multi-stream connection.
-        connection_stream_open: (connectionId) => {
-            const connection = connections[connectionId];
-            connection.openOutSubstream();
-        },
-        // Closes a substream on a multi-stream connection.
-        connection_stream_reset: (connectionId, streamId) => {
-            const connection = connections[connectionId];
-            connection.reset(streamId);
-        },
-        // Must queue the data found in the WebAssembly memory at the given pointer. It is assumed
-        // that this function is called only when the connection is in an open state.
-        stream_send: (connectionId, streamId, ptr, len) => {
-            if (killedTracked.killed)
-                return;
-            const instance = config.instance;
-            ptr >>>= 0;
-            len >>>= 0;
-            const data = new Uint8Array(instance.exports.memory.buffer).slice(ptr, ptr + len);
-            const connection = connections[connectionId];
-            connection.send(data, streamId); // TODO: docs says the streamId is provided only for multi-stream connections, but here it's always provided
-        },
-        stream_send_close: (connectionId, streamId) => {
-            if (killedTracked.killed)
-                return;
-            const connection = connections[connectionId];
-            connection.closeSend(streamId); // TODO: docs says the streamId is provided only for multi-stream connections, but here it's always provided
-        },
-        current_task_entered: (ptr, len) => {
-            if (killedTracked.killed)
-                return;
-            const instance = config.instance;
-            ptr >>>= 0;
-            len >>>= 0;
-            const taskName = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), ptr, len);
-            if (config.currentTaskCallback)
-                config.currentTaskCallback(taskName);
-        },
-        current_task_exit: () => {
-            if (killedTracked.killed)
-                return;
-            if (config.currentTaskCallback)
-                config.currentTaskCallback(null);
-        }
-    };
-    return { imports, killAll };
-}

package/dist/mjs/instance/bindings-wasi.d.ts

@@ -1,27 +0,0 @@
-import type { SmoldotWasmInstance } from './bindings.js';
-export interface Config {
-    instance?: SmoldotWasmInstance;
-    /**
-     * 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"];`
-     *
-     * Must never be modified after the bindings have been initialized.
-     */
-    envVars: string[];
-    /**
-     * Closure to call when the Wasm instance calls `proc_exit`.
-     *
-     * This callback will always be invoked from within a binding called the Wasm instance.
-     */
-    onProcExit: (retCode: number) => never;
-}
-declare const _default: (config: Config) => WebAssembly.ModuleImports;
-export default _default;

package/dist/mjs/instance/bindings-wasi.js

@@ -1,170 +0,0 @@
-// 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/>.
-//! Exports a function that provides bindings for the Wasi interface.
-//!
-//! These bindings can then be used by the Wasm virtual machine to invoke Wasi-related functions.
-//! See <https://wasi.dev/>.
-//!
-//! In order to use this code, call the function passing an object, then fill the `instance` field
-//! of that object with the Wasm instance.
-import * as buffer from './buffer.js';
-export default (config) => {
-    // Buffers holding temporary data being written by the Rust code to respectively stdout and
-    // stderr.
-    let stdoutBuffer = "";
-    let stderrBuffer = "";
-    return {
-        // 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 = config.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 = 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;
-            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) {
-                stdoutBuffer += toWrite;
-                stdoutBuffer = flushBuffer(stdoutBuffer);
-            }
-            else if (fd == 2) {
-                stderrBuffer += toWrite;
-                stderrBuffer = flushBuffer(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) => {
-            config.onProcExit(retCode);
-        },
-        // 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 = config.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 = config.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;
-        },
-    };
-};

package/dist/mjs/instance/bindings.d.ts

@@ -1,31 +0,0 @@
-/**
- * Interface that the Wasm module exports. Contains the functions that are exported by the Rust
- * code.
- *
- * Must match the bindings found in the Rust code.
- */
-export interface SmoldotWasmExports extends WebAssembly.Exports {
-    memory: WebAssembly.Memory;
-    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;
-    chain_is_ok: (chainId: number) => number;
-    chain_error_len: (chainId: number) => number;
-    chain_error_ptr: (chainId: number) => number;
-    json_rpc_send: (textBufferIndex: number, chainId: number) => number;
-    json_rpc_responses_peek: (chainId: number) => number;
-    json_rpc_responses_pop: (chainId: 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;
-    stream_message: (connectionId: number, streamId: number, bufferIndex: number) => void;
-    connection_stream_opened: (connectionId: number, streamId: number, outbound: number, initialWritableBytes: number) => void;
-    connection_reset: (connectionId: number, bufferIndex: number) => void;
-    stream_reset: (connectionId: number, streamId: number) => void;
-}
-export interface SmoldotWasmInstance extends WebAssembly.Instance {
-    readonly exports: SmoldotWasmExports;
-}

package/dist/mjs/instance/bindings.js

@@ -1,4 +0,0 @@
-// Smoldot
-// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
-export {};

package/dist/mjs/instance/instance.d.ts

@@ -1,45 +0,0 @@
-import * as instance from './raw-instance.js';
-export { PlatformBindings, ConnectionError, ConnectionConfig, Connection } from './raw-instance.js';
-/**
- * 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();
-}
-/**
- * Contains the configuration of the instance.
- */
-export interface Config {
-    wasmModule: Promise<WebAssembly.Module>;
-    logCallback: (level: number, target: string, message: string) => void;
-    maxLogLevel: number;
-    cpuRateLimit: number;
-}
-export interface Instance {
-    request: (request: string, chainId: number) => void;
-    nextJsonRpcResponse: (chainId: number) => Promise<string>;
-    addChain: (chainSpec: string, databaseContent: string, potentialRelayChains: number[], disableJsonRpc: boolean) => Promise<{
-        success: true;
-        chainId: number;
-    } | {
-        success: false;
-        error: string;
-    }>;
-    removeChain: (chainId: number) => void;
-    startShutdown: () => void;
-}
-export declare function start(configMessage: Config, platformBindings: instance.PlatformBindings): Instance;