@owney/sdk 0.7.25-beta.14 → 0.7.25-beta.16

package/dist/index.js

@@ -68,6 +68,8 @@ function inspectFundingReceipt(receipt, evidence, tokenAddress, direction) {
   const attributed = /* @__PURE__ */ new Map();
   const agent = evidence.agentWallet?.toLowerCase();
   const owner = evidence.walletAddress.toLowerCase();
+  const source = direction === "deposit" ? owner : agent;
+  const destination = direction === "deposit" ? agent : owner;
   const logIndexes = [];
   const transferLogs = [];
   const zeroTransferLogs = [];
@@ -82,17 +84,13 @@ function inspectFundingReceipt(receipt, evidence, tokenAddress, direction) {
       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);
-      }
+      const sender = from.toLowerCase();
+      const recipient = to.toLowerCase();
+      const available = sender === source ? value : attributed.get(sender) ?? 0n;
+      const carried = available < value ? available : value;
+      if (sender !== source) attributed.set(sender, available - carried);
+      if (recipient === destination) matched = carried;
+      else if (recipient !== source) attributed.set(recipient, (attributed.get(recipient) ?? 0n) + carried);
       if (matched === 0n) continue;
       amount += matched;
       transferLogs.push({ logIndex: log.logIndex, amountRaw: matched.toString() });
@@ -372,20 +370,44 @@ function observeWithdrawalSubmission(sdk, chainId, token) {
         };
         const notify = (outcome) => {
           if (outcome === "rejected" && matching.length !== 1) return;
+          const evidence = matching.length === 1 ? { ...request2 } : {
+            attempted: request2.attempted,
+            method: request2.method,
+            path: request2.path,
+            ...request2.elapsedMs !== void 0 ? { elapsedMs: request2.elapsedMs } : {}
+          };
           for (const observer of matching) {
             try {
-              observer.notify(outcome, { ...request2 });
+              observer.notify(outcome, evidence);
             } catch {
             }
           }
         };
         notify("attempted");
+        let callArgs = args;
+        if (withdrawal && client.client?.defaults) {
+          const configIndex = method === "get" ? 1 : 2;
+          const config = args[configIndex];
+          const transforms = config?.transformResponse !== void 0 ? config.transformResponse : client.client.defaults.transformResponse;
+          const captureStatus = (data, _headers, status) => {
+            if (typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599) request2.httpStatus = status;
+            return data;
+          };
+          callArgs = [...args];
+          callArgs[configIndex] = { ...config, transformResponse: [
+            ...Array.isArray(transforms) ? transforms : typeof transforms === "function" ? [transforms] : [],
+            captureStatus
+          ] };
+        }
         try {
-          return await original.apply(this, args);
+          return await original.apply(this, callArgs);
         } 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");
+          const status = error?.response?.status;
+          if (request2.httpStatus === void 0 && typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599)
+            request2.httpStatus = status;
+          request2.failure = message === "Unauthorized: Invalid API key" ? "unauthorized" : message === "Forbidden: Access denied" ? "forbidden" : message === "Rate limit exceeded. Please try again later." ? "rate-limited" : /^Idle balance \d+(?:\.\d+)? (USDC|WETH|ETH|EURC) is below the minimum withdrawal of \d+(?:\.\d+)? \1\.?$/.test(message) ? "insufficient-balance" : /^User doesn't have any active session key\.?$/.test(message) ? "session-key-missing" : method === "post" && request2.httpStatus === 400 && message === "Partial withdrawal already in progress" ? "withdrawal-in-progress" : message === "Network error: Unable to reach the server" ? "network" : "other";
+          if (["unauthorized", "forbidden", "rate-limited", "insufficient-balance", "session-key-missing", "withdrawal-in-progress"].includes(request2.failure) && (request2.httpStatus === void 0 || request2.httpStatus >= 400 && request2.httpStatus < 500)) notify("rejected");
           throw error;
         } finally {
           request2.elapsedMs = Math.max(0, Date.now() - startedAt);
@@ -408,9 +430,49 @@ function observeWithdrawalSubmission(sdk, chainId, token) {
   } };
 }
 
+// src/agents/zyfai/zyfai.withdraw-empty.ts
+function hasEmptyWithdrawalSnapshot(raw2, chainId, token) {
+  const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  const response = record(raw2);
+  const portfolio = record(response?.portfolio);
+  const chains = record(portfolio?.portfolioByChain);
+  if (response?.success === false || !chains || !Array.isArray(portfolio?.positions) || !Array.isArray(portfolio.staleBalances)) return false;
+  if (portfolio.pendingAsyncWithdrawals !== void 0 && (!Array.isArray(portfolio.pendingAsyncWithdrawals) || portfolio.pendingAsyncWithdrawals.length > 0)) return false;
+  const symbol = (value) => typeof value === "string" ? value.toUpperCase() === "ETH" ? "WETH" : value.toUpperCase() : void 0;
+  const chain = (value) => {
+    if (typeof value === "number") return value;
+    if (typeof value !== "string") return void 0;
+    return /^\d+$/.test(value) ? Number(value) : { base: 8453, arbitrum: 42161, ethereum: 1, mainnet: 1 }[value.trim().toLowerCase()];
+  };
+  const zero = (value) => typeof value === "string" && /^(?:0x)?0+$/i.test(value);
+  for (const [id, assets] of Object.entries(chains)) {
+    const idNumber = chain(id);
+    if (idNumber === void 0) return false;
+    if (idNumber !== chainId) continue;
+    const entries = record(assets);
+    if (!entries) return false;
+    for (const [asset, value] of Object.entries(entries)) {
+      if (symbol(asset) !== token) continue;
+      const balance = record(value);
+      if (!balance || !zero(balance.balance)) return false;
+    }
+  }
+  for (const value of [...portfolio.positions, ...portfolio.staleBalances]) {
+    const entry = record(value);
+    if (!entry) return false;
+    const id = chain(entry.chainId ?? entry.chain);
+    const asset = symbol(entry.tokenSymbol ?? entry.token_symbol);
+    if (id === void 0 || asset === void 0) return false;
+    if (id !== chainId || asset !== token) continue;
+    const amounts = [entry.balance, entry.amount, entry.underlyingAmount].filter((value2) => value2 !== void 0);
+    if (!amounts.length || !amounts.every(zero)) return false;
+  }
+  return true;
+}
+
 // src/agents/zyfai/zyfai.agent.ts
 import { SMART_SESSIONS_VALIDATOR, ZyfaiSDK } from "@zyfai/sdk";
-import { formatUnits, parseAbi as parseAbi2 } from "viem";
+import { erc20Abi as erc20Abi2, formatUnits as formatUnits2, isAddress, parseAbi as parseAbi2 } from "viem";
 import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/types/config.ts
@@ -497,14 +559,6 @@ function hexToDecimal(hex, decimals = 6) {
   const remainder = parsed % divisor;
   return Number(whole) + Number(remainder) / Number(divisor);
 }
-function normalizeDecimalPlace(value, decimals = 6) {
-  const parsed = BigInt(value);
-  if (decimals <= 0) return Number(parsed);
-  const divisor = BigInt(10 ** decimals);
-  const whole = parsed / divisor;
-  const remainder = parsed % divisor;
-  return Number(whole) + Number(remainder) / Number(divisor);
-}
 var DayFilterMapping = {
   "30D": 30,
   "14D": 14,
@@ -512,6 +566,8 @@ var DayFilterMapping = {
 };
 
 // src/agents/zyfai/zyfai.mapper.ts
+import { formatUnits } from "viem";
+var exactHexAmount = (raw2, decimals) => formatUnits(BigInt(/^0x/i.test(raw2) ? raw2 : `0x${raw2}`), decimals);
 var DECIMALS_BY_SYMBOL = {
   usdc: 6,
   weth: 18,
@@ -566,15 +622,15 @@ function mapPendingAllocations(raw2) {
     if (typeof e.balance !== "string") continue;
     let amount;
     try {
-      amount = hexToDecimal(e.balance, tokenDecimals(e.tokenSymbol));
+      if (BigInt(/^0x/i.test(e.balance) ? e.balance : `0x${e.balance}`) <= 0n) continue;
+      amount = exactHexAmount(e.balance, tokenDecimals(e.tokenSymbol));
     } catch {
       continue;
     }
-    if (!Number.isFinite(amount) || amount <= 0) continue;
     pending.push({
       chainId: e.chainId,
       asset: e.tokenSymbol,
-      amount: String(amount),
+      amount,
       isPending: e.isPending === true,
       ...typeof e.updatedAt === "string" && e.updatedAt !== "" ? { since: e.updatedAt } : {}
     });
@@ -597,13 +653,13 @@ function mapBalances(raw2, _chainId, smartWallet) {
       { balance, balanceWithFee, decimals }
     ] of Object.entries(tokensBySymbol ?? {})) {
       if (balanceWithFee === void 0 && balance === void 0) throw new Error("Zyfai asset balance is unavailable.");
-      const amount = hexToDecimal(balanceWithFee ?? balance, decimals);
-      totalBalance += amount;
+      const amount = exactHexAmount(balanceWithFee ?? balance, tokenDecimals(symbol, decimals));
+      totalBalance += Number(amount);
       tokens.push({
         chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
         chainId: positionChainId,
         asset: symbol,
-        amount: String(amount)
+        amount
       });
     }
   }
@@ -617,19 +673,17 @@ function mapBalances(raw2, _chainId, smartWallet) {
     // legacy `amount` fallback is hex. Runtime
     // getBalances payloads often carry one (e.g. 18 for WETH) — prefer that
     // when present, otherwise fall back to the per-symbol lookup.
-    amount: String(
-      p.underlyingAmountWithFee ?? p.underlyingAmount ? normalizeDecimalPlace(
-        p.underlyingAmountWithFee ?? p.underlyingAmount ?? "0",
-        tokenDecimals(
-          p.token_symbol,
-          p.decimals
-        )
-      ) : hexToDecimal(
-        p.amount || "0",
-        tokenDecimals(
-          p.token_symbol,
-          p.decimals
-        )
+    amount: p.underlyingAmountWithFee ?? p.underlyingAmount ? formatUnits(
+      BigInt(p.underlyingAmountWithFee ?? p.underlyingAmount ?? "0"),
+      tokenDecimals(
+        p.token_symbol,
+        p.decimals
+      )
+    ) : exactHexAmount(
+      p.amount || "0",
+      tokenDecimals(
+        p.token_symbol,
+        p.decimals
       )
     ),
     apy: netApy(p.pool_apy_withFee, p.pool_apy, "pool_apy_withFee"),
@@ -1434,6 +1488,7 @@ var VIEM_CHAIN = { 8453: base, 42161: arbitrum, 1: mainnet };
 var SPLITTING_ASSETS = ["USDC", "WETH"];
 var POOL_POLICY_CHAIN_IDS = [8453, 42161, 1];
 var EARNINGS_REFRESH_COOLDOWN_MS = 60 * 60 * 1e3;
+var WITHDRAW_BALANCE_TIMEOUT_MS = 2e3;
 var ZyfaiAgent = class _ZyfaiAgent {
   id = "zyfai";
   supportedChainIds = [8453, 42161, 1];
@@ -1573,7 +1628,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
           }, asset.address, entry.action === "Withdraw" ? "withdraw" : "deposit");
           if (evidence.transfer === "confirmed" && evidence.confirmedAmount) {
             Object.assign(tx, {
-              amount: formatUnits(BigInt(evidence.confirmedAmount), asset.decimals),
+              amount: formatUnits2(BigInt(evidence.confirmedAmount), asset.decimals),
               amountRaw: evidence.confirmedAmount,
               blockNumber: evidence.blockNumber,
               logIndexes: evidence.logIndexes,
@@ -2300,6 +2355,8 @@ var ZyfaiAgent = class _ZyfaiAgent {
           evidence2 = { ...evidence2, transfer: "unknown" };
         }
         notifyFunding(onProgress, evidence2);
+        if (evidence2.transfer === "failed")
+          throw new OwneyError("AGENT_TRANSACTION_REVERTED", "Zyfai deposit transaction reverted.", { txHash }, this.id);
         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));
@@ -2338,12 +2395,113 @@ var ZyfaiAgent = class _ZyfaiAgent {
       } catch {
       }
       notifyFunding(onProgress, evidence);
+      if (evidence.transfer === "failed")
+        throw new OwneyError("AGENT_TRANSACTION_REVERTED", "Zyfai deposit transaction reverted.", { txHash: raw2.txHash }, this.id);
       return { ...mapDeposit(raw2), evidence };
     } catch (error) {
       throw error;
     }
   }
   // --- IAgent: Fund operations ---
+  /** Only after a definitive endpoint rejection, combine a new provider
+   * snapshot with the Safe's exact idle balance. Never parse its rounded error
+   * amount as proof of zero, or use this to skip sending a new MAX request. */
+  async assertNotEmptyRejectedWithdrawal(state, chainId, token, owner) {
+    const internals = this.sdk;
+    const generation = this.earningsGeneration;
+    let expired = false;
+    const unavailable = () => new OwneyError(
+      "WITHDRAW_BALANCE_UNAVAILABLE",
+      "Could not verify Zyfai's balance after its withdrawal rejection.",
+      { chainId, token },
+      this.id
+    );
+    const assertScope = () => {
+      if (expired) throw unavailable();
+      const account = internals.walletClient?.account?.address;
+      if (generation !== this.earningsGeneration || state.chainId !== chainId || state.walletAddress.toLowerCase() !== owner.toLowerCase() || this.connectedAddress?.toLowerCase() !== owner.toLowerCase() || this.connectedChainId !== chainId || account && account.toLowerCase() !== owner.toLowerCase())
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed while preparing Zyfai withdrawal.", void 0, this.id);
+    };
+    const read2 = async () => {
+      assertScope();
+      const [wallet, registered, portfolio] = await Promise.all([
+        this.sdk.getSmartWalletAddress(owner, chainId),
+        this.sdk.getSmartWalletByEOA(owner),
+        this.sdk.getPortfolio(owner).catch(() => void 0)
+      ]);
+      assertScope();
+      if (!isAddress(wallet.address) || !registered.smartWallet || registered.smartWallet.toLowerCase() !== wallet.address.toLowerCase())
+        throw new OwneyError(
+          "AGENT_AUTH_FAILED",
+          "Could not verify Zyfai's withdrawal wallet.",
+          { reason: "ZYFAI_SESSION_UNAVAILABLE", phase: "prepare", chainId, token },
+          this.id
+        );
+      if (hasEmptyWithdrawalSnapshot(portfolio, chainId, token)) {
+        const asset = SupportedAssets.find((value) => value.chainId === chainId && value.symbol === token);
+        const idle = asset ? await this.getPublicClient(chainId).readContract({
+          address: asset.address,
+          abi: erc20Abi2,
+          functionName: "balanceOf",
+          args: [wallet.address]
+        }).catch(() => void 0) : void 0;
+        assertScope();
+        if (idle === 0n) throw new OwneyError(
+          "WITHDRAW_INSUFFICIENT_BALANCE",
+          "No funds remain in Zyfai for this asset.",
+          { available: "0", chainId, token },
+          this.id
+        );
+      }
+    };
+    let timer;
+    try {
+      await Promise.race([read2(), new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          expired = true;
+          reject(unavailable());
+        }, WITHDRAW_BALANCE_TIMEOUT_MS);
+      })]);
+    } finally {
+      expired = true;
+      if (timer) clearTimeout(timer);
+    }
+  }
+  /** Called only after the execution endpoint explicitly rejected a request.
+   * A timeout or an accepted request never authorizes repair and resubmission. */
+  async recoverWithdrawalSession(state, chainId, token, owner) {
+    await this.assertNotEmptyRejectedWithdrawal(state, chainId, token, owner);
+    const internals = this.sdk;
+    const assertScope = () => {
+      const account = internals.walletClient?.account?.address;
+      if (state.walletAddress.toLowerCase() !== owner.toLowerCase() || this.connectedAddress?.toLowerCase() !== owner.toLowerCase() || this.connectedChainId !== chainId || account && account.toLowerCase() !== owner.toLowerCase())
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed while preparing Zyfai withdrawal.", void 0, this.id);
+    };
+    assertScope();
+    const walletState = await this.readWalletState(owner);
+    assertScope();
+    const unavailable = () => new OwneyError(
+      "AGENT_AUTH_FAILED",
+      "Zyfai has no active withdrawal session. Its withdrawal was not submitted.",
+      { reason: "ZYFAI_SESSION_UNAVAILABLE", phase: "prepare", chainId, token },
+      this.id
+    );
+    if (walletState.predeployed !== false || internals.isPredeployed === true) throw unavailable();
+    internals.hasActiveSessionKey = false;
+    const key2 = `${owner.toLowerCase()}:${chainId}`;
+    this.sessionKeyAttempts.delete(key2);
+    try {
+      const result = await this.sdk.createSessionKey(owner, chainId);
+      assertScope();
+      if (result.success === false || result.alreadyActive === true) throw unavailable();
+      this.sessionKeyAttempts.add(key2);
+    } catch (error) {
+      assertScope();
+      const code = error?.code;
+      if (code === 4001 || code === "ACTION_REJECTED" || error instanceof Error && /user (rejected|denied)|request rejected|action rejected/i.test(error.message)) throw error;
+      throw unavailable();
+    }
+  }
   async withdraw(state, chainId, token, amount, onProgress) {
     const validChainId = isValidChainId(chainId);
     try {
@@ -2361,11 +2519,42 @@ var ZyfaiAgent = class _ZyfaiAgent {
       });
       throw error;
     }
-    const observation = observeWithdrawalSubmission(this.sdk, validChainId, token);
+    let observation = observeWithdrawalSubmission(this.sdk, validChainId, token);
     const authToken = this.sdk.httpClient?.authToken;
+    const owner = this.getAddress();
     let raw2;
     try {
-      raw2 = await this.sdk.withdrawFunds(this.getAddress(), validChainId, amount, token);
+      for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+          raw2 = await this.sdk.withdrawFunds(owner, validChainId, amount, token);
+          break;
+        } catch (error) {
+          if (!amount && observation.rejected() && observation.request()?.failure === "insufficient-balance") {
+            try {
+              await this.assertNotEmptyRejectedWithdrawal(state, validChainId, token, owner);
+            } catch (proofError) {
+              if (proofError instanceof OwneyError && (proofError.code === "WITHDRAW_INSUFFICIENT_BALANCE" || proofError.code === "NOT_CONNECTED")) throw proofError;
+            }
+          }
+          if (!observation.rejected() || observation.request()?.failure !== "session-key-missing") throw error;
+          if (attempt === 1)
+            throw new OwneyError(
+              "AGENT_AUTH_FAILED",
+              "Zyfai has no active withdrawal session. Its withdrawal was not submitted.",
+              { reason: "ZYFAI_SESSION_UNAVAILABLE", phase: "prepare", chainId, token },
+              this.id
+            );
+          await this.recoverWithdrawalSession(state, validChainId, token, owner);
+          observation.stop();
+          observation = observeWithdrawalSubmission(this.sdk, validChainId, token);
+        }
+      }
+      if (!raw2) throw new OwneyError(
+        "AGENT_INVALID_RESPONSE",
+        "Zyfai returned no withdrawal result.",
+        { chainId, token, phase: "observe" },
+        this.id
+      );
     } catch (error) {
       this.invalidateRejectedWithdrawalSession(error, state, validChainId, authToken);
       if (observation.attempted() !== void 0) {
@@ -2440,6 +2629,67 @@ var ZyfaiAgent = class _ZyfaiAgent {
   async getFundingWallet(state, chainId) {
     return (await this.sdk.getSmartWalletAddress(state.walletAddress, isValidChainId(chainId))).address;
   }
+  /** A positive Safe balance is a withdrawal planning floor when the portfolio
+   * index reports zero. Idle zero cannot prove that Zyfai's protocol positions
+   * are empty: its SDK does not expose a complete contract catalog for them. */
+  async getWithdrawableBalance(state, chainId, token) {
+    const validChainId = isValidChainId(chainId);
+    const asset = SupportedAssets.find((value) => value.chainId === validChainId && value.symbol === token);
+    if (!asset) throw new OwneyError("WITHDRAW_NO_PERMITTED_TOKENS", "Asset selected is not supported", void 0, this.id);
+    const owner = state.walletAddress;
+    const generation = this.earningsGeneration;
+    const internals = this.sdk;
+    let expired = false;
+    const unavailable = () => new OwneyError(
+      "WITHDRAW_BALANCE_UNAVAILABLE",
+      "Could not verify Zyfai's withdrawal balance. Its vault positions may still contain funds.",
+      { reason: "ZYFAI_VAULT_BALANCE_UNVERIFIED", chainId, token },
+      this.id
+    );
+    const assertScope = () => {
+      if (expired) throw unavailable();
+      const account = internals.walletClient?.account?.address;
+      if (generation !== this.earningsGeneration || this.connectedAddress?.toLowerCase() !== owner.toLowerCase() || this.connectedChainId !== validChainId || state.walletAddress.toLowerCase() !== owner.toLowerCase() || state.chainId !== validChainId || account && account.toLowerCase() !== owner.toLowerCase())
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed while checking Zyfai's withdrawal balance.", void 0, this.id);
+    };
+    let timer;
+    const read2 = async () => {
+      assertScope();
+      const [wallet, registered] = await Promise.all([
+        this.sdk.getSmartWalletAddress(owner, validChainId),
+        this.sdk.getSmartWalletByEOA(owner)
+      ]);
+      assertScope();
+      if (!isAddress(wallet.address) || wallet.isDeployed !== true || wallet.isOwner !== true || !registered.smartWallet || registered.smartWallet.toLowerCase() !== wallet.address.toLowerCase()) throw unavailable();
+      const client = this.getPublicClient(validChainId);
+      const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
+      assertScope();
+      const idle = await client.readContract({
+        address: asset.address,
+        abi: erc20Abi2,
+        functionName: "balanceOf",
+        args: [wallet.address],
+        blockNumber
+      });
+      assertScope();
+      if (typeof idle !== "bigint" || idle <= 0n) throw unavailable();
+      return idle;
+    };
+    try {
+      return await Promise.race([read2(), new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          expired = true;
+          reject(unavailable());
+        }, WITHDRAW_BALANCE_TIMEOUT_MS);
+      })]);
+    } catch (error) {
+      if (error instanceof OwneyError) throw error;
+      throw unavailable();
+    } finally {
+      expired = true;
+      if (timer) clearTimeout(timer);
+    }
+  }
   async getBalances(state, chainId) {
     const requestedAt = Date.now();
     const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
@@ -2648,10 +2898,13 @@ import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient3,
   custom as custom3,
+  decodeEventLog as decodeEventLog2,
+  encodeEventTopics,
   encodeFunctionData,
-  erc20Abi as erc20Abi2,
+  erc20Abi as erc20Abi3,
+  erc4626Abi,
   getAddress as getAddress4,
-  isAddress as isAddress2
+  isAddress as isAddress3
 } from "viem";
 import { base as base4 } from "viem/chains";
 
@@ -3270,7 +3523,7 @@ var YieldseekerApiClient = class {
 };
 
 // src/agents/yieldseeker/yieldseeker.mapper.ts
-import { formatUnits as formatUnits2, isAddress } from "viem";
+import { formatUnits as formatUnits3, isAddress as isAddress2 } from "viem";
 
 // src/lib/helpers/snapshot-apy.ts
 var DAY_MS = 864e5;
@@ -3337,10 +3590,10 @@ function raw(value, endpoint) {
   return BigInt(value);
 }
 function decimal(value, decimals, endpoint) {
-  return formatUnits2(raw(value, endpoint), decimals);
+  return formatUnits3(raw(value, endpoint), decimals);
 }
 function usd(rawAmount, decimals, price) {
-  return Number(formatUnits2(rawAmount, decimals)) * price;
+  return Number(formatUnits3(rawAmount, decimals)) * price;
 }
 function percent(value) {
   const result = Number(value);
@@ -3366,7 +3619,7 @@ function assetAddressValue(record, address) {
 }
 function position(value, asset, baseAssetDecimals) {
   const option = value?.yieldOption;
-  if (!option || typeof option.provider !== "string" || typeof option.name !== "string" || typeof option.address !== "string" || !isAddress(option.address)) {
+  if (!option || typeof option.provider !== "string" || typeof option.name !== "string" || typeof option.address !== "string" || !isAddress2(option.address)) {
     return invalid("yield positions", "missing vault metadata");
   }
   return {
@@ -3458,7 +3711,7 @@ function mapYieldseekerEarnings(contexts) {
       chain: "BASE",
       chainId: 8453,
       asset: context.asset,
-      amount: formatUnits2(amount, context.snapshot.baseAssetDecimals)
+      amount: formatUnits3(amount, context.snapshot.baseAssetDecimals)
     });
     lifetimeEarnings += usd(
       amount,
@@ -3587,7 +3840,7 @@ function allocationEntry(action, context) {
     const leg = deposit;
     const symbol = typeof leg.assetSymbol === "string" ? leg.assetSymbol.toUpperCase() : "";
     if (symbol !== context.asset && !(context.asset === "WETH" && symbol === "ETH")) return void 0;
-    if (typeof leg.vaultAddress !== "string" || !isAddress(leg.vaultAddress)) return void 0;
+    if (typeof leg.vaultAddress !== "string" || !isAddress2(leg.vaultAddress)) return void 0;
     const rawAmount = typeof leg.rawAmount === "string" && /^\d+$/.test(leg.rawAmount) ? BigInt(leg.rawAmount) : typeof leg.rawAmount === "number" && Number.isSafeInteger(leg.rawAmount) ? BigInt(leg.rawAmount) : void 0;
     if (rawAmount === void 0 || rawAmount <= 0n) return void 0;
     const option = context.positions.find((position2) => position2.yieldOption.address.toLowerCase() === leg.vaultAddress.toLowerCase())?.yieldOption;
@@ -3595,7 +3848,7 @@ function allocationEntry(action, context) {
       protocol: typeof leg.vaultProvider === "string" && leg.vaultProvider ? leg.vaultProvider : option?.provider || "Vault",
       pool: typeof leg.vaultName === "string" && leg.vaultName ? leg.vaultName : option?.name,
       tokenSymbol: context.asset,
-      amount: formatUnits2(rawAmount, YIELDSEEKER_ASSET_METADATA[context.asset].decimals)
+      amount: formatUnits3(rawAmount, YIELDSEEKER_ASSET_METADATA[context.asset].decimals)
     });
     amountRaw += rawAmount;
   }
@@ -3614,7 +3867,7 @@ function allocationEntry(action, context) {
       tokenSymbol: context.asset,
       agentWallet: context.wallet.walletAddress,
       amountRaw: String(amountRaw),
-      amount: formatUnits2(amountRaw, YIELDSEEKER_ASSET_METADATA[context.asset].decimals)
+      amount: formatUnits3(amountRaw, YIELDSEEKER_ASSET_METADATA[context.asset].decimals)
     }]
   };
 }
@@ -3738,7 +3991,7 @@ function mapYieldseekerHistory(contexts, options) {
       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(
+        target.amount = formatUnits3(
           BigInt(target.amountRaw),
           YIELDSEEKER_ASSET_METADATA[target.tokenSymbol].decimals
         );
@@ -3833,7 +4086,8 @@ var walletAbi = parseAbi3([
   "function ownerAgentIndex() view returns (uint256)",
   "function baseAsset() view returns (address)",
   "function FACTORY() view returns (address)",
-  "function upgradeToLatest()"
+  "function upgradeToLatest()",
+  "event Upgraded(address indexed implementation)"
 ]);
 var factoryAbi = parseAbi3([
   "function userWallets(address owner, uint256 index) view returns (address)",
@@ -3842,19 +4096,19 @@ var factoryAbi = parseAbi3([
 function yieldseekerOwnerPath(code) {
   return !code || code === "0x" || /^0xef0100[0-9a-f]{40}$/i.test(code) ? "eoa" : "smart";
 }
-async function readYieldseekerWalletStatus(client, wallet, owner, asset) {
+async function readYieldseekerWalletStatus(client, wallet, owner, asset, blockNumber) {
   const agentWallet = getAddress2(wallet);
   const expectedOwner = getAddress2(owner);
   const expectedAsset = getAddress2(asset);
   const [code, ownerCode, slot, actualOwner, index, actualAsset, actualFactory, latest] = await Promise.all([
-    client.getBytecode({ address: agentWallet }),
-    client.getBytecode({ address: expectedOwner }),
-    client.getStorageAt({ address: agentWallet, slot: ERC1967_IMPLEMENTATION_SLOT }),
-    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "owner" }),
-    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "ownerAgentIndex" }),
-    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "baseAsset" }),
-    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "FACTORY" }),
-    client.readContract({ address: YIELDSEEKER_FACTORY, abi: factoryAbi, functionName: "agentWalletImplementation" })
+    client.getBytecode({ address: agentWallet, blockNumber }),
+    client.getBytecode({ address: expectedOwner, blockNumber }),
+    client.getStorageAt({ address: agentWallet, slot: ERC1967_IMPLEMENTATION_SLOT, blockNumber }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "owner", blockNumber }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "ownerAgentIndex", blockNumber }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "baseAsset", blockNumber }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "FACTORY", blockNumber }),
+    client.readContract({ address: YIELDSEEKER_FACTORY, abi: factoryAbi, functionName: "agentWalletImplementation", blockNumber })
   ]);
   if (!code || code === "0x" || !slot || /^0x0+$/.test(slot)) {
     throw new Error("Yieldseeker wallet is not a deployed ERC1967 proxy");
@@ -3864,7 +4118,8 @@ async function readYieldseekerWalletStatus(client, wallet, owner, asset) {
     address: YIELDSEEKER_FACTORY,
     abi: factoryAbi,
     functionName: "userWallets",
-    args: [expectedOwner, index]
+    args: [expectedOwner, index],
+    blockNumber
   });
   const verified = isAddressEqual(actualOwner, expectedOwner) && isAddressEqual(actualAsset, expectedAsset) && isAddressEqual(actualFactory, YIELDSEEKER_FACTORY) && isAddressEqual(mapped, agentWallet);
   const version = !verified ? "unknown" : isAddressEqual(implementation, YIELDSEEKER_V2_IMPLEMENTATION) ? "v2" : isAddressEqual(implementation, YIELDSEEKER_V1_IMPLEMENTATION) ? "v1" : "unknown";
@@ -3893,6 +4148,8 @@ import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import { base as base3 } from "viem/chains";
 var ENTRY_POINT_V06 = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
 var USER_OP_FEE_HEADROOM = 2n;
+var OBSERVATION_WINDOW_MS = 6e4;
+var OBSERVATION_POLL_MS = 1500;
 var ENTRY_POINT_NONCE_ABI = [
   { type: "function", name: "getNonce", stateMutability: "view", inputs: [
     { name: "sender", type: "address" },
@@ -3925,10 +4182,119 @@ function sponsorError(message, safeToFallback, details = {}) {
   return new OwneyError(
     "SPONSOR_REQUEST_FAILED",
     message,
-    { safeToFallback, ...details },
+    {
+      safeToFallback,
+      phase: safeToFallback ? "prepare" : "observe",
+      failureCode: safeToFallback ? "SPONSOR_PREPARATION_FAILED" : "SPONSOR_OUTCOME_UNRESOLVED",
+      ...safeToFallback ? { rejectedBeforeSubmission: true } : {},
+      ...details
+    },
     "yieldseeker"
   );
 }
+function providerReason(value) {
+  if (typeof value !== "string") return void 0;
+  return value.replace(/https?:\/\/\S+/gi, "[url]").replace(/0x[0-9a-fA-F]{40,}/g, "[hex]").replace(/[A-Za-z0-9_+=\/-]{48,}/g, "[token]").slice(0, 300);
+}
+function rpcDiagnostics(data) {
+  const details = {};
+  if (typeof data?.failureCode === "string" && [
+    "SPONSOR_RATE_LIMIT",
+    "SPONSOR_UPSTREAM_UNAVAILABLE",
+    "SPONSOR_RPC_UNSUPPORTED",
+    "SPONSOR_POLICY_REJECTED",
+    "SPONSOR_BUDGET_REJECTED",
+    "SPONSOR_EXECUTION_REVERTED"
+  ].includes(data.failureCode))
+    details.failureCode = data.failureCode;
+  if (typeof data?.revertSelector === "string" && /^0x[0-9a-fA-F]{8}$/.test(data.revertSelector))
+    details.revertSelector = data.revertSelector;
+  if (typeof data?.revertName === "string" && [
+    "InsufficientBalance",
+    "InvalidAsset",
+    "Unauthorized",
+    "Error",
+    "Panic",
+    "FailedOp",
+    "FailedOpWithRevert"
+  ].includes(data.revertName))
+    details.revertName = data.revertName;
+  if (typeof data?.aaCode === "string" && /^AA[0-9]{2}$/.test(data.aaCode)) details.aaCode = data.aaCode;
+  if (typeof data?.panicCode === "string" && /^0x[0-9a-fA-F]{1,2}$/.test(data.panicCode)) {
+    const panicCode = toHex(BigInt(data.panicCode));
+    if (["0x0", "0x1", "0x11", "0x12", "0x21", "0x22", "0x31", "0x32", "0x41", "0x51"].includes(panicCode))
+      details.panicCode = panicCode;
+  }
+  return details;
+}
+function isHash(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value);
+}
+async function assertOwnerSession(state, owner) {
+  const [chain, accounts] = await Promise.all([
+    state.provider.request({ method: "eth_chainId" }),
+    state.provider.request({ method: "eth_accounts" })
+  ]);
+  if (Number(chain) !== 8453)
+    throw new OwneyError(
+      "CHAIN_MISMATCH",
+      "Switch back to Base before withdrawing.",
+      { rejectedBeforeSubmission: true, phase: "prepare" },
+      "yieldseeker"
+    );
+  if (!Array.isArray(accounts) || typeof accounts[0] !== "string" || accounts[0].toLowerCase() !== owner.toLowerCase())
+    throw new OwneyError(
+      "NOT_CONNECTED",
+      "The connected withdrawal account changed.",
+      { rejectedBeforeSubmission: true, phase: "prepare" },
+      "yieldseeker"
+    );
+}
+function savePending(onPending, evidence, beforeSubmission = false) {
+  try {
+    onPending?.(evidence);
+  } catch {
+    if (beforeSubmission)
+      throw sponsorError(
+        "Withdrawal status cannot be saved before submission.",
+        true,
+        { phase: "prepare", rejectedBeforeSubmission: true, failureCode: "RECOVERY_STORAGE_UNAVAILABLE" }
+      );
+  }
+}
+async function checkpoint(callback, pending) {
+  try {
+    await callback?.(pending);
+  } catch {
+    throw sponsorError(
+      "Withdrawal status cannot be saved before submission.",
+      true,
+      { phase: "prepare", rejectedBeforeSubmission: true, failureCode: "RECOVERY_STORAGE_UNAVAILABLE" }
+    );
+  }
+}
+function finalPaymasterFields(value) {
+  const result = {};
+  for (const key2 of [
+    "paymasterAndData",
+    "callGasLimit",
+    "verificationGasLimit",
+    "preVerificationGas",
+    "maxFeePerGas",
+    "maxPriorityFeePerGas"
+  ]) {
+    const field = value[key2];
+    if (field === void 0) continue;
+    if (typeof field !== "string" || !/^0x[0-9a-fA-F]+$/.test(field))
+      throw sponsorError(
+        "Paymaster returned an invalid final operation.",
+        true,
+        { phase: "prepare", rejectedBeforeSubmission: true, failureCode: "INVALID_PAYMASTER_QUOTE" }
+      );
+    result[key2] = field;
+  }
+  return result;
+}
 async function requestIntent(input) {
   const baseUrl = (input.routingApiBaseUrl ?? DEFAULT_ROUTING_API).replace(/\/$/, "");
   let response;
@@ -3950,18 +4316,35 @@ async function requestIntent(input) {
         action: input.action,
         yieldseekerUserId: input.userId,
         yieldseekerAgentId: input.agentId
-      })
+      }),
+      signal: AbortSignal.timeout(15e3)
     });
   } catch {
-    throw sponsorError("Withdrawal sponsorship could not be requested.", true);
+    throw sponsorError(
+      "Withdrawal sponsorship could not be requested.",
+      true,
+      { phase: "prepare", rejectedBeforeSubmission: true, failureCode: "INTENT_NETWORK_ERROR" }
+    );
   }
   const envelope = await response.json().catch(() => null);
   const intent = envelope?.data;
   if (!response.ok || !envelope?.success || !intent?.intent || !["eoa", "smart"].includes(intent.ownerPath)) {
+    const rawCode = typeof envelope?.failureCode === "string" ? envelope.failureCode : envelope?.code;
+    const failureCode = typeof rawCode === "string" && /^[A-Z][A-Z0-9_]{0,79}$/.test(rawCode) ? rawCode : void 0;
+    if (input.refreshYieldseekerSignature && (failureCode === "YIELDSEEKER_AUTH_REJECTED" || failureCode === "AUTH_REJECTED" || envelope?.sponsorshipStage === "provider-auth" && (envelope.providerStatus === 401 || envelope.providerStatus === 403))) {
+      const signature = await input.refreshYieldseekerSignature(input.yieldseekerSignature);
+      return requestIntent({ ...input, yieldseekerSignature: signature, refreshYieldseekerSignature: void 0 });
+    }
     throw sponsorError(
       "Withdrawal sponsorship is currently unavailable.",
       true,
-      { statusCode: response.status }
+      {
+        statusCode: response.status,
+        phase: "prepare",
+        rejectedBeforeSubmission: true,
+        failureCode: failureCode ?? "INTENT_REJECTED",
+        providerReason: providerReason(envelope?.message)
+      }
     );
   }
   const url = new URL(`${baseUrl}/api/v1/sponsor/yieldseeker-withdraw/rpc`);
@@ -3974,19 +4357,55 @@ async function rpc(url, method, params, phase) {
     response = await fetch(url, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+      signal: AbortSignal.timeout(15e3)
     });
   } catch {
-    throw sponsorError("Withdrawal sponsorship request status is unknown.", phase === "prepare");
+    throw sponsorError(
+      "Withdrawal sponsorship request status is unknown.",
+      phase === "prepare",
+      {
+        phase,
+        rpcMethod: method,
+        ...phase === "prepare" ? { rejectedBeforeSubmission: true } : {},
+        failureCode: "RPC_NETWORK_ERROR"
+      }
+    );
   }
   const payload = await response.json().catch(() => null);
   if (!response.ok || payload?.error || payload?.result === void 0) {
     const rejection = payload?.error;
-    const definitiveRejection = phase === "send" && response.status < 500 && !!rejection && (rejection.data?.rejectedBeforeSubmission === true || [-32501, -32502, -32503, -32504, -32505, -32507].includes(rejection.code ?? 0) || /maxFeePerGas.*(?:too low|lower than|less than|must be at least)/i.test(rejection.message ?? ""));
+    const diagnostics = rpcDiagnostics(rejection?.data);
+    const executionReverted = rejection?.code === -32521 || diagnostics.failureCode === "SPONSOR_EXECUTION_REVERTED";
+    const details = {
+      statusCode: response.status,
+      rpcCode: rejection?.code,
+      rpcMethod: method,
+      phase,
+      providerReason: providerReason(rejection?.data?.providerReason) ?? providerReason(rejection?.message),
+      failureCode: "RPC_REJECTED",
+      ...diagnostics
+    };
+    if (phase === "prepare" && executionReverted)
+      throw new OwneyError(
+        "WITHDRAW_FAILED",
+        "Yieldseeker withdrawal simulation reverted before submission.",
+        {
+          ...details,
+          failureCode: "SPONSOR_EXECUTION_REVERTED",
+          safeToFallback: false,
+          rejectedBeforeSubmission: true
+        },
+        "yieldseeker"
+      );
+    const definitiveRejection = phase === "send" && !executionReverted && response.status < 500 && !!rejection && (rejection.data?.rejectedBeforeSubmission === true || [-32501, -32502, -32503, -32504, -32505, -32507].includes(rejection.code ?? 0) || /maxFeePerGas.*(?:too low|lower than|less than|must be at least)/i.test(rejection.message ?? ""));
     throw sponsorError(
       phase !== "prepare" && !definitiveRejection ? "Sponsored withdrawal submission status is unknown." : "Withdrawal sponsorship was declined before submission.",
       phase === "prepare" || definitiveRejection,
-      { statusCode: response.status, rpcCode: payload?.error?.code, rpcMethod: method }
+      {
+        ...details,
+        ...phase === "prepare" || definitiveRejection ? { rejectedBeforeSubmission: true } : {}
+      }
     );
   }
   return payload.result;
@@ -4006,13 +4425,15 @@ async function submitEoa(input) {
   let nonce;
   let fees;
   try {
-    nonce = await input.client.readContract({
-      address: ENTRY_POINT_V06,
-      abi: ENTRY_POINT_NONCE_ABI,
-      functionName: "getNonce",
-      args: [input.agentWallet, 0n]
-    });
-    fees = await input.client.estimateFeesPerGas();
+    [nonce, fees] = await Promise.all([
+      input.client.readContract({
+        address: ENTRY_POINT_V06,
+        abi: ENTRY_POINT_NONCE_ABI,
+        functionName: "getNonce",
+        args: [input.agentWallet, 0n]
+      }),
+      input.client.estimateFeesPerGas()
+    ]);
   } catch {
     throw sponsorError("Could not prepare the sponsored withdrawal.", true);
   }
@@ -4055,9 +4476,10 @@ async function submitEoa(input) {
     );
     if (!final.paymasterAndData?.startsWith("0x"))
       throw sponsorError("CDP did not return final paymaster data.", true);
-    operation = { ...operation, paymasterAndData: final.paymasterAndData };
+    operation = { ...operation, ...finalPaymasterFields(final) };
   }
   const userOpHash = operationHash(operation);
+  await assertOwnerSession(input.state, input.owner);
   const wallet = createWalletClient2({
     account: input.owner,
     chain: base3,
@@ -4065,24 +4487,47 @@ async function submitEoa(input) {
   });
   const signature = await wallet.signMessage({ message: { raw: userOpHash } });
   operation = { ...operation, signature };
-  input.onPending?.({ userOpHash });
+  await assertOwnerSession(input.state, input.owner);
+  const userOperation = {
+    sender: operation.sender,
+    nonce: operation.nonce,
+    initCode: operation.initCode,
+    callData: operation.callData,
+    callGasLimit: operation.callGasLimit,
+    verificationGasLimit: operation.verificationGasLimit,
+    preVerificationGas: operation.preVerificationGas,
+    maxFeePerGas: operation.maxFeePerGas,
+    maxPriorityFeePerGas: operation.maxPriorityFeePerGas,
+    paymasterAndData: operation.paymasterAndData
+  };
+  savePending(input.onPending, { userOpHash, userOperation }, true);
+  await checkpoint(input.onBeforeSubmission, { userOpHash, userOperation });
   const submittedHash = await rpc(
     input.rpcUrl,
     "eth_sendUserOperation",
     [operation, ENTRY_POINT_V06],
     "send"
   );
-  if (submittedHash.toLowerCase() !== userOpHash.toLowerCase())
+  if (!isHash(submittedHash) || submittedHash.toLowerCase() !== userOpHash.toLowerCase())
     throw sponsorError(
       "Bundler returned a different UserOperation hash.",
       false,
-      { userOpHash, submittedHash }
+      { userOpHash, submittedHash, phase: "send", failureCode: "BUNDLER_HASH_MISMATCH" }
     );
-  for (let poll = 0; poll < 40; poll++) {
-    const response = await rpc(input.rpcUrl, "eth_getUserOperationReceipt", [userOpHash], "observe");
+  const deadline = Date.now() + OBSERVATION_WINDOW_MS;
+  let lastReadError;
+  for (let poll = 0; poll < 40 && Date.now() < deadline; poll++) {
+    let response;
+    try {
+      response = await rpc(input.rpcUrl, "eth_getUserOperationReceipt", [userOpHash], "observe");
+    } catch (error) {
+      lastReadError = error;
+      await new Promise((resolve) => setTimeout(resolve, Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - Date.now()))));
+      continue;
+    }
     const txHash = response?.receipt?.transactionHash;
-    if (txHash) {
-      input.onPending?.({ userOpHash, txHash });
+    if (isHash(txHash)) {
+      savePending(input.onPending, { userOpHash, txHash });
       if (response?.success === false)
         throw new OwneyError(
           "AGENT_TRANSACTION_REVERTED",
@@ -4092,12 +4537,17 @@ async function submitEoa(input) {
         );
       return { txHash, receipt: await waitForTransaction(input.client, txHash) };
     }
-    await new Promise((resolve) => setTimeout(resolve, 1500));
+    await new Promise((resolve) => setTimeout(resolve, OBSERVATION_POLL_MS));
   }
   throw sponsorError(
     "Sponsored withdrawal is still pending; check status before retrying.",
     false,
-    { userOpHash }
+    {
+      userOpHash,
+      phase: "observe",
+      failureCode: "RECEIPT_UNRESOLVED",
+      ...lastReadError instanceof OwneyError ? { lastObservationError: lastReadError.details } : {}
+    }
   );
 }
 async function submitSmart(input) {
@@ -4110,14 +4560,14 @@ async function submitSmart(input) {
   } catch {
     throw sponsorError("This account cannot check paymaster support on Base.", true);
   }
-  if (!capabilities?.[toHex(8453)]?.paymasterService?.supported && !capabilities?.["8453"]?.paymasterService?.supported)
+  const supportsPaymaster = capabilities?.[toHex(8453)]?.paymasterService?.supported ?? capabilities?.["8453"]?.paymasterService?.supported ?? capabilities?.["0x0"]?.paymasterService?.supported;
+  if (supportsPaymaster !== true)
     throw sponsorError("This account cannot use a paymaster on Base.", true);
+  await assertOwnerSession(input.state, input.owner);
   let sent;
-  try {
-    input.onPending?.({});
-  } catch {
-    throw sponsorError("Upgrade or withdrawal status cannot be saved.", true);
-  }
+  const requestedId = toHex(globalThis.crypto.getRandomValues(new Uint8Array(32)));
+  savePending(input.onPending, { callsId: requestedId }, true);
+  await checkpoint(input.onBeforeSubmission, { callsId: requestedId });
   try {
     sent = await input.state.provider.request({
       method: "wallet_sendCalls",
@@ -4125,6 +4575,7 @@ async function submitSmart(input) {
         version: "2.0.0",
         from: input.owner,
         chainId: toHex(8453),
+        id: requestedId,
         atomicRequired: false,
         calls: [{ to: input.agentWallet, value: "0x0", data: input.callData }],
         capabilities: { paymasterService: { url: input.rpcUrl } }
@@ -4133,17 +4584,27 @@ async function submitSmart(input) {
   } catch (error) {
     if (error?.code === 4001) throw error;
     if ([4200, -32601].includes(Number(error?.code)))
-      throw sponsorError("This account does not support sponsored calls.", true);
-    throw sponsorError("Wallet submission status is unknown. Check activity before retrying.", false);
+      throw sponsorError(
+        "This account does not support sponsored calls.",
+        true,
+        { phase: "send", failureCode: "WALLET_CALLS_UNSUPPORTED" }
+      );
+    throw sponsorError(
+      "Wallet submission status is unknown. Check activity before retrying.",
+      false,
+      { callsId: requestedId, phase: "send", failureCode: "WALLET_SEND_UNRESOLVED" }
+    );
   }
   const callsId = typeof sent === "string" ? sent : sent?.id;
-  if (!callsId) throw sponsorError("Wallet returned no calls ID; submission status is unknown.", false);
-  try {
-    input.onPending?.({ callsId });
-  } catch {
-    throw sponsorError("Submitted call status could not be saved.", false, { callsId });
-  }
-  for (let poll = 0; poll < 40; poll++) {
+  if (typeof callsId !== "string" || callsId.length === 0 || callsId.length > 8194)
+    throw sponsorError(
+      "Wallet returned no calls ID; submission status is unknown.",
+      false,
+      { callsId: requestedId, phase: "send", failureCode: "WALLET_SEND_UNRESOLVED" }
+    );
+  savePending(input.onPending, { callsId });
+  const deadline = Date.now() + OBSERVATION_WINDOW_MS;
+  for (let poll = 0; poll < 40 && Date.now() < deadline; poll++) {
     let status;
     try {
       status = await input.state.provider.request({
@@ -4151,33 +4612,40 @@ async function submitSmart(input) {
         params: [callsId]
       });
     } catch {
-      throw sponsorError("Sponsored withdrawal status is unknown.", false, { callsId });
+      await new Promise((resolve) => setTimeout(resolve, Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - Date.now()))));
+      continue;
     }
-    if (status?.status === 400 || status?.status === 500)
+    if (status?.id !== void 0 && status.id !== callsId || status?.chainId !== void 0 && Number(status.chainId) !== 8453)
+      throw sponsorError(
+        "Wallet returned a different sponsored operation status.",
+        false,
+        { callsId, phase: "observe", failureCode: "WALLET_STATUS_MISMATCH" }
+      );
+    if (Number(status?.status) === 400 || Number(status?.status) === 500)
       throw sponsorError(
         "Sponsored withdrawal failed in the wallet.",
         false,
-        { callsId, executionFailed: true }
+        { callsId, executionFailed: true, phase: "observe", failureCode: "WALLET_EXECUTION_FAILED" }
       );
-    const txHash = status?.receipts?.[0]?.transactionHash;
+    const hashes = [...new Set((status?.receipts ?? []).map((receipt) => receipt.transactionHash).filter(isHash))];
+    const txHash = hashes.length === 1 ? hashes[0] : void 0;
     if (txHash) {
-      try {
-        input.onPending?.({ callsId, txHash });
-      } catch {
-        throw sponsorError(
-          "Submitted call receipt could not be saved.",
-          false,
-          { callsId, txHash }
+      savePending(input.onPending, { callsId, txHash });
+      if (status?.receipts?.some((receipt) => receipt.transactionHash === txHash && /^(?:0x0+|0|failed|reverted)$/i.test(String(receipt.status))))
+        throw new OwneyError(
+          "AGENT_TRANSACTION_REVERTED",
+          "Sponsored withdrawal execution reverted.",
+          { callsId, transactionHash: txHash },
+          "yieldseeker"
         );
-      }
       return { txHash, receipt: await waitForTransaction(input.client, txHash) };
     }
-    await new Promise((resolve) => setTimeout(resolve, 1500));
+    await new Promise((resolve) => setTimeout(resolve, OBSERVATION_POLL_MS));
   }
   throw sponsorError(
     "Sponsored withdrawal is still pending; check status before retrying.",
     false,
-    { callsId }
+    { callsId, phase: "observe", failureCode: "RECEIPT_UNRESOLVED" }
   );
 }
 async function submitYieldseekerSponsoredWithdrawal(input) {
@@ -4192,7 +4660,8 @@ async function submitYieldseekerSponsoredWithdrawal(input) {
     agentWallet: input.agentWallet,
     asset: input.asset,
     callData: input.callData,
-    action: "withdraw"
+    action: "withdraw",
+    refreshYieldseekerSignature: input.refreshYieldseekerSignature
   });
   const args = { ...input, owner, rpcUrl };
   return intent.ownerPath === "eoa" ? submitEoa(args) : submitSmart(args);
@@ -4209,7 +4678,8 @@ async function submitYieldseekerSponsoredUpgrade(input) {
     agentWallet: input.agentWallet,
     asset: input.asset,
     callData: input.callData,
-    action: "upgrade"
+    action: "upgrade",
+    refreshYieldseekerSignature: input.refreshYieldseekerSignature
   });
   if (intent.ownerPath !== "smart")
     throw sponsorError("V1 upgrade sponsorship requires a Base Account owner.", true);
@@ -4231,6 +4701,9 @@ var YIELDSEEKER_READ_FAILURE_COOLDOWN_MS = 6e4;
 var YIELDSEEKER_SETTLEMENT_WINDOW_MS = 5 * 6e4;
 var YIELDSEEKER_ACTIVITY_CACHE_MS = 6e4;
 var YIELDSEEKER_MAX_WITHDRAW_SWEEPS = 3;
+var YIELDSEEKER_MAX_POSITION_VERIFICATION_MS = 2e3;
+var YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT = 64;
+var YIELDSEEKER_VAULTS_PER_RPC_BATCH = 10;
 function generateYieldseekerUsername() {
   const suffix = globalThis.crypto.randomUUID().replaceAll("-", "").slice(0, YIELDSEEKER_USERNAME_RANDOM_LENGTH).toLowerCase();
   return `${YIELDSEEKER_USERNAME_PREFIX}${suffix}`;
@@ -4241,6 +4714,13 @@ function isUsernameConflict(error) {
   return code.includes("USERNAME") && (code.includes("TAKEN") || code.includes("EXIST") || code.includes("UNAVAILABLE") || code.includes("IN_USE"));
 }
 var YIELDSEEKER_AGENT_WALLET_ABI = [
+  {
+    type: "function",
+    name: "feeTracker",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
   {
     type: "function",
     name: "withdrawAssetToUser",
@@ -4263,6 +4743,13 @@ var YIELDSEEKER_AGENT_WALLET_ABI = [
     outputs: []
   }
 ];
+var YIELDSEEKER_FEE_TRACKER_ABI = [{
+  type: "function",
+  name: "getFeesOwed",
+  stateMutability: "view",
+  inputs: [{ name: "wallet", type: "address" }],
+  outputs: [{ name: "", type: "uint256" }]
+}];
 function query(params) {
   const search = new URLSearchParams();
   for (const [key2, value] of Object.entries(params)) {
@@ -4346,17 +4833,22 @@ var YieldseekerAgent = class {
       getAddress4(state.walletAddress),
       YIELDSEEKER_ASSET_METADATA[asset].address
     );
+    this.rememberWalletStatus(key2, status);
+    return status;
+  }
+  rememberWalletStatus(key2, status) {
     if (status.verified && status.version === "v2") {
       this.withdrawalVersionCache.set(key2, { at: Date.now(), status: { ...status } });
       if (this.withdrawalVersionCache.size > 128)
         this.withdrawalVersionCache.delete(this.withdrawalVersionCache.keys().next().value);
     } else this.withdrawalVersionCache.delete(key2);
-    return status;
   }
   /** Explicit owner action. This never runs as a side effect of withdrawal. */
   async upgradeWallet(state, chainId, asset, gasMode = "paid") {
+    const generation = this.readGeneration;
     const before = await this.getWalletStatus(state, chainId, asset);
-    if (!before?.verified || !before.upgradeAvailable) {
+    this.assertSession(generation, chainId);
+    if (!before?.verified || before.version === "unknown") {
       throw new OwneyError(
         "WITHDRAW_FAILED",
         "This Yieldseeker wallet cannot be upgraded to the reviewed V2 implementation.",
@@ -4364,48 +4856,77 @@ var YieldseekerAgent = class {
         this.id
       );
     }
-    const data = encodeFunctionData({ abi: YIELDSEEKER_UPGRADE_ABI, functionName: "upgradeToLatest" });
-    let txHash;
-    if (gasMode === "sponsored") {
-      if (before.ownerPath !== "smart")
-        throw new OwneyError(
-          "SPONSOR_REQUEST_FAILED",
-          "EOA owners pay Base gas for the V1 upgrade.",
-          { safeToFallback: true },
-          this.id
-        );
-      let storage5;
-      try {
-        storage5 = typeof window === "undefined" ? void 0 : window.localStorage;
-      } catch {
-        storage5 = void 0;
-      }
-      if (!storage5)
+    const versionKey = `${chainId}:${before.owner.toLowerCase()}:${before.agentWallet.toLowerCase()}:${asset}`;
+    const pendingKey2 = `owney.yieldseeker.upgrade:${before.owner.toLowerCase()}:${before.agentWallet.toLowerCase()}`;
+    const confirmUpgrade = async (hash, receipt2) => {
+      this.withdrawalVersionCache.delete(versionKey);
+      const upgradeTopic = encodeEventTopics({ abi: YIELDSEEKER_UPGRADE_ABI, eventName: "Upgraded" })[0];
+      const lastUpgrade = receipt2?.logs.filter((log) => log.address.toLowerCase() === before.agentWallet.toLowerCase() && log.topics[0] === upgradeTopic).at(-1);
+      const expectedUpgrade = (() => {
+        if (!lastUpgrade || lastUpgrade.removed) return false;
+        try {
+          const event = decodeEventLog2({ abi: YIELDSEEKER_UPGRADE_ABI, eventName: "Upgraded", data: lastUpgrade.data, topics: lastUpgrade.topics });
+          return event.args.implementation.toLowerCase() === YIELDSEEKER_V2_IMPLEMENTATION.toLowerCase();
+        } catch {
+          return false;
+        }
+      })();
+      if (!receipt2 || receipt2.status !== "success" || receipt2.transactionHash.toLowerCase() !== hash.toLowerCase() || typeof receipt2.blockNumber !== "bigint" || !expectedUpgrade)
         throw new OwneyError(
-          "SPONSOR_REQUEST_FAILED",
-          "Upgrade status cannot be saved in this browser.",
-          { safeToFallback: true },
+          "WITHDRAW_FAILED",
+          "Yieldseeker wallet upgrade receipt could not be verified.",
+          { txHash: hash, reason: "UPGRADE_RECEIPT_MISMATCH" },
           this.id
         );
-      const pendingKey = `owney.yieldseeker.upgrade:${state.walletAddress.toLowerCase()}:${before.agentWallet.toLowerCase()}`;
-      let prior = null;
-      let saved;
+      this.assertSession(generation, chainId);
+      const status = {
+        ...before,
+        implementation: YIELDSEEKER_V2_IMPLEMENTATION,
+        version: "v2",
+        upgradeAvailable: false
+      };
+      this.rememberWalletStatus(versionKey, status);
+      return { txHash: hash, status };
+    };
+    let storage5;
+    try {
+      storage5 = typeof window === "undefined" ? void 0 : window.localStorage;
+    } catch {
+      storage5 = void 0;
+    }
+    const clearConfirmedUpgrade = () => {
       try {
-        saved = storage5.getItem(pendingKey);
+        storage5?.removeItem(pendingKey2);
       } catch {
-        throw new OwneyError(
-          "SPONSOR_REQUEST_FAILED",
-          "Upgrade status cannot be read in this browser.",
-          { safeToFallback: true },
-          this.id
-        );
       }
+    };
+    if (!storage5 && (gasMode === "sponsored" || before.ownerPath === "smart"))
+      throw new OwneyError(
+        "SPONSOR_REQUEST_FAILED",
+        "Upgrade status cannot be saved in this browser.",
+        { safeToFallback: false },
+        this.id
+      );
+    let prior = null;
+    try {
+      const saved = storage5?.getItem(pendingKey2);
       try {
         prior = JSON.parse(saved ?? "null");
       } catch {
         prior = { callsId: void 0 };
       }
-      if (prior) {
+    } catch {
+      if (gasMode === "paid" && before.ownerPath === "eoa") storage5 = void 0;
+      else throw new OwneyError(
+        "SPONSOR_REQUEST_FAILED",
+        "Upgrade status cannot be read in this browser.",
+        { safeToFallback: false },
+        this.id
+      );
+    }
+    if (prior) {
+      let earlierHash = this.isTransactionHash(prior.txHash) ? prior.txHash : void 0;
+      if (!earlierHash) {
         if (!prior.callsId)
           throw new OwneyError(
             "SPONSOR_REQUEST_FAILED",
@@ -4415,10 +4936,7 @@ var YieldseekerAgent = class {
           );
         let callsStatus;
         try {
-          callsStatus = await state.provider.request({
-            method: "wallet_getCallsStatus",
-            params: [prior.callsId]
-          });
+          callsStatus = await state.provider.request({ method: "wallet_getCallsStatus", params: [prior.callsId] });
         } catch {
           throw new OwneyError(
             "SPONSOR_REQUEST_FAILED",
@@ -4427,8 +4945,15 @@ var YieldseekerAgent = class {
             this.id
           );
         }
-        if (callsStatus?.status === 400 || callsStatus?.status === 500) {
-          storage5.removeItem(pendingKey);
+        if (callsStatus?.id !== void 0 && callsStatus.id !== prior.callsId || callsStatus?.chainId !== void 0 && Number(callsStatus.chainId) !== chainId)
+          throw new OwneyError(
+            "SPONSOR_REQUEST_FAILED",
+            "The earlier upgrade returned a different operation status.",
+            { safeToFallback: false, callsId: prior.callsId },
+            this.id
+          );
+        if (Number(callsStatus?.status) === 400 || Number(callsStatus?.status) === 500) {
+          storage5.removeItem(pendingKey2);
           throw new OwneyError(
             "SPONSOR_REQUEST_FAILED",
             "The earlier sponsored upgrade failed.",
@@ -4436,22 +4961,39 @@ var YieldseekerAgent = class {
             this.id
           );
         }
-        const earlierHash = callsStatus?.receipts?.[0]?.transactionHash;
-        if (earlierHash) {
-          await this.waitForReceipt(state, chainId, earlierHash);
-          const earlierStatus = await this.getWalletStatus(state, chainId, asset);
-          if (earlierStatus?.version === "v2" && earlierStatus.verified) {
-            storage5.removeItem(pendingKey);
-            return { txHash: earlierHash, status: earlierStatus };
-          }
-        }
+        const hashes = [...new Set((callsStatus?.receipts ?? []).map((value) => value.transactionHash).filter(this.isTransactionHash))];
+        earlierHash = hashes.length === 1 ? hashes[0] : void 0;
+      }
+      if (earlierHash) {
+        const recovered = await confirmUpgrade(earlierHash, await this.waitForReceipt(state, chainId, earlierHash));
+        clearConfirmedUpgrade();
+        return recovered;
+      }
+      throw new OwneyError(
+        "SPONSOR_REQUEST_FAILED",
+        "An earlier upgrade is still pending.",
+        { safeToFallback: false, callsId: prior.callsId },
+        this.id
+      );
+    }
+    if (!before.upgradeAvailable)
+      throw new OwneyError(
+        "WITHDRAW_FAILED",
+        "This Yieldseeker wallet cannot be upgraded to the reviewed V2 implementation.",
+        { version: before.version },
+        this.id
+      );
+    const data = encodeFunctionData({ abi: YIELDSEEKER_UPGRADE_ABI, functionName: "upgradeToLatest" });
+    let txHash;
+    let receipt;
+    if (gasMode === "sponsored") {
+      if (before.ownerPath !== "smart")
         throw new OwneyError(
           "SPONSOR_REQUEST_FAILED",
-          "An earlier upgrade is still pending.",
-          { safeToFallback: false, callsId: prior.callsId },
+          "EOA owners pay Base gas for the V1 upgrade.",
+          { safeToFallback: true },
           this.id
         );
-      }
       const context = await this.findAgent(state, chainId, asset);
       if (!context) throw new OwneyError("NOT_CONNECTED", "Yieldseeker agent is unavailable.");
       try {
@@ -4461,14 +5003,15 @@ var YieldseekerAgent = class {
           apiKey: this.owneyApiKey,
           routingApiBaseUrl: this.routingApiBaseUrl,
           yieldseekerSignature: await this.auth.getToken(state, chainId),
+          refreshYieldseekerSignature: (rejected) => this.auth.refreshToken(state, chainId, rejected),
           userId: context.user.userId,
           agentId: context.agent.agentId,
           agentWallet: before.agentWallet,
           asset: YIELDSEEKER_ASSET_METADATA[asset].address,
           callData: data,
           onPending: (pending) => {
-            const current = storage5.getItem(pendingKey);
-            storage5.setItem(pendingKey, JSON.stringify({
+            const current = storage5.getItem(pendingKey2);
+            storage5.setItem(pendingKey2, JSON.stringify({
               startedAt: Date.now(),
               ...current ? JSON.parse(current) : {},
               ...pending
@@ -4476,8 +5019,9 @@ var YieldseekerAgent = class {
           }
         });
         txHash = upgraded.txHash;
+        receipt = upgraded.receipt;
       } catch (error) {
-        if (error?.code === 4001 || error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)) storage5.removeItem(pendingKey);
+        if (error?.code === 4001 || error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)) storage5.removeItem(pendingKey2);
         throw error;
       }
     } else {
@@ -4487,20 +5031,13 @@ var YieldseekerAgent = class {
         data,
         value: "0",
         chainId
+      }, void 0, (value) => {
+        receipt = value;
       });
     }
-    const status = await this.getWalletStatus(state, chainId, asset);
-    if (!status?.verified || status.version !== "v2") {
-      throw new OwneyError(
-        "WITHDRAW_FAILED",
-        "Yieldseeker wallet upgrade was not confirmed as V2.",
-        { txHash, version: status?.version ?? "missing" },
-        this.id
-      );
-    }
-    if (gasMode === "sponsored" && typeof window !== "undefined")
-      window.localStorage.removeItem(`owney.yieldseeker.upgrade:${state.walletAddress.toLowerCase()}:${before.agentWallet.toLowerCase()}`);
-    return { txHash, status };
+    const confirmed = await confirmUpgrade(txHash, receipt ?? await this.waitForReceipt(state, chainId, txHash));
+    if (gasMode === "sponsored") clearConfirmedUpgrade();
+    return confirmed;
   }
   async disconnect() {
     this.withdrawalVersionCache.clear();
@@ -4573,30 +5110,48 @@ var YieldseekerAgent = class {
       submitted(txHash);
       receipt = await this.waitForReceipt(state, chainId, txHash);
     } else {
-      txHash = await this.submitTransaction(state, chainId, {
-        from: getAddress4(state.walletAddress),
-        to: YIELDSEEKER_ASSET_METADATA[asset].address,
-        data: encodeFunctionData({
-          abi: erc20Abi2,
-          functionName: "transfer",
-          args: [getAddress4(context.wallet.walletAddress), BigInt(amount)]
-        }),
-        value: "0",
-        chainId
-      }, submitted, (value) => {
-        receipt = value;
-      });
-    }
-    if (this.readGeneration === generation) {
-      void this.refreshSnapshotAfterMovement(state, chainId, context, "deposit", movement);
-    }
-    const base6 = { 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, base6, YIELDSEEKER_ASSET_METADATA[asset].address, "deposit") : base6;
-    notifyFunding(onProgress, evidence);
-    return { txHash, smartWallet: context.wallet.walletAddress, amount, evidence };
-  }
-  async withdraw(state, chainId, asset, amount, onProgress, gasMode = "auto") {
-    let ownerTransferAttempted = false;
+      try {
+        txHash = await this.submitTransaction(state, chainId, {
+          from: getAddress4(state.walletAddress),
+          to: YIELDSEEKER_ASSET_METADATA[asset].address,
+          data: encodeFunctionData({
+            abi: erc20Abi3,
+            functionName: "transfer",
+            args: [getAddress4(context.wallet.walletAddress), BigInt(amount)]
+          }),
+          value: "0",
+          chainId
+        }, submitted, (value) => {
+          receipt = value;
+        });
+      } catch (error) {
+        if (error instanceof OwneyError && error.details?.ownerTransferNotExecuted === true && error.details.reason === "TRANSACTION_REPLACED_WITH_DIFFERENT_CALL") {
+          notifyFunding(onProgress, {
+            agentId: this.id,
+            chainId,
+            token: asset,
+            walletAddress: state.walletAddress,
+            agentWallet: context.wallet.walletAddress,
+            intendedAmount: amount,
+            txHash: String(error.details.originalTransactionHash),
+            transfer: "failed",
+            registration: "not-applicable",
+            delivery: "not-applicable"
+          });
+        }
+        throw error;
+      }
+    }
+    if (this.readGeneration === generation) {
+      void this.refreshSnapshotAfterMovement(state, chainId, context, "deposit", movement);
+    }
+    const base6 = { 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, base6, YIELDSEEKER_ASSET_METADATA[asset].address, "deposit") : base6;
+    notifyFunding(onProgress, evidence);
+    return { txHash, smartWallet: context.wallet.walletAddress, amount, evidence };
+  }
+  async withdraw(state, chainId, asset, amount, onProgress, gasMode = "auto", onBeforeSubmission) {
+    let ownerTransferAttempted = false;
     let evidence = {
       agentId: this.id,
       chainId,
@@ -4613,10 +5168,10 @@ var YieldseekerAgent = class {
         notifyFunding(onProgress, evidence);
       }, () => {
         ownerTransferAttempted = true;
-      }, gasMode);
+      }, gasMode, onBeforeSubmission);
     } catch (error) {
       if (error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED") this.withdrawalVersionCache.clear();
-      if (!ownerTransferAttempted || error?.code === 4001 || error instanceof OwneyError && (error.code === "AGENT_TRANSACTION_REVERTED" || error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)))
+      if (!ownerTransferAttempted || error?.code === 4001 || error instanceof OwneyError && (error.code === "AGENT_TRANSACTION_REVERTED" || error.details?.ownerTransferNotExecuted === true || error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)))
         notifyFunding(onProgress, {
           ...evidence,
           ...error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && error.details?.safeToFallback === true ? { userOpHash: void 0, callsId: void 0 } : {},
@@ -4626,7 +5181,7 @@ var YieldseekerAgent = class {
       throw error;
     }
   }
-  async withdrawInternal(state, chainId, asset, amount, onProgress, onOwnerTransferAttempted, gasMode = "auto") {
+  async withdrawInternal(state, chainId, asset, amount, onProgress, onOwnerTransferAttempted, gasMode = "auto", onBeforeSubmission) {
     this.assertChain(chainId);
     this.assertAsset(asset);
     if (amount !== void 0 && BigInt(amount) <= 0n) {
@@ -4671,37 +5226,140 @@ var YieldseekerAgent = class {
     let confirmedMovement = false;
     let settlement = null;
     try {
-      if (amount === void 0) this.advancePortfolioVersion(this.contextKey(state, chainId, asset));
-      const portfolio = await this.loadPortfolioContext(
-        state,
-        chainId,
-        context
+      const maxSettlementBasis = amount === void 0 ? this.snapshotMovement(state, chainId, context, 0n) : null;
+      const contextKey = this.contextKey(state, chainId, asset);
+      const priorPositions = this.withdrawalVaultHints(state, chainId, context);
+      this.advancePortfolioVersion(contextKey);
+      const boundedVerification = async (read2, timeoutMs = YIELDSEEKER_MAX_POSITION_VERIFICATION_MS) => {
+        let timer;
+        try {
+          return await Promise.race([read2, new Promise((resolve) => {
+            timer = setTimeout(() => resolve(void 0), Math.max(0, timeoutMs));
+          })]);
+        } finally {
+          if (timer) clearTimeout(timer);
+        }
+      };
+      const feeRateRead = amount === void 0 ? Promise.resolve(0) : boundedVerification(
+        (() => {
+          try {
+            return this.portfolioSnapshot(state, chainId, context, contextKey).read.then((value) => value.agentSnapshot.feeRateBps);
+          } catch (error) {
+            return Promise.reject(error);
+          }
+        })().catch(() => void 0)
       );
+      const positionsRead = this.readWithdrawalPositions(state, chainId, context);
       const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-      const readIdle = async () => {
-        const balance = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
-          address: metadata.address,
-          abi: erc20Abi2,
-          functionName: "balanceOf",
-          args: [getAddress4(context.wallet.walletAddress)]
+      const agentWallet = getAddress4(context.wallet.walletAddress);
+      const readOwnerFunds = async (blockNumber) => {
+        const feeTracker = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
+          address: agentWallet,
+          abi: YIELDSEEKER_AGENT_WALLET_ABI,
+          functionName: "feeTracker",
+          blockNumber
         }), chainId, "eth_call", this.id);
         this.assertSession(generation, chainId, asset);
-        return balance;
+        if (!isAddress3(feeTracker) || /^0x0{40}$/i.test(feeTracker))
+          throw this.invalidResponse("wallet fee tracker");
+        const [idle2, fees] = await Promise.all([
+          withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
+            address: metadata.address,
+            abi: erc20Abi3,
+            functionName: "balanceOf",
+            args: [agentWallet],
+            blockNumber
+          }), chainId, "eth_call", this.id),
+          withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
+            address: getAddress4(feeTracker),
+            abi: YIELDSEEKER_FEE_TRACKER_ABI,
+            functionName: "getFeesOwed",
+            args: [agentWallet],
+            blockNumber
+          }), chainId, "eth_call", this.id)
+        ]);
+        this.assertSession(generation, chainId, asset);
+        if (typeof idle2 !== "bigint" || idle2 < 0n || typeof fees !== "bigint" || fees < 0n)
+          throw this.invalidResponse("wallet withdrawal balance");
+        return { blockNumber, idle: idle2, fees, available: idle2 > fees ? idle2 - fees : 0n };
       };
-      const idle = await readIdle();
-      let positions = portfolio.positions;
+      const [funds, feeRateBps] = await Promise.all([
+        positionsRead.then((positions2) => this.resolveWithdrawalLiquidity(
+          state,
+          chainId,
+          context,
+          positions2,
+          priorPositions,
+          amount === void 0 ? void 0 : BigInt(amount)
+        )),
+        feeRateRead
+      ]);
+      const initialFunds = funds;
+      const idle = initialFunds.idle;
+      const maxLiquidity = amount === void 0 ? funds : void 0;
+      let positions = [...funds.positions, ...funds.indexedPositions.filter((position2) => !funds.verifiedVaults.includes(position2.yieldOption.address.toLowerCase()))];
       let positionsStatus = "empty";
-      const validatePositions = (values) => {
-        const seen = /* @__PURE__ */ new Set();
-        for (const value of values) {
-          const address = value?.yieldOption?.address;
-          if (typeof address !== "string" || !isAddress2(address) || seen.has(address.toLowerCase()) || typeof value.assetsRaw !== "string" || !/^\d+$/.test(value.assetsRaw) || typeof value.withdrawableAssetsRaw !== "string" || !/^\d+$/.test(value.withdrawableAssetsRaw))
-            throw this.invalidResponse("yield positions");
-          seen.add(address.toLowerCase());
-        }
-        return values;
+      const validatePositions = (values) => this.validateWithdrawalPositions(values, chainId, asset);
+      validatePositions(positions);
+      const zeroValuePositions = /* @__PURE__ */ new WeakSet();
+      const hasPositions = (values) => values.some((position2) => !zeroValuePositions.has(position2) && (BigInt(position2.assetsRaw) > 0n || BigInt(position2.withdrawableAssetsRaw) > 0n));
+      const knownPositions = /* @__PURE__ */ new Map();
+      const rememberPositions = (values) => {
+        for (const position2 of values) knownPositions.set(position2.yieldOption.address.toLowerCase(), position2);
+      };
+      const verifyKnownPositions = async (blockNumber, values = [...knownPositions.values()], timeoutMs = YIELDSEEKER_MAX_POSITION_VERIFICATION_MS) => {
+        const verifiedPositions = [];
+        if (timeoutMs <= 0) return { verified: false, positions: verifiedPositions };
+        let active = true;
+        const checks = this.readVaultLiquidity(values.map((position2) => position2.yieldOption), agentWallet, blockNumber).catch(() => []);
+        const reads = values.map(async (position2, index) => {
+          const address = getAddress4(position2.yieldOption.address);
+          try {
+            const group = (await checks).slice(index * 3, index * 3 + 3);
+            if (!active || group.length !== 3 || group.some((value) => value.status !== "success")) return null;
+            this.assertSession(generation, chainId, asset);
+            const [underlying, shares, withdrawable] = group.map((value) => value.result);
+            if (typeof underlying !== "string" || !isAddress3(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n || typeof withdrawable !== "bigint" || withdrawable < 0n) return null;
+            const verified = { ...position2, assetsRaw: shares.toString(), withdrawableAssetsRaw: withdrawable.toString() };
+            if (shares > 0n && withdrawable === 0n) {
+              let positiveValue = false;
+              const valuations = await Promise.all(["convertToAssets", "previewRedeem"].map(async (functionName) => {
+                try {
+                  const value = await this.getReceiptClient().readContract({
+                    address,
+                    abi: erc4626Abi,
+                    functionName,
+                    args: [shares],
+                    blockNumber
+                  });
+                  if (typeof value !== "bigint" || value < 0n) return null;
+                  if (value > 0n && !positiveValue) {
+                    positiveValue = true;
+                    verifiedPositions.push(verified);
+                  }
+                  return value;
+                } catch {
+                  return null;
+                }
+              }));
+              if (positiveValue) return verified;
+              if (blockNumber === void 0 || valuations.some((value) => value !== 0n)) return null;
+              zeroValuePositions.add(verified);
+            }
+            verifiedPositions.push(verified);
+            return verified;
+          } catch {
+            return null;
+          }
+        });
+        const result = await boundedVerification(Promise.all(reads), timeoutMs);
+        active = false;
+        this.assertSession(generation, chainId, asset);
+        return {
+          verified: result !== void 0 && result.every((position2) => position2 !== null),
+          positions: [...verifiedPositions]
+        };
       };
-      const hasPositions = (values) => values.some((position2) => BigInt(position2.assetsRaw) > 0n || BigInt(position2.withdrawableAssetsRaw) > 0n);
       const refreshPositions = async () => {
         this.assertSession(generation, chainId, asset);
         const response = await this.walletRequest(
@@ -4714,22 +5372,41 @@ var YieldseekerAgent = class {
         return validatePositions(response.yieldPositions);
       };
       if (amount === void 0) {
-        validatePositions(positions);
+        rememberPositions(funds.indexedPositions);
+        rememberPositions(positions);
         positionsStatus = hasPositions(positions) ? "remaining" : "empty";
       }
       const deployed = positions.reduce(
         (total, position2) => total + BigInt(position2.withdrawableAssetsRaw),
         0n
       );
-      const totalAvailable = idle + deployed;
+      const grossAvailable = idle + deployed;
+      const totalAvailable = grossAvailable > initialFunds.fees ? grossAvailable - initialFunds.fees : 0n;
       const requested = amount === void 0 ? totalAvailable : BigInt(amount);
       if (requested === 0n) {
         this.invalidateFundingRead(state, chainId, asset);
-        if (amount === void 0 && positionsStatus === "remaining")
+        const zeroPayoutCandidates = positions.filter((position2) => BigInt(position2.assetsRaw) > 0n || BigInt(position2.withdrawableAssetsRaw) > 0n);
+        if (amount === void 0 && zeroPayoutCandidates.length) {
+          const deadline = Date.now() + YIELDSEEKER_MAX_POSITION_VERIFICATION_MS;
+          const blockNumber = initialFunds.blockNumber ?? await boundedVerification(
+            Promise.resolve().then(() => this.getReceiptClient().getBlockNumber({ cacheTime: 0 })).catch(() => void 0)
+          );
+          const proof = typeof blockNumber === "bigint" ? await verifyKnownPositions(blockNumber, zeroPayoutCandidates, deadline - Date.now()) : { verified: false, positions: [] };
+          positions = proof.positions;
+          positionsStatus = hasPositions(positions) ? "remaining" : proof.verified ? "empty" : "unavailable";
+          if (positionsStatus !== "empty")
+            throw new OwneyError(
+              "WITHDRAW_FAILED",
+              "Yieldseeker vault funds are not currently withdrawable.",
+              { asset, positionsStatus, remainingPositions: positions.map((position2) => position2.yieldOption.address) },
+              this.id
+            );
+        }
+        if (grossAvailable > 0n && totalAvailable === 0n)
           throw new OwneyError(
-            "WITHDRAW_FAILED",
-            "Yieldseeker vault funds are not currently withdrawable.",
-            { asset, remainingPositions: positions.map((position2) => position2.yieldOption.address) },
+            "WITHDRAW_INSUFFICIENT_BALANCE",
+            "No owner-withdrawable Yieldseeker funds remain after reserved fees.",
+            { asset, available: "0", reason: "YIELDSEEKER_FEES_ONLY", feesReserved: initialFunds.fees.toString() },
             this.id
           );
         throw new OwneyError(
@@ -4751,28 +5428,50 @@ var YieldseekerAgent = class {
           this.id
         );
       }
-      let remaining = requested > idle ? requested - idle : 0n;
+      const requiredIdle = requested + initialFunds.fees;
+      let remaining = requiredIdle > idle ? requiredIdle - idle : 0n;
       let grossUnwound = 0n;
+      let latestUnwindBlock;
       const unwind = async (position2, assetsRaw) => {
         this.assertSession(generation, chainId, asset);
-        const response = await this.walletRequest(
-          state,
-          chainId,
-          this.agentPath(context, "withdraw-from-position"),
-          {
-            method: "POST",
-            body: { chainId, vaultAddress: position2.yieldOption.address, assetsRaw: assetsRaw.toString() }
-          }
-        );
-        if (!this.isTransactionHash(response?.transactionHash)) throw this.invalidResponse("position withdrawal");
-        await this.waitForReceipt(state, chainId, response.transactionHash);
+        let unwindTransactionHash;
+        try {
+          const response = await this.walletRequest(
+            state,
+            chainId,
+            this.agentPath(context, "withdraw-from-position"),
+            {
+              method: "POST",
+              body: { chainId, vaultAddress: position2.yieldOption.address, assetsRaw: assetsRaw.toString() }
+            }
+          );
+          if (!this.isTransactionHash(response?.transactionHash)) throw this.invalidResponse("position withdrawal");
+          unwindTransactionHash = response.transactionHash;
+          const unwindReceipt = await this.waitForReceipt(state, chainId, unwindTransactionHash);
+          if (unwindReceipt) latestUnwindBlock = unwindReceipt.blockNumber;
+        } catch (error) {
+          this.invalidateFundingRead(state, chainId, asset);
+          throw new OwneyError(
+            error instanceof OwneyError ? error.code : "WITHDRAW_FAILED",
+            "Could not confirm the Yieldseeker vault release. No owner transfer was submitted.",
+            {
+              ...error instanceof OwneyError ? error.details : {},
+              withdrawalPhase: "unwind",
+              reason: "YIELDSEEKER_UNWIND_UNRESOLVED",
+              vaultAddress: position2.yieldOption.address,
+              unwindTransactionHash,
+              ownerTransferSubmitted: false
+            },
+            this.id
+          );
+        }
         confirmedMovement = true;
         this.assertSession(generation, chainId, asset);
         grossUnwound += assetsRaw;
       };
       if (amount === void 0) {
         for (let sweep = 0; sweep < YIELDSEEKER_MAX_WITHDRAW_SWEEPS && hasPositions(positions); sweep++) {
-          const before = new Map(positions.map((position2) => [position2.yieldOption.address.toLowerCase(), BigInt(position2.assetsRaw)]));
+          const before = new Map(positions.map((position2) => [position2.yieldOption.address.toLowerCase(), BigInt(position2.withdrawableAssetsRaw)]));
           let unwound = false;
           for (const position2 of positions) {
             const available = BigInt(position2.withdrawableAssetsRaw);
@@ -4781,15 +5480,22 @@ var YieldseekerAgent = class {
             unwound = true;
           }
           if (!unwound) break;
-          try {
-            positions = await refreshPositions();
-            positionsStatus = hasPositions(positions) ? "remaining" : "empty";
-          } catch {
-            this.assertSession(generation, chainId, asset);
+          const knownBeforeRefresh = new Set(knownPositions.keys());
+          const [catalog, proof] = await Promise.all([
+            boundedVerification(refreshPositions().catch(() => void 0)),
+            verifyKnownPositions(latestUnwindBlock)
+          ]);
+          if (catalog) rememberPositions(catalog);
+          this.assertSession(generation, chainId, asset);
+          if (proof.verified) {
+            positions = [...proof.positions, ...(catalog ?? []).filter((position2) => !knownBeforeRefresh.has(position2.yieldOption.address.toLowerCase()))];
+          } else if (catalog) positions = catalog;
+          else {
             positionsStatus = "unavailable";
             break;
           }
-          if (positions.some((position2) => BigInt(position2.assetsRaw) > 0n && before.has(position2.yieldOption.address.toLowerCase()) && BigInt(position2.assetsRaw) >= before.get(position2.yieldOption.address.toLowerCase()))) break;
+          positionsStatus = hasPositions(positions) ? "remaining" : "empty";
+          if (positions.some((position2) => BigInt(position2.withdrawableAssetsRaw) > 0n && before.has(position2.yieldOption.address.toLowerCase()) && BigInt(position2.withdrawableAssetsRaw) >= before.get(position2.yieldOption.address.toLowerCase()))) break;
         }
       } else {
         for (const position2 of positions) {
@@ -4807,8 +5513,9 @@ var YieldseekerAgent = class {
           remaining: remaining.toString()
         });
       }
-      const availableForOwner = confirmedMovement ? await readIdle() : idle;
-      const feeRate = portfolio.snapshot.feeRateBps;
+      const ownerFunds = confirmedMovement ? await readOwnerFunds(latestUnwindBlock) : initialFunds;
+      const availableForOwner = ownerFunds.available;
+      const feeRate = feeRateBps ?? 0;
       const maxFee = confirmedMovement && Number.isInteger(feeRate) && feeRate >= 0 && feeRate <= 1e3 ? (grossUnwound * BigInt(feeRate) + 9999n) / 10000n : 0n;
       const shortfall = availableForOwner < requested ? requested - availableForOwner : 0n;
       if (availableForOwner === 0n || amount !== void 0 && shortfall > maxFee) {
@@ -4828,7 +5535,11 @@ var YieldseekerAgent = class {
         );
       }
       const payout = amount === void 0 || availableForOwner < requested ? availableForOwner : requested;
-      const plannedMovement = this.snapshotMovement(state, chainId, context, -payout);
+      const plannedMovement = amount === void 0 && maxSettlementBasis ? {
+        ...maxSettlementBasis,
+        delta: maxSettlementBasis.delta - payout,
+        expectedNetDeposits: maxSettlementBasis.expectedNetDeposits - payout
+      } : this.snapshotMovement(state, chainId, context, -payout);
       const account = getAddress4(state.walletAddress);
       let receipt;
       const base6 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount === void 0 ? "MAX" : payout.toString(), transfer: "pending", registration: "not-applicable", delivery: "pending" };
@@ -4841,7 +5552,6 @@ var YieldseekerAgent = class {
         functionName: "withdrawAssetToUser",
         args: [account, metadata.address, payout]
       });
-      onOwnerTransferAttempted?.();
       let txHash;
       if (sponsor) {
         const submitted = await submitYieldseekerSponsoredWithdrawal({
@@ -4850,16 +5560,22 @@ var YieldseekerAgent = class {
           apiKey: this.owneyApiKey,
           routingApiBaseUrl: this.routingApiBaseUrl,
           yieldseekerSignature: await this.auth.getToken(state, chainId),
+          refreshYieldseekerSignature: (rejected) => this.auth.refreshToken(state, chainId, rejected),
           userId: context.user.userId,
           agentId: context.agent.agentId,
           agentWallet: getAddress4(context.wallet.walletAddress),
           asset: metadata.address,
           callData: data,
-          onPending: (pending) => notifyFunding(onProgress, { ...base6, ...pending })
+          onPending: (pending) => notifyFunding(onProgress, { ...base6, ...pending }),
+          onBeforeSubmission: async (pending) => {
+            await onBeforeSubmission?.({ ...base6, ...pending });
+            onOwnerTransferAttempted?.();
+          }
         });
         txHash = submitted.txHash;
         receipt = submitted.receipt;
       } else {
+        onOwnerTransferAttempted?.();
         txHash = await this.submitTransaction(state, chainId, {
           from: account,
           to: getAddress4(context.wallet.walletAddress),
@@ -4874,14 +5590,26 @@ var YieldseekerAgent = class {
       settlement = plannedMovement;
       const evidence = receipt ? inspectFundingReceipt(receipt, { ...base6, txHash }, metadata.address, "withdraw") : { ...base6, txHash, confirmedAmount: payout.toString(), transfer: "confirmed", delivery: "confirmed" };
       notifyFunding(onProgress, evidence);
+      let completion = maxLiquidity && !maxLiquidity.complete ? "unverified" : void 0;
       if (amount === void 0) {
-        try {
-          positions = await refreshPositions();
-          positionsStatus = hasPositions(positions) ? "remaining" : "empty";
-        } catch {
-          positionsStatus = "unavailable";
-        }
-        if (positionsStatus !== "empty") {
+        const verificationDeadline = Date.now() + YIELDSEEKER_MAX_POSITION_VERIFICATION_MS;
+        const knownAtPayout = new Set(knownPositions.keys());
+        const [catalogVerified, knownProof] = await Promise.all([
+          boundedVerification(refreshPositions().then((values) => {
+            rememberPositions(values);
+            return true;
+          }).catch(() => false)),
+          verifyKnownPositions(receipt?.blockNumber)
+        ]);
+        const newPositions = [...knownPositions].filter(([address]) => !knownAtPayout.has(address)).map(([, position2]) => position2);
+        const newProof = newPositions.length ? await verifyKnownPositions(receipt?.blockNumber, newPositions, verificationDeadline - Date.now()) : { verified: true, positions: [] };
+        const proof = {
+          verified: catalogVerified === true && knownProof.verified && newProof.verified,
+          positions: [...knownProof.positions, ...newProof.positions]
+        };
+        positions = proof.positions;
+        positionsStatus = hasPositions(positions) ? "remaining" : proof.verified ? "empty" : "unavailable";
+        if (positionsStatus === "remaining") {
           const result = { txHash, type: "partial", amount: evidence.confirmedAmount ?? payout.toString(), evidence };
           throw new OwneyError(
             "WITHDRAW_PARTIAL_FAILURE",
@@ -4890,7 +5618,7 @@ var YieldseekerAgent = class {
               reason: "YIELDSEEKER_MAX_INCOMPLETE",
               asset,
               positionsStatus,
-              remainingPositions: positionsStatus === "remaining" ? positions.map((position2) => ({
+              remainingPositions: positionsStatus === "remaining" ? positions.filter((position2) => !zeroValuePositions.has(position2) && (BigInt(position2.assetsRaw) > 0n || BigInt(position2.withdrawableAssetsRaw) > 0n)).map((position2) => ({
                 vaultAddress: position2.yieldOption.address,
                 sharesRaw: position2.assetsRaw,
                 withdrawableAmountRaw: position2.withdrawableAssetsRaw
@@ -4900,6 +5628,7 @@ var YieldseekerAgent = class {
             this.id
           );
         }
+        if (!proof.verified) completion = "unverified";
       }
       if (evidence.transfer === "failed" && evidence.confirmedAmount === "0")
         throw new OwneyError(
@@ -4908,7 +5637,17 @@ var YieldseekerAgent = class {
           { asset, available: "0", txHash },
           this.id
         );
-      return { txHash, type: amount === void 0 ? "full" : "partial", amount: evidence.confirmedAmount ?? payout.toString(), evidence };
+      const confirmedAmount = evidence.confirmedAmount && /^\d+$/.test(evidence.confirmedAmount) ? BigInt(evidence.confirmedAmount) : void 0;
+      const feeIncrease = ownerFunds.fees - initialFunds.fees;
+      const feeAdjustment = amount !== void 0 && receipt && initialFunds.blockNumber !== void 0 && latestUnwindBlock !== void 0 && initialFunds.blockNumber <= latestUnwindBlock && receipt.blockNumber >= latestUnwindBlock && evidence.transfer === "confirmed" && evidence.delivery === "confirmed" && confirmedAmount === payout && feeIncrease > 0n && feeIncrease <= maxFee && requested - payout === feeIncrease ? { grossAmount: requested.toString(), feeAmount: feeIncrease.toString() } : void 0;
+      return {
+        txHash,
+        type: amount === void 0 && !completion ? "full" : "partial",
+        ...completion ? { completion } : {},
+        ...feeAdjustment ? { feeAdjustment } : {},
+        amount: evidence.confirmedAmount ?? payout.toString(),
+        evidence
+      };
     } finally {
       if (confirmedMovement && this.readGeneration === generation) {
         void this.refreshSnapshotAfterMovement(
@@ -4921,6 +5660,236 @@ var YieldseekerAgent = class {
       }
     }
   }
+  /** A withdrawal-only liquidity floor; display snapshots never authorize it. */
+  async getWithdrawableBalance(state, chainId, asset, minimumAmount) {
+    this.assertChain(chainId);
+    this.assertAsset(asset);
+    const generation = this.readGeneration;
+    const context = await this.findAgent(state, chainId, asset);
+    this.assertSession(generation, chainId, asset);
+    if (!context) throw new OwneyError(
+      "WITHDRAW_BALANCE_UNAVAILABLE",
+      "The Yieldseeker withdrawal wallet could not be verified.",
+      { asset },
+      this.id
+    );
+    const hints = this.withdrawalVaultHints(state, chainId, context);
+    const positions = await this.readWithdrawalPositions(state, chainId, context);
+    const proof = await this.resolveWithdrawalLiquidity(state, chainId, context, positions, hints, minimumAmount);
+    this.assertSession(generation, chainId, asset);
+    if (proof.available === 0n && !proof.complete) throw new OwneyError(
+      "WITHDRAW_BALANCE_UNAVAILABLE",
+      "Yieldseeker withdrawal liquidity could not be verified yet.",
+      { asset },
+      this.id
+    );
+    return proof.available;
+  }
+  async readVaultLiquidity(options, wallet, blockNumber) {
+    const owner = getAddress4(wallet);
+    const batches = Array.from({ length: Math.ceil(options.length / YIELDSEEKER_VAULTS_PER_RPC_BATCH) }, (_, index) => options.slice(index * YIELDSEEKER_VAULTS_PER_RPC_BATCH, (index + 1) * YIELDSEEKER_VAULTS_PER_RPC_BATCH));
+    const results = await Promise.all(batches.map((batch) => this.getReceiptClient().multicall({
+      blockNumber,
+      allowFailure: true,
+      contracts: batch.flatMap((option) => {
+        const address = getAddress4(option.address);
+        return [
+          { address, abi: erc4626Abi, functionName: "asset" },
+          { address, abi: erc20Abi3, functionName: "balanceOf", args: [owner] },
+          { address, abi: erc4626Abi, functionName: "maxWithdraw", args: [owner] }
+        ];
+      })
+    })));
+    return results.flat();
+  }
+  validateWithdrawalPositions(values, chainId, asset) {
+    const underlying = YIELDSEEKER_ASSET_METADATA[asset].address.toLowerCase();
+    const seen = /* @__PURE__ */ new Set();
+    for (const value of values) {
+      const option = value?.yieldOption;
+      if (!option || typeof option.address !== "string" || !isAddress3(option.address) || seen.has(option.address.toLowerCase()) || option.chainId !== void 0 && option.chainId !== chainId || option.assetAddress !== void 0 && (typeof option.assetAddress !== "string" || option.assetAddress.toLowerCase() !== underlying) || typeof value.assetsRaw !== "string" || !/^\d+$/.test(value.assetsRaw) || typeof value.withdrawableAssetsRaw !== "string" || !/^\d+$/.test(value.withdrawableAssetsRaw))
+        throw this.invalidResponse("yield positions");
+      seen.add(option.address.toLowerCase());
+    }
+    return values;
+  }
+  withdrawalVaultHints(state, chainId, context) {
+    const key2 = this.contextKey(state, chainId, context.asset);
+    const positions = this.readCache.get(`positions:${key2}`)?.value?.yieldPositions ?? [];
+    const hints = new Map(this.validateWithdrawalPositions(positions, chainId, context.asset).map((position2) => [position2.yieldOption.address.toLowerCase(), position2]));
+    const historic = this.readCache.get(`historic:${key2}`)?.value?.position;
+    const receivedAssets = new Set((historic?.movements ?? []).filter((movement) => movement.chainId === chainId && movement.agentWalletId === context.wallet.agentWalletId && movement.toAddress?.toLowerCase() === context.wallet.walletAddress.toLowerCase()).filter((movement) => typeof movement.assetAddress === "string").map((movement) => movement.assetAddress.toLowerCase()));
+    for (const option of this.yieldOptions.get(context.asset)?.value ?? []) {
+      if (option.chainId !== chainId || typeof option.assetAddress !== "string" || option.assetAddress.toLowerCase() !== YIELDSEEKER_ASSET_METADATA[context.asset].address.toLowerCase() || !isAddress3(option.address) || !receivedAssets.has(option.address.toLowerCase()) || hints.has(option.address.toLowerCase())) continue;
+      hints.set(option.address.toLowerCase(), {
+        yieldOption: option,
+        assetsRaw: "0",
+        assetsBase: "0",
+        assetsUsd: 0,
+        withdrawableAssetsRaw: "0",
+        withdrawableAssetsBase: "0"
+      });
+    }
+    return [...hints.values()];
+  }
+  async readWithdrawalPositions(state, chainId, context) {
+    const generation = this.readGeneration;
+    let timer;
+    try {
+      const positions = await Promise.race([
+        this.loadActivityContext(state, chainId, context, {}).then((value) => value.positions).catch((error) => {
+          if (!(error instanceof OwneyError) || !["AGENT_API_ERROR", "AGENT_TIMEOUT"].includes(error.code)) throw error;
+          return void 0;
+        }),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(void 0), YIELDSEEKER_MAX_POSITION_VERIFICATION_MS);
+        })
+      ]);
+      this.assertSession(generation, chainId, context.asset);
+      return positions === void 0 ? void 0 : this.validateWithdrawalPositions(positions, chainId, context.asset);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async resolveWithdrawalLiquidity(state, chainId, context, positions, previousPositions = [], requested) {
+    const generation = this.readGeneration;
+    const contextKey = this.contextKey(state, chainId, context.asset);
+    const version = this.portfolioVersion(contextKey);
+    const metadata = YIELDSEEKER_ASSET_METADATA[context.asset];
+    const unavailable = () => new OwneyError(
+      "WITHDRAW_BALANCE_UNAVAILABLE",
+      "Yieldseeker withdrawal liquidity could not be verified yet.",
+      { asset: context.asset, reason: "YIELDSEEKER_LIQUIDITY_UNVERIFIED" },
+      this.id
+    );
+    let active = true;
+    let knownProof;
+    const hasUnverifiedIndexedFunds = (proof) => proof.indexedPositions.some((position2) => !proof.verifiedVaults.includes(position2.yieldOption.address.toLowerCase()) && BigInt(position2.withdrawableAssetsRaw) > 0n);
+    const assertReadCurrent = () => {
+      this.assertSession(generation, chainId, context.asset);
+      if (!active || this.portfolioVersion(contextKey) !== version) throw unavailable();
+    };
+    const read2 = async () => {
+      const client = this.getReceiptClient();
+      const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
+      const wallet = getAddress4(context.wallet.walletAddress);
+      assertReadCurrent();
+      if (typeof blockNumber !== "bigint") throw unavailable();
+      const indexedPositions = this.validateWithdrawalPositions(positions ?? [], chainId, context.asset);
+      const candidates = /* @__PURE__ */ new Map();
+      for (const position2 of this.validateWithdrawalPositions([...previousPositions], chainId, context.asset))
+        candidates.set(position2.yieldOption.address.toLowerCase(), position2.yieldOption);
+      for (const position2 of indexedPositions) candidates.set(position2.yieldOption.address.toLowerCase(), position2.yieldOption);
+      const options = [...candidates.values()];
+      if (options.length > YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT) throw unavailable();
+      const [checks, idle, feeTracker] = await Promise.all([
+        this.readVaultLiquidity(options, wallet, blockNumber),
+        client.readContract({
+          address: metadata.address,
+          abi: erc20Abi3,
+          functionName: "balanceOf",
+          args: [wallet],
+          blockNumber
+        }),
+        client.readContract({
+          address: wallet,
+          abi: YIELDSEEKER_AGENT_WALLET_ABI,
+          functionName: "feeTracker",
+          blockNumber
+        })
+      ]);
+      if (typeof idle !== "bigint" || idle < 0n || !isAddress3(feeTracker) || /^0x0{40}$/i.test(feeTracker)) throw unavailable();
+      assertReadCurrent();
+      const fees = await client.readContract({
+        address: getAddress4(feeTracker),
+        abi: YIELDSEEKER_FEE_TRACKER_ABI,
+        functionName: "getFeesOwed",
+        args: [wallet],
+        blockNumber
+      });
+      if (typeof fees !== "bigint" || fees < 0n) throw unavailable();
+      const verified = [];
+      const verifiedVaults = [];
+      let deployed = 0n;
+      const collect = (options2, results) => {
+        let valid2 = true;
+        options2.forEach((option, index) => {
+          const group = results.slice(index * 3, index * 3 + 3);
+          if (group.length !== 3 || group.some((value) => value.status !== "success")) {
+            valid2 = false;
+            return;
+          }
+          const [underlying, shares, withdrawable] = group.map((value) => value.result);
+          if (typeof underlying !== "string" || !isAddress3(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n || typeof withdrawable !== "bigint" || withdrawable < 0n || shares === 0n && withdrawable > 0n) {
+            valid2 = false;
+            return;
+          }
+          verifiedVaults.push(option.address.toLowerCase());
+          deployed += withdrawable;
+          verified.push({
+            yieldOption: option,
+            assetsRaw: shares.toString(),
+            assetsBase: "0",
+            assetsUsd: 0,
+            withdrawableAssetsRaw: withdrawable.toString(),
+            withdrawableAssetsBase: withdrawable.toString()
+          });
+        });
+        return valid2;
+      };
+      const allKnownVerified = collect(options, checks);
+      const proof = (complete) => ({
+        blockNumber,
+        idle,
+        fees,
+        available: idle + deployed > fees ? idle + deployed - fees : 0n,
+        positions: [...verified],
+        verifiedVaults: [...verifiedVaults],
+        indexedPositions,
+        complete
+      });
+      knownProof = proof(false);
+      const indexed = new Map(indexedPositions.map((position2) => [position2.yieldOption.address.toLowerCase(), position2]));
+      const discrepancy = verified.some((position2) => {
+        const row = indexed.get(position2.yieldOption.address.toLowerCase());
+        return row ? BigInt(position2.withdrawableAssetsRaw) < BigInt(row.withdrawableAssetsRaw) : BigInt(position2.assetsRaw) > 0n;
+      });
+      const typedCoveredByIdle = requested !== void 0 && idle >= requested + fees;
+      const expand = positions === void 0 || indexedPositions.length === 0 && !typedCoveredByIdle || !allKnownVerified || discrepancy || knownProof.available === 0n || requested !== void 0 && requested > knownProof.available;
+      if (!expand) {
+        assertReadCurrent();
+        return proof(true);
+      }
+      const catalog = await this.loadYieldOptions(context.asset).catch(() => void 0);
+      assertReadCurrent();
+      const eligible = /* @__PURE__ */ new Map();
+      for (const option of catalog ?? []) {
+        if (option?.chainId === chainId && typeof option.assetAddress === "string" && option.assetAddress.toLowerCase() === metadata.address.toLowerCase() && isAddress3(option.address))
+          eligible.set(option.address.toLowerCase(), option);
+      }
+      const extra = [...eligible].filter(([address]) => !candidates.has(address)).map(([, option]) => option);
+      if (options.length + extra.length > YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT) throw unavailable();
+      const allExtraVerified = collect(extra, await this.readVaultLiquidity(extra, wallet, blockNumber));
+      assertReadCurrent();
+      const result = proof(eligible.size > 0 && allKnownVerified && allExtraVerified);
+      if (result.available === 0n && !result.complete && !hasUnverifiedIndexedFunds(result)) throw unavailable();
+      return result;
+    };
+    let timer;
+    try {
+      return await Promise.race([read2(), new Promise((_, reject) => {
+        timer = setTimeout(() => reject(unavailable()), YIELDSEEKER_MAX_POSITION_VERIFICATION_MS);
+      })]);
+    } catch (error) {
+      assertReadCurrent();
+      if (knownProof && (knownProof.available > 0n || hasUnverifiedIndexedFunds(knownProof)) && (!(error instanceof OwneyError) || error.code === "WITHDRAW_BALANCE_UNAVAILABLE")) return knownProof;
+      if (error instanceof OwneyError) throw error;
+      throw unavailable();
+    } finally {
+      active = false;
+      if (timer) clearTimeout(timer);
+    }
+  }
   async getBalances(state, chainId, asset) {
     this.assertChain(chainId);
     if (asset !== void 0) this.assertAsset(asset);
@@ -4955,6 +5924,23 @@ var YieldseekerAgent = class {
     if (!context) throw new OwneyError("NOT_CONNECTED", "Reconnect the agent before recovering funding.");
     return context.wallet.walletAddress;
   }
+  async hasExistingDepositFunds(state, chainId, asset) {
+    this.assertChain(chainId);
+    this.assertAsset(asset);
+    const generation = this.readGeneration;
+    const context = await this.findAgent(state, chainId, asset);
+    this.assertSession(generation, chainId, asset);
+    if (!context) return void 0;
+    const idle = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
+      address: YIELDSEEKER_ASSET_METADATA[asset].address,
+      abi: erc20Abi3,
+      functionName: "balanceOf",
+      args: [getAddress4(context.wallet.walletAddress)]
+    }), chainId, "eth_call", this.id);
+    this.assertSession(generation, chainId, asset);
+    if (typeof idle !== "bigint" || idle < 0n) throw this.invalidResponse("wallet deposit balance");
+    return idle > 0n ? true : void 0;
+  }
   async getEarnings(state, chainId) {
     this.assertChain(chainId);
     return mapYieldseekerEarnings(await this.loadPortfolio(state, chainId, {}));
@@ -4985,7 +5971,7 @@ var YieldseekerAgent = class {
     );
     const vaultAddresses = new Set(
       catalog.flat().filter(
-        (yieldOption) => yieldOption.chainId === chainId && isAddress2(yieldOption.address)
+        (yieldOption) => yieldOption.chainId === chainId && isAddress3(yieldOption.address)
       ).map((yieldOption) => yieldOption.address.toLowerCase())
     );
     return mapYieldseekerHistory(contexts, {
@@ -5112,7 +6098,7 @@ var YieldseekerAgent = class {
       `/users/${user.userId}/agents/${agent.agentId}/wallet`
     ).then((walletResponse) => {
       this.assertSession(generation, chainId, asset);
-      if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
+      if (!walletResponse?.agentWallet || !isAddress3(walletResponse.agentWallet.walletAddress)) {
         throw this.invalidResponse("agent wallet");
       }
       const context = {
@@ -5525,7 +6511,7 @@ var YieldseekerAgent = class {
       this.agentPath(context, "deploy"),
       { method: "POST", body: {} }
     );
-    if (!deployed?.agentWallet || !isAddress2(deployed.agentWallet.walletAddress) || deployed.agentWallet.walletAddress.toLowerCase() !== walletAddress) {
+    if (!deployed?.agentWallet || !isAddress3(deployed.agentWallet.walletAddress) || deployed.agentWallet.walletAddress.toLowerCase() !== walletAddress) {
       throw this.invalidResponse("agent deployment", {
         reason: "Deploy did not return the expected Agent Wallet."
       });
@@ -5656,25 +6642,79 @@ var YieldseekerAgent = class {
       value: BigInt(transaction.value)
     });
     onSubmitted?.(hash);
+    let replacement;
     const receipt = await withPaidRpcDiagnostics(
       () => this.getReceiptClient().waitForTransactionReceipt({
         hash,
-        confirmations: 1
+        confirmations: 1,
+        onReplaced: (value) => {
+          replacement = value;
+        }
       }),
       8453,
       "eth_getTransactionReceipt",
       this.id
     );
+    const actualHash = receipt.transactionHash;
+    if (!this.isTransactionHash(actualHash))
+      throw new OwneyError(
+        "WITHDRAW_FAILED",
+        "The confirmed transaction hash could not be verified.",
+        { originalTransactionHash: hash, ownerTransferNotExecuted: false },
+        this.id
+      );
+    if (actualHash.toLowerCase() !== hash.toLowerCase()) {
+      if (!replacement || replacement.transaction.hash.toLowerCase() !== actualHash.toLowerCase()) {
+        try {
+          const [original2, actual2] = await Promise.all([
+            this.getReceiptClient().getTransaction({ hash }),
+            this.getReceiptClient().getTransaction({ hash: actualHash })
+          ]);
+          replacement = { replacedTransaction: original2, transaction: actual2 };
+        } catch {
+          replacement = void 0;
+        }
+      }
+      const original = replacement?.replacedTransaction;
+      const actual = replacement?.transaction;
+      const sameNonce = !!original && !!actual && original.hash.toLowerCase() === hash.toLowerCase() && actual.hash.toLowerCase() === actualHash.toLowerCase() && original.from.toLowerCase() === account.toLowerCase() && actual.from.toLowerCase() === account.toLowerCase() && original.nonce === actual.nonce && (actual.chainId === void 0 || actual.chainId === chainId) && receipt.blockNumber !== null && receipt.blockNumber !== void 0;
+      if (!sameNonce)
+        throw new OwneyError(
+          "WITHDRAW_FAILED",
+          "The replacement transaction could not be verified.",
+          {
+            originalTransactionHash: hash,
+            replacementTransactionHash: actualHash,
+            reason: "TRANSACTION_REPLACEMENT_UNRESOLVED",
+            ownerTransferNotExecuted: false
+          },
+          this.id
+        );
+      const sameCall = actual.to?.toLowerCase() === transaction.to.toLowerCase() && actual.input?.toLowerCase() === transaction.data.toLowerCase() && actual.value === BigInt(transaction.value);
+      if (!sameCall)
+        throw new OwneyError(
+          "WITHDRAW_FAILED",
+          "The transaction was replaced without executing this withdrawal.",
+          {
+            originalTransactionHash: hash,
+            replacementTransactionHash: actualHash,
+            reason: "TRANSACTION_REPLACED_WITH_DIFFERENT_CALL",
+            ownerTransferNotExecuted: true
+          },
+          this.id
+        );
+      onSubmitted?.(actualHash);
+    }
     if (receipt.status !== "success") {
       throw new OwneyError(
         "AGENT_TRANSACTION_REVERTED",
-        `Yieldseeker transaction reverted (${hash}).`,
-        { transactionHash: hash },
+        `Yieldseeker transaction reverted (${actualHash}).`,
+        { transactionHash: actualHash },
         this.id
       );
     }
     onReceipt?.(receipt);
-    return hash;
+    return actualHash;
   }
   async waitForReceipt(state, chainId, transactionHash) {
     if (this.unwindReceiptWaiter) {
@@ -5701,12 +6741,12 @@ var YieldseekerAgent = class {
     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 || getAddress4(transaction.from) !== getAddress4(state.walletAddress)) {
+    if (!transaction || typeof transaction.from !== "string" || !isAddress3(transaction.from) || typeof transaction.to !== "string" || !isAddress3(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 || getAddress4(transaction.from) !== getAddress4(state.walletAddress)) {
       throw this.invalidResponse("transaction");
     }
   }
   assertAgent(agent) {
-    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !isAddress2(agent.assetAddress) || agent.chainId !== 8453) {
+    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !isAddress3(agent.assetAddress) || agent.chainId !== 8453) {
       throw this.invalidResponse("agent");
     }
   }
@@ -6047,6 +7087,7 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 
 // src/client.ts
 import {
+  parseUnits as parseUnits2,
   createPublicClient as createPublicClient4,
   createWalletClient as createWalletClient4,
   custom as custom4
@@ -6154,6 +7195,18 @@ var planOf = (transfers) => JSON.stringify(
     amount: BigInt(t.amount).toString()
   }))
 );
+var pendingKey = (i) => `owney.token-batch.v1:${keccak256(toBytes(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
+function pendingTokenBatch(i) {
+  try {
+    const saved = read(pendingKey(i));
+    if (!saved) return;
+    const body = JSON.parse(saved);
+    if (!body.serializedTransaction || body.chainId !== i.chainId || !isAddressEqual2(body.from, i.owner) || !isAddressEqual2(body.token, i.token) || !body.transfers?.length) return;
+    return { txHash: keccak256(body.serializedTransaction), transfers: body.transfers.map(({ to, amount }) => ({ to, amount })) };
+  } catch {
+    return;
+  }
+}
 function read(key2) {
   return typeof window === "undefined" ? memory.get(key2) : window.localStorage.getItem(key2);
 }
@@ -6170,11 +7223,11 @@ function clear(key2) {
   else window.localStorage.removeItem(key2);
 }
 function sponsorTokenBatch(i) {
-  const key2 = `owney.token-batch.v1:${keccak256(toBytes(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
+  const key2 = pendingKey(i);
   const plan = planOf(i.transfers);
   const active = inflight.get(key2);
   if (active) {
-    if (active.plan !== plan)
+    if (active.plan !== plan || i.resumeTxHash && pendingTokenBatch(i)?.txHash !== i.resumeTxHash)
       return Promise.reject(
         new Error(
           "A token deposit is already in progress. Wait for its result before depositing again."
@@ -6249,6 +7302,8 @@ async function execute(i, key2, plan) {
     }
   };
   const saved = read(key2);
+  if (i.resumeTxHash && pendingTokenBatch(i)?.txHash !== i.resumeTxHash)
+    throw new OwneyError("DEPOSIT_IN_PROGRESS", "The saved deposit changed. Check its status before depositing again.");
   if (saved) {
     const previous = JSON.parse(saved);
     if (previous.chainId !== i.chainId || !isAddressEqual2(previous.from, i.owner) || !isAddressEqual2(previous.token, i.token) || planOf(previous.transfers) !== plan)
@@ -6360,7 +7415,8 @@ function makeSponsoredTokenCallback(deps) {
       pub,
       wallet,
       onApproved: deps.onApproved,
-      onSubmitted: (hash) => deps.onSubmitted?.(hash, transfers)
+      onSubmitted: (hash) => deps.onSubmitted?.(hash, transfers),
+      resumeTxHash: deps.resumeTxHash
     });
   };
   const callback = makeVerificationAwareDepositCallback(
@@ -6446,7 +7502,7 @@ async function runAgentDepositBatch(chainId, legs, transfer) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi3, toHex as toHex2 } from "viem";
+import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi4, toHex as toHex2 } from "viem";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -6492,7 +7548,7 @@ function makeSponsoredCallsCallback(deps) {
       to: token,
       value: "0x0",
       data: encodeFunctionData2({
-        abi: erc20Abi3,
+        abi: erc20Abi4,
         functionName: "transfer",
         args: [transfer.to, BigInt(transfer.amount)]
       })
@@ -6524,50 +7580,73 @@ function makeSponsoredCallsCallback(deps) {
       url.searchParams.append("owneyIntent", intent);
       paymasterUrl = url.toString();
     }
-    const sendResult = await deps.provider.request({
-      method: "wallet_sendCalls",
-      params: [
-        {
-          version: "2.0.0",
-          from: deps.ownerAddress,
-          chainId: toHex2(chainId),
-          atomicRequired: transfers.length > 1,
-          calls,
-          capabilities: {
-            paymasterService: { url: paymasterUrl }
+    const requestedId = toHex2(globalThis.crypto.getRandomValues(new Uint8Array(32)));
+    const progress = (id, transfer) => {
+      try {
+        deps.onCallsProgress?.(id, transfers, transfer);
+      } catch {
+      }
+    };
+    progress(requestedId, "pending");
+    let sendResult;
+    try {
+      sendResult = await deps.provider.request({
+        method: "wallet_sendCalls",
+        params: [
+          {
+            version: "2.0.0",
+            id: requestedId,
+            from: deps.ownerAddress,
+            chainId: toHex2(chainId),
+            atomicRequired: transfers.length > 1,
+            calls,
+            capabilities: {
+              paymasterService: { url: paymasterUrl }
+            }
           }
-        }
-      ]
-    });
-    deps.onApproved?.();
+        ]
+      });
+    } catch (error) {
+      if (error?.code === 4001 || error?.code === "ACTION_REJECTED")
+        progress(requestedId, "failed");
+      throw error;
+    }
+    try {
+      deps.onApproved?.();
+    } catch {
+    }
     const callsId = typeof sendResult === "string" ? sendResult : sendResult?.id;
     if (!callsId) {
       throw new OwneyError(
         "SPONSORED_CALLS_NO_ID",
         "Wallet accepted wallet_sendCalls but returned no calls id.",
-        { chainId }
+        { chainId, callsId: requestedId }
       );
     }
+    progress(callsId, "pending");
     for (let attempt = 0; attempt < maxPolls; attempt += 1) {
       const status = await deps.provider.request({
         method: "wallet_getCallsStatus",
         params: [callsId]
       });
+      if (status?.id && status.id !== callsId || status?.chainId && Number(status.chainId) !== chainId)
+        throw new OwneyError("SPONSORED_CALLS_NO_RECEIPT", "Wallet returned status for a different deposit batch.", { chainId, callsId });
       const txHash = status?.receipts?.[0]?.transactionHash;
-      if (txHash && !status?.receipts?.some((receipt) => receipt.transactionHash !== txHash)) {
+      if (txHash && /^0x[\da-f]{64}$/i.test(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) {
+      if (status?.status === 400 || status?.status === 500) {
+        progress(callsId, "failed");
         throw new OwneyError(
           "SPONSOR_REQUEST_FAILED",
           "The sponsored deposit did not complete successfully.",
           { chainId, callsId, safeToFallback: false }
         );
       }
-      if (txHash && (transfers.length === 1 || status?.status === 200 || status?.status === "CONFIRMED")) {
+      if (txHash && /^0x[\da-f]{64}$/i.test(txHash) && (transfers.length === 1 || status?.status === 200 || status?.status === "CONFIRMED")) {
         if (status?.receipts?.some(
           (receipt) => receipt.transactionHash !== txHash
         ))
@@ -6783,8 +7862,8 @@ var OwneySDK = class {
     return createPaidRpcClient(VIEM_CHAIN2[chainId], this.rpcUrls);
   }
   /** Builds the default USDC batch callback for the connected wallet. */
-  getDefaultSponsoredCallback(onApproved, onSubmitted) {
-    if (!onApproved && !onSubmitted && this.cachedSponsoredCallback)
+  getDefaultSponsoredCallback(onApproved, onSubmitted, resumeTxHash) {
+    if (!onApproved && !onSubmitted && !resumeTxHash && this.cachedSponsoredCallback)
       return this.cachedSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
@@ -6794,6 +7873,7 @@ var OwneySDK = class {
       ownerAddress: owner,
       onApproved,
       onSubmitted,
+      resumeTxHash,
       tokenAddressByChain: SPONSORED_USDC_BY_CHAIN,
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
@@ -6809,13 +7889,13 @@ var OwneySDK = class {
         transport: custom4(provider)
       })
     });
-    if (!onApproved && !onSubmitted) this.cachedSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted && !resumeTxHash) this.cachedSponsoredCallback = callback;
     return callback;
   }
   /** Builds the wallet-native sponsored calls callback for compatible paymasters. */
-  getDefaultSponsoredCallsCallback(asset, onApproved, onSubmitted) {
+  getDefaultSponsoredCallsCallback(asset, onApproved, onSubmitted, onCallsProgress) {
     const cached = this.cachedSponsoredCallsCallbacks.get(asset);
-    if (!onApproved && !onSubmitted && cached) return cached;
+    if (!onApproved && !onSubmitted && !onCallsProgress && cached) return cached;
     const provider = this.requireConnectedProvider();
     const callback = makeSponsoredCallsCallback({
       apiKey: this.apiKey,
@@ -6825,9 +7905,10 @@ var OwneySDK = class {
       paymasterServiceUrl: this.paymasterServiceUrl,
       onApproved,
       onSubmitted,
+      onCallsProgress,
       tokenAddressByChain: sponsoredTokensFor(asset)
     });
-    if (!onApproved && !onSubmitted) this.cachedSponsoredCallsCallbacks.set(asset, callback);
+    if (!onApproved && !onSubmitted && !onCallsProgress) this.cachedSponsoredCallsCallbacks.set(asset, callback);
     return callback;
   }
   /**
@@ -6836,8 +7917,8 @@ var OwneySDK = class {
    * Mirrors `getDefaultSponsoredCallback()` but signs a Permit2
    * single-use batch authorization instead of an EIP-3009 authorization.
    */
-  getDefaultWethSponsoredCallback(onApproved, onSubmitted) {
-    if (!onApproved && !onSubmitted && this.cachedWethSponsoredCallback)
+  getDefaultWethSponsoredCallback(onApproved, onSubmitted, resumeTxHash) {
+    if (!onApproved && !onSubmitted && !resumeTxHash && this.cachedWethSponsoredCallback)
       return this.cachedWethSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
@@ -6847,6 +7928,7 @@ var OwneySDK = class {
       ownerAddress: owner,
       onApproved,
       onSubmitted,
+      resumeTxHash,
       tokenAddressByChain: SPONSORED_WETH_BY_CHAIN,
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
@@ -6862,7 +7944,7 @@ var OwneySDK = class {
         transport: custom4(provider)
       })
     });
-    if (!onApproved && !onSubmitted) this.cachedWethSponsoredCallback = callback;
+    if (!onApproved && !onSubmitted && !resumeTxHash) this.cachedWethSponsoredCallback = callback;
     return callback;
   }
   getAgent(agentId) {
@@ -7171,6 +8253,7 @@ var OwneySDK = class {
   async deposit(options) {
     const { amount, asset, depositCallback, agentId, onApproved } = options;
     const prepared = /* @__PURE__ */ new Map();
+    const paidFallbackAgents = /* @__PURE__ */ new Set();
     const onProgress = options.onProgress ? (evidence) => {
       if (evidence.agentWallet) prepared.set(evidence.agentWallet.toLowerCase(), evidence);
       notifyFunding(options.onProgress, evidence);
@@ -7181,152 +8264,184 @@ var OwneySDK = class {
         if (evidence) notifyFunding(onProgress, { ...evidence, txHash: hash, transfer: "pending" });
       }
     } : void 0;
+    const onCallsProgress = onProgress ? (callsId, destinations, transfer) => {
+      for (const destination of destinations) {
+        const evidence = prepared.get(destination.to.toLowerCase());
+        if (evidence) notifyFunding(onProgress, { ...evidence, callsId, transfer });
+      }
+    } : 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, onSubmitted) : asset === "WETH" ? this.getDefaultWethSponsoredCallback(onApproved, onSubmitted) : this.getDefaultSponsoredCallback(onApproved, onSubmitted));
-    if (agentId) {
-      if (this.isAgentDisabled(agentId)) {
-        throw new OwneyError(
-          "AGENT_DISABLED",
-          `Cannot deposit into disabled agent "${agentId}". Existing balances remain visible and withdrawable.`,
-          { agentId }
-        );
-      }
-      const agent = this.getAgent(agentId);
-      this.validateAssetSupport(agent, chainId, asset);
-      await this.validateMinDepositAmount(agent, state, chainId, asset, amount);
-      return this.depositWithFallback(
-        agent,
-        state,
-        chainId,
-        amount,
-        asset,
-        effectiveCallback,
-        depositCallback,
-        onProgress
-      );
-    }
-    const totalAmount = BigInt(amount);
-    const eligibleAgents = this.getEligibleAgents(chainId, asset, {
-      excludeDisabled: true
-    });
-    const exemptFlags = await Promise.all(
-      eligibleAgents.map(
-        (a) => this.hasExistingBalance(a, state, chainId, asset, true)
-      )
-    );
-    const exempt = new Set(
-      eligibleAgents.filter((_, i) => exemptFlags[i]).map((a) => a.id)
-    );
-    const agentAmounts = this.splitDepositAmount(
-      totalAmount,
-      eligibleAgents,
-      chainId,
-      asset,
-      exempt
-    );
-    if (agentAmounts.length === 0) {
-      const agentsRequiringActivation = eligibleAgents.filter(
-        (agent) => !exempt.has(agent.id)
-      );
-      const perAgentMinimum = agentsRequiringActivation.reduce(
-        (highest, agent) => {
-          const minimum = this.getMinDepositAmount(agent, chainId, asset);
-          return minimum > highest ? minimum : highest;
-        },
-        0n
-      );
-      const minimumRequired = agentsRequiringActivation.length > 0 ? (perAgentMinimum > 0n ? perAgentMinimum : 1n) * BigInt(agentsRequiringActivation.length) : BigInt(eligibleAgents.length);
-      throw new OwneyError(
-        "DEPOSIT_AMOUNT_BELOW_MINIMUM",
-        `Amount "${amount}" cannot activate every eligible agent. The combined minimum is "${minimumRequired.toString()}" for ${asset}.`,
-        {
-          amount,
-          asset,
-          chainId,
-          minDepositAmount: minimumRequired.toString(),
-          perAgentDepositAmount: perAgentMinimum.toString(),
-          agentMinimums: agentsRequiringActivation.map((agent) => ({
-            agentId: agent.id,
-            minDepositAmount: this.getMinDepositAmount(
-              agent,
-              chainId,
-              asset
-            ).toString()
-          }))
-        }
-      );
-    }
-    const batchTransfer = getDepositBatchTransfer(effectiveCallback);
-    if (!depositCallback && batchTransfer) {
-      return runAgentDepositBatch(
-        chainId,
-        agentAmounts.map(({ agent, amount: amount2 }) => ({
-          id: agent.id,
-          amount: amount2,
-          run: (callback) => withFailureReporting(
-            this.apiKey,
-            agent.id,
-            () => onProgress ? agent.deposit(state, chainId, amount2, asset, callback, onProgress) : agent.deposit(state, chainId, amount2, asset, callback),
-            this.routingApiBaseUrl
-          )
-        })),
-        async (cid, transfers) => {
-          try {
-            return await batchTransfer(cid, transfers);
-          } catch (error) {
-            if (!(error instanceof OwneyError) || error.code !== "PERMIT2_APPROVAL_REQUIRED")
-              throw error;
-            const requiredAmount = transfers.reduce(
-              (sum, transfer) => sum + BigInt(transfer.amount),
-              0n
-            );
-            await this.approvePermit2(
-              asset,
-              requiredAmount,
-              cid
-            );
-            return batchTransfer(cid, transfers);
-          }
+    if (options.resumeTxHash && (depositCallback || this.paymasterServiceUrl || !/^0x[\da-f]{64}$/i.test(options.resumeTxHash)))
+      throw new OwneyError("DEPOSIT_IN_PROGRESS", "This deposit cannot resume the saved relayer transaction.");
+    const effectiveCallback = depositCallback ?? (this.paymasterServiceUrl ? this.getDefaultSponsoredCallsCallback(asset, onApproved, onSubmitted, onCallsProgress) : asset === "WETH" ? this.getDefaultWethSponsoredCallback(onApproved, onSubmitted, options.resumeTxHash) : this.getDefaultSponsoredCallback(onApproved, onSubmitted, options.resumeTxHash));
+    try {
+      if (agentId) {
+        if (this.isAgentDisabled(agentId)) {
+          throw new OwneyError(
+            "AGENT_DISABLED",
+            `Cannot deposit into disabled agent "${agentId}". Existing balances remain visible and withdrawable.`,
+            { agentId }
+          );
         }
-      );
-    }
-    const agentResults = {};
-    for (const [
-      index,
-      { agent, amount: agentAmount }
-    ] of agentAmounts.entries()) {
-      try {
-        agentResults[agent.id] = await this.depositWithFallback(
+        const agent = this.getAgent(agentId);
+        this.validateAssetSupport(agent, chainId, asset);
+        await this.validateMinDepositAmount(agent, state, chainId, asset, amount);
+        return await this.depositWithFallback(
           agent,
           state,
           chainId,
-          agentAmount,
+          amount,
           asset,
           effectiveCallback,
           depositCallback,
-          onProgress
+          onProgress,
+          () => paidFallbackAgents.add(agent.id),
+          !!options.resumeTxHash
         );
-      } catch (error) {
-        if (Object.keys(agentResults).length === 0) throw error;
+      }
+      const totalAmount = BigInt(amount);
+      const eligibleAgents = this.getEligibleAgents(chainId, asset, {
+        excludeDisabled: true
+      });
+      const prospectiveShare = totalAmount / BigInt(eligibleAgents.length);
+      const meetsEveryMinimum = eligibleAgents.every((agent) => prospectiveShare >= this.getMinDepositAmount(agent, chainId, asset));
+      const exemptFlags = meetsEveryMinimum ? eligibleAgents.map(() => false) : await Promise.all(eligibleAgents.map((agent) => this.hasExistingBalance(agent, state, chainId, asset, true)));
+      const exempt = new Set(
+        eligibleAgents.filter((_, i) => exemptFlags[i]).map((a) => a.id)
+      );
+      const agentAmounts = this.splitDepositAmount(
+        totalAmount,
+        eligibleAgents,
+        chainId,
+        asset,
+        exempt
+      );
+      if (agentAmounts.length === 0) {
+        const agentsRequiringActivation = eligibleAgents.filter(
+          (agent) => !exempt.has(agent.id)
+        );
+        const perAgentMinimum = agentsRequiringActivation.reduce(
+          (highest, agent) => {
+            const minimum = this.getMinDepositAmount(agent, chainId, asset);
+            return minimum > highest ? minimum : highest;
+          },
+          0n
+        );
+        const minimumRequired = agentsRequiringActivation.length > 0 ? (perAgentMinimum > 0n ? perAgentMinimum : 1n) * BigInt(agentsRequiringActivation.length) : BigInt(eligibleAgents.length);
         throw new OwneyError(
-          "DEPOSIT_PARTIAL_FAILURE",
-          "Some deposits completed before another agent failed. Check activity and balances before depositing again; the failed transfer may still settle.",
+          "DEPOSIT_AMOUNT_BELOW_MINIMUM",
+          `Amount "${amount}" cannot activate every eligible agent. The combined minimum is "${minimumRequired.toString()}" for ${asset}.`,
           {
-            agentResults,
-            failedAgentId: agent.id,
-            failedAmount: agentAmount,
-            unattemptedAgentIds: agentAmounts.slice(index + 1).map(({ agent: agent2 }) => agent2.id),
-            cause: error
-          },
-          agent.id
+            amount,
+            asset,
+            chainId,
+            minDepositAmount: minimumRequired.toString(),
+            perAgentDepositAmount: perAgentMinimum.toString(),
+            agentMinimums: agentsRequiringActivation.map((agent) => ({
+              agentId: agent.id,
+              minDepositAmount: this.getMinDepositAmount(
+                agent,
+                chainId,
+                asset
+              ).toString()
+            }))
+          }
         );
       }
+      const batchTransfer = getDepositBatchTransfer(effectiveCallback);
+      if (!depositCallback && batchTransfer) {
+        return await runAgentDepositBatch(
+          chainId,
+          agentAmounts.map(({ agent, amount: amount2 }) => ({
+            id: agent.id,
+            amount: amount2,
+            run: (callback) => withFailureReporting(
+              this.apiKey,
+              agent.id,
+              () => onProgress ? agent.deposit(state, chainId, amount2, asset, callback, onProgress) : agent.deposit(state, chainId, amount2, asset, callback),
+              this.routingApiBaseUrl
+            )
+          })),
+          async (cid, transfers) => {
+            try {
+              return await batchTransfer(cid, transfers);
+            } catch (error) {
+              if (!(error instanceof OwneyError) || error.code !== "PERMIT2_APPROVAL_REQUIRED")
+                throw error;
+              const requiredAmount = transfers.reduce(
+                (sum, transfer) => sum + BigInt(transfer.amount),
+                0n
+              );
+              await this.approvePermit2(
+                asset,
+                requiredAmount,
+                cid
+              );
+              return batchTransfer(cid, transfers);
+            }
+          }
+        );
+      }
+      const agentResults = {};
+      for (const [
+        index,
+        { agent, amount: agentAmount }
+      ] of agentAmounts.entries()) {
+        try {
+          agentResults[agent.id] = await this.depositWithFallback(
+            agent,
+            state,
+            chainId,
+            agentAmount,
+            asset,
+            effectiveCallback,
+            depositCallback,
+            onProgress,
+            () => paidFallbackAgents.add(agent.id),
+            !!options.resumeTxHash
+          );
+        } catch (error) {
+          if (Object.keys(agentResults).length === 0) throw error;
+          throw new OwneyError(
+            "DEPOSIT_PARTIAL_FAILURE",
+            "Some deposits completed before another agent failed. Check activity and balances before depositing again; the failed transfer may still settle.",
+            {
+              agentResults,
+              failedAgentId: agent.id,
+              failedAmount: agentAmount,
+              unattemptedAgentIds: agentAmounts.slice(index + 1).map(({ agent: agent2 }) => agent2.id),
+              cause: error
+            },
+            agent.id
+          );
+        }
+      }
+      return { agentResults };
+    } catch (error) {
+      if (!depositCallback && onProgress && !options.resumeTxHash) {
+        const ids = agentId ? [agentId] : this.getEligibleAgents(chainId, asset).map((agent) => agent.id);
+        for (const id of ids) {
+          const evidence = [...prepared.values()].find((value) => value.agentId === id);
+          if (paidFallbackAgents.has(id) || evidence?.transfer === "confirmed" || evidence?.transfer === "failed") continue;
+          const rejected = error instanceof OwneyError && error.details?.notSubmitted === true;
+          if (!rejected && (evidence?.txHash || evidence?.userOpHash || evidence?.callsId)) continue;
+          notifyFunding(onProgress, { ...evidence ?? {
+            agentId: id,
+            chainId,
+            token: asset,
+            walletAddress: state.walletAddress,
+            intendedAmount: amount,
+            registration: "unknown",
+            delivery: "not-applicable"
+          }, transfer: "failed" });
+        }
+      }
+      throw error;
     }
-    return { agentResults };
   }
   /**
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
@@ -7355,7 +8470,7 @@ 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, onProgress) {
+  async depositWithFallback(agent, state, chainId, amount, asset, effectiveCallback, appCallback, onProgress, onPaidFallback, resumeOnly = false) {
     const attempt = (callback) => withFailureReporting(
       this.apiKey,
       agent.id,
@@ -7367,6 +8482,7 @@ var OwneySDK = class {
       try {
         return await attempt(effectiveCallback);
       } catch (error) {
+        if (resumeOnly) throw error;
         if (!approvalAttempted && appCallback === void 0 && (asset === "WETH" || asset === "USDC") && error instanceof OwneyError && error.code === "PERMIT2_APPROVAL_REQUIRED") {
           approvalAttempted = true;
           console.warn(
@@ -7384,6 +8500,7 @@ var OwneySDK = class {
           `[owney-sdk] ${asset} sponsorship unavailable, falling back to user-paid deposit:`,
           error
         );
+        onPaidFallback?.();
         return attempt(void 0);
       }
     }
@@ -7466,7 +8583,12 @@ var OwneySDK = class {
    */
   async hasExistingBalance(agent, state, chainId, asset, requireReliableRead = false) {
     try {
-      const balance = await agent.getBalances(state, chainId);
+      if (agent.hasExistingDepositFunds && await agent.hasExistingDepositFunds(
+        state,
+        chainId,
+        asset
+      ).catch(() => void 0) === true) return true;
+      const balance = await agent.getBalances(state, chainId, asset);
       const target = asset.toLowerCase();
       const token = balance.tokens.find(
         (t) => t.chainId === chainId && t.asset.toLowerCase() === target
@@ -7592,7 +8714,8 @@ var OwneySDK = class {
     return verified;
   }
   /** Resolve a saved sponsored-withdrawal ID without opening a wallet prompt. */
-  async resolveSponsoredWithdrawalEvidence(evidence) {
+  async resolveSponsoredWithdrawalEvidence(evidence, options = {}) {
+    if (evidence.callsId && !evidence.userOpHash) return this.resolveWalletCallsFundingEvidence(evidence, "withdraw");
     const { state, chainId, assertCurrent } = this.captureReadScope(evidence.chainId);
     if (evidence.agentId !== "yieldseeker" || chainId !== 8453 || evidence.txHash || state.walletAddress.toLowerCase() !== evidence.walletAddress.toLowerCase()) return evidence;
     const agent = this.getAgent("yieldseeker");
@@ -7608,18 +8731,26 @@ var OwneySDK = class {
           owner: state.walletAddress,
           agentWallet: wallet,
           asset: SupportedAssets.find((t) => t.chainId === chainId && t.symbol === evidence.token)?.address,
-          userOpHash: evidence.userOpHash
+          userOpHash: evidence.userOpHash,
+          ...evidence.userOperation ? { userOperation: Object.fromEntries([
+            "sender",
+            "nonce",
+            "initCode",
+            "callData",
+            "callGasLimit",
+            "verificationGasLimit",
+            "preVerificationGas",
+            "maxFeePerGas",
+            "maxPriorityFeePerGas",
+            "paymasterAndData"
+          ].map((key2) => [key2, evidence.userOperation[key2]])) } : {},
+          ...Number.isFinite(options.submittedAt) && options.submittedAt > 0 ? { submittedAt: options.submittedAt } : {}
         })
       });
       if (!response.ok) throw new OwneyError("AGENT_API_ERROR", "Could not resolve sponsored withdrawal status.");
       const payload = await response.json();
       txHash = payload.data?.txHash ?? void 0;
       executionFailed = payload.data?.executionFailed === true;
-    } else if (evidence.callsId) {
-      const status = await state.provider.request({ method: "wallet_getCallsStatus", params: [evidence.callsId] });
-      if (status?.id && status.id !== evidence.callsId || status?.chainId && Number(status.chainId) !== chainId) return evidence;
-      executionFailed = status?.status === 400 || status?.status === 500;
-      txHash = status?.receipts?.[0]?.transactionHash;
     }
     assertCurrent();
     if (executionFailed) return {
@@ -7630,6 +8761,60 @@ var OwneySDK = class {
     };
     return txHash && /^0x[0-9a-fA-F]{64}$/.test(txHash) ? { ...evidence, txHash } : evidence;
   }
+  /** Recover an EIP-5792 deposit or payout using this account's exact batch ID. */
+  async resolveWalletCallsFundingEvidence(evidence, direction) {
+    const { state, chainId, assertCurrent } = this.captureReadScope(evidence.chainId);
+    if (!evidence.callsId || evidence.txHash || state.walletAddress.toLowerCase() !== evidence.walletAddress.toLowerCase()) return evidence;
+    const agent = this.getAgent(evidence.agentId);
+    const wallet = agent.getFundingWallet ? await agent.getFundingWallet(state, chainId, evidence.token) : (await agent.getUserProfile(state, chainId)).smartWallet;
+    if (!wallet || wallet.toLowerCase() !== evidence.agentWallet?.toLowerCase()) return evidence;
+    const status = await state.provider.request({ method: "wallet_getCallsStatus", params: [evidence.callsId] });
+    assertCurrent();
+    if (status?.id !== void 0 && status.id !== evidence.callsId || status?.chainId !== void 0 && Number(status.chainId) !== chainId) return evidence;
+    const statusCode2 = Number(status?.status);
+    if (statusCode2 === 400 || statusCode2 === 500) return {
+      ...evidence,
+      transfer: "failed",
+      delivery: direction === "withdraw" ? "failed" : "not-applicable"
+    };
+    const hashes = [...new Set((status?.receipts ?? []).map((receipt) => receipt.transactionHash?.toLowerCase()).filter((hash) => !!hash && /^0x[\da-f]{64}$/i.test(hash)))];
+    if (hashes.length === 1) return { ...evidence, txHash: hashes[0] };
+    if (hashes.length > 16) return evidence;
+    const matches = [];
+    for (const txHash of hashes) {
+      const inspected = await this.inspectFunding({ ...evidence, txHash }, direction);
+      assertCurrent();
+      if (inspected.transfer === "confirmed") matches.push(inspected);
+    }
+    return matches.length === 1 ? matches[0] : evidence;
+  }
+  /** Whether a foreground deposit can resume the same signed batch, never a
+   * fresh authorization. The batch rail independently rechecks the exact plan. */
+  async canResumePendingDeposit(evidences, amount) {
+    if (this.paymasterServiceUrl || !evidences.length || !/^\d+$/.test(amount)) return false;
+    const first = evidences[0];
+    const { state, chainId, assertCurrent } = this.captureReadScope(first.chainId);
+    const token = SupportedAssets.find((value) => value.chainId === chainId && value.symbol === first.token);
+    if (!token) return false;
+    const pending = pendingTokenBatch({
+      apiKey: this.apiKey,
+      baseUrl: this.routingApiBaseUrl,
+      owner: state.walletAddress,
+      chainId,
+      token: token.address
+    });
+    if (!pending || pending.transfers.length !== evidences.length || pending.transfers.reduce((sum, transfer) => sum + BigInt(transfer.amount), 0n).toString() !== amount) return false;
+    const destinations = /* @__PURE__ */ new Set();
+    for (const evidence of evidences) {
+      if (evidence.chainId !== chainId || evidence.token !== first.token || evidence.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || evidence.callsId || evidence.userOpHash || evidence.txHash?.toLowerCase() !== pending.txHash.toLowerCase()) return false;
+      const agent = this.getAgent(evidence.agentId);
+      const wallet = agent.getFundingWallet ? await agent.getFundingWallet(state, chainId, evidence.token) : (await agent.getUserProfile(state, chainId)).smartWallet;
+      if (!wallet || destinations.has(wallet.toLowerCase()) || !pending.transfers.some((transfer) => transfer.to.toLowerCase() === wallet.toLowerCase() && transfer.amount === evidence.intendedAmount)) return false;
+      destinations.add(wallet.toLowerCase());
+    }
+    assertCurrent();
+    return true;
+  }
   /** A display acknowledgement controls polling only; it never confirms a financial outcome. */
   endFundingBalanceRefresh(evidence, read2) {
     const { state, chainId } = this.captureReadScope(evidence.chainId);
@@ -7730,6 +8915,30 @@ var OwneySDK = class {
       }
     };
     const token = asset;
+    const agentFailures = {};
+    const recordAgentFailure = (id, error) => {
+      if (!(error instanceof OwneyError)) return;
+      const details = error.details ?? {};
+      const codeValue = (value) => typeof value === "string" && /^[A-Z][A-Z0-9_]{0,79}$/.test(value) ? value : void 0;
+      const revertNames = ["InsufficientBalance", "InvalidAsset", "Unauthorized", "Error", "Panic", "FailedOp", "FailedOpWithRevert"];
+      const panicCodes = [0, 1, 17, 18, 33, 34, 49, 50, 65, 81];
+      agentFailures[id] = {
+        code: error.code,
+        phase: ["prepare", "send", "observe"].includes(String(details.phase)) ? details.phase : void 0,
+        failureCode: codeValue(details.failureCode),
+        reason: codeValue(details.reason),
+        withdrawalPhase: details.withdrawalPhase === "unwind" ? "unwind" : void 0,
+        statusCode: typeof details.statusCode === "number" ? details.statusCode : void 0,
+        rpcCode: typeof details.rpcCode === "number" ? details.rpcCode : void 0,
+        rpcMethod: typeof details.rpcMethod === "string" && /^[A-Za-z_]{1,80}$/.test(details.rpcMethod) ? details.rpcMethod : void 0,
+        revertSelector: typeof details.revertSelector === "string" && /^0x[0-9a-f]{8}$/i.test(details.revertSelector) ? details.revertSelector : void 0,
+        revertName: typeof details.revertName === "string" && revertNames.includes(details.revertName) ? details.revertName : void 0,
+        aaCode: typeof details.aaCode === "string" && /^AA[0-9]{2}$/.test(details.aaCode) ? details.aaCode : void 0,
+        panicCode: typeof details.panicCode === "string" && /^0x[0-9a-f]{1,2}$/i.test(details.panicCode) && panicCodes.includes(Number.parseInt(details.panicCode.slice(2), 16)) ? details.panicCode : void 0,
+        safeToFallback: typeof details.safeToFallback === "boolean" ? details.safeToFallback : void 0,
+        executionFailed: typeof details.executionFailed === "boolean" ? details.executionFailed : void 0
+      };
+    };
     const submissionEvidence = /* @__PURE__ */ new Map();
     const submit = async (agent, requested2) => {
       attempted.add(agent.id);
@@ -7750,9 +8959,19 @@ var OwneySDK = class {
       };
       progress(evidence);
       try {
+        if (options.onBeforeSubmission)
+          return await agent.withdraw(
+            state,
+            chainId,
+            token,
+            requested2,
+            progress,
+            options.gasMode ?? "auto",
+            (next) => options.onBeforeSubmission({ ...evidence, ...next })
+          );
         return await (options.gasMode === void 0 ? agent.withdraw(state, chainId, token, requested2, progress) : agent.withdraw(state, chainId, token, requested2, progress, options.gasMode));
       } catch (error) {
-        if (!evidence.txHash && (this.isUserRejectedWithdrawal(error) || /insufficient (balance|funds)/i.test(error instanceof Error ? error.message : "")))
+        if (!evidence.txHash && !evidence.userOpHash && !evidence.callsId && (this.isUserRejectedWithdrawal(error) || /insufficient (balance|funds)/i.test(error instanceof Error ? error.message : "")))
           progress({ ...evidence, transfer: "failed", delivery: "failed" });
         throw error;
       }
@@ -7802,6 +9021,7 @@ var OwneySDK = class {
           }
           console.error(`withdraw failed for agent "${agent.id}":`, err);
           agentErrors2[agent.id] = err instanceof Error ? err.message : String(err);
+          recordAgentFailure(agent.id, err);
           const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
           void reportAgentFailure(
             this.apiKey,
@@ -7812,17 +9032,23 @@ var OwneySDK = class {
         }
       }
       if (Object.keys(results2).length === 0) {
+        if (Object.keys(agentErrors2).length === 0)
+          throw new OwneyError(
+            "WITHDRAW_INSUFFICIENT_BALANCE",
+            "No funds are currently available to withdraw for this asset.",
+            { asset, available: "0" }
+          );
         throw new OwneyError(
           "WITHDRAW_ALL_FAILED",
           `Failed to withdraw "${asset}" from all eligible agents.`,
-          { asset, agentErrors: agentErrors2 }
+          { asset, agentErrors: agentErrors2, agentFailures }
         );
       }
       if (Object.keys(agentErrors2).length > 0) {
         throw new OwneyError(
           "WITHDRAW_PARTIAL_FAILURE",
           "Some agents could not complete the withdrawal.",
-          { asset, partialResults: results2, agentErrors: agentErrors2, ...Object.keys(incompleteWithdrawals).length ? { incompleteWithdrawals } : {} }
+          { asset, partialResults: results2, agentErrors: agentErrors2, agentFailures, ...Object.keys(incompleteWithdrawals).length ? { incompleteWithdrawals } : {} }
         );
       }
       const amountsKnown = Object.values(results2).every(
@@ -7834,11 +9060,10 @@ var OwneySDK = class {
       };
     }
     const requested = BigInt(amount);
-    const aggregated = await this.getBalances(void 0, { chainId, asset: token });
+    const { balances: aggregated, failures: balanceFailures } = await this.readAggregatedBalances({ chainId, asset: token });
     const unavailableAgents = eligibleAgents.filter(
       (agent) => !(agent.id in aggregated.agentBalances)
     );
-    const unavailableAgentIds = unavailableAgents.map((agent) => agent.id);
     const balances = projectAgentBalancesForAsset(
       eligibleAgents,
       aggregated.agentBalances,
@@ -7846,6 +9071,44 @@ var OwneySDK = class {
       asset,
       assetInfo.decimals
     );
+    const indexedAvailable = balances.reduce((sum, entry) => sum + entry.balance, 0n);
+    await Promise.all(balances.map(async (entry) => {
+      if (entry.balance !== 0n && indexedAvailable >= requested || !entry.agent.getWithdrawableBalance) return;
+      const originalFailure = balanceFailures.get(entry.agent.id);
+      if (originalFailure instanceof OwneyError && ![
+        "AGENT_API_ERROR",
+        "AGENT_TIMEOUT",
+        "AGENT_RATE_LIMITED"
+      ].includes(originalFailure.code)) return;
+      if (this.isUserRejectedWithdrawal(originalFailure)) throw originalFailure;
+      if (entry.balance !== 0n && entry.agent.id !== "yieldseeker") {
+        const total = aggregated.agentBalances[entry.agent.id]?.assetBalances?.find((value) => value.chainId === chainId && value.asset.toUpperCase() === token);
+        if (!total || parseUnits2(total.amount, assetInfo.decimals) <= entry.balance) return;
+      }
+      try {
+        const otherAvailable = indexedAvailable - entry.balance;
+        const minimumAmount = requested > otherAvailable ? requested - otherAvailable : void 0;
+        const verified = await entry.agent.getWithdrawableBalance(state, chainId, token, minimumAmount);
+        if (typeof verified !== "bigint" || verified < 0n)
+          throw new OwneyError("WITHDRAW_BALANCE_UNAVAILABLE", "Invalid withdrawal balance proof.", {}, entry.agent.id);
+        if (this.state !== state || this.state.walletAddress !== state.walletAddress || this.state.chainId !== chainId)
+          throw new OwneyError("NOT_CONNECTED", "Account changed while planning withdrawal.");
+        entry.balance = verified;
+        const unavailableIndex = unavailableAgents.indexOf(entry.agent);
+        if (unavailableIndex !== -1) unavailableAgents.splice(unavailableIndex, 1);
+        if (aggregated.agentErrors) delete aggregated.agentErrors[entry.agent.id];
+      } catch (error) {
+        entry.balance = 0n;
+        if (!unavailableAgents.includes(entry.agent)) unavailableAgents.push(entry.agent);
+        aggregated.agentErrors = {
+          ...aggregated.agentErrors,
+          [entry.agent.id]: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }));
+    if (this.state !== state || this.state.chainId !== chainId)
+      throw new OwneyError("NOT_CONNECTED", "Account changed while planning withdrawal.");
+    const unavailableAgentIds = unavailableAgents.map((agent) => agent.id);
     const totalAvailable = balances.reduce((sum, x) => sum + x.balance, 0n);
     if (totalAvailable === 0n && unavailableAgents.length > 0) {
       throw new OwneyError(
@@ -7903,6 +9166,7 @@ var OwneySDK = class {
         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);
+        recordAgentFailure(p.agent.id, err);
         const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
         void reportAgentFailure(
           this.apiKey,
@@ -7923,12 +9187,24 @@ var OwneySDK = class {
         {
           asset,
           amount,
-          agentErrors
+          agentErrors,
+          agentFailures
         }
       );
     }
     const withdrawn = sumWithdrawnAmount(results);
-    if (withdrawn < requested) {
+    const verifiedFeeDeductions = orderedPlans.reduce((total, plan) => {
+      const result = results[plan.agent.id];
+      const adjustment = result?.feeAdjustment;
+      const evidence = result?.evidence;
+      const submitted = submissionEvidence.get(plan.agent.id);
+      if (plan.agent.id !== "yieldseeker" || !adjustment || !evidence || !submitted || typeof result.amount !== "string" || !/^\d+$/.test(result.amount) || typeof adjustment.grossAmount !== "string" || !/^\d+$/.test(adjustment.grossAmount) || typeof adjustment.feeAmount !== "string" || !/^\d+$/.test(adjustment.feeAmount) || evidence.agentId !== plan.agent.id || evidence.chainId !== chainId || evidence.token !== token || typeof evidence.walletAddress !== "string" || evidence.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || typeof evidence.agentWallet !== "string" || !/^0x[\da-f]{40}$/i.test(evidence.agentWallet) || typeof result.txHash !== "string" || !/^0x[\da-f]{64}$/i.test(result.txHash) || typeof evidence.txHash !== "string" || typeof submitted.txHash !== "string" || evidence.txHash?.toLowerCase() !== result.txHash.toLowerCase() || submitted.txHash?.toLowerCase() !== result.txHash.toLowerCase() || submitted.agentId !== evidence.agentId || submitted.chainId !== chainId || submitted.token !== token || typeof submitted.walletAddress !== "string" || typeof submitted.agentWallet !== "string" || submitted.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || submitted.agentWallet?.toLowerCase() !== evidence.agentWallet.toLowerCase() || evidence.transfer !== "confirmed" || evidence.delivery !== "confirmed" || submitted.transfer !== "confirmed" || submitted.delivery !== "confirmed" || evidence.confirmedAmount !== result.amount || submitted.confirmedAmount !== result.amount || evidence.intendedAmount !== result.amount || submitted.intendedAmount !== result.amount) return total;
+      const fee = BigInt(adjustment.feeAmount);
+      const net = BigInt(result.amount);
+      const gross = BigInt(adjustment.grossAmount);
+      return fee > 0n && net > 0n && gross === plan.planned && net + fee === gross ? total + fee : total;
+    }, 0n);
+    if (withdrawn + verifiedFeeDeductions < requested) {
       throw new OwneyError(
         "WITHDRAW_PARTIAL_FAILURE",
         `Withdrew "${withdrawn.toString()}" of requested "${amount}" of "${asset}". One or more agents failed; remaining balance could not cover the shortfall.`,
@@ -7938,6 +9214,7 @@ var OwneySDK = class {
           withdrawn: withdrawn.toString(),
           partialResults: results,
           agentErrors,
+          agentFailures,
           ...unavailableAgentIds.length > 0 ? { unavailableAgents: unavailableAgentIds } : {}
         }
       );
@@ -7951,23 +9228,42 @@ var OwneySDK = class {
    * @returns {AgentBalance} for a single agent, or {OwneyBalances} with totalBalance and per-agent breakdown
    */
   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 { state, chainId, assertCurrent } = this.captureReadScope(options?.chainId);
+      const asset = options?.asset;
       const agent = this.getAgent(agentId);
-      const result = await readBalance(agent);
+      const result = await this.readAgent(
+        agent,
+        "balances",
+        () => asset ? agent.getBalances(state, chainId, asset) : agent.getBalances(state, chainId),
+        asset ? { asset } : null
+      );
       assertCurrent();
       return {
         ...result,
         balanceComposition: agent.balanceComposition ?? "tokens-include-positions"
       };
     }
+    const { balances, failures } = await this.readAggregatedBalances(options);
+    if (Object.keys(balances.agentBalances).length === 0) {
+      throw new OwneyError(
+        "BALANCE_ALL_FAILED",
+        "Failed to fetch balances for all active agents.",
+        { agentErrors: balances.agentErrors ?? {}, failures: [...failures.values()] }
+      );
+    }
+    return balances;
+  }
+  /** Preserve failure objects for withdrawal recovery without changing public balance results. */
+  async readAggregatedBalances(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
+    );
     let totalBalance = 0;
     const results = {};
     const entries = [...this.getActiveAgents().entries()];
@@ -7984,39 +9280,33 @@ var OwneySDK = class {
       })
     );
     assertCurrent();
-    let successCount = 0;
     const agentErrors = {};
     const agentRetryAt = {};
-    const agentFailures = [];
+    const agentFailures = /* @__PURE__ */ new Map();
     for (let i = 0; i < balanceResults.length; i++) {
       const settledResult = balanceResults[i];
-      const [agentId2] = entries[i];
+      const [agentId] = entries[i];
       if (settledResult.status === "fulfilled") {
         const [id, b] = settledResult.value;
         results[id] = b;
         totalBalance += Number(b.totalBalance);
-        successCount += 1;
         continue;
       }
       const reason = settledResult.reason;
-      agentFailures.push(reason);
+      agentFailures.set(agentId, reason);
       const retryDelay = rateLimitDelay(reason);
-      if (retryDelay !== void 0) agentRetryAt[agentId2] = Date.now() + retryDelay;
-      agentErrors[agentId2] = reason instanceof Error ? reason.message : String(reason);
-      console.error(`[owney-sdk] Balance fetch failed for agent "${agentId2}":`, reason);
-    }
-    if (successCount === 0) {
-      throw new OwneyError(
-        "BALANCE_ALL_FAILED",
-        "Failed to fetch balances for all active agents.",
-        { agentErrors, failures: agentFailures }
-      );
+      if (retryDelay !== void 0) agentRetryAt[agentId] = Date.now() + retryDelay;
+      agentErrors[agentId] = reason instanceof Error ? reason.message : String(reason);
+      console.error(`[owney-sdk] Balance fetch failed for agent "${agentId}":`, reason);
     }
     return {
-      totalBalance: String(totalBalance),
-      totalBalanceAsset: "usdc",
-      agentBalances: results,
-      ...Object.keys(agentErrors).length > 0 ? { agentErrors, agentRetryAt } : {}
+      balances: {
+        totalBalance: String(totalBalance),
+        totalBalanceAsset: "usdc",
+        agentBalances: results,
+        ...Object.keys(agentErrors).length > 0 ? { agentErrors, agentRetryAt } : {}
+      },
+      failures: agentFailures
     };
   }
   /**