smoldot 0.7.13 → 1.0.1

package/dist/mjs/index-deno.js

@@ -99,7 +99,6 @@ function trustedBase64Decode(base64) {
  * @throws {@link ConnectionError} If the multiaddress couldn't be parsed or contains an invalid protocol.
  */
 function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
-    let connection;
     // Attempt to parse the multiaddress.
     // TODO: remove support for `/wss` in a long time (https://github.com/paritytech/smoldot/issues/1940)
     const wsParsed = config.address.match(/^\/(ip4|ip6|dns4|dns6|dns)\/(.*?)\/tcp\/(.*?)\/(ws|wss|tls\/ws)$/);
@@ -114,24 +113,72 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
         const url = (wsParsed[1] == 'ip6') ?
             (proto + "://[" + wsParsed[2] + "]:" + wsParsed[3]) :
             (proto + "://" + wsParsed[2] + ":" + wsParsed[3]);
-        connection = {
-            ty: 'websocket',
-            socket: new WebSocket(url)
+        const socket = new WebSocket(url);
+        socket.binaryType = 'arraybuffer';
+        const bufferedAmountCheck = { quenedUnreportedBytes: 0, nextTimeout: 10 };
+        const checkBufferedAmount = () => {
+            if (socket.readyState != 1)
+                return;
+            // Note that we might expect `bufferedAmount` to always be <= the sum of the lengths
+            // of all the data that has been sent, but that might not be the case. For this
+            // reason, we use `bufferedAmount` as a hint rather than a correct value.
+            const bufferedAmount = socket.bufferedAmount;
+            let wasSent = bufferedAmountCheck.quenedUnreportedBytes - bufferedAmount;
+            if (wasSent < 0)
+                wasSent = 0;
+            bufferedAmountCheck.quenedUnreportedBytes -= wasSent;
+            if (bufferedAmountCheck.quenedUnreportedBytes != 0) {
+                setTimeout(checkBufferedAmount, bufferedAmountCheck.nextTimeout);
+                bufferedAmountCheck.nextTimeout *= 2;
+                if (bufferedAmountCheck.nextTimeout > 500)
+                    bufferedAmountCheck.nextTimeout = 500;
+            }
+            // Note: it is important to call `onWritableBytes` at the very end, as it might
+            // trigger a call to `send`.
+            if (wasSent != 0)
+                config.onWritableBytes(wasSent);
         };
-        connection.socket.binaryType = 'arraybuffer';
-        connection.socket.onopen = () => {
-            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux' });
+        socket.onopen = () => {
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: false });
         };
-        connection.socket.onclose = (event) => {
+        socket.onclose = (event) => {
             const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
             config.onConnectionReset(message);
         };
-        connection.socket.onmessage = (msg) => {
+        socket.onmessage = (msg) => {
             config.onMessage(new Uint8Array(msg.data));
         };
+        return {
+            reset: () => {
+                // We can't set these fields to null because the TypeScript definitions don't
+                // allow it, but we can set them to dummy values.
+                socket.onopen = () => { };
+                socket.onclose = () => { };
+                socket.onmessage = () => { };
+                socket.onerror = () => { };
+                socket.close();
+            },
+            send: (data) => {
+                // The WebSocket library that we use seems to spontaneously transition connections
+                // to the "closed" state but not call the `onclosed` callback immediately. Calling
+                // `send` on that object throws an exception. In order to avoid panicking smoldot,
+                // 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;
+                }
+                catch (_error) { }
+            },
+            closeSend: () => { throw new Error('Wrong connection type'); },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
     }
     else if (tcpParsed != null) {
-        // `net` module will be missing when we're not in NodeJS.
         if (forbidTcp) {
             throw new ConnectionError('TCP connections not available');
         }
@@ -140,21 +187,24 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
             inner: Deno.connect({
                 hostname: tcpParsed[2],
                 port: parseInt(tcpParsed[3], 10),
+            }).catch((error) => {
+                socket.destroyed = true;
+                config.onConnectionReset(error.toString());
+                return null;
             })
         };
-        connection = { ty: 'tcp', socket };
         socket.inner = socket.inner.then((established) => {
             // TODO: at the time of writing of this comment, `setNoDelay` is still unstable
             //established.setNoDelay();
             if (socket.destroyed)
                 return established;
-            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux' });
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: true });
             // 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
             // if the user calls `close()`.
             const read = (readBuffer) => __awaiter(this, void 0, void 0, function* () {
-                if (socket.destroyed)
+                if (socket.destroyed || established === null)
                     return;
                 let outcome = null;
                 try {
@@ -180,53 +230,21 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
             read(new Uint8Array(1024));
             return established;
         });
-    }
-    else {
-        throw new ConnectionError('Unrecognized multiaddr format');
-    }
-    return {
-        reset: () => {
-            if (connection.ty == 'websocket') {
-                // WebSocket
-                // We can't set these fields to null because the TypeScript definitions don't
-                // allow it, but we can set them to dummy values.
-                connection.socket.onopen = () => { };
-                connection.socket.onclose = () => { };
-                connection.socket.onmessage = () => { };
-                connection.socket.onerror = () => { };
-                connection.socket.close();
-            }
-            else {
-                // TCP
-                connection.socket.destroyed = true;
-                connection.socket.inner.then((connec) => connec.close());
-            }
-        },
-        send: (data) => {
-            if (connection.ty == 'websocket') {
-                // WebSocket
-                // The WebSocket library that we use seems to spontaneously transition connections
-                // to the "closed" state but not call the `onclosed` callback immediately. Calling
-                // `send` on that object throws an exception. In order to avoid panicking smoldot,
-                // we thus absorb any exception thrown here.
-                // See also <https://github.com/paritytech/smoldot/issues/2937>.
-                try {
-                    connection.socket.send(data);
-                }
-                catch (_error) { }
-            }
-            else {
-                // TCP
-                // TODO: at the moment, sending data doesn't have any back-pressure mechanism; as such, we just buffer data indefinitely
+        return {
+            reset: () => {
+                socket.destroyed = true;
+                socket.inner.then((connec) => connec.close());
+            },
+            send: (data) => {
                 let dataCopy = Uint8Array.from(data); // Deep copy of the data
-                const socket = connection.socket;
-                connection.socket.inner = connection.socket.inner.then((c) => __awaiter(this, void 0, void 0, function* () {
+                socket.inner = socket.inner.then((c) => __awaiter(this, void 0, void 0, function* () {
                     while (dataCopy.length > 0) {
-                        if (socket.destroyed)
+                        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`
@@ -246,8 +264,17 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
                     }
                     return c;
                 }));
-            }
-        },
-        openOutSubstream: () => { throw new Error('Wrong connection type'); }
-    };
+            },
+            closeSend: () => {
+                socket.inner = socket.inner.then((c) => __awaiter(this, void 0, void 0, function* () {
+                    yield (c === null || c === void 0 ? void 0 : c.closeWrite());
+                    return c;
+                }));
+            },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
+    }
+    else {
+        throw new ConnectionError('Unrecognized multiaddr format');
+    }
 }

package/dist/mjs/index-nodejs.js

@@ -42,7 +42,7 @@ export function start(options) {
             return performance.now();
         },
         getRandomValues: (buffer) => {
-            if (buffer.length >= 65536)
+            if (buffer.length >= 1024 * 1024)
                 throw new Error('getRandomValues buffer too large');
             randomFillSync(buffer);
         },
@@ -58,7 +58,6 @@ export function start(options) {
  * @throws {@link ConnectionError} If the multiaddress couldn't be parsed or contains an invalid protocol.
  */
 function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
-    let connection;
     // Attempt to parse the multiaddress.
     // TODO: remove support for `/wss` in a long time (https://github.com/paritytech/smoldot/issues/1940)
     const wsParsed = config.address.match(/^\/(ip4|ip6|dns4|dns6|dns)\/(.*?)\/tcp\/(.*?)\/(ws|wss|tls\/ws)$/);
@@ -75,8 +74,33 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
             (proto + "://" + wsParsed[2] + ":" + wsParsed[3]);
         const socket = new WebSocket(url);
         socket.binaryType = 'arraybuffer';
+        const bufferedAmountCheck = { quenedUnreportedBytes: 0, nextTimeout: 10 };
+        const checkBufferedAmount = () => {
+            if (socket.readyState != 1)
+                return;
+            // Note that we might expect `bufferedAmount` to always be <= the sum of the lengths
+            // of all the data that has been sent, but that seems to not be the case. It is
+            // unclear whether this is intended or a bug, but is is likely that `bufferedAmount`
+            // also includes WebSocket headers. For this reason, we use `bufferedAmount` as a hint
+            // rather than a correct value.
+            const bufferedAmount = socket.bufferedAmount;
+            let wasSent = bufferedAmountCheck.quenedUnreportedBytes - bufferedAmount;
+            if (wasSent < 0)
+                wasSent = 0;
+            bufferedAmountCheck.quenedUnreportedBytes -= wasSent;
+            if (bufferedAmountCheck.quenedUnreportedBytes != 0) {
+                setTimeout(checkBufferedAmount, bufferedAmountCheck.nextTimeout);
+                bufferedAmountCheck.nextTimeout *= 2;
+                if (bufferedAmountCheck.nextTimeout > 500)
+                    bufferedAmountCheck.nextTimeout = 500;
+            }
+            // Note: it is important to call `onWritableBytes` at the very end, as it might
+            // trigger a call to `send`.
+            if (wasSent != 0)
+                config.onWritableBytes(wasSent);
+        };
         socket.onopen = () => {
-            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux' });
+            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux', initialWritableBytes: 1024 * 1024, writeClosable: false });
         };
         socket.onclose = (event) => {
             const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
@@ -96,7 +120,27 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
         socket.onmessage = (msg) => {
             config.onMessage(new Uint8Array(msg.data));
         };
-        connection = { ty: 'websocket', socket };
+        return {
+            reset: () => {
+                // We can't set these fields to null because the TypeScript definitions don't
+                // allow it, but we can set them to dummy values.
+                socket.onopen = () => { };
+                socket.onclose = () => { };
+                socket.onmessage = () => { };
+                socket.onerror = () => { };
+                socket.close();
+            },
+            send: (data) => {
+                socket.send(data);
+                if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
+                    bufferedAmountCheck.nextTimeout = 10;
+                    setTimeout(checkBufferedAmount, 10);
+                }
+                bufferedAmountCheck.quenedUnreportedBytes += data.length;
+            },
+            closeSend: () => { throw new Error('Wrong connection type'); },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
     }
     else if (tcpParsed != null) {
         // `net` module will be missing when we're not in NodeJS.
@@ -107,14 +151,18 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
             host: tcpParsed[2],
             port: parseInt(tcpParsed[3], 10),
         });
-        connection = { ty: 'tcp', socket };
-        connection.socket.setNoDelay();
-        connection.socket.on('connect', () => {
+        // Number of bytes queued using `socket.write` and where `write` has returned false.
+        const drainingBytes = { num: 0 };
+        socket.setNoDelay();
+        socket.on('connect', () => {
             if (socket.destroyed)
                 return;
-            config.onOpen({ type: 'single-stream', handshake: 'multistream-select-noise-yamux' });
+            config.onOpen({
+                type: 'single-stream', handshake: 'multistream-select-noise-yamux',
+                initialWritableBytes: socket.writableHighWaterMark, writeClosable: true
+            });
         });
-        connection.socket.on('close', (hasError) => {
+        socket.on('close', (hasError) => {
             if (socket.destroyed)
                 return;
             // NodeJS doesn't provide a reason why the closing happened, but only
@@ -122,43 +170,46 @@ function connect(config, forbidTcp, forbidWs, forbidNonLocalWs, forbidWss) {
             const message = hasError ? "Error" : "Closed gracefully";
             config.onConnectionReset(message);
         });
-        connection.socket.on('error', () => { });
-        connection.socket.on('data', (message) => {
+        socket.on('error', () => { });
+        socket.on('data', (message) => {
             if (socket.destroyed)
                 return;
             config.onMessage(new Uint8Array(message.buffer));
         });
+        socket.on('drain', () => {
+            // The bytes queued using `socket.write` and where `write` has returned false have now
+            // been sent. Notify the API that it can write more data.
+            if (socket.destroyed)
+                return;
+            const val = drainingBytes.num;
+            drainingBytes.num = 0;
+            config.onWritableBytes(val);
+        });
+        return {
+            reset: () => {
+                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;
+                }
+            },
+            closeSend: () => {
+                socket.end();
+            },
+            openOutSubstream: () => { throw new Error('Wrong connection type'); }
+        };
     }
     else {
         throw new ConnectionError('Unrecognized multiaddr format');
     }
-    return {
-        reset: () => {
-            if (connection.ty == 'websocket') {
-                // WebSocket
-                // We can't set these fields to null because the TypeScript definitions don't
-                // allow it, but we can set them to dummy values.
-                connection.socket.onopen = () => { };
-                connection.socket.onclose = () => { };
-                connection.socket.onmessage = () => { };
-                connection.socket.onerror = () => { };
-                connection.socket.close();
-            }
-            else {
-                // TCP
-                connection.socket.destroy();
-            }
-        },
-        send: (data) => {
-            if (connection.ty == 'websocket') {
-                // WebSocket
-                connection.socket.send(data);
-            }
-            else {
-                // TCP
-                connection.socket.write(data);
-            }
-        },
-        openOutSubstream: () => { throw new Error('Wrong connection type'); }
-    };
 }