smoldot 0.7.13 → 1.0.1

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

@@ -63,12 +63,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 +125,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 +144,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 +153,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/mjs/instance/bindings-smoldot-light.js

@@ -93,7 +93,7 @@ export default function (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;
@@ -136,7 +136,7 @@ export default function (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': {
@@ -164,6 +164,14 @@ export default function (config) {
                         }
                         catch (_error) { }
                     },
+                    onWritableBytes: (numExtra, streamId) => {
+                        if (killedTracked.killed)
+                            return;
+                        try {
+                            instance.exports.stream_writable_bytes(connectionId, streamId || 0, numExtra);
+                        }
+                        catch (_error) { }
+                    },
                     onMessage: (message, streamId) => {
                         if (killedTracked.killed)
                             return;
@@ -174,11 +182,11 @@ export default function (config) {
                         }
                         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) { }
                     },
@@ -240,6 +248,12 @@ export default function (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/mjs/instance/bindings.d.ts

@@ -19,10 +19,11 @@ export interface SmoldotWasmExports extends WebAssembly.Exports {
     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_single_stream: (connectionId: number, handshakeTy: number, initialWritableBytes: number, writeClosable: number) => void;
     connection_open_multi_stream: (connectionId: number, handshakeTyPtr: number, handshakeTyLen: number) => void;
+    stream_writable_bytes: (connectionId: number, streamId: number, numBytes: number) => void;
     stream_message: (connectionId: number, streamId: number, ptr: number, len: number) => void;
-    connection_stream_opened: (connectionId: number, streamId: number, outbound: number) => void;
+    connection_stream_opened: (connectionId: number, streamId: number, outbound: number, initialWritableBytes: number) => void;
     connection_reset: (connectionId: number, ptr: number, len: number) => void;
     stream_reset: (connectionId: number, streamId: number) => void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoldot",
-  "version": "0.7.13",
+  "version": "1.0.1",
   "description": "Light client that connects to Polkadot and Substrate-based blockchains",
   "author": "Parity Technologies <admin@parity.io>",
   "license": "GPL-3.0-or-later WITH Classpath-exception-2.0",
@@ -48,6 +48,6 @@
     "dtslint": "^4.0.6",
     "rimraf": "^4.1.2",
     "typedoc": "^0.23.15",
-    "typescript": "^4.5.4"
+    "typescript": "^5.0.2"
   }
 }