smoldot 0.3.6 → 0.7.11

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

@@ -0,0 +1,10 @@
+export declare function utf8BytesToString(buffer: Uint8Array, offset: number, length: number): string;
+export declare function readUInt32LE(buffer: Uint8Array, offset: number): number;
+/**
+ * Sets the value of a given byte in the buffer.
+ *
+ * This function is equivalent to `buffer[offset] = value`, except that an exception is thrown
+ * if `offset` is out of range.
+ */
+export declare function writeUInt8(buffer: Uint8Array, offset: number, value: number): void;
+export declare function writeUInt32LE(buffer: Uint8Array, offset: number, value: number): void;

package/dist/mjs/instance/buffer.js

@@ -0,0 +1,46 @@
+// 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/>.
+export function utf8BytesToString(buffer, offset, length) {
+    checkRange(buffer, offset, length);
+    // The `TextDecoder` API is supported by all major browsers and by NodeJS.
+    // <https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder>
+    return new TextDecoder().decode(buffer.slice(offset, offset + length));
+}
+export function readUInt32LE(buffer, offset) {
+    checkRange(buffer, offset, 4);
+    return (buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16)) + (buffer[offset + 3] * 0x1000000);
+}
+/**
+ * Sets the value of a given byte in the buffer.
+ *
+ * This function is equivalent to `buffer[offset] = value`, except that an exception is thrown
+ * if `offset` is out of range.
+ */
+export function writeUInt8(buffer, offset, value) {
+    checkRange(buffer, offset, 1);
+    buffer[offset] = value & 0xff;
+}
+export function writeUInt32LE(buffer, offset, value) {
+    checkRange(buffer, offset, 4);
+    buffer[offset + 3] = (value >>> 24) & 0xff;
+    buffer[offset + 2] = (value >>> 16) & 0xff;
+    buffer[offset + 1] = (value >>> 8) & 0xff;
+    buffer[offset] = value & 0xff;
+}
+function checkRange(buffer, offset, length) {
+    if (!Number.isInteger(offset) || offset < 0)
+        throw new RangeError();
+    if (offset + length > buffer.length)
+        throw new RangeError();
+}

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

@@ -0,0 +1,45 @@
+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 {
+    logCallback: (level: number, target: string, message: string) => void;
+    maxLogLevel: number;
+    enableCurrentTask: boolean;
+    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;

package/dist/mjs/instance/instance.js

@@ -0,0 +1,293 @@
+// 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();
+    // 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);
+        },
+        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,
+    };
+    state = {
+        initialized: false, promise: instance.startInstance(config, platformBindings).then((instance) => {
+            // `config.cpuRateLimit` is a floating point that should be between 0 and 1, while the value
+            // to pass as parameter must be between `0` and `2^32-1`.
+            // The few lines of code below should handle all possible values of `number`, including
+            // infinites and NaN.
+            let cpuRateLimit = Math.round(config.cpuRateLimit * 4294967295); // `2^32 - 1`
+            if (cpuRateLimit < 0)
+                cpuRateLimit = 0;
+            if (cpuRateLimit > 4294967295)
+                cpuRateLimit = 4294967295;
+            if (!Number.isFinite(cpuRateLimit))
+                cpuRateLimit = 4294967295; // User might have passed NaN
+            // Smoldot requires an initial call to the `init` function in order to do its internal
+            // configuration.
+            const [periodicallyYield, unregisterCallback] = platformBindings.registerShouldPeriodicallyYield((newValue) => {
+                if (state.initialized && !crashError.error) {
+                    try {
+                        state.instance.exports.set_periodically_yield(newValue ? 1 : 0);
+                    }
+                    catch (_error) { }
+                }
+            });
+            instance.exports.init(configMessage.maxLogLevel, configMessage.enableCurrentTask ? 1 : 0, cpuRateLimit, periodicallyYield ? 1 : 0);
+            state = { initialized: true, instance, unregisterCallback };
+            return instance;
+        })
+    };
+    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) => operation(instance));
+            }
+            else {
+                // Everything is already initialized. Process the message synchronously.
+                return operation(state.instance);
+            }
+        });
+    }
+    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 {
+                const encoded = new TextEncoder().encode(request);
+                const ptr = state.instance.exports.alloc(encoded.length) >>> 0;
+                new Uint8Array(state.instance.exports.memory.buffer).set(encoded, ptr);
+                retVal = state.instance.exports.json_rpc_send(ptr, encoded.length, 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) => {
+                if (crashError.error)
+                    throw crashError.error;
+                try {
+                    // Write the chain specification into memory.
+                    const chainSpecEncoded = new TextEncoder().encode(chainSpec);
+                    const chainSpecPtr = instance.exports.alloc(chainSpecEncoded.length) >>> 0;
+                    new Uint8Array(instance.exports.memory.buffer).set(chainSpecEncoded, chainSpecPtr);
+                    // Write the database content into memory.
+                    const databaseContentEncoded = new TextEncoder().encode(databaseContent);
+                    const databaseContentPtr = instance.exports.alloc(databaseContentEncoded.length) >>> 0;
+                    new Uint8Array(instance.exports.memory.buffer).set(databaseContentEncoded, databaseContentPtr);
+                    // Write the potential relay chains into memory.
+                    const potentialRelayChainsLen = potentialRelayChains.length;
+                    const potentialRelayChainsPtr = instance.exports.alloc(potentialRelayChainsLen * 4) >>> 0;
+                    for (let idx = 0; idx < potentialRelayChains.length; ++idx) {
+                        buffer.writeUInt32LE(new Uint8Array(instance.exports.memory.buffer), potentialRelayChainsPtr + idx * 4, potentialRelayChains[idx]);
+                    }
+                    // `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.
+                    const chainId = instance.exports.add_chain(chainSpecPtr, chainSpecEncoded.length, databaseContentPtr, databaseContentEncoded.length, disableJsonRpc ? 0 : 1, potentialRelayChainsPtr, potentialRelayChainsLen);
+                    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;
+                if (state.initialized)
+                    state.unregisterCallback();
+                try {
+                    printError.printError = false;
+                    instance.exports.start_shutdown();
+                }
+                catch (_error) {
+                }
+            });
+        }
+    };
+}

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

@@ -0,0 +1,65 @@
+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;
+    jsonRpcResponsesNonEmptyCallback: (chainId: number) => void;
+    currentTaskCallback?: (taskName: string | null) => void;
+    cpuRateLimit: number;
+}
+/**
+ * Contains functions that the client will use when it needs to leverage the platform.
+ */
+export interface PlatformBindings {
+    /**
+     * Base64-decode the given buffer then decompress its content using the inflate algorithm
+     * with zlib header.
+     *
+     * The input is considered trusted. In other words, the implementation doesn't have to
+     * resist malicious input.
+     *
+     * This function is asynchronous because implementations might use the compression streams
+     * Web API, which for whatever reason is asynchronous.
+     */
+    trustedBase64DecodeAndZlibInflate: (input: string) => Promise<Uint8Array>;
+    /**
+     * 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>;

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

@@ -0,0 +1,67 @@
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+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';
+import { default as wasmBase64 } from './autogen/wasm.js';
+export { ConnectionError } from './bindings-smoldot-light.js';
+export function startInstance(config, platformBindings) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // The actual Wasm bytecode is base64-decoded then deflate-decoded from a constant found in a
+        // different file.
+        // This is suboptimal compared to using `instantiateStreaming`, but it is the most
+        // cross-platform cross-bundler approach.
+        const wasmBytecode = yield platformBindings.trustedBase64DecodeAndZlibInflate(wasmBase64);
+        let killAll;
+        // Used to bind with the smoldot-light bindings. See the `bindings-smoldot-light.js` file.
+        const smoldotJsConfig = Object.assign({ performanceNow: platformBindings.performanceNow, connect: platformBindings.connect, onPanic: (message) => {
+                killAll();
+                config.onWasmPanic(message);
+                throw new Error();
+            } }, config);
+        // Used to bind with the Wasi bindings. See the `bindings-wasi.js` file.
+        const wasiConfig = {
+            envVars: [],
+            getRandomValues: platformBindings.getRandomValues,
+            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(wasmBytecode, {
+            // 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.instance;
+        smoldotJsConfig.instance = instance;
+        wasiConfig.instance = instance;
+        return instance;
+    });
+}

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/package.json

@@ -1,37 +1,53 @@
 {
   "name": "smoldot",
-  "version": "0.3.6",
+  "version": "0.7.11",
   "description": "Light client that connects to Polkadot and Substrate-based blockchains",
   "author": "Parity Technologies <admin@parity.io>",
   "license": "GPL-3.0-or-later WITH Classpath-exception-2.0",
-  "homepage": "https://github.com/paritytech/smoldot",
+  "homepage": "https://github.com/smol-dot/smoldot",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/paritytech/smoldot.git"
+    "url": "git+https://github.com/smol-dot/smoldot.git"
   },
   "bugs": {
-    "url": "https://github.com/paritytech/smoldot/issues"
+    "url": "https://github.com/smol-dot/smoldot/issues"
   },
-  "type": "module",
-  "types": "src/index.d.ts",
-  "main": "src/index.js",
-  "scripts": {
-    "prepublishOnly": "node prepare.js --release",
-    "build": "node prepare.js --release",
-    "start": "node prepare.js --debug && node test/demo.js",
-    "test": "node prepare.js --debug && dtslint src/ && node test/test.js"
+  "files": [
+    "dist"
+  ],
+  "main": "dist/cjs/index-browser.js",
+  "types": "dist/mjs/index-browser.d.ts",
+  "module": "dist/mjs/index-browser.js",
+  "exports": {
+    "node": {
+      "import": "./dist/mjs/index-nodejs.js",
+      "require": "./dist/cjs/index-nodejs.js"
+    },
+    "default": {
+      "import": "./dist/mjs/index-browser.js",
+      "require": "./dist/cjs/index-browser.js"
+    }
   },
-  "browser": {
-    "./src/compat-nodejs.js": "./src/compat-browser.js"
+  "scripts": {
+    "buildModules": "tsc -p tsconfig-mjs.json && tsc -p tsconfig-cjs.json && bash fix-package-type.sh",
+    "prepublishOnly": "node prepare.mjs --release && rimraf ./dist && npm run buildModules",
+    "build": "node prepare.mjs --release && rimraf ./dist && npm run buildModules",
+    "start": "node prepare.mjs --debug && rimraf ./dist && npm run buildModules && node demo/demo.mjs",
+    "test": "node prepare.mjs --debug && rimraf ./dist && npm run buildModules && deno run ./dist/mjs/index-deno.js && ava --timeout=2m --concurrency 2 --no-worker-threads",
+    "doc": "node prepare.mjs --debug && typedoc --basePath ./src --out ./dist/doc --treatWarningsAsErrors ./src/index-browser.ts"
   },
   "dependencies": {
-    "buffer": "^6.0.1",
-    "performance-now": "^2.1.0",
-    "randombytes": "^2.1.0",
-    "websocket": "^1.0.32"
+    "pako": "^2.0.4",
+    "ws": "^8.8.1"
   },
   "devDependencies": {
+    "@types/node": "^18.0.0",
+    "@types/pako": "^2.0.0",
+    "@types/ws": "^8.5.3",
+    "ava": "^5.0.1",
     "dtslint": "^4.0.6",
-    "typescript": "^4.1.4"
+    "rimraf": "^3.0.2",
+    "typedoc": "^0.23.15",
+    "typescript": "^4.5.4"
   }
 }