@unicitylabs/sphere-sdk 0.14.11-dev.8 → 0.14.11

package/dist/index.js

@@ -12994,22 +12994,24 @@ var Receive = class {
    * 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) {
+  async maybeRefresh(ctx) {
+    const { deps, pending, pageEpoch } = ctx;
     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();
+    if ((await flushAcks(deps, pending, pageEpoch)).progressed) deps.refreshView();
   }
   /** One listing pass: process each entry, flushing and refreshing as it goes. */
   async drainPages(ctx, basis) {
-    const { deps, engine, pending, stored, pageEpoch } = ctx;
+    const { deps, pending, pageEpoch, claimable } = ctx;
     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);
+      const claimableBefore = claimable.n;
+      await this.processEntry(ctx, entry);
+      if (pending.length >= ACK_BATCH_SIZE) {
+        if (!(await flushAcks(deps, pending, pageEpoch)).progressed) return;
+      }
+      if (claimable.n > claimableBefore) await this.maybeRefresh(ctx);
     }
     await flushAcks(deps, pending, pageEpoch);
   }
@@ -13020,11 +13022,16 @@ var Receive = class {
     const stored = [];
     const pending = [];
     const pageEpoch = () => deps.delivery.incomingEpoch() ?? deps.syncEpoch();
+    const claimable = { n: 0 };
+    const finish = () => {
+      if (claimable.n > 0) deps.refreshView?.();
+      return stored;
+    };
     try {
       const record = await deps.kv.get(STORE_KEYS.streamCursor("mailbox"));
       let basis = record !== null && record.syncEpoch === deps.syncEpoch() ? record : null;
       for (let pass = 0; pass < 2; pass++) {
-        await this.drainPages({ deps, engine, pending, stored, pageEpoch }, basis);
+        await this.drainPages({ deps, engine, pending, stored, pageEpoch, claimable }, basis);
         const served = deps.delivery.incomingEpoch();
         if (basis === null || served === null || served === basis.syncEpoch) break;
         await deps.kv.remove(STORE_KEYS.streamCursor("mailbox"));
@@ -13032,22 +13039,25 @@ var Receive = class {
       }
     } catch (err) {
       logger.warn("PaymentsV2", "receive drain interrupted \u2014 unacked entries retry next drain:", err);
-      if (isRetryableAckError(err)) return stored;
+      if (isRetryableAckError(err)) return finish();
       await flushAcks(deps, pending, pageEpoch).catch((flushErr) => {
         logger.warn("PaymentsV2", "receive ack flush failed \u2014 cursor holds at the acked prefix:", flushErr);
+        return { progressed: false };
       });
     }
-    if (stored.length > 0) deps.refreshView?.();
-    return stored;
+    return finish();
   }
-  async processEntry(deps, engine, entry, pending, stored) {
+  async processEntry(ctx, entry) {
+    const { deps, engine, pending, stored, claimable } = ctx;
     const screened = await screen(deps, engine, entry);
     if (screened.kind === "ack") {
       pending.push(screened.ack);
+      if (screened.ack.disposition === "claimed") claimable.n += 1;
       return;
     }
     await deps.view.store(screened.record);
     pending.push(claimAck(entry));
+    claimable.n += 1;
     const transfer = await announce(deps, entry, screened.record);
     stored.push(transfer);
     deps.emit("transfer:incoming", transfer);
@@ -13108,7 +13118,8 @@ async function announce(deps, entry, record) {
   };
 }
 async function flushAcks(deps, pending, epochOf) {
-  if (pending.length === 0) return;
+  if (pending.length === 0) return { progressed: true };
+  const before = pending.length;
   let lastAcked = null;
   try {
     const settled = await settleAcks(deps, pending);
@@ -13126,6 +13137,7 @@ async function flushAcks(deps, pending, epochOf) {
       await deps.kv.set(STORE_KEYS.streamCursor("mailbox"), record);
     }
   }
+  return { progressed: pending.length < before };
 }
 async function settleAcks(deps, pending) {
   const batch = deps.delivery.ackBatch?.bind(deps.delivery);
@@ -15646,7 +15658,9 @@ var WalletApiDeliveryPort = class {
       await this.settleClaims(acks, settled, outcomes);
       await this.settleRejects(acks, settled);
     } catch (err) {
-      await this.addSeenAll(settled).catch(() => void 0);
+      await this.addSeenAll(settled).catch((seenErr) => {
+        logger.warn("WalletApiDelivery", `seen-set write failed for ${String(settled.length)} committed acks:`, seenErr);
+      });
       throw asRetryable(err);
     }
     await this.addSeenAll(settled);