starknet 10.6.4 → 10.6.6

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [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
+
+- **ws:** guard malformed frames and honour request id 0 ([cf1f4e2](https://github.com/starknet-io/starknet.js/commit/cf1f4e2c1f58eba5f1d63628959fe2ee47387025))
+
 ## [10.6.4](https://github.com/starknet-io/starknet.js/compare/v10.6.3...v10.6.4) (2026-08-04)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -5243,6 +5243,16 @@ 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;
     private _restoreSubscriptions;
     /**
      * Reset the reconnection attempt counter, but only once the current connection has

package/dist/index.global.js

@@ -12654,7 +12654,7 @@ ${indent}}` : "}";
       this.websocket.addEventListener("error", this.errorListener);
     }
     idResolver(id) {
-      if (id) return id;
+      if (id !== void 0) return id;
       return this.sendId++;
     }
     /**
@@ -12712,7 +12712,15 @@ ${indent}}` : "}";
             logger.warn("WebSocket received non-string message data:", event.data);
             return;
           }
-          const message = JSON.parse(event.data);
+          let message;
+          try {
+            message = JSON.parse(event.data);
+          } catch (error) {
+            logger.error(
+              `WebSocketChannel: Error parsing incoming message: ${event.data}, Error: ${error}`
+            );
+            return;
+          }
           if (message.id === sendId) {
             clearTimeout(timeoutId);
             this.websocket.removeEventListener("message", messageHandler);
@@ -12795,6 +12803,8 @@ ${indent}}` : "}";
         this.reconnectStabilityTimeoutId = null;
       }
       this.userInitiatedClose = true;
+      this.isReconnecting = false;
+      this._rejectRequestQueue("the connection was closed by the user");
       this.websocket.close(code, reason);
     }
     /**
@@ -12868,6 +12878,24 @@ ${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}`));
+      });
+    }
     async _restoreSubscriptions() {
       const oldSubscriptions = Array.from(this.activeSubscriptions.values());
       this.activeSubscriptions.clear();
@@ -12911,6 +12939,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;