starknet 10.6.5 → 10.6.7

package/dist/index.js

@@ -7578,6 +7578,8 @@ var WebSocketChannel = class {
   // 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();
@@ -7661,12 +7663,19 @@ var WebSocketChannel = class {
       });
     }
     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);
@@ -7681,34 +7690,35 @@ var WebSocketChannel = class {
           );
           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`
@@ -7763,6 +7773,9 @@ var WebSocketChannel = class {
       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);
   }
   /**
@@ -7836,6 +7849,39 @@ var WebSocketChannel = class {
       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();
@@ -7879,6 +7925,9 @@ var WebSocketChannel = class {
       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;
@@ -7886,18 +7935,24 @@ var WebSocketChannel = class {
         `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();
   }
@@ -7906,6 +7961,7 @@ var WebSocketChannel = class {
     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();