smoldot 1.0.0 → 1.0.2

package/dist/cjs/instance/bindings-smoldot-light.d.ts

@@ -1,6 +1,12 @@
 import type { SmoldotWasmInstance } from './bindings.js';
 export interface Config {
     instance?: SmoldotWasmInstance;
+    /**
+     * Array used to store the buffers provided to the Rust code.
+     *
+     * When `buffer_size` or `buffer_index` are called, the buffer is found here.
+     */
+    bufferIndices: Array<Uint8Array>;
     /**
      * Returns the number of milliseconds since an arbitrary epoch.
      */
@@ -63,12 +69,33 @@ export interface Connection {
     /**
      * Queues data to be sent on the given connection.
      *
-     * The connection must currently be in the `Open` state.
+     * The connection and stream must currently be in the `Open` state.
+     *
+     * The number of bytes most never exceed the number of "writable bytes" of the stream.
+     * `onWritableBytes` can be used in order to notify that more writable bytes are available.
      *
      * The `streamId` must be provided if and only if the connection is of type "multi-stream".
      * It indicates which substream to send the data on.
+     *
+     * Must not be called after `closeSend` has been called.
      */
     send(data: Uint8Array, streamId?: number): void;
+    /**
+     * Closes the writing side of the given stream of the given connection.
+     *
+     * Never called for connection types where this isn't possible to implement (i.e. WebSocket
+     * and WebRTC at the moment).
+     *
+     * The connection and stream must currently be in the `Open` state.
+     *
+     * Implicitly sets the "writable bytes" of the stream to zero.
+     *
+     * The `streamId` must be provided if and only if the connection is of type "multi-stream".
+     * It indicates which substream to send the data on.
+     *
+     * Must only be called once per stream.
+     */
+    closeSend(streamId?: number): void;
     /**
      * Start opening an additional outbound substream on the given connection.
      *
@@ -104,6 +131,8 @@ export interface ConnectionConfig {
     onOpen: (info: {
         type: 'single-stream';
         handshake: 'multistream-select-noise-yamux';
+        initialWritableBytes: number;
+        writeClosable: boolean;
     } | {
         type: 'multi-stream';
         handshake: 'webrtc';
@@ -121,7 +150,7 @@ export interface ConnectionConfig {
      *
      * This function must only be called for connections of type "multi-stream".
      */
-    onStreamOpened: (streamId: number, direction: 'inbound' | 'outbound') => void;
+    onStreamOpened: (streamId: number, direction: 'inbound' | 'outbound', initialWritableBytes: number) => void;
     /**
      * Callback called when a stream transitions to the `Reset` state.
      *
@@ -130,6 +159,17 @@ export interface ConnectionConfig {
      * This function must only be called for connections of type "multi-stream".
      */
     onStreamReset: (streamId: number) => void;
+    /**
+     * Callback called when more data can be written on the stream.
+     *
+     * Can only happen while the connection is in the `Open` state.
+     *
+     * This callback must not be called after `closeSend` has been called.
+     *
+     * The `streamId` parameter must be provided if and only if the connection is of type
+     * "multi-stream".
+     */
+    onWritableBytes: (numExtra: number, streamId?: number) => void;
     /**
      * Callback called when a message sent by the remote has been received.
      *

package/dist/cjs/instance/bindings-smoldot-light.js

@@ -55,6 +55,16 @@ function default_1(config) {
             const message = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), ptr, len);
             config.onPanic(message);
         },
+        buffer_size: (bufferIndex) => {
+            const buf = config.bufferIndices[bufferIndex];
+            return buf.byteLength;
+        },
+        buffer_copy: (bufferIndex, targetPtr) => {
+            const instance = config.instance;
+            targetPtr = targetPtr >>> 0;
+            const buf = config.bufferIndices[bufferIndex];
+            new Uint8Array(instance.exports.memory.buffer).set(buf, targetPtr);
+        },
         // Used by the Rust side to notify that a JSON-RPC response or subscription notification
         // is available in the queue of JSON-RPC responses.
         json_rpc_responses_non_empty: (chainId) => {
@@ -97,7 +107,7 @@ function default_1(config) {
             // In browsers, `setTimeout` works as expected when `ms` equals 0. However, NodeJS
             // requires a minimum of 1 millisecond (if `0` is passed, it is automatically replaced
             // with `1`) and wants you to use `setImmediate` instead.
-            if (ms == 0 && typeof setImmediate === "function") {
+            if (ms < 1 && typeof setImmediate === "function") {
                 setImmediate(() => {
                     if (killedTracked.killed)
                         return;
@@ -120,11 +130,11 @@ function default_1(config) {
         },
         // Must create a new connection object. This implementation stores the created object in
         // `connections`.
-        connection_new: (connectionId, addrPtr, addrLen, errorPtrPtr) => {
+        connection_new: (connectionId, addrPtr, addrLen, errorBufferIndexPtr) => {
             const instance = config.instance;
             addrPtr >>>= 0;
             addrLen >>>= 0;
-            errorPtrPtr >>>= 0;
+            errorBufferIndexPtr >>>= 0;
             if (!!connections[connectionId]) {
                 throw new Error("internal error: connection already allocated");
             }
@@ -140,17 +150,17 @@ function default_1(config) {
                         try {
                             switch (info.type) {
                                 case 'single-stream': {
-                                    instance.exports.connection_open_single_stream(connectionId, 0);
+                                    instance.exports.connection_open_single_stream(connectionId, 0, info.initialWritableBytes, info.writeClosable ? 1 : 0);
                                     break;
                                 }
                                 case 'multi-stream': {
-                                    const bufferLen = 1 + info.localTlsCertificateMultihash.length + info.remoteTlsCertificateMultihash.length;
-                                    const ptr = instance.exports.alloc(bufferLen) >>> 0;
-                                    const mem = new Uint8Array(instance.exports.memory.buffer);
-                                    buffer.writeUInt8(mem, ptr, 0);
-                                    mem.set(info.localTlsCertificateMultihash, ptr + 1);
-                                    mem.set(info.remoteTlsCertificateMultihash, ptr + 1 + info.localTlsCertificateMultihash.length);
-                                    instance.exports.connection_open_multi_stream(connectionId, ptr, bufferLen);
+                                    const handshakeTy = new Uint8Array(1 + info.localTlsCertificateMultihash.length + info.remoteTlsCertificateMultihash.length);
+                                    buffer.writeUInt8(handshakeTy, 0, 0);
+                                    handshakeTy.set(info.localTlsCertificateMultihash, 1);
+                                    handshakeTy.set(info.remoteTlsCertificateMultihash, 1 + info.localTlsCertificateMultihash.length);
+                                    config.bufferIndices[0] = handshakeTy;
+                                    instance.exports.connection_open_multi_stream(connectionId, 0);
+                                    delete config.bufferIndices[0];
                                     break;
                                 }
                             }
@@ -161,10 +171,17 @@ function default_1(config) {
                         if (killedTracked.killed)
                             return;
                         try {
-                            const encoded = new TextEncoder().encode(message);
-                            const ptr = instance.exports.alloc(encoded.length) >>> 0;
-                            new Uint8Array(instance.exports.memory.buffer).set(encoded, ptr);
-                            instance.exports.connection_reset(connectionId, ptr, encoded.length);
+                            config.bufferIndices[0] = new TextEncoder().encode(message);
+                            instance.exports.connection_reset(connectionId, 0);
+                            delete config.bufferIndices[0];
+                        }
+                        catch (_error) { }
+                    },
+                    onWritableBytes: (numExtra, streamId) => {
+                        if (killedTracked.killed)
+                            return;
+                        try {
+                            instance.exports.stream_writable_bytes(connectionId, streamId || 0, numExtra);
                         }
                         catch (_error) { }
                     },
@@ -172,17 +189,17 @@ function default_1(config) {
                         if (killedTracked.killed)
                             return;
                         try {
-                            const ptr = instance.exports.alloc(message.length) >>> 0;
-                            new Uint8Array(instance.exports.memory.buffer).set(message, ptr);
-                            instance.exports.stream_message(connectionId, streamId || 0, ptr, message.length);
+                            config.bufferIndices[0] = message;
+                            instance.exports.stream_message(connectionId, streamId || 0, 0);
+                            delete config.bufferIndices[0];
                         }
                         catch (_error) { }
                     },
-                    onStreamOpened: (streamId, direction) => {
+                    onStreamOpened: (streamId, direction, initialWritableBytes) => {
                         if (killedTracked.killed)
                             return;
                         try {
-                            instance.exports.connection_stream_opened(connectionId, streamId, direction === 'outbound' ? 1 : 0);
+                            instance.exports.connection_stream_opened(connectionId, streamId, direction === 'outbound' ? 1 : 0, initialWritableBytes);
                         }
                         catch (_error) { }
                     },
@@ -205,12 +222,9 @@ function default_1(config) {
                     errorStr = error.toString();
                 }
                 const mem = new Uint8Array(instance.exports.memory.buffer);
-                const encoded = new TextEncoder().encode(errorStr);
-                const ptr = instance.exports.alloc(encoded.length) >>> 0;
-                mem.set(encoded, ptr);
-                buffer.writeUInt32LE(mem, errorPtrPtr, ptr);
-                buffer.writeUInt32LE(mem, errorPtrPtr + 4, encoded.length);
-                buffer.writeUInt8(mem, errorPtrPtr + 8, isBadAddress ? 1 : 0);
+                config.bufferIndices[0] = new TextEncoder().encode(errorStr);
+                buffer.writeUInt32LE(mem, errorBufferIndexPtr, 0);
+                buffer.writeUInt8(mem, errorBufferIndexPtr + 4, isBadAddress ? 1 : 0);
                 return 1;
             }
         },
@@ -244,6 +258,12 @@ function default_1(config) {
             const connection = connections[connectionId];
             connection.send(data, streamId); // TODO: docs says the streamId is provided only for multi-stream connections, but here it's always provided
         },
+        stream_send_close: (connectionId, streamId) => {
+            if (killedTracked.killed)
+                return;
+            const connection = connections[connectionId];
+            connection.closeSend(streamId); // TODO: docs says the streamId is provided only for multi-stream connections, but here it's always provided
+        },
         current_task_entered: (ptr, len) => {
             if (killedTracked.killed)
                 return;

package/dist/cjs/instance/bindings.d.ts

@@ -9,21 +9,21 @@ export interface SmoldotWasmExports extends WebAssembly.Exports {
     init: (maxLogLevel: number, enableCurrentTask: number, cpuRateLimit: number, periodicallyYield: number) => void;
     set_periodically_yield: (periodicallyYield: number) => void;
     start_shutdown: () => void;
-    alloc: (len: number) => number;
-    add_chain: (chainSpecPointer: number, chainSpecLen: number, databaseContentPointer: number, databaseContentLen: number, jsonRpcRunning: number, potentialRelayChainsPtr: number, potentialRelayChainsLen: number) => number;
+    add_chain: (chainSpecBufferIndex: number, databaseContentBufferIndex: number, jsonRpcRunning: number, potentialRelayChainsBufferIndex: number) => number;
     remove_chain: (chainId: number) => void;
     chain_is_ok: (chainId: number) => number;
     chain_error_len: (chainId: number) => number;
     chain_error_ptr: (chainId: number) => number;
-    json_rpc_send: (textPtr: number, textLen: number, chainId: number) => number;
+    json_rpc_send: (textBufferIndex: number, chainId: number) => number;
     json_rpc_responses_peek: (chainId: number) => number;
     json_rpc_responses_pop: (chainId: number) => void;
     timer_finished: (timerId: number) => void;
-    connection_open_single_stream: (connectionId: number, handshakeTy: number) => void;
-    connection_open_multi_stream: (connectionId: number, handshakeTyPtr: number, handshakeTyLen: number) => void;
-    stream_message: (connectionId: number, streamId: number, ptr: number, len: number) => void;
-    connection_stream_opened: (connectionId: number, streamId: number, outbound: number) => void;
-    connection_reset: (connectionId: number, ptr: number, len: number) => void;
+    connection_open_single_stream: (connectionId: number, handshakeTy: number, initialWritableBytes: number, writeClosable: number) => void;
+    connection_open_multi_stream: (connectionId: number, handshakeTyBufferIndex: number) => void;
+    stream_writable_bytes: (connectionId: number, streamId: number, numBytes: number) => void;
+    stream_message: (connectionId: number, streamId: number, bufferIndex: number) => void;
+    connection_stream_opened: (connectionId: number, streamId: number, outbound: number, initialWritableBytes: number) => void;
+    connection_reset: (connectionId: number, bufferIndex: number) => void;
     stream_reset: (connectionId: number, streamId: number) => void;
 }
 export interface SmoldotWasmInstance extends WebAssembly.Instance {

package/dist/cjs/instance/instance.js

@@ -104,7 +104,7 @@ function start(configMessage, platformBindings) {
         cpuRateLimit: configMessage.cpuRateLimit,
     };
     state = {
-        initialized: false, promise: instance.startInstance(config, platformBindings).then((instance) => {
+        initialized: false, promise: instance.startInstance(config, platformBindings).then(([instance, bufferIndices]) => {
             // `config.cpuRateLimit` is a floating point that should be between 0 and 1, while the value
             // to pass as parameter must be between `0` and `2^32-1`.
             // The few lines of code below should handle all possible values of `number`, including
@@ -127,8 +127,8 @@ function start(configMessage, platformBindings) {
                 }
             });
             instance.exports.init(configMessage.maxLogLevel, configMessage.enableCurrentTask ? 1 : 0, cpuRateLimit, periodicallyYield ? 1 : 0);
-            state = { initialized: true, instance, unregisterCallback };
-            return instance;
+            state = { initialized: true, instance, bufferIndices, unregisterCallback };
+            return [instance, bufferIndices];
         })
     };
     function queueOperation(operation) {
@@ -138,11 +138,11 @@ function start(configMessage, platformBindings) {
             if (!state.initialized) {
                 // A message has been received while the Wasm VM is still initializing. Queue it for when
                 // initialization is over.
-                return state.promise.then((instance) => operation(instance));
+                return state.promise.then(([instance, bufferIndices]) => operation(instance, bufferIndices));
             }
             else {
                 // Everything is already initialized. Process the message synchronously.
-                return operation(state.instance);
+                return operation(state.instance, state.bufferIndices);
             }
         });
     }
@@ -157,10 +157,8 @@ function start(configMessage, platformBindings) {
                 throw crashError.error;
             let retVal;
             try {
-                const encoded = new TextEncoder().encode(request);
-                const ptr = state.instance.exports.alloc(encoded.length) >>> 0;
-                new Uint8Array(state.instance.exports.memory.buffer).set(encoded, ptr);
-                retVal = state.instance.exports.json_rpc_send(ptr, encoded.length, chainId) >>> 0;
+                state.bufferIndices[0] = new TextEncoder().encode(request);
+                retVal = state.instance.exports.json_rpc_send(0, chainId) >>> 0;
             }
             catch (_error) {
                 console.assert(crashError.error);
@@ -207,29 +205,25 @@ function start(configMessage, platformBindings) {
             }
         }),
         addChain: (chainSpec, databaseContent, potentialRelayChains, disableJsonRpc) => {
-            return queueOperation((instance) => {
+            return queueOperation((instance, bufferIndices) => {
                 if (crashError.error)
                     throw crashError.error;
                 try {
-                    // Write the chain specification into memory.
-                    const chainSpecEncoded = new TextEncoder().encode(chainSpec);
-                    const chainSpecPtr = instance.exports.alloc(chainSpecEncoded.length) >>> 0;
-                    new Uint8Array(instance.exports.memory.buffer).set(chainSpecEncoded, chainSpecPtr);
-                    // Write the database content into memory.
-                    const databaseContentEncoded = new TextEncoder().encode(databaseContent);
-                    const databaseContentPtr = instance.exports.alloc(databaseContentEncoded.length) >>> 0;
-                    new Uint8Array(instance.exports.memory.buffer).set(databaseContentEncoded, databaseContentPtr);
-                    // Write the potential relay chains into memory.
-                    const potentialRelayChainsLen = potentialRelayChains.length;
-                    const potentialRelayChainsPtr = instance.exports.alloc(potentialRelayChainsLen * 4) >>> 0;
-                    for (let idx = 0; idx < potentialRelayChains.length; ++idx) {
-                        buffer.writeUInt32LE(new Uint8Array(instance.exports.memory.buffer), potentialRelayChainsPtr + idx * 4, potentialRelayChains[idx]);
-                    }
                     // `add_chain` unconditionally allocates a chain id. If an error occurs, however, this chain
                     // id will refer to an *erroneous* chain. `chain_is_ok` is used below to determine whether it
                     // has succeeeded or not.
                     // Note that `add_chain` properly de-allocates buffers even if it failed.
-                    const chainId = instance.exports.add_chain(chainSpecPtr, chainSpecEncoded.length, databaseContentPtr, databaseContentEncoded.length, disableJsonRpc ? 0 : 1, potentialRelayChainsPtr, potentialRelayChainsLen);
+                    bufferIndices[0] = new TextEncoder().encode(chainSpec);
+                    bufferIndices[1] = new TextEncoder().encode(databaseContent);
+                    const potentialRelayChainsEncoded = new Uint8Array(potentialRelayChains.length * 4);
+                    for (let idx = 0; idx < potentialRelayChains.length; ++idx) {
+                        buffer.writeUInt32LE(potentialRelayChainsEncoded, idx * 4, potentialRelayChains[idx]);
+                    }
+                    bufferIndices[2] = potentialRelayChainsEncoded;
+                    const chainId = instance.exports.add_chain(0, 1, disableJsonRpc ? 0 : 1, 2);
+                    delete bufferIndices[0];
+                    delete bufferIndices[1];
+                    delete bufferIndices[2];
                     if (instance.exports.chain_is_ok(chainId) != 0) {
                         console.assert(!chains.has(chainId));
                         chains.set(chainId, {

package/dist/cjs/instance/raw-instance.d.ts

@@ -62,4 +62,4 @@ export interface PlatformBindings {
      */
     connect(config: ConnectionConfig): Connection;
 }
-export declare function startInstance(config: Config, platformBindings: PlatformBindings): Promise<SmoldotWasmInstance>;
+export declare function startInstance(config: Config, platformBindings: PlatformBindings): Promise<[SmoldotWasmInstance, Array<Uint8Array>]>;

package/dist/cjs/instance/raw-instance.js

@@ -36,8 +36,9 @@ function startInstance(config, platformBindings) {
         // cross-platform cross-bundler approach.
         const wasmBytecode = yield platformBindings.trustedBase64DecodeAndZlibInflate(wasm_js_1.default);
         let killAll;
+        const bufferIndices = new Array;
         // Used to bind with the smoldot-light bindings. See the `bindings-smoldot-light.js` file.
-        const smoldotJsConfig = Object.assign({ performanceNow: platformBindings.performanceNow, connect: platformBindings.connect, onPanic: (message) => {
+        const smoldotJsConfig = Object.assign({ bufferIndices, performanceNow: platformBindings.performanceNow, connect: platformBindings.connect, onPanic: (message) => {
                 killAll();
                 config.onWasmPanic(message);
                 throw new Error();
@@ -66,7 +67,7 @@ function startInstance(config, platformBindings) {
         const instance = result.instance;
         smoldotJsConfig.instance = instance;
         wasiConfig.instance = instance;
-        return instance;
+        return [instance, bufferIndices];
     });
 }
 exports.startInstance = startInstance;

package/dist/mjs/index-browser.js

@@ -40,6 +40,8 @@ export function start(options) {
             return Promise.resolve(inflate(classicDecode(input)));
         },
         registerShouldPeriodicallyYield: (callback) => {
+            if (typeof document === 'undefined') // We might be in a web worker.
+                return [false, () => { }];
             const wrappedCallback = () => callback(document.visibilityState === 'visible');
             document.addEventListener('visibilitychange', wrappedCallback);
             return [document.visibilityState === 'visible', () => { document.removeEventListener('visibilitychange', wrappedCallback); }];
@@ -68,9 +70,8 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
     // 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)$/);
-    const webRTCParsed = config.address.match(/^\/(ip4|ip6)\/(.*?)\/udp\/(.*?)\/webrtc\/certhash\/(.*?)$/);
+    const webRTCParsed = config.address.match(/^\/(ip4|ip6)\/(.*?)\/udp\/(.*?)\/webrtc-direct\/certhash\/(.*?)$/);
     if (wsParsed != null) {
-        let connection;
         const proto = (wsParsed[4] == 'ws') ? 'ws' : 'wss';
         if ((proto == 'ws' && forbidWs) ||
             (proto == 'ws' && wsParsed[2] != 'localhost' && wsParsed[2] != '127.0.0.1' && forbidNonLocalWs) ||
@@ -80,10 +81,36 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
         const url = (wsParsed[1] == 'ip6') ?
             (proto + "://[" + wsParsed[2] + "]:" + wsParsed[3]) :
             (proto + "://" + wsParsed[2] + ":" + wsParsed[3]);
-        connection = new WebSocket(url);
+        const connection = new WebSocket(url);
         connection.binaryType = 'arraybuffer';
+        const bufferedAmountCheck = { quenedUnreportedBytes: 0, nextTimeout: 10 };
+        const checkBufferedAmount = () => {
+            if (connection.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 = connection.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.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,
+            });
         };
         connection.onclose = (event) => {
             const message = "Error code " + event.code + (!!event.reason ? (": " + event.reason) : "");
@@ -102,7 +129,13 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
             },
             send: (data) => {
                 connection.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'); }
         };
     }
@@ -152,16 +185,18 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
             pc.onnegotiationneeded = null;
             pc.ondatachannel = null;
             for (const channel of Array.from(dataChannels.values())) {
-                channel.onopen = null;
-                channel.onerror = null;
-                channel.onclose = null;
-                channel.onmessage = null;
+                channel.channel.onopen = null;
+                channel.channel.onerror = null;
+                channel.channel.onclose = null;
+                channel.channel.onbufferedamountlow = null;
+                channel.channel.onmessage = null;
             }
             dataChannels.clear();
             if (handshakeDataChannel) {
                 handshakeDataChannel.onopen = null;
                 handshakeDataChannel.onerror = null;
                 handshakeDataChannel.onclose = null;
+                handshakeDataChannel.onbufferedamountlow = null;
                 handshakeDataChannel.onmessage = null;
             }
             handshakeDataChannel = undefined;
@@ -190,7 +225,7 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
                 }
                 else {
                     console.assert(direction !== 'outbound' || !handshakeDataChannel, "handshakeDataChannel still defined");
-                    config.onStreamOpened(dataChannelId, direction);
+                    config.onStreamOpened(dataChannelId, direction, 65536);
                 }
             };
             dataChannel.onerror = dataChannel.onclose = (_error) => {
@@ -212,6 +247,7 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
                     handshakeDataChannel.onopen = null;
                     handshakeDataChannel.onerror = null;
                     handshakeDataChannel.onclose = null;
+                    handshakeDataChannel.onbufferedamountlow = null;
                     handshakeDataChannel.onmessage = null;
                     handshakeDataChannel = undefined;
                 }
@@ -228,12 +264,18 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
                     config.onStreamReset(dataChannelId);
                 }
             };
+            dataChannel.onbufferedamountlow = () => {
+                const channel = dataChannels.get(dataChannelId);
+                const val = channel.bufferedBytes;
+                channel.bufferedBytes = 0;
+                config.onWritableBytes(val, dataChannelId);
+            };
             dataChannel.onmessage = (m) => {
                 // The `data` field is an `ArrayBuffer`.
                 config.onMessage(new Uint8Array(m.data), dataChannelId);
             };
             if (direction !== 'first-outbound')
-                dataChannels.set(dataChannelId, dataChannel);
+                dataChannels.set(dataChannelId, { channel: dataChannel, bufferedBytes: 0 });
             else
                 handshakeDataChannel = dataChannel;
         };
@@ -375,7 +417,8 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
                     // (UDP or TCP)
                     "a=sctp-port:5000" + "\n" +
                     // The maximum SCTP user message size (in bytes) (RFC8841)
-                    "a=max-message-size:16384" + "\n" + // TODO: should this be part of the spec?
+                    // Setting this field is part of the libp2p spec.
+                    "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";
@@ -404,17 +447,21 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
                 }
                 else {
                     const channel = dataChannels.get(streamId);
-                    channel.onopen = null;
-                    channel.onerror = null;
-                    channel.onclose = null;
-                    channel.onmessage = null;
-                    channel.close();
+                    channel.channel.onopen = null;
+                    channel.channel.onerror = null;
+                    channel.channel.onclose = null;
+                    channel.channel.onbufferedamountlow = null;
+                    channel.channel.onmessage = null;
+                    channel.channel.close();
                     dataChannels.delete(streamId);
                 }
             },
             send: (data, streamId) => {
-                dataChannels.get(streamId).send(data);
+                const channel = dataChannels.get(streamId);
+                channel.channel.send(data);
+                channel.bufferedBytes += data.length;
             },
+            closeSend: () => { throw new Error('Wrong connection type'); },
             openOutSubstream: () => {
                 // `openOutSubstream` can only be called after we have called `config.onOpen`, therefore
                 // `pc` is guaranteed to be non-null.
@@ -426,8 +473,8 @@ function connect(config, forbidWs, forbidNonLocalWs, forbidWss, forbidWebRTC) {
                         // We need to check again if `handshakeDataChannel` is still defined, as the
                         // connection might have been closed.
                         if (handshakeDataChannel) {
-                            config.onStreamOpened(handshakeDataChannel.id, 'outbound');
-                            dataChannels.set(handshakeDataChannel.id, handshakeDataChannel);
+                            config.onStreamOpened(handshakeDataChannel.id, 'outbound', 1024 * 1024);
+                            dataChannels.set(handshakeDataChannel.id, { channel: handshakeDataChannel, bufferedBytes: 0 });
                             handshakeDataChannel = undefined;
                         }
                     }))();