@owney/sdk 0.7.25-beta.1 → 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;
@@ -125,6 +215,34 @@ function rateLimitDelay(error, now = Date.now()) {
 }
 
 // src/lib/agent-reads.ts
+function rateLimitDiagnostics(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let details = {};
+  function visit(value, depth = 0) {
+    if (depth > 6 || !value || typeof value !== "object" || seen.has(value))
+      return;
+    seen.add(value);
+    const record = value;
+    for (const key2 of [
+      "rpcSource",
+      "chainId",
+      "rpcMethod",
+      "providerRequestId",
+      "statusCode"
+    ]) {
+      const candidate = record[key2];
+      if (candidate !== void 0 && details[key2] === void 0)
+        details = { ...details, [key2]: candidate };
+    }
+    for (const key2 of ["details", "cause", "response", "fields", "error"])
+      visit(record[key2], depth + 1);
+  }
+  visit(error);
+  return {
+    rpcSource: details.rpcSource ?? "agent-api",
+    ...details
+  };
+}
 var AgentReads = class {
   inFlight = /* @__PURE__ */ new Map();
   cooldowns = /* @__PURE__ */ new Map();
@@ -132,14 +250,15 @@ var AgentReads = class {
   clearInFlight() {
     this.inFlight.clear();
   }
-  limited(agentId, until) {
+  limited(agentId, until, diagnostics) {
     return new OwneyError(
       "AGENT_RATE_LIMITED",
       "Too many requests. Please wait before trying again.",
       {
         statusCode: 429,
         retryAt: until,
-        retryAfterSeconds: Math.max(0, Math.ceil((until - Date.now()) / 1e3))
+        retryAfterSeconds: Math.max(0, Math.ceil((until - Date.now()) / 1e3)),
+        ...diagnostics
       },
       agentId
     );
@@ -147,7 +266,9 @@ var AgentReads = class {
   run(agentId, key2, fetch2) {
     const cooldown = this.cooldowns.get(agentId);
     if (cooldown && cooldown.until > Date.now()) {
-      return Promise.reject(this.limited(agentId, cooldown.until));
+      return Promise.reject(
+        this.limited(agentId, cooldown.until, cooldown.diagnostics)
+      );
     }
     const requestKey = JSON.stringify([agentId, key2]);
     const existing = this.inFlight.get(requestKey);
@@ -168,8 +289,9 @@ var AgentReads = class {
           Math.min(3e4 * 2 ** (failures - 1), 3e5)
         );
         const until = Math.max(previous?.until ?? 0, Date.now() + delay);
-        this.cooldowns.set(agentId, { until, failures });
-        throw this.limited(agentId, until);
+        const diagnostics = rateLimitDiagnostics(error);
+        this.cooldowns.set(agentId, { until, failures, diagnostics });
+        throw this.limited(agentId, until, diagnostics);
       }
     ).finally(() => {
       if (this.inFlight.get(requestKey) === promise)
@@ -180,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 { createPublicClient, http, parseAbi } from "viem";
+import { formatUnits, parseAbi as parseAbi2 } from "viem";
 import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/types/config.ts
@@ -355,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)) {
@@ -364,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",
@@ -414,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 } : {}
   };
 }
@@ -754,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";
@@ -1063,15 +1240,148 @@ function protocolsPolicyNeedsUpdate(current, desiredProtocols, desiredAutoSelect
   return !protocolListsEqual(current.protocols, desiredProtocols);
 }
 
+// src/lib/paid-rpc.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+var PAID_RPC_RETRY_COUNT = 3;
+var PAID_RPC_RETRY_DELAY_MS = 1e3;
+function configuredRpcProxyBaseUrl(baseUrl) {
+  const configured = (baseUrl ?? "")?.trim();
+  if (!configured) {
+    throw new Error(
+      "OWNEY_ROUTING_API_BASE_URL is required for RPC proxy requests unless routingApiBaseUrl or all rpcUrls are configured."
+    );
+  }
+  return configured;
+}
+function rpcProxyUrl(chainId, apiKey, baseUrl) {
+  const url = new URL(
+    `${configuredRpcProxyBaseUrl(baseUrl).replace(/\/$/, "")}/api/v1/rpc/${chainId}`
+  );
+  if (apiKey) url.searchParams.set("apiKey", apiKey);
+  return url.toString();
+}
+function resolveRpcUrl(rpcUrls, chainId, apiKey = "", baseUrl) {
+  const url = rpcUrls?.[chainId]?.trim();
+  if (url) return url;
+  return rpcProxyUrl(chainId, apiKey, baseUrl);
+}
+function resolveRpcUrls(rpcUrls, apiKey = "", baseUrl) {
+  return {
+    1: resolveRpcUrl(rpcUrls, 1, apiKey, baseUrl),
+    8453: resolveRpcUrl(rpcUrls, 8453, apiKey, baseUrl),
+    42161: resolveRpcUrl(rpcUrls, 42161, apiKey, baseUrl)
+  };
+}
+function createPaidRpcClient(chain, rpcUrls) {
+  const url = resolveRpcUrl(
+    rpcUrls,
+    chain.id
+  );
+  return createPublicClient({
+    chain,
+    transport: http(url, {
+      retryCount: PAID_RPC_RETRY_COUNT,
+      retryDelay: PAID_RPC_RETRY_DELAY_MS
+    })
+  });
+}
+function headerValue(error, name) {
+  const seen = /* @__PURE__ */ new Set();
+  let value;
+  function visit(candidate, depth = 0) {
+    if (value || depth > 6 || !candidate || typeof candidate !== "object")
+      return;
+    if (seen.has(candidate)) return;
+    seen.add(candidate);
+    const record = candidate;
+    const headers = record.headers;
+    let found;
+    if (typeof headers?.get === "function") {
+      found = headers.get(name);
+    } else {
+      const headerRecord = headers;
+      found = headerRecord?.[name] ?? headerRecord?.[name.toLowerCase()];
+    }
+    if (typeof found === "string" && found) {
+      value = found;
+      return;
+    }
+    for (const key2 of ["cause", "details", "response", "error"])
+      visit(record[key2], depth + 1);
+  }
+  visit(error);
+  return value;
+}
+function statusCode(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let status;
+  function visit(candidate, depth = 0) {
+    if (status || depth > 6 || !candidate || typeof candidate !== "object")
+      return;
+    if (seen.has(candidate)) return;
+    seen.add(candidate);
+    const record = candidate;
+    for (const key2 of ["status", "statusCode"]) {
+      const parsed = Number(record[key2]);
+      if (Number.isInteger(parsed) && parsed >= 100 && parsed <= 599) {
+        status = parsed;
+        return;
+      }
+    }
+    for (const key2 of ["cause", "details", "response", "error"])
+      visit(record[key2], depth + 1);
+  }
+  visit(error);
+  return status;
+}
+function paidRpcError(error, chainId, rpcMethod, agentId) {
+  const delay = rateLimitDelay(error);
+  const providerRequestId = headerValue(error, "x-alchemy-request-id") ?? headerValue(error, "x-request-id");
+  if (delay === void 0) {
+    return new OwneyError(
+      "AGENT_API_ERROR",
+      "The blockchain RPC request failed.",
+      {
+        rpcSource: "paid-rpc",
+        chainId,
+        rpcMethod,
+        ...statusCode(error) ? { statusCode: statusCode(error) } : {},
+        ...providerRequestId ? { providerRequestId } : {}
+      },
+      agentId
+    );
+  }
+  const retryAt = Date.now() + delay;
+  return new OwneyError(
+    "AGENT_RATE_LIMITED",
+    "The blockchain RPC is rate limited. Please wait before trying again.",
+    {
+      rpcSource: "paid-rpc",
+      chainId,
+      rpcMethod,
+      statusCode: 429,
+      retryAt,
+      retryAfterSeconds: Math.max(0, Math.ceil(delay / 1e3)),
+      ...providerRequestId ? { providerRequestId } : {}
+    },
+    agentId
+  );
+}
+async function withPaidRpcDiagnostics(operation, chainId, rpcMethod, agentId) {
+  try {
+    return await operation();
+  } catch (error) {
+    throw paidRpcError(error, 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 DEFAULT_ZYFAI_RPC_URLS = {
-  8453: "https://base-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
-  42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
-  1: "https://eth-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
-};
 var WETH_ADDRESS_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -1128,16 +1438,15 @@ 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;
   earningsGeneration = 0;
   constructor(apiKey, rpcUrls, referralSource) {
-    this.rpcUrls = rpcUrls ?? DEFAULT_ZYFAI_RPC_URLS;
+    this.rpcUrls = resolveRpcUrls(rpcUrls);
     this.sdk = new ZyfaiSDK({
       apiKey,
       rpcUrls: this.rpcUrls,
@@ -1151,16 +1460,17 @@ var ZyfaiAgent = class _ZyfaiAgent {
   getPublicClient(chainId) {
     const cached = this.publicClients.get(chainId);
     if (cached) return cached;
-    const client = createPublicClient({
-      chain: VIEM_CHAIN[chainId],
-      transport: http(this.rpcUrls[chainId])
-    });
+    const client = createPaidRpcClient(
+      VIEM_CHAIN[chainId],
+      this.rpcUrls
+    );
     this.publicClients.set(chainId, client);
     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.
@@ -1172,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 {
         }
@@ -1302,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.
@@ -1335,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
@@ -1880,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);
@@ -1889,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(
@@ -1909,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.",
@@ -1932,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([
@@ -2011,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.
    */
@@ -2030,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;
@@ -2071,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
     };
@@ -2127,7 +2606,7 @@ import {
   createWalletClient as createWalletClient2,
   custom as custom2,
   encodeFunctionData,
-  erc20Abi,
+  erc20Abi as erc20Abi2,
   getAddress as getAddress2,
   isAddress as isAddress2
 } from "viem";
@@ -2287,11 +2766,12 @@ async function postSponsorBatchTransfer(input) {
 // src/lib/permit2.ts
 import { bytesToHex as bytesToHex2 } from "viem";
 var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var MAX_UINT256 = 2n ** 256n - 1n;
 function permit2ApprovalAmount(requiredAmount) {
   if (requiredAmount <= 0n) {
     throw new Error("Permit2 approval requires a positive deposit amount");
   }
-  return requiredAmount;
+  return MAX_UINT256;
 }
 var ERC20_ALLOWANCE_ABI = [
   {
@@ -2327,12 +2807,13 @@ function randomPermit2Nonce() {
   globalThis.crypto.getRandomValues(bytes);
   return BigInt(bytesToHex2(bytes));
 }
-async function readPermit2Allowance(publicClient, token, owner) {
+async function readPermit2Allowance(publicClient, token, owner, blockNumber) {
   return publicClient.readContract({
     address: token,
     abi: ERC20_ALLOWANCE_ABI,
     functionName: "allowance",
-    args: [owner, PERMIT2_ADDRESS]
+    args: [owner, PERMIT2_ADDRESS],
+    ...blockNumber === void 0 ? {} : { blockNumber }
   });
 }
 async function readErc20Balance(publicClient, token, owner) {
@@ -2720,10 +3201,11 @@ var YieldseekerApiClient = class {
       const payload = await response.json().catch(() => null);
       if (!response.ok) {
         const error = providerError(payload, `HTTP_${response.status}`);
+        const retryAfter = response.headers.get("Retry-After");
         throw new YieldseekerApiError(
           response.status,
           error.code,
-          error.fields
+          retryAfter ? { ...error.fields, headers: { "Retry-After": retryAfter } } : error.fields
         );
       }
       if (payload && typeof payload === "object" && payload.success === true && "data" in payload) {
@@ -2745,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;
@@ -2812,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);
@@ -2854,13 +3336,14 @@ function position(value, asset, baseAssetDecimals) {
     // differ from the underlying asset. Yieldseeker already converts it to
     // underlying base-asset units in `assetsBase`; pair that value with the
     // snapshot's corresponding `baseAssetDecimals` for display. Keep the raw
-    // share quantity separately because withdraw-from-position expects it.
+    // share quantity separate from the withdrawable underlying asset amount.
     amount: decimal(
       value.assetsBase,
       baseAssetDecimals,
       "yield positions"
     ),
     amountRaw: String(value.assetsRaw),
+    withdrawableAmountRaw: String(value.withdrawableAssetsRaw),
     apy: percent(option.riskAdjustedApy),
     tvl: Number(option.totalDepositsUsd),
     liquidity: Number(option.withdrawableDepositsUsd)
@@ -2910,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) {
@@ -2922,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,
@@ -3024,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,
@@ -3053,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;
@@ -3078,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(
@@ -3123,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);
@@ -3136,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 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 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 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) {
@@ -3185,10 +3724,18 @@ function mapYieldseekerAgentApy(options, days) {
 
 // src/agents/yieldseeker/yieldseeker.agent.ts
 var OWNEY_AGENT_NAME = "owney";
+var OWNEY_AGENT_RULE_PRESET = "explorative";
 var YIELDSEEKER_USERNAME_PREFIX = "owney_";
 var YIELDSEEKER_USERNAME_RANDOM_LENGTH = 14;
 var YIELDSEEKER_USERNAME_CREATE_ATTEMPTS = 3;
 var YIELDSEEKER_YIELD_OPTIONS_CACHE_MS = 6e4;
+var YIELDSEEKER_AGENT_LIST_CACHE_MS = 12e4;
+var YIELDSEEKER_PORTFOLIO_CACHE_MS = 12e4;
+var YIELDSEEKER_SETTLEMENT_CACHE_MS = 5e3;
+var YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS = 15e3;
+var YIELDSEEKER_READ_FAILURE_COOLDOWN_MS = 6e4;
+var YIELDSEEKER_SETTLEMENT_WINDOW_MS = 5 * 6e4;
+var YIELDSEEKER_ACTIVITY_CACHE_MS = 6e4;
 function generateYieldseekerUsername() {
   const suffix = globalThis.crypto.randomUUID().replaceAll("-", "").slice(0, YIELDSEEKER_USERNAME_RANDOM_LENGTH).toLowerCase();
   return `${YIELDSEEKER_USERNAME_PREFIX}${suffix}`;
@@ -3232,6 +3779,7 @@ function query(params) {
 var YieldseekerAgent = class {
   id = "yieldseeker";
   balanceComposition = "tokens-plus-positions";
+  withdrawalRequiresWalletApproval = true;
   supportedChainIds = [8453];
   supportedAssets = [
     {
@@ -3245,11 +3793,26 @@ var YieldseekerAgent = class {
   ];
   api;
   auth;
+  rpcUrls;
+  receiptClient;
   transactionExecutor;
   unwindReceiptWaiter;
   agentContexts = /* @__PURE__ */ new Map();
   users = /* @__PURE__ */ new Map();
   pendingAgents = /* @__PURE__ */ new Map();
+  pendingWalletContexts = /* @__PURE__ */ new Map();
+  readCache = /* @__PURE__ */ new Map();
+  pendingReads = /* @__PURE__ */ new Map();
+  readGeneration = 0;
+  portfolioVersions = /* @__PURE__ */ new Map();
+  snapshotFailures = /* @__PURE__ */ new Map();
+  standardReadFailures = /* @__PURE__ */ new Map();
+  reconcileUntil = /* @__PURE__ */ new Map();
+  activityRefreshUntil = /* @__PURE__ */ new Map();
+  // null means a confirmed movement has no reliable baseline. Do not guess
+  // settlement; keep slow reconciliation after the fast window expires.
+  snapshotMovements = /* @__PURE__ */ new Map();
+  movementEpochs = /* @__PURE__ */ new Map();
   yieldOptions = /* @__PURE__ */ new Map();
   pendingYieldOptions = /* @__PURE__ */ new Map();
   constructor(owneyApiKey, options = {}) {
@@ -3259,10 +3822,16 @@ var YieldseekerAgent = class {
       options.fetchFn
     );
     this.auth = new YieldseekerAuth(options.auth);
+    this.rpcUrls = options.rpcUrls;
     this.transactionExecutor = options.transactionExecutor;
     this.unwindReceiptWaiter = options.unwindReceiptWaiter;
   }
+  getReceiptClient() {
+    this.receiptClient ??= createPaidRpcClient(base3, this.rpcUrls);
+    return this.receiptClient;
+  }
   async disconnect() {
+    this.readGeneration += 1;
     this.auth.clear();
     for (const key2 of this.users.keys()) {
       const [walletAddress, chainId] = key2.split(":");
@@ -3271,6 +3840,16 @@ var YieldseekerAgent = class {
     this.users.clear();
     this.agentContexts.clear();
     this.pendingAgents.clear();
+    this.pendingWalletContexts.clear();
+    this.readCache.clear();
+    this.pendingReads.clear();
+    this.portfolioVersions.clear();
+    this.snapshotFailures.clear();
+    this.standardReadFailures.clear();
+    this.reconcileUntil.clear();
+    this.activityRefreshUntil.clear();
+    this.snapshotMovements.clear();
+    this.movementEpochs.clear();
   }
   async activateAgent(state, chainId, asset) {
     this.assertChain(chainId);
@@ -3278,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) {
@@ -3290,49 +3869,85 @@ 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;
-    try {
-      if (depositCallback) {
-        provideDepositVerificationContext(depositCallback, {
-          agentId: "yieldseeker",
-          signature: await this.auth.getToken(state, chainId),
-          userId: context.user.userId,
-          yieldseekerAgentId: context.agent.agentId
-        });
-        txHash = await depositCallback(
-          context.wallet.walletAddress,
-          chainId,
-          amount
-        );
-        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,
-            functionName: "transfer",
-            args: [getAddress2(context.wallet.walletAddress), BigInt(amount)]
-          }),
-          value: "0",
-          chainId
-        });
-      }
-    } finally {
-      await this.refreshSnapshotAfterMovement(
-        state,
+    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",
+        signature: await this.auth.getToken(state, chainId),
+        userId: context.user.userId,
+        yieldseekerAgentId: context.agent.agentId
+      });
+      txHash = await depositCallback(
+        context.wallet.walletAddress,
         chainId,
-        context,
-        "deposit"
+        amount
       );
+      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: erc20Abi2,
+          functionName: "transfer",
+          args: [getAddress2(context.wallet.walletAddress), BigInt(amount)]
+        }),
+        value: "0",
+        chainId
+      }, submitted, (value) => {
+        receipt = value;
+      });
     }
-    return {
-      txHash,
-      smartWallet: context.wallet.walletAddress,
-      amount
+    if (this.readGeneration === generation) {
+      void this.refreshSnapshotAfterMovement(state, chainId, context, "deposit", movement);
+    }
+    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) {
@@ -3352,6 +3967,9 @@ var YieldseekerAgent = class {
         this.id
       );
     }
+    const generation = this.readGeneration;
+    let confirmedMovement = false;
+    let settlement = null;
     try {
       const portfolio = await this.loadPortfolioContext(
         state,
@@ -3359,16 +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);
+      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",
@@ -3404,6 +4038,7 @@ var YieldseekerAgent = class {
           throw this.invalidResponse("position withdrawal");
         }
         await this.waitForReceipt(state, chainId, response.transactionHash);
+        confirmedMovement = true;
         remaining -= assetsRaw;
       }
       if (remaining > 0n) {
@@ -3412,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),
@@ -3427,24 +4077,66 @@ var YieldseekerAgent = class {
         }),
         value: "0",
         chainId
+      }, (hash) => notifyFunding(onProgress, { ...base5, txHash: hash }), (value) => {
+        receipt = value;
       });
-      return {
-        txHash,
-        type: amount === void 0 ? "full" : "partial",
-        amount: requested.toString()
-      };
+      confirmedMovement = true;
+      settlement = plannedMovement;
+      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 {
-      await this.refreshSnapshotAfterMovement(
-        state,
-        chainId,
-        context,
-        "withdrawal"
-      );
+      if (confirmedMovement && this.readGeneration === generation) {
+        void this.refreshSnapshotAfterMovement(
+          state,
+          chainId,
+          context,
+          "withdrawal",
+          settlement
+        );
+      }
     }
   }
-  async getBalances(state, chainId) {
+  async getBalances(state, chainId, asset) {
+    this.assertChain(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);
-    return mapYieldseekerBalances(await this.loadPortfolio(state, 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);
@@ -3464,7 +4156,7 @@ var YieldseekerAgent = class {
     this.assertChain(chainId);
     const asset = options?.tokenSymbol?.toUpperCase();
     if (asset !== void 0) this.assertAsset(asset);
-    const contexts = await this.loadPortfolio(state, chainId, {
+    const contexts = await this.loadActivityPortfolio(state, chainId, {
       ...asset ? { asset } : {},
       historic: true,
       actions: true
@@ -3481,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 } : {},
@@ -3491,7 +4184,7 @@ var YieldseekerAgent = class {
     this.assertChain(chainId);
     return mapYieldseekerProfile(
       state.walletAddress,
-      await this.loadPortfolio(state, chainId, {})
+      await this.loadActivityPortfolio(state, chainId, {})
     );
   }
   async getAgentApy(days, options) {
@@ -3533,18 +4226,109 @@ var YieldseekerAgent = class {
   contextKey(state, chainId, asset) {
     return `${this.userKey(state, chainId)}:${asset}`;
   }
-  async resolveUser(state, chainId) {
-    const key2 = this.userKey(state, chainId);
-    const inMemory = this.users.get(key2);
-    if (inMemory) return inMemory;
-    const persisted = readYieldseekerIdentity(state.walletAddress, chainId);
-    if (persisted) {
-      this.users.set(key2, persisted);
-      return persisted;
+  assertSession(generation, chainId, asset) {
+    if (this.readGeneration !== generation) {
+      throw new OwneyError(
+        "NOT_CONNECTED",
+        "Wallet session changed during the Yieldseeker request.",
+        { rpcSource: "agent-api", chainId, ...asset ? { asset } : {} },
+        this.id
+      );
     }
-    const walletAddress = getAddress2(state.walletAddress);
-    let user = null;
-    try {
+  }
+  cachedRead(key2, ttlMs, read2) {
+    const cached = this.readCache.get(key2);
+    if (cached && cached.expiresAt > Date.now()) {
+      return Promise.resolve(cached.value);
+    }
+    const pending = this.pendingReads.get(key2);
+    if (pending) return pending;
+    const generation = this.readGeneration;
+    const request = Promise.resolve().then(read2).then((value) => {
+      if (this.readGeneration === generation && this.pendingReads.get(key2) === request) {
+        this.readCache.set(key2, {
+          expiresAt: Date.now() + ttlMs,
+          fetchedAt: Date.now(),
+          value
+        });
+      }
+      return value;
+    }).finally(() => {
+      if (this.pendingReads.get(key2) === request) {
+        this.pendingReads.delete(key2);
+      }
+    });
+    this.pendingReads.set(key2, request);
+    return request;
+  }
+  agentListKey(state, chainId) {
+    return `agents:${this.userKey(state, chainId)}`;
+  }
+  async listAgents(state, chainId, user) {
+    const response = await this.cachedRead(
+      this.agentListKey(state, chainId),
+      YIELDSEEKER_AGENT_LIST_CACHE_MS,
+      async () => {
+        const response2 = await this.walletRequest(
+          state,
+          chainId,
+          `/users/${user.userId}/agents`
+        );
+        if (!Array.isArray(response2?.agents)) {
+          throw this.invalidResponse("agent list");
+        }
+        return response2;
+      }
+    );
+    return response.agents;
+  }
+  async contextForAgent(state, chainId, user, agent, asset) {
+    const key2 = this.contextKey(state, chainId, asset);
+    const cached = this.agentContexts.get(key2);
+    if (cached?.agent.agentId === agent.agentId) return cached;
+    const pending = this.pendingWalletContexts.get(key2);
+    if (pending) return pending;
+    const generation = this.readGeneration;
+    const request = this.walletRequest(
+      state,
+      chainId,
+      `/users/${user.userId}/agents/${agent.agentId}/wallet`
+    ).then((walletResponse) => {
+      this.assertSession(generation, chainId, asset);
+      if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
+        throw this.invalidResponse("agent wallet");
+      }
+      const context = {
+        user,
+        agent,
+        wallet: walletResponse.agentWallet,
+        asset
+      };
+      this.agentContexts.set(key2, context);
+      return context;
+    });
+    this.pendingWalletContexts.set(key2, request);
+    try {
+      return await request;
+    } finally {
+      if (this.pendingWalletContexts.get(key2) === request) {
+        this.pendingWalletContexts.delete(key2);
+      }
+    }
+  }
+  async resolveUser(state, chainId) {
+    const key2 = this.userKey(state, chainId);
+    const inMemory = this.users.get(key2);
+    if (inMemory) return inMemory;
+    const persisted = readYieldseekerIdentity(state.walletAddress, chainId);
+    if (persisted) {
+      this.users.set(key2, persisted);
+      return persisted;
+    }
+    const walletAddress = getAddress2(state.walletAddress);
+    const generation = this.readGeneration;
+    let user = null;
+    try {
       const login = await this.providerRequest(
         state,
         chainId,
@@ -3589,6 +4373,7 @@ var YieldseekerAgent = class {
     if (!user || !/^[a-zA-Z0-9_-]{1,128}$/.test(user.userId)) {
       throw this.invalidResponse("wallet identity");
     }
+    this.assertSession(generation, chainId);
     const resolved = { userId: user.userId };
     this.users.set(key2, resolved);
     writeYieldseekerIdentity(state.walletAddress, chainId, resolved.userId);
@@ -3604,10 +4389,13 @@ var YieldseekerAgent = class {
     if (cached) return cached;
     const pending = this.pendingAgents.get(key2);
     if (pending) return pending;
+    const generation = this.readGeneration;
     const request = this.resolveAgent(state, chainId, asset, true).then(
       async (context) => {
+        this.assertSession(generation, chainId, asset);
         if (!context) throw this.invalidResponse("agent creation");
         await this.deployAgent(state, chainId, context);
+        this.assertSession(generation, chainId, asset);
         this.agentContexts.set(key2, context);
         return context;
       }
@@ -3616,29 +4404,27 @@ var YieldseekerAgent = class {
     try {
       return await request;
     } finally {
-      this.pendingAgents.delete(key2);
+      if (this.pendingAgents.get(key2) === request) this.pendingAgents.delete(key2);
     }
   }
   async findAgent(state, chainId, asset) {
     const key2 = this.contextKey(state, chainId, asset);
     const cached = this.agentContexts.get(key2);
     if (cached) return cached;
+    const generation = this.readGeneration;
     const context = await this.resolveAgent(state, chainId, asset, false);
+    this.assertSession(generation, chainId, asset);
     if (context) this.agentContexts.set(key2, context);
     return context;
   }
   async resolveAgent(state, chainId, asset, createIfMissing) {
+    const generation = this.readGeneration;
     const user = await this.resolveUser(state, chainId);
-    const response = await this.walletRequest(
-      state,
-      chainId,
-      `/users/${user.userId}/agents`
-    );
-    if (!Array.isArray(response?.agents)) {
-      throw this.invalidResponse("agent list");
-    }
+    this.assertSession(generation, chainId, asset);
+    const agents = await this.listAgents(state, chainId, user);
+    this.assertSession(generation, chainId, asset);
     const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-    let agent = response.agents.find(
+    let agent = agents.find(
       (candidate) => this.isOwneyAgent(candidate) && candidate.chainId === chainId && candidate.type === "vault" && candidate.assetAddress.toLowerCase() === metadata.address.toLowerCase()
     );
     if (!agent && createIfMissing) {
@@ -3654,99 +4440,260 @@ var YieldseekerAgent = class {
             chainId,
             assetAddress: metadata.address,
             type: "vault",
-            rulePreset: null
+            rulePreset: OWNEY_AGENT_RULE_PRESET
           }
         }
       );
+      this.assertSession(generation, chainId, asset);
       agent = created?.agent;
+      if (agent) {
+        this.readCache.set(this.agentListKey(state, chainId), {
+          expiresAt: Date.now() + YIELDSEEKER_AGENT_LIST_CACHE_MS,
+          fetchedAt: Date.now(),
+          value: {
+            agents: [...agents, agent]
+          }
+        });
+      }
     }
     if (!agent) return null;
     this.assertAgent(agent);
-    const walletResponse = await this.walletRequest(
-      state,
-      chainId,
-      `/users/${user.userId}/agents/${agent.agentId}/wallet`
-    );
-    if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
-      throw this.invalidResponse("agent wallet");
-    }
-    return { user, agent, wallet: walletResponse.agentWallet, asset };
+    return this.contextForAgent(state, chainId, user, agent, asset);
   }
   async loadPortfolio(state, chainId, options) {
-    const user = await this.resolveUser(state, chainId);
-    const response = await this.walletRequest(
-      state,
-      chainId,
-      `/users/${user.userId}/agents`
+    const contexts = await this.resolvePortfolioContexts(state, chainId, options.asset);
+    return Promise.all(
+      contexts.map(
+        (context) => this.loadPortfolioContext(state, chainId, context, options)
+      )
     );
-    if (!Array.isArray(response?.agents)) {
-      throw this.invalidResponse("agent list");
-    }
+  }
+  async loadActivityPortfolio(state, chainId, options) {
+    const contexts = await this.resolvePortfolioContexts(state, chainId, options.asset);
+    return Promise.all(
+      contexts.map(
+        (context) => this.loadActivityContext(state, chainId, context, options)
+      )
+    );
+  }
+  async resolvePortfolioContexts(state, chainId, assetFilter) {
+    const generation = this.readGeneration;
+    const user = await this.resolveUser(state, chainId);
+    this.assertSession(generation, chainId);
+    const agents = await this.listAgents(state, chainId, user);
+    this.assertSession(generation, chainId);
     const contexts = [];
-    for (const agent of response.agents) {
+    for (const agent of agents) {
       const asset = this.assetForAgent(agent);
-      if (!this.isOwneyAgent(agent) || !asset || agent.chainId !== chainId || agent.type !== "vault" || options.asset && options.asset !== asset) {
+      if (!this.isOwneyAgent(agent) || !asset || agent.chainId !== chainId || agent.type !== "vault" || assetFilter && assetFilter !== asset) {
         continue;
       }
       this.assertAgent(agent);
-      const walletResponse = await this.walletRequest(
-        state,
-        chainId,
-        `/users/${user.userId}/agents/${agent.agentId}/wallet`
-      );
-      if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
-        throw this.invalidResponse("agent wallet");
-      }
-      const context = {
-        user,
-        agent,
-        wallet: walletResponse.agentWallet,
-        asset
+      contexts.push(this.contextForAgent(state, chainId, user, agent, asset));
+    }
+    const resolvedContexts = await Promise.all(contexts);
+    this.assertSession(generation, chainId);
+    return resolvedContexts;
+  }
+  portfolioVersion(contextKey) {
+    return this.portfolioVersions.get(contextKey) ?? 0;
+  }
+  portfolioCacheMs(contextKey) {
+    return (this.reconcileUntil.get(contextKey) ?? 0) > Date.now() ? YIELDSEEKER_SETTLEMENT_CACHE_MS : YIELDSEEKER_PORTFOLIO_CACHE_MS;
+  }
+  snapshotMovement(state, chainId, context, delta) {
+    const key2 = this.contextKey(state, chainId, context.asset);
+    const previous = this.snapshotMovements.get(key2);
+    if (this.snapshotMovements.has(key2)) {
+      if (!previous || previous.delta > 0n !== delta > 0n) return null;
+      return {
+        ...previous,
+        epoch: this.movementEpochs.get(key2) ?? 0,
+        delta: previous.delta + delta,
+        expectedNetDeposits: previous.expectedNetDeposits + delta
       };
-      this.agentContexts.set(this.contextKey(state, chainId, asset), context);
-      contexts.push(context);
     }
-    return Promise.all(
-      contexts.map(
-        (context) => this.loadPortfolioContext(state, chainId, context, options)
-      )
-    );
+    const cached = this.readCache.get(`snapshot:${key2}`);
+    if (!cached || cached.expiresAt <= Date.now()) return null;
+    const snapshot = cached.value.agentSnapshot;
+    if (snapshot.baseAssetDecimals !== YIELDSEEKER_ASSET_METADATA[context.asset].decimals) return null;
+    if (!/^-?\d+$/.test(snapshot.netDepositsBase) || !/^\d+$/.test(snapshot.totalValueBase)) return null;
+    return {
+      epoch: this.movementEpochs.get(key2) ?? 0,
+      delta,
+      decimals: snapshot.baseAssetDecimals,
+      expectedNetDeposits: BigInt(snapshot.netDepositsBase) + delta
+    };
+  }
+  advancePortfolioVersion(contextKey) {
+    const version = this.portfolioVersion(contextKey) + 1;
+    this.portfolioVersions.set(contextKey, version);
+    this.snapshotFailures.delete(contextKey);
+    for (const kind of ["snapshot", "positions", "historic", "actions"]) {
+      const key2 = `${kind}:${contextKey}`;
+      this.readCache.delete(key2);
+      this.pendingReads.delete(key2);
+    }
+    return version;
+  }
+  requestPortfolioSnapshot(state, chainId, context, contextKey, version, generation, forceRefresh = false) {
+    return this.walletRequest(
+      state,
+      chainId,
+      `${this.agentPath(context, "snapshot")}${query(forceRefresh ? { shouldForceRefresh: true } : { shouldOnlyUseRecentValue: true, shouldAllowStaleOnError: true })}`
+    ).then((response) => {
+      if (!response?.agentSnapshot) {
+        throw this.invalidResponse("agent snapshot");
+      }
+      if (this.readGeneration === generation && this.portfolioVersion(contextKey) === version) {
+        this.snapshotFailures.delete(contextKey);
+        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 netDeposits = BigInt(snapshot.netDepositsBase);
+          const reconciled = movement.delta > 0n ? netDeposits >= movement.expectedNetDeposits : netDeposits <= movement.expectedNetDeposits;
+          if (reconciled) {
+            this.snapshotMovements.delete(contextKey);
+            this.reconcileUntil.delete(contextKey);
+          }
+        }
+      }
+      return response;
+    }).catch((error) => {
+      if (this.readGeneration === generation && this.portfolioVersion(contextKey) === version) {
+        this.snapshotFailures.set(contextKey, {
+          retryAt: Date.now() + Math.max(YIELDSEEKER_READ_FAILURE_COOLDOWN_MS, rateLimitDelay(error) ?? 0),
+          error
+        });
+      }
+      throw error;
+    });
+  }
+  portfolioSnapshot(state, chainId, context, contextKey) {
+    const key2 = `snapshot:${contextKey}`;
+    const cached = this.readCache.get(key2);
+    if ((!cached || cached.expiresAt <= Date.now()) && !this.pendingReads.has(key2)) {
+      const failure = this.snapshotFailures.get(contextKey);
+      if (failure && failure.retryAt > Date.now()) throw failure.error;
+      this.advancePortfolioVersion(contextKey);
+    }
+    const version = this.portfolioVersion(contextKey);
+    const generation = this.readGeneration;
+    return {
+      version,
+      read: this.cachedRead(key2, this.portfolioCacheMs(contextKey), () => (
+        // Force only during the bounded post-transaction window. Keep unknown
+        // or unreconciled movements for verification, but do not let them turn
+        // routine polling into forced refreshes indefinitely.
+        this.requestPortfolioSnapshot(
+          state,
+          chainId,
+          context,
+          contextKey,
+          version,
+          generation,
+          this.snapshotMovements.has(contextKey) && (this.reconcileUntil.get(contextKey) ?? 0) > Date.now()
+        )
+      ))
+    };
   }
   async loadPortfolioContext(state, chainId, context, options = {}) {
-    const [snapshot, positions, historic, actions] = await Promise.all([
-      this.walletRequest(
-        state,
-        chainId,
-        `${this.agentPath(context, "snapshot")}${query({
-          shouldOnlyUseRecentValue: true,
-          shouldAllowStaleOnError: true
-        })}`
-      ),
-      this.walletRequest(
-        state,
-        chainId,
-        this.agentPath(context, "yield-positions")
+    const contextKey = this.contextKey(state, chainId, context.asset);
+    const generation = this.readGeneration;
+    const assertSession = () => this.assertSession(generation, chainId, context.asset);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const { version, read: read2 } = this.portfolioSnapshot(state, chainId, context, contextKey);
+      const parts = this.loadPortfolioParts(state, chainId, context, options, contextKey);
+      try {
+        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) {
+        assertSession();
+        if (this.portfolioVersion(contextKey) !== version) continue;
+        throw error;
+      }
+    }
+    throw new OwneyError(
+      "AGENT_API_ERROR",
+      "Yieldseeker portfolio changed during the read. Please retry.",
+      { rpcSource: "agent-api", chainId, asset: context.asset },
+      this.id
+    );
+  }
+  async loadActivityContext(state, chainId, context, options) {
+    const contextKey = this.contextKey(state, chainId, context.asset);
+    const generation = this.readGeneration;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const version = this.portfolioVersion(contextKey);
+      try {
+        const parts = await this.loadPortfolioParts(state, chainId, context, options, contextKey);
+        this.assertSession(generation, chainId, context.asset);
+        if (this.portfolioVersion(contextKey) !== version) continue;
+        return { ...context, ...parts };
+      } catch (error) {
+        this.assertSession(generation, chainId, context.asset);
+        if (this.portfolioVersion(contextKey) !== version) continue;
+        throw error;
+      }
+    }
+    throw new OwneyError(
+      "AGENT_API_ERROR",
+      "Yieldseeker activity changed during the read. Please retry.",
+      { rpcSource: "agent-api", chainId, asset: context.asset },
+      this.id
+    );
+  }
+  async loadPortfolioParts(state, chainId, context, options, contextKey) {
+    const [positions, historic, actions] = await Promise.all([
+      this.cachedRead(
+        `positions:${contextKey}`,
+        this.portfolioCacheMs(contextKey),
+        async () => {
+          const response = await this.walletRequest(
+            state,
+            chainId,
+            this.agentPath(context, "yield-positions")
+          );
+          if (!Array.isArray(response?.yieldPositions)) {
+            throw this.invalidResponse("yield positions");
+          }
+          return response;
+        }
       ),
-      options.historic ? this.walletRequest(
-        state,
-        chainId,
-        this.agentPath(context, "wallet/historic-position")
+      options.historic ? this.cachedRead(
+        `historic:${contextKey}`,
+        (this.activityRefreshUntil.get(contextKey) ?? 0) > Date.now() ? YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS : YIELDSEEKER_ACTIVITY_CACHE_MS,
+        () => this.walletRequest(
+          state,
+          chainId,
+          this.agentPath(context, "wallet/historic-position")
+        )
       ) : Promise.resolve(void 0),
-      options.actions ? this.walletRequest(
-        state,
-        chainId,
-        this.agentPath(context, "actions")
+      options.actions ? this.cachedRead(
+        `actions:${contextKey}`,
+        (this.activityRefreshUntil.get(contextKey) ?? 0) > Date.now() ? YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS : YIELDSEEKER_ACTIVITY_CACHE_MS,
+        () => this.walletRequest(
+          state,
+          chainId,
+          this.agentPath(context, "actions")
+        )
       ) : Promise.resolve(void 0)
     ]);
-    if (!snapshot?.agentSnapshot) {
-      throw this.invalidResponse("agent snapshot");
-    }
-    if (!Array.isArray(positions?.yieldPositions)) {
-      throw this.invalidResponse("yield positions");
-    }
     return {
-      ...context,
-      snapshot: snapshot.agentSnapshot,
       positions: positions.yieldPositions,
       ...historic?.position ? { historic: historic.position } : {},
       ...actions?.actions ? { actions: actions.actions } : {}
@@ -3768,18 +4715,21 @@ var YieldseekerAgent = class {
     }
     context.wallet = deployed.agentWallet;
   }
-  async refreshSnapshotAfterMovement(state, chainId, context, movement) {
+  async refreshSnapshotAfterMovement(state, chainId, context, movement, settlement) {
+    const contextKey = this.contextKey(state, chainId, context.asset);
+    this.reconcileUntil.set(contextKey, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
+    this.activityRefreshUntil.set(contextKey, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
+    const epoch = this.movementEpochs.get(contextKey) ?? 0;
+    this.snapshotMovements.set(contextKey, settlement?.epoch === epoch ? settlement : null);
+    this.movementEpochs.set(contextKey, epoch + 1);
+    const version = this.advancePortfolioVersion(contextKey);
+    const generation = this.readGeneration;
     try {
-      const response = await this.walletRequest(
-        state,
-        chainId,
-        `${this.agentPath(context, "snapshot")}${query({
-          shouldForceRefresh: true
-        })}`
+      await this.cachedRead(
+        `snapshot:${contextKey}`,
+        YIELDSEEKER_SETTLEMENT_CACHE_MS,
+        () => this.requestPortfolioSnapshot(state, chainId, context, contextKey, version, generation, true)
       );
-      if (!response?.agentSnapshot) {
-        throw this.invalidResponse("agent snapshot refresh");
-      }
     } catch (error) {
       console.warn(
         `[owney-sdk] Yieldseeker ${movement} snapshot refresh failed:`,
@@ -3791,10 +4741,26 @@ var YieldseekerAgent = class {
     return `/users/${context.user.userId}/agents/${context.agent.agentId}/${suffix}`;
   }
   async walletRequest(state, chainId, path, options = {}) {
+    const read2 = (options.method ?? "GET") === "GET";
+    const userKey = this.userKey(state, chainId);
+    if (read2) {
+      const failure = this.standardReadFailures.get(userKey);
+      if (failure && failure.retryAt > Date.now()) throw failure.error;
+      if (failure) this.standardReadFailures.delete(userKey);
+    }
+    const generation = this.readGeneration;
     try {
       return await this.providerRequest(state, chainId, path, options);
     } catch (error) {
-      throw this.mapApiError(error);
+      const mapped = this.mapApiError(error);
+      const delay = read2 ? rateLimitDelay(mapped) : void 0;
+      if (delay !== void 0 && this.readGeneration === generation) {
+        this.standardReadFailures.set(userKey, {
+          retryAt: Date.now() + Math.max(YIELDSEEKER_READ_FAILURE_COOLDOWN_MS, delay),
+          error: mapped
+        });
+      }
+      throw mapped;
     }
   }
   async providerRequest(state, chainId, path, options = {}) {
@@ -3835,6 +4801,7 @@ var YieldseekerAgent = class {
       code,
       `Yieldseeker request failed: ${error.providerCode}.`,
       {
+        rpcSource: "agent-api",
         statusCode: error.status,
         providerCode: error.providerCode,
         ...error.responseFields ? { fields: error.responseFields } : {}
@@ -3842,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);
@@ -3853,12 +4822,12 @@ var YieldseekerAgent = class {
       chain: base3,
       transport: custom2(state.provider)
     });
-    const publicClient = createPublicClient3({
+    const walletChainClient = createPublicClient3({
       chain: base3,
       transport: custom2(state.provider)
     });
     await ensureWalletOnChain(
-      publicClient,
+      walletChainClient,
       walletClient,
       8453
     );
@@ -3869,10 +4838,16 @@ var YieldseekerAgent = class {
       data: transaction.data,
       value: BigInt(transaction.value)
     });
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash,
-      confirmations: 1
-    });
+    onSubmitted?.(hash);
+    const receipt = await withPaidRpcDiagnostics(
+      () => this.getReceiptClient().waitForTransactionReceipt({
+        hash,
+        confirmations: 1
+      }),
+      8453,
+      "eth_getTransactionReceipt",
+      this.id
+    );
     if (receipt.status !== "success") {
       throw new OwneyError(
         "AGENT_TRANSACTION_REVERTED",
@@ -3881,6 +4856,7 @@ var YieldseekerAgent = class {
         this.id
       );
     }
+    onReceipt?.(receipt);
     return hash;
   }
   async waitForReceipt(state, chainId, transactionHash) {
@@ -3888,14 +4864,15 @@ var YieldseekerAgent = class {
       await this.unwindReceiptWaiter(state, chainId, transactionHash);
       return;
     }
-    const publicClient = createPublicClient3({
-      chain: base3,
-      transport: custom2(state.provider)
-    });
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash: transactionHash,
-      confirmations: 1
-    });
+    const receipt = await withPaidRpcDiagnostics(
+      () => this.getReceiptClient().waitForTransactionReceipt({
+        hash: transactionHash,
+        confirmations: 1
+      }),
+      8453,
+      "eth_getTransactionReceipt",
+      this.id
+    );
     if (receipt.status !== "success") {
       throw new OwneyError(
         "AGENT_TRANSACTION_REVERTED",
@@ -3904,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)) {
@@ -4084,16 +5062,16 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
         const positionChain = position2.chain.trim().toUpperCase();
         const matchesChain = positionChain === String(chainId) || targetChain !== void 0 && positionChain === targetChain;
         if (!matchesChain || position2.asset.toUpperCase() !== target) continue;
-        if (position2.amountRaw !== void 0) {
-          try {
-            balance += BigInt(position2.amountRaw);
-            continue;
-          } catch {
-          }
-        }
-        balance += parseUnits(position2.amount, decimals);
+        balance += position2.withdrawableAmountRaw !== void 0 ? BigInt(position2.withdrawableAmountRaw) : parseUnits(position2.amount, decimals);
       }
     }
+    const assetTotal = agentBalance?.assetBalances?.find(
+      (t) => t.chainId === chainId && t.asset.toUpperCase() === target
+    );
+    if (assetTotal) {
+      const total = parseUnits(assetTotal.amount, decimals);
+      if (total < balance) balance = total > 0n ? total : 0n;
+    }
     return { agent, balance };
   });
 }
@@ -4265,8 +5243,43 @@ 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";
+var ERC2612_PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var ERC2612_READ_ABI = parseAbi3([
+  "function name() view returns (string)",
+  "function version() view returns (string)",
+  "function nonces(address owner) view returns (uint256)"
+]);
+function erc2612TypedData(input) {
+  return {
+    domain: {
+      name: input.permit.tokenName,
+      version: input.permit.tokenVersion,
+      chainId: input.chainId,
+      verifyingContract: input.token
+    },
+    types: ERC2612_PERMIT_TYPES,
+    primaryType: "Permit",
+    message: {
+      owner: input.owner,
+      spender: BATCH_PERMIT2_ADDRESS,
+      value: BigInt(input.permit.value),
+      nonce: BigInt(input.permit.nonce),
+      deadline: BigInt(input.permit.deadline)
+    }
+  };
+}
 var PERMIT_BATCH_TYPES = {
   PermitBatchWitnessTransferFrom: [
     { name: "permitted", type: "TokenPermissions[]" },
@@ -4281,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; }",
@@ -4381,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,
@@ -4418,28 +5435,67 @@ async function execute(i, key2, plan) {
       "DEPOSIT_INSUFFICIENT_BALANCE",
       "Insufficient token balance for this deposit."
     );
-  if (allowance < total)
+  if (allowance < total && (i.chainId !== 8453 || !isAddressEqual(i.token, BASE_USDC_ADDRESS)))
     throw new OwneyError(
       "PERMIT2_APPROVAL_REQUIRED",
       "token deposits need a one-time Permit2 approval."
     );
-  const relayer = await getSponsorRelayerAddress({
+  const now = (await i.pub.getBlock()).timestamp;
+  let erc2612Permit;
+  if (allowance < total) {
+    const [tokenName, tokenVersion, permitNonce] = await Promise.all([
+      i.pub.readContract({
+        address: i.token,
+        abi: ERC2612_READ_ABI,
+        functionName: "name"
+      }),
+      i.pub.readContract({
+        address: i.token,
+        abi: ERC2612_READ_ABI,
+        functionName: "version"
+      }),
+      i.pub.readContract({
+        address: i.token,
+        abi: ERC2612_READ_ABI,
+        functionName: "nonces",
+        args: [i.owner]
+      })
+    ]);
+    const unsignedPermit = {
+      value: MAX_UINT256.toString(),
+      nonce: permitNonce.toString(),
+      deadline: (now + 900n).toString(),
+      tokenName,
+      tokenVersion
+    };
+    const signature2 = await i.wallet.signTypedData({
+      account: i.owner,
+      ...erc2612TypedData({
+        chainId: 8453,
+        token: i.token,
+        owner: i.owner,
+        permit: unsignedPermit
+      })
+    });
+    erc2612Permit = { ...unsignedPermit, signature: signature2 };
+  }
+  const spender = erc2612Permit ? MULTICALL3_ADDRESS : await getSponsorRelayerAddress({
     apiKey: i.apiKey,
     baseUrl: i.baseUrl,
     chainId: i.chainId
   });
-  const now = (await i.pub.getBlock()).timestamp;
   const unsigned = {
     chainId: i.chainId,
     token: i.token,
     from: i.owner,
     transfers: i.transfers,
     nonce: randomPermit2Nonce().toString(),
-    deadline: (now + 900n).toString()
+    deadline: (now + 900n).toString(),
+    ...erc2612Permit ? { erc2612Permit } : {}
   };
   const signature = await i.wallet.signTypedData({
     account: i.owner,
-    ...batchTypedData(unsigned, relayer)
+    ...batchTypedData(unsigned, spender)
   });
   i.onApproved?.();
   return send({ ...unsigned, signature });
@@ -4459,8 +5515,8 @@ function makeSponsoredTokenCallback(deps) {
         "CHAIN_UNSUPPORTED",
         `No sponsored token configured for chain ${chainId}`
       );
-    const pub = deps.getPublicClient(chainId), wallet = deps.getWalletClient(chainId);
-    await ensureWalletOnChain(pub, wallet, chainId);
+    const pub = deps.getPublicClient(chainId), walletChain = deps.getWalletChainClient?.(chainId) ?? pub, wallet = deps.getWalletClient(chainId);
+    await ensureWalletOnChain(walletChain, wallet, chainId);
     return sponsorTokenBatch({
       apiKey: deps.apiKey,
       baseUrl: deps.baseUrl,
@@ -4470,7 +5526,8 @@ function makeSponsoredTokenCallback(deps) {
       transfers,
       pub,
       wallet,
-      onApproved: deps.onApproved
+      onApproved: deps.onApproved,
+      onSubmitted: (hash) => deps.onSubmitted?.(hash, transfers)
     });
   };
   const callback = makeVerificationAwareDepositCallback(
@@ -4556,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) {
@@ -4602,7 +5659,7 @@ function makeSponsoredCallsCallback(deps) {
       to: token,
       value: "0x0",
       data: encodeFunctionData2({
-        abi: erc20Abi2,
+        abi: erc20Abi3,
         functionName: "transfer",
         args: [transfer.to, BigInt(transfer.amount)]
       })
@@ -4664,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",
@@ -4700,6 +5763,8 @@ function makeSponsoredCallsCallback(deps) {
 }
 
 // src/client.ts
+var PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS = 6;
+var PERMIT2_ALLOWANCE_VERIFY_DELAY_MS = 250;
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
 }
@@ -4760,6 +5825,7 @@ var OwneySDK = class {
   // leave every user's agent profile alone.
   orgAgentConfig;
   orgAgentConfigPromise = null;
+  rpcUrls;
   zyfaiRpcUrls;
   yieldseekerApiBaseUrl;
   yieldseekerSiweOrigin;
@@ -4770,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([
@@ -4784,7 +5851,12 @@ var OwneySDK = class {
   constructor(config) {
     this.apiKey = config.apiKey;
     if (config.debug) setOwneyDebug(true);
-    this.zyfaiRpcUrls = config.zyfaiRpcUrls;
+    this.rpcUrls = resolveRpcUrls(
+      config.rpcUrls,
+      config.apiKey,
+      config.routingApiBaseUrl
+    );
+    this.zyfaiRpcUrls = config.rpcUrls ? void 0 : config.zyfaiRpcUrls;
     this.yieldseekerApiBaseUrl = config.yieldseekerApiBaseUrl;
     this.yieldseekerSiweOrigin = config.yieldseekerSiweOrigin;
     this.routingApiBaseUrl = config.routingApiBaseUrl;
@@ -4874,9 +5946,12 @@ var OwneySDK = class {
     }
     return this.state.provider;
   }
+  getPaidRpcClient(chainId) {
+    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;
@@ -4885,11 +5960,13 @@ 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
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => createPublicClient4({
+      getPublicClient: (cid) => this.getPaidRpcClient(cid),
+      getWalletChainClient: (cid) => createPublicClient4({
         chain: VIEM_CHAIN2[cid],
         transport: custom3(provider)
       }),
@@ -4899,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,
@@ -4914,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;
   }
   /**
@@ -4925,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;
@@ -4935,11 +6013,13 @@ 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
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => createPublicClient4({
+      getPublicClient: (cid) => this.getPaidRpcClient(cid),
+      getWalletChainClient: (cid) => createPublicClient4({
         chain: VIEM_CHAIN2[cid],
         transport: custom3(provider)
       }),
@@ -4949,7 +6029,7 @@ var OwneySDK = class {
         transport: custom3(provider)
       })
     });
-    if (!onApproved) this.cachedWethSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted) this.cachedWethSponsoredCallback = callback;
     return callback;
   }
   getAgent(agentId) {
@@ -4959,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) {
@@ -5052,12 +6135,21 @@ var OwneySDK = class {
   createAgent(agentId, key2) {
     if (agentId === "zyfai") {
       if (!key2) return null;
-      return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
+      return new ZyfaiAgent(
+        key2,
+        this.zyfaiRpcUrls ? resolveRpcUrls(
+          this.zyfaiRpcUrls,
+          this.apiKey,
+          this.routingApiBaseUrl
+        ) : this.rpcUrls,
+        this.referralSource
+      );
     }
     if (agentId === "yieldseeker") {
       return new YieldseekerAgent(this.apiKey, {
         auth: { origin: this.yieldseekerSiweOrigin },
-        baseUrl: this.yieldseekerApiBaseUrl ?? getYieldseekerProxyBaseUrl(this.routingApiBaseUrl)
+        baseUrl: this.yieldseekerApiBaseUrl ?? getYieldseekerProxyBaseUrl(this.routingApiBaseUrl),
+        rpcUrls: this.rpcUrls
       });
     }
     return null;
@@ -5244,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(
@@ -5268,7 +6371,8 @@ var OwneySDK = class {
         amount,
         asset,
         effectiveCallback,
-        depositCallback
+        depositCallback,
+        onProgress
       );
     }
     const totalAmount = BigInt(amount);
@@ -5332,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
           )
         })),
@@ -5348,7 +6452,8 @@ var OwneySDK = class {
             );
             await this.approvePermit2(
               asset,
-              requiredAmount
+              requiredAmount,
+              cid
             );
             return batchTransfer(cid, transfers);
           }
@@ -5368,7 +6473,8 @@ var OwneySDK = class {
           agentAmount,
           asset,
           effectiveCallback,
-          depositCallback
+          depositCallback,
+          onProgress
         );
       } catch (error) {
         if (Object.keys(agentResults).length === 0) throw error;
@@ -5392,10 +6498,12 @@ var OwneySDK = class {
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
    * two independent auto-recovery mechanisms:
    *
-   * 1. Missing Permit2 allowance: when the app did not supply its own
-   *    callback and the attempt fails with `PERMIT2_APPROVAL_REQUIRED` on a
-   *    token deposit, this is the wallet's first Permit2 deposit for that token. We send
-   *    the one-time (user-paid) Permit2 approval via `approvePermit2()` and
+   * 1. Missing Permit2 allowance outside the atomic Base-USDC path: when the
+   *    app did not supply its own callback and the attempt fails with
+   *    `PERMIT2_APPROVAL_REQUIRED`, this is the wallet's first Permit2 deposit
+   *    for that token. Base USDC bundles a gasless ERC-2612 approval inside
+   *    its sponsored deposit and never reaches this branch. Other tokens send
+   *    the one-time user-paid Permit2 approval via `approvePermit2()` and
    *    retry the SAME sponsored attempt once. Bounded to one approval attempt
    *    per call so a wallet/agent that keeps reporting the allowance as
    *    missing can't loop forever. If `approvePermit2()` itself throws (e.g.
@@ -5413,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;
@@ -5438,7 +6540,8 @@ var OwneySDK = class {
           );
           await this.approvePermit2(
             asset,
-            BigInt(amount)
+            BigInt(amount),
+            chainId
           );
           continue;
         }
@@ -5585,6 +6688,98 @@ var OwneySDK = class {
     }
     return eligible;
   }
+  /**
+   * Run owner-approved withdrawals before relayer-only withdrawals. Wallet
+   * approval is the only point at which the user can cancel the aggregate
+   * operation, so no relayer leg should commit before it has completed.
+   */
+  orderAgentsForWithdrawal(agents) {
+    return agents.map((agent, index) => ({ agent, index })).sort((left, right) => {
+      const approvalOrder = Number(Boolean(right.agent.withdrawalRequiresWalletApproval)) - Number(Boolean(left.agent.withdrawalRequiresWalletApproval));
+      return approvalOrder || left.index - right.index;
+    }).map(({ agent }) => agent);
+  }
+  isUserRejectedWithdrawal(error) {
+    let current = error;
+    const seen = /* @__PURE__ */ new Set();
+    while (current && typeof current === "object" && !seen.has(current)) {
+      seen.add(current);
+      const candidate = current;
+      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|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.
@@ -5596,10 +6791,66 @@ var OwneySDK = class {
    * @returns {AgentWithdrawResult} for a single agent, or {OwneyWithdrawResult} with per-agent results
    */
   async withdraw(options) {
-    const { asset, amount, agentId } = 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 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
     );
@@ -5612,21 +6863,27 @@ var OwneySDK = class {
     if (agentId) {
       const agent = this.getAgent(agentId);
       this.validateAssetSupport(agent, chainId, asset);
-      return withFailureReporting(
+      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 eligibleAgents) {
+      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";
@@ -5645,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)
       );
@@ -5654,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)
     );
@@ -5707,21 +6971,19 @@ var OwneySDK = class {
       planned: 0n
     }));
     const plans = [...disabledPlans, ...enabledPlans];
+    const orderedPlans = this.orderAgentsForWithdrawal(plans.map((p) => p.agent)).map((agent) => plans.find((plan) => plan.agent === agent));
     const results = {};
     const agentErrors = {
       ...aggregated.agentErrors ?? {}
     };
-    for (let i = 0; i < plans.length; i++) {
-      const p = plans[i];
+    for (let i = 0; i < orderedPlans.length; i++) {
+      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;
         console.error(`withdraw failed for agent "${p.agent.id}":`, err);
         agentErrors[p.agent.id] = err instanceof Error ? err.message : String(err);
         const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
@@ -5733,7 +6995,8 @@ var OwneySDK = class {
         );
         const failedAmount = p.planned;
         p.planned = 0n;
-        redistributeShare(plans, i, failedAmount);
+        if (submissionEvidence.get(p.agent.id)?.transfer === "failed")
+          redistributeShare(orderedPlans, i, failedAmount);
       }
     }
     if (Object.keys(results).length === 0) {
@@ -5770,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"
@@ -5786,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,
           {
@@ -5796,6 +7066,7 @@ var OwneySDK = class {
         ];
       })
     );
+    assertCurrent();
     let successCount = 0;
     const agentErrors = {};
     const agentRetryAt = {};
@@ -5843,23 +7114,11 @@ var OwneySDK = class {
       const agent = this.getAgent(agentId);
       return this.readAgent(agent, "earnings", () => agent.getEarnings(state, chainId));
     }
-    let totalEarnings = 0;
-    const results = {};
     const entries = [...this.getActiveAgents().entries()];
-    const earningsResults = await Promise.all(
-      entries.map(async ([id, agent]) => {
-        const e = await this.readAgent(agent, "earnings", () => agent.getEarnings(state, chainId));
-        return [id, e];
-      })
+    return this.aggregateEarnings(
+      entries,
+      (agent) => this.readAgent(agent, "earnings", () => agent.getEarnings(state, chainId))
     );
-    for (const [id, e] of earningsResults) {
-      results[id] = e;
-      totalEarnings += Number(e.lifetimeEarnings);
-    }
-    return {
-      totalEarnings: String(totalEarnings),
-      agentEarnings: results
-    };
   }
   /**
    * Return refreshed earnings while letting each agent own its refresh policy.
@@ -5874,18 +7133,42 @@ var OwneySDK = class {
       () => agent.refreshEarnings?.(state, chainId) ?? agent.getEarnings(state, chainId)
     );
     if (agentId) return refreshAgent(this.getAgent(agentId));
-    let totalEarnings = 0;
+    return this.aggregateEarnings([...this.getActiveAgents().entries()], refreshAgent);
+  }
+  async aggregateEarnings(entries, read2) {
+    const settled = await Promise.allSettled(entries.map(([, agent]) => read2(agent)));
     const agentEarnings = {};
-    const refreshed = await Promise.all(
-      [...this.getActiveAgents().entries()].map(
-        async ([id, agent]) => [id, await refreshAgent(agent)]
-      )
-    );
-    for (const [id, earnings] of refreshed) {
-      agentEarnings[id] = earnings;
-      totalEarnings += Number(earnings.lifetimeEarnings);
+    const agentErrors = {};
+    const agentRetryAt = {};
+    const failures = [];
+    let totalEarnings = 0;
+    for (let i = 0; i < settled.length; i++) {
+      const [id] = entries[i];
+      const result = settled[i];
+      if (result.status === "fulfilled") {
+        agentEarnings[id] = result.value;
+        totalEarnings += Number(result.value.lifetimeEarnings);
+        continue;
+      }
+      const reason = result.reason;
+      failures.push(reason);
+      const retryDelay = rateLimitDelay(reason);
+      if (retryDelay !== void 0) agentRetryAt[id] = Date.now() + retryDelay;
+      agentErrors[id] = reason instanceof Error ? reason.message : String(reason);
+      console.error(`[owney-sdk] Earnings fetch failed for agent "${id}":`, reason);
+    }
+    if (entries.length > 0 && Object.keys(agentEarnings).length === 0) {
+      throw new OwneyError(
+        "EARNINGS_ALL_FAILED",
+        "Failed to fetch earnings for all active agents.",
+        { agentErrors, failures }
+      );
     }
-    return { totalEarnings: String(totalEarnings), agentEarnings };
+    return {
+      totalEarnings: String(totalEarnings),
+      agentEarnings,
+      ...Object.keys(agentErrors).length > 0 ? { agentErrors, agentRetryAt } : {}
+    };
   }
   /**
    * Get the weighted APY for the user's account over a time period.
@@ -6051,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) : {};
@@ -6066,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) {
@@ -6099,6 +7398,7 @@ var OwneySDK = class {
     });
     return {
       data: merged,
+      ...Object.keys(agentErrors).length ? { agentErrors, agentRetryAt } : {},
       hasMore,
       nextCursor: hasMore ? encodeMultiAgentCursor(nextCursorMap) : void 0
     };
@@ -6159,16 +7459,18 @@ var OwneySDK = class {
   }
   /**
    * User-paid approval of Permit2 on the selected token for the active chain.
-   * Approves exactly the pending deposit amount. Another approval is required
-   * for a later deposit once this allowance has been consumed. Resolves after
-   * one confirmation so the subsequent deposit attempt sees the new allowance.
+   * Grants the maximum ERC20 allowance so later deposits do not require another
+   * approval. Resolves after one confirmation so the subsequent deposit attempt
+   * sees the new allowance. Deposit retries pass their captured chain id so a
+   * concurrent activation cannot redirect the approval to another network.
    *
    * @param requiredAmount Raw base-unit amount the pending deposit must cover.
+   * @param expectedChainId Chain captured by the deposit that requested approval.
    * @returns the approval transaction hash.
    */
-  async approvePermit2(asset = "WETH", requiredAmount = 0n) {
+  async approvePermit2(asset = "WETH", requiredAmount = 0n, expectedChainId) {
     const state = this.requireState();
-    const chainId = this.requireChainId();
+    const chainId = expectedChainId ?? this.requireChainId();
     this.getEligibleAgents(chainId, asset, { excludeDisabled: true });
     const token = sponsoredTokensFor(asset)[chainId];
     if (!token) {
@@ -6178,16 +7480,18 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const publicClient = createPublicClient4({
+    const walletChainClient = createPublicClient4({
       chain: VIEM_CHAIN2[chainId],
       transport: custom3(provider)
     });
+    const publicClient = this.getPaidRpcClient(chainId);
     const approvalAmount = permit2ApprovalAmount(requiredAmount);
     const wallet = createWalletClient3({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
       transport: custom3(provider)
     });
+    await ensureWalletOnChain(walletChainClient, wallet, chainId);
     const hash = await wallet.writeContract({
       address: token,
       abi: ERC20_ALLOWANCE_ABI,
@@ -6196,14 +7500,53 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash,
-      confirmations: 1
-    });
+    const receipt = await withPaidRpcDiagnostics(
+      () => publicClient.waitForTransactionReceipt({
+        hash,
+        confirmations: 1
+      }),
+      chainId,
+      "eth_getTransactionReceipt"
+    );
     if (receipt.status !== "success") {
       throw new Error(`Permit2 approval reverted (tx ${hash})`);
     }
-    return hash;
+    let observedAllowance = 0n;
+    let verificationError;
+    for (let attempt = 0; attempt < PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS; attempt += 1) {
+      try {
+        observedAllowance = await readPermit2Allowance(
+          publicClient,
+          token,
+          state.walletAddress,
+          attempt === 0 ? receipt.blockNumber : void 0
+        );
+        verificationError = void 0;
+        if (observedAllowance >= requiredAmount) return hash;
+      } catch (error) {
+        verificationError = error;
+      }
+      if (attempt + 1 < PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS) {
+        await new Promise(
+          (resolve) => setTimeout(resolve, PERMIT2_ALLOWANCE_VERIFY_DELAY_MS)
+        );
+      }
+    }
+    throw new OwneyError(
+      "PERMIT2_APPROVAL_REQUIRED",
+      "Permit2 approval was confirmed, but the required token allowance was not observable.",
+      {
+        approvalConfirmed: true,
+        approvalTxHash: hash,
+        owner: state.walletAddress,
+        token,
+        spender: PERMIT2_ADDRESS,
+        chainId,
+        requiredAmount: requiredAmount.toString(),
+        observedAllowance: observedAllowance.toString(),
+        ...verificationError instanceof Error ? { verificationError: verificationError.message } : {}
+      }
+    );
   }
   // --- Discovery (no wallet required) ---
   /**