@unicitylabs/sphere-sdk 0.14.11-dev.1 → 0.14.11-dev.3

package/dist/core/index.cjs

@@ -12970,6 +12970,7 @@ var InventoryView = class {
 
 // modules/payments-v2/receive/Receive.ts
 var ACK_BATCH_SIZE = 200;
+var REFRESH_INTERVAL_MS = 750;
 var POLL_INTERVAL_MS = 3e4;
 var ATTENTION_CLAIM_CONFLICT = "claim:conflict";
 function receivedDedupKey(tokenId, stateHash) {
@@ -12986,6 +12987,7 @@ var Receive = class {
   drainFlight = new SingleFlight();
   pollTimer = null;
   unsubscribeWake = null;
+  lastRefreshAt = 0;
   drainOnce() {
     return this.drainFlight.run(() => this.doDrain());
   }
@@ -13003,8 +13005,28 @@ var Receive = class {
     this.unsubscribeWake?.();
     this.unsubscribeWake = null;
   }
+  /**
+   * 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 = [];
@@ -13014,8 +13036,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 > storedBefore) await this.maybeRefresh(deps, pending, pageEpoch);
         }
         await flushAcks(deps, pending, pageEpoch);
         const served = deps.delivery.incomingEpoch();
@@ -13915,7 +13939,7 @@ function composeFacadeParts(deps, hooks) {
     machineDeps,
     machine: new TransferMachine(machineDeps),
     heldStates,
-    receiveLoop: buildReceive(deps, hooks, historyStore, heldStates),
+    receiveLoop: buildReceive(deps, hooks, historyStore, heldStates, view),
     requests: buildRequests(deps, hooks),
     restoreDeps: buildRestoreDeps(deps, machineDeps, machineStores, view)
   };
@@ -13982,7 +14006,7 @@ function buildMachineDeps(deps, hooks, historyStore) {
     }
   };
 }
-function buildReceive(deps, hooks, historyStore, heldStates) {
+function buildReceive(deps, hooks, historyStore, heldStates, view) {
   return new Receive({
     delivery: deps.deliveryPort,
     engine: () => hooks.engine(),
@@ -13996,6 +14020,11 @@ function buildReceive(deps, hooks, historyStore, heldStates) {
     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);
+    },
     attention: (transferId, code, detail) => {
       deps.emit(
         "transfer:attention",