smoldot 0.3.6 → 0.7.11

package/dist/cjs/instance/buffer.js

@@ -0,0 +1,53 @@
+"use strict";
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeUInt32LE = exports.writeUInt8 = exports.readUInt32LE = exports.utf8BytesToString = 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/>.
+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));
+}
+exports.utf8BytesToString = utf8BytesToString;
+function readUInt32LE(buffer, offset) {
+    checkRange(buffer, offset, 4);
+    return (buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16)) + (buffer[offset + 3] * 0x1000000);
+}
+exports.readUInt32LE = readUInt32LE;
+/**
+ * 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.
+ */
+function writeUInt8(buffer, offset, value) {
+    checkRange(buffer, offset, 1);
+    buffer[offset] = value & 0xff;
+}
+exports.writeUInt8 = writeUInt8;
+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;
+}
+exports.writeUInt32LE = writeUInt32LE;
+function checkRange(buffer, offset, length) {
+    if (!Number.isInteger(offset) || offset < 0)
+        throw new RangeError();
+    if (offset + length > buffer.length)
+        throw new RangeError();
+}

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

@@ -0,0 +1,301 @@
+"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();
+    // 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 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;
+                if (state.initialized)
+                    state.unregisterCallback();
+                try {
+                    printError.printError = false;
+                    instance.exports.start_shutdown();
+                }
+                catch (_error) {
+                }
+            });
+        }
+    };
+}
+exports.start = start;

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

@@ -0,0 +1,72 @@
+"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");
+const wasm_js_1 = require("./autogen/wasm.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* () {
+        // 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(wasm_js_1.default);
+        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 } = (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(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": (0, bindings_wasi_js_1.default)(wasiConfig),
+        });
+        const instance = result.instance;
+        smoldotJsConfig.instance = instance;
+        wasiConfig.instance = instance;
+        return instance;
+    });
+}
+exports.startInstance = startInstance;

package/dist/cjs/package.json

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

package/dist/mjs/base64.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Decodes a multibase-encoded string.
+ *
+ * Throws an exception if the encoding isn't base64 or one of its variants.
+ */
+export declare function multibaseBase64Decode(input: string): Uint8Array;
+/**
+ * Decodes a base64-encoded string into bytes using the original alphabet from RFC4648.
+ *
+ * See <https://datatracker.ietf.org/doc/html/rfc4648#section-4>.
+ */
+export declare function classicDecode(input: string): Uint8Array;
+/**
+ * Decodes a base64-encoded string into bytes using the URL-safe alphabet.
+ *
+ * See <https://datatracker.ietf.org/doc/html/rfc4648#section-5>.
+ */
+export declare function urlSafeDecode(input: string): Uint8Array;
+/**
+ * Decodes a base64-encoded string into bytes using the given alphabet.
+ */
+export declare function base64Decode(input: string, alphabet: Map<string, number>): Uint8Array;

package/dist/mjs/base64.js

@@ -0,0 +1,97 @@
+// 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/>.
+let rfc4648Alphabet = new Map();
+const rfc4648AlphabetAsStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (let i = 0; i < rfc4648AlphabetAsStr.length; ++i) {
+    rfc4648Alphabet.set(rfc4648AlphabetAsStr[i], i);
+}
+let urlSafeAlphabet = new Map();
+const urlSafeAlphabetAsStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+for (let i = 0; i < urlSafeAlphabetAsStr.length; ++i) {
+    urlSafeAlphabet.set(urlSafeAlphabetAsStr[i], i);
+}
+/**
+ * Decodes a multibase-encoded string.
+ *
+ * Throws an exception if the encoding isn't base64 or one of its variants.
+ */
+export function multibaseBase64Decode(input) {
+    if (input.length === 0)
+        throw new Error("Invalid multibase");
+    switch (input[0]) {
+        case 'm':
+        case 'M':
+            return classicDecode(input.slice(1));
+        case 'u':
+        case 'U':
+            return urlSafeDecode(input.slice(1));
+        default:
+            throw new Error('Unknown multibase prefix: ' + input[0]);
+    }
+}
+/**
+ * Decodes a base64-encoded string into bytes using the original alphabet from RFC4648.
+ *
+ * See <https://datatracker.ietf.org/doc/html/rfc4648#section-4>.
+ */
+export function classicDecode(input) {
+    return base64Decode(input, rfc4648Alphabet);
+}
+/**
+ * Decodes a base64-encoded string into bytes using the URL-safe alphabet.
+ *
+ * See <https://datatracker.ietf.org/doc/html/rfc4648#section-5>.
+ */
+export function urlSafeDecode(input) {
+    return base64Decode(input, urlSafeAlphabet);
+}
+/**
+ * Decodes a base64-encoded string into bytes using the given alphabet.
+ */
+export function base64Decode(input, alphabet) {
+    // Remove the padding bytes at the end of the string. We don't check whether the padding is
+    // accurate.
+    while (input.length !== 0 && input[input.length - 1] === '=')
+        input = input.slice(0, -1);
+    // Contains the output data.
+    const out = new Uint8Array(Math.floor(input.length * 6 / 8));
+    // Position within `out` of the next byte to write.
+    let outPos = 0;
+    // The bits decoded from the input are added to the right of this value.
+    let currentByte = 0;
+    // The left-most `validBitsInCurrentByte` bits of `currentByte` must be written out.
+    let validBitsInCurrentByte = 0;
+    for (let i = 0; i < input.length; ++i) {
+        const inputChr = input[i];
+        const bitsToAppend = alphabet.get(inputChr);
+        if (bitsToAppend === undefined)
+            throw new Error('Invalid base64 character: ' + inputChr);
+        console.assert(bitsToAppend < (1 << 6));
+        currentByte = (currentByte << 6) | bitsToAppend;
+        validBitsInCurrentByte += 6;
+        if (validBitsInCurrentByte >= 8) {
+            let outByte = currentByte >> (validBitsInCurrentByte - 8);
+            out[outPos] = outByte;
+            outPos += 1;
+            validBitsInCurrentByte -= 8;
+        }
+        console.assert(validBitsInCurrentByte < 8);
+        currentByte &= 0xff;
+    }
+    if ((currentByte & ((1 << validBitsInCurrentByte) - 1)) !== 0)
+        throw new Error("Unexpected EOF");
+    if (validBitsInCurrentByte >= 6)
+        throw new Error("Unexpected EOF");
+    return out;
+}