smoldot 0.3.6 → 0.7.11

package/src/bindings-smoldot-js.js

@@ -1,223 +0,0 @@
-// Smoldot
-// Copyright (C) 2019-2021  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 { Buffer } from 'buffer';
-import Websocket from 'websocket';
-import now from 'performance-now';
-import { net } from './compat-nodejs.js';
-
-export default (config) => {
-    // Used below to store the list of all connections.
-    // The indices within this array are chosen by the Rust code.
-    let connections = {};
-
-    const bindings = {
-        // Must throw an error. A human-readable message can be found in the WebAssembly memory in
-        // the given buffer.
-        throw: (ptr, len) => {
-            const message = Buffer.from(config.instance.exports.memory.buffer).toString('utf8', ptr, ptr + len);
-            throw new Error(message);
-        },
-
-        // Used by the Rust side to emit a JSON-RPC response or subscription notification.
-        json_rpc_respond: (ptr, len, chainId) => {
-            let message = Buffer.from(config.instance.exports.memory.buffer).toString('utf8', ptr, ptr + len);
-            if (config.jsonRpcCallback) {
-                config.jsonRpcCallback(message, chainId);
-            }
-        },
-
-        // Used by the Rust side to emit a log entry.
-        // See also the `max_log_level` parameter in the configuration.
-        log: (level, target_ptr, target_len, message_ptr, message_len) => {
-            if (config.logCallback) {
-                let target = Buffer.from(config.instance.exports.memory.buffer)
-                    .toString('utf8', target_ptr, target_ptr + target_len);
-                let message = Buffer.from(config.instance.exports.memory.buffer)
-                    .toString('utf8', message_ptr, message_ptr + message_len);
-                config.logCallback(level, target, message);
-            }
-        },
-
-        // Must return the UNIX time in milliseconds.
-        unix_time_ms: () => Date.now(),
-
-        // Must return the value of a monotonic clock in milliseconds.
-        monotonic_clock_ms: () => now(),
-
-        // Must call `timer_finished` after the given number of milliseconds has elapsed.
-        start_timer: (id, ms) => {
-            // 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 == 0 && typeof setImmediate === "function") {
-                setImmediate(() => {
-                    config.instance.exports.timer_finished(id);
-                })
-            } else {
-                setTimeout(() => {
-                    config.instance.exports.timer_finished(id);
-                }, ms)
-            }
-        },
-
-        // Must create a new connection object. This implementation stores the created object in
-        // `connections`.
-        connection_new: (id, addr_ptr, addr_len, error_ptr_ptr) => {
-            try {
-                if (!!connections[id]) {
-                    throw new Error("internal error: connection already allocated");
-                }
-
-                const addr = Buffer.from(config.instance.exports.memory.buffer)
-                    .toString('utf8', addr_ptr, addr_ptr + addr_len);
-
-                let connection;
-
-                // Attempt to parse the multiaddress.
-                // Note: peers can decide of the content of `addr`, meaning that it shouldn't be
-                // trusted.
-                const wsParsed = addr.match(/^\/(ip4|ip6|dns4|dns6|dns)\/(.*?)\/tcp\/(.*?)\/(ws|wss)$/);
-                const tcpParsed = addr.match(/^\/(ip4|ip6|dns4|dns6|dns)\/(.*?)\/tcp\/(.*?)$/);
-
-                if (wsParsed != null) {
-                    let proto = 'wss';
-                    if (wsParsed[4] == 'ws') {
-                        proto = 'ws';
-                    }
-                    if ((proto == 'ws' && config.forbidWs) || (proto == 'wss' && config.forbidWss)) {
-                        throw new Error('Connection type not allowed');
-                    }
-                    if (wsParsed[1] == 'ip6') {
-                        connection = new Websocket.w3cwebsocket(proto + "://[" + wsParsed[2] + "]:" + wsParsed[3]);
-                    } else {
-                        connection = new Websocket.w3cwebsocket(proto + "://" + wsParsed[2] + ":" + wsParsed[3]);
-                    }
-
-                    connection.binaryType = 'arraybuffer';
-
-                    connection.onopen = () => {
-                        config.instance.exports.connection_open(id);
-                    };
-                    connection.onclose = (event) => {
-                        const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
-                        const len = Buffer.byteLength(message, 'utf8');
-                        const ptr = config.instance.exports.alloc(len);
-                        Buffer.from(config.instance.exports.memory.buffer).write(message, ptr);
-                        config.instance.exports.connection_closed(id, ptr, len);
-                    };
-                    connection.onmessage = (msg) => {
-                        const message = Buffer.from(msg.data);
-                        const ptr = config.instance.exports.alloc(message.length);
-                        message.copy(Buffer.from(config.instance.exports.memory.buffer), ptr);
-                        config.instance.exports.connection_message(id, ptr, message.length);
-                    };
-
-                } else if (tcpParsed != null) {
-                    // `net` module will be missing when we're not in NodeJS.
-                    if (!net || config.forbidTcp) {
-                        throw new Error('TCP connections not available');
-                    }
-
-                    connection = net.createConnection({
-                        host: tcpParsed[2],
-                        port: parseInt(tcpParsed[3], 10),
-                    });
-                    connection.setNoDelay();
-
-                    connection.on('connect', () => {
-                        if (connection.destroyed) return;
-                        config.instance.exports.connection_open(id);
-                    });
-                    connection.on('close', (hasError) => {
-                        if (connection.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";
-                        const len = Buffer.byteLength(message, 'utf8');
-                        const ptr = config.instance.exports.alloc(len);
-                        Buffer.from(config.instance.exports.memory.buffer).write(message, ptr);
-                        config.instance.exports.connection_closed(id, ptr, len);
-                    });
-                    connection.on('error', () => { });
-                    connection.on('data', (message) => {
-                        if (connection.destroyed) return;
-                        const ptr = config.instance.exports.alloc(message.length);
-                        message.copy(Buffer.from(config.instance.exports.memory.buffer), ptr);
-                        config.instance.exports.connection_message(id, ptr, message.length);
-                    });
-
-                } else {
-                    throw new Error('Unrecognized multiaddr format');
-                }
-
-                connections[id] = connection;
-                return 0;
-
-            } catch (error) {
-                const errorStr = error.toString();
-                const mem = Buffer.from(config.instance.exports.memory.buffer);
-                const len = Buffer.byteLength(errorStr, 'utf8');
-                const ptr = config.instance.exports.alloc(len);
-                mem.write(errorStr, ptr);
-                mem.writeUInt32LE(ptr, error_ptr_ptr);
-                mem.writeUInt32LE(len, error_ptr_ptr + 4);
-                return 1;
-            }
-        },
-
-        // Must close and destroy the connection object.
-        connection_close: (id) => {
-            let connection = connections[id];
-            if (connection.close) {
-                // WebSocket
-                connection.onopen = null;
-                connection.onclose = null;
-                connection.onmessage = null;
-                connection.onerror = null;
-                connection.close();
-            } else {
-                // TCP
-                connection.destroy();
-            }
-            connections[id] = undefined;
-        },
-
-        // 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.
-        connection_send: (id, ptr, len) => {
-            let data = Buffer.from(config.instance.exports.memory.buffer).slice(ptr, ptr + len);
-            let connection = connections[id];
-            if (connection.send) {
-                // WebSocket
-                connection.send(data);
-            } else {
-                // TCP
-                connection.write(data);
-            }
-        }
-    };
-
-    return {
-        bindings,
-    }
-}

package/src/compat-browser.js

@@ -1,25 +0,0 @@
-// Smoldot
-// Copyright (C) 2019-2021  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/>.
-
-// Overrides `compat-nodejs.js` when in a browser.
-
-export const net = null;
-export const Worker = typeof window != 'undefined' ? window.Worker : null;
-export const workerOnMessage = (worker, callback) => { worker.onmessage = (event) => callback(event.data) };
-export const workerOnError = (worker, callback) => { worker.onerror = callback; };  // TODO: unclear if the parameter of the callback is same as with NodeJS
-export const postMessage = (msg) => self.postMessage(msg);
-export const setOnMessage = (callback) => { self.onmessage = (event) => callback(event.data) };

package/src/compat-nodejs.js

@@ -1,30 +0,0 @@
-// Smoldot
-// Copyright (C) 2019-2021  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/>.
-
-// This small dummy module re-exports some types from NodeJS.
-//
-// A rule in the `package.json` overrides it with `compat-browser.js` when in a browser.
-
-import { parentPort } from 'worker_threads';
-
-export { default as net } from 'net';
-export { Worker } from 'worker_threads';
-
-export const workerOnMessage = (worker, callback) => worker.on('message', callback);
-export const workerOnError = (worker, callback) => worker.on('error', callback);
-export const postMessage = (msg) => parentPort.postMessage(msg);
-export const setOnMessage = (callback) => parentPort.on('message', callback);

package/src/health.js

@@ -1,206 +0,0 @@
-// Smoldot
-// Copyright (C) 2019-2021  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/>.
-
-import randombytes from 'randombytes';
-
-// Creates a new health checker.
-//
-// The role of the health checker is to report to the user the health of a smoldot chain.
-//
-// In order to use it, start by creating a health checker. The health checker is disabled by
-// default. Use `start()` in order to start the health checks. The `start()` function must be
-// passed a function that the health checker can use to send JSON-RPC requests to the chain, and
-// a callback called when an update to the health of the node is available.
-//
-// When the chain send a JSON-RPC response, it must be passed to `responsePassThrough()`. This
-// function intercepts the responses destined to the requests that have been emitted by the health
-// checker and returns `null`. If the response doesn't concern the health checker, the response is
-// simply returned by the function.
-//
-// # How it works
-//
-// The health checker periodically calls the `system_health` JSON-RPC call in order to determine
-// the health of the chain.
-//
-// In addition to this, as long as the health check reports that `isSyncing` is `true`, the
-// health checker also maintains a subscription to new best blocks using `chain_subscribeNewHeads`.
-// Whenever a new block is notified, a health check is performed immediately in order to determine
-// whether `isSyncing` has changed to `false`.
-//
-// Thanks to this subscription, the latency of the report of the switch from `isSyncing: true` to
-// `isSyncing: false` is very low.
-//
-export function healthChecker() {
-    // `null` if health checker is not started.
-    let checker = null;
-
-    return {
-        start: (sendJsonRpc, healthCallback) => {
-            if (checker !== null)
-                throw new Error("Can't start the health checker multiple times in parallel");
-
-            checker = {
-                healthCallback,
-                currentHealthCheckId: null,
-                currentHealthTimeout: null,
-                currentSubunsubRequestId: null,
-                currentSubscriptionId: null,
-                isSyncing: false,
-
-                responsePassThrough: function (jsonRpcResponse) {
-                    let parsedResponse;
-                    try {
-                        parsedResponse = JSON.parse(jsonRpcResponse);
-                    } catch (err) {
-                        return jsonRpcResponse;
-                    };
-
-                    // Check whether response is a response to `system_health`.
-                    if (parsedResponse.id && this.currentHealthCheckId == parsedResponse.id) {
-                        this.currentHealthCheckId = null;
-
-                        // Check whether query was successful. It is possible for queries to fail for
-                        // various reasons, such as the client being overloaded.
-                        if (!parsedResponse.result) {
-                            this.update();
-                            return null;
-                        }
-
-                        this.healthCallback(parsedResponse.result);
-                        this.isSyncing = parsedResponse.result.isSyncing;
-                        this.update();
-                        return null;
-                    }
-
-                    // Check whether response is a response to the subscription or unsubscription.
-                    if (parsedResponse.id && this.currentSubunsubRequestId == parsedResponse.id) {
-                        this.currentSubunsubRequestId = null;
-
-                        // Check whether query was successful. It is possible for queries to fail for
-                        // various reasons, such as the client being overloaded.
-                        if (!parsedResponse.result) {
-                            this.update();
-                            return null;
-                        }
-
-                        if (this.currentSubscriptionId)
-                            this.currentSubscriptionId = null;
-                        else
-                            this.currentSubscriptionId = parsedResponse.result;
-
-                        this.update();
-                        return null;
-                    }
-
-                    // Check whether response is a notification to a subscription.
-                    if (parsedResponse.params && this.currentSubscriptionId &&
-                        parsedResponse.params.subscription == this.currentSubscriptionId) {
-                        // Note that after a successful subscription, a notification containing
-                        // the current best block is always returned. Considering that a
-                        // subscription is performed in response to a health check, calling
-                        // `startHealthCheck()` here will lead to a second health check.
-                        // It might seem redundant to perform two health checks in a quick
-                        // succession, but doing so doesn't lead to any problem, and it is
-                        // actually possible for the health to have changed in between as the
-                        // current best block might have been updated during the subscription
-                        // request.
-                        this.startHealthCheck();
-                        this.update();
-                        return null;
-                    }
-
-                    // Response doesn't concern us.
-                    return jsonRpcResponse;
-                },
-
-                update: function () {
-                    if (!this.currentHealthTimeout) {
-                        this.currentHealthTimeout = setTimeout(() => {
-                            this.currentHealthTimeout = null;
-                            this.startHealthCheck();
-                        }, 10000);
-                    }
-
-                    if (this.isSyncing && !this.currentSubscriptionId && !this.currentSubunsubRequestId)
-                        this.startSubscription();
-                    if (!this.isSyncing && this.currentSubscriptionId && !this.currentSubunsubRequestId)
-                        this.endSubscription();
-                },
-
-                startHealthCheck: function () {
-                    if (this.currentHealthCheckId)
-                        throw new Error('Internal error in health checker');
-                    if (this.currentHealthTimeout) {
-                        clearTimeout(this.currentHealthTimeout);
-                        this.currentHealthTimeout = null;
-                    }
-                    this.currentHealthCheckId = randombytes(32).toString('base64');
-                    sendJsonRpc(JSON.stringify({
-                        jsonrpc: "2.0",
-                        id: this.currentHealthCheckId,
-                        method: 'system_health',
-                        params: [],
-                    }));
-                },
-
-                startSubscription: function () {
-                    if (this.currentSubunsubRequestId || this.currentSubscriptionId)
-                        throw new Error('Internal error in health checker');
-                    this.currentSubunsubRequestId = randombytes(32).toString('base64');
-                    sendJsonRpc(JSON.stringify({
-                        jsonrpc: "2.0",
-                        id: this.currentSubunsubRequestId,
-                        method: 'chain_subscribeNewHeads',
-                        params: [],
-                    }));
-                },
-
-                endSubscription: function () {
-                    if (this.currentSubunsubRequestId || !this.currentSubscriptionId)
-                        throw new Error('Internal error in health checker');
-                    this.currentSubunsubRequestId = randombytes(32).toString('base64');
-                    sendJsonRpc(JSON.stringify({
-                        jsonrpc: "2.0",
-                        id: this.currentSubunsubRequestId,
-                        method: 'chain_unsubscribeNewHeads',
-                        params: [this.currentSubscriptionId],
-                    }));
-                },
-
-                destroy: function () {
-                    if (this.currentHealthTimeout) {
-                        clearTimeout(this.currentHealthTimeout);
-                        this.currentHealthTimeout = null;
-                    }
-                }
-            };
-
-            checker.startHealthCheck();
-        },
-        stop: () => {
-            if (checker === null)
-                return; // Already stopped.
-            checker.destroy();
-            checker = null;
-        },
-        responsePassThrough: (jsonRpcResponse) => {
-            if (checker === null)
-                return jsonRpcResponse;
-            return checker.responsePassThrough(jsonRpcResponse);
-        },
-    };
-}

package/src/index.d.ts

@@ -1,68 +0,0 @@
-// Smoldot
-// Copyright (C) 2019-2021  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/>.
-
-declare class SmoldotError extends Error {
-  constructor(message: string);
-}
-
-export interface SmoldotClient {
-  addChain(options: SmoldotAddChainOptions): Promise<SmoldotChain>;
-  terminate(): void;
-}
-
-export interface SmoldotChain {
-  sendJsonRpc(rpc: string): void;
-  remove(): void;
-}
-
-export type SmoldotJsonRpcCallback = (response: string) => void;
-export type SmoldotLogCallback = (level: number, target: string, message: string) => void;
-
-export interface SmoldotOptions {
-  maxLogLevel?: number;
-  logCallback?: SmoldotLogCallback;
-  forbidTcp?: boolean;
-  forbidWs?: boolean;
-  forbidWss?: boolean;
-}
-
-export interface SmoldotAddChainOptions {
-  chainSpec: string;
-  potentialRelayChains?: SmoldotChain[];
-  jsonRpcCallback?: SmoldotJsonRpcCallback;
-}
-
-export interface SmoldotHealth {
-  isSyncing: boolean;
-  peers: number;
-  shouldHavePeers: boolean;
-}
-
-export interface HealthChecker {
-  start(sendRequest: (request: string) => void, healthCallback: (health: SmoldotHealth) => void): void;
-  stop(): void;
-  responsePassThrough(response: string): string | null;
-}
-
-export interface Smoldot {
-  start(options?: SmoldotOptions): Promise<SmoldotClient>;
-  healthChecker(): HealthChecker;
-}
-
-export const smoldot: Smoldot;
-
-export default smoldot;