@unicitylabs/sphere-sdk 0.14.11-dev.2 → 0.14.11-dev.4

package/dist/index.js

@@ -12683,6 +12683,12 @@ var InventoryView = class {
   release(tokenId) {
     if (this.inFlight.delete(tokenId)) this.deps.emit("inventory:updated");
   }
+  /** Release a whole set as ONE change (per-token emitted 54 events per send). */
+  releaseMany(tokenIds) {
+    let changed = false;
+    for (const tokenId of tokenIds) if (this.inFlight.delete(tokenId)) changed = true;
+    if (changed) this.deps.emit("inventory:updated");
+  }
   pinned(tokenId) {
     return this.deps.isPinned?.(tokenId) ?? false;
   }
@@ -12935,16 +12941,28 @@ var Receive = class {
     this.unsubscribeWake?.();
     this.unsubscribeWake = null;
   }
-  /** Ask for a mirror refresh at most once per REFRESH_INTERVAL_MS. */
-  maybeRefresh(deps) {
+  /**
+   * Flush what has been accepted, then ask for a mirror refresh — at most once
+   * per REFRESH_INTERVAL_MS.
+   *
+   * The flush is not incidental. A `claimed` ack is what materializes a token
+   * into SERVER inventory, and acks otherwise sit queued until ACK_BATCH_SIZE
+   * (200) — so for any ordinary drain, including the 54-token case this exists
+   * for, refreshing before the flush would query an inventory holding none of
+   * the tokens just accepted, and the balance would still only move at the end.
+   * Ordering is preserved: store() still precedes the ack (§5.7).
+   */
+  async maybeRefresh(deps, pending, epochOf) {
     if (deps.refreshView === void 0) return;
     const now = deps.now?.() ?? Date.now();
     if (now - this.lastRefreshAt < REFRESH_INTERVAL_MS) return;
     this.lastRefreshAt = now;
+    await flushAcks(deps, pending, epochOf);
     deps.refreshView();
   }
   async doDrain() {
     const deps = this.deps;
+    this.lastRefreshAt = deps.now?.() ?? Date.now();
     const engine = deps.engine();
     const stored = [];
     const pending = [];
@@ -12954,9 +12972,10 @@ var Receive = class {
       let basis = record !== null && record.syncEpoch === deps.syncEpoch() ? record : null;
       for (let pass = 0; pass < 2; pass++) {
         for await (const entry of deps.delivery.incoming(basis === null ? void 0 : String(basis.cursor))) {
+          const storedBefore = stored.length;
           await this.processEntry(deps, engine, entry, pending, stored);
           if (pending.length >= ACK_BATCH_SIZE) await flushAcks(deps, pending, pageEpoch);
-          if (stored.length > 0) this.maybeRefresh(deps);
+          if (stored.length > storedBefore) await this.maybeRefresh(deps, pending, pageEpoch);
         }
         await flushAcks(deps, pending, pageEpoch);
         const served = deps.delivery.incomingEpoch();
@@ -13816,6 +13835,16 @@ function parseAmount(raw) {
 function supportsDeterministicMint(engine) {
   return engine.deterministicMint === true;
 }
+function makeSingleFlightRefresh(refresh) {
+  let inFlight = false;
+  return () => {
+    if (inFlight) return;
+    inFlight = true;
+    void refresh().catch(() => void 0).finally(() => {
+      inFlight = false;
+    });
+  };
+}
 function composeFacadeParts(deps, hooks) {
   const ownPubkeyBytes = hexToBytes4(deps.ownPubkey);
   const ledger = new ReservationLedger();
@@ -13937,11 +13966,10 @@ function buildReceive(deps, hooks, historyStore, heldStates, view) {
     registry: deps.registry,
     recordReceived: (record) => recordReceived(historyStore, record),
     emit: (event, transfer) => deps.emit(event, transfer),
-    // The mirror is the balance the wallet renders; refresh it as the drain runs
-    // so a multi-token receive lands progressively instead of all at the end.
-    refreshView: () => {
-      void view.delta().catch(() => void 0);
-    },
+    // Single-flight: view.delta() enqueues on a strict-FIFO SerialChain, so
+    // firing per throttle tick regardless of the last one builds a queue that
+    // drains in a burst at the END — a slower version of the bug being fixed.
+    refreshView: makeSingleFlightRefresh(() => view.delta()),
     attention: (transferId, code, detail) => {
       deps.emit(
         "transfer:attention",
@@ -14386,7 +14414,7 @@ var PaymentsFacade = class {
   settleFailure(transferId, coinId, releaseIds) {
     this.ledger.cancel(transferId);
     this.queue.clearExpectedChange(transferId);
-    for (const tokenId of releaseIds) this.view.release(tokenId);
+    this.view.releaseMany(releaseIds);
     this.queue.notifyChange(coinId);
   }
   /** Open intent: sources stay reserved + in-flight (§5.2) until resume adopts them. */
@@ -14411,7 +14439,7 @@ var PaymentsFacade = class {
   async refreshThenRelease(coinId, spentIds) {
     try {
       await this.view.delta();
-      for (const tokenId of spentIds) this.view.release(tokenId);
+      this.view.releaseMany(spentIds);
     } finally {
       this.queue.notifyChange(coinId);
     }