starknet 10.6.5 → 10.6.7

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [10.6.7](https://github.com/starknet-io/starknet.js/compare/v10.6.6...v10.6.7) (2026-08-06)
+
+### Bug Fixes
+
+- **ws:** settle in-flight requests when the connection drops ([8eae9c9](https://github.com/starknet-io/starknet.js/commit/8eae9c9457befe6e0c3f4fd30a56025fe5455fd8))
+
+## [10.6.6](https://github.com/starknet-io/starknet.js/compare/v10.6.5...v10.6.6) (2026-08-05)
+
+### Bug Fixes
+
+- **ws:** reject queued requests instead of hanging ([82ced97](https://github.com/starknet-io/starknet.js/commit/82ced97dc6dc409131bc5650db076efedf467101))
+
 ## [10.6.5](https://github.com/starknet-io/starknet.js/compare/v10.6.4...v10.6.5) (2026-08-05)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -5151,6 +5151,8 @@ declare class WebSocketChannel {
     private reconnectTimeoutId;
     private reconnectStabilityTimeoutId;
     private requestQueue;
+    /** Abort handles for the requests currently on the wire, one per pending `sendReceive`. */
+    private inFlight;
     private events;
     private openListener;
     private closeListener;
@@ -5243,6 +5245,25 @@ declare class WebSocketChannel {
      */
     reconnect(): void;
     private _processRequestQueue;
+    /**
+     * Reject every request still waiting in the queue.
+     *
+     * A queued request carries no timeout of its own: the `requestTimeout` timer is only
+     * armed once the request is actually put on the wire. So once the channel reaches a state
+     * where the queue can never be flushed — reconnection gave up, or the user closed the
+     * connection — the queued promises would stay pending forever, and no caller-side timeout
+     * could rescue them. Settling them here is the only way out.
+     */
+    private _rejectRequestQueue;
+    /**
+     * Settle every request already on the wire.
+     *
+     * The counterpart of `_rejectRequestQueue`, for requests past the queue. Their only other
+     * exit is the `requestTimeout` timer, so without this the caller waits the whole timeout —
+     * 60s by default — for a reply that can no longer arrive, and that pending timer keeps the
+     * Node event loop alive for just as long.
+     */
+    private _rejectInFlight;
     private _restoreSubscriptions;
     /**
      * Reset the reconnection attempt counter, but only once the current connection has

package/dist/index.global.js

@@ -12618,6 +12618,8 @@ ${indent}}` : "}";
     // resetting the reconnection attempt counter.
     reconnectStabilityTimeoutId = null;
     requestQueue = [];
+    /** Abort handles for the requests currently on the wire, one per pending `sendReceive`. */
+    inFlight = /* @__PURE__ */ new Set();
     events = new EventEmitter();
     openListener = (ev) => {
       this.scheduleReconnectAttemptsReset();
@@ -12701,12 +12703,19 @@ ${indent}}` : "}";
         });
       }
       const sendId = this.send(method, params);
+      const socket = this.websocket;
       return new Promise((resolve, reject) => {
-        let timeoutId;
-        if (!this.websocket || this.websocket.readyState !== ws_default.OPEN) {
+        if (socket.readyState !== ws_default.OPEN) {
           reject(new WebSocketNotConnectedError("WebSocket not available or not connected."));
           return;
         }
+        let timeoutId;
+        const settle = () => {
+          clearTimeout(timeoutId);
+          socket.removeEventListener("message", messageHandler);
+          socket.removeEventListener("error", errorHandler);
+          this.inFlight.delete(abort);
+        };
         const messageHandler = (event) => {
           if (!isString(event.data)) {
             logger.warn("WebSocket received non-string message data:", event.data);
@@ -12721,34 +12730,35 @@ ${indent}}` : "}";
             );
             return;
           }
-          if (message.id === sendId) {
-            clearTimeout(timeoutId);
-            this.websocket.removeEventListener("message", messageHandler);
-            this.websocket.removeEventListener("error", errorHandler);
-            if ("result" in message) {
-              resolve(message.result);
-            } else {
-              reject(
-                new Error(`Error on ${method} (id: ${sendId}): ${JSON.stringify(message.error)}`)
-              );
-            }
+          if (message.id !== sendId) return;
+          settle();
+          if ("result" in message) {
+            resolve(message.result);
+          } else {
+            reject(new Error(`Error on ${method} (id: ${sendId}): ${JSON.stringify(message.error)}`));
           }
         };
         const errorHandler = (event) => {
-          clearTimeout(timeoutId);
-          this.websocket.removeEventListener("message", messageHandler);
-          this.websocket.removeEventListener("error", errorHandler);
+          settle();
           reject(
             new Error(
               `WebSocket error during ${method} (id: ${sendId}): ${event.type || "Unknown error"}`
             )
           );
         };
-        this.websocket.addEventListener("message", messageHandler);
-        this.websocket.addEventListener("error", errorHandler);
+        const abort = (reason) => {
+          settle();
+          reject(
+            new WebSocketNotConnectedError(
+              `Request ${method} (id: ${sendId}) went unanswered: ${reason}`
+            )
+          );
+        };
+        socket.addEventListener("message", messageHandler);
+        socket.addEventListener("error", errorHandler);
+        this.inFlight.add(abort);
         timeoutId = setTimeout(() => {
-          this.websocket.removeEventListener("message", messageHandler);
-          this.websocket.removeEventListener("error", errorHandler);
+          settle();
           reject(
             new TimeoutError(
               `Request ${method} (id: ${sendId}) timed out after ${this.requestTimeout}ms`
@@ -12803,6 +12813,9 @@ ${indent}}` : "}";
         this.reconnectStabilityTimeoutId = null;
       }
       this.userInitiatedClose = true;
+      this.isReconnecting = false;
+      this._rejectRequestQueue("the connection was closed by the user");
+      this._rejectInFlight("the connection was closed by the user");
       this.websocket.close(code, reason);
     }
     /**
@@ -12876,6 +12889,39 @@ ${indent}}` : "}";
         this.sendReceive(method, params).then(resolve).catch(reject);
       });
     }
+    /**
+     * Reject every request still waiting in the queue.
+     *
+     * A queued request carries no timeout of its own: the `requestTimeout` timer is only
+     * armed once the request is actually put on the wire. So once the channel reaches a state
+     * where the queue can never be flushed — reconnection gave up, or the user closed the
+     * connection — the queued promises would stay pending forever, and no caller-side timeout
+     * could rescue them. Settling them here is the only way out.
+     */
+    _rejectRequestQueue(reason) {
+      if (this.requestQueue.length === 0) return;
+      const pending = this.requestQueue;
+      this.requestQueue = [];
+      logger.info(`WebSocket: Rejecting ${pending.length} queued request(s). Reason: ${reason}.`);
+      pending.forEach(({ method, reject }) => {
+        reject(new WebSocketNotConnectedError(`Request ${method} was never sent: ${reason}`));
+      });
+    }
+    /**
+     * Settle every request already on the wire.
+     *
+     * The counterpart of `_rejectRequestQueue`, for requests past the queue. Their only other
+     * exit is the `requestTimeout` timer, so without this the caller waits the whole timeout —
+     * 60s by default — for a reply that can no longer arrive, and that pending timer keeps the
+     * Node event loop alive for just as long.
+     */
+    _rejectInFlight(reason) {
+      if (this.inFlight.size === 0) return;
+      const pending = Array.from(this.inFlight);
+      this.inFlight.clear();
+      logger.info(`WebSocket: Rejecting ${pending.length} in-flight request(s). Reason: ${reason}.`);
+      pending.forEach((abort) => abort(reason));
+    }
     async _restoreSubscriptions() {
       const oldSubscriptions = Array.from(this.activeSubscriptions.values());
       this.activeSubscriptions.clear();
@@ -12919,6 +12965,9 @@ ${indent}}` : "}";
         if (this.reconnectAttempts >= this.reconnectOptions.retries) {
           logger.error("WebSocket: Maximum reconnection retries reached. Giving up.");
           this.isReconnecting = false;
+          this._rejectRequestQueue(
+            `reconnection gave up after ${this.reconnectOptions.retries} attempts`
+          );
           return;
         }
         this.reconnectAttempts += 1;
@@ -12926,18 +12975,24 @@ ${indent}}` : "}";
           `WebSocket: Connection lost. Attempting to reconnect... (${this.reconnectAttempts}/${this.reconnectOptions.retries})`
         );
         this.reconnect();
+        let attemptSettled = false;
+        const scheduleRetry = () => {
+          if (attemptSettled || !this.isReconnecting) return;
+          attemptSettled = true;
+          const delay = this.reconnectOptions.exponential ? this.reconnectOptions.delay * 2 ** (this.reconnectAttempts - 1) : this.reconnectOptions.delay;
+          logger.info(`WebSocket: Reconnect attempt failed. Retrying in ${delay}ms.`);
+          this.reconnectTimeoutId = setTimeout(tryReconnect, delay);
+        };
         this.websocket.onopen = async () => {
           logger.info("WebSocket: Reconnection successful.");
+          attemptSettled = true;
           this.isReconnecting = false;
           await this._restoreSubscriptions();
           this._processRequestQueue();
           this.events.emit("open", new Event("open"));
         };
-        this.websocket.onerror = () => {
-          const delay = this.reconnectOptions.exponential ? this.reconnectOptions.delay * 2 ** (this.reconnectAttempts - 1) : this.reconnectOptions.delay;
-          logger.info(`WebSocket: Reconnect attempt failed. Retrying in ${delay}ms.`);
-          this.reconnectTimeoutId = setTimeout(tryReconnect, delay);
-        };
+        this.websocket.onerror = scheduleRetry;
+        this.websocket.addEventListener("close", scheduleRetry);
       };
       tryReconnect();
     }
@@ -12946,6 +13001,7 @@ ${indent}}` : "}";
       this.websocket.removeEventListener("close", this.closeListener);
       this.websocket.removeEventListener("message", this.messageListener);
       this.websocket.removeEventListener("error", this.errorListener);
+      this._rejectInFlight("the connection was closed");
       this.events.emit("close", ev);
       if (!this.userInitiatedClose) {
         this._startReconnect();