@owney/sdk 0.7.25-beta.10 → 0.7.25-beta.11

package/dist/index.js

@@ -1,3 +1,93 @@
+// src/lib/funding-evidence.ts
+import { decodeEventLog, decodeFunctionData, erc20Abi, parseAbi } from "viem";
+function notifyFunding(callback, evidence) {
+  try {
+    void Promise.resolve(callback?.({ ...evidence })).catch(() => {
+    });
+  } catch {
+  }
+}
+var fullWithdrawalAbi = parseAbi(["function withdrawAllAssetToUser(address recipient, address asset)"]);
+var withdrawalEventAbi = parseAbi(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
+function isFullYieldseekerWithdrawal(transaction, evidence, tokenAddress) {
+  if (evidence.agentId !== "yieldseeker" || transaction.chainId !== evidence.chainId || transaction.hash.toLowerCase() !== evidence.txHash?.toLowerCase() || transaction.to?.toLowerCase() !== evidence.agentWallet?.toLowerCase() || transaction.from.toLowerCase() !== evidence.walletAddress.toLowerCase()) return false;
+  try {
+    const decoded = decodeFunctionData({ abi: fullWithdrawalAbi, data: transaction.input });
+    return decoded.args[0].toLowerCase() === evidence.walletAddress.toLowerCase() && decoded.args[1].toLowerCase() === tokenAddress.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function inspectFundingReceipt(receipt, evidence, tokenAddress, direction) {
+  if (receipt.status !== "success") return { ...evidence, transfer: "failed", delivery: "failed" };
+  let amount = 0n;
+  const seen = /* @__PURE__ */ new Set();
+  const attributed = /* @__PURE__ */ new Map();
+  const agent = evidence.agentWallet?.toLowerCase();
+  const owner = evidence.walletAddress.toLowerCase();
+  const logIndexes = [];
+  const transferLogs = [];
+  const zeroTransferLogs = [];
+  for (const log of [...receipt.logs].sort((a, b) => a.logIndex - b.logIndex)) {
+    if (log.address.toLowerCase() !== tokenAddress.toLowerCase()) continue;
+    if (seen.has(log.logIndex)) continue;
+    seen.add(log.logIndex);
+    try {
+      const event = decodeEventLog({ abi: erc20Abi, data: log.data, topics: log.topics });
+      if (event.eventName !== "Transfer") continue;
+      const { from, to, value } = event.args;
+      if (direction === "withdraw" && value === 0n && from.toLowerCase() === agent && to.toLowerCase() === owner)
+        zeroTransferLogs.push(log.logIndex);
+      let matched = 0n;
+      if (direction === "deposit") {
+        if (to.toLowerCase() === agent) matched = value;
+      } else {
+        const sender = from.toLowerCase();
+        const recipient = to.toLowerCase();
+        const available = sender === agent ? value : attributed.get(sender) ?? 0n;
+        const carried = available < value ? available : value;
+        if (sender !== agent) attributed.set(sender, available - carried);
+        if (recipient === owner) matched = carried;
+        else if (recipient !== agent) attributed.set(recipient, (attributed.get(recipient) ?? 0n) + carried);
+      }
+      if (matched === 0n) continue;
+      amount += matched;
+      transferLogs.push({ logIndex: log.logIndex, amountRaw: matched.toString() });
+      logIndexes.push(log.logIndex);
+    } catch {
+    }
+  }
+  const expected = /^\d+$/.test(evidence.intendedAmount) ? BigInt(evidence.intendedAmount) : void 0;
+  const emptyPayout = direction === "withdraw" && evidence.agentId === "yieldseeker" && amount === 0n && zeroTransferLogs.length > 0 && receipt.logs.some((log) => {
+    if (log.address.toLowerCase() !== agent) return false;
+    try {
+      const { args } = decodeEventLog({ abi: withdrawalEventAbi, data: log.data, topics: log.topics });
+      return args.owner.toLowerCase() === owner && args.recipient.toLowerCase() === owner && args.token.toLowerCase() === tokenAddress.toLowerCase() && args.amount === 0n;
+    } catch {
+      return false;
+    }
+  });
+  if (emptyPayout) return {
+    ...evidence,
+    blockNumber: receipt.blockNumber.toString(),
+    confirmedAmount: "0",
+    logIndexes: zeroTransferLogs,
+    transferLogs: zeroTransferLogs.map((logIndex) => ({ logIndex, amountRaw: "0" })),
+    transfer: "failed",
+    delivery: "failed"
+  };
+  const delivered = amount > 0n && (expected === void 0 || amount >= expected);
+  return {
+    ...evidence,
+    blockNumber: receipt.blockNumber.toString(),
+    logIndexes,
+    transferLogs,
+    ...amount > 0n ? { confirmedAmount: amount.toString() } : {},
+    transfer: delivered ? "confirmed" : "unknown",
+    delivery: direction === "withdraw" ? delivered ? "confirmed" : "unknown" : "not-applicable"
+  };
+}
+
 // src/lib/deposit-batch-callback.ts
 var batchCallbacks = /* @__PURE__ */ new WeakMap();
 var getDepositBatchTransfer = (callback) => callback ? batchCallbacks.get(callback) : void 0;
@@ -212,9 +302,72 @@ var AgentReads = class {
   }
 };
 
+// src/agents/zyfai/zyfai.withdraw-submission.ts
+var listenersByClient = /* @__PURE__ */ new WeakMap();
+function observeWithdrawalSubmission(sdk, chainId, token) {
+  const client = sdk.httpClient;
+  if (!client || typeof client.get !== "function" || typeof client.post !== "function")
+    return { attempted: () => void 0, rejected: () => false, request: () => void 0, stop: () => {
+    } };
+  let listeners = listenersByClient.get(client);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    listenersByClient.set(client, listeners);
+    const observers = listeners;
+    for (const method of ["get", "post"]) {
+      const original = client[method];
+      client[method] = async function(...args) {
+        const [url, options] = args;
+        const withdrawal = method === "get" && url === "/users/withdraw" || method === "post" && url === "/users/partial-withdraw";
+        const payload = method === "get" ? options?.params : options;
+        const matching = withdrawal ? [...observers].filter((observer) => observer.chainId === payload?.chainId && observer.token === payload?.tokenSymbol) : [];
+        const startedAt = Date.now();
+        const request2 = {
+          attempted: true,
+          method: method === "get" ? "GET" : "POST",
+          path: method === "get" ? "/users/withdraw" : "/users/partial-withdraw"
+        };
+        const notify = (outcome) => {
+          if (outcome === "rejected" && matching.length !== 1) return;
+          for (const observer of matching) {
+            try {
+              observer.notify(outcome, { ...request2 });
+            } catch {
+            }
+          }
+        };
+        notify("attempted");
+        try {
+          return await original.apply(this, args);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "";
+          request2.failure = message === "Unauthorized: Invalid API key" ? "unauthorized" : message === "Forbidden: Access denied" ? "forbidden" : message === "Rate limit exceeded. Please try again later." ? "rate-limited" : message === "Network error: Unable to reach the server" ? "network" : "other";
+          if (["unauthorized", "forbidden", "rate-limited"].includes(request2.failure)) notify("rejected");
+          throw error;
+        } finally {
+          request2.elapsedMs = Math.max(0, Date.now() - startedAt);
+          notify("finished");
+        }
+      };
+    }
+  }
+  let submitted = false;
+  let rejected = false;
+  let request = { attempted: false };
+  const listener = { chainId, token, notify: (outcome, evidence) => {
+    request = evidence;
+    if (outcome === "attempted") submitted = true;
+    else if (outcome === "rejected") rejected = true;
+  } };
+  listeners.add(listener);
+  return { attempted: () => submitted, rejected: () => rejected, request: () => ({ ...request }), stop: () => {
+    listeners.delete(listener);
+  } };
+}
+
 // src/agents/zyfai/zyfai.agent.ts
 import { SMART_SESSIONS_VALIDATOR, ZyfaiSDK } from "@zyfai/sdk";
-import { parseAbi } from "viem";
+import { formatUnits, parseAbi as parseAbi2 } from "viem";
 import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/types/config.ts
@@ -387,7 +540,11 @@ function mapPendingAllocations(raw2) {
 }
 function mapBalances(raw2, _chainId, smartWallet) {
   const portfolio = raw2.portfolio;
-  const portfolioByChain = portfolio.portfolioByChain ?? {};
+  if (!portfolio?.portfolioByChain || typeof portfolio.portfolioByChain !== "object")
+    throw new Error("Zyfai balance snapshot is unavailable.");
+  const portfolioByChain = portfolio.portfolioByChain;
+  const fetchedAt = Date.now();
+  const provenance = portfolio;
   let totalBalance = 0;
   const tokens = [];
   for (const [chainIdKey, tokensBySymbol] of Object.entries(portfolioByChain)) {
@@ -396,7 +553,8 @@ function mapBalances(raw2, _chainId, smartWallet) {
       symbol,
       { balance, balanceWithFee, decimals }
     ] of Object.entries(tokensBySymbol ?? {})) {
-      const amount = hexToDecimal(balanceWithFee ?? balance ?? "0", decimals);
+      if (balanceWithFee === void 0 && balance === void 0) throw new Error("Zyfai asset balance is unavailable.");
+      const amount = hexToDecimal(balanceWithFee ?? balance, decimals);
       totalBalance += amount;
       tokens.push({
         chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
@@ -446,6 +604,15 @@ function mapBalances(raw2, _chainId, smartWallet) {
     totalBalanceAsset: "usdc",
     tokens,
     positions,
+    readMetadata: tokens.map((token) => ({
+      chainId: token.chainId,
+      asset: token.asset,
+      fetchedAt,
+      providerUpdatedAt: typeof provenance.updatedAt === "string" ? provenance.updatedAt : void 0,
+      snapshotId: provenance.snapshotId === void 0 ? void 0 : String(provenance.snapshotId),
+      blockNumber: provenance.blockNumber === void 0 ? void 0 : String(provenance.blockNumber),
+      positionsStatus: Array.isArray(portfolio.positions) ? "available" : "unavailable"
+    })),
     ...pendingAllocations ? { pendingAllocations } : {}
   };
 }
@@ -786,28 +953,6 @@ function mapDailyEarnings(raw2, chainId, tokenSymbol) {
   return { walletAddress: raw2.walletAddress, chainId, assets };
 }
 
-// src/agents/zyfai/zyfai.withdraw-amount.ts
-var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-function topicToAddress(topic) {
-  return `0x${(topic ?? "").slice(-40)}`.toLowerCase();
-}
-function extractWithdrawnAmount(logs, recipient, token, decimals) {
-  const wantRecipient = recipient.toLowerCase();
-  const wantToken = token.toLowerCase();
-  let total = 0n;
-  let matched = false;
-  for (const log of logs) {
-    if (log.address.toLowerCase() !== wantToken) continue;
-    if ((log.topics[0] ?? "").toLowerCase() !== TRANSFER_TOPIC) continue;
-    if (topicToAddress(log.topics[2]) !== wantRecipient) continue;
-    if (!log.data || log.data === "0x") continue;
-    total += BigInt(log.data);
-    matched = true;
-  }
-  if (!matched) return void 0;
-  return String(hexToDecimal(`0x${total.toString(16)}`, decimals));
-}
-
 // src/agents/zyfai/zyfai.history-cursor.ts
 var InvalidHistoryCursorError = class extends Error {
   code = "invalid_cursor";
@@ -1234,7 +1379,7 @@ async function withPaidRpcDiagnostics(operation, chainId, rpcMethod, agentId) {
 }
 
 // src/agents/zyfai/zyfai.agent.ts
-var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi([
+var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi2([
   "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)"
 ]);
 var WETH_ADDRESS_BY_CHAIN = {
@@ -1293,10 +1438,9 @@ var ZyfaiAgent = class _ZyfaiAgent {
   connectAuthPromise = null;
   rpcUrls;
   publicClients = /* @__PURE__ */ new Map();
-  // txHash -> resolved withdrawn amount. Receipts are immutable, so a
-  // successful decode is cached forever; failures are NOT cached so a transient
-  // RPC error retries on the next fetch.
-  withdrawAmountCache = /* @__PURE__ */ new Map();
+  // Receipt-derived amounts and log identities, scoped to the owner and asset.
+  // Failures remain retryable; successful immutable evidence has a bounded cache.
+  fundingHistoryCache = /* @__PURE__ */ new Map();
   earningsReads = /* @__PURE__ */ new Map();
   earningsRefreshes = /* @__PURE__ */ new Map();
   earningsSnapshot = null;
@@ -1324,8 +1468,9 @@ var ZyfaiAgent = class _ZyfaiAgent {
     return client;
   }
   /**
-   * Fills in the true withdrawn amount for `Withdraw` entries by decoding the
-   * on-chain `Transfer` that lands in the user's wallet. The Zyfai history
+   * Resolves funding amounts and log identities from token receipts. Withdrawals
+   * must travel from this agent wallet to its owner; top-ups must reach the agent.
+   * The Zyfai history
    * payload only reports the *remaining* position for a partial withdraw (see
    * the note in `mapEntries`), so without this the UI shows the leftover
    * balance instead of the amount withdrawn.
@@ -1337,48 +1482,62 @@ var ZyfaiAgent = class _ZyfaiAgent {
    * Entries with no symbol (older payload shapes) fall back to USDC to
    * preserve prior behavior.
    *
-   * Mutates `entries` in place. Runs all lookups concurrently and is tolerant
-   * of RPC failures: an entry whose amount can't be resolved keeps
-   * `amount: undefined`, which consumers render as a hidden/retryable row
-   * rather than a wrong number.
+   * Mutates `entries` in place, sharing receipt requests within the page. RPC
+   * failures leave provider top-ups unchanged and withdrawal amounts unknown.
    */
-  async resolveWithdrawnAmounts(entries, chainId, recipient) {
-    const withdrawals = entries.filter(
-      (e) => e.action === "Withdraw" && e.transactions[0]?.txHashes[0]
+  async resolveFundingTransfers(entries, chainId, recipient, smartWallet, tokenSymbol) {
+    const movements = entries.filter(
+      (e) => (e.action === "Withdraw" || e.action === "Top up") && e.transactions[0]?.txHashes[0]
     );
-    if (withdrawals.length === 0) return;
+    if (movements.length === 0) return;
     const client = this.getPublicClient(chainId);
+    const receipts = /* @__PURE__ */ new Map();
     await Promise.all(
-      withdrawals.map(async (entry) => {
+      movements.map(async (entry) => {
         const tx = entry.transactions[0];
         const txHash = tx.txHashes[0];
-        const rawSymbol = tx.tokenSymbol;
+        const rawSymbol = tx.tokenSymbol ?? tokenSymbol;
         const normalizedSymbol = rawSymbol ? rawSymbol.toLowerCase() === "eth" ? "WETH" : rawSymbol.toUpperCase() : "USDC";
         const asset = SupportedAssets.find(
           (a) => a.chainId === chainId && a.symbol === normalizedSymbol
-        ) ?? SupportedAssets.find(
-          (a) => a.chainId === chainId && a.symbol === "USDC"
         );
         if (!asset) return;
-        const cacheKey = `${txHash}:${asset.address}`;
-        const cached = this.withdrawAmountCache.get(cacheKey);
+        tx.tokenSymbol = asset.symbol;
+        tx.tokenAddress = asset.address;
+        tx.agentWallet = smartWallet;
+        entry.id = `${chainId}:${txHash.toLowerCase()}:${entry.action}:${asset.address.toLowerCase()}:${smartWallet.toLowerCase()}`;
+        if (!/^0x[0-9a-f]{64}$/i.test(txHash)) return;
+        const cacheKey = `${entry.id}:${recipient.toLowerCase()}`;
+        const cached = this.fundingHistoryCache.get(cacheKey);
         if (cached !== void 0) {
-          tx.amount = cached;
+          Object.assign(tx, cached);
           return;
         }
         try {
-          const receipt = await client.getTransactionReceipt({
-            hash: txHash
-          });
-          const amount = extractWithdrawnAmount(
-            receipt.logs,
-            recipient,
-            asset.address,
-            asset.decimals
-          );
-          if (amount !== void 0) {
-            this.withdrawAmountCache.set(cacheKey, amount);
-            tx.amount = amount;
+          if (!receipts.has(txHash)) receipts.set(txHash, client.getTransactionReceipt({ hash: txHash }));
+          const receipt = await receipts.get(txHash);
+          const evidence = inspectFundingReceipt(receipt, {
+            agentId: "zyfai",
+            walletAddress: recipient,
+            chainId,
+            token: asset.symbol,
+            agentWallet: smartWallet,
+            intendedAmount: "MAX",
+            txHash,
+            transfer: "unknown",
+            registration: "not-applicable",
+            delivery: "unknown"
+          }, asset.address, entry.action === "Withdraw" ? "withdraw" : "deposit");
+          if (evidence.transfer === "confirmed" && evidence.confirmedAmount) {
+            Object.assign(tx, {
+              amount: formatUnits(BigInt(evidence.confirmedAmount), asset.decimals),
+              amountRaw: evidence.confirmedAmount,
+              blockNumber: evidence.blockNumber,
+              logIndexes: evidence.logIndexes,
+              transferLogs: evidence.transferLogs
+            });
+            if (this.fundingHistoryCache.size >= 256) this.fundingHistoryCache.delete(this.fundingHistoryCache.keys().next().value);
+            this.fundingHistoryCache.set(cacheKey, { ...tx });
           }
         } catch {
         }
@@ -1467,7 +1626,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
    * Wraps `sdk.connectAccount` with a one-shot retry on auth errors. If the
    * cached JWT is rejected by the backend (revoked, signing-key rotated, etc.)
    * we drop the cache and try again — the second attempt has no cache entry,
-   * so it falls through to a real SIWE prompt. Zyfai collapses every 4xx into
+   * so it falls through to a real SIWE prompt. Zyfai labels every HTTP 401 with
    * an `"Unauthorized: Invalid API key"` error so we can't distinguish revoked
    * JWT from a misconfigured API key; we retry once either way, and if the
    * second attempt still fails the original error propagates.
@@ -1500,6 +1659,17 @@ var ZyfaiAgent = class _ZyfaiAgent {
       await this.connectAuth(state, chainId);
     }
   }
+  /** A rejected execution session must not be reused by the next foreground attempt. */
+  invalidateRejectedWithdrawalSession(error, state, chainId, authToken) {
+    const message = error instanceof Error ? error.message : "";
+    if (!/(?:^|: )Unauthorized: Invalid API key$/.test(message)) return;
+    const internals = this.sdk;
+    if (typeof authToken !== "string" || internals.httpClient.authToken !== authToken || this.connectedAddress?.toLowerCase() !== state.walletAddress.toLowerCase() || this.connectedChainId !== chainId) return;
+    clearSession(state.walletAddress, chainId);
+    internals.httpClient.clearAuthToken();
+    internals.authenticatedUserId = null;
+    this.connectedChainId = null;
+  }
   /**
    * Sync newly-available protocols onto an existing user's profile at wallet
    * connection. Zyfai's own protocol sync (`updateUserProtocols`) runs only when
@@ -2045,7 +2215,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
     await this.ensureSessionKey(ownerAddress, chainId, redeployed.address);
     return redeployed.address;
   }
-  async deposit(state, chainId, amount, asset, depositCallback) {
+  async deposit(state, chainId, amount, asset, depositCallback, onProgress) {
     try {
       const validChainId = isValidChainId(chainId);
       await this.ensureConnected(state, validChainId);
@@ -2054,17 +2224,48 @@ var ZyfaiAgent = class _ZyfaiAgent {
           this.getAddress(),
           validChainId
         );
+        notifyFunding(onProgress, {
+          agentId: this.id,
+          chainId,
+          token: asset,
+          walletAddress: state.walletAddress,
+          agentWallet: smartWallet,
+          intendedAmount: amount,
+          transfer: "pending",
+          registration: "pending",
+          delivery: "not-applicable"
+        });
         const txHash = await depositCallback(smartWallet, validChainId, amount);
-        const tokenAddress = asset === "WETH" ? WETH_ADDRESS_BY_CHAIN[validChainId] : void 0;
+        let evidence2 = {
+          agentId: this.id,
+          chainId,
+          token: asset,
+          walletAddress: state.walletAddress,
+          agentWallet: smartWallet,
+          intendedAmount: amount,
+          txHash,
+          transfer: "pending",
+          registration: "pending",
+          delivery: "not-applicable"
+        };
+        notifyFunding(onProgress, evidence2);
+        try {
+          const receipt = await this.getPublicClient(validChainId).getTransactionReceipt({ hash: txHash });
+          const token = SupportedAssets.find((token2) => token2.chainId === chainId && token2.symbol === asset);
+          evidence2 = inspectFundingReceipt(receipt, evidence2, token.address, "deposit");
+        } catch {
+          evidence2 = { ...evidence2, transfer: "unknown" };
+        }
+        notifyFunding(onProgress, evidence2);
         try {
+          const tokenAddress = asset === "WETH" ? WETH_ADDRESS_BY_CHAIN[validChainId] : void 0;
           await (tokenAddress ? this.sdk.logDeposit(validChainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(validChainId, txHash, amount));
-        } catch (logError) {
-          console.warn(
-            "[owney-sdk] Deposit landed on-chain but logDeposit failed (non-fatal):",
-            logError
-          );
+          evidence2 = { ...evidence2, registration: "confirmed" };
+        } catch {
+          evidence2 = { ...evidence2, registration: "unknown" };
         }
-        return { txHash, smartWallet, amount };
+        notifyFunding(onProgress, evidence2);
+        return { txHash, smartWallet, amount, evidence: evidence2 };
       }
       await this.ensureWalletDeployed(this.getAddress(), validChainId);
       const raw2 = await this.sdk.depositFunds(
@@ -2074,22 +2275,88 @@ var ZyfaiAgent = class _ZyfaiAgent {
         asset,
         "aggressive"
       );
-      return mapDeposit(raw2);
+      let evidence = {
+        agentId: this.id,
+        chainId,
+        token: asset,
+        walletAddress: state.walletAddress,
+        agentWallet: raw2.smartWallet,
+        intendedAmount: amount,
+        txHash: raw2.txHash,
+        transfer: "unknown",
+        registration: "unknown",
+        delivery: "not-applicable"
+      };
+      notifyFunding(onProgress, evidence);
+      try {
+        const receipt = await this.getPublicClient(validChainId).getTransactionReceipt({ hash: raw2.txHash });
+        const token = SupportedAssets.find((value) => value.chainId === chainId && value.symbol === asset);
+        evidence = inspectFundingReceipt(receipt, evidence, token.address, "deposit");
+      } catch {
+      }
+      notifyFunding(onProgress, evidence);
+      return { ...mapDeposit(raw2), evidence };
     } catch (error) {
       throw error;
     }
   }
   // --- IAgent: Fund operations ---
-  async withdraw(state, chainId, token, amount) {
+  async withdraw(state, chainId, token, amount, onProgress) {
     const validChainId = isValidChainId(chainId);
-    await this.ensureConnected(state, validChainId);
-    const raw2 = await this.sdk.withdrawFunds(
-      this.getAddress(),
-      validChainId,
-      amount,
-      token
-    );
+    try {
+      await this.ensureConnected(state, validChainId);
+    } catch (error) {
+      notifyFunding(onProgress, {
+        agentId: this.id,
+        chainId,
+        token,
+        walletAddress: state.walletAddress,
+        intendedAmount: amount ?? "MAX",
+        transfer: "failed",
+        registration: "not-applicable",
+        delivery: "failed"
+      });
+      throw error;
+    }
+    const observation = observeWithdrawalSubmission(this.sdk, validChainId, token);
+    const authToken = this.sdk.httpClient?.authToken;
+    let raw2;
+    try {
+      raw2 = await this.sdk.withdrawFunds(this.getAddress(), validChainId, amount, token);
+    } catch (error) {
+      this.invalidateRejectedWithdrawalSession(error, state, validChainId, authToken);
+      if (observation.attempted() !== void 0) {
+        const failed = observation.attempted() === false || observation.rejected();
+        notifyFunding(onProgress, {
+          agentId: this.id,
+          chainId,
+          token,
+          walletAddress: state.walletAddress,
+          intendedAmount: amount ?? "MAX",
+          transfer: failed ? "failed" : "unknown",
+          registration: "not-applicable",
+          delivery: failed ? "failed" : "unknown",
+          withdrawalRequest: observation.request()
+        });
+      }
+      throw error;
+    } finally {
+      observation.stop();
+    }
     if (!raw2.success) {
+      const unresolved = !!raw2.txHash || /already|pending|queued|in.progress/i.test(raw2.message ?? "");
+      notifyFunding(onProgress, {
+        agentId: this.id,
+        chainId,
+        token,
+        walletAddress: state.walletAddress,
+        intendedAmount: amount ?? "MAX",
+        txHash: raw2.txHash,
+        transfer: unresolved ? "unknown" : "failed",
+        registration: "not-applicable",
+        delivery: unresolved ? "unknown" : "failed",
+        withdrawalRequest: observation.request()
+      });
       throw new OwneyError(
         "WITHDRAW_FAILED",
         raw2.message || "Zyfai withdraw failed.",
@@ -2097,13 +2364,45 @@ var ZyfaiAgent = class _ZyfaiAgent {
         this.id
       );
     }
-    return mapWithdraw(raw2);
+    const evidence = {
+      agentId: this.id,
+      chainId,
+      token,
+      walletAddress: state.walletAddress,
+      intendedAmount: amount ?? "MAX",
+      txHash: raw2.txHash,
+      transfer: "pending",
+      registration: "not-applicable",
+      delivery: "pending",
+      withdrawalRequest: observation.request()
+    };
+    notifyFunding(onProgress, evidence);
+    return { ...mapWithdraw(raw2), evidence };
+  }
+  /** Registration recovery never signs, transfers, activates, or refreshes authentication. */
+  async retryDepositRegistration(state, evidence) {
+    const internals = this.sdk;
+    if (!internals.httpClient.authToken || internals.authenticatedUserId === null || this.connectedAddress?.toLowerCase() !== state.walletAddress.toLowerCase() || this.connectedChainId !== evidence.chainId) {
+      throw new OwneyError("NOT_CONNECTED", "Reconnect the wallet before recovering deposit registration.");
+    }
+    if (evidence.transfer !== "confirmed" || !evidence.txHash) {
+      throw new OwneyError("AGENT_API_ERROR", "Deposit transfer must be verified before registration recovery.");
+    }
+    const cid = isValidChainId(evidence.chainId);
+    const tokenAddress = evidence.token === "WETH" ? WETH_ADDRESS_BY_CHAIN[cid] : void 0;
+    await this.sdk.logDeposit(cid, evidence.txHash, evidence.intendedAmount, tokenAddress);
+    return { ...evidence, registration: "confirmed" };
   }
   // --- IAgent: Portfolio reads ---
+  async getFundingWallet(state, chainId) {
+    return (await this.sdk.getSmartWalletAddress(state.walletAddress, isValidChainId(chainId))).address;
+  }
   async getBalances(state, chainId) {
+    const requestedAt = Date.now();
     const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
     const raw2 = await this.sdk.getPortfolio(this.getAddress());
-    return mapBalances(raw2, validChainId, smartWallet);
+    const balance = mapBalances(raw2, validChainId, smartWallet);
+    return { ...balance, readMetadata: balance.readMetadata?.map((read2) => ({ ...read2, requestedAt })) };
   }
   earningsKey(state, chainId, smartWallet) {
     return JSON.stringify([
@@ -2176,7 +2475,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
   /**
    * Owney speaks asset symbols ("USDC" / "WETH"); Zyfai's history endpoint
    * takes lowercase `assetType` and denominates WETH as "eth" (the same
-   * spelling `resolveWithdrawnAmounts` normalizes on the way in). Anything
+   * spelling `resolveFundingTransfers` normalizes on the way in). Anything
    * unrecognised returns undefined so the request stays unfiltered rather
    * than silently narrowing to nothing.
    */
@@ -2195,6 +2494,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   async getHistory(state, chainId, options) {
     const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
+    return this.readHistory(state, smartWallet, validChainId, options);
+  }
+  /** Recovery reads never enter connectAuth or wallet activation. */
+  async getFundingHistory(state, chainId, options) {
+    const smartWallet = await this.getFundingWallet(state, chainId);
+    return this.readHistory(state, smartWallet, isValidChainId(chainId), options);
+  }
+  async readHistory(state, smartWallet, validChainId, options) {
     const limit = options?.limit ?? 10;
     const assetType = _ZyfaiAgent.toZyfaiAssetType(options?.tokenSymbol);
     const cursor = options?.cursor ? decodeHistoryCursor(options.cursor) : null;
@@ -2236,9 +2543,16 @@ var ZyfaiAgent = class _ZyfaiAgent {
       rawOffset: firstOvershoot ? firstOvershoot.rawIdx : offset
     }) : void 0;
     const data = mapEntries(pageData, validChainId);
-    await this.resolveWithdrawnAmounts(data, validChainId, state.walletAddress);
+    await this.resolveFundingTransfers(data, validChainId, state.walletAddress, smartWallet, options?.tokenSymbol);
+    const seen = /* @__PURE__ */ new Set();
+    const unique = data.filter((entry) => {
+      if (!entry.id || !entry.transactions[0]?.transferLogs?.length) return true;
+      if (seen.has(entry.id)) return false;
+      seen.add(entry.id);
+      return true;
+    });
     return {
-      data,
+      data: unique,
       hasMore,
       nextCursor
     };
@@ -2292,7 +2606,7 @@ import {
   createWalletClient as createWalletClient2,
   custom as custom2,
   encodeFunctionData,
-  erc20Abi,
+  erc20Abi as erc20Abi2,
   getAddress as getAddress2,
   isAddress as isAddress2
 } from "viem";
@@ -2913,7 +3227,7 @@ var YieldseekerApiClient = class {
 };
 
 // src/agents/yieldseeker/yieldseeker.mapper.ts
-import { formatUnits, isAddress } from "viem";
+import { formatUnits as formatUnits2, isAddress } from "viem";
 
 // src/lib/helpers/snapshot-apy.ts
 var DAY_MS = 864e5;
@@ -2980,10 +3294,10 @@ function raw(value, endpoint) {
   return BigInt(value);
 }
 function decimal(value, decimals, endpoint) {
-  return formatUnits(raw(value, endpoint), decimals);
+  return formatUnits2(raw(value, endpoint), decimals);
 }
 function usd(rawAmount, decimals, price) {
-  return Number(formatUnits(rawAmount, decimals)) * price;
+  return Number(formatUnits2(rawAmount, decimals)) * price;
 }
 function percent(value) {
   const result = Number(value);
@@ -3079,7 +3393,17 @@ function mapYieldseekerBalances(contexts) {
     totalBalanceAsset: "usdc",
     assetBalances,
     tokens,
-    positions
+    positions,
+    readMetadata: contexts.map((context) => ({
+      chainId: context.agent.chainId,
+      asset: context.asset,
+      fetchedAt: context.fetchedAt,
+      readVersion: context.readVersion,
+      providerUpdatedAt: context.snapshot.updatedDate,
+      snapshotId: String(context.snapshot.agentWalletSnapshotId),
+      netDepositsRaw: context.snapshot.netDepositsBase,
+      positionsStatus: context.positionsUnavailable ? "unavailable" : "available"
+    }))
   };
 }
 function mapYieldseekerEarnings(contexts) {
@@ -3091,7 +3415,7 @@ function mapYieldseekerEarnings(contexts) {
       chain: "BASE",
       chainId: 8453,
       asset: context.asset,
-      amount: formatUnits(amount, context.snapshot.baseAssetDecimals)
+      amount: formatUnits2(amount, context.snapshot.baseAssetDecimals)
     });
     lifetimeEarnings += usd(
       amount,
@@ -3193,6 +3517,7 @@ function transactionHashes(details) {
 function actionEntry(action) {
   if (action.actionType.toLowerCase().includes("withdraw")) return void 0;
   return {
+    id: `yieldseeker:action:${action.agentActionId}`,
     agent: "yieldseeker",
     action: actionType(action.actionType),
     date: action.createdDate,
@@ -3222,7 +3547,7 @@ function movementEntry(movement, wallet, agent, asset, ownerAddress, vaultAddres
   const owner = ownerAddress.toLowerCase();
   const agentWallet = wallet.walletAddress.toLowerCase();
   const baseAsset = agent.assetAddress.toLowerCase();
-  if (movement.chainId !== agent.chainId || movement.assetAddress.toLowerCase() !== baseAsset) {
+  if (movement.chainId !== agent.chainId || movement.assetAddress.toLowerCase() !== baseAsset || raw(movement.assetAmount, "historic position") <= 0n) {
     return void 0;
   }
   let action;
@@ -3247,6 +3572,12 @@ function movementEntry(movement, wallet, agent, asset, ownerAddress, vaultAddres
     transactions: [
       {
         txHashes: [movement.transactionHash],
+        tokenAddress: movement.assetAddress,
+        agentWallet: wallet.walletAddress,
+        logIndexes: [movement.logIndex],
+        transferLogs: [{ logIndex: movement.logIndex, amountRaw: movement.assetAmount }],
+        amountRaw: movement.assetAmount,
+        blockNumber: String(movement.blockNumber),
         chainId: agent.chainId,
         tokenSymbol: asset,
         amount: decimal(
@@ -3292,7 +3623,8 @@ function mapYieldseekerHistory(contexts, options) {
       ungrouped.push(entry);
       continue;
     }
-    const key2 = `${entry.agent}:${entry.action}:${tx.chainId}:${hash.toLowerCase()}`;
+    const key2 = `${entry.agent}:${entry.action}:${tx.chainId}:${hash.toLowerCase()}:${tx.tokenAddress?.toLowerCase() ?? ""}:${tx.agentWallet?.toLowerCase() ?? ""}`;
+    entry.id = key2;
     const previous = grouped.get(key2);
     if (!previous) {
       grouped.set(key2, entry);
@@ -3305,14 +3637,52 @@ function mapYieldseekerHistory(contexts, options) {
       }
       previous.positions.push(...entry.positions);
       previous.transactions.push(...entry.transactions);
+    } else if ((entry.action === "Top up" || entry.action === "Withdraw") && tx.amountRaw) {
+      const target = previous.transactions[0];
+      const known = new Set(target.logIndexes ?? []);
+      if (tx.logIndexes?.some((index) => !known.has(index))) {
+        target.amountRaw = String(BigInt(target.amountRaw ?? "0") + BigInt(tx.amountRaw));
+        target.amount = formatUnits2(
+          BigInt(target.amountRaw),
+          YIELDSEEKER_ASSET_METADATA[target.tokenSymbol].decimals
+        );
+        target.logIndexes = [...known, ...tx.logIndexes.filter((index) => !known.has(index))];
+        target.transferLogs = [...target.transferLogs ?? [], ...(tx.transferLogs ?? []).filter((log) => !known.has(log.logIndex))];
+      }
+    }
+  }
+  const values = [...grouped.values(), ...ungrouped].filter((entry) => {
+    const tx = entry.transactions[0];
+    return tx?.amountRaw !== void 0 || ![...grouped.values()].some((other) => other !== entry && other.action === entry.action && other.transactions[0]?.amountRaw !== void 0 && other.transactions[0]?.txHashes[0]?.toLowerCase() === tx?.txHashes[0]?.toLowerCase());
+  });
+  let boundary;
+  const scope = JSON.stringify([
+    options.ownerAddress.toLowerCase(),
+    contexts.map((context) => `${context.agent.chainId}:${context.wallet.walletAddress.toLowerCase()}:${context.asset}`).sort(),
+    options.fromDate ?? null
+  ]);
+  if (options.cursor) {
+    try {
+      boundary = JSON.parse(decodeURIComponent(atob(options.cursor)));
+      if (!boundary || boundary.scope !== scope || typeof boundary.id !== "string" || !Number.isFinite(Date.parse(boundary.date)) || !Number.isFinite(Date.parse(boundary.toDate))) throw new Error();
+    } catch {
+      throw new InvalidHistoryCursorError("Invalid Yieldseeker history cursor.");
     }
   }
-  const filtered = [...grouped.values(), ...ungrouped].filter((entry) => (!options.fromDate || entry.date >= options.fromDate) && (!options.toDate || entry.date <= options.toDate)).sort((left, right) => right.date.localeCompare(left.date));
+  const toDate = boundary?.toDate ?? options.toDate ?? (/* @__PURE__ */ new Date()).toISOString();
+  const filtered = values.filter((entry) => (!options.fromDate || entry.date >= options.fromDate) && entry.date <= toDate && (!boundary || entry.date < boundary.date || entry.date === boundary.date && (entry.id ?? "") > boundary.id)).sort((left, right) => right.date.localeCompare(left.date) || (left.id ?? "").localeCompare(right.id ?? ""));
+  const data = filtered.slice(0, Math.max(1, options.limit));
+  const hasMore = filtered.length > data.length;
+  const last = data.at(-1);
   return {
-    data: filtered.slice(0, options.limit),
-    // v1 returns the whole action/movement collection and defines no cursor.
-    // Report a terminal page so callers never loop over the same prefix.
-    hasMore: false
+    data,
+    hasMore,
+    ...hasMore && last ? { nextCursor: btoa(encodeURIComponent(JSON.stringify({
+      date: last.date,
+      id: last.id ?? "",
+      toDate,
+      scope
+    }))) } : {}
   };
 }
 function mapYieldseekerProfile(address, contexts) {
@@ -3487,7 +3857,7 @@ var YieldseekerAgent = class {
     this.assertAsset(targetAsset);
     await this.ensureAgent(state, chainId, targetAsset);
   }
-  async deposit(state, chainId, amount, asset, depositCallback) {
+  async deposit(state, chainId, amount, asset, depositCallback, onProgress) {
     this.assertChain(chainId);
     this.assertAsset(asset);
     if (BigInt(amount) <= 0n) {
@@ -3501,7 +3871,20 @@ var YieldseekerAgent = class {
     const context = await this.ensureAgent(state, chainId, asset);
     const generation = this.readGeneration;
     const movement = this.snapshotMovement(state, chainId, context, BigInt(amount));
+    notifyFunding(onProgress, {
+      agentId: this.id,
+      chainId,
+      token: asset,
+      walletAddress: state.walletAddress,
+      agentWallet: context.wallet.walletAddress,
+      intendedAmount: amount,
+      transfer: "pending",
+      registration: "not-applicable",
+      delivery: "not-applicable"
+    });
     let txHash;
+    let receipt;
+    const submitted = (hash) => notifyFunding(onProgress, { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount, txHash: hash, transfer: "pending", registration: "not-applicable", delivery: "not-applicable" });
     if (depositCallback) {
       provideDepositVerificationContext(depositCallback, {
         agentId: "yieldseeker",
@@ -3514,30 +3897,57 @@ var YieldseekerAgent = class {
         chainId,
         amount
       );
-      await this.waitForReceipt(state, chainId, txHash);
+      submitted(txHash);
+      receipt = await this.waitForReceipt(state, chainId, txHash);
     } else {
       txHash = await this.submitTransaction(state, chainId, {
         from: getAddress2(state.walletAddress),
         to: YIELDSEEKER_ASSET_METADATA[asset].address,
         data: encodeFunctionData({
-          abi: erc20Abi,
+          abi: erc20Abi2,
           functionName: "transfer",
           args: [getAddress2(context.wallet.walletAddress), BigInt(amount)]
         }),
         value: "0",
         chainId
+      }, submitted, (value) => {
+        receipt = value;
       });
     }
     if (this.readGeneration === generation) {
       void this.refreshSnapshotAfterMovement(state, chainId, context, "deposit", movement);
     }
-    return {
-      txHash,
-      smartWallet: context.wallet.walletAddress,
-      amount
+    const base5 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount, confirmedAmount: amount, txHash, transfer: "confirmed", registration: "not-applicable", delivery: "not-applicable" };
+    const evidence = receipt ? inspectFundingReceipt(receipt, base5, YIELDSEEKER_ASSET_METADATA[asset].address, "deposit") : base5;
+    notifyFunding(onProgress, evidence);
+    return { txHash, smartWallet: context.wallet.walletAddress, amount, evidence };
+  }
+  async withdraw(state, chainId, asset, amount, onProgress) {
+    let ownerTransferAttempted = false;
+    let evidence = {
+      agentId: this.id,
+      chainId,
+      token: asset,
+      walletAddress: state.walletAddress,
+      intendedAmount: amount ?? "MAX",
+      transfer: "pending",
+      registration: "not-applicable",
+      delivery: "pending"
     };
+    try {
+      return await this.withdrawInternal(state, chainId, asset, amount, (next) => {
+        evidence = { ...evidence, ...next };
+        notifyFunding(onProgress, evidence);
+      }, () => {
+        ownerTransferAttempted = true;
+      });
+    } catch (error) {
+      if (!ownerTransferAttempted || error instanceof OwneyError && error.code === "AGENT_TRANSACTION_REVERTED")
+        notifyFunding(onProgress, { ...evidence, transfer: "failed", delivery: "failed" });
+      throw error;
+    }
   }
-  async withdraw(state, chainId, asset, amount) {
+  async withdrawInternal(state, chainId, asset, amount, onProgress, onOwnerTransferAttempted) {
     this.assertChain(chainId);
     this.assertAsset(asset);
     if (amount !== void 0 && BigInt(amount) <= 0n) {
@@ -3567,17 +3977,32 @@ var YieldseekerAgent = class {
         context
       );
       const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-      const idleEntry = Object.entries(portfolio.snapshot.tokenBalances).find(
-        ([address]) => address.toLowerCase() === metadata.address.toLowerCase()
-      );
-      const idle = BigInt(idleEntry?.[1] ?? "0");
+      const readIdle = async () => {
+        const balance = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
+          address: metadata.address,
+          abi: erc20Abi2,
+          functionName: "balanceOf",
+          args: [getAddress2(context.wallet.walletAddress)]
+        }), chainId, "eth_call", this.id);
+        this.assertSession(generation, chainId, asset);
+        return balance;
+      };
+      const idle = await readIdle();
       const deployed = portfolio.positions.reduce(
         (total, position2) => total + BigInt(position2.withdrawableAssetsRaw),
         0n
       );
       const totalAvailable = idle + deployed;
       const requested = amount === void 0 ? totalAvailable : BigInt(amount);
-      const plannedMovement = this.snapshotMovement(state, chainId, context, -requested);
+      if (requested === 0n) {
+        this.invalidateFundingRead(state, chainId, asset);
+        throw new OwneyError(
+          "WITHDRAW_INSUFFICIENT_BALANCE",
+          "No Yieldseeker funds are available to withdraw.",
+          { asset, available: "0" },
+          this.id
+        );
+      }
       if (requested > totalAvailable) {
         throw new OwneyError(
           "WITHDRAW_INSUFFICIENT_BALANCE",
@@ -3622,7 +4047,22 @@ var YieldseekerAgent = class {
           remaining: remaining.toString()
         });
       }
+      const availableForOwner = confirmedMovement ? await readIdle() : idle;
+      if (availableForOwner === 0n || amount !== void 0 && availableForOwner < requested) {
+        this.invalidateFundingRead(state, chainId, asset);
+        throw new OwneyError(
+          "WITHDRAW_INSUFFICIENT_BALANCE",
+          "Yieldseeker funds are not available for the owner transfer.",
+          { asset, requested: amount ?? "MAX", available: availableForOwner.toString() },
+          this.id
+        );
+      }
+      const payout = amount === void 0 ? availableForOwner : requested;
+      const plannedMovement = this.snapshotMovement(state, chainId, context, -payout);
       const account = getAddress2(state.walletAddress);
+      let receipt;
+      const base5 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount === void 0 ? "MAX" : requested.toString(), transfer: "pending", registration: "not-applicable", delivery: "pending" };
+      onOwnerTransferAttempted?.();
       const txHash = await this.submitTransaction(state, chainId, {
         from: account,
         to: getAddress2(context.wallet.walletAddress),
@@ -3637,14 +4077,21 @@ var YieldseekerAgent = class {
         }),
         value: "0",
         chainId
+      }, (hash) => notifyFunding(onProgress, { ...base5, txHash: hash }), (value) => {
+        receipt = value;
       });
       confirmedMovement = true;
       settlement = plannedMovement;
-      return {
-        txHash,
-        type: amount === void 0 ? "full" : "partial",
-        amount: requested.toString()
-      };
+      const evidence = receipt ? inspectFundingReceipt(receipt, { ...base5, txHash }, metadata.address, "withdraw") : { ...base5, txHash, confirmedAmount: payout.toString(), transfer: "confirmed", delivery: "confirmed" };
+      notifyFunding(onProgress, evidence);
+      if (evidence.transfer === "failed" && evidence.confirmedAmount === "0")
+        throw new OwneyError(
+          "WITHDRAW_INSUFFICIENT_BALANCE",
+          "The Yieldseeker withdrawal completed without transferring funds.",
+          { asset, available: "0", txHash },
+          this.id
+        );
+      return { txHash, type: amount === void 0 ? "full" : "partial", amount: evidence.confirmedAmount ?? payout.toString(), evidence };
     } finally {
       if (confirmedMovement && this.readGeneration === generation) {
         void this.refreshSnapshotAfterMovement(
@@ -3657,9 +4104,39 @@ var YieldseekerAgent = class {
       }
     }
   }
-  async getBalances(state, chainId) {
+  async getBalances(state, chainId, asset) {
     this.assertChain(chainId);
-    return mapYieldseekerBalances(await this.loadPortfolio(state, chainId, {}));
+    if (asset !== void 0) this.assertAsset(asset);
+    return mapYieldseekerBalances(await this.loadPortfolio(state, chainId, { asset, allowMissingPositions: true }));
+  }
+  invalidateFundingRead(state, chainId, asset, refreshUntil = Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS) {
+    this.assertAsset(asset);
+    const key2 = this.contextKey(state, chainId, asset);
+    const failure = this.snapshotFailures.get(key2);
+    this.advancePortfolioVersion(key2);
+    if (failure && failure.retryAt > Date.now()) this.snapshotFailures.set(key2, failure);
+    if (!this.snapshotMovements.has(key2)) this.snapshotMovements.set(key2, null);
+    const until = Math.min(refreshUntil, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
+    this.reconcileUntil.set(key2, Math.max(this.reconcileUntil.get(key2) ?? 0, until));
+    this.activityRefreshUntil.set(key2, Math.max(this.activityRefreshUntil.get(key2) ?? 0, until));
+  }
+  endFundingBalanceRefresh(state, chainId, asset, read2) {
+    this.assertChain(chainId);
+    this.assertAsset(asset);
+    const key2 = this.contextKey(state, chainId, asset);
+    const cached = this.readCache.get(`snapshot:${key2}`);
+    const snapshot = cached?.value?.agentSnapshot;
+    if (!cached || !snapshot || read2.chainId !== chainId || read2.asset.toUpperCase() !== asset || read2.readVersion !== this.portfolioVersion(key2) || read2.fetchedAt !== cached.fetchedAt || read2.snapshotId !== String(snapshot.agentWalletSnapshotId) || read2.providerUpdatedAt !== snapshot.updatedDate || read2.netDepositsRaw !== snapshot.netDepositsBase) return false;
+    this.snapshotMovements.delete(key2);
+    this.reconcileUntil.delete(key2);
+    cached.expiresAt = cached.fetchedAt + YIELDSEEKER_PORTFOLIO_CACHE_MS;
+    return true;
+  }
+  async getFundingWallet(state, chainId, asset) {
+    this.assertAsset(asset);
+    const context = this.agentContexts.get(this.contextKey(state, chainId, asset));
+    if (!context) throw new OwneyError("NOT_CONNECTED", "Reconnect the agent before recovering funding.");
+    return context.wallet.walletAddress;
   }
   async getEarnings(state, chainId) {
     this.assertChain(chainId);
@@ -3696,6 +4173,7 @@ var YieldseekerAgent = class {
     );
     return mapYieldseekerHistory(contexts, {
       limit: options?.limit ?? 10,
+      cursor: options?.cursor,
       ownerAddress: state.walletAddress,
       vaultAddresses,
       ...options?.fromDate ? { fromDate: options.fromDate } : {},
@@ -3770,6 +4248,7 @@ var YieldseekerAgent = class {
       if (this.readGeneration === generation && this.pendingReads.get(key2) === request) {
         this.readCache.set(key2, {
           expiresAt: Date.now() + ttlMs,
+          fetchedAt: Date.now(),
           value
         });
       }
@@ -3970,6 +4449,7 @@ var YieldseekerAgent = class {
       if (agent) {
         this.readCache.set(this.agentListKey(state, chainId), {
           expiresAt: Date.now() + YIELDSEEKER_AGENT_LIST_CACHE_MS,
+          fetchedAt: Date.now(),
           value: {
             agents: [...agents, agent]
           }
@@ -4030,7 +4510,6 @@ var YieldseekerAgent = class {
         ...previous,
         epoch: this.movementEpochs.get(key2) ?? 0,
         delta: previous.delta + delta,
-        expectedBalance: previous.expectedBalance + delta,
         expectedNetDeposits: previous.expectedNetDeposits + delta
       };
     }
@@ -4043,7 +4522,6 @@ var YieldseekerAgent = class {
       epoch: this.movementEpochs.get(key2) ?? 0,
       delta,
       decimals: snapshot.baseAssetDecimals,
-      expectedBalance: BigInt(snapshot.totalValueBase) + delta,
       expectedNetDeposits: BigInt(snapshot.netDepositsBase) + delta
     };
   }
@@ -4072,9 +4550,8 @@ var YieldseekerAgent = class {
         const movement = this.snapshotMovements.get(contextKey);
         const snapshot = response.agentSnapshot;
         if (movement && snapshot.baseAssetDecimals === movement.decimals && /^-?\d+$/.test(snapshot.netDepositsBase) && /^\d+$/.test(snapshot.totalValueBase)) {
-          const balance = BigInt(snapshot.totalValueBase);
           const netDeposits = BigInt(snapshot.netDepositsBase);
-          const reconciled = movement.delta > 0n ? balance >= movement.expectedBalance && netDeposits >= movement.expectedNetDeposits : balance <= movement.expectedBalance && netDeposits <= movement.expectedNetDeposits;
+          const reconciled = movement.delta > 0n ? netDeposits >= movement.expectedNetDeposits : netDeposits <= movement.expectedNetDeposits;
           if (reconciled) {
             this.snapshotMovements.delete(contextKey);
             this.reconcileUntil.delete(contextKey);
@@ -4128,12 +4605,20 @@ var YieldseekerAgent = class {
       const { version, read: read2 } = this.portfolioSnapshot(state, chainId, context, contextKey);
       const parts = this.loadPortfolioParts(state, chainId, context, options, contextKey);
       try {
-        const [snapshot, portfolioParts] = await Promise.all([read2, parts]);
+        let positionsUnavailable = false;
+        const safeParts = options.allowMissingPositions ? parts.catch(() => {
+          positionsUnavailable = true;
+          return { positions: [] };
+        }) : parts;
+        const [snapshot, portfolioParts] = await Promise.all([read2, safeParts]);
         assertSession();
         if (this.portfolioVersion(contextKey) !== version) continue;
         return {
           ...context,
           snapshot: snapshot.agentSnapshot,
+          fetchedAt: this.readCache.get(`snapshot:${contextKey}`)?.fetchedAt,
+          readVersion: version,
+          positionsUnavailable,
           ...portfolioParts
         };
       } catch (error) {
@@ -4324,9 +4809,11 @@ var YieldseekerAgent = class {
       this.id
     );
   }
-  async submitTransaction(state, chainId, transaction) {
+  async submitTransaction(state, chainId, transaction, onSubmitted, onReceipt) {
     if (this.transactionExecutor) {
-      return this.transactionExecutor(state, chainId, transaction);
+      const hash2 = await this.transactionExecutor(state, chainId, transaction);
+      onSubmitted?.(hash2);
+      return hash2;
     }
     this.assertTransaction(transaction, state, chainId);
     const account = getAddress2(state.walletAddress);
@@ -4351,6 +4838,7 @@ var YieldseekerAgent = class {
       data: transaction.data,
       value: BigInt(transaction.value)
     });
+    onSubmitted?.(hash);
     const receipt = await withPaidRpcDiagnostics(
       () => this.getReceiptClient().waitForTransactionReceipt({
         hash,
@@ -4368,6 +4856,7 @@ var YieldseekerAgent = class {
         this.id
       );
     }
+    onReceipt?.(receipt);
     return hash;
   }
   async waitForReceipt(state, chainId, transactionHash) {
@@ -4392,6 +4881,7 @@ var YieldseekerAgent = class {
         this.id
       );
     }
+    return receipt;
   }
   assertTransaction(transaction, state, chainId) {
     if (!transaction || typeof transaction.from !== "string" || !isAddress2(transaction.from) || typeof transaction.to !== "string" || !isAddress2(transaction.to) || typeof transaction.data !== "string" || !/^0x[a-fA-F0-9]*$/.test(transaction.data) || typeof transaction.value !== "string" || !/^[0-9]+$/.test(transaction.value) || transaction.chainId !== chainId || getAddress2(transaction.from) !== getAddress2(state.walletAddress)) {
@@ -4753,7 +5243,7 @@ import {
 } from "viem";
 
 // src/lib/permit2-batch.ts
-import { parseAbi as parseAbi2, hashStruct } from "viem";
+import { parseAbi as parseAbi3, hashStruct } from "viem";
 var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
@@ -4766,7 +5256,7 @@ var ERC2612_PERMIT_TYPES = {
     { name: "deadline", type: "uint256" }
   ]
 };
-var ERC2612_READ_ABI = parseAbi2([
+var ERC2612_READ_ABI = parseAbi3([
   "function name() view returns (string)",
   "function version() view returns (string)",
   "function nonces(address owner) view returns (uint256)"
@@ -4804,7 +5294,7 @@ var PERMIT_BATCH_TYPES = {
     { name: "amount", type: "uint256" }
   ]
 };
-var PERMIT2_BATCH_ABI = parseAbi2([
+var PERMIT2_BATCH_ABI = parseAbi3([
   "struct TokenPermissions { address token; uint256 amount; }",
   "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
   "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
@@ -4904,6 +5394,10 @@ async function execute(i, key2, plan) {
         };
         save(key2, body);
       }
+      try {
+        i.onSubmitted?.(keccak256(body.serializedTransaction));
+      } catch {
+      }
       const result = await postSponsorBatchTransfer({
         apiKey: i.apiKey,
         baseUrl: i.baseUrl,
@@ -5032,7 +5526,8 @@ function makeSponsoredTokenCallback(deps) {
       transfers,
       pub,
       wallet,
-      onApproved: deps.onApproved
+      onApproved: deps.onApproved,
+      onSubmitted: (hash) => deps.onSubmitted?.(hash, transfers)
     });
   };
   const callback = makeVerificationAwareDepositCallback(
@@ -5118,7 +5613,7 @@ async function runAgentDepositBatch(chainId, legs, transfer) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi2, toHex } from "viem";
+import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi3, toHex } from "viem";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -5164,7 +5659,7 @@ function makeSponsoredCallsCallback(deps) {
       to: token,
       value: "0x0",
       data: encodeFunctionData2({
-        abi: erc20Abi2,
+        abi: erc20Abi3,
         functionName: "transfer",
         args: [transfer.to, BigInt(transfer.amount)]
       })
@@ -5226,6 +5721,12 @@ function makeSponsoredCallsCallback(deps) {
         params: [callsId]
       });
       const txHash = status?.receipts?.[0]?.transactionHash;
+      if (txHash && !status?.receipts?.some((receipt) => receipt.transactionHash !== txHash)) {
+        try {
+          deps.onSubmitted?.(txHash, transfers);
+        } catch {
+        }
+      }
       if (status?.receipts?.some((receipt) => receipt.status === "0x0") || typeof status?.status === "number" && status.status >= 400) {
         throw new OwneyError(
           "SPONSOR_REQUEST_FAILED",
@@ -5335,6 +5836,7 @@ var OwneySDK = class {
   paymasterServiceUrl;
   cachedSponsoredCallsCallbacks = /* @__PURE__ */ new Map();
   agentReads = new AgentReads();
+  recoveredFundingReads = /* @__PURE__ */ new Set();
   activationChecks = /* @__PURE__ */ new Map();
   readAgent(agent, method, fetch2, params = null) {
     const key2 = JSON.stringify([
@@ -5448,8 +5950,8 @@ var OwneySDK = class {
     return createPaidRpcClient(VIEM_CHAIN2[chainId], this.rpcUrls);
   }
   /** Builds the default USDC batch callback for the connected wallet. */
-  getDefaultSponsoredCallback(onApproved) {
-    if (!onApproved && this.cachedSponsoredCallback)
+  getDefaultSponsoredCallback(onApproved, onSubmitted) {
+    if (!onApproved && !onSubmitted && this.cachedSponsoredCallback)
       return this.cachedSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
@@ -5458,6 +5960,7 @@ var OwneySDK = class {
       baseUrl: this.routingApiBaseUrl,
       ownerAddress: owner,
       onApproved,
+      onSubmitted,
       tokenAddressByChain: SPONSORED_USDC_BY_CHAIN,
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
@@ -5473,13 +5976,13 @@ var OwneySDK = class {
         transport: custom3(provider)
       })
     });
-    if (!onApproved) this.cachedSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted) this.cachedSponsoredCallback = callback;
     return callback;
   }
   /** Builds the wallet-native sponsored calls callback for compatible paymasters. */
-  getDefaultSponsoredCallsCallback(asset, onApproved) {
+  getDefaultSponsoredCallsCallback(asset, onApproved, onSubmitted) {
     const cached = this.cachedSponsoredCallsCallbacks.get(asset);
-    if (!onApproved && cached) return cached;
+    if (!onApproved && !onSubmitted && cached) return cached;
     const provider = this.requireConnectedProvider();
     const callback = makeSponsoredCallsCallback({
       apiKey: this.apiKey,
@@ -5488,9 +5991,10 @@ var OwneySDK = class {
       ownerAddress: this.state.walletAddress,
       paymasterServiceUrl: this.paymasterServiceUrl,
       onApproved,
+      onSubmitted,
       tokenAddressByChain: sponsoredTokensFor(asset)
     });
-    if (!onApproved) this.cachedSponsoredCallsCallbacks.set(asset, callback);
+    if (!onApproved && !onSubmitted) this.cachedSponsoredCallsCallbacks.set(asset, callback);
     return callback;
   }
   /**
@@ -5499,8 +6003,8 @@ var OwneySDK = class {
    * Mirrors `getDefaultSponsoredCallback()` but signs a Permit2
    * single-use batch authorization instead of an EIP-3009 authorization.
    */
-  getDefaultWethSponsoredCallback(onApproved) {
-    if (!onApproved && this.cachedWethSponsoredCallback)
+  getDefaultWethSponsoredCallback(onApproved, onSubmitted) {
+    if (!onApproved && !onSubmitted && this.cachedWethSponsoredCallback)
       return this.cachedWethSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
@@ -5509,6 +6013,7 @@ var OwneySDK = class {
       baseUrl: this.routingApiBaseUrl,
       ownerAddress: owner,
       onApproved,
+      onSubmitted,
       tokenAddressByChain: SPONSORED_WETH_BY_CHAIN,
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
@@ -5524,7 +6029,7 @@ var OwneySDK = class {
         transport: custom3(provider)
       })
     });
-    if (!onApproved) this.cachedWethSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted) this.cachedWethSponsoredCallback = callback;
     return callback;
   }
   getAgent(agentId) {
@@ -5534,6 +6039,9 @@ var OwneySDK = class {
     }
     return agent;
   }
+  getActiveAgentIds() {
+    return [...this.getActiveAgents().keys()].sort();
+  }
   getActiveAgents() {
     const active = /* @__PURE__ */ new Map();
     for (const id of this.activeAgents) {
@@ -5828,12 +6336,23 @@ var OwneySDK = class {
    */
   async deposit(options) {
     const { amount, asset, depositCallback, agentId, onApproved } = options;
+    const prepared = /* @__PURE__ */ new Map();
+    const onProgress = options.onProgress ? (evidence) => {
+      if (evidence.agentWallet) prepared.set(evidence.agentWallet.toLowerCase(), evidence);
+      notifyFunding(options.onProgress, evidence);
+    } : void 0;
+    const onSubmitted = onProgress ? (hash, destinations) => {
+      for (const destination of destinations) {
+        const evidence = prepared.get(destination.to.toLowerCase());
+        if (evidence) notifyFunding(onProgress, { ...evidence, txHash: hash, transfer: "pending" });
+      }
+    } : void 0;
     if (BigInt(amount) === 0n) {
       return { agentResults: {} };
     }
     const state = this.requireState();
     const chainId = this.requireChainId();
-    const effectiveCallback = depositCallback ?? (this.paymasterServiceUrl ? this.getDefaultSponsoredCallsCallback(asset, onApproved) : asset === "WETH" ? this.getDefaultWethSponsoredCallback(onApproved) : this.getDefaultSponsoredCallback(onApproved));
+    const effectiveCallback = depositCallback ?? (this.paymasterServiceUrl ? this.getDefaultSponsoredCallsCallback(asset, onApproved, onSubmitted) : asset === "WETH" ? this.getDefaultWethSponsoredCallback(onApproved, onSubmitted) : this.getDefaultSponsoredCallback(onApproved, onSubmitted));
     if (agentId) {
       if (this.isAgentDisabled(agentId)) {
         throw new OwneyError(
@@ -5852,7 +6371,8 @@ var OwneySDK = class {
         amount,
         asset,
         effectiveCallback,
-        depositCallback
+        depositCallback,
+        onProgress
       );
     }
     const totalAmount = BigInt(amount);
@@ -5916,7 +6436,7 @@ var OwneySDK = class {
           run: (callback) => withFailureReporting(
             this.apiKey,
             agent.id,
-            () => agent.deposit(state, chainId, amount2, asset, callback),
+            () => onProgress ? agent.deposit(state, chainId, amount2, asset, callback, onProgress) : agent.deposit(state, chainId, amount2, asset, callback),
             this.routingApiBaseUrl
           )
         })),
@@ -5953,7 +6473,8 @@ var OwneySDK = class {
           agentAmount,
           asset,
           effectiveCallback,
-          depositCallback
+          depositCallback,
+          onProgress
         );
       } catch (error) {
         if (Object.keys(agentResults).length === 0) throw error;
@@ -6000,17 +6521,11 @@ var OwneySDK = class {
    * propagates unchanged. Scoped per agent invocation so one agent's failure
    * doesn't force a retry of sibling agents in a multi-agent split.
    */
-  async depositWithFallback(agent, state, chainId, amount, asset, effectiveCallback, appCallback) {
+  async depositWithFallback(agent, state, chainId, amount, asset, effectiveCallback, appCallback, onProgress) {
     const attempt = (callback) => withFailureReporting(
       this.apiKey,
       agent.id,
-      () => agent.deposit(
-        state,
-        chainId,
-        amount,
-        asset,
-        callback
-      ),
+      () => onProgress ? agent.deposit(state, chainId, amount, asset, callback, onProgress) : agent.deposit(state, chainId, amount, asset, callback),
       this.routingApiBaseUrl
     );
     let approvalAttempted = false;
@@ -6190,15 +6705,81 @@ var OwneySDK = class {
     while (current && typeof current === "object" && !seen.has(current)) {
       seen.add(current);
       const candidate = current;
-      if (candidate.code === 4001 || candidate.code === "4001") return true;
+      if (candidate.code === 4001 || candidate.code === "4001" || candidate.code === "ACTION_REJECTED") return true;
       const message = [candidate.message, candidate.shortMessage].filter((value) => typeof value === "string").join(" ");
-      if (/user (?:rejected|denied)|rejected by user/i.test(message)) {
+      if (/user (?:rejected|denied)|rejected by user|request rejected/i.test(message)) {
         return true;
       }
       current = candidate.cause;
     }
     return false;
   }
+  captureReadScope(requestedChain) {
+    const original = this.requireState();
+    const chainId = this.requireChainId();
+    if (requestedChain !== void 0 && requestedChain !== chainId) {
+      throw new OwneyError("NO_ACTIVE_CHAIN", "Account read scope changed. Please retry.");
+    }
+    const wallet = original.walletAddress;
+    return { state: { ...original }, chainId, assertCurrent: () => {
+      if (this.state !== original || this.state.walletAddress !== wallet || this.state.chainId !== chainId)
+        throw new OwneyError("NOT_CONNECTED", "Account read scope changed. Please retry.");
+    } };
+  }
+  /** Revalidate a saved transfer against the authenticated account and actual receipt. */
+  async inspectFunding(evidence, direction, options = {}) {
+    const { state, chainId, assertCurrent } = this.captureReadScope(evidence.chainId);
+    if (state.walletAddress.toLowerCase() !== evidence.walletAddress.toLowerCase() || !evidence.txHash)
+      throw new OwneyError("AGENT_API_ERROR", "Funding evidence does not match the connected account.");
+    const agent = this.getAgent(evidence.agentId);
+    const verifiedWallet = agent.getFundingWallet ? await agent.getFundingWallet(state, chainId, evidence.token) : (await agent.getUserProfile(state, chainId)).smartWallet;
+    const agentWallet = evidence.agentWallet ?? verifiedWallet;
+    if (!agentWallet || agentWallet.toLowerCase() !== verifiedWallet.toLowerCase())
+      throw new OwneyError("AGENT_API_ERROR", "Funding wallet does not match this account.");
+    const token = SupportedAssets.find((t) => t.chainId === chainId && t.symbol === evidence.token);
+    if (!token) throw new OwneyError("CHAIN_UNSUPPORTED", "Unsupported funding asset.");
+    const rpc = this.getPaidRpcClient(chainId);
+    const receipt = await rpc.getTransactionReceipt({ hash: evidence.txHash });
+    assertCurrent();
+    let verified = inspectFundingReceipt(receipt, { ...evidence, agentWallet }, token.address, direction);
+    if (direction === "withdraw" && evidence.agentId === "yieldseeker" && verified.transfer === "unknown" && verified.confirmedAmount && BigInt(verified.confirmedAmount) > 0n) {
+      const transaction = await rpc.getTransaction({ hash: evidence.txHash });
+      assertCurrent();
+      if (isFullYieldseekerWithdrawal(transaction, { ...evidence, agentWallet }, token.address))
+        verified = inspectFundingReceipt(receipt, { ...evidence, agentWallet, intendedAmount: "MAX" }, token.address, direction);
+    }
+    const key2 = `${state.walletAddress.toLowerCase()}:${chainId}:${evidence.agentId}:${evidence.token}:${evidence.txHash}`;
+    if ((verified.transfer === "confirmed" || verified.transfer === "failed" && verified.confirmedAmount === "0") && !this.recoveredFundingReads.has(key2)) {
+      if (options.refreshBalance !== false)
+        agent.invalidateFundingRead?.(state, chainId, evidence.token, options.balanceRefreshUntil);
+      this.recoveredFundingReads.add(key2);
+      if (this.recoveredFundingReads.size > 256) this.recoveredFundingReads.delete(this.recoveredFundingReads.values().next().value);
+    }
+    return verified;
+  }
+  /** A display acknowledgement controls polling only; it never confirms a financial outcome. */
+  endFundingBalanceRefresh(evidence, read2) {
+    const { state, chainId } = this.captureReadScope(evidence.chainId);
+    if (state.walletAddress.toLowerCase() !== evidence.walletAddress.toLowerCase() || read2.chainId !== chainId || read2.asset.toUpperCase() !== evidence.token) return false;
+    return this.getAgent(evidence.agentId).endFundingBalanceRefresh?.(state, chainId, evidence.token, read2) ?? false;
+  }
+  /** History lookup for receipt recovery; adapters may not authenticate or sign here. */
+  async getFundingHistory(evidence, fromDate, options) {
+    const { state, chainId, assertCurrent } = this.captureReadScope(evidence.chainId);
+    if (state.walletAddress.toLowerCase() !== evidence.walletAddress.toLowerCase())
+      throw new OwneyError("NOT_CONNECTED", "Funding account changed.");
+    const agent = this.getAgent(evidence.agentId);
+    if (!agent.getFundingHistory) return { data: [], hasMore: false };
+    const filters = { tokenSymbol: evidence.token, fromDate, limit: 50, ...options };
+    const page = await this.readAgent(agent, "history", () => agent.getFundingHistory(state, chainId, filters), filters);
+    assertCurrent();
+    return page;
+  }
+  async recoverDepositRegistration(evidence) {
+    const verified = await this.inspectFunding(evidence, "deposit");
+    if (verified.agentId !== "zyfai") return verified;
+    return this.getAgent("zyfai").retryDepositRegistration(this.requireState(), verified);
+  }
   // --- Fund operations ---
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
@@ -6210,17 +6791,66 @@ var OwneySDK = class {
    * @returns {AgentWithdrawResult} for a single agent, or {OwneyWithdrawResult} with per-agent results
    */
   async withdraw(options) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const ids = options.agentId ? [options.agentId] : this.getActiveAgentIds().filter((id) => !options.excludeAgentIds?.includes(id));
+    const attempted = /* @__PURE__ */ new Set();
+    try {
+      return await this.withdrawFromAgents(options, state, chainId, attempted);
+    } catch (error) {
+      for (const id of ids) if (!attempted.has(id)) {
+        notifyFunding(options.onProgress, {
+          agentId: id,
+          chainId,
+          token: options.asset,
+          walletAddress: state.walletAddress,
+          intendedAmount: options.amount ?? "MAX",
+          transfer: "failed",
+          registration: "not-applicable",
+          delivery: "failed"
+        });
+      }
+      throw error;
+    }
+  }
+  async withdrawFromAgents(options, state, chainId, attempted) {
     const { asset, amount, agentId, onAgentResult } = options;
     const notifyAgentResult = (id, result) => {
       try {
+        if (result.evidence) notifyFunding(options.onProgress, result.evidence);
         onAgentResult?.(id, result);
       } catch (error) {
         console.warn("Withdrawal result observer failed:", error);
       }
     };
-    const state = this.requireState();
-    const chainId = this.requireChainId();
     const token = asset;
+    const submissionEvidence = /* @__PURE__ */ new Map();
+    const submit = async (agent, requested2) => {
+      attempted.add(agent.id);
+      let evidence = {
+        agentId: agent.id,
+        chainId,
+        token,
+        walletAddress: state.walletAddress,
+        intendedAmount: requested2 ?? "MAX",
+        transfer: "pending",
+        registration: "not-applicable",
+        delivery: "pending"
+      };
+      const progress = (next) => {
+        evidence = { ...evidence, ...next };
+        submissionEvidence.set(agent.id, evidence);
+        notifyFunding(options.onProgress, evidence);
+      };
+      progress(evidence);
+      try {
+        return await agent.withdraw(state, chainId, token, requested2, progress);
+      } catch (error) {
+        if (!evidence.txHash && (this.isUserRejectedWithdrawal(error) || /insufficient (balance|funds)/i.test(error instanceof Error ? error.message : "")))
+          progress({ ...evidence, transfer: "failed", delivery: "failed" });
+        throw error;
+      }
+    };
     const assetInfo = SupportedAssets.find(
       (a) => a.chainId === chainId && a.symbol === token
     );
@@ -6236,23 +6866,24 @@ var OwneySDK = class {
       const result = await withFailureReporting(
         this.apiKey,
         agent.id,
-        () => agent.withdraw(state, chainId, token, amount),
+        () => submit(agent, amount),
         this.routingApiBaseUrl
       );
       notifyAgentResult(agent.id, result);
       return result;
     }
-    const eligibleAgents = this.getEligibleAgents(chainId, asset);
+    const eligibleAgents = this.getEligibleAgents(chainId, asset).filter((agent) => !options.excludeAgentIds?.includes(agent.id));
     const withdrawalAgents = this.orderAgentsForWithdrawal(eligibleAgents);
     if (!amount) {
       const results2 = {};
       const agentErrors2 = {};
       for (const agent of withdrawalAgents) {
         try {
-          results2[agent.id] = await agent.withdraw(state, chainId, token);
+          results2[agent.id] = await submit(agent);
           notifyAgentResult(agent.id, results2[agent.id]);
         } catch (err) {
           if (this.isUserRejectedWithdrawal(err)) throw err;
+          if (err instanceof OwneyError && err.code === "WITHDRAW_INSUFFICIENT_BALANCE" && err.details?.available === "0" && submissionEvidence.get(agent.id)?.transfer === "failed") continue;
           console.error(`withdraw failed for agent "${agent.id}":`, err);
           agentErrors2[agent.id] = err instanceof Error ? err.message : String(err);
           const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
@@ -6271,6 +6902,13 @@ var OwneySDK = class {
           { asset, agentErrors: agentErrors2 }
         );
       }
+      if (Object.keys(agentErrors2).length > 0) {
+        throw new OwneyError(
+          "WITHDRAW_PARTIAL_FAILURE",
+          "Some agents could not complete the withdrawal.",
+          { asset, partialResults: results2, agentErrors: agentErrors2 }
+        );
+      }
       const amountsKnown = Object.values(results2).every(
         (result) => typeof result.amount === "string" && /^\d+$/.test(result.amount)
       );
@@ -6280,7 +6918,7 @@ var OwneySDK = class {
       };
     }
     const requested = BigInt(amount);
-    const aggregated = await this.getBalances();
+    const aggregated = await this.getBalances(void 0, { chainId, asset: token });
     const unavailableAgents = eligibleAgents.filter(
       (agent) => !(agent.id in aggregated.agentBalances)
     );
@@ -6342,12 +6980,7 @@ var OwneySDK = class {
       const p = orderedPlans[i];
       if (p.planned === 0n) continue;
       try {
-        results[p.agent.id] = await p.agent.withdraw(
-          state,
-          chainId,
-          token,
-          p.planned.toString()
-        );
+        results[p.agent.id] = await submit(p.agent, p.planned.toString());
         notifyAgentResult(p.agent.id, results[p.agent.id]);
       } catch (err) {
         if (this.isUserRejectedWithdrawal(err)) throw err;
@@ -6362,7 +6995,8 @@ var OwneySDK = class {
         );
         const failedAmount = p.planned;
         p.planned = 0n;
-        redistributeShare(orderedPlans, i, failedAmount);
+        if (submissionEvidence.get(p.agent.id)?.transfer === "failed")
+          redistributeShare(orderedPlans, i, failedAmount);
       }
     }
     if (Object.keys(results).length === 0) {
@@ -6399,12 +7033,19 @@ var OwneySDK = class {
    * @param agentId - Optional. Agent to query. Omit for aggregated balances.
    * @returns {AgentBalance} for a single agent, or {OwneyBalances} with totalBalance and per-agent breakdown
    */
-  async getBalances(agentId) {
-    const state = this.requireState();
-    const chainId = this.requireChainId();
+  async getBalances(agentId, options) {
+    const { state, chainId, assertCurrent } = this.captureReadScope(options?.chainId);
+    const asset = options?.asset;
+    const readBalance = (agent) => this.readAgent(
+      agent,
+      "balances",
+      () => asset ? agent.getBalances(state, chainId, asset) : agent.getBalances(state, chainId),
+      asset ? { asset } : null
+    );
     if (agentId) {
       const agent = this.getAgent(agentId);
-      const result = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
+      const result = await readBalance(agent);
+      assertCurrent();
       return {
         ...result,
         balanceComposition: agent.balanceComposition ?? "tokens-include-positions"
@@ -6415,7 +7056,7 @@ var OwneySDK = class {
     const entries = [...this.getActiveAgents().entries()];
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
-        const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
+        const b = await readBalance(agent);
         return [
           id,
           {
@@ -6425,6 +7066,7 @@ var OwneySDK = class {
         ];
       })
     );
+    assertCurrent();
     let successCount = 0;
     const agentErrors = {};
     const agentRetryAt = {};
@@ -6692,12 +7334,13 @@ var OwneySDK = class {
    * @returns {OwneyAgentHistory} `data` (up to `limit` entries), `hasMore`, `nextCursor`.
    */
   async getHistory(options) {
-    const state = this.requireState();
-    const chainId = this.requireChainId();
+    const { state, chainId, assertCurrent } = this.captureReadScope(options?.chainId);
     const { agentId, filters } = options ?? {};
     if (agentId) {
       const agent = this.getAgent(agentId);
-      return this.readAgent(agent, "history", () => agent.getHistory(state, chainId, filters), filters);
+      const page = await this.readAgent(agent, "history", () => agent.getHistory(state, chainId, filters), filters);
+      assertCurrent();
+      return page;
     }
     const activeAgents = [...this.getActiveAgents().values()];
     const cursorMap = filters?.cursor ? decodeMultiAgentCursor(filters.cursor) : {};
@@ -6707,20 +7350,35 @@ var OwneySDK = class {
         if (filters?.cursor && agentCursor === void 0) {
           return { agentId: agent.id, page: null };
         }
-        const agentFilters = { ...filters, cursor: agentCursor };
-        const page = await this.readAgent(
-          agent,
-          "history",
-          () => agent.getHistory(state, chainId, agentFilters),
-          agentFilters
-        );
-        return { agentId: agent.id, page };
+        const agentFilters = { ...filters, cursor: agentCursor || void 0 };
+        try {
+          const page = await this.readAgent(
+            agent,
+            "history",
+            () => agent.getHistory(state, chainId, agentFilters),
+            agentFilters
+          );
+          return { agentId: agent.id, page };
+        } catch (error) {
+          return { agentId: agent.id, page: null, error };
+        }
       })
     );
+    assertCurrent();
+    const agentErrors = {};
+    const agentRetryAt = {};
     const merged = [];
     const nextCursorMap = {};
     let hasMore = false;
-    for (const { agentId: id, page } of perAgent) {
+    for (const result of perAgent) {
+      const { agentId: id, page } = result;
+      if ("error" in result) {
+        agentErrors[id] = result.error instanceof Error ? result.error.message : String(result.error);
+        const delay = rateLimitDelay(result.error);
+        if (delay !== void 0) agentRetryAt[id] = Date.now() + delay;
+        nextCursorMap[id] = cursorMap[id] ?? "";
+        hasMore = true;
+      }
       if (!page) continue;
       merged.push(...page.data);
       if (page.hasMore && page.nextCursor) {
@@ -6740,6 +7398,7 @@ var OwneySDK = class {
     });
     return {
       data: merged,
+      ...Object.keys(agentErrors).length ? { agentErrors, agentRetryAt } : {},
       hasMore,
       nextCursor: hasMore ? encodeMultiAgentCursor(nextCursorMap) : void 0
     };