smoldot 1.0.11 → 1.0.13

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

@@ -287,8 +287,11 @@ function start(options, wasmModule, platformBindings) {
             if (jsonRpcMaxSubscriptions > 0xffffffff) {
                 jsonRpcMaxSubscriptions = 0xffffffff;
             }
+            // Sanitize `databaseContent`.
+            if (options.databaseContent !== undefined && typeof options.databaseContent !== 'string')
+                throw new public_types_js_1.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 public_types_js_1.AddChainError(outcome.error);

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

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMultiaddr = exports.startLocalInstance = void 0;
+exports.startLocalInstance = 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
@@ -127,26 +127,90 @@ 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) => {
@@ -476,14 +540,14 @@ 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];
@@ -524,49 +588,3 @@ function startLocalInstance(config, wasmModule, eventCallback) {
     });
 }
 exports.startLocalInstance = startLocalInstance;
-// TODO: consider moving this function somewhere else or something
-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' };
-    }
-}
-exports.parseMultiaddr = parseMultiaddr;

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

@@ -14,7 +14,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startWithBytecode = exports.QueueFullError = exports.MalformedJsonRpcError = exports.JsonRpcDisabledError = exports.CrashError = exports.AlreadyDestroyedError = exports.AddChainError = void 0;
 const client_js_1 = require("./internals/client.js");
-const base64_js_1 = require("./internals/base64.js");
 var public_types_js_1 = require("./public-types.js");
 Object.defineProperty(exports, "AddChainError", { enumerable: true, get: function () { return public_types_js_1.AddChainError; } });
 Object.defineProperty(exports, "AlreadyDestroyedError", { enumerable: true, get: function () { return public_types_js_1.AlreadyDestroyedError; } });
@@ -107,7 +106,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) => {
@@ -159,13 +158,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 = (0, base64_js_1.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
@@ -179,10 +172,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.
@@ -232,8 +225,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 {
@@ -338,9 +331,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.
@@ -376,7 +368,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 = 
@@ -403,7 +395,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" +
@@ -434,7 +426,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 }) => {
@@ -506,12 +498,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/cjs/no-auto-bytecode-deno.js

@@ -80,7 +80,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) : "");
@@ -135,7 +135,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/cjs/no-auto-bytecode-nodejs.js

@@ -76,7 +76,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) : "");
@@ -131,7 +131,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/dist/mjs/internals/buffer.d.ts

@@ -1,4 +1,6 @@
 export declare function utf8BytesToString(buffer: Uint8Array, offset: number, length: number): string;
+export declare function readUInt8(buffer: Uint8Array, offset: number): number;
+export declare function readUInt16BE(buffer: Uint8Array, offset: number): number;
 export declare function readUInt32LE(buffer: Uint8Array, offset: number): number;
 /**
  * Sets the value of a given byte in the buffer.

package/dist/mjs/internals/buffer.js

@@ -17,6 +17,14 @@ export function utf8BytesToString(buffer, offset, length) {
     // <https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder>
     return new TextDecoder().decode(buffer.slice(offset, offset + length));
 }
+export function readUInt8(buffer, offset) {
+    checkRange(buffer, offset, 1);
+    return buffer[offset];
+}
+export function readUInt16BE(buffer, offset) {
+    checkRange(buffer, offset, 2);
+    return ((buffer[offset] << 8) | buffer[offset + 1]);
+}
 export function readUInt32LE(buffer, offset) {
     checkRange(buffer, offset, 4);
     return (buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16)) + (buffer[offset + 3] * 0x1000000);