smoldot 3.3.0 → 3.3.2

package/dist/cjs/internals/client.js

@@ -78,7 +78,7 @@ function start(options, wasmModule, platformBindings) {
                 console.error("Smoldot has panicked" +
                     (event.currentTask ? (" while executing task `" + event.currentTask + "`") : "") +
                     ". This is a bug in smoldot. Please open an issue at " +
-                    "https://github.com/smol-dot/smoldot/issues with the following message:\n" +
+                    "https://github.com/paritytech/smoldot/issues with the following message:\n" +
                     event.message);
                 state.instance = {
                     status: "destroyed",

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

@@ -304,6 +304,7 @@ function startLocalInstance(config, wasmModule, eventCallback) {
         // panic happens.
         const shutdownExecutorOrWasmPanicPromise = new Promise((resolve) => state.onShutdownExecutorOrWasmPanic = () => resolve("stop"));
         (() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const cpuRateLimit = config.cpuRateLimit;
             // In order to avoid calling `setTimeout` too often, we accumulate sleep up until
             // a certain threshold.
@@ -316,7 +317,30 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                 try {
                     state.instance.exports.advance_execution();
                 }
-                catch (_error) {
+                catch (error) {
+                    // Two kinds of exceptions can reach this point:
+                    //
+                    // - A Rust panic. The `panic` binding has already emitted the `wasm-panic`
+                    //   event, notified the shutdown callback, and set `state.instance` to `null`.
+                    //
+                    // - An exception thrown by JavaScript code called from within the Wasm (for
+                    //   example a platform binding, see
+                    //   <https://github.com/paritytech/smoldot/issues/3302>). The exception has
+                    //   unwound through the Wasm frames without the Rust code being aware of it,
+                    //   leaving the instance in an unusable state (locks still held, etc.).
+                    //   Swallowing it would leave a zombie instance that panics at every
+                    //   subsequent entry point. Instead, report it as a crash, the same way as
+                    //   a panic.
+                    if (state.instance) {
+                        state.instance = null;
+                        eventCallback({
+                            ty: "wasm-panic",
+                            message: error instanceof Error ? ((_a = error.stack) !== null && _a !== void 0 ? _a : error.toString()) : String(error),
+                            currentTask: state.currentTask
+                        });
+                        state.onShutdownExecutorOrWasmPanic();
+                        state.onShutdownExecutorOrWasmPanic = () => { };
+                    }
                     return;
                 }
                 const afterExec = config.performanceNow();

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

@@ -29,6 +29,10 @@ Object.defineProperty(exports, "QueueFullError", { enumerable: true, get: functi
  */
 function startWithBytecode(options) {
     options.forbidTcp = true;
+    // Browsers only expose the WebRTC API on `Window`, it doesn't exist in worker global
+    // scopes, and consequently there is no way to open WebRTC connections from here.
+    if (typeof RTCPeerConnection === 'undefined')
+        options.forbidWebRtc = true;
     // When in a secure context, browsers refuse to open non-secure WebSocket connections to
     // non-localhost. There is an exception if the page is localhost, in which case all connections
     // are allowed.
@@ -169,6 +173,27 @@ function connect(config) {
         };
     }
     else if (config.address.ty === "webrtc") {
+        // Browsers only expose the WebRTC API on `Window`.
+        // When running in a worker, opening a WebRTC connection is impossible.
+        // Instead of throwing an exception (which would crash the entire client),
+        // report the connection as reset so that smoldot moves on to other
+        // addresses.
+        //
+        // Note: `startWithBytecode` sets `forbidWebRtc` in that situation, making
+        // this code path unreachable, but better be defensive.
+        if (typeof RTCPeerConnection === 'undefined') {
+            let cancelled = false;
+            setTimeout(() => {
+                if (!cancelled)
+                    config.onConnectionReset('RTCPeerConnection is not available in this environment');
+            }, 1);
+            return {
+                reset: () => { cancelled = true; },
+                send: () => { throw new Error('Connection is closed'); },
+                closeSend: () => { throw new Error('Connection is closed'); },
+                openOutSubstream: () => { throw new Error('Connection is closed'); },
+            };
+        }
         const { targetPort, ipVersion, targetIp, remoteTlsCertificateSha256 } = config.address;
         const state = {
             pc: undefined,
@@ -208,7 +233,13 @@ function connect(config) {
             dataChannel.binaryType = 'arraybuffer';
             let isOpen = { value: false };
             dataChannel.onopen = () => {
+                // Guard against the `open` event firing more than once for the same channel.
+                // Reporting the same stream id twice would make smoldot panic (observed in
+                // production as "same stream_id used multiple times in
+                // connection_stream_opened").
                 console.assert(!isOpen.value, "substream opened twice");
+                if (isOpen.value)
+                    return;
                 isOpen.value = true;
                 config.onStreamOpened(streamId, direction);
                 config.onWritableBytes(65536, streamId);