smoldot 1.0.4 → 1.0.6

package/dist/cjs/instance/instance.js

@@ -1,277 +0,0 @@
-"use strict";
-// 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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.start = exports.QueueFullError = exports.MalformedJsonRpcError = exports.CrashError = exports.ConnectionError = void 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/>.
-const buffer = require("./buffer.js");
-const instance = require("./raw-instance.js");
-const client_js_1 = require("../client.js");
-var raw_instance_js_1 = require("./raw-instance.js");
-Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return raw_instance_js_1.ConnectionError; } });
-/**
- * Thrown in case the underlying client encounters an unexpected crash.
- *
- * This is always an internal bug in smoldot and is never supposed to happen.
- */
-class CrashError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-exports.CrashError = CrashError;
-/**
- * Thrown in case a malformed JSON-RPC request is sent.
- */
-class MalformedJsonRpcError extends Error {
-    constructor() {
-        super("JSON-RPC request is malformed");
-    }
-}
-exports.MalformedJsonRpcError = MalformedJsonRpcError;
-/**
- * Thrown in case the buffer of JSON-RPC requests is full and cannot accept any more request.
- */
-class QueueFullError extends Error {
-    constructor() {
-        super("JSON-RPC requests queue is full");
-    }
-}
-exports.QueueFullError = QueueFullError;
-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 client_js_1.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) {
-                }
-            });
-        }
-    };
-}
-exports.start = start;

package/dist/cjs/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/cjs/instance/raw-instance.js

@@ -1,129 +0,0 @@
-"use strict";
-// 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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startInstance = exports.ConnectionError = void 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/>.
-const bindings_smoldot_light_js_1 = require("./bindings-smoldot-light.js");
-const bindings_wasi_js_1 = require("./bindings-wasi.js");
-var bindings_smoldot_light_js_2 = require("./bindings-smoldot-light.js");
-Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return bindings_smoldot_light_js_2.ConnectionError; } });
-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 } = (0, bindings_smoldot_light_js_1.default)(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": (0, bindings_wasi_js_1.default)(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];
-    });
-}
-exports.startInstance = startInstance;

package/dist/mjs/client.js

@@ -1,162 +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 { MalformedJsonRpcError, start as startInstance } from './instance/instance.js';
-export { MalformedJsonRpcError, QueueFullError, CrashError } from './instance/instance.js';
-/**
- * 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";
-    }
-}
-// This function is similar to the `start` function found in `index.ts`, except with an extra
-// parameter containing the platform-specific bindings.
-// Contrary to the one within `index.js`, this function is not supposed to be directly used.
-export function start(options, wasmModule, platformBindings) {
-    const logCallback = options.logCallback || ((level, target, message) => {
-        // The first parameter of the methods of `console` has some printf-like substitution
-        // capabilities. We don't really need to use this, but not using it means that the logs might
-        // not get printed correctly if they contain `%`.
-        if (level <= 1) {
-            console.error("[%s] %s", target, message);
-        }
-        else if (level == 2) {
-            console.warn("[%s] %s", target, message);
-        }
-        else if (level == 3) {
-            console.info("[%s] %s", target, message);
-        }
-        else if (level == 4) {
-            console.debug("[%s] %s", target, message);
-        }
-        else {
-            console.trace("[%s] %s", target, message);
-        }
-    });
-    // For each chain object returned by `addChain`, the associated internal chain id.
-    //
-    // Immediately cleared when `remove()` is called on a chain.
-    const chainIds = new WeakMap();
-    // If `Client.terminate()̀  is called, this error is set to a value.
-    // All the functions of the public API check if this contains a value.
-    const alreadyDestroyedError = { value: null };
-    const instance = startInstance({
-        wasmModule,
-        // Maximum level of log entries sent by the client.
-        // 0 = Logging disabled, 1 = Error, 2 = Warn, 3 = Info, 4 = Debug, 5 = Trace
-        maxLogLevel: options.maxLogLevel || 3,
-        logCallback,
-        cpuRateLimit: options.cpuRateLimit || 1.0,
-    }, platformBindings);
-    return {
-        addChain: (options) => __awaiter(this, void 0, void 0, function* () {
-            if (alreadyDestroyedError.value)
-                throw alreadyDestroyedError.value;
-            // Passing a JSON object for the chain spec is an easy mistake, so we provide a more
-            // readable error.
-            if (!(typeof options.chainSpec === 'string'))
-                throw new Error("Chain specification must be a string");
-            let potentialRelayChainsIds = [];
-            if (!!options.potentialRelayChains) {
-                for (const chain of options.potentialRelayChains) {
-                    // The content of `options.potentialRelayChains` are supposed to be chains earlier
-                    // returned by `addChain`.
-                    const id = chainIds.get(chain);
-                    if (id === undefined) // It is possible for `id` to be missing if it has earlier been removed.
-                        continue;
-                    potentialRelayChainsIds.push(id);
-                }
-            }
-            const outcome = yield instance.addChain(options.chainSpec, typeof options.databaseContent === 'string' ? options.databaseContent : "", potentialRelayChainsIds, !!options.disableJsonRpc);
-            if (!outcome.success)
-                throw new AddChainError(outcome.error);
-            const chainId = outcome.chainId;
-            const wasDestroyed = { destroyed: false };
-            // `expected` was pushed by the `addChain` method.
-            // Resolve the promise that `addChain` returned to the user.
-            const newChain = {
-                sendJsonRpc: (request) => {
-                    if (alreadyDestroyedError.value)
-                        throw alreadyDestroyedError.value;
-                    if (wasDestroyed.destroyed)
-                        throw new AlreadyDestroyedError();
-                    if (options.disableJsonRpc)
-                        throw new JsonRpcDisabledError();
-                    if (request.length >= 64 * 1024 * 1024) {
-                        throw new MalformedJsonRpcError();
-                    }
-                    ;
-                    instance.request(request, chainId);
-                },
-                nextJsonRpcResponse: () => {
-                    if (alreadyDestroyedError.value)
-                        return Promise.reject(alreadyDestroyedError.value);
-                    if (wasDestroyed.destroyed)
-                        return Promise.reject(new AlreadyDestroyedError());
-                    if (options.disableJsonRpc)
-                        return Promise.reject(new JsonRpcDisabledError());
-                    return instance.nextJsonRpcResponse(chainId);
-                },
-                remove: () => {
-                    if (alreadyDestroyedError.value)
-                        throw alreadyDestroyedError.value;
-                    if (wasDestroyed.destroyed)
-                        throw new AlreadyDestroyedError();
-                    wasDestroyed.destroyed = true;
-                    console.assert(chainIds.has(newChain));
-                    chainIds.delete(newChain);
-                    instance.removeChain(chainId);
-                },
-            };
-            chainIds.set(newChain, chainId);
-            return newChain;
-        }),
-        terminate: () => __awaiter(this, void 0, void 0, function* () {
-            if (alreadyDestroyedError.value)
-                throw alreadyDestroyedError.value;
-            alreadyDestroyedError.value = new AlreadyDestroyedError();
-            instance.startShutdown();
-        })
-    };
-}