starknet 10.6.7 → 10.7.0

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);
@@ -12852,7 +12927,7 @@ function fromWalletApiCall(call) {
 }
 function toWalletApiActions(actions) {
   return actions.map(
-    (action) => action.type === "subaccount_invoke" ? { ...action, calls: action.calls.map(toWalletApiCall) } : action
+    (action) => action.type === "shadow_account_invoke" ? { ...action, calls: action.calls.map(toWalletApiCall) } : action
   );
 }
 
@@ -12871,7 +12946,7 @@ __export(connectV6_exports, {
   strk20Balances: () => strk20Balances,
   strk20InvokeTransaction: () => strk20InvokeTransaction,
   strk20PrepareInvoke: () => strk20PrepareInvoke,
-  strk20SubaccountCommitment: () => strk20SubaccountCommitment,
+  strk20ShadowAccountCommitment: () => strk20ShadowAccountCommitment,
   subscribeWalletEvent: () => subscribeWalletEvent2,
   supportedSpecs: () => supportedSpecs3,
   supportedWalletApi: () => supportedWalletApi3,
@@ -12959,9 +13034,9 @@ function strk20InvokeTransaction(walletWSF, actions) {
     params: { actions }
   });
 }
-function strk20SubaccountCommitment(walletWSF, dapp_name, nonce) {
+function strk20ShadowAccountCommitment(walletWSF, dapp_name, nonce) {
   return walletWSF.features["starknet:walletApi"].request({
-    type: "wallet_strk20SubaccountCommitment",
+    type: "wallet_strk20ShadowAccountCommitment",
     params: { dapp_name, nonce }
   });
 }
@@ -13053,25 +13128,25 @@ var WalletAccountV6 = class _WalletAccountV6 extends WalletAccountV5 {
     return strk20InvokeTransaction(this.v6Provider, toWalletApiActions(actions));
   }
   /**
-   * Compute the commitment of a DAPP STRK20 sub-account. The commitment is computed
+   * Compute the commitment of a DAPP STRK20 shadow account. The commitment is computed
    * locally by the wallet from the user private state ; no transaction is sent.
    *
-   * When `nonce` is given, the full commitment of this single sub-account is returned.
+   * When `nonce` is given, the full commitment of this single shadow account is returned.
    * When `nonce` is omitted, the partial (nonce independent) commitment is returned
-   * instead : it is shared by every sub-account the user derives for this DAPP, so it can
-   * be published once to let a DAPP recognize all the sub-accounts of a user without
-   * learning any individual nonce.
-   * @param {STRK20_DAPP_NAME} dappName - The DAPP that scopes the sub-account(s).
-   * @param {FELT} [nonce] - The sub-account nonce ; each nonce selects a distinct sub-account for this user + DAPP. Omit it to get the partial commitment.
-   * @returns {Promise<FELT>} The sub-account commitment.
+   * instead : it is shared by every shadow account the user derives for this DAPP, so it
+   * can be published once to let a DAPP recognize all the shadow accounts of a user
+   * without learning any individual nonce.
+   * @param {STRK20_DAPP_NAME} dappName - The DAPP that scopes the shadow account(s).
+   * @param {FELT} [nonce] - The shadow account nonce ; each nonce selects a distinct shadow account for this user + DAPP. Omit it to get the partial commitment.
+   * @returns {Promise<FELT>} The shadow account commitment.
    * @example
    * ```typescript
-   * const commitment = await myWalletAccount.strk20SubaccountCommitment('myDapp', '0x0');
+   * const commitment = await myWalletAccount.strk20ShadowAccountCommitment('myDapp', '0x0');
    * // commitment = '0x5f2e...'
    * ```
    */
-  strk20SubaccountCommitment(dappName, nonce) {
-    return strk20SubaccountCommitment(this.v6Provider, dappName, nonce);
+  strk20ShadowAccountCommitment(dappName, nonce) {
+    return strk20ShadowAccountCommitment(this.v6Provider, dappName, nonce);
   }
   static async connect(provider, walletProvider, cairoVersion, paymaster, silentMode = false) {
     const { accounts } = await standardConnect2(walletProvider, silentMode);