smoldot 1.0.4 → 1.0.6

package/dist/mjs/instance/instance.js

@@ -1,269 +0,0 @@
-// 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());
-    });
-};
-// 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 buffer from './buffer.js';
-import * as instance from './raw-instance.js';
-import { AlreadyDestroyedError } from '../client.js';
-export { ConnectionError } 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 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");
-    }
-}
-export function start(configMessage, platformBindings) {
-    // This variable represents the state of the instance, and serves two different purposes:
-    //
-    // - At initialization, it is a Promise containing the Wasm VM is still initializing.
-    // - After the Wasm VM has finished initialization, contains the `WebAssembly.Instance` object.
-    //
-    let state;
-    const crashError = {};
-    const currentTask = { name: null };
-    const printError = { printError: true };
-    // Contains the information of each chain that is currently alive.
-    let chains = new Map();
-    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);
-                    }
-                    chain.jsonRpcResponsesPromises = [];
-                }
-            },
-            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];
-        })
-    };
-    function queueOperation(operation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // What to do depends on the type of `state`.
-            // See the documentation of the `state` variable for information.
-            if (!state.initialized) {
-                // A message has been received while the Wasm VM is still initializing. Queue it for when
-                // initialization is over.
-                return state.promise.then(([instance, bufferIndices]) => operation(instance, bufferIndices));
-            }
-            else {
-                // Everything is already initialized. Process the message synchronously.
-                return operation(state.instance, state.bufferIndices);
-            }
-        });
-    }
-    return {
-        request: (request, chainId) => {
-            // Because `request` is passed as parameter an identifier returned by `addChain`, it is
-            // always the case that the Wasm instance is already initialized. The only possibility for
-            // it to not be the case is if the user completely invented the `chainId`.
-            if (!state.initialized)
-                throw new Error("Internal error");
-            if (crashError.error)
-                throw crashError.error;
-            let retVal;
-            try {
-                state.bufferIndices[0] = new TextEncoder().encode(request);
-                retVal = state.instance.exports.json_rpc_send(0, chainId) >>> 0;
-            }
-            catch (_error) {
-                console.assert(crashError.error);
-                throw crashError.error;
-            }
-            switch (retVal) {
-                case 0: break;
-                case 1: throw new MalformedJsonRpcError();
-                case 2: throw new QueueFullError();
-                default: throw new Error("Internal error: unknown json_rpc_send error code: " + retVal);
-            }
-        },
-        nextJsonRpcResponse: (chainId) => __awaiter(this, void 0, void 0, function* () {
-            // Because `nextJsonRpcResponse` is passed as parameter an identifier returned by `addChain`,
-            // it is always the case that the Wasm instance is already initialized. The only possibility
-            // for it to not be the case is if the user completely invented the `chainId`.
-            if (!state.initialized)
-                throw new Error("Internal error");
-            while (true) {
-                if (crashError.error)
-                    throw crashError.error;
-                // Try to pop a message from the queue.
-                try {
-                    const mem = new Uint8Array(state.instance.exports.memory.buffer);
-                    const responseInfo = state.instance.exports.json_rpc_responses_peek(chainId) >>> 0;
-                    const ptr = buffer.readUInt32LE(mem, responseInfo) >>> 0;
-                    const len = buffer.readUInt32LE(mem, responseInfo + 4) >>> 0;
-                    // `len === 0` means "queue is empty" according to the API.
-                    // In that situation, queue the resolve/reject.
-                    if (len !== 0) {
-                        const message = buffer.utf8BytesToString(mem, ptr, len);
-                        state.instance.exports.json_rpc_responses_pop(chainId);
-                        return message;
-                    }
-                }
-                catch (_error) {
-                    console.assert(crashError.error);
-                    throw crashError.error;
-                }
-                // If no message is available, wait for one to be.
-                yield new Promise((resolve, reject) => {
-                    chains.get(chainId).jsonRpcResponsesPromises.push({ resolve: () => resolve(undefined), reject });
-                });
-            }
-        }),
-        addChain: (chainSpec, databaseContent, potentialRelayChains, disableJsonRpc) => {
-            return queueOperation((instance, bufferIndices) => {
-                if (crashError.error)
-                    throw crashError.error;
-                try {
-                    // `add_chain` unconditionally allocates a chain id. If an error occurs, however, this chain
-                    // id will refer to an *erroneous* chain. `chain_is_ok` is used below to determine whether it
-                    // has succeeeded or not.
-                    // Note that `add_chain` properly de-allocates buffers even if it failed.
-                    bufferIndices[0] = new TextEncoder().encode(chainSpec);
-                    bufferIndices[1] = new TextEncoder().encode(databaseContent);
-                    const potentialRelayChainsEncoded = new Uint8Array(potentialRelayChains.length * 4);
-                    for (let idx = 0; idx < potentialRelayChains.length; ++idx) {
-                        buffer.writeUInt32LE(potentialRelayChainsEncoded, idx * 4, potentialRelayChains[idx]);
-                    }
-                    bufferIndices[2] = potentialRelayChainsEncoded;
-                    const chainId = instance.exports.add_chain(0, 1, disableJsonRpc ? 0 : 1, 2);
-                    delete bufferIndices[0];
-                    delete bufferIndices[1];
-                    delete bufferIndices[2];
-                    if (instance.exports.chain_is_ok(chainId) != 0) {
-                        console.assert(!chains.has(chainId));
-                        chains.set(chainId, {
-                            jsonRpcResponsesPromises: new Array()
-                        });
-                        return { success: true, chainId };
-                    }
-                    else {
-                        const errorMsgLen = instance.exports.chain_error_len(chainId) >>> 0;
-                        const errorMsgPtr = instance.exports.chain_error_ptr(chainId) >>> 0;
-                        const errorMsg = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), errorMsgPtr, errorMsgLen);
-                        instance.exports.remove_chain(chainId);
-                        return { success: false, error: errorMsg };
-                    }
-                }
-                catch (_error) {
-                    console.assert(crashError.error);
-                    throw crashError.error;
-                }
-            });
-        },
-        removeChain: (chainId) => {
-            // Because `removeChain` is passed as parameter an identifier returned by `addChain`, it is
-            // always the case that the Wasm instance is already initialized. The only possibility for
-            // it to not be the case is if the user completely invented the `chainId`.
-            if (!state.initialized)
-                throw new Error("Internal error");
-            if (crashError.error)
-                throw crashError.error;
-            // Removing the chain synchronously avoids having to deal with race conditions such as a
-            // JSON-RPC response corresponding to a chain that is going to be deleted but hasn't been yet.
-            // These kind of race conditions are already delt with within smoldot.
-            console.assert(chains.has(chainId));
-            for (const { reject } of chains.get(chainId).jsonRpcResponsesPromises) {
-                reject(new AlreadyDestroyedError());
-            }
-            chains.delete(chainId);
-            try {
-                state.instance.exports.remove_chain(chainId);
-            }
-            catch (_error) {
-                console.assert(crashError.error);
-                throw crashError.error;
-            }
-        },
-        startShutdown: () => {
-            return queueOperation((instance) => {
-                // `startShutdown` is a bit special in its handling of crashes.
-                // Shutting down will lead to `onWasmPanic` being called at some point, possibly during
-                // the call to `start_shutdown` itself. As such, we move into "don't print errors anymore"
-                // mode even before calling `start_shutdown`.
-                //
-                // Furthermore, if a crash happened in the past, there is no point in throwing an
-                // exception when the user wants the shutdown to happen.
-                if (crashError.error)
-                    return;
-                try {
-                    printError.printError = false;
-                    instance.exports.start_shutdown();
-                }
-                catch (_error) {
-                }
-            });
-        }
-    };
-}

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

@@ -1,56 +0,0 @@
-import { ConnectionConfig, Connection } from './bindings-smoldot-light.js';
-import { SmoldotWasmInstance } from './bindings.js';
-export { ConnectionConfig, ConnectionError, Connection } from './bindings-smoldot-light.js';
-export interface Config {
-    /**
-     * Closure to call when the Wasm instance panics.
-     *
-     * This callback will always be invoked from within a binding called the Wasm instance.
-     *
-     * After this callback has been called, it is forbidden to invoke any function from the Wasm
-     * VM.
-     *
-     * If this callback is called while invoking a function from the Wasm VM, this function will
-     * throw a dummy exception.
-     */
-    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 {
-    /**
-     * Returns the number of milliseconds since an arbitrary epoch.
-     */
-    performanceNow: () => number;
-    /**
-     * Fills the given buffer with randomly-generated bytes.
-     */
-    getRandomValues: (buffer: Uint8Array) => void;
-    /**
-     * The "should periodically yield" setting indicates whether the execution should periodically
-     * yield back control by using `setTimeout(..., 0)`.
-     *
-     * On platforms such as browsers where `setTimeout(..., 0)` takes way more than 0 milliseconds,
-     * this setting should be set to `false`.
-     *
-     * This function registers a callback that is called when the setting should be updated with
-     * a new value. It returns the initial value of the setting and a function used to unregister
-     * the callback.
-     */
-    registerShouldPeriodicallyYield: (callback: (newValue: boolean) => void) => [boolean, () => void];
-    /**
-     * 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.
-     */
-    connect(config: ConnectionConfig): Connection;
-}
-export declare function startInstance(config: Config, platformBindings: PlatformBindings): Promise<[SmoldotWasmInstance, Array<Uint8Array>]>;

package/dist/mjs/instance/raw-instance.js

@@ -1,124 +0,0 @@
-// 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());
-    });
-};
-// 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 { default as smoldotLightBindingsBuilder } from './bindings-smoldot-light.js';
-import { default as wasiBindingsBuilder } from './bindings-wasi.js';
-export { ConnectionError } from './bindings-smoldot-light.js';
-export function startInstance(config, platformBindings) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let killAll;
-        const bufferIndices = new Array;
-        // Callback called when `advance_execution_ready` is called by the Rust code, if any.
-        const advanceExecutionPromise = { value: null };
-        // Used to bind with the smoldot-light bindings. See the `bindings-smoldot-light.js` file.
-        const smoldotJsConfig = Object.assign({ bufferIndices, connect: platformBindings.connect, onPanic: (message) => {
-                killAll();
-                config.onWasmPanic(message);
-                throw new Error();
-            }, advanceExecutionReadyCallback: () => {
-                if (advanceExecutionPromise.value)
-                    advanceExecutionPromise.value();
-                advanceExecutionPromise.value = null;
-            } }, config);
-        // Used to bind with the Wasi bindings. See the `bindings-wasi.js` file.
-        const wasiConfig = {
-            envVars: [],
-            getRandomValues: platformBindings.getRandomValues,
-            performanceNow: platformBindings.performanceNow,
-            onProcExit: (retCode) => {
-                killAll();
-                config.onWasmPanic(`proc_exit called: ${retCode}`);
-                throw new Error();
-            }
-        };
-        const { imports: smoldotBindings, killAll: smoldotBindingsKillAll } = smoldotLightBindingsBuilder(smoldotJsConfig);
-        killAll = smoldotBindingsKillAll;
-        // 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(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;
-        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];
-    });
-}