@glyphteck/veyl 0.74.2 → 0.75.1

package/dist/account.js

@@ -16784,13 +16784,13 @@ var RECENT_PEER_REFRESH_THROTTLE_MS = 120;
 var BAN_REFRESH_GRACE_MS = 50;
 var REQUEST_MONEY_MAX_SATS = SATS_PER_BITCOIN * 100000n;
 var WALLET_TRANSFER_POLL_MS = 3 * MS_PER_SECOND;
-var WALLET_ACTIVE_TRANSFER_REFRESH_MS = MS_PER_SECOND;
+var WALLET_TRANSFER_REPAIR_MS = 30 * MS_PER_SECOND;
 var WALLET_CACHE_HYDRATE_DELAY_MS = 0;
 var WALLET_BOOT_REFRESH_DELAY_MS = 500;
 var WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500;
 var WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS = 20 * MS_PER_SECOND;
 var WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS = MINUTE_MS;
-var WALLET_BALANCE_EVENT_COALESCE_MS = 2 * MS_PER_SECOND;
+var WALLET_BALANCE_EVENT_COALESCE_MS = 100;
 var WALLET_INCOMING_UPDATE_COALESCE_MS = 250;
 var WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000;
 var WALLET_CLAIM_PAGE_SIZE = 100;
@@ -54549,56 +54549,25 @@ function createIncomingTransferClaims({ wallet, claim, batchSize = null, getTran
     }
   });
 }
-async function queryPendingTransferIds(wallet, ids = [], diag) {
-  if (!ids.length || typeof wallet?.transferService?.queryPendingTransfers !== "function") {
-    return new Set;
-  }
-  const startedAt = Date.now();
-  markDiag(diag, "wallet.pendingTxs.claim.verify.start", { count: ids.length });
-  const requestedIds = new Set(ids);
-  try {
-    const page = await wallet.transferService.queryPendingTransfers.call(wallet.transferService, ids);
-    const pendingTransfers = (Array.isArray(page?.transfers) ? page.transfers : []).filter((transfer) => requestedIds.has(String(transfer?.id || "")));
-    markDone(diag, "wallet.pendingTxs.claim.verify", startedAt, { count: ids.length, pending: pendingTransfers.length });
-    return new Set(pendingTransfers.map((transfer) => String(transfer?.id || "")).filter(Boolean));
-  } catch (error) {
-    markError(diag, "wallet.pendingTxs.claim.verify", startedAt, error, { count: ids.length });
-    throw error;
-  }
-}
-async function claimIncomingTransfersById(wallet, transfers = [], { onClaimed, emitClaimEvents = false, drainAll = true, diag } = {}) {
+async function claimIncomingTransfersById(wallet, transfers = [], { onClaimed, emitClaimEvents = false, diag } = {}) {
   const ids = transferIds(transfers);
-  if (!ids.length || typeof wallet?.transferService?.queryPendingTransfers !== "function" || typeof wallet?.claimTransfers !== "function" && typeof wallet?.claimTransfer !== "function") {
+  if (!ids.length || typeof wallet?.transferService?.queryPendingTransfers !== "function" || typeof wallet?.claimTransfer !== "function") {
     return [];
   }
   const requestedIds = new Set(ids);
   const activeClaim = activeWalletClaims.get(wallet);
   if (activeClaim) {
-    const claimedIds = transferIds(await activeClaim).filter((id) => requestedIds.has(id));
+    const claimedIds = transferIds(await activeClaim.catch(() => [])).filter((id) => requestedIds.has(id));
     if (claimedIds.length) {
       onClaimed?.(claimedIds);
     }
-    return claimedIds;
+    const remaining = ids.filter((id) => !claimedIds.includes(id));
+    if (!remaining.length)
+      return claimedIds;
+    const next = await claimIncomingTransfersById(wallet, remaining, { onClaimed, emitClaimEvents, diag });
+    return [...claimedIds, ...next];
   }
   const claimPromise = (async () => {
-    if (drainAll !== false && typeof wallet?.claimTransfers === "function") {
-      const claimedIds2 = [];
-      const claimStartedAt = Date.now();
-      markDiag(diag, "wallet.pendingTxs.claim.sdk.start", { count: ids.length, mode: "all" });
-      try {
-        claimedIds2.push(...transferIds(await wallet.claimTransfers(undefined, emitClaimEvents === true)));
-        markDone(diag, "wallet.pendingTxs.claim.sdk", claimStartedAt, { count: ids.length, mode: "all", claimed: claimedIds2.length });
-      } catch (error) {
-        markError(diag, "wallet.pendingTxs.claim.sdk", claimStartedAt, error, { count: ids.length, mode: "all" });
-      }
-      const pendingIds2 = await queryPendingTransferIds(wallet, ids, diag).catch(() => new Set);
-      claimedIds2.push(...ids.filter((id) => !pendingIds2.has(id)));
-      const uniqueClaimedIds = [...new Set(claimedIds2)];
-      if (uniqueClaimedIds.length) {
-        onClaimed?.(uniqueClaimedIds);
-      }
-      return uniqueClaimedIds;
-    }
     const queryStartedAt = Date.now();
     markDiag(diag, "wallet.pendingTxs.claim.query.start", { count: ids.length });
     let page;
@@ -54610,13 +54579,7 @@ async function claimIncomingTransfersById(wallet, transfers = [], { onClaimed, e
     }
     const pendingTransfers = (Array.isArray(page?.transfers) ? page.transfers : []).filter((transfer) => requestedIds.has(String(transfer?.id || "")));
     markDone(diag, "wallet.pendingTxs.claim.query", queryStartedAt, { count: ids.length, pending: pendingTransfers.length });
-    const pendingIds = new Set(pendingTransfers.map((transfer) => String(transfer?.id || "")).filter(Boolean));
     const claimedIds = [];
-    const alreadySettledIds = ids.filter((id) => !pendingIds.has(id));
-    if (alreadySettledIds.length) {
-      claimedIds.push(...alreadySettledIds);
-      onClaimed?.(alreadySettledIds);
-    }
     for (const transfer of pendingTransfers) {
       if (!isClaimablePendingTransfer(transfer)) {
         continue;
@@ -54896,7 +54859,7 @@ async function claimStaticDeposits(wallet, { maxFeeSats = AUTO_CLAIM_MAX_FEE_SAT
 }
 
 // ../../core/wallet/claims.js
-function createDepositClaims({ wallet, updateWalletData, diag }) {
+function createDepositClaims({ wallet, diag }) {
   let claimPromise = null;
   let closed = false;
   const claimDeposits = async () => {
@@ -54922,27 +54885,8 @@ function createDepositClaims({ wallet, updateWalletData, diag }) {
     claimPromise = request;
     return request;
   };
-  const refresh = async () => {
-    const startedAt = Date.now();
-    markDiag(diag, "wallet.refresh.start", {});
-    const claimed = await claimDeposits();
-    if (!closed) {
-      await updateWalletData({ force: true, reason: "deposit-refresh" });
-    }
-    markDone(diag, "wallet.refresh", startedAt, { claimed: !!claimed });
-  };
-  const refreshClaims = async () => {
-    const claimed = await claimDeposits();
-    if (!claimed || closed) {
-      return false;
-    }
-    await updateWalletData({ force: true, reason: "deposit-claim" });
-    return true;
-  };
   return {
     claimDeposits,
-    refresh,
-    refreshClaims,
     close() {
       closed = true;
       claimPromise = null;
@@ -55087,7 +55031,6 @@ function createLightning({ wallet }) {
 
 // ../../core/wallet/lifecycle.js
 var POLL_TXS_RATE = WALLET_TRANSFER_POLL_MS;
-var ACTIVE_TRANSFER_REFRESH_RATE = WALLET_ACTIVE_TRANSFER_REFRESH_MS;
 var BOOT_REFRESH_DELAY_MS = WALLET_BOOT_REFRESH_DELAY_MS;
 var BOOT_CACHED_REFRESH_DELAY_MS = WALLET_BOOT_CACHED_REFRESH_DELAY_MS;
 var BOOT_CACHE_DECISION_DELAY_MS = BOOT_REFRESH_DELAY_MS + Math.max(0, WALLET_CACHE_HYDRATE_DELAY_MS) + 250;
@@ -55161,7 +55104,7 @@ function createWalletData({ wallet, getBalance, getRecentTxs, diag }) {
           tasks.push(getBalance());
         }
         if (currentRequest.transfers) {
-          tasks.push(getRecentTxs({ force: currentRequest.force, reason: currentRequest.reason }));
+          tasks.push(getRecentTxs({ force: currentRequest.force, reason: currentRequest.reason, includePending: false }));
         }
         await Promise.all(tasks);
         markDone(diag, "wallet.update", startedAt, {
@@ -55196,353 +55139,240 @@ function createWalletData({ wallet, getBalance, getRecentTxs, diag }) {
   };
   return updateWalletData;
 }
-function createWalletEvents({ wallet, updateWalletData, getTransferState, setBalance, setTokenBalances, setSatsBalanceResult, diag }) {
-  const balanceEvent = { timer: null, value: null };
-  const incomingEvent = { timer: null, balance: null };
-  const claimedEvent = { timer: null, balance: null, transfers: [], ids: [] };
-  if (!wallet || typeof wallet.on !== "function" || typeof wallet.off !== "function") {
-    return { close() {} };
-  }
-  const flushBalanceEvent = () => {
-    balanceEvent.timer = null;
-    const value = balanceEvent.value;
-    balanceEvent.value = null;
-    if (value) {
-      if (getTransferState().hasActivePendingClaim?.() === true) {
-        return;
-      }
-      markDiag(diag, "wallet.events.balance.flush", {});
-      setSatsBalanceResult(value);
-    }
-  };
-  const flushIncomingEvent = () => {
-    incomingEvent.timer = null;
-    const balance = incomingEvent.balance;
-    incomingEvent.balance = null;
-    if (balance != null) {
-      setBalance(balance);
-    }
-    markDiag(diag, "wallet.events.incoming.flush", { hasBalance: balance != null });
-    updateWalletData({ transfers: true, balance: false, reason: "incoming" });
+function createWalletEvents({ wallet, getTransferState, setTokenBalances, setSatsBalanceResult, reconcile, sync, diag }) {
+  let closed = false;
+  let balanceTimer = null;
+  let claimTimer = null;
+  let balanceValue = null;
+  const claimedIds = new Set;
+  const handleBalanceUpdate = (value) => {
+    if (closed || !value || typeof value !== "object")
+      return;
+    balanceValue = value;
+    if (balanceTimer)
+      return;
+    balanceTimer = setTimeout(() => {
+      balanceTimer = null;
+      if (!closed)
+        setSatsBalanceResult(balanceValue);
+    }, BALANCE_EVENT_COALESCE_MS);
   };
-  const flushClaimedEvent = () => {
-    claimedEvent.timer = null;
-    const balance = claimedEvent.balance;
-    const transfers = claimedEvent.transfers;
-    const ids = claimedEvent.ids;
-    claimedEvent.balance = null;
-    claimedEvent.transfers = [];
-    claimedEvent.ids = [];
-    if (balance != null) {
-      setBalance(balance);
-    }
-    markDiag(diag, "wallet.events.transfer.claimed.flush", { count: transfers.length, ids: ids.length, hasBalance: balance != null });
-    const transferState = getTransferState();
-    if (transfers.length) {
-      transferState.rememberTransfer?.(transfers, { completed: true, incoming: true });
-    }
-    if (ids.length) {
-      const completedIds = new Set(transferState.markTransfersCompleted?.(ids) || []);
-      const unknownIds = ids.filter((id) => !completedIds.has(String(id)));
-      if (unknownIds.length) {
-        transferState.refreshPendingTransfers?.(unknownIds);
-      }
-    }
+  const handleTransferClaimed = (id) => {
+    if (closed || !id)
+      return;
+    claimedIds.add(String(id));
+    if (claimTimer)
+      return;
+    claimTimer = setTimeout(() => {
+      claimTimer = null;
+      const ids = [...claimedIds];
+      claimedIds.clear();
+      if (closed)
+        return;
+      const transfers = getTransferState();
+      transfers.markTransfersCompleted(ids);
+      transfers.refreshPendingTransfers(ids).finally(sync);
+      sync();
+      markDiag(diag, "wallet.events.transfer.claimed.flush", { count: ids.length });
+    }, INCOMING_UPDATE_COALESCE_MS);
   };
   const handleTokenBalanceUpdate = (event) => {
-    if (event?.tokenBalances instanceof Map) {
+    if (!closed && event?.tokenBalances instanceof Map)
       setTokenBalances(new Map(event.tokenBalances));
-    }
   };
-  const handleBalanceUpdate = (nextSatsBalance) => {
-    if (!nextSatsBalance || typeof nextSatsBalance !== "object") {
-      return;
-    }
-    balanceEvent.value = nextSatsBalance;
-    if (!balanceEvent.timer) {
-      balanceEvent.timer = setTimeout(flushBalanceEvent, BALANCE_EVENT_COALESCE_MS);
-    }
+  const handleDepositConfirmed = () => {
+    if (!closed)
+      reconcile({ history: true, reason: "deposit-confirmed" });
   };
-  const handleIncomingBalance = (updatedBalance) => {
-    if (updatedBalance != null) {
-      incomingEvent.balance = updatedBalance;
-    }
-    if (!incomingEvent.timer) {
-      incomingEvent.timer = setTimeout(flushIncomingEvent, INCOMING_UPDATE_COALESCE_MS);
-    }
+  const handleConnected = () => {
+    if (!closed)
+      reconcile({ history: true, pending: true, reason: "stream-connected" });
   };
-  const handleTransferClaimed = (transferId, updatedBalance, transfer) => {
-    if (updatedBalance != null) {
-      claimedEvent.balance = updatedBalance;
-    }
-    if (transfer) {
-      claimedEvent.transfers.push(transfer);
-    } else if (transferId) {
-      claimedEvent.ids.push(String(transferId));
-    }
-    if (!claimedEvent.timer) {
-      claimedEvent.timer = setTimeout(flushClaimedEvent, INCOMING_UPDATE_COALESCE_MS);
-    }
+  const handleReconnecting = () => {
+    markDiag(diag, "wallet.stream.reconnecting", {});
   };
-  const handleDepositConfirmed = (_id, updatedBalance) => {
-    handleIncomingBalance(updatedBalance);
+  const handlers = {
+    [WALLET_EVENTS.balance]: handleBalanceUpdate,
+    [WALLET_EVENTS.tokenBalance]: handleTokenBalanceUpdate,
+    [WALLET_EVENTS.transferClaimed]: handleTransferClaimed,
+    [WALLET_EVENTS.depositConfirmed]: handleDepositConfirmed,
+    "stream:connected": handleConnected,
+    "stream:reconnecting": handleReconnecting
   };
-  wallet.on(WALLET_EVENTS.balance, handleBalanceUpdate);
-  wallet.on(WALLET_EVENTS.tokenBalance, handleTokenBalanceUpdate);
-  wallet.on(WALLET_EVENTS.depositConfirmed, handleDepositConfirmed);
-  wallet.on(WALLET_EVENTS.transferClaimed, handleTransferClaimed);
+  for (const [name, handler] of Object.entries(handlers))
+    wallet.on(name, handler);
   return {
     close() {
-      wallet.off(WALLET_EVENTS.balance, handleBalanceUpdate);
-      wallet.off(WALLET_EVENTS.tokenBalance, handleTokenBalanceUpdate);
-      wallet.off(WALLET_EVENTS.depositConfirmed, handleDepositConfirmed);
-      wallet.off(WALLET_EVENTS.transferClaimed, handleTransferClaimed);
-      for (const event of [balanceEvent, incomingEvent, claimedEvent]) {
-        if (event.timer) {
-          clearTimeout(event.timer);
-          event.timer = null;
-        }
-      }
+      closed = true;
+      clearTimeout(balanceTimer);
+      clearTimeout(claimTimer);
+      claimedIds.clear();
+      for (const [name, handler] of Object.entries(handlers))
+        wallet.off(name, handler);
     }
   };
 }
-function createWalletPolling({ wallet, network, appState, getTransferState, getBalanceState, refreshClaims, activeTransferRefreshMs = ACTIVE_TRANSFER_REFRESH_RATE, diag }) {
-  let pollInterval = null;
-  let activeRefreshInterval = null;
-  let activeRefreshPromise = null;
-  let pendingPollPromise = null;
-  let activeRefreshLastAt = 0;
-  let transferDiscoveryVisible = false;
+function createWalletReconciliation({ network, appState, getTransferState, updateWalletData, claimDeposits, deferBackgroundWork = null, backgroundSignal = null, diag }) {
+  const waits = createOwnedWaits();
+  const depositRate = getDepositClaimPollMs(network);
+  let started = false;
+  let starting = false;
   let closed = false;
-  const depositClaimRate = getDepositClaimPollMs(network);
-  const activeRefreshPollMs = Math.max(500, Number(activeTransferRefreshMs) || ACTIVE_TRANSFER_REFRESH_RATE);
-  const isActive = () => !appState?.currentState || appState.currentState === "active";
-  const isTxReady = () => getTransferState().txReady === true && getBalanceState().balanceReady === true;
-  const hasActivePendingClaim = () => getTransferState().hasActivePendingClaim?.() === true;
-  const hasFastActiveRefreshWork = () => transferDiscoveryVisible || hasActivePendingClaim();
-  const activeRefreshDue = () => {
-    if (!hasFastActiveRefreshWork())
-      return false;
-    return hasActivePendingClaim() || !activeRefreshLastAt || Date.now() - activeRefreshLastAt >= activeRefreshPollMs;
-  };
-  const runActiveRefresh = (reason = "active-poll") => {
-    if (closed || !wallet || !isActive()) {
-      return Promise.resolve([]);
-    }
-    if (activeRefreshPromise) {
-      return activeRefreshPromise;
-    }
-    const promise = (async () => {
-      activeRefreshLastAt = Date.now();
-      const transferState = getTransferState();
-      const transfers = typeof transferState.claimPendingIncomingTransfers === "function" ? await transferState.claimPendingIncomingTransfers(reason) : [];
-      const claimActive = hasActivePendingClaim();
-      if (isTxReady() && typeof transferState.refreshPendingTransfers === "function" && !transferDiscoveryVisible && !claimActive) {
-        transferState.refreshPendingTransfers(null, { cold: true, reason });
-      }
-      return transfers;
-    })().finally(() => {
-      if (activeRefreshPromise === promise) {
-        activeRefreshPromise = null;
-      }
-    });
-    activeRefreshPromise = promise;
-    return promise;
-  };
-  const stopActiveRefreshPoll = () => {
-    if (!activeRefreshInterval)
-      return;
-    clearInterval(activeRefreshInterval);
-    activeRefreshInterval = null;
+  let timer = null;
+  let promise = null;
+  let queued = null;
+  const waiters = [];
+  const finishWaiters = () => {
+    for (const resolve of waiters.splice(0))
+      resolve();
   };
-  const runObservedActiveRefresh = () => {
-    if (!hasFastActiveRefreshWork()) {
-      stopActiveRefreshPoll();
-      return;
-    }
-    if (activeRefreshDue()) {
-      runActiveRefresh();
-    }
+  let pendingAt = 0;
+  let repairAt = 0;
+  let depositAt = 0;
+  const isActive = () => !appState?.currentState || appState.currentState === "active";
+  const isOpen = () => !closed && !backgroundSignal?.aborted;
+  const hasPending = () => {
+    const state = getTransferState();
+    return state.hasPendingTxs || state.hasRequestedTransfers();
   };
-  const startActiveRefreshPoll = () => {
-    if (closed || !appState || activeRefreshInterval || !wallet || !isActive() || !hasFastActiveRefreshWork() || typeof getTransferState().claimPendingIncomingTransfers !== "function") {
+  function sync() {
+    clearTimeout(timer);
+    timer = null;
+    if (!isOpen() || !started || !isActive() || promise)
       return;
-    }
-    markDiag(diag, "wallet.pendingTxs.active.start", {});
-    activeRefreshInterval = setInterval(() => {
-      if (!isActive()) {
-        return;
-      }
-      runObservedActiveRefresh();
-    }, activeRefreshPollMs);
-    runObservedActiveRefresh();
-  };
-  const runPendingPoll = () => {
-    if (pendingPollPromise) {
-      return pendingPollPromise;
-    }
-    const promise = Promise.resolve().then(() => getTransferState().refreshPendingTransfers?.()).finally(() => {
-      if (pendingPollPromise === promise) {
-        pendingPollPromise = null;
+    const next = Math.min(repairAt, depositAt, hasPending() ? pendingAt : Infinity);
+    timer = setTimeout(tick, Math.max(0, next - Date.now()));
+  }
+  function request(options = {}) {
+    if (!isOpen())
+      return Promise.resolve();
+    queued = {
+      history: queued?.history || options.history === true,
+      incoming: queued?.incoming || options.incoming === true,
+      pending: queued?.pending || options.pending === true,
+      deposits: queued?.deposits || options.deposits === true,
+      forcePending: queued?.forcePending || options.pending === true && options.reason !== "scheduled",
+      reason: queued?.reason && queued.reason !== options.reason ? "merged" : options.reason || "manual"
+    };
+    const result = new Promise((resolve) => waiters.push(resolve));
+    if (!started || !isActive() || promise)
+      return result;
+    clearTimeout(timer);
+    const run = async () => {
+      while (queued && isOpen() && isActive()) {
+        const work = queued;
+        queued = null;
+        const startedAt = Date.now();
+        try {
+          if (work.incoming) {
+            repairAt = Date.now() + WALLET_TRANSFER_REPAIR_MS;
+            await getTransferState().claimPendingIncomingTransfers(work.reason);
+          }
+          if (!isOpen())
+            break;
+          if (!isActive()) {
+            request(work);
+            break;
+          }
+          if (work.deposits) {
+            depositAt = Date.now() + depositRate;
+            if (await claimDeposits())
+              work.history = true;
+          }
+          if (!isOpen())
+            break;
+          if (!isActive()) {
+            request(work);
+            break;
+          }
+          if (work.history)
+            await updateWalletData({ force: true, reason: work.reason });
+          if (!isOpen())
+            break;
+          if (!isActive()) {
+            request(work);
+            break;
+          }
+          if (work.pending) {
+            pendingAt = Date.now() + POLL_TXS_RATE;
+            await getTransferState().refreshPendingTransfers(null, { force: work.forcePending, reason: work.reason });
+          }
+          if (!isOpen())
+            break;
+          if (!isActive()) {
+            request(work);
+            break;
+          }
+          markDone(diag, "wallet.reconcile", startedAt, work);
+        } catch (error) {
+          markError(diag, "wallet.reconcile", startedAt, error, { reason: work.reason });
+        }
       }
+    };
+    const running = Promise.resolve().then(run).finally(() => {
+      if (promise === running)
+        promise = null;
+      if (!queued)
+        finishWaiters();
+      sync();
     });
-    pendingPollPromise = promise;
-    return promise;
-  };
-  const startPoll = () => {
-    const transferState = getTransferState();
-    if (closed || pollInterval || !wallet || !transferState.hasPendingTxs || !isTxReady() || !isActive()) {
-      return;
-    }
-    runPendingPoll();
-    pollInterval = setInterval(() => {
-      if (isActive()) {
-        runPendingPoll();
-      }
-    }, POLL_TXS_RATE);
-  };
-  const stopPoll = () => {
-    if (!pollInterval)
-      return;
-    clearInterval(pollInterval);
-    pollInterval = null;
-  };
-  const sync = () => {
-    if (closed || !wallet) {
-      stopPoll();
-      stopActiveRefreshPoll();
-      return;
-    }
-    if (isActive() && hasFastActiveRefreshWork()) {
-      startActiveRefreshPoll();
-    } else {
-      stopActiveRefreshPoll();
-    }
-    if (getTransferState().hasPendingTxs && isActive()) {
-      startPoll();
-    } else {
-      stopPoll();
+    promise = running;
+    return result;
+  }
+  function tick() {
+    timer = null;
+    const now = Date.now();
+    const incoming = now >= repairAt;
+    const deposits = now >= depositAt;
+    const pending = hasPending() && now >= pendingAt;
+    if (incoming)
+      repairAt = now + WALLET_TRANSFER_REPAIR_MS;
+    if (deposits)
+      depositAt = now + depositRate;
+    if (pending)
+      pendingAt = now + POLL_TXS_RATE;
+    request({ incoming, deposits, pending, reason: "scheduled" });
+  }
+  const subscription = appState?.addEventListener?.("change", (state) => {
+    if (state === "active") {
+      request({ incoming: true, history: true, pending: true, deposits: true, reason: "resume" });
     }
-  };
-  const setTransferDiscoveryVisible = (visible) => {
-    const next = visible === true;
-    if (transferDiscoveryVisible === next)
-      return;
-    transferDiscoveryVisible = next;
-    if (next)
-      activeRefreshLastAt = 0;
     sync();
-  };
-  const appStateSubscription = appState?.addEventListener?.("change", (nextState2) => {
-    if (nextState2 === "active") {
-      runActiveRefresh("focus");
-      startActiveRefreshPoll();
-      if (getTransferState().hasPendingTxs) {
-        startPoll();
-        runPendingPoll();
-      }
-      refreshClaims();
-      return;
-    }
-    stopPoll();
-    stopActiveRefreshPoll();
   });
-  const depositClaimInterval = setInterval(() => {
-    if (isActive()) {
-      refreshClaims();
-    }
-  }, depositClaimRate);
-  sync();
   return {
-    setTransferDiscoveryVisible,
-    stopPoll,
+    request,
+    refresh: () => request({ incoming: true, history: true, pending: true, deposits: true, reason: "manual" }),
     sync,
-    close() {
-      if (closed)
+    async start() {
+      if (starting || !isOpen())
         return;
-      closed = true;
-      stopPoll();
-      stopActiveRefreshPoll();
-      clearInterval(depositClaimInterval);
-      appStateSubscription?.remove?.();
-    }
-  };
-}
-function createWalletBoot({ wallet, getTransferState, getBalance, getRecentTxs, deferBackgroundWork = null, backgroundSignal = null, stopPoll, diag }) {
-  let closed = false;
-  const waits = createOwnedWaits();
-  const boot = async () => {
-    const startedAt = Date.now();
-    markDiag(diag, "wallet.provider.boot.start", {});
-    await waits.delay(BOOT_CACHE_DECISION_DELAY_MS);
-    await waits.idle({ timeout: BOOT_REFRESH_DELAY_MS, delay: BOOT_REFRESH_DELAY_MS });
-    if (closed) {
-      markDone(diag, "wallet.provider.boot", startedAt, { cancelled: true });
-      return;
-    }
-    const transferState = getTransferState();
-    if (transferState.txReady) {
-      const cachedTransferCount = transferState.transferCount;
-      markDone(diag, "wallet.provider.boot", startedAt, {
-        cancelled: false,
-        cachedTxReady: true,
-        deferredTxRefresh: true,
-        deferredBalanceRefresh: true,
-        firstTxCount: cachedTransferCount
-      });
-      await waits.delay(BOOT_CACHED_REFRESH_DELAY_MS);
-      if (closed)
+      starting = true;
+      await waits.delay(BOOT_CACHE_DECISION_DELAY_MS);
+      await waits.idle({ timeout: BOOT_REFRESH_DELAY_MS, delay: BOOT_REFRESH_DELAY_MS });
+      if (!isOpen())
         return;
-      if (typeof deferBackgroundWork === "function") {
+      if (getTransferState().txReady)
+        await waits.delay(BOOT_CACHED_REFRESH_DELAY_MS);
+      if (!isOpen())
+        return;
+      if (deferBackgroundWork)
         await deferBackgroundWork("wallet.boot.refresh", { signal: backgroundSignal });
-      } else {
-        await waits.idle({ timeout: BOOT_REFRESH_DELAY_MS, delay: BOOT_REFRESH_DELAY_MS });
-      }
-      if (closed)
+      if (!isOpen())
         return;
-      const refreshStartedAt = Date.now();
-      markDiag(diag, "wallet.provider.boot.refresh.start", { balance: true, transfers: true });
-      try {
-        const [, recent] = await Promise.all([getBalance(), getRecentTxs({ force: true, includePending: false, reason: "boot-cache" })]);
-        markDone(diag, "wallet.provider.boot.refresh", refreshStartedAt, {
-          balance: true,
-          transfers: true,
-          count: recent?.transfers?.length || 0
-        });
-      } catch (error) {
-        markError(diag, "wallet.provider.boot.refresh", refreshStartedAt, error);
-      }
-      return;
-    }
-    if (typeof deferBackgroundWork === "function") {
-      await deferBackgroundWork("wallet.boot.initial", { signal: backgroundSignal });
-    }
-    if (closed) {
-      markDone(diag, "wallet.provider.boot", startedAt, { cancelled: true });
-      return;
-    }
-    const [, firstTxPage] = await Promise.all([getBalance(), getRecentTxs({ reason: "boot", includePending: false })]);
-    markDone(diag, "wallet.provider.boot", startedAt, {
-      cancelled: closed,
-      cachedTxReady: false,
-      deferredTxRefresh: false,
-      firstTxCount: firstTxPage?.transfers?.length || 0,
-      firstTxHasMore: !!firstTxPage?.hasMore,
-      cachedHistoryComplete: firstTxPage?.cachedHistoryComplete === true,
-      reconcileCount: Array.isArray(firstTxPage?.reconcileIds) ? firstTxPage.reconcileIds.length : 0
-    });
-  };
-  if (wallet) {
-    boot();
-  }
-  return {
+      started = true;
+      const now = Date.now();
+      pendingAt = now + POLL_TXS_RATE;
+      repairAt = now + WALLET_TRANSFER_REPAIR_MS;
+      depositAt = now + depositRate;
+      await request({ history: true, pending: true, reason: "boot" });
+    },
     close() {
-      if (closed)
-        return;
       closed = true;
+      queued = null;
+      finishWaiters();
       waits.close();
-      markDiag(diag, "wallet.provider.boot.stop", {});
-      stopPoll();
+      clearTimeout(timer);
+      subscription?.remove?.();
     }
   };
 }
@@ -56009,18 +55839,6 @@ function createWalletPrivacy({ wallet, ghostWallet, diag }) {
   };
 }
 
-// ../../core/wallet/history.js
-function transferPage(page, currentOffset, limit) {
-  const transfers = Array.isArray(page?.transfers) ? page.transfers : [];
-  const returnedOffset = Number(page?.offset);
-  const nextOffset = Number.isFinite(returnedOffset) && returnedOffset > currentOffset ? returnedOffset : currentOffset + transfers.length;
-  return {
-    transfers,
-    nextOffset,
-    hasMore: transfers.length >= limit
-  };
-}
-
 // ../../core/wallet/transferdata.js
 var RECENT_TRANSFER_LIMIT = WALLET_RECENT_TRANSFER_LIMIT;
 var TRANSFER_PAGE_LIMIT = WALLET_TRANSFER_PAGE_LIMIT;
@@ -56191,16 +56009,6 @@ function getOldestTransferMs(transfers = []) {
   }
   return oldest;
 }
-function getOldestAnyTransferMs(transfers = []) {
-  let oldest = null;
-  for (const tx of transfers) {
-    const ms = txCreatedMs(tx);
-    if (!ms)
-      continue;
-    oldest = oldest == null ? ms : Math.min(oldest, ms);
-  }
-  return oldest;
-}
 function shouldReplaceTransfer(current, next) {
   return isPendingTransfer(current) && (!isPendingTransfer(next) || current?.status !== next?.status || txUpdatedMs(next) > txUpdatedMs(current));
 }
@@ -56463,14 +56271,6 @@ function reconciliationDue(owner, transfer, id, now) {
   const retryMs = getPendingTransferRetryMs(transfer, ageMs, owner.unresolvedCount.get(id) || 0);
   return retryMs <= 0 || now - lastAttemptAt >= retryMs;
 }
-async function stillPendingTransferIds(wallet, ids = []) {
-  const selectedIds = transferIds2(ids);
-  if (!selectedIds.length || typeof wallet?.transferService?.queryPendingTransfers !== "function")
-    return new Set;
-  const requestedIds = new Set(selectedIds);
-  const page = await wallet.transferService.queryPendingTransfers.call(wallet.transferService, selectedIds);
-  return new Set((Array.isArray(page?.transfers) ? page.transfers : []).map((transfer) => String(transfer?.id || "")).filter((id) => id && requestedIds.has(id)));
-}
 function normalizeCursor(owner, transfers = owner.snapshot.getTransfers()) {
   const count = pendingTransferIds(transfers).length;
   if (!count) {
@@ -56571,8 +56371,10 @@ async function refreshRequestedTransfers(owner, ids = []) {
   const requestedIds = transferIds2(ids);
   if (!requestedIds.length)
     return [];
-  for (const id of requestedIds)
+  for (const id of requestedIds) {
     owner.requestedIds.add(id);
+    owner.hydrationDue.set(id, Date.now() + WALLET_TRANSFER_POLL_MS);
+  }
   if (owner.requestedPromise) {
     markDiag(owner.diag, "wallet.pendingTxs.requested.queue", { count: requestedIds.length });
     return owner.requestedPromise;
@@ -56580,56 +56382,44 @@ async function refreshRequestedTransfers(owner, ids = []) {
   const run = async () => {
     let latestTransfers = [];
     while (isCurrentGeneration(owner, generation) && owner.requestedIds.size) {
-      const batchIds = [...owner.requestedIds];
-      owner.requestedIds.clear();
+      const batchIds = [...owner.requestedIds].slice(0, COLD_BATCH_SIZE);
+      for (const id of batchIds)
+        owner.requestedIds.delete(id);
       const batchIdSet = new Set(batchIds);
       const startedAt = Date.now();
       markDiag(owner.diag, "wallet.pendingTxs.requested.start", { requested: batchIds.length });
       try {
         const baseTransfers = owner.snapshot.getTransfers();
         const baseById = new Map(baseTransfers.map((transfer) => [String(transfer?.id || ""), transfer]));
-        let pages = 0;
-        let pageTransfers = [];
-        let fetchedTransfers = await owner.reads.byIds(batchIds);
+        const fetchedTransfers = await owner.reads.byIds(batchIds);
         if (!isCurrentGeneration(owner, generation))
           return [];
-        if (!fetchedTransfers) {
-          if (batchIds.length === 1) {
-            const transfer = await owner.reads.byId(batchIds[0]);
-            fetchedTransfers = transfer ? [transfer] : [];
-          } else {
-            const result = await owner.reads.recentPages(batchIds, baseTransfers);
-            pages = result.pages;
-            pageTransfers = result.transfers;
-            fetchedTransfers = pageTransfers;
-          }
-        }
-        if (!isCurrentGeneration(owner, generation))
-          return [];
-        const updates = fetchedTransfers.map((transfer) => {
+        const updates = fetchedTransfers.filter((transfer) => batchIdSet.has(String(transfer?.id)) && transferBelongsToWallet(compactTransfer(transfer), owner.walletPK)).map((transfer) => {
           const id = String(transfer?.id || "");
           const current = id ? baseById.get(id) : null;
           return current?.transferDirection && !transfer?.transferDirection ? { ...transfer, transferDirection: current.transferDirection } : transfer;
         });
         forgetResolvedFetched(owner, updates);
-        const nextTransfers = updates.length ? mergeTransferPageForWallet(baseTransfers, updates, owner.walletPK, "append") : baseTransfers;
+        const currentTransfers = owner.snapshot.getTransfers();
+        const nextTransfers = updates.length ? overlayPending(owner, mergeTransferPageForWallet(currentTransfers, updates, owner.walletPK, "append")) : currentTransfers;
         const requestedTransfers = nextTransfers.filter((transfer) => batchIdSet.has(String(transfer?.id || "")));
         const claimCandidates = owner.claims.candidates(pendingIncomingTransfers(requestedTransfers));
         const resolvedIds = requestedTransfers.filter((transfer) => !isPendingTransfer(transfer)).map((transfer) => String(transfer.id));
         forgetPending(owner, resolvedIds);
-        if (nextTransfers !== baseTransfers) {
+        if (nextTransfers !== currentTransfers) {
           await owner.snapshot.commitConfirmed(requestedTransfers.filter((transfer) => !isPendingTransfer(transfer)), { position: "prepend" });
           if (!isCurrentGeneration(owner, generation))
             return [];
-          owner.snapshot.replace(nextTransfers);
+          owner.snapshot.replace(mergeTransferPageForWallet(owner.snapshot.getTransfers(), updates, owner.walletPK, "append"));
           owner.snapshot.setReady();
         }
+        for (const transfer of updates)
+          owner.hydrationDue.delete(String(transfer.id));
         if (claimCandidates.length)
           owner.claims.enqueue(claimCandidates, "requested");
         markDone(owner.diag, "wallet.pendingTxs.requested", startedAt, {
           requested: batchIds.length,
-          pages,
-          pageCount: pageTransfers.length,
+          pages: 0,
           updateCount: updates.length,
           found: requestedTransfers.length,
           resolved: resolvedIds.length,
@@ -56654,7 +56444,7 @@ async function refreshRequestedTransfers(owner, ids = []) {
   owner.requestedPromise = request;
   return request;
 }
-function planPendingReconciliation(owner, { startedAt, cold, reason }) {
+function planPendingReconciliation(owner, { startedAt, cold, reason, force }) {
   const previousTransfers = owner.snapshot.getTransfers();
   const pendingList = pendingTransfers(previousTransfers);
   const pendingById = syncReconciliationAges(owner, pendingList, startedAt);
@@ -56666,11 +56456,13 @@ function planPendingReconciliation(owner, { startedAt, cold, reason }) {
     const transfer = pendingById.get(id);
     if (cold && transfer && isIncomingTransfer(transfer))
       return false;
+    if (force)
+      return true;
     if (bootGraceActive && transfer && !owner.rememberedIds.has(id) && !isIncomingTransfer(transfer))
       return false;
     return reconciliationDue(owner, transfer, id, startedAt);
   });
-  const limit = Math.min(cold ? COLD_BATCH_SIZE : STATUS_BATCH_SIZE, candidateIds.length);
+  const limit = Math.min(cold || force ? COLD_BATCH_SIZE : STATUS_BATCH_SIZE, candidateIds.length);
   const selectedIds = rotateIds(candidateIds, owner.cursor, limit);
   if (candidateIds.length)
     owner.cursor = (owner.cursor + selectedIds.length) % candidateIds.length;
@@ -56699,58 +56491,45 @@ async function readPendingReconciliation(owner, plan, generation) {
   const baseTransfers = currentTransfers.length ? currentTransfers : plan.previousTransfers;
   const baseById = new Map(baseTransfers.map((transfer) => [String(transfer?.id || ""), transfer]));
   const resolvedIds = [];
-  const completedOverlayIds = [];
   const updates = [];
-  let actualChecked = 0;
   let unresolvedOutgoing = 0;
   let maxUnresolvedCount = 0;
-  if (plan.incomingIds.length) {
-    const stillPending = await stillPendingTransferIds(owner.wallet, plan.incomingIds);
-    if (!isCurrentGeneration(owner, generation))
-      return null;
-    const resolvedIncoming = plan.incomingIds.filter((id) => !stillPending.has(id));
-    resolvedIds.push(...resolvedIncoming);
-    completedOverlayIds.push(...resolvedIncoming);
-  }
-  if (plan.outgoingIds.length) {
-    const fetched = await owner.reads.byIds(plan.outgoingIds, { fallbackToSingles: true }) || [];
-    if (!isCurrentGeneration(owner, generation))
-      return null;
-    actualChecked = fetched.length;
-    const fetchedById = new Map(fetched.map((transfer) => [String(transfer?.id || ""), transfer]));
-    for (const id of plan.outgoingIds) {
-      const transfer = fetchedById.get(id);
-      if (!transfer)
-        continue;
-      const current = baseById.get(id);
-      const update = current?.transferDirection && !transfer?.transferDirection ? { ...transfer, transferDirection: current.transferDirection } : transfer;
-      updates.push(update);
-      if (!isPendingTransfer(update)) {
-        resolvedIds.push(id);
-        owner.unresolvedCount.delete(id);
-      } else {
-        const count = (owner.unresolvedCount.get(id) || 0) + 1;
-        owner.unresolvedCount.set(id, count);
-        unresolvedOutgoing += 1;
-        maxUnresolvedCount = Math.max(maxUnresolvedCount, count);
-      }
+  const fetched = await owner.reads.byIds(plan.selectedIds);
+  if (!isCurrentGeneration(owner, generation))
+    return null;
+  const actualChecked = fetched.length;
+  const selected = new Set(plan.selectedIds);
+  for (const transfer of fetched) {
+    const id = String(transfer?.id || "");
+    if (!selected.has(id) || !transferBelongsToWallet(compactTransfer(transfer), owner.walletPK))
+      continue;
+    const current = baseById.get(id);
+    const update = current?.transferDirection && !transfer?.transferDirection ? { ...transfer, transferDirection: current.transferDirection } : transfer;
+    updates.push(update);
+    if (!isPendingTransfer(update)) {
+      resolvedIds.push(id);
+      owner.unresolvedCount.delete(id);
+    } else if (!isIncomingTransfer(update)) {
+      const count = (owner.unresolvedCount.get(id) || 0) + 1;
+      owner.unresolvedCount.set(id, count);
+      unresolvedOutgoing += 1;
+      maxUnresolvedCount = Math.max(maxUnresolvedCount, count);
     }
   }
-  return { baseTransfers, resolvedIds, completedOverlayIds, updates, actualChecked, unresolvedOutgoing, maxUnresolvedCount };
+  return { resolvedIds, updates, actualChecked, unresolvedOutgoing, maxUnresolvedCount };
 }
 async function commitPendingReconciliation(owner, plan, result, generation) {
   if (!result || !isCurrentGeneration(owner, generation))
     return null;
-  let nextTransfers = result.updates.length ? mergeTransferPageForWallet(result.baseTransfers, result.updates, owner.walletPK, "append") : result.baseTransfers;
+  const current = owner.snapshot.getTransfers();
+  const nextTransfers = result.updates.length ? overlayPending(owner, mergeTransferPageForWallet(current, result.updates, owner.walletPK, "append")) : current;
   forgetPending(owner, result.resolvedIds);
-  if (result.completedOverlayIds.length)
-    nextTransfers = markClaimedTransfersCompleted(nextTransfers, result.completedOverlayIds);
-  if (nextTransfers !== result.baseTransfers) {
+  if (nextTransfers !== current) {
     const selectedIds = new Set(plan.selectedIds);
     await owner.snapshot.commitConfirmed(nextTransfers.filter((transfer) => selectedIds.has(String(transfer?.id)) && !isPendingTransfer(transfer)), { position: "prepend" });
     if (!isCurrentGeneration(owner, generation))
       return null;
-    owner.snapshot.replace(nextTransfers);
+    owner.snapshot.replace(mergeTransferPageForWallet(owner.snapshot.getTransfers(), result.updates, owner.walletPK, "append"));
     owner.snapshot.setReady();
   }
   markDone(owner.diag, "wallet.pendingTxs.reconcile", plan.startedAt, {
@@ -56787,7 +56566,7 @@ async function reconcilePendingTransfers(owner, options = {}, generation = owner
   }
   if (cold)
     owner.coldRefreshAt = startedAt;
-  const plan = planPendingReconciliation(owner, { startedAt, cold, reason });
+  const plan = planPendingReconciliation(owner, { startedAt, cold, reason, force: options.force === true });
   if (!plan.selectedIds.length)
     return [];
   if (!await owner.waitForWork("pending-reconcile", plan.eagerOutgoing ? { waitForSdkQuiet: false, idleMs: 0 } : undefined) || !isCurrentGeneration(owner, generation))
@@ -56821,29 +56600,38 @@ function refreshPending(owner, ids = null, options = {}) {
   const requestedIds = transferIds2(ids);
   if (requestedIds.length)
     return refreshRequestedTransfers(owner, requestedIds);
-  if (owner.claims.isActive())
-    return Promise.resolve([]);
-  const queuedClaims = owner.claims.queuedCount();
-  if (owner.isPendingQuery() || queuedClaims) {
-    markDiag(owner.diag, "wallet.pendingTxs.reconcile.defer", {
-      reason: owner.isPendingQuery() ? "pending-query" : "claim-queue",
-      queued: queuedClaims
-    });
-    return Promise.resolve([]);
-  }
   if (owner.promise) {
     owner.queuedAll = true;
+    owner.queuedForce ||= options.force === true;
     return owner.promise;
   }
-  const request = reconcilePendingTransfers(owner, options, generation).finally(() => {
+  const run = async () => {
+    const dueIds = [...owner.hydrationDue].filter(([, due]) => options.force === true || due <= Date.now()).map(([id]) => id);
+    if (dueIds.length)
+      await refreshRequestedTransfers(owner, dueIds);
+    if (!isCurrentGeneration(owner, generation) || owner.claims.isActive())
+      return [];
+    const queuedClaims = owner.claims.queuedCount();
+    if (owner.isPendingQuery() || queuedClaims) {
+      markDiag(owner.diag, "wallet.pendingTxs.reconcile.defer", {
+        reason: owner.isPendingQuery() ? "pending-query" : "claim-queue",
+        queued: queuedClaims
+      });
+      return [];
+    }
+    return reconcilePendingTransfers(owner, options, generation);
+  };
+  const request = run().finally(() => {
     if (owner.promise === request)
       owner.promise = null;
     if (!isCurrentGeneration(owner, generation))
       return;
     const queuedAll = owner.queuedAll;
+    const force = owner.queuedForce;
     owner.queuedAll = false;
+    owner.queuedForce = false;
     if (queuedAll)
-      refreshPending(owner);
+      refreshPending(owner, null, { force });
   });
   owner.promise = request;
   return request;
@@ -56868,9 +56656,11 @@ function createPendingTransferReconciliation({ wallet, walletPK, outgoingSettleM
     attemptAt: new Map,
     unresolvedCount: new Map,
     requestedIds: new Set,
+    hydrationDue: new Map,
     requestedPromise: null,
     promise: null,
     queuedAll: false,
+    queuedForce: false,
     cursor: 0,
     coldRefreshAt: 0,
     graceUntil: 0,
@@ -56883,9 +56673,11 @@ function createPendingTransferReconciliation({ wallet, walletPK, outgoingSettleM
     owner.attemptAt.clear();
     owner.unresolvedCount.clear();
     owner.requestedIds.clear();
+    owner.hydrationDue.clear();
     owner.requestedPromise = null;
     owner.promise = null;
     owner.queuedAll = false;
+    owner.queuedForce = false;
     owner.cursor = 0;
     owner.coldRefreshAt = 0;
     owner.graceUntil = 0;
@@ -56901,11 +56693,24 @@ function createPendingTransferReconciliation({ wallet, walletPK, outgoingSettleM
     startBootGrace() {
       owner.graceUntil = Date.now() + WALLET_PENDING_TRANSFER_BOOT_GRACE_MS;
     },
+    hasRequestedTransfers: () => owner.hydrationDue.size > 0,
     refresh: (ids, options) => refreshPending(owner, ids, options),
     reset
   });
 }
 
+// ../../core/wallet/history.js
+function transferPage(page, currentOffset, limit) {
+  const transfers = Array.isArray(page?.transfers) ? page.transfers : [];
+  const returnedOffset = Number(page?.offset);
+  const nextOffset = Number.isFinite(returnedOffset) && returnedOffset > currentOffset ? returnedOffset : currentOffset + transfers.length;
+  return {
+    transfers,
+    nextOffset,
+    hasMore: transfers.length >= limit
+  };
+}
+
 // ../../core/wallet/transferhistorysync.js
 function isCurrentGeneration2(owner, generation) {
   return owner.generation === generation && !owner.isClosed();
@@ -58272,9 +58077,7 @@ function createWalletHistoryStore() {
 // ../../core/wallet/transfers.js
 var TRANSFER_FETCH_THROTTLE_MS = WALLET_TRANSFER_FETCH_THROTTLE_MS;
 var PENDING_TRANSFER_QUERY_PAGE_SIZE = TRANSFER_PAGE_LIMIT;
-var PENDING_TRANSFER_RECONCILE_PAGE_SIZE = TRANSFER_PAGE_LIMIT;
 var SDK_BACKGROUND_QUIET_MS = Math.max(0, WALLET_SDK_BACKGROUND_QUIET_MS);
-var PENDING_TRANSFER_RECONCILE_MAX_PAGES = 5;
 var PENDING_TRANSFER_CLAIM_RETRY_MS = WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS;
 var PENDING_TRANSFER_OUTGOING_SETTLE_MS = PENDING_TRANSFER_CLAIM_RETRY_MS;
 async function getPendingIncomingTransfers(wallet, diag) {
@@ -58487,72 +58290,16 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
     }
     return queueWalletFetch(() => wallet.getTransfer(String(transferId2)));
   };
-  const fetchTransfersByIds = async (ids, { fallbackToSingles = false } = {}) => {
+  const fetchTransfersByIds = async (ids) => {
     const transferIds3 = uniqueIds(ids);
-    if (!transferIds3.length) {
+    if (!transferIds3.length)
       return [];
-    }
-    if (typeof wallet?.transferService?.getTransfersByIds !== "function") {
-      if (!fallbackToSingles) {
-        return null;
-      }
-      const transfers = [];
-      for (const transferId2 of transferIds3) {
-        const tx = await fetchTransferById(transferId2);
-        if (tx) {
-          transfers.push(tx);
-        }
-      }
-      return transfers;
-    }
     return queueWalletFetch(async () => {
-      const fetched = await wallet.transferService.getTransfersByIds.call(wallet.transferService, transferIds3);
-      if (typeof wallet.constructTransfersWithUserRequest === "function") {
-        return wallet.constructTransfersWithUserRequest(fetched);
-      }
-      return Array.isArray(fetched) ? fetched : [];
+      const client = await wallet.connectionManager.createSparkClient(wallet.config.getCoordinatorAddress());
+      const result = await client.query_transfers_by_id({ transferIds: transferIds3, network: wallet.config.getNetworkProto() });
+      return wallet.constructTransfersWithUserRequest(result.transfers);
     });
   };
-  const fetchRecentTransferPagesForIds = async (ids, baseTransfers = [], { maxPages = PENDING_TRANSFER_RECONCILE_MAX_PAGES, pageSize = PENDING_TRANSFER_RECONCILE_PAGE_SIZE } = {}) => {
-    const requestedIds = uniqueIds(ids);
-    if (!requestedIds.length) {
-      return { transfers: [], foundIds: [], pages: 0, pageCount: 0 };
-    }
-    const requestedSet = new Set(requestedIds);
-    const baseById = new Map(baseTransfers.map((tx) => [String(tx?.id || ""), tx]));
-    const targetTransfers = requestedIds.map((id) => baseById.get(id)).filter(Boolean);
-    const oldestTargetMs = getOldestAnyTransferMs(targetTransfers);
-    const foundIds = new Set;
-    const transfers = [];
-    let offset = 0;
-    let pages = 0;
-    let pageCount = 0;
-    while (pages < maxPages && foundIds.size < requestedSet.size) {
-      const page = transferPage(await fetchTransfersPage(pageSize, offset), offset, pageSize);
-      const pageTransfers = page.transfers;
-      pages += 1;
-      pageCount += pageTransfers.length;
-      transfers.push(...pageTransfers);
-      for (const tx of pageTransfers) {
-        const id = String(tx?.id || "");
-        if (requestedSet.has(id)) {
-          foundIds.add(id);
-        }
-      }
-      if (!page.hasMore) {
-        break;
-      }
-      const oldestPageMs = getOldestAnyTransferMs(pageTransfers);
-      if (oldestTargetMs != null && oldestPageMs != null && oldestPageMs < oldestTargetMs) {
-        break;
-      }
-      if (page.nextOffset <= offset) {
-        break;
-      }
-      offset = page.nextOffset;
-    }
-    return { transfers, foundIds: [...foundIds], pages, pageCount };
-  };
   const getPendingTransfersSnapshot = () => {
     if (!wallet) {
       return Promise.resolve([]);
@@ -58607,9 +58354,7 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
       setReady: () => setTxReadyValue(true)
     },
     reads: {
-      byId: fetchTransferById,
-      byIds: fetchTransfersByIds,
-      recentPages: fetchRecentTransferPagesForIds
+      byIds: fetchTransfersByIds
     },
     claims: incomingClaims,
     waitForWork: waitForBackgroundWorkSlot,
@@ -58802,6 +58547,7 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
       serverHistoryComplete: historyComplete,
       hasMoreTxs: !historyComplete,
       hasPendingTxs,
+      hasRequestedTransfers: pendingReconciliation.hasRequestedTransfers,
       hasPendingIncomingTxs: pendingIncomingTransfers(transfers).length > 0,
       beginSdkActivity,
       getRecentTxs,
@@ -58849,7 +58595,6 @@ function createWalletTransferSession({ wallet, walletPK, claimIncomingTransfers,
 }
 
 // ../../core/wallet/session.js
-var NOOP5 = () => {};
 var ASYNC_NOOP = async () => null;
 var ASYNC_FALSE = async () => false;
 var EMPTY_COVERAGE = async () => ({ loaded: 0, historyComplete: false });
@@ -58902,7 +58647,6 @@ function createEmptyWalletSessionSnapshot(network, transferSnapshot = null, cach
       isWalletDataReady: false,
       isWalletDataLoaded: cachedDataReady || cachedBalance != null,
       refresh: ASYNC_NOOP,
-      setTransferDiscoveryVisible: NOOP5,
       claimDeposits: ASYNC_FALSE,
       getFundingAddress: ASYNC_NOOP,
       preparePayment: WALLET_NOT_READY,
@@ -58935,7 +58679,6 @@ function createWalletSession({
   network,
   claimIncomingTransfers = null,
   pendingClaimBatchSize = null,
-  activeTransferRefreshMs = null,
   eagerOutgoingStatusRefresh = false,
   sentTransferRefreshDelayMs = null,
   deferBackgroundWork = null,
@@ -58958,7 +58701,7 @@ function createWalletSession({
   let publishedSnapshot = null;
   const valueSubscriptions = createFieldSubscriptions(() => publishedSnapshot?.value);
   const txSubscriptions = createFieldSubscriptions(() => publishedSnapshot?.txValue);
-  let polling = null;
+  let reconciliation = null;
   let readyDiag = null;
   let refreshWalletBalance = null;
   const transferSession = createWalletTransferSession({
@@ -58980,7 +58723,7 @@ function createWalletSession({
       return;
     const nextSnapshot = buildSnapshot();
     readyDiag?.sync();
-    polling?.sync();
+    reconciliation?.sync();
     if (publishedSnapshot && nextSnapshot.value === publishedSnapshot.value && nextSnapshot.txValue === publishedSnapshot.txValue) {
       return;
     }
@@ -59010,17 +58753,16 @@ function createWalletSession({
   });
   const claims = createDepositClaims({
     wallet,
-    updateWalletData,
     diag
   });
-  polling = createWalletPolling({
-    wallet,
+  reconciliation = createWalletReconciliation({
     network,
     appState,
     getTransferState,
-    getBalanceState: balance.getSnapshot,
-    refreshClaims: claims.refreshClaims,
-    activeTransferRefreshMs,
+    updateWalletData,
+    deferBackgroundWork,
+    backgroundSignal: backgroundAbort.signal,
+    claimDeposits: claims.claimDeposits,
     diag
   });
   readyDiag = createWalletReadyDiag({
@@ -59031,9 +58773,9 @@ function createWalletSession({
   });
   const events = createWalletEvents({
     wallet,
-    updateWalletData,
     getTransferState,
-    setBalance: balance.setBalance,
+    reconcile: reconciliation.request,
+    sync: reconciliation.sync,
     setTokenBalances: balance.setTokenBalances,
     setSatsBalanceResult: balance.setSatsBalanceResult,
     diag
@@ -59077,8 +58819,7 @@ function createWalletSession({
       isBalanceLoading: balanceState.isBalanceLoading,
       isWalletDataReady: true,
       isWalletDataLoaded: balanceState.balanceReady || currentTransferState.txReady,
-      refresh: claims.refresh,
-      setTransferDiscoveryVisible: polling.setTransferDiscoveryVisible,
+      refresh: reconciliation.refresh,
       claimDeposits: claims.claimDeposits,
       getFundingAddress: funding.getFundingAddress,
       preparePayment: mutationActions.preparePayment,
@@ -59110,17 +58851,8 @@ function createWalletSession({
   const unsubscribeTransfers = transferSession.subscribe(publish);
   publishedSnapshot = buildSnapshot();
   readyDiag.sync();
-  polling.sync();
-  const boot = createWalletBoot({
-    wallet,
-    getTransferState,
-    getBalance: balance.getBalance,
-    getRecentTxs: transferState.getRecentTxs,
-    deferBackgroundWork,
-    backgroundSignal: backgroundAbort.signal,
-    stopPoll: polling.stopPoll,
-    diag
-  });
+  reconciliation.sync();
+  reconciliation.start();
   return {
     wallet,
     walletPK,
@@ -59144,9 +58876,8 @@ function createWalletSession({
         return;
       closed = true;
       backgroundAbort.abort();
-      boot.close();
       events.close();
-      polling.close();
+      reconciliation.close();
       privacy.close();
       mutations.close();
       payment.close();
@@ -59771,7 +59502,7 @@ function getPeerDataFromTransfers(transfers, walletPK, peerPK) {
   txs.sort(byRecentTx);
   return { txs, stats: stats.cnt ? stats : null };
 }
-var NOOP6 = () => {};
+var NOOP5 = () => {};
 var EMPTY_TX_DATA_SOURCES = Object.freeze({
   balance: null,
   walletPK: null,
@@ -59803,8 +59534,8 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
   let snapshot = null;
   let observedStoreSnapshot = null;
   let observedHistorySnapshot = null;
-  let unsubscribeStore = NOOP6;
-  let unsubscribeHistory = NOOP6;
+  let unsubscribeStore = NOOP5;
+  let unsubscribeHistory = NOOP5;
   let closed = false;
   function readCurrentAggregatedData(walletPK) {
     const transfers = transferStore.getSnapshot().transfers;
@@ -60139,7 +59870,7 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
     },
     subscribe(listener) {
       if (closed || typeof listener !== "function")
-        return NOOP6;
+        return NOOP5;
       if (!listeners.size) {
         if (!deferAggregation) {
           unsubscribeStore = transferStore.subscribe(() => rebuild());
@@ -60159,8 +59890,8 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
           return;
         unsubscribeStore();
         unsubscribeHistory();
-        unsubscribeStore = NOOP6;
-        unsubscribeHistory = NOOP6;
+        unsubscribeStore = NOOP5;
+        unsubscribeHistory = NOOP5;
       };
     },
     setSources,
@@ -60170,8 +59901,8 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
       closed = true;
       unsubscribeStore();
       unsubscribeHistory();
-      unsubscribeStore = NOOP6;
-      unsubscribeHistory = NOOP6;
+      unsubscribeStore = NOOP5;
+      unsubscribeHistory = NOOP5;
       listeners.clear();
       seriesCache.current.clear();
       historySeriesCache.current.clear();
@@ -60180,7 +59911,7 @@ function createTxData({ transferStore, historyStore, diag = null, deferAggregati
 }
 
 // src/wallet.js
-var NOOP7 = () => {};
+var NOOP6 = () => {};
 var ACTIVE_APP_STATE = Object.freeze({
   currentState: "active",
   addEventListener() {
@@ -60232,8 +59963,8 @@ function openWallet(options = {}) {
   let cachedBalance = null;
   let peerCache = { transfers: null, historyGeneration: -1, walletPK: "", value: {} };
   let sessionOwner = null;
-  let releaseSessionOwner = NOOP7;
-  let stopSessionOwner = NOOP7;
+  let releaseSessionOwner = NOOP6;
+  let stopSessionOwner = NOOP6;
   let snapshot = createEmptyWalletSessionSnapshot(initialNetwork, transferStore.getSnapshot(), null, historyStore.getSnapshot());
   function syncTransactions() {
     transactions.setSources({
@@ -60267,8 +59998,8 @@ function openWallet(options = {}) {
   function detachSessionOwner() {
     const stop = stopSessionOwner;
     const release = releaseSessionOwner;
-    stopSessionOwner = NOOP7;
-    releaseSessionOwner = NOOP7;
+    stopSessionOwner = NOOP6;
+    releaseSessionOwner = NOOP6;
     sessionOwner = null;
     stop();
     release();
@@ -60284,7 +60015,6 @@ function openWallet(options = {}) {
       network: sources.network,
       claimIncomingTransfers: options.claimIncomingTransfers || claimIncomingTransfersById,
       pendingClaimBatchSize: options.pendingClaimBatchSize,
-      activeTransferRefreshMs: options.activeTransferRefreshMs,
       eagerOutgoingStatusRefresh: options.eagerOutgoingStatusRefresh === true,
       sentTransferRefreshDelayMs: options.sentTransferRefreshDelayMs,
       deferBackgroundWork: options.deferBackgroundWork || null,
@@ -60345,7 +60075,7 @@ function openWallet(options = {}) {
     },
     subscribe(listener) {
       if (closed || typeof listener !== "function")
-        return NOOP7;
+        return NOOP6;
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
@@ -60508,7 +60238,7 @@ function createAccountOperationCloseBarrier() {
 }
 
 // src/account.js
-var NOOP8 = () => {};
+var NOOP7 = () => {};
 function vaultPasswordChangeError(code, message, cause = null) {
   const error = new Error(message);
   error.code = `vault-password/${code}`;
@@ -60566,7 +60296,7 @@ function openAccount(options = {}) {
   let closed = false;
   let attempt = 0;
   let foreground = true;
-  let stopVault = NOOP8;
+  let stopVault = NOOP7;
   let syncingUser = false;
   let closePromise = null;
   let state;
@@ -60593,7 +60323,7 @@ function openAccount(options = {}) {
     revokedUid = accountUid;
     bootstrapGeneration += 1;
     if (accountUid && options.bootstrapStorage) {
-      bootstrapWriteTail = bootstrapWriteTail.catch(NOOP8).then(() => options.bootstrapStorage.remove(accountUid));
+      bootstrapWriteTail = bootstrapWriteTail.catch(NOOP7).then(() => options.bootstrapStorage.remove(accountUid));
       bootstrapWriteTail.catch((error) => diag?.("account.bootstrap.remove.error", { code: error?.code || "" }));
     }
     let callback;
@@ -60979,7 +60709,7 @@ function openAccount(options = {}) {
   }
   function watchVault(uid) {
     stopVault();
-    stopVault = NOOP8;
+    stopVault = NOOP7;
     if (!uid)
       return;
     const startedAt = Date.now();
@@ -61057,11 +60787,11 @@ function openAccount(options = {}) {
       bootstrapGeneration += 1;
       lastBootstrap = "";
       if (previousUid && !uid && options.bootstrapStorage) {
-        bootstrapWriteTail = bootstrapWriteTail.catch(NOOP8).then(() => options.bootstrapStorage.remove(previousUid));
+        bootstrapWriteTail = bootstrapWriteTail.catch(NOOP7).then(() => options.bootstrapStorage.remove(previousUid));
         bootstrapWriteTail.catch((error) => diag?.("account.bootstrap.remove.error", { code: error?.code || "" }));
       }
       stopVault();
-      stopVault = NOOP8;
+      stopVault = NOOP7;
       closeSession({ notify: false });
       user.setNetwork(defaultNetwork);
       const currentUser = user.getSnapshot();
@@ -61126,7 +60856,7 @@ function openAccount(options = {}) {
     lastBootstrap = serialized;
     const uid = state.uid;
     const generation = bootstrapGeneration;
-    bootstrapWriteTail = bootstrapWriteTail.catch(NOOP8).then(() => {
+    bootstrapWriteTail = bootstrapWriteTail.catch(NOOP7).then(() => {
       if (closed || generation !== bootstrapGeneration || state.uid !== uid)
         return;
       return options.bootstrapStorage.write(uid, value);
@@ -61551,7 +61281,7 @@ function openAccount(options = {}) {
     getSnapshot: () => state,
     subscribe(listener) {
       if (typeof listener !== "function")
-        return NOOP8;
+        return NOOP7;
       listeners.add(listener);
       return () => listeners.delete(listener);
     },