smoldot 2.0.10 → 2.0.12

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

@@ -68,7 +68,7 @@ export interface Connection {
      *
      * Must not be called after `closeSend` has been called.
      */
-    send(data: Uint8Array, streamId?: number): void;
+    send(data: Array<Uint8Array>, streamId?: number): void;
     /**
      * Closes the writing side of the given stream of the given connection.
      *

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

@@ -69,7 +69,7 @@ export type Event = {
     ty: "stream-send";
     connectionId: number;
     streamId?: number;
-    data: Uint8Array;
+    data: Array<Uint8Array>;
 } | {
     ty: "stream-send-close";
     connectionId: number;

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

@@ -250,9 +250,15 @@ function startLocalInstance(config, wasmModule, eventCallback) {
             // that this function is called only when the connection is in an open state.
             stream_send: (connectionId, streamId, ptr, len) => {
                 const instance = state.instance;
+                const mem = new Uint8Array(instance.exports.memory.buffer);
                 ptr >>>= 0;
                 len >>>= 0;
-                const data = new Uint8Array(instance.exports.memory.buffer).slice(ptr, ptr + len);
+                const data = new Array();
+                for (let i = 0; i < len; ++i) {
+                    const bufPtr = buffer.readUInt32LE(mem, ptr + 8 * i);
+                    const bufLen = buffer.readUInt32LE(mem, ptr + 8 * i + 4);
+                    data.push(mem.slice(bufPtr, bufPtr + bufLen));
+                }
                 // TODO: docs says the streamId is provided only for multi-stream connections, but here it's always provided
                 eventCallback({ ty: "stream-send", connectionId, streamId, data });
             },

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

@@ -29,6 +29,19 @@ Object.defineProperty(exports, "QueueFullError", { enumerable: true, get: functi
  */
 function startWithBytecode(options) {
     options.forbidTcp = 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.
+    // Detecting this ahead of time is better for the overall health of the client, as it will
+    // avoid storing in memory addresses that it knows it can't connect to.
+    // The condition below is a hint, and false-positives or false-negatives are not fundamentally
+    // an issue.
+    if ((typeof isSecureContext === 'boolean' && isSecureContext) && typeof location !== undefined) {
+        const loc = location.toString();
+        if (loc.indexOf('localhost') !== -1 && loc.indexOf('127.0.0.1') !== -1 && loc.indexOf('::1') !== -1) {
+            options.forbidNonLocalWs = true;
+        }
+    }
     return (0, client_js_1.start)(options, options.bytecode, {
         performanceNow: () => {
             return performance.now();
@@ -142,12 +155,14 @@ function connect(config) {
                 connection = null;
             },
             send: (data) => {
-                connection.send(data);
                 if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
                     bufferedAmountCheck.nextTimeout = 10;
                     setTimeout(checkBufferedAmount, 10);
                 }
-                bufferedAmountCheck.quenedUnreportedBytes += data.length;
+                for (const buffer of data) {
+                    bufferedAmountCheck.quenedUnreportedBytes += buffer.length;
+                }
+                connection.send(new Blob(data));
             },
             closeSend: () => { throw new Error('Wrong connection type'); },
             openOutSubstream: () => { throw new Error('Wrong connection type'); }
@@ -418,8 +433,10 @@ function connect(config) {
             },
             send: (data, streamId) => {
                 const channel = state.dataChannels.get(streamId);
-                channel.channel.send(data);
-                channel.bufferedBytes += data.length;
+                for (const buffer of data) {
+                    channel.bufferedBytes += buffer.length;
+                }
+                channel.channel.send(new Blob(data));
             },
             closeSend: () => { throw new Error('Wrong connection type'); },
             openOutSubstream: () => {

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

@@ -105,12 +105,14 @@ function connect(config) {
                 // we thus absorb any exception thrown here.
                 // See also <https://github.com/paritytech/smoldot/issues/2937>.
                 try {
-                    socket.send(data);
                     if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
                         bufferedAmountCheck.nextTimeout = 10;
                         setTimeout(checkBufferedAmount, 10);
                     }
-                    bufferedAmountCheck.quenedUnreportedBytes += data.length;
+                    for (const buffer of data) {
+                        bufferedAmountCheck.quenedUnreportedBytes += buffer.length;
+                    }
+                    socket.send(new Blob(data));
                 }
                 catch (_error) { }
             },
@@ -172,31 +174,35 @@ function connect(config) {
                 socket.inner.then((connec) => connec.close());
             },
             send: (data) => {
-                let dataCopy = Uint8Array.from(data); // Deep copy of the data
+                let dataCopy = data.map((buf) => Uint8Array.from(buf)); // Deep copy of the data
                 socket.inner = socket.inner.then((c) => __awaiter(this, void 0, void 0, function* () {
-                    while (dataCopy.length > 0) {
-                        if (socket.destroyed || c === null)
-                            return c;
-                        let outcome;
-                        try {
-                            outcome = yield c.write(dataCopy);
-                            config.onWritableBytes(dataCopy.length);
-                        }
-                        catch (error) {
-                            // The type of `error` is unclear, but we assume that it implements `Error`
-                            outcome = error.toString();
-                        }
-                        if (typeof outcome !== 'number') {
-                            // The socket is reported closed, but `socket.destroyed` is still
-                            // `false` (see check above). As such, we must inform the inner layers.
-                            socket.destroyed = true;
-                            config.onConnectionReset(outcome);
-                            return c;
+                    for (let buffer of dataCopy) {
+                        while (buffer.length > 0) {
+                            if (socket.destroyed || c === null)
+                                return c;
+                            let outcome;
+                            try {
+                                outcome = yield c.write(buffer);
+                                config.onWritableBytes(buffer.length);
+                            }
+                            catch (error) {
+                                // The type of `error` is unclear, but we assume that it
+                                // implements `Error`
+                                outcome = error.toString();
+                            }
+                            if (typeof outcome !== 'number') {
+                                // The socket is reported closed, but `socket.destroyed` is still
+                                // `false` (see check above). As such, we must inform the
+                                // inner layers.
+                                socket.destroyed = true;
+                                config.onConnectionReset(outcome);
+                                return c;
+                            }
+                            // Note that, contrary to `read`, it is possible for `outcome` to be 0.
+                            // This happen if the write had to be interrupted, and the only thing
+                            // we have to do is try writing again.
+                            buffer = buffer.slice(outcome);
                         }
-                        // Note that, contrary to `read`, it is possible for `outcome` to be 0.
-                        // This happen if the write had to be interrupted, and the only thing
-                        // we have to do is try writing again.
-                        dataCopy = dataCopy.slice(outcome);
                     }
                     return c;
                 }));

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

@@ -106,12 +106,14 @@ function connect(config) {
                 socket.close();
             },
             send: (data) => {
-                socket.send(data);
                 if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
                     bufferedAmountCheck.nextTimeout = 10;
                     setTimeout(checkBufferedAmount, 10);
                 }
-                bufferedAmountCheck.quenedUnreportedBytes += data.length;
+                for (const buffer of data) {
+                    socket.send(buffer);
+                    bufferedAmountCheck.quenedUnreportedBytes += buffer.length;
+                }
             },
             closeSend: () => { throw new Error('Wrong connection type'); },
             openOutSubstream: () => { throw new Error('Wrong connection type'); }
@@ -158,17 +160,19 @@ function connect(config) {
                 socket.destroy();
             },
             send: (data) => {
-                const dataLen = data.length;
-                const allWritten = socket.write(data);
-                if (allWritten) {
-                    setImmediate(() => {
-                        if (!socket.writable)
-                            return;
-                        config.onWritableBytes(dataLen);
-                    });
-                }
-                else {
-                    drainingBytes.num += dataLen;
+                for (const buffer of data) {
+                    const bufferLen = buffer.length;
+                    const allWritten = socket.write(buffer);
+                    if (allWritten) {
+                        setImmediate(() => {
+                            if (!socket.writable)
+                                return;
+                            config.onWritableBytes(bufferLen);
+                        });
+                    }
+                    else {
+                        drainingBytes.num += bufferLen;
+                    }
                 }
             },
             closeSend: () => {