smoldot 3.6.0 → 3.7.0

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

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { start as innerStart } from './internals/client.js';
+import { resolveDnsOverHttps } from './internals/dns-over-https.js';
 export { AddChainError, AlreadyDestroyedError, CrashError, JsonRpcDisabledError, QueueFullError } from './public-types.js';
 /**
  * Initializes a new client. This is a pre-requisite to connecting to a blockchain.
@@ -185,17 +186,46 @@ function connect(config) {
                 openOutSubstream: () => { throw new Error('Connection is closed'); },
             };
         }
-        const { targetPort, ipVersion, targetIp, remoteTlsCertificateSha256 } = config.address;
+        const { targetPort, remoteTlsCertificateSha256 } = config.address;
         const state = {
             pc: undefined,
             dataChannels: new Map(),
             nextStreamId: 0,
             isFirstOutSubstream: true,
+            dnsAbort: null,
         };
+        // The SDP answer needs the literal IP address of the remote.
+        // Browsers expose no DNS API, so a multiaddress with a domain name is resolved over
+        // DNS-over-HTTPS. Resolution is started here and is only awaited in
+        // `onnegotiationneeded`, where the IP is actually needed.
+        let target;
+        if ("targetIp" in config.address) {
+            target = Promise.resolve({ targetIp: config.address.targetIp, ipVersion: config.address.ipVersion });
+        }
+        else {
+            const { hostname, family } = config.address;
+            const controller = new AbortController();
+            state.dnsAbort = controller;
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const finished = () => {
+                clearTimeout(timeout);
+                state.dnsAbort = null;
+            };
+            target = resolveDnsOverHttps(hostname, family, controller.signal).then((ip) => {
+                finished();
+                return { targetIp: ip, ipVersion: ip.includes(':') ? 6 : 4 };
+            }, (error) => {
+                finished();
+                throw error;
+            });
+            target.catch(() => { });
+        }
         // 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.
         const killAllJs = () => {
+            if (state.dnsAbort)
+                state.dnsAbort.abort();
             // The `RTCPeerConnection` is created pretty quickly. It is however still possible for
             // smoldot to cancel the opening, in which case `pc` will still be undefined.
             if (!state.pc) {
@@ -216,6 +246,18 @@ function connect(config) {
             state.dataChannels.clear();
             state.pc.close(); // Not necessarily necessary, but it doesn't hurt to do so.
         };
+        // Due to <https://bugzilla.mozilla.org/show_bug.cgi?id=1659672>,
+        // connections from Firefox to a localhost WebRTC server always fail:
+        // Firefox gathers no loopback ICE candidate.
+        // 
+        // Returns `true` if the connection was refused, in which case the caller must stop.
+        const refuseIfFirefoxLoopback = (ip) => {
+            if ((ip !== '127.0.0.1' && ip !== '::1') || navigator.userAgent.indexOf('Firefox') === -1)
+                return false;
+            killAllJs();
+            config.onConnectionReset("Firefox can't connect to a localhost WebRTC server");
+            return true;
+        };
         // Function that configures a newly-opened channel and adds it to the map. Used for both
         // inbound and outbound substreams.
         const addChannel = (dataChannel, direction) => {
@@ -278,19 +320,10 @@ function connect(config) {
         RTCPeerConnection.generateCertificate({ name: "ECDSA", namedCurve: "P-256", hash: "SHA-256" }).then((localCertificate) => __awaiter(this, void 0, void 0, function* () {
             if (state.pc === null)
                 return;
-            // Due to <https://bugzilla.mozilla.org/show_bug.cgi?id=1659672>, connections from
-            // Firefox to a localhost WebRTC server always fails. Since this bug has been opened
-            // for three years at the time of writing, it is unlikely to be fixed in the short
-            // term. In order to provider better user feedback, we straight up refuse connecting
-            // and stop the connection.
-            // Note that this is just a hint. Failing to detect this will lead to the WebRTC
-            // handshake  timing out.
-            // TODO: eventually remove this if the Firefox bug is fixed
-            if ((targetIp == 'localhost' || targetIp == '127.0.0.1' || targetIp == '::1') && navigator.userAgent.indexOf('Firefox') !== -1) {
-                killAllJs();
-                config.onConnectionReset("Firefox can't connect to a localhost WebRTC server");
+            // A literal loopback address can be refused before anything is created. A domain
+            // name is checked once resolved, in `onnegotiationneeded`.
+            if ("targetIp" in config.address && refuseIfFirefoxLoopback(config.address.targetIp))
                 return;
-            }
             // Create a new WebRTC connection.
             state.pc = new RTCPeerConnection({ certificates: [localCertificate] });
             // We need to build the multihash corresponding to the local certificate.
@@ -365,6 +398,25 @@ function connect(config) {
                 sdpOffer = sdpOffer.replace(/^a=ice-ufrag.*$/m, 'a=ice-ufrag:' + ufragPwd);
                 sdpOffer = sdpOffer.replace(/^a=ice-pwd.*$/m, 'a=ice-pwd:' + ufragPwd);
                 yield state.pc.setLocalDescription({ type: 'offer', sdp: sdpOffer });
+                // The answer needs the literal IP address of the remote, resolution was already stared.
+                let targetIp;
+                let ipVersion;
+                try {
+                    ({ targetIp, ipVersion } = yield target);
+                }
+                catch (error) {
+                    // `reset()` aborts the resolution, and a failure reported through
+                    // `onconnectionstatechange` closes the connection.
+                    if (state.pc.signalingState === "closed")
+                        return;
+                    killAllJs();
+                    config.onConnectionReset("DNS resolution failed: " + (error instanceof Error ? error.message : String(error)));
+                    return;
+                }
+                if (state.pc.signalingState === "closed")
+                    return;
+                if (refuseIfFirefoxLoopback(targetIp))
+                    return;
                 // Transform certificate hash into fingerprint (upper-hex; each byte separated by ":").
                 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

package/package.json

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