starknet 10.6.7 → 10.6.8

package/dist/index.mjs

@@ -7292,6 +7292,8 @@ var Subscription = class {
   maxBufferSize;
   handler = null;
   _isClosed = false;
+  // The unsubscribe request currently on the wire, shared by concurrent callers.
+  pendingUnsubscribe = null;
   /**
    * @internal
    * @param options - Subscription configuration options
@@ -7310,6 +7312,20 @@ var Subscription = class {
   get isClosed() {
     return this._isClosed;
   }
+  /**
+   * Closes the subscription locally, without contacting the node.
+   *
+   * Used when the channel knows the subscription is gone and cannot be recovered — a
+   * re-subscribe refused after a reconnection, for instance. Without it the object would keep
+   * reporting itself as open while no event could ever reach its handler again.
+   * @internal
+   */
+  _markClosed() {
+    if (this._isClosed) return;
+    this._isClosed = true;
+    this.events.emit("unsubscribe", void 0);
+    this.events.clear();
+  }
   /**
    * Internal method to handle incoming events from the WebSocket channel.
    * If a handler is attached, it's invoked immediately. Otherwise, the event is buffered.
@@ -7356,14 +7372,24 @@ var Subscription = class {
     if (this._isClosed) {
       return true;
     }
-    const success = await this.channel.unsubscribe(this.id);
-    if (success) {
-      this._isClosed = true;
-      this.channel.removeSubscription(this.id);
-      this.events.emit("unsubscribe", void 0);
-      this.events.clear();
+    if (this.pendingUnsubscribe) {
+      return this.pendingUnsubscribe;
     }
-    return success;
+    this.pendingUnsubscribe = (async () => {
+      try {
+        const success = await this.channel.unsubscribe(this.id);
+        if (success) {
+          this._isClosed = true;
+          this.channel.removeSubscription(this.id);
+          this.events.emit("unsubscribe", void 0);
+          this.events.clear();
+        }
+        return success;
+      } finally {
+        this.pendingUnsubscribe = null;
+      }
+    })();
+    return this.pendingUnsubscribe;
   }
 };
 
@@ -7396,6 +7422,15 @@ var WebSocketChannel = class {
   requestQueue = [];
   /** Abort handles for the requests currently on the wire, one per pending `sendReceive`. */
   inFlight = /* @__PURE__ */ new Set();
+  /**
+   * Callers blocked in `waitForUnsubscription`, keyed by subscription id.
+   *
+   * Held here rather than as `unsubscribe` event listeners because that event only ever
+   * announces success: a waiter attached to it cannot learn that the node refused the
+   * unsubscribe or that the connection went away, and would wait forever with no timeout of
+   * its own to fall back on.
+   */
+  unsubscribeWaiters = /* @__PURE__ */ new Map();
   events = new EventEmitter();
   openListener = (ev) => {
     this.scheduleReconnectAttemptsReset();
@@ -7592,6 +7627,7 @@ var WebSocketChannel = class {
     this.isReconnecting = false;
     this._rejectRequestQueue("the connection was closed by the user");
     this._rejectInFlight("the connection was closed by the user");
+    this._rejectUnsubscribeWaiters("the connection was closed by the user");
     this.websocket.close(code, reason);
   }
   /**
@@ -7616,14 +7652,48 @@ var WebSocketChannel = class {
    * @returns {Promise<boolean>} A Promise that resolves with `true` if the unsubscription was successful.
    */
   async unsubscribe(subscriptionId) {
-    const status = await this.sendReceive("starknet_unsubscribe", {
-      subscription_id: subscriptionId
-    });
+    let status;
+    try {
+      status = await this.sendReceive("starknet_unsubscribe", {
+        subscription_id: subscriptionId
+      });
+    } catch (error) {
+      this._settleUnsubscribeWaiters(subscriptionId, error);
+      throw error;
+    }
     if (status) {
       this.events.emit("unsubscribe", subscriptionId);
+      this._settleUnsubscribeWaiters(subscriptionId);
+    } else {
+      this._settleUnsubscribeWaiters(
+        subscriptionId,
+        new Error(`Node refused to unsubscribe subscription ${subscriptionId}`)
+      );
     }
     return status;
   }
+  /** Settles every caller waiting on one subscription id: resolved, or rejected with `error`. */
+  _settleUnsubscribeWaiters(subscriptionId, error) {
+    const waiters = this.unsubscribeWaiters.get(subscriptionId);
+    if (!waiters) return;
+    this.unsubscribeWaiters.delete(subscriptionId);
+    waiters.forEach((waiter) => error ? waiter.reject(error) : waiter.resolve());
+  }
+  /**
+   * Rejects every caller still waiting on any subscription.
+   *
+   * Once the connection is gone, no unsubscribe can be observed on it: a reconnection restores
+   * each subscription under a fresh id, so the id being waited on will never be announced.
+   */
+  _rejectUnsubscribeWaiters(reason) {
+    if (this.unsubscribeWaiters.size === 0) return;
+    Array.from(this.unsubscribeWaiters.keys()).forEach(
+      (id) => this._settleUnsubscribeWaiters(
+        id,
+        new WebSocketNotConnectedError(`Subscription ${id} was never unsubscribed: ${reason}`)
+      )
+    );
+  }
   /**
    * Returns a Promise that resolves when a specific subscription is successfully unsubscribed.
    * @param {SUBSCRIPTION_ID} targetId - The ID of the subscription to wait for.
@@ -7635,14 +7705,10 @@ var WebSocketChannel = class {
    * ```
    */
   waitForUnsubscription(targetId) {
-    return new Promise((resolve) => {
-      const listener = (unsubId) => {
-        if (unsubId === targetId) {
-          this.events.off("unsubscribe", listener);
-          resolve();
-        }
-      };
-      this.events.on("unsubscribe", listener);
+    return new Promise((resolve, reject) => {
+      const waiters = this.unsubscribeWaiters.get(targetId) ?? /* @__PURE__ */ new Set();
+      waiters.add({ resolve, reject });
+      this.unsubscribeWaiters.set(targetId, waiters);
     });
   }
   /**
@@ -7709,6 +7775,7 @@ var WebSocketChannel = class {
         logger.info(`Subscription ${sub.method} restored with new ID: ${newSubId}`);
       } catch (error) {
         logger.error(`Failed to restore subscription ${sub.method}:`, error);
+        sub._markClosed();
       }
     });
     await Promise.all(restorePromises);
@@ -7778,6 +7845,7 @@ var WebSocketChannel = class {
     this.websocket.removeEventListener("message", this.messageListener);
     this.websocket.removeEventListener("error", this.errorListener);
     this._rejectInFlight("the connection was closed");
+    this._rejectUnsubscribeWaiters("the connection was closed");
     this.events.emit("close", ev);
     if (!this.userInitiatedClose) {
       this._startReconnect();
@@ -7799,9 +7867,16 @@ var WebSocketChannel = class {
       if (subscription) {
         subscription._handleEvent(result);
       } else {
-        logger.warn(
-          `WebSocketChannel: Received event for untracked subscription ID: ${subscription_id}.`
-        );
+        queueMicrotask(() => {
+          const registered = this.activeSubscriptions.get(subscription_id);
+          if (registered) {
+            registered._handleEvent(result);
+          } else {
+            logger.warn(
+              `WebSocketChannel: Received event for untracked subscription ID: ${subscription_id}.`
+            );
+          }
+        });
       }
     }
     logger.debug("onMessageProxy:", event.data);