smoldot 1.0.11 → 1.0.13

package/dist/mjs/internals/client.d.ts

@@ -120,12 +120,11 @@ export interface ConnectionConfig {
         type: 'single-stream';
         handshake: 'multistream-select-noise-yamux';
         initialWritableBytes: number;
-        writeClosable: boolean;
     } | {
         type: 'multi-stream';
         handshake: 'webrtc';
-        localTlsCertificateMultihash: Uint8Array;
-        remoteTlsCertificateMultihash: Uint8Array;
+        localTlsCertificateSha256: Uint8Array;
+        remoteTlsCertificateSha256: Uint8Array;
     }) => void;
     /**
      * Callback called when the connection transitions to the `Reset` state.

package/dist/mjs/internals/client.js

@@ -284,8 +284,11 @@ export function start(options, wasmModule, platformBindings) {
             if (jsonRpcMaxSubscriptions > 0xffffffff) {
                 jsonRpcMaxSubscriptions = 0xffffffff;
             }
+            // Sanitize `databaseContent`.
+            if (options.databaseContent !== undefined && typeof options.databaseContent !== 'string')
+                throw new AddChainError("`databaseContent` is not a string");
             const promise = new Promise((resolve) => state.addChainResults.push(resolve));
-            state.instance.instance.addChain(options.chainSpec, typeof options.databaseContent === 'string' ? options.databaseContent : "", potentialRelayChainsIds, !!options.disableJsonRpc, jsonRpcMaxPendingRequests, jsonRpcMaxSubscriptions);
+            state.instance.instance.addChain(options.chainSpec, options.databaseContent || "", potentialRelayChainsIds, !!options.disableJsonRpc, jsonRpcMaxPendingRequests, jsonRpcMaxSubscriptions);
             const outcome = yield promise;
             if (!outcome.success)
                 throw new AddChainError(outcome.error);

package/dist/mjs/internals/local-instance.d.ts

@@ -84,10 +84,10 @@ export type ParsedMultiaddr = {
     url: string;
 } | {
     ty: "webrtc";
-    targetPort: string;
+    targetPort: number;
     ipVersion: string;
     targetIp: string;
-    remoteCertMultibase: string;
+    remoteTlsCertificateSha256: Uint8Array;
 };
 export interface Instance {
     request: (request: string, chainId: number) => number;
@@ -107,12 +107,11 @@ export interface Instance {
         type: 'single-stream';
         handshake: 'multistream-select-noise-yamux';
         initialWritableBytes: number;
-        writeClosable: boolean;
     } | {
         type: 'multi-stream';
         handshake: 'webrtc';
-        localTlsCertificateMultihash: Uint8Array;
-        remoteTlsCertificateMultihash: Uint8Array;
+        localTlsCertificateSha256: Uint8Array;
+        remoteTlsCertificateSha256: Uint8Array;
     }) => void;
     connectionReset: (connectionId: number, message: string) => void;
     streamWritableBytes: (connectionId: number, numExtra: number, streamId?: number) => void;
@@ -133,10 +132,3 @@ export interface Instance {
  * isn't sanitized. In other words, you know what you're doing.
  */
 export declare function startLocalInstance(config: Config, wasmModule: WebAssembly.Module, eventCallback: (event: Event) => void): Promise<Instance>;
-export declare function parseMultiaddr(address: string, forbidTcp: boolean, forbidWs: boolean, forbidNonLocalWs: boolean, forbidWss: boolean, forbidWebRtc: boolean): {
-    success: true;
-    address: ParsedMultiaddr;
-} | {
-    success: false;
-    error: string;
-};

package/dist/mjs/internals/local-instance.js

@@ -124,26 +124,90 @@ export function startLocalInstance(config, wasmModule, eventCallback) {
                     }, ms);
                 }
             },
+            // Must indicate whether the given connection type is supported.
+            connection_type_supported: (ty) => {
+                // TODO: consider extracting config options so user can't change the fields dynamically
+                switch (ty) {
+                    case 0:
+                    case 1:
+                    case 2: {
+                        return config.forbidTcp ? 0 : 1;
+                    }
+                    case 4:
+                    case 5:
+                    case 6: {
+                        return config.forbidNonLocalWs ? 0 : 1;
+                    }
+                    case 7: {
+                        return config.forbidWs ? 0 : 1;
+                    }
+                    case 14: {
+                        return config.forbidWss ? 0 : 1;
+                    }
+                    case 16:
+                    case 17: {
+                        return config.forbidWebRtc ? 0 : 1;
+                    }
+                    default:
+                        // Indicates a bug somewhere.
+                        throw new Error("Invalid connection type passed to `connection_type_supported`");
+                }
+            },
             // Must create a new connection object. This implementation stores the created object in
             // `connections`.
-            connection_new: (connectionId, addrPtr, addrLen, errorBufferIndexPtr) => {
+            connection_new: (connectionId, addrPtr, addrLen) => {
                 const instance = state.instance;
+                const mem = new Uint8Array(instance.exports.memory.buffer);
                 addrPtr >>>= 0;
                 addrLen >>>= 0;
-                errorBufferIndexPtr >>>= 0;
-                const address = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), addrPtr, addrLen);
-                // TODO: consider extracting config options so user can't change the fields dynamically
-                const result = parseMultiaddr(address, config.forbidTcp, config.forbidWs, config.forbidNonLocalWs, config.forbidWss, config.forbidWebRtc);
-                if (result.success) {
-                    eventCallback({ ty: "new-connection", connectionId, address: result.address });
-                    return 0;
-                }
-                else {
-                    const mem = new Uint8Array(instance.exports.memory.buffer);
-                    state.bufferIndices[0] = new TextEncoder().encode(result.error);
-                    buffer.writeUInt32LE(mem, errorBufferIndexPtr, 0);
-                    return 1;
+                let address;
+                switch (buffer.readUInt8(mem, addrPtr)) {
+                    case 0:
+                    case 1:
+                    case 2: {
+                        const port = buffer.readUInt16BE(mem, addrPtr + 1);
+                        const hostname = buffer.utf8BytesToString(mem, addrPtr + 3, addrLen - 3);
+                        address = { ty: "tcp", port, hostname };
+                        break;
+                    }
+                    case 4:
+                    case 6: {
+                        const port = buffer.readUInt16BE(mem, addrPtr + 1);
+                        const hostname = buffer.utf8BytesToString(mem, addrPtr + 3, addrLen - 3);
+                        address = { ty: "websocket", url: "ws://" + hostname + ":" + port };
+                        break;
+                    }
+                    case 5: {
+                        const port = buffer.readUInt16BE(mem, addrPtr + 1);
+                        const hostname = buffer.utf8BytesToString(mem, addrPtr + 3, addrLen - 3);
+                        address = { ty: "websocket", url: "ws://[" + hostname + "]:" + port };
+                        break;
+                    }
+                    case 14: {
+                        const port = buffer.readUInt16BE(mem, addrPtr + 1);
+                        const hostname = buffer.utf8BytesToString(mem, addrPtr + 3, addrLen - 3);
+                        address = { ty: "websocket", url: "wss://" + hostname + ":" + port };
+                        break;
+                    }
+                    case 16: {
+                        const targetPort = buffer.readUInt16BE(mem, addrPtr + 1);
+                        const remoteTlsCertificateSha256 = mem.slice(addrPtr + 3, addrPtr + 35);
+                        const targetIp = buffer.utf8BytesToString(mem, addrPtr + 35, addrLen - 3);
+                        address = { ty: "webrtc", ipVersion: '4', remoteTlsCertificateSha256, targetIp, targetPort };
+                        break;
+                    }
+                    case 17: {
+                        const targetPort = buffer.readUInt16BE(mem, addrPtr + 1);
+                        const remoteTlsCertificateSha256 = mem.slice(addrPtr + 3, addrPtr + 35);
+                        const targetIp = buffer.utf8BytesToString(mem, addrPtr + 35, addrLen - 3);
+                        address = { ty: "webrtc", ipVersion: '6', remoteTlsCertificateSha256, targetIp, targetPort };
+                        break;
+                    }
+                    default:
+                        // Indicates a bug somewhere.
+                        throw new Error("Invalid encoded address passed to `connection_new`");
                 }
+                eventCallback({ ty: "new-connection", connectionId, address });
             },
             // Must close and destroy the connection object.
             reset_connection: (connectionId) => {
@@ -473,14 +537,14 @@ export function startLocalInstance(config, wasmModule, eventCallback) {
                     return;
                 switch (info.type) {
                     case 'single-stream': {
-                        state.instance.exports.connection_open_single_stream(connectionId, 0, info.initialWritableBytes, info.writeClosable ? 1 : 0);
+                        state.instance.exports.connection_open_single_stream(connectionId, info.initialWritableBytes);
                         break;
                     }
                     case 'multi-stream': {
-                        const handshakeTy = new Uint8Array(1 + info.localTlsCertificateMultihash.length + info.remoteTlsCertificateMultihash.length);
+                        const handshakeTy = new Uint8Array(1 + info.localTlsCertificateSha256.length + info.remoteTlsCertificateSha256.length);
                         buffer.writeUInt8(handshakeTy, 0, 0);
-                        handshakeTy.set(info.localTlsCertificateMultihash, 1);
-                        handshakeTy.set(info.remoteTlsCertificateMultihash, 1 + info.localTlsCertificateMultihash.length);
+                        handshakeTy.set(info.localTlsCertificateSha256, 1);
+                        handshakeTy.set(info.remoteTlsCertificateSha256, 1 + info.localTlsCertificateSha256.length);
                         state.bufferIndices[0] = handshakeTy;
                         state.instance.exports.connection_open_multi_stream(connectionId, 0);
                         delete state.bufferIndices[0];
@@ -520,48 +584,3 @@ export function startLocalInstance(config, wasmModule, eventCallback) {
         };
     });
 }
-// TODO: consider moving this function somewhere else or something
-export function parseMultiaddr(address, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRtc) {
-    const tcpParsed = address.match(/^\/(ip4|ip6|dns4|dns6|dns)\/(.*?)\/tcp\/(.*?)$/);
-    // TODO: remove support for `/wss` in a long time (https://github.com/paritytech/smoldot/issues/1940)
-    const wsParsed = address.match(/^\/(ip4|ip6|dns4|dns6|dns)\/(.*?)\/tcp\/(.*?)\/(ws|wss|tls\/ws)$/);
-    const webRTCParsed = address.match(/^\/(ip4|ip6)\/(.*?)\/udp\/(.*?)\/webrtc-direct\/certhash\/(.*?)$/);
-    if (wsParsed != null) {
-        const proto = (wsParsed[4] == 'ws') ? 'ws' : 'wss';
-        if (proto == 'ws' && forbidWs) {
-            return { success: false, error: 'WebSocket connections not available' };
-        }
-        if (proto == 'wss' && forbidWss) {
-            return { success: false, error: 'WebSocket secure connections not available' };
-        }
-        if (proto == 'ws' && wsParsed[2] != 'localhost' && wsParsed[2] != '127.0.0.1' && forbidNonLocalWs) {
-            return { success: false, error: 'Non-local WebSocket connections not available' };
-        }
-        const url = (wsParsed[1] == 'ip6') ?
-            (proto + "://[" + wsParsed[2] + "]:" + wsParsed[3]) :
-            (proto + "://" + wsParsed[2] + ":" + wsParsed[3]);
-        return { success: true, address: { ty: "websocket", url } };
-    }
-    else if (tcpParsed != null) {
-        if (forbidTcp) {
-            return { success: false, error: 'TCP connections not available' };
-        }
-        return { success: true, address: { ty: "tcp", hostname: tcpParsed[2], port: parseInt(tcpParsed[3]) } };
-    }
-    else if (webRTCParsed != null) {
-        const targetPort = webRTCParsed[3];
-        if (forbidWebRtc) {
-            return { success: false, error: 'WebRTC connections not available' };
-        }
-        if (targetPort === '0') {
-            return { success: false, error: 'Invalid WebRTC target port' };
-        }
-        const ipVersion = webRTCParsed[1] == 'ip4' ? '4' : '6';
-        const targetIp = webRTCParsed[2];
-        const remoteCertMultibase = webRTCParsed[4];
-        return { success: true, address: { ty: "webrtc", targetPort, ipVersion, targetIp, remoteCertMultibase } };
-    }
-    else {
-        return { success: false, error: 'Unrecognized multiaddr format' };
-    }
-}

package/dist/mjs/no-auto-bytecode-browser.js

@@ -11,7 +11,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { start as innerStart } from './internals/client.js';
-import { multibaseBase64Decode } from './internals/base64.js';
 export { AddChainError, AlreadyDestroyedError, CrashError, JsonRpcDisabledError, MalformedJsonRpcError, QueueFullError } from './public-types.js';
 /**
  * Initializes a new client. This is a pre-requisite to connecting to a blockchain.
@@ -97,7 +96,7 @@ function connect(config) {
             connection.onopen = () => {
                 config.onOpen({
                     type: 'single-stream', handshake: 'multistream-select-noise-yamux',
-                    initialWritableBytes: 1024 * 1024, writeClosable: false,
+                    initialWritableBytes: 1024 * 1024
                 });
             };
             connection.onclose = (event) => {
@@ -149,13 +148,7 @@ function connect(config) {
         };
     }
     else if (config.address.ty === "webrtc") {
-        const { targetPort, ipVersion, targetIp, remoteCertMultibase } = config.address;
-        // The payload of `/certhash` is the hash of the self-generated certificate that the
-        // server presents.
-        // This function throws an exception if the certhash isn't correct. For this reason, this call
-        // is performed as part of the parsing of the multiaddr.
-        const remoteCertMultihash = multibaseBase64Decode(remoteCertMultibase);
-        const remoteCertSha256Hash = multihashToSha256(remoteCertMultihash);
+        const { targetPort, ipVersion, targetIp, remoteTlsCertificateSha256 } = config.address;
         // TODO: detect localhost for Firefox? https://bugzilla.mozilla.org/show_bug.cgi?id=1659672
         // Note that `pc` can be the connection, but also null or undefined.
         // `undefined` means "certificate generation in progress", while `null` means "opening must
@@ -169,10 +162,10 @@ function connect(config) {
         // to smoldot. This data channel is stored in this variable. Once it is reported to smoldot,
         // it is inserted in `dataChannels`.
         let handshakeDataChannel;
-        // Multihash-encoded DTLS certificate of the local node. Unknown as long as it hasn't been
+        // SHA256 hash of the DTLS certificate of the local node. Unknown as long as it hasn't been
         // generated.
         // TODO: could be merged with `pc` in one variable, and maybe even the other fields as well
-        let localTlsCertificateMultihash;
+        let localTlsCertificateSha256;
         // Kills all the JavaScript objects (the connection and all its substreams), ensuring that no
         // callback will be called again. Doesn't report anything to smoldot, as this should be done
         // by the caller.
@@ -222,8 +215,8 @@ function connect(config) {
                         handshake: 'webrtc',
                         // `addChannel` can never be called before the local certificate is generated, so this
                         // value is always defined.
-                        localTlsCertificateMultihash: localTlsCertificateMultihash,
-                        remoteTlsCertificateMultihash: remoteCertMultihash
+                        localTlsCertificateSha256: localTlsCertificateSha256,
+                        remoteTlsCertificateSha256,
                     });
                 }
                 else {
@@ -328,9 +321,8 @@ function connect(config) {
                 config.onConnectionReset('Failed to obtain the browser certificate fingerprint');
                 return;
             }
-            localTlsCertificateMultihash = new Uint8Array(34);
-            localTlsCertificateMultihash.set([0x12, 32], 0);
-            localTlsCertificateMultihash.set(localTlsCertificateHex.split(':').map((s) => parseInt(s, 16)), 2);
+            localTlsCertificateSha256 = new Uint8Array(32);
+            localTlsCertificateSha256.set(localTlsCertificateHex.split(':').map((s) => parseInt(s, 16)), 0);
             // `onconnectionstatechange` is used to detect when the connection has closed or has failed
             // to open.
             // Note that smoldot will think that the connection is open even when it is still opening.
@@ -366,7 +358,7 @@ function connect(config) {
                 sdpOffer = sdpOffer.replace(/^a=ice-pwd.*$/m, 'a=ice-pwd:' + ufragPwd);
                 yield pc.setLocalDescription({ type: 'offer', sdp: sdpOffer });
                 // Transform certificate hash into fingerprint (upper-hex; each byte separated by ":").
-                const fingerprint = Array.from(remoteCertSha256Hash).map((n) => ("0" + n.toString(16)).slice(-2).toUpperCase()).join(':');
+                const fingerprint = Array.from(remoteTlsCertificateSha256).map((n) => ("0" + n.toString(16)).slice(-2).toUpperCase()).join(':');
                 // Note that the trailing line feed is important, as otherwise Chrome
                 // fails to parse the payload.
                 const remoteSdp = 
@@ -393,7 +385,7 @@ function connect(config) {
                     // The `<fmt>` component must always be `webrtc-datachannel` for WebRTC.
                     // The rest of the SDP payload adds attributes to this specific media stream.
                     // RFCs: 8839, 8866, 8841
-                    "m=application " + targetPort + " " + "UDP/DTLS/SCTP webrtc-datachannel" + "\n" +
+                    "m=application " + String(targetPort) + " " + "UDP/DTLS/SCTP webrtc-datachannel" + "\n" +
                     // Indicates the IP address of the remote.
                     // Note that "IN" means "Internet" (and not "input").
                     "c=IN IP" + ipVersion + " " + targetIp + "\n" +
@@ -424,7 +416,7 @@ function connect(config) {
                     "a=max-message-size:16384" + "\n" +
                     // A transport address for a candidate that can be used for connectivity
                     // checks (RFC8839).
-                    "a=candidate:1 1 UDP 1 " + targetIp + " " + targetPort + " typ host" + "\n";
+                    "a=candidate:1 1 UDP 1 " + targetIp + " " + String(targetPort) + " typ host" + "\n";
                 yield pc.setRemoteDescription({ type: "answer", sdp: remoteSdp });
             });
             pc.ondatachannel = ({ channel }) => {
@@ -496,12 +488,3 @@ function connect(config) {
         throw new Error();
     }
 }
-/// Parses a multihash-multibase-encoded string into a SHA256 hash.
-///
-/// Throws an exception if the multihash algorithm isn't SHA256.
-const multihashToSha256 = (certMultihash) => {
-    if (certMultihash.length != 34 || certMultihash[0] != 0x12 || certMultihash[1] != 32) {
-        throw new Error('Certificate multihash is not SHA-256');
-    }
-    return new Uint8Array(certMultihash.slice(2));
-};

package/dist/mjs/no-auto-bytecode-deno.js

@@ -70,7 +70,7 @@ function connect(config) {
                 config.onWritableBytes(wasSent);
         };
         socket.onopen = () => {
-            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: false });
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024 });
         };
         socket.onclose = (event) => {
             const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
@@ -125,7 +125,7 @@ function connect(config) {
             if (socket.destroyed)
                 return established;
             established === null || established === void 0 ? void 0 : established.setNoDelay();
-            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: true });
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024 });
             // Spawns an asynchronous task that continuously reads from the socket.
             // Every time data is read, the task re-executes itself in order to continue reading.
             // The task ends automatically if an EOF or error is detected, which should also happen

package/dist/mjs/no-auto-bytecode-nodejs.js

@@ -66,7 +66,7 @@ function connect(config) {
                 config.onWritableBytes(wasSent);
         };
         socket.onopen = () => {
-            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: false });
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024 });
         };
         socket.onclose = (event) => {
             const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
@@ -121,7 +121,7 @@ function connect(config) {
                 return;
             config.onOpen({
                 type: 'single-stream', handshake: 'multistream-select-noise-yamux',
-                initialWritableBytes: socket.writableHighWaterMark, writeClosable: true
+                initialWritableBytes: socket.writableHighWaterMark
             });
         });
         socket.on('close', (hasError) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoldot",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Light client that connects to Polkadot and Substrate-based blockchains",
   "contributors": [
     "Parity Technologies <admin@parity.io>",

package/dist/cjs/internals/base64.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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/cjs/internals/base64.js

@@ -1,104 +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
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.base64Decode = exports.urlSafeDecode = exports.classicDecode = exports.multibaseBase64Decode = 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/>.
-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.
- */
-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]);
-    }
-}
-exports.multibaseBase64Decode = multibaseBase64Decode;
-/**
- * Decodes a base64-encoded string into bytes using the original alphabet from RFC4648.
- *
- * See <https://datatracker.ietf.org/doc/html/rfc4648#section-4>.
- */
-function classicDecode(input) {
-    return base64Decode(input, rfc4648Alphabet);
-}
-exports.classicDecode = classicDecode;
-/**
- * Decodes a base64-encoded string into bytes using the URL-safe alphabet.
- *
- * See <https://datatracker.ietf.org/doc/html/rfc4648#section-5>.
- */
-function urlSafeDecode(input) {
-    return base64Decode(input, urlSafeAlphabet);
-}
-exports.urlSafeDecode = urlSafeDecode;
-/**
- * Decodes a base64-encoded string into bytes using the given alphabet.
- */
-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;
-}
-exports.base64Decode = base64Decode;

package/dist/mjs/internals/base64.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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/internals/base64.js

@@ -1,97 +0,0 @@
-// 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;
-}