@owney/sdk 0.7.27-beta.0 → 0.7.27-beta.2

package/dist/index.js

@@ -1,5 +1,213 @@
+// src/errors.ts
+var OwneyError = class extends Error {
+  code;
+  details;
+  agentId;
+  constructor(code, message, details, agentId) {
+    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
+    super(`${prefix} ${message}`);
+    this.name = "OwneyError";
+    this.code = code;
+    this.details = details;
+    this.agentId = agentId;
+  }
+};
+var AgentNotFoundError = class extends OwneyError {
+  constructor(agentId, available) {
+    super(
+      "AGENT_NOT_FOUND",
+      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+      { agentId, available },
+      agentId
+    );
+    this.name = "AgentNotFoundError";
+  }
+};
+var NotConnectedError = class extends OwneyError {
+  constructor() {
+    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
+  }
+};
+var AgentChainIncompatibleError = class extends OwneyError {
+  incompatibleAgents;
+  connectedChainId;
+  constructor(incompatibleAgents, connectedChainId) {
+    const details = incompatibleAgents.map(
+      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+    ).join("; ");
+    super(
+      "AGENT_CHAIN_INCOMPATIBLE",
+      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+      { incompatibleAgents, connectedChainId }
+    );
+    this.name = "AgentChainIncompatibleError";
+    this.incompatibleAgents = incompatibleAgents;
+    this.connectedChainId = connectedChainId;
+  }
+};
+
+// src/lib/swap/swap.observation.ts
+var active = /* @__PURE__ */ new Set();
+var isOrderObserved = (key2) => active.has(key2);
+async function observeOrder(key2, run) {
+  const busy = () => new OwneyError(
+    "SWAP_REQUEST_FAILED",
+    "This order is already being observed.",
+    { orderHash: key2, watchActive: true, settlementUnconfirmed: true }
+  );
+  if (active.has(key2)) throw busy();
+  active.add(key2);
+  try {
+    if (typeof navigator !== "undefined" && navigator.locks)
+      return await navigator.locks.request(`owney.swap.observe:${key2}`, { ifAvailable: true }, (lock) => {
+        if (!lock) throw busy();
+        return run();
+      });
+    return await run();
+  } finally {
+    active.delete(key2);
+  }
+}
+
+// src/lib/swap/swap.deadline.ts
+async function bounded(work, timeoutMs, error) {
+  if (timeoutMs <= 0) throw error();
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(work),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(error()), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function mapConcurrent(items, run, concurrency = 3) {
+  const results = new Array(items.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await run(items[index]);
+    }
+  }));
+  return results;
+}
+
+// src/lib/permit2-batch.ts
+import { parseAbi, hashStruct } from "viem";
+var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var ARBITRUM_USDC_ADDRESS = "0xaf88d065e77c8cc2239327c5edb3a432268e5831";
+function supportsSponsoredErc2612(chainId, token) {
+  const expected = chainId === 8453 ? BASE_USDC_ADDRESS : chainId === 42161 ? ARBITRUM_USDC_ADDRESS : void 0;
+  return expected !== void 0 && token.toLowerCase() === expected.toLowerCase();
+}
+var ERC2612_PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var ERC2612_READ_ABI = parseAbi([
+  "function name() view returns (string)",
+  "function version() view returns (string)",
+  "function nonces(address owner) view returns (uint256)"
+]);
+function erc2612TypedData(input) {
+  return {
+    domain: {
+      name: input.permit.tokenName,
+      version: input.permit.tokenVersion,
+      chainId: input.chainId,
+      verifyingContract: input.token
+    },
+    types: ERC2612_PERMIT_TYPES,
+    primaryType: "Permit",
+    message: {
+      owner: input.owner,
+      spender: BATCH_PERMIT2_ADDRESS,
+      value: BigInt(input.permit.value),
+      nonce: BigInt(input.permit.nonce),
+      deadline: BigInt(input.permit.deadline)
+    }
+  };
+}
+var PERMIT_BATCH_TYPES = {
+  PermitBatchWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions[]" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Deposit" }
+  ],
+  Deposit: [{ name: "recipients", type: "address[]" }],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+var PERMIT2_BATCH_ABI = parseAbi([
+  "struct TokenPermissions { address token; uint256 amount; }",
+  "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
+  "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
+  "function permitWitnessTransferFrom(PermitBatchTransferFrom permit,SignatureTransferDetails[] transferDetails,address owner,bytes32 witness,string witnessTypeString,bytes signature)",
+  "function nonceBitmap(address owner,uint256 wordPos) view returns (uint256)"
+]);
+function batchPermit(b) {
+  return {
+    permitted: b.transfers.map((t) => ({
+      token: b.token,
+      amount: BigInt(t.amount)
+    })),
+    nonce: BigInt(b.nonce),
+    deadline: BigInt(b.deadline)
+  };
+}
+function batchTypedData(b, spender) {
+  return {
+    domain: {
+      name: "Permit2",
+      chainId: b.chainId,
+      verifyingContract: BATCH_PERMIT2_ADDRESS
+    },
+    types: PERMIT_BATCH_TYPES,
+    primaryType: "PermitBatchWitnessTransferFrom",
+    message: {
+      ...batchPermit(b),
+      spender,
+      witness: { recipients: b.transfers.map((t) => t.to) }
+    }
+  };
+}
+var BATCH_WITNESS_TYPE = "Deposit witness)Deposit(address[] recipients)TokenPermissions(address token,uint256 amount)";
+function batchWitness(b) {
+  return hashStruct({
+    types: PERMIT_BATCH_TYPES,
+    primaryType: "Deposit",
+    data: { recipients: b.transfers.map((t) => t.to) }
+  });
+}
+function batchArgs(b) {
+  return [
+    batchPermit(b),
+    b.transfers.map((t) => ({ to: t.to, requestedAmount: BigInt(t.amount) })),
+    b.from,
+    batchWitness(b),
+    BATCH_WITNESS_TYPE,
+    b.signature
+  ];
+}
+
 // src/lib/funding-evidence.ts
-import { decodeEventLog, decodeFunctionData, erc20Abi, parseAbi } from "viem";
+import { decodeEventLog, decodeFunctionData, erc20Abi, parseAbi as parseAbi2 } from "viem";
 import { entryPoint06Abi, entryPoint07Abi, getUserOperationHash, toUserOperation } from "viem/account-abstraction";
 function notifyFunding(callback, evidence) {
   try {
@@ -8,9 +216,9 @@ function notifyFunding(callback, evidence) {
   } catch {
   }
 }
-var fullWithdrawalAbi = parseAbi(["function withdrawAllAssetToUser(address recipient, address asset)"]);
-var withdrawalEventAbi = parseAbi(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
-var accountExecutionAbi = parseAbi([
+var fullWithdrawalAbi = parseAbi2(["function withdrawAllAssetToUser(address recipient, address asset)"]);
+var withdrawalEventAbi = parseAbi2(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
+var accountExecutionAbi = parseAbi2([
   "function execute(address target,uint256 value,bytes data)",
   "function executeBatch((address target,uint256 value,bytes data)[] calls)"
 ]);
@@ -203,55 +411,6 @@ function registerDepositBatch(callback, transfer) {
   batchCallbacks.set(callback, transfer);
 }
 
-// src/errors.ts
-var OwneyError = class extends Error {
-  code;
-  details;
-  agentId;
-  constructor(code, message, details, agentId) {
-    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
-    super(`${prefix} ${message}`);
-    this.name = "OwneyError";
-    this.code = code;
-    this.details = details;
-    this.agentId = agentId;
-  }
-};
-var AgentNotFoundError = class extends OwneyError {
-  constructor(agentId, available) {
-    super(
-      "AGENT_NOT_FOUND",
-      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
-      { agentId, available },
-      agentId
-    );
-    this.name = "AgentNotFoundError";
-  }
-};
-var NotConnectedError = class extends OwneyError {
-  constructor() {
-    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
-    this.name = "NotConnectedError";
-  }
-};
-var AgentChainIncompatibleError = class extends OwneyError {
-  incompatibleAgents;
-  connectedChainId;
-  constructor(incompatibleAgents, connectedChainId) {
-    const details = incompatibleAgents.map(
-      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
-    ).join("; ");
-    super(
-      "AGENT_CHAIN_INCOMPATIBLE",
-      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
-      { incompatibleAgents, connectedChainId }
-    );
-    this.name = "AgentChainIncompatibleError";
-    this.incompatibleAgents = incompatibleAgents;
-    this.connectedChainId = connectedChainId;
-  }
-};
-
 // src/lib/transfer-auth.ts
 import { bytesToHex } from "viem";
 
@@ -518,21 +677,21 @@ function rateLimitDelay(error, now = Date.now()) {
     }
     if (typeof value !== "object" || seen.has(value)) return;
     seen.add(value);
-    const record = value;
-    if ([record.status, record.statusCode, record.code].some(
+    const record2 = value;
+    if ([record2.status, record2.statusCode, record2.code].some(
       (code) => String(code) === "429"
     )) {
       limited = true;
     }
     for (const key2 of ["retryAfterSeconds", "retryAfter"]) {
-      const seconds = Number(record[key2]);
+      const seconds = Number(record2[key2]);
       if (Number.isFinite(seconds) && seconds > 0)
         delay = Math.max(delay, seconds * 1e3);
     }
-    const retryAt = Number(record.retryAt);
+    const retryAt = Number(record2.retryAt);
     if (Number.isFinite(retryAt) && retryAt > now)
       delay = Math.max(delay, retryAt - now);
-    const headers = record.headers;
+    const headers = record2.headers;
     const header = typeof headers?.get === "function" ? headers.get("Retry-After") : headers?.["retry-after"] ?? headers?.["Retry-After"];
     if (typeof header === "string" || typeof header === "number") {
       const seconds = Number(header);
@@ -548,10 +707,10 @@ function rateLimitDelay(error, now = Date.now()) {
       "data",
       "fields"
     ]) {
-      visit(record[key2], depth + 1);
+      visit(record2[key2], depth + 1);
     }
     for (const key2 of ["agentErrors", "failures"]) {
-      const entries = record[key2];
+      const entries = record2[key2];
       if (entries && typeof entries === "object") {
         for (const entry of Object.values(entries)) visit(entry, depth + 1);
       }
@@ -569,7 +728,7 @@ function rateLimitDiagnostics(error) {
     if (depth > 6 || !value || typeof value !== "object" || seen.has(value))
       return;
     seen.add(value);
-    const record = value;
+    const record2 = value;
     for (const key2 of [
       "rpcSource",
       "chainId",
@@ -577,12 +736,12 @@ function rateLimitDiagnostics(error) {
       "providerRequestId",
       "statusCode"
     ]) {
-      const candidate = record[key2];
+      const candidate = record2[key2];
       if (candidate !== void 0 && details[key2] === void 0)
         details = { ...details, [key2]: candidate };
     }
     for (const key2 of ["details", "cause", "response", "fields", "error"])
-      visit(record[key2], depth + 1);
+      visit(record2[key2], depth + 1);
   }
   visit(error);
   return {
@@ -650,12 +809,19 @@ var AgentReads = class {
 };
 
 // src/agents/zyfai/zyfai.withdraw-submission.ts
+var BELOW_MINIMUM = /^Idle balance (\d+(?:\.\d+)?) (USDC|WETH|ETH|EURC) is below the minimum withdrawal of (\d+(?:\.\d+)?) \2\.?$/;
 var listenersByClient = /* @__PURE__ */ new WeakMap();
 function observeWithdrawalSubmission(sdk, chainId, token, assertCurrent) {
   const client = sdk.httpClient;
   if (!client || typeof client.get !== "function" || typeof client.post !== "function")
-    return { attempted: () => void 0, rejected: () => false, request: () => void 0, stop: () => {
-    } };
+    return {
+      attempted: () => void 0,
+      rejected: () => false,
+      request: () => void 0,
+      belowMinimum: () => void 0,
+      stop: () => {
+      }
+    };
   let listeners2 = listenersByClient.get(client);
   if (!listeners2) {
     listeners2 = /* @__PURE__ */ new Set();
@@ -675,6 +841,7 @@ function observeWithdrawalSubmission(sdk, chainId, token, assertCurrent) {
           method: method === "get" ? "GET" : "POST",
           path: method === "get" ? "/users/withdraw" : "/users/partial-withdraw"
         };
+        let belowMinimum2;
         const notify2 = (outcome) => {
           if (outcome === "rejected" && matching.length !== 1) return;
           const evidence = matching.length === 1 ? { ...request3 } : {
@@ -685,7 +852,7 @@ function observeWithdrawalSubmission(sdk, chainId, token, assertCurrent) {
           };
           for (const observer of matching) {
             try {
-              observer.notify(outcome, evidence);
+              observer.notify(outcome, evidence, outcome === "rejected" ? belowMinimum2 : void 0);
             } catch {
             }
           }
@@ -710,10 +877,12 @@ function observeWithdrawalSubmission(sdk, chainId, token, assertCurrent) {
           return await original.apply(this, callArgs);
         } catch (error) {
           const message = error instanceof Error ? error.message : "";
+          const minimum = BELOW_MINIMUM.exec(message);
+          if (minimum) belowMinimum2 = { symbol: minimum[2], idle: minimum[1], minimum: minimum[3] };
           const status = error?.response?.status;
           if (request3.httpStatus === void 0 && typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599)
             request3.httpStatus = status;
-          request3.failure = message === "Unauthorized: Invalid API key" ? "unauthorized" : message === "Forbidden: Access denied" ? "forbidden" : message === "Rate limit exceeded. Please try again later." ? "rate-limited" : request3.httpStatus === 400 && message === "No balance to withdraw" ? "insufficient-balance" : /^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" && request3.httpStatus === 400 && message === "Partial withdrawal already in progress" ? "withdrawal-in-progress" : message === "Network error: Unable to reach the server" ? "network" : "other";
+          request3.failure = message === "Unauthorized: Invalid API key" ? "unauthorized" : message === "Forbidden: Access denied" ? "forbidden" : message === "Rate limit exceeded. Please try again later." ? "rate-limited" : request3.httpStatus === 400 && message === "No balance to withdraw" ? "insufficient-balance" : minimum ? "insufficient-balance" : /^User doesn't have any active session key\.?$/.test(message) ? "session-key-missing" : method === "post" && request3.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(request3.failure) && (request3.httpStatus === void 0 || request3.httpStatus >= 400 && request3.httpStatus < 500)) notify2("rejected");
           throw error;
         } finally {
@@ -726,32 +895,45 @@ function observeWithdrawalSubmission(sdk, chainId, token, assertCurrent) {
   let submitted = false;
   let rejected = false;
   let request2 = { attempted: false };
-  const listener = { chainId, token, assertCurrent, notify: (outcome, evidence) => {
+  let belowMinimum;
+  const listener = { chainId, token, assertCurrent, notify: (outcome, evidence, detail) => {
     request2 = evidence;
     if (outcome === "attempted") submitted = true;
-    else if (outcome === "rejected") rejected = true;
+    else if (outcome === "rejected") {
+      rejected = true;
+      belowMinimum = detail;
+    }
   } };
   listeners2.add(listener);
-  return { attempted: () => submitted, rejected: () => rejected, request: () => ({ ...request2 }), stop: () => {
-    listeners2.delete(listener);
-  } };
+  return {
+    attempted: () => submitted,
+    rejected: () => rejected,
+    request: () => ({ ...request2 }),
+    belowMinimum: () => belowMinimum && { ...belowMinimum },
+    stop: () => {
+      listeners2.delete(listener);
+    }
+  };
 }
 
 // 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;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var symbol = (value) => typeof value === "string" ? value.toUpperCase() === "ETH" ? "WETH" : value.toUpperCase() : void 0;
+var 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()];
+};
+var zero = (value) => typeof value === "string" && /^(?:0x)?0+$/i.test(value);
+var units = (value) => typeof value === "string" && /^(?:0x[0-9a-f]+|\d+)$/i.test(value) ? BigInt(value) : void 0;
+function snapshotPortfolio(raw2) {
   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);
+  if (response?.success === false || !portfolio || !chains || !Array.isArray(portfolio.positions) || !Array.isArray(portfolio.staleBalances)) return void 0;
+  return { portfolio, chains, entries: [...portfolio.positions, ...portfolio.staleBalances] };
+}
+function chainBalancesMatch(chains, chainId, token, accept) {
   for (const [id, assets] of Object.entries(chains)) {
     const idNumber = chain(id);
     if (idNumber === void 0) return false;
@@ -761,10 +943,13 @@ function hasEmptyWithdrawalSnapshot(raw2, chainId, token) {
     for (const [asset, value] of Object.entries(entries)) {
       if (symbol(asset) !== token) continue;
       const balance = record(value);
-      if (!balance || !zero(balance.balance)) return false;
+      if (!balance || !accept(balance)) return false;
     }
   }
-  for (const value of [...portfolio.positions, ...portfolio.staleBalances]) {
+  return true;
+}
+function positionsEmpty(entries, chainId, token) {
+  for (const value of entries) {
     const entry = record(value);
     if (!entry) return false;
     const id = chain(entry.chainId ?? entry.chain);
@@ -776,6 +961,23 @@ function hasEmptyWithdrawalSnapshot(raw2, chainId, token) {
   }
   return true;
 }
+function hasEmptyWithdrawalSnapshot(raw2, chainId, token) {
+  const snapshot = snapshotPortfolio(raw2);
+  if (!snapshot) return false;
+  const pending = snapshot.portfolio.pendingAsyncWithdrawals;
+  if (pending !== void 0 && (!Array.isArray(pending) || pending.length > 0)) return false;
+  return chainBalancesMatch(snapshot.chains, chainId, token, (balance) => zero(balance.balance)) && positionsEmpty(snapshot.entries, chainId, token);
+}
+function hasIdleOnlyWithdrawalSnapshot(raw2, chainId, token, decimals, idle) {
+  const snapshot = snapshotPortfolio(raw2);
+  if (!snapshot) return false;
+  const pending = snapshot.portfolio.pendingAsyncWithdrawals;
+  if (pending !== void 0 && (!Array.isArray(pending) || pending.some((value) => record(value)?.status !== "CLAIMED"))) return false;
+  return chainBalancesMatch(snapshot.chains, chainId, token, (balance) => {
+    const amount = units(balance.balance);
+    return amount !== void 0 && amount <= idle && (balance.decimals === void 0 || balance.decimals === decimals);
+  }) && positionsEmpty(snapshot.entries, chainId, token);
+}
 
 // src/agents/zyfai/zyfai.deposit.ts
 import { createWalletClient, custom, encodeFunctionData, erc20Abi as erc20Abi2, isAddress } from "viem";
@@ -828,20 +1030,20 @@ var SupportedAssets = [
 ];
 
 // src/agents/zyfai/zyfai.deposit.ts
-async function submitZyfaiDeposit({ sdk, state, chain, amount, asset, smartWallet, assertCurrent, onBeforeSubmission }) {
+async function submitZyfaiDeposit({ sdk, state, chain: chain2, amount, asset, smartWallet, assertCurrent, onBeforeSubmission }) {
   const owner = state.walletAddress;
   const provider = state.provider;
-  const token = SupportedAssets.find((value) => value.chainId === chain.id && value.symbol === asset);
+  const token = SupportedAssets.find((value) => value.chainId === chain2.id && value.symbol === asset);
   if (!token || !isAddress(owner) || !isAddress(smartWallet) || !/^\d+$/.test(amount) || BigInt(amount) <= 0n)
-    throw new OwneyError("AGENT_INVALID_RESPONSE", "Invalid Zyfai deposit transfer.", { chainId: chain.id, asset }, "zyfai");
+    throw new OwneyError("AGENT_INVALID_RESPONSE", "Invalid Zyfai deposit transfer.", { chainId: chain2.id, asset }, "zyfai");
   assertCurrent();
-  const prepared = await sdk.prepareEnterPosition({ userAddress: owner, chainId: chain.id, amount, asset, strategy: "aggressive" });
+  const prepared = await sdk.prepareEnterPosition({ userAddress: owner, chainId: chain2.id, amount, asset, strategy: "aggressive" });
   assertCurrent();
   const expectedData = encodeFunctionData({ abi: erc20Abi2, functionName: "transfer", args: [smartWallet, BigInt(amount)] });
   const transfer = prepared?.transfer;
   if (!transfer || transfer.safeAddress?.toLowerCase() !== smartWallet.toLowerCase() || transfer.tokenAddress?.toLowerCase() !== token.address.toLowerCase() || transfer.to?.toLowerCase() !== token.address.toLowerCase() || transfer.data?.toLowerCase() !== expectedData.toLowerCase() || transfer.value !== "0")
-    throw new OwneyError("AGENT_INVALID_RESPONSE", "Zyfai prepared a different deposit transfer.", { chainId: chain.id, asset }, "zyfai");
-  const wallet = createWalletClient({ account: owner, chain, transport: custom({
+    throw new OwneyError("AGENT_INVALID_RESPONSE", "Zyfai prepared a different deposit transfer.", { chainId: chain2.id, asset }, "zyfai");
+  const wallet = createWalletClient({ account: owner, chain: chain2, transport: custom({
     request: async (args) => {
       assertCurrent();
       if (args.method === "eth_sendTransaction") {
@@ -850,7 +1052,7 @@ async function submitZyfaiDeposit({ sdk, state, chain, amount, asset, smartWalle
           provider.request({ method: "eth_chainId" })
         ]);
         assertCurrent();
-        if (!Array.isArray(accounts) || typeof accounts[0] !== "string" || accounts[0].toLowerCase() !== owner.toLowerCase() || Number(chainId) !== chain.id)
+        if (!Array.isArray(accounts) || typeof accounts[0] !== "string" || accounts[0].toLowerCase() !== owner.toLowerCase() || Number(chainId) !== chain2.id)
           throw new OwneyError("NOT_CONNECTED", "Wallet changed while preparing Zyfai deposit.", void 0, "zyfai");
         await onBeforeSubmission?.();
         assertCurrent();
@@ -858,12 +1060,12 @@ async function submitZyfaiDeposit({ sdk, state, chain, amount, asset, smartWalle
       return provider.request(args);
     }
   }, { retryCount: 0 }) });
-  return wallet.sendTransaction({ account: owner, chain, to: token.address, data: expectedData, value: 0n });
+  return wallet.sendTransaction({ account: owner, chain: chain2, to: token.address, data: expectedData, value: 0n });
 }
 
 // src/agents/zyfai/zyfai.agent.ts
 import { SMART_SESSIONS_VALIDATOR, ZyfaiSDK } from "@zyfai/sdk";
-import { erc20Abi as erc20Abi3, formatUnits as formatUnits2, isAddress as isAddress2, parseAbi as parseAbi2 } from "viem";
+import { erc20Abi as erc20Abi3, formatUnits as formatUnits2, isAddress as isAddress2, parseAbi as parseAbi3, parseUnits } from "viem";
 import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/lib/debug.ts
@@ -914,8 +1116,8 @@ function assetAliases(asset) {
   const normalised = asset.toLowerCase();
   return normalised === "weth" ? ["weth", "eth"] : [normalised];
 }
-function matchesAsset(symbol, asset) {
-  return assetAliases(asset).includes(symbol.toLowerCase());
+function matchesAsset(symbol2, asset) {
+  return assetAliases(asset).includes(symbol2.toLowerCase());
 }
 
 // src/agents/zyfai/zyfai.mapper.ts
@@ -929,10 +1131,10 @@ var DECIMALS_BY_SYMBOL = {
   wbtc: 8,
   cbbtc: 8
 };
-function tokenDecimals(symbol, explicit) {
+function tokenDecimals(symbol2, explicit) {
   if (typeof explicit === "number" && Number.isFinite(explicit))
     return explicit;
-  return DECIMALS_BY_SYMBOL[(symbol ?? "").toLowerCase()] ?? 6;
+  return DECIMALS_BY_SYMBOL[(symbol2 ?? "").toLowerCase()] ?? 6;
 }
 function mapWithdraw(raw2) {
   return {
@@ -952,10 +1154,10 @@ var NAME_TO_CHAIN_ID = Object.entries(
   acc[name.toLowerCase()] = Number(id);
   return acc;
 }, {});
-function resolveChainId(chain) {
-  const asNum = Number(chain);
+function resolveChainId(chain2) {
+  const asNum = Number(chain2);
   if (Number.isFinite(asNum) && asNum > 0) return asNum;
-  return NAME_TO_CHAIN_ID[chain.trim().toLowerCase()] ?? NaN;
+  return NAME_TO_CHAIN_ID[chain2.trim().toLowerCase()] ?? NaN;
 }
 function mapPendingAllocations(raw2) {
   if (!Array.isArray(raw2)) return void 0;
@@ -995,16 +1197,16 @@ function mapBalances(raw2, _chainId, smartWallet) {
   for (const [chainIdKey, tokensBySymbol] of Object.entries(portfolioByChain)) {
     const positionChainId = Number(chainIdKey);
     for (const [
-      symbol,
+      symbol2,
       { balance, balanceWithFee, decimals }
     ] of Object.entries(tokensBySymbol ?? {})) {
       if (balanceWithFee === void 0 && balance === void 0) throw new Error("Zyfai asset balance is unavailable.");
-      const amount = exactHexAmount(balanceWithFee ?? balance, tokenDecimals(symbol, decimals));
+      const amount = exactHexAmount(balanceWithFee ?? balance, tokenDecimals(symbol2, decimals));
       totalBalance += Number(amount);
       tokens.push({
         chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
         chainId: positionChainId,
-        asset: symbol,
+        asset: symbol2,
         amount
       });
     }
@@ -1072,12 +1274,12 @@ function mapEarnings(raw2, smartWallet) {
     totalEarningsByChain
   )) {
     const positionChainId = Number(chainIdKey);
-    for (const [symbol, earnings] of Object.entries(tokensBySymbol ?? {})) {
+    for (const [symbol2, earnings] of Object.entries(tokensBySymbol ?? {})) {
       const amount = Number(earnings);
       tokens.push({
         chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
         chainId: positionChainId,
-        asset: symbol,
+        asset: symbol2,
         amount: String(amount)
       });
     }
@@ -1097,8 +1299,8 @@ function mapWeightedApyByChain(raw2) {
     const chainId = Number(chainKey);
     if (!SUPPORTED_CHAIN_IDS.includes(chainId)) continue;
     const perAsset = {};
-    for (const [symbol, apy] of Object.entries(tokenApy)) {
-      const token = symbol;
+    for (const [symbol2, apy] of Object.entries(tokenApy)) {
+      const token = symbol2;
       if (!SUPPORTED_TOKENS.includes(token)) continue;
       perAsset[token] = apy;
     }
@@ -1329,8 +1531,8 @@ function computeAllocationApy(positions) {
 function earningsForToken(bucket, chainId, asset) {
   const tokens = bucket?.[String(chainId)];
   if (!tokens) return null;
-  for (const [symbol, value] of Object.entries(tokens)) {
-    if (!matchesAsset(symbol, asset)) continue;
+  for (const [symbol2, value] of Object.entries(tokens)) {
+    if (!matchesAsset(symbol2, asset)) continue;
     const amount = Number(value);
     return Number.isFinite(amount) ? amount : null;
   }
@@ -1347,8 +1549,8 @@ function assetsInSnapshot(entry, chainId) {
     entry.current_earnings_by_token,
     entry.total_earnings_by_token
   ]) {
-    for (const symbol of Object.keys(bucket?.[key2] ?? {})) {
-      seen.add(symbol.toUpperCase());
+    for (const symbol2 of Object.keys(bucket?.[key2] ?? {})) {
+      seen.add(symbol2.toUpperCase());
     }
   }
   return [...seen];
@@ -1717,13 +1919,13 @@ function resolveRpcUrls(rpcUrls, apiKey = "", baseUrl) {
     42161: resolveRpcUrl(rpcUrls, 42161, apiKey, baseUrl)
   };
 }
-function createPaidRpcClient(chain, rpcUrls) {
+function createPaidRpcClient(chain2, rpcUrls) {
   const url = resolveRpcUrl(
     rpcUrls,
-    chain.id
+    chain2.id
   );
   return createPublicClient({
-    chain,
+    chain: chain2,
     transport: http(url, {
       retryCount: PAID_RPC_RETRY_COUNT,
       retryDelay: PAID_RPC_RETRY_DELAY_MS
@@ -1738,8 +1940,8 @@ function headerValue(error, name) {
       return;
     if (seen.has(candidate)) return;
     seen.add(candidate);
-    const record = candidate;
-    const headers = record.headers;
+    const record2 = candidate;
+    const headers = record2.headers;
     let found;
     if (typeof headers?.get === "function") {
       found = headers.get(name);
@@ -1752,7 +1954,7 @@ function headerValue(error, name) {
       return;
     }
     for (const key2 of ["cause", "details", "response", "error"])
-      visit(record[key2], depth + 1);
+      visit(record2[key2], depth + 1);
   }
   visit(error);
   return value;
@@ -1765,16 +1967,16 @@ function statusCode(error) {
       return;
     if (seen.has(candidate)) return;
     seen.add(candidate);
-    const record = candidate;
+    const record2 = candidate;
     for (const key2 of ["status", "statusCode"]) {
-      const parsed = Number(record[key2]);
+      const parsed = Number(record2[key2]);
       if (Number.isInteger(parsed) && parsed >= 100 && parsed <= 599) {
         status = parsed;
         return;
       }
     }
     for (const key2 of ["cause", "details", "response", "error"])
-      visit(record[key2], depth + 1);
+      visit(record2[key2], depth + 1);
   }
   visit(error);
   return status;
@@ -1821,7 +2023,7 @@ async function withPaidRpcDiagnostics(operation, chainId, rpcMethod, agentId) {
 }
 
 // src/agents/zyfai/zyfai.agent.ts
-var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi2([
+var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi3([
   "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)"
 ]);
 var WETH_ADDRESS_BY_CHAIN = {
@@ -1834,6 +2036,17 @@ 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;
+function belowMinimumCeiling(rejection, token, decimals) {
+  if ((rejection.symbol === "ETH" ? "WETH" : rejection.symbol) !== token) return void 0;
+  const ceiling = (display) => {
+    const places = display.split(".")[1]?.length ?? 0;
+    if (places >= decimals) return void 0;
+    return parseUnits(display, decimals) + 5n * 10n ** BigInt(decimals - places - 1);
+  };
+  const idle = ceiling(rejection.idle);
+  const minimum = ceiling(rejection.minimum);
+  return idle === void 0 || minimum === void 0 ? void 0 : idle < minimum ? idle : minimum;
+}
 var ZyfaiAgent = class _ZyfaiAgent {
   constructor(apiKey, rpcUrls, referralSource) {
     this.apiKey = apiKey;
@@ -2790,8 +3003,10 @@ var ZyfaiAgent = class _ZyfaiAgent {
   // --- 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) {
+   * amount as proof of zero, or use this to skip sending a new MAX request.
+   * After Zyfai's minimum-withdrawal rejection, exact idle-only dust that fits
+   * within the message's rounded amounts is reported as not withdrawable. */
+  async assertNotEmptyRejectedWithdrawal(state, chainId, token, owner, belowMinimum) {
     const internals = this.sdk;
     const generation = this.earningsGeneration;
     let expired = false;
@@ -2822,22 +3037,31 @@ var ZyfaiAgent = class _ZyfaiAgent {
           { 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: erc20Abi3,
-          functionName: "balanceOf",
-          args: [wallet.address]
-        }).catch(() => void 0) : void 0;
-        assertScope();
-        if (idle === 0n) throw new OwneyError(
+      const asset = SupportedAssets.find((value) => value.chainId === chainId && value.symbol === token);
+      if (!asset || portfolio === void 0) return;
+      const empty = hasEmptyWithdrawalSnapshot(portfolio, chainId, token);
+      const ceiling = belowMinimum && belowMinimumCeiling(belowMinimum, token, asset.decimals);
+      if (!empty && ceiling === void 0) return;
+      const idle = await this.getPublicClient(chainId).readContract({
+        address: asset.address,
+        abi: erc20Abi3,
+        functionName: "balanceOf",
+        args: [wallet.address]
+      }).catch(() => void 0);
+      assertScope();
+      if (idle === 0n && empty) throw new OwneyError(
+        "WITHDRAW_INSUFFICIENT_BALANCE",
+        "No funds remain in Zyfai for this asset.",
+        { available: "0", chainId, token },
+        this.id
+      );
+      if (typeof idle === "bigint" && idle > 0n && ceiling !== void 0 && idle < ceiling && hasIdleOnlyWithdrawalSnapshot(portfolio, chainId, token, asset.decimals, idle))
+        throw new OwneyError(
           "WITHDRAW_INSUFFICIENT_BALANCE",
-          "No funds remain in Zyfai for this asset.",
-          { available: "0", chainId, token },
+          "The remaining Zyfai balance is below Zyfai's minimum withdrawal.",
+          { available: "0", chainId, token, reason: "ZYFAI_BELOW_MINIMUM_WITHDRAWAL", remainingRaw: idle.toString() },
           this.id
         );
-      }
     };
     let timer;
     try {
@@ -2888,7 +3112,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
       throw unavailable();
     }
   }
-  async withdraw(state, chainId, token, amount, onProgress) {
+  async withdraw(state, chainId, token, amount, onProgress, _gasMode, _onBeforeSubmission, assertOperation) {
     if (amount !== void 0 && (typeof amount !== "string" || !/^[0-9]+$/.test(amount) || BigInt(amount) <= 0n))
       throw new OwneyError("WITHDRAW_INVALID_AMOUNT", "Withdrawal amount must be a positive integer in token base units.", void 0, this.id);
     const validChainId = isValidChainId(chainId);
@@ -2924,7 +3148,11 @@ var ZyfaiAgent = class _ZyfaiAgent {
         throw staleSessionError;
       }
     };
-    let observation = observeWithdrawalSubmission(executionSdk, validChainId, token, assertCurrent);
+    const assertSubmission = () => {
+      assertCurrent();
+      assertOperation?.();
+    };
+    let observation = observeWithdrawalSubmission(executionSdk, validChainId, token, assertSubmission);
     const authToken = internals.httpClient?.authToken;
     let raw2;
     try {
@@ -2943,7 +3171,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
           }
           if (!amount && observation.rejected() && observation.request()?.failure === "insufficient-balance") {
             try {
-              await this.assertNotEmptyRejectedWithdrawal(state, validChainId, token, owner);
+              await this.assertNotEmptyRejectedWithdrawal(state, validChainId, token, owner, observation.belowMinimum());
             } catch (proofError) {
               if (proofError instanceof OwneyError && (proofError.code === "WITHDRAW_INSUFFICIENT_BALANCE" || proofError.code === "NOT_CONNECTED")) throw proofError;
             }
@@ -2956,9 +3184,10 @@ var ZyfaiAgent = class _ZyfaiAgent {
               { reason: "ZYFAI_SESSION_UNAVAILABLE", phase: "prepare", chainId, token },
               this.id
             );
+          assertSubmission();
           await this.recoverWithdrawalSession(state, validChainId, token, owner);
           observation.stop();
-          observation = observeWithdrawalSubmission(executionSdk, validChainId, token, assertCurrent);
+          observation = observeWithdrawalSubmission(executionSdk, validChainId, token, assertSubmission);
         }
       }
       if (!raw2) throw new OwneyError(
@@ -3352,7 +3581,7 @@ import {
   erc4626Abi as erc4626Abi2,
   getAddress as getAddress5,
   isAddress as isAddress4,
-  parseUnits
+  parseUnits as parseUnits2
 } from "viem";
 import { base as base4 } from "viem/chains";
 
@@ -3503,6 +3732,11 @@ var YieldseekerAuth = class {
   key(state, chainId) {
     return `${state.walletAddress.toLowerCase()}:${chainId}:${resolveSiweOrigin(this.dependencies.origin).origin}`;
   }
+  /** Observation must never open a sign-in prompt. */
+  peekToken(state, chainId) {
+    const token = this.tokens.get(this.key(state, chainId)) ?? readYieldseekerSession(state.walletAddress, chainId);
+    return token && this.isReusable(token, state, chainId) ? token : void 0;
+  }
   async getToken(state, chainId) {
     const key2 = this.key(state, chainId);
     const scope = { address: state.walletAddress, chainId };
@@ -3687,10 +3921,10 @@ var YieldseekerApiError = class extends Error {
 };
 function providerError(body, fallback2) {
   if (!body || typeof body !== "object") return { code: fallback2 };
-  const record = body;
+  const record2 = body;
   return {
-    code: typeof record.message === "string" ? record.message : fallback2,
-    fields: record.fields && typeof record.fields === "object" ? record.fields : void 0
+    code: typeof record2.message === "string" ? record2.message : fallback2,
+    fields: record2.fields && typeof record2.fields === "object" ? record2.fields : void 0
   };
 }
 var YieldseekerApiClient = class {
@@ -3844,16 +4078,16 @@ function riskAdjustedApyForDays(option, days) {
   if (days === "30D") return option.riskAdjustedApy30dAverage;
   return (option.riskAdjustedApy7dAverage + option.riskAdjustedApy30dAverage) / 2;
 }
-function assetAddressValue(record, address) {
-  const entry = Object.entries(record).find(
+function assetAddressValue(record2, address) {
+  const entry = Object.entries(record2).find(
     ([key2]) => key2.toLowerCase() === address.toLowerCase()
   );
   return entry?.[1] ?? "0";
 }
 function position(value, asset, baseAssetDecimals) {
-  const option = value?.yieldOption;
+  const option = value?.vaultOption;
   if (!option || typeof option.provider !== "string" || typeof option.name !== "string" || typeof option.address !== "string" || !isAddress3(option.address)) {
-    return invalid("yield positions", "missing vault metadata");
+    return invalid("vault positions", "missing vault metadata");
   }
   return {
     chain: "BASE",
@@ -3869,10 +4103,10 @@ function position(value, asset, baseAssetDecimals) {
     amount: balanceDecimal(
       value.assetsBase,
       baseAssetDecimals,
-      "yield positions"
+      "vault positions"
     ),
-    amountRaw: balanceRaw(value.assetsRaw, "yield positions").toString(),
-    withdrawableAmountRaw: balanceRaw(value.withdrawableAssetsRaw, "yield positions").toString(),
+    amountRaw: balanceRaw(value.assetsRaw, "vault positions").toString(),
+    withdrawableAmountRaw: balanceRaw(value.withdrawableAssetsRaw, "vault positions").toString(),
     apy: percent(option.riskAdjustedApy),
     tvl: Number(option.totalDepositsUsd),
     liquidity: Number(option.withdrawableDepositsUsd)
@@ -4091,52 +4325,82 @@ function actionEntry(action) {
     rebalanceLog: []
   };
 }
-function allocationEntry(action, context) {
-  if (action.actionType.toLowerCase() !== "autoseek") return void 0;
-  const hash2 = action.details?.depositTransactionHash;
-  const deposits = action.details?.deposits;
-  if (typeof hash2 !== "string" || !/^0x[a-fA-F0-9]{64}$/.test(hash2) || !Array.isArray(deposits) || deposits.length === 0) return void 0;
-  const positions = [];
-  let amountRaw = 0n;
-  for (const deposit of deposits) {
-    if (!deposit || typeof deposit !== "object") return void 0;
-    const leg = deposit;
-    const symbol = typeof leg.assetSymbol === "string" ? leg.assetSymbol.toUpperCase() : "";
-    if (symbol !== context.asset && !(context.asset === "WETH" && symbol === "ETH")) return void 0;
+var TX_HASH = /^0x[a-fA-F0-9]{64}$/;
+function allocationLegs(value, context, requireAmount) {
+  if (!Array.isArray(value)) return void 0;
+  const legs = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object") return void 0;
+    const leg = item;
+    const symbol2 = typeof leg.assetSymbol === "string" ? leg.assetSymbol.toUpperCase() : "";
+    if ((requireAmount || symbol2) && symbol2 !== context.asset && !(context.asset === "WETH" && symbol2 === "ETH"))
+      return void 0;
     if (typeof leg.vaultAddress !== "string" || !isAddress3(leg.vaultAddress)) return void 0;
     const rawAmount2 = 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 (rawAmount2 === void 0 || rawAmount2 <= 0n) return void 0;
-    const option = context.positions.find((position2) => position2.yieldOption.address.toLowerCase() === leg.vaultAddress.toLowerCase())?.yieldOption;
-    positions.push({
+    if (requireAmount && (rawAmount2 === void 0 || rawAmount2 <= 0n)) return void 0;
+    const vault = leg.vaultAddress.toLowerCase();
+    const option = context.positions.find((position2) => position2.vaultOption.address.toLowerCase() === vault)?.vaultOption;
+    const receipt = context.historic?.assets?.find((asset) => asset.address.toLowerCase() === vault && !asset.isSpam);
+    legs.push({
       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: formatUnits3(rawAmount2, YIELDSEEKER_ASSET_METADATA[context.asset].decimals)
+      pool: typeof leg.vaultName === "string" && leg.vaultName ? leg.vaultName : option?.name ?? (receipt?.name || receipt?.symbol || void 0),
+      rawAmount: rawAmount2
     });
-    amountRaw += rawAmount2;
   }
+  return legs;
+}
+function allocationEntry(action, context) {
+  if (action.actionType.toLowerCase() !== "autoseek") return void 0;
+  const hash2 = action.details?.depositTransactionHash;
+  const withdrawHash = action.details?.withdrawTransactionHash;
+  if (typeof hash2 !== "string" || !TX_HASH.test(hash2)) return null;
+  const deposits = allocationLegs(action.details?.deposits, context, true);
+  const withdrawals = action.details?.withdrawals == null ? [] : allocationLegs(action.details.withdrawals, context, false);
+  if (!deposits?.length || !withdrawals) return null;
+  const decimals = YIELDSEEKER_ASSET_METADATA[context.asset].decimals;
+  const positions = deposits.map((leg) => ({
+    protocol: leg.protocol,
+    pool: leg.pool,
+    tokenSymbol: context.asset,
+    amount: formatUnits3(leg.rawAmount, decimals)
+  }));
+  const amountRaw = deposits.reduce((total, leg) => total + leg.rawAmount, 0n);
+  const rebalance = withdrawals.length > 0;
+  const hashes = rebalance && typeof withdrawHash === "string" && TX_HASH.test(withdrawHash) && withdrawHash.toLowerCase() !== hash2.toLowerCase() ? [hash2, withdrawHash] : [hash2];
+  const source = withdrawals.length === 1 ? withdrawals[0] : {
+    protocol: [...new Set(withdrawals.map((leg) => leg.protocol))].join(" + "),
+    pool: withdrawals.map((leg) => leg.pool).filter(Boolean).join(" + ") || void 0
+  };
   return {
     agent: "yieldseeker",
-    action: "Deposit",
+    action: rebalance ? "Rebalance" : "Deposit",
     date: action.createdDate,
     oldApy: null,
     newApy: null,
     positions,
-    rebalanceLog: [],
+    rebalanceLog: rebalance ? deposits.map((leg) => ({
+      fromProtocol: source.protocol,
+      ...source.pool ? { fromPool: source.pool } : {},
+      toProtocol: leg.protocol,
+      ...leg.pool ? { toPool: leg.pool } : {},
+      tokenSymbol: context.asset,
+      amount: formatUnits3(leg.rawAmount, decimals),
+      status: "success"
+    })) : [],
     transactions: [{
-      txHashes: [hash2],
+      txHashes: hashes,
       chainId: context.agent.chainId,
       tokenAddress: context.agent.assetAddress,
       tokenSymbol: context.asset,
       agentWallet: context.wallet.walletAddress,
       amountRaw: String(amountRaw),
-      amount: formatUnits3(amountRaw, YIELDSEEKER_ASSET_METADATA[context.asset].decimals)
+      amount: formatUnits3(amountRaw, decimals)
     }]
   };
 }
 function depositDestination(context, movement) {
   const to = movement.toAddress.toLowerCase();
-  const option = context.positions.find(({ yieldOption }) => yieldOption.chainId === movement.chainId && yieldOption.assetAddress.toLowerCase() === context.agent.assetAddress.toLowerCase() && yieldOption.address.toLowerCase() === to)?.yieldOption;
+  const option = context.positions.find(({ vaultOption }) => vaultOption.chainId === movement.chainId && vaultOption.assetAddress.toLowerCase() === context.agent.assetAddress.toLowerCase() && vaultOption.address.toLowerCase() === to)?.vaultOption;
   if (option) return { protocol: option.provider || "Vault", pool: option.name, tokenSymbol: context.asset };
   const receipt = context.historic?.assets.find((asset) => asset.chainId === movement.chainId && !asset.isSpam && asset.address.toLowerCase() === to && asset.address.toLowerCase() !== context.agent.assetAddress.toLowerCase());
   const minted = receipt && context.historic?.movements.some((candidate) => candidate.chainId === movement.chainId && candidate.transactionHash.toLowerCase() === movement.transactionHash.toLowerCase() && candidate.assetAddress.toLowerCase() === receipt.address.toLowerCase() && candidate.fromAddress.toLowerCase() === "0x0000000000000000000000000000000000000000" && candidate.toAddress.toLowerCase() === context.wallet.walletAddress.toLowerCase() && raw(candidate.assetAmount, "historic position") > 0n);
@@ -4201,6 +4465,23 @@ function mapYieldseekerHistory(contexts, options) {
       seenMovements.add(key2);
       return true;
     });
+    const allocations = /* @__PURE__ */ new Map();
+    const rebalanceHashes = /* @__PURE__ */ new Set();
+    const actions = [];
+    for (const action of context.actions ?? []) {
+      const allocation = allocationEntry(action, context);
+      if (allocation === null) continue;
+      if (!allocation) {
+        const entry = actionEntry(action);
+        if (entry) actions.push(entry);
+        continue;
+      }
+      const hash2 = allocation.transactions[0].txHashes[0].toLowerCase();
+      if (allocations.has(hash2)) continue;
+      allocations.set(hash2, allocation);
+      if (allocation.action === "Rebalance")
+        for (const value of allocation.transactions[0].txHashes) rebalanceHashes.add(value.toLowerCase());
+    }
     const movementEntries = movements.map(
       (movement) => movementEntry(
         movement,
@@ -4211,19 +4492,10 @@ function mapYieldseekerHistory(contexts, options) {
         options.vaultAddresses,
         depositDestination(context, movement)
       )
-    ).filter((entry) => entry !== void 0);
+    ).filter((entry) => entry !== void 0 && !((entry.action === "Deposit" || entry.action === "Top up") && rebalanceHashes.has(entry.transactions[0]?.txHashes[0]?.toLowerCase() ?? "")));
     const deposits = new Set(movementEntries.filter((entry) => entry.action === "Deposit").map((entry) => entry.transactions[0]?.txHashes[0]?.toLowerCase()));
-    const actions = (context.actions ?? []).flatMap((action) => {
-      const allocation = allocationEntry(action, context);
-      if (allocation) {
-        const hash2 = allocation.transactions[0].txHashes[0].toLowerCase();
-        if (deposits.has(hash2)) return [];
-        deposits.add(hash2);
-        return [allocation];
-      }
-      const entry = actionEntry(action);
-      return entry ? [entry] : [];
-    });
+    for (const [hash2, allocation] of allocations)
+      if (allocation.action === "Rebalance" || !deposits.has(hash2)) actions.push(allocation);
     return [...movementEntries, ...actions];
   });
   const grouped = /* @__PURE__ */ new Map();
@@ -4301,8 +4573,8 @@ function mapYieldseekerProfile(address, contexts) {
   const protocols = /* @__PURE__ */ new Set();
   for (const context of contexts) {
     for (const current of context.positions) {
-      if (current.yieldOption?.provider) {
-        protocols.add(String(current.yieldOption.provider));
+      if (current.vaultOption?.provider) {
+        protocols.add(String(current.vaultOption.provider));
       }
     }
   }
@@ -4320,7 +4592,7 @@ function mapYieldseekerAgentApy(options, days) {
   const perAsset = {};
   const all = [];
   for (const entry of options) {
-    const apys = entry.yieldOptions.map(
+    const apys = entry.vaultOptions.map(
       (option) => publicApyAfterYieldseekerFee(riskAdjustedApyForDays(option, days))
     ).filter(Number.isFinite);
     if (apys.length === 0) continue;
@@ -4384,13 +4656,13 @@ async function remainingVaultBalance(client, wallet, asset, vaults, blockNumber)
 import {
   getAddress as getAddress3,
   isAddressEqual,
-  parseAbi as parseAbi3
+  parseAbi as parseAbi4
 } from "viem";
 var YIELDSEEKER_FACTORY = "0x9c7410a0faCAC60850C46eE5b58B518daec95130";
 var YIELDSEEKER_V1_IMPLEMENTATION = "0x32403455357589523435dB18b414057D7cE05051";
 var YIELDSEEKER_V2_IMPLEMENTATION = "0x613Db9c924ADB7A7A90c11b02Cce20c913E3Fe50";
 var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
-var walletAbi = parseAbi3([
+var walletAbi = parseAbi4([
   "function owner() view returns (address)",
   "function ownerAgentIndex() view returns (uint256)",
   "function baseAsset() view returns (address)",
@@ -4398,7 +4670,7 @@ var walletAbi = parseAbi3([
   "function upgradeToLatest()",
   "event Upgraded(address indexed implementation)"
 ]);
-var factoryAbi = parseAbi3([
+var factoryAbi = parseAbi4([
   "function userWallets(address owner, uint256 index) view returns (address)",
   "function agentWalletImplementation() view returns (address)"
 ]);
@@ -4548,11 +4820,11 @@ 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([
+  const [chain2, accounts] = await Promise.all([
     state.provider.request({ method: "eth_chainId" }),
     state.provider.request({ method: "eth_accounts" })
   ]);
-  if (Number(chain) !== 8453)
+  if (Number(chain2) !== 8453)
     throw new OwneyError(
       "CHAIN_MISMATCH",
       "Switch back to Base before withdrawing.",
@@ -4803,6 +5075,7 @@ async function submitEoa(input) {
     chain: base3,
     transport: custom3(input.state.provider)
   });
+  input.assertCurrent?.();
   const signature = await wallet.signMessage({ message: { raw: userOpHash } });
   operation = { ...operation, signature };
   await assertOwnerSession(input.state, input.owner);
@@ -4820,7 +5093,9 @@ async function submitEoa(input) {
     paymasterAndData: operation.paymasterAndData
   };
   savePending(input.onPending, { userOpHash, userOperation }, true);
+  input.assertCurrent?.();
   await checkpoint(input.onBeforeSubmission, { userOpHash, userOperation });
+  input.assertCurrent?.();
   const submittedHash = await rpc(
     input.rpcUrl,
     "eth_sendUserOperation",
@@ -4887,7 +5162,9 @@ async function submitSmart(input) {
   assertIntentFresh(input.expiresAt);
   const requestedId = toHex(globalThis.crypto.getRandomValues(new Uint8Array(32)));
   savePending(input.onPending, { callsId: requestedId }, true);
+  input.assertCurrent?.();
   await checkpoint(input.onBeforeSubmission, { callsId: requestedId });
+  input.assertCurrent?.();
   try {
     sent = await input.state.provider.request({
       method: "wallet_sendCalls",
@@ -5014,7 +5291,7 @@ var OWNEY_AGENT_RULE_PRESET = "explorative";
 var YIELDSEEKER_USERNAME_PREFIX = "owney_";
 var YIELDSEEKER_USERNAME_RANDOM_LENGTH = 14;
 var YIELDSEEKER_USERNAME_CREATE_ATTEMPTS = 3;
-var YIELDSEEKER_YIELD_OPTIONS_CACHE_MS = 6e4;
+var YIELDSEEKER_VAULT_OPTIONS_CACHE_MS = 6e4;
 var YIELDSEEKER_AGENT_LIST_CACHE_MS = 12e4;
 var YIELDSEEKER_PORTFOLIO_CACHE_MS = 12e4;
 var YIELDSEEKER_SETTLEMENT_CACHE_MS = 5e3;
@@ -5117,6 +5394,7 @@ var YieldseekerAgent = class {
   pendingReads = /* @__PURE__ */ new Map();
   readGeneration = 0;
   portfolioVersions = /* @__PURE__ */ new Map();
+  liquidityVersions = /* @__PURE__ */ new Map();
   snapshotFailures = /* @__PURE__ */ new Map();
   standardReadFailures = /* @__PURE__ */ new Map();
   reconcileUntil = /* @__PURE__ */ new Map();
@@ -5126,8 +5404,8 @@ var YieldseekerAgent = class {
   // settlement; keep slow reconciliation after the fast window expires.
   snapshotMovements = /* @__PURE__ */ new Map();
   movementEpochs = /* @__PURE__ */ new Map();
-  yieldOptions = /* @__PURE__ */ new Map();
-  pendingYieldOptions = /* @__PURE__ */ new Map();
+  vaultOptions = /* @__PURE__ */ new Map();
+  pendingVaultOptions = /* @__PURE__ */ new Map();
   constructor(owneyApiKey, options = {}) {
     this.owneyApiKey = owneyApiKey;
     this.routingApiBaseUrl = options.routingApiBaseUrl;
@@ -5421,6 +5699,7 @@ var YieldseekerAgent = class {
     this.readCache.clear();
     this.pendingReads.clear();
     this.portfolioVersions.clear();
+    this.liquidityVersions.clear();
     this.snapshotFailures.clear();
     this.standardReadFailures.clear();
     this.reconcileUntil.clear();
@@ -5528,7 +5807,7 @@ var YieldseekerAgent = class {
     notifyFunding(onProgress, evidence);
     return { txHash, smartWallet: context.wallet.walletAddress, amount, evidence };
   }
-  async withdraw(state, chainId, asset, amount, onProgress, gasMode = "auto", onBeforeSubmission) {
+  async withdraw(state, chainId, asset, amount, onProgress, gasMode = "auto", onBeforeSubmission, assertOperation) {
     let ownerTransferAttempted = false;
     let evidence = {
       agentId: this.id,
@@ -5546,7 +5825,7 @@ var YieldseekerAgent = class {
         notifyFunding(onProgress, evidence);
       }, () => {
         ownerTransferAttempted = true;
-      }, gasMode, onBeforeSubmission);
+      }, gasMode, onBeforeSubmission, assertOperation);
     } 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.details?.ownerTransferNotExecuted === true || error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)))
@@ -5559,7 +5838,7 @@ var YieldseekerAgent = class {
       throw error;
     }
   }
-  async withdrawInternal(state, chainId, asset, amount, onProgress, onOwnerTransferAttempted, gasMode = "auto", onBeforeSubmission) {
+  async withdrawInternal(state, chainId, asset, amount, onProgress, onOwnerTransferAttempted, gasMode = "auto", onBeforeSubmission, assertOperation) {
     this.assertChain(chainId);
     this.assertAsset(asset);
     if (amount !== void 0 && BigInt(amount) <= 0n) {
@@ -5677,7 +5956,7 @@ var YieldseekerAgent = class {
       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 positions = [...funds.positions, ...funds.indexedPositions.filter((position2) => !funds.resolvedVaults.includes(position2.vaultOption.address.toLowerCase()))];
       let positionsStatus = "empty";
       const validatePositions = (values) => this.validateWithdrawalPositions(values, chainId, asset);
       validatePositions(positions);
@@ -5685,23 +5964,23 @@ var YieldseekerAgent = class {
       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);
+        for (const position2 of values) knownPositions.set(position2.vaultOption.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(() => []);
+        let active2 = true;
+        const checks = this.readVaultShares(values.map((position2) => position2.vaultOption), agentWallet, blockNumber).catch(() => []);
         const reads = values.map(async (position2, index) => {
-          const address = getAddress5(position2.yieldOption.address);
+          const address = getAddress5(position2.vaultOption.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;
+            const group = (await checks).slice(index * 2, index * 2 + 2);
+            if (!active2 || group.length !== 2 || 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" || !isAddress4(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) {
+            const [underlying, shares] = group.map((value) => value.result);
+            if (typeof underlying !== "string" || !isAddress4(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n) return null;
+            const verified = { ...position2, assetsRaw: shares.toString(), withdrawableAssetsRaw: "0" };
+            if (shares > 0n) {
               let positiveValue = false;
               const valuations = await Promise.all(["convertToAssets", "previewRedeem"].map(async (functionName) => {
                 try {
@@ -5712,9 +5991,11 @@ var YieldseekerAgent = class {
                     args: [shares],
                     blockNumber
                   });
-                  if (typeof value !== "bigint" || value < 0n) return null;
+                  if (!active2 || typeof value !== "bigint" || value < 0n) return null;
+                  this.assertSession(generation, chainId, asset);
                   if (value > 0n && !positiveValue) {
                     positiveValue = true;
+                    verified.withdrawableAssetsRaw = value.toString();
                     verifiedPositions.push(verified);
                   }
                   return value;
@@ -5722,7 +6003,12 @@ var YieldseekerAgent = class {
                   return null;
                 }
               }));
-              if (positiveValue) return verified;
+              if (positiveValue) {
+                const redemptionValue = valuations[1];
+                if (redemptionValue !== null && redemptionValue > 0n)
+                  verified.withdrawableAssetsRaw = redemptionValue.toString();
+                return verified;
+              }
               if (blockNumber === void 0 || valuations.some((value) => value !== 0n)) return null;
               zeroValuePositions.add(verified);
             }
@@ -5733,7 +6019,7 @@ var YieldseekerAgent = class {
           }
         });
         const result = await boundedVerification(Promise.all(reads), timeoutMs);
-        active = false;
+        active2 = false;
         this.assertSession(generation, chainId, asset);
         return {
           verified: result !== void 0 && result.every((position2) => position2 !== null),
@@ -5745,13 +6031,14 @@ var YieldseekerAgent = class {
         const response = await this.walletRequest(
           state,
           chainId,
-          this.agentPath(context, "yield-positions")
+          this.agentPath(context, "vault-positions")
         );
         this.assertSession(generation, chainId, asset);
-        if (!Array.isArray(response?.yieldPositions)) throw this.invalidResponse("yield positions");
-        return validatePositions(response.yieldPositions);
+        if (!Array.isArray(response?.vaultPositions)) throw this.invalidResponse("vault positions");
+        return validatePositions(response.vaultPositions);
       };
       if (amount === void 0) {
+        rememberPositions(priorPositions);
         rememberPositions(funds.indexedPositions);
         rememberPositions(positions);
         positionsStatus = hasPositions(positions) ? "remaining" : "empty";
@@ -5778,7 +6065,7 @@ var YieldseekerAgent = class {
             throw new OwneyError(
               "WITHDRAW_FAILED",
               "Yieldseeker vault funds are not currently withdrawable.",
-              { asset, positionsStatus, remainingPositions: positions.map((position2) => position2.yieldOption.address) },
+              { asset, positionsStatus, remainingPositions: positions.map((position2) => position2.vaultOption.address) },
               this.id
             );
         }
@@ -5827,6 +6114,7 @@ var YieldseekerAgent = class {
       let latestUnwindBlock;
       const unwind = async (position2, assetsRaw) => {
         this.assertSession(generation, chainId, asset);
+        assertOperation?.();
         let unwindTransactionHash;
         try {
           const response = await this.walletRequest(
@@ -5835,7 +6123,8 @@ var YieldseekerAgent = class {
             this.agentPath(context, "withdraw-from-position"),
             {
               method: "POST",
-              body: { chainId, vaultAddress: position2.yieldOption.address, assetsRaw: assetsRaw.toString() }
+              body: { chainId, vaultAddress: position2.vaultOption.address, assetsRaw: assetsRaw.toString() },
+              assertCurrent: assertOperation
             }
           );
           if (!this.isTransactionHash(response?.transactionHash)) throw this.invalidResponse("position withdrawal");
@@ -5854,7 +6143,7 @@ var YieldseekerAgent = class {
               ...error instanceof OwneyError ? error.details : {},
               withdrawalPhase: "unwind",
               reason: "YIELDSEEKER_UNWIND_UNRESOLVED",
-              vaultAddress: position2.yieldOption.address,
+              vaultAddress: position2.vaultOption.address,
               unwindTransactionHash,
               ownerTransferSubmitted: false
             },
@@ -5867,7 +6156,7 @@ var YieldseekerAgent = class {
       };
       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.withdrawableAssetsRaw)]));
+          const before = new Map(positions.map((position2) => [position2.vaultOption.address.toLowerCase(), BigInt(position2.withdrawableAssetsRaw)]));
           let unwound = false;
           for (const position2 of positions) {
             const available = BigInt(position2.withdrawableAssetsRaw);
@@ -5884,14 +6173,16 @@ var YieldseekerAgent = class {
           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 {
+            positions = [...proof.positions, ...(catalog ?? []).filter((position2) => !knownBeforeRefresh.has(position2.vaultOption.address.toLowerCase()))];
+          } else if (catalog) {
+            const checked = new Set(proof.positions.map((position2) => position2.vaultOption.address.toLowerCase()));
+            positions = [...proof.positions, ...catalog.filter((position2) => !checked.has(position2.vaultOption.address.toLowerCase()))];
+          } else {
             positionsStatus = "unavailable";
             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;
+          if (positions.some((position2) => BigInt(position2.withdrawableAssetsRaw) > 0n && before.has(position2.vaultOption.address.toLowerCase()) && BigInt(position2.withdrawableAssetsRaw) >= before.get(position2.vaultOption.address.toLowerCase()))) break;
         }
       } else {
         for (const position2 of positions) {
@@ -5904,7 +6195,7 @@ var YieldseekerAgent = class {
         }
       }
       if (amount !== void 0 && remaining > 0n) {
-        throw this.invalidResponse("yield positions", {
+        throw this.invalidResponse("vault positions", {
           reason: "Withdrawable positions could not cover the request.",
           remaining: remaining.toString()
         });
@@ -5939,6 +6230,13 @@ var YieldseekerAgent = class {
       const account = getAddress5(state.walletAddress);
       let receipt;
       const base7 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount ?? "MAX", transfer: "pending", registration: "not-applicable", delivery: "pending" };
+      if (amount === void 0) base7.maxCompletion = {
+        userId: context.user.userId,
+        agentId: context.agent.agentId,
+        vaults: [...knownPositions.keys()],
+        inventoryComplete: funds.complete
+      };
+      if (base7.maxCompletion) notifyFunding(onProgress, base7);
       let submissionEvidence = base7;
       const data = amount === void 0 ? encodeFunctionData2({
         abi: YIELDSEEKER_AGENT_WALLET_ABI,
@@ -5956,6 +6254,7 @@ var YieldseekerAgent = class {
           client: this.getReceiptClient(),
           apiKey: this.owneyApiKey,
           routingApiBaseUrl: this.routingApiBaseUrl,
+          assertCurrent: assertOperation,
           yieldseekerSignature: await this.auth.getToken(state, chainId),
           refreshYieldseekerSignature: (rejected) => this.auth.refreshToken(state, chainId, rejected),
           userId: context.user.userId,
@@ -5968,6 +6267,7 @@ var YieldseekerAgent = class {
             notifyFunding(onProgress, submissionEvidence);
           },
           onBeforeSubmission: async (pending) => {
+            assertOperation?.();
             await onBeforeSubmission?.({ ...base7, ...pending });
             onOwnerTransferAttempted?.();
           }
@@ -5976,15 +6276,26 @@ var YieldseekerAgent = class {
         receipt = submitted.receipt;
       } else {
         onOwnerTransferAttempted?.();
-        txHash = await this.submitTransaction(state, chainId, {
-          from: account,
-          to: getAddress5(context.wallet.walletAddress),
-          data,
-          value: "0",
-          chainId
-        }, (hash2) => notifyFunding(onProgress, { ...base7, txHash: hash2 }), (value) => {
-          receipt = value;
-        });
+        txHash = await this.submitTransaction(
+          state,
+          chainId,
+          {
+            from: account,
+            to: getAddress5(context.wallet.walletAddress),
+            data,
+            value: "0",
+            chainId
+          },
+          (hash2) => notifyFunding(onProgress, { ...base7, txHash: hash2 }),
+          (value) => {
+            receipt = value;
+          },
+          async () => {
+            assertOperation?.();
+            await onBeforeSubmission?.(base7);
+            assertOperation?.();
+          }
+        );
       }
       const evidence = receipt ? inspectFundingReceipt(receipt, { ...submissionEvidence, txHash }, metadata.address, "withdraw") : { ...submissionEvidence, txHash, transfer: "pending", delivery: "pending" };
       notifyFunding(onProgress, evidence);
@@ -6029,7 +6340,7 @@ var YieldseekerAgent = class {
               asset,
               positionsStatus,
               remainingPositions: positionsStatus === "remaining" ? positions.filter((position2) => !zeroValuePositions.has(position2) && (BigInt(position2.assetsRaw) > 0n || BigInt(position2.withdrawableAssetsRaw) > 0n)).map((position2) => ({
-                vaultAddress: position2.yieldOption.address,
+                vaultAddress: position2.vaultOption.address,
                 sharesRaw: position2.assetsRaw,
                 withdrawableAmountRaw: position2.withdrawableAssetsRaw
               })) : void 0,
@@ -6038,6 +6349,7 @@ var YieldseekerAgent = class {
             this.id
           );
         }
+        if (evidence.maxCompletion) evidence.maxCompletion.vaults = [...knownPositions.keys()];
         if (!proof.verified) completion = "unverified";
       }
       if (explicitEmptyPayout)
@@ -6070,7 +6382,7 @@ var YieldseekerAgent = class {
       }
     }
   }
-  /** A withdrawal-only liquidity floor; display snapshots never authorize it. */
+  /** Fresh position amounts for withdrawal planning, net of reserved fees. */
   async getWithdrawableBalance(state, chainId, asset, minimumAmount) {
     this.assertChain(chainId);
     this.assertAsset(asset);
@@ -6095,7 +6407,66 @@ var YieldseekerAgent = class {
     );
     return proof.available;
   }
-  async readVaultLiquidity(options, wallet, blockNumber) {
+  /** Recheck MAX without re-unwinding, paying out, or requesting a signature. */
+  async verifyWithdrawalCompletion(state, evidence) {
+    const unknown = (reason2) => ({ status: "unavailable", reason: reason2 });
+    const proof = evidence.maxCompletion;
+    if (evidence.agentId !== this.id || evidence.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase() || evidence.chainId !== 8453 || !proof || !evidence.agentWallet || !isAddress4(evidence.agentWallet) || !evidence.blockNumber || !/^\d+$/.test(evidence.blockNumber) || evidence.transfer !== "confirmed" || evidence.delivery !== "confirmed" || !this.isTransactionHash(evidence.txHash)) return unknown("PAYOUT_PROOF_UNAVAILABLE");
+    this.assertAsset(evidence.token);
+    const asset = evidence.token;
+    const metadata = YIELDSEEKER_ASSET_METADATA[asset];
+    const signature = this.auth.peekToken(state, evidence.chainId);
+    if (!signature) return unknown("AUTHENTICATION_REQUIRED");
+    let reason = "CATALOG_UNAVAILABLE";
+    try {
+      return await bounded(async () => {
+        const response = await this.api.request(
+          `/users/${encodeURIComponent(proof.userId)}/agents/${encodeURIComponent(proof.agentId)}/vault-positions`,
+          { signature }
+        );
+        if (!Array.isArray(response?.vaultPositions)) return unknown("CATALOG_INVALID");
+        const positions = this.validateWithdrawalPositions(response.vaultPositions, evidence.chainId, asset);
+        const vaults = new Set([...proof.vaults, ...positions.map((p) => p.vaultOption.address)].map((a) => a.toLowerCase()));
+        if (!proof.inventoryComplete) {
+          const catalog = await this.loadVaultOptions(asset);
+          const eligible = catalog.filter((o) => o.chainId === evidence.chainId && o.assetAddress?.toLowerCase() === metadata.address.toLowerCase() && isAddress4(o.address));
+          if (!eligible.length) return unknown("INVENTORY_INCOMPLETE");
+          eligible.forEach((o) => vaults.add(o.address.toLowerCase()));
+        }
+        if (vaults.size > YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT || [...vaults].some((a) => !isAddress4(a)))
+          return unknown("INVENTORY_INVALID");
+        reason = "VAULT_PROOF_UNAVAILABLE";
+        const blockNumber = BigInt(evidence.blockNumber);
+        const addresses = [...vaults];
+        const shares = await this.readVaultShares(addresses.map((address) => ({ address })), evidence.agentWallet, blockNumber);
+        const checks = await Promise.all(addresses.map(async (address, i) => {
+          const group = shares.slice(i * 2, i * 2 + 2);
+          if (group.length !== 2 || group.some((r) => r.status !== "success")) return "unavailable";
+          const [underlying, value] = group.map((r) => r.result);
+          if (typeof underlying !== "string" || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof value !== "bigint" || value < 0n) return "unavailable";
+          if (value === 0n) return "complete";
+          const amounts = await Promise.allSettled(["convertToAssets", "previewRedeem"].map((functionName) => this.getReceiptClient().readContract({
+            address: getAddress5(address),
+            abi: erc4626Abi2,
+            functionName,
+            args: [value],
+            blockNumber
+          })));
+          if (amounts.some((r) => r.status === "fulfilled" && typeof r.value === "bigint" && r.value > 0n)) return "remaining";
+          return amounts.every((r) => r.status === "fulfilled" && r.value === 0n) ? "complete" : "unavailable";
+        }));
+        const status = checks.includes("remaining") ? "remaining" : checks.includes("unavailable") ? "unavailable" : "complete";
+        return {
+          status,
+          checkedVaults: addresses.length,
+          ...status === "unavailable" ? { reason } : status === "remaining" ? { reason: "VAULT_REMAINDER" } : {}
+        };
+      }, 8e3, () => new Error("MAX proof read timed out"));
+    } catch {
+      return unknown(reason);
+    }
+  }
+  async readVaultShares(options, wallet, blockNumber) {
     const owner = getAddress5(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({
@@ -6105,8 +6476,7 @@ var YieldseekerAgent = class {
         const address = getAddress5(option.address);
         return [
           { address, abi: erc4626Abi2, functionName: "asset" },
-          { address, abi: erc20Abi5, functionName: "balanceOf", args: [owner] },
-          { address, abi: erc4626Abi2, functionName: "maxWithdraw", args: [owner] }
+          { address, abi: erc20Abi5, functionName: "balanceOf", args: [owner] }
         ];
       })
     })));
@@ -6116,23 +6486,23 @@ var YieldseekerAgent = class {
     const underlying = YIELDSEEKER_ASSET_METADATA[asset].address.toLowerCase();
     const seen = /* @__PURE__ */ new Set();
     for (const value of values) {
-      const option = value?.yieldOption;
+      const option = value?.vaultOption;
       if (!option || typeof option.address !== "string" || !isAddress4(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");
+        throw this.invalidResponse("vault 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 positions = this.readCache.get(`positions:${key2}`)?.value?.vaultPositions ?? [];
+    const hints = new Map(this.validateWithdrawalPositions(positions, chainId, context.asset).map((position2) => [position2.vaultOption.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 ?? []) {
+    for (const option of this.vaultOptions.get(context.asset)?.value ?? []) {
       if (option.chainId !== chainId || typeof option.assetAddress !== "string" || option.assetAddress.toLowerCase() !== YIELDSEEKER_ASSET_METADATA[context.asset].address.toLowerCase() || !isAddress4(option.address) || !receivedAssets.has(option.address.toLowerCase()) || hints.has(option.address.toLowerCase())) continue;
       hints.set(option.address.toLowerCase(), {
-        yieldOption: option,
+        vaultOption: option,
         assetsRaw: "0",
         assetsBase: "0",
         assetsUsd: 0,
@@ -6166,7 +6536,7 @@ var YieldseekerAgent = class {
   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 version = this.liquidityVersions.get(contextKey) ?? 0;
     const metadata = YIELDSEEKER_ASSET_METADATA[context.asset];
     const unavailable = () => new OwneyError(
       "WITHDRAW_BALANCE_UNAVAILABLE",
@@ -6174,12 +6544,12 @@ var YieldseekerAgent = class {
       { asset: context.asset, reason: "YIELDSEEKER_LIQUIDITY_UNVERIFIED" },
       this.id
     );
-    let active = true;
+    let active2 = true;
     let knownProof;
-    const hasUnverifiedIndexedFunds = (proof) => proof.indexedPositions.some((position2) => !proof.verifiedVaults.includes(position2.yieldOption.address.toLowerCase()) && BigInt(position2.withdrawableAssetsRaw) > 0n);
+    const hasUnverifiedIndexedFunds = (proof) => proof.indexedPositions.some((position2) => !proof.resolvedVaults.includes(position2.vaultOption.address.toLowerCase()) && BigInt(position2.withdrawableAssetsRaw) > 0n);
     const assertReadCurrent = () => {
       this.assertSession(generation, chainId, context.asset);
-      if (!active || this.portfolioVersion(contextKey) !== version) throw unavailable();
+      if (!active2 || (this.liquidityVersions.get(contextKey) ?? 0) !== version) throw unavailable();
     };
     const read2 = async () => {
       const client = this.getReceiptClient();
@@ -6190,11 +6560,10 @@ var YieldseekerAgent = class {
       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);
+        candidates.set(position2.vaultOption.address.toLowerCase(), position2.vaultOption);
+      for (const position2 of indexedPositions) candidates.set(position2.vaultOption.address.toLowerCase(), position2.vaultOption);
       const options = [...candidates.values()];
       if (options.length > YIELDSEEKER_WITHDRAWAL_CANDIDATE_LIMIT) throw unavailable();
-      const checksRead = this.readVaultLiquidity(options, wallet, blockNumber).then((value) => ({ value }), (error) => ({ error }));
       const [idle, feeTracker] = await Promise.all([
         client.readContract({
           address: metadata.address,
@@ -6221,7 +6590,7 @@ var YieldseekerAgent = class {
       });
       if (typeof fees !== "bigint" || fees < 0n) throw unavailable();
       const verified = [];
-      const verifiedVaults = [];
+      const resolvedVaults = [];
       let deployed = 0n;
       const proof = (complete) => ({
         blockNumber,
@@ -6229,53 +6598,102 @@ var YieldseekerAgent = class {
         fees,
         available: idle + deployed > fees ? idle + deployed - fees : 0n,
         positions: [...verified],
-        verifiedVaults: [...verifiedVaults],
+        resolvedVaults: [...resolvedVaults],
         indexedPositions,
         complete
       });
       assertReadCurrent();
       knownProof = proof(false);
       if (requested !== void 0 && knownProof.available >= requested) return knownProof;
-      const collect = (options2, results) => {
+      const indexed = new Map(indexedPositions.map((position2) => [position2.vaultOption.address.toLowerCase(), position2]));
+      const indexedValue = indexedPositions.reduce((sum, position2) => sum + BigInt(position2.withdrawableAssetsRaw), 0n);
+      const missingKnownPosition = previousPositions.some((position2) => !indexed.has(position2.vaultOption.address.toLowerCase()));
+      const unvaluedPosition = indexedPositions.some((position2) => BigInt(position2.assetsRaw) > 0n && BigInt(position2.withdrawableAssetsRaw) === 0n);
+      const indexedAvailable = idle + indexedValue > fees ? idle + indexedValue - fees : 0n;
+      if (indexedValue > 0n && !missingKnownPosition && !unvaluedPosition && (requested === void 0 || indexedAvailable >= requested)) {
+        const known = this.balanceVaults.get(contextKey) ?? /* @__PURE__ */ new Set();
+        for (const position2 of indexedPositions) if (BigInt(position2.withdrawableAssetsRaw) > 0n)
+          known.add(position2.vaultOption.address.toLowerCase());
+        this.balanceVaults.set(contextKey, known);
+        return {
+          blockNumber,
+          idle,
+          fees,
+          available: indexedAvailable,
+          positions: indexedPositions,
+          resolvedVaults: [...indexed.keys()],
+          indexedPositions,
+          complete: true
+        };
+      }
+      const collect = async (options2, results) => {
         assertReadCurrent();
         const known = this.balanceVaults.get(contextKey) ?? /* @__PURE__ */ new Set();
         this.balanceVaults.set(contextKey, known);
-        let valid2 = true;
-        options2.forEach((option, index) => {
-          const group = results.slice(index * 3, index * 3 + 3);
-          const shareProbe = group[1];
-          if (shareProbe?.status === "success" && typeof shareProbe.result === "bigint" && shareProbe.result > 0n)
-            known.add(option.address.toLowerCase());
-          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" || !isAddress4(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,
+        const valid2 = await Promise.all(options2.map(async (option, index) => {
+          const group = results.slice(index * 2, index * 2 + 2);
+          if (group.length !== 2 || group.some((value2) => value2.status !== "success")) return false;
+          const [underlying, shares] = group.map((value2) => value2.result);
+          if (typeof underlying !== "string" || !isAddress4(underlying) || underlying.toLowerCase() !== metadata.address.toLowerCase() || typeof shares !== "bigint" || shares < 0n) return false;
+          if (shares > 0n) known.add(option.address.toLowerCase());
+          const position2 = {
+            vaultOption: option,
             assetsRaw: shares.toString(),
             assetsBase: "0",
             assetsUsd: 0,
-            withdrawableAssetsRaw: withdrawable.toString(),
-            withdrawableAssetsBase: withdrawable.toString()
-          });
-        });
-        return valid2;
+            withdrawableAssetsRaw: "0",
+            withdrawableAssetsBase: "0"
+          };
+          resolvedVaults.push(option.address.toLowerCase());
+          verified.push(position2);
+          knownProof = proof(false);
+          if (shares === 0n) return true;
+          let preview;
+          try {
+            const value2 = await client.readContract({
+              address: getAddress5(option.address),
+              abi: erc4626Abi2,
+              functionName: "previewRedeem",
+              args: [shares],
+              blockNumber
+            });
+            if (typeof value2 === "bigint" && value2 >= 0n) preview = value2;
+          } catch {
+          }
+          assertReadCurrent();
+          let value = preview;
+          if (value === void 0 || value === 0n) {
+            try {
+              const converted = await client.readContract({
+                address: getAddress5(option.address),
+                abi: erc4626Abi2,
+                functionName: "convertToAssets",
+                args: [shares],
+                blockNumber
+              });
+              if (typeof converted === "bigint" && converted >= 0n && (converted > 0n || preview === 0n)) value = converted;
+              else value = void 0;
+            } catch {
+              value = void 0;
+            }
+          }
+          assertReadCurrent();
+          if (value === void 0) return false;
+          position2.withdrawableAssetsRaw = value.toString();
+          position2.withdrawableAssetsBase = value.toString();
+          deployed += value;
+          knownProof = proof(false);
+          return true;
+        }));
+        return valid2.every(Boolean);
       };
-      const checks = await checksRead;
+      const checks = await this.readVaultShares(options, wallet, blockNumber);
       assertReadCurrent();
-      if ("error" in checks) throw checks.error;
-      const allKnownVerified = collect(options, checks.value);
+      const allKnownVerified = await collect(options, checks);
       knownProof = proof(false);
-      const indexed = new Map(indexedPositions.map((position2) => [position2.yieldOption.address.toLowerCase(), position2]));
+      if (requested !== void 0 && knownProof.available >= requested) return knownProof;
       const discrepancy = verified.some((position2) => {
-        const row = indexed.get(position2.yieldOption.address.toLowerCase());
+        const row = indexed.get(position2.vaultOption.address.toLowerCase());
         return row ? BigInt(position2.withdrawableAssetsRaw) < BigInt(row.withdrawableAssetsRaw) : BigInt(position2.assetsRaw) > 0n;
       });
       const typedCoveredByIdle = requested !== void 0 && idle >= requested + fees;
@@ -6284,7 +6702,7 @@ var YieldseekerAgent = class {
         assertReadCurrent();
         return proof(true);
       }
-      const catalog = await this.loadYieldOptions(context.asset).catch(() => void 0);
+      const catalog = await this.loadVaultOptions(context.asset).catch(() => void 0);
       assertReadCurrent();
       const eligible = /* @__PURE__ */ new Map();
       for (const option of catalog ?? []) {
@@ -6293,7 +6711,7 @@ var YieldseekerAgent = class {
       }
       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));
+      const allExtraVerified = await collect(extra, await this.readVaultShares(extra, wallet, blockNumber));
       assertReadCurrent();
       const result = proof(eligible.size > 0 && allKnownVerified && allExtraVerified);
       if (result.available === 0n && !result.complete && !hasUnverifiedIndexedFunds(result)) throw unavailable();
@@ -6310,7 +6728,7 @@ var YieldseekerAgent = class {
       if (error instanceof OwneyError) throw error;
       throw unavailable();
     } finally {
-      active = false;
+      active2 = false;
       if (timer) clearTimeout(timer);
     }
   }
@@ -6324,7 +6742,7 @@ var YieldseekerAgent = class {
       this.balanceContexts.set(read2, { context, generation: this.readGeneration });
       const key2 = this.contextKey(state, chainId, context.asset);
       const known = this.balanceVaults.get(key2) ?? /* @__PURE__ */ new Set();
-      for (const position2 of context.positions) known.add(position2.yieldOption.address.toLowerCase());
+      for (const position2 of context.positions) known.add(position2.vaultOption.address.toLowerCase());
       this.balanceVaults.set(key2, known);
     }
     return balance;
@@ -6363,7 +6781,7 @@ var YieldseekerAgent = class {
     const total = idle + invested > fees ? idle + invested - fees : 0n;
     const displayed = balance.assetBalances?.find((item) => item.chainId === evidence.chainId && item.asset === evidence.token);
     if (!displayed || !evidence.confirmedAmount || !/^\d+$/.test(evidence.confirmedAmount)) return void 0;
-    const amount = parseUnits(displayed.amount, asset.decimals);
+    const amount = parseUnits2(displayed.amount, asset.decimals);
     if (amount < 0n) return void 0;
     const displayUnit = evidence.token === "USDC" ? 5000n : 500000000000n;
     const movementUnit = BigInt(evidence.confirmedAmount) / 1000n;
@@ -6462,13 +6880,13 @@ var YieldseekerAgent = class {
     });
     const catalog = await Promise.all(
       [...new Set(contexts.map((context) => context.asset))].map(
-        (contextAsset) => this.loadYieldOptions(contextAsset)
+        (contextAsset) => this.loadVaultOptions(contextAsset)
       )
     );
     const vaultAddresses = new Set(
       catalog.flat().filter(
-        (yieldOption) => yieldOption.chainId === chainId && isAddress4(yieldOption.address)
-      ).map((yieldOption) => yieldOption.address.toLowerCase())
+        (vaultOption) => vaultOption.chainId === chainId && isAddress4(vaultOption.address)
+      ).map((vaultOption) => vaultOption.address.toLowerCase())
     );
     return mapYieldseekerHistory(contexts, {
       limit: options?.limit ?? 10,
@@ -6493,30 +6911,30 @@ var YieldseekerAgent = class {
     const assets = requested ? [requested] : ["USDC", "WETH"];
     const values = await Promise.all(
       assets.map(async (asset) => {
-        return { asset, yieldOptions: await this.loadYieldOptions(asset) };
+        return { asset, vaultOptions: await this.loadVaultOptions(asset) };
       })
     );
     return mapYieldseekerAgentApy(values, days);
   }
-  async loadYieldOptions(asset) {
-    const cached = this.yieldOptions.get(asset);
+  async loadVaultOptions(asset) {
+    const cached = this.vaultOptions.get(asset);
     if (cached && cached.expiresAt > Date.now()) return cached.value;
-    const pending = this.pendingYieldOptions.get(asset);
+    const pending = this.pendingVaultOptions.get(asset);
     if (pending) return pending;
     const metadata = YIELDSEEKER_ASSET_METADATA[asset];
     const request2 = this.api.request(
-      `/chains/8453/assets/${metadata.address}/yield-options`
+      `/chains/8453/assets/${metadata.address}/vault-options`
     ).then((response) => {
-      if (!Array.isArray(response?.yieldOptions)) {
-        throw this.invalidResponse("yield options");
+      if (!Array.isArray(response?.vaultOptions)) {
+        throw this.invalidResponse("vault options");
       }
-      this.yieldOptions.set(asset, {
-        expiresAt: Date.now() + YIELDSEEKER_YIELD_OPTIONS_CACHE_MS,
-        value: response.yieldOptions
+      this.vaultOptions.set(asset, {
+        expiresAt: Date.now() + YIELDSEEKER_VAULT_OPTIONS_CACHE_MS,
+        value: response.vaultOptions
       });
-      return response.yieldOptions;
-    }).finally(() => this.pendingYieldOptions.delete(asset));
-    this.pendingYieldOptions.set(asset, request2);
+      return response.vaultOptions;
+    }).finally(() => this.pendingVaultOptions.delete(asset));
+    this.pendingVaultOptions.set(asset, request2);
     return request2;
   }
   userKey(state, chainId) {
@@ -6826,9 +7244,10 @@ var YieldseekerAgent = class {
       expectedNetDeposits: BigInt(snapshot.netDepositsBase) + delta
     };
   }
-  advancePortfolioVersion(contextKey) {
+  advancePortfolioVersion(contextKey, { snapshotOnly = false } = {}) {
     const version = this.portfolioVersion(contextKey) + 1;
     this.portfolioVersions.set(contextKey, version);
+    if (!snapshotOnly) this.liquidityVersions.set(contextKey, version);
     this.snapshotFailures.delete(contextKey);
     for (const kind of ["snapshot", "positions", "historic", "actions"]) {
       const key2 = `${kind}:${contextKey}`;
@@ -6876,7 +7295,7 @@ var YieldseekerAgent = class {
     if ((!cached || cached.expiresAt <= Date.now()) && !this.pendingReads.has(key2)) {
       const failure = this.snapshotFailures.get(contextKey);
       if (failure && failure.retryAt > Date.now()) throw failure.error;
-      this.advancePortfolioVersion(contextKey);
+      this.advancePortfolioVersion(contextKey, { snapshotOnly: true });
     }
     const version = this.portfolioVersion(contextKey);
     const generation = this.readGeneration;
@@ -6959,17 +7378,17 @@ var YieldseekerAgent = class {
   }
   async loadPortfolioParts(state, chainId, context, options, contextKey) {
     const [positions, historic, actions] = await Promise.all([
-      options.includePositions === false ? Promise.resolve({ yieldPositions: [] }) : this.cachedRead(
+      options.includePositions === false ? Promise.resolve({ vaultPositions: [] }) : this.cachedRead(
         `positions:${contextKey}`,
         this.portfolioCacheMs(contextKey),
         async () => {
           const response = await this.walletRequest(
             state,
             chainId,
-            this.agentPath(context, "yield-positions")
+            this.agentPath(context, "vault-positions")
           );
-          if (!Array.isArray(response?.yieldPositions)) {
-            throw this.invalidResponse("yield positions");
+          if (!Array.isArray(response?.vaultPositions)) {
+            throw this.invalidResponse("vault positions");
           }
           return response;
         }
@@ -6994,7 +7413,7 @@ var YieldseekerAgent = class {
       ) : Promise.resolve(void 0)
     ]);
     return {
-      positions: positions.yieldPositions,
+      positions: positions.vaultPositions,
       ...historic?.position ? { historic: historic.position } : {},
       ...actions?.actions ? { actions: actions.actions } : {}
     };
@@ -7065,10 +7484,10 @@ var YieldseekerAgent = class {
   }
   async providerRequest(state, chainId, path, options = {}) {
     this.assertChain(chainId);
-    const request2 = (signature2) => this.api.request(path, {
-      ...options,
-      signature: signature2
-    });
+    const request2 = (signature2) => {
+      options.assertCurrent?.();
+      return this.api.request(path, { method: options.method, body: options.body, signature: signature2 });
+    };
     let signature = await this.auth.getToken(state, chainId);
     try {
       return await request2(signature);
@@ -7370,45 +7789,57 @@ async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL2) {
 // src/lib/swap/swap-api.ts
 async function request(baseUrl, apiKey, path, init) {
   const url = `${baseUrl}/api/v1/swap${path}`;
-  const res = await fetch(url, {
-    method: init?.method ?? "GET",
-    headers: {
-      "Content-Type": "application/json",
-      "x-owney-api-key": apiKey
-    },
-    ...init ? { body: JSON.stringify(init.body) } : {}
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    if (res.status === 429) {
-      throw new OwneyError(
-        "SWAP_RATE_LIMITED",
-        "Swap provider is rate limiting, retry shortly",
-        { statusCode: res.status }
-      );
-    }
-    if (res.status === 403) {
-      throw new OwneyError(
-        "SWAP_DISABLED",
-        "Swap is not enabled for this organization",
-        { statusCode: res.status }
-      );
-    }
-    throw new OwneyError(
-      "SWAP_REQUEST_FAILED",
-      `Swap API error ${res.status}: ${text}`,
-      { statusCode: res.status, responseBody: text }
-    );
-  }
-  const json = await res.json();
-  if (!json.success) {
-    throw new OwneyError(
+  const controller = new AbortController();
+  try {
+    return await bounded(async () => {
+      const res = await fetch(url, {
+        signal: controller.signal,
+        method: init?.method ?? "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "x-owney-api-key": apiKey
+        },
+        ...init ? { body: JSON.stringify(init.body) } : {}
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        if (res.status === 429) {
+          throw new OwneyError(
+            "SWAP_RATE_LIMITED",
+            "Swap provider is rate limiting, retry shortly",
+            { statusCode: res.status }
+          );
+        }
+        if (res.status === 403) {
+          throw new OwneyError(
+            "SWAP_DISABLED",
+            "Swap is not enabled for this organization",
+            { statusCode: res.status }
+          );
+        }
+        throw new OwneyError(
+          "SWAP_REQUEST_FAILED",
+          `Swap API error ${res.status}: ${text}`,
+          { statusCode: res.status, responseBody: text }
+        );
+      }
+      const json = await res.json();
+      if (!json.success) {
+        throw new OwneyError(
+          "SWAP_REQUEST_FAILED",
+          `Swap API request failed: ${json.message ?? "unknown error"}`,
+          { message: json.message }
+        );
+      }
+      return json.data;
+    }, 2e4, () => new OwneyError(
       "SWAP_REQUEST_FAILED",
-      `Swap API request failed: ${json.message ?? "unknown error"}`,
-      { message: json.message }
-    );
+      "Swap request timed out. Its outcome may still need confirmation.",
+      { requestTimedOut: true, phase: path === "/order" ? "submit" : "read" }
+    ));
+  } finally {
+    controller.abort();
   }
-  return json.data;
 }
 function createSwapApi(baseUrl, apiKey) {
   return {
@@ -7714,8 +8145,12 @@ async function awaitBalanceIncrease(options) {
   let lastError;
   for (; ; ) {
     try {
-      const balance = await readBalance();
-      if (balance > baseline) {
+      const balance = await bounded(
+        readBalance,
+        Math.max(1, Math.min(1e4, deadline - Date.now())),
+        () => new Error("Balance observation timed out")
+      );
+      if (Date.now() <= deadline && balance > baseline) {
         const arrived = balance - baseline;
         debugLog("owney-sdk", "arrival: funds landed", {
           arrived: arrived.toString()
@@ -7741,7 +8176,7 @@ async function awaitBalanceIncrease(options) {
         lastReadError: lastError instanceof Error ? lastError.message : String(lastError)
       } : { arrived: null };
     }
-    await sleep(pollMs);
+    await sleep(Math.min(pollMs, Math.max(0, deadline - Date.now())));
   }
 }
 
@@ -7794,7 +8229,7 @@ var DEFAULT_POLL_MS2 = 5e3;
 var MAX_BACKOFF_MS = 3e4;
 var backoffFor = (failures, base7) => Math.min(base7 * 2 ** Math.min(failures, 5), MAX_BACKOFF_MS);
 var DEFAULT_TIMEOUT_MS2 = 15 * 60 * 1e3;
-async function runFusionOrder(deps, options) {
+async function runFusionOrderInternal(deps, options) {
   const {
     orderHash,
     secrets,
@@ -7803,39 +8238,51 @@ async function runFusionOrder(deps, options) {
     timeoutMs = DEFAULT_TIMEOUT_MS2
   } = options;
   const deadline = deps.now() + timeoutMs;
+  let partial = options.hasPartialFill === true;
+  const timeout = () => new OwneyError(
+    "SWAP_REQUEST_FAILED",
+    "Swap settlement is not confirmed yet. Check its status before starting another swap.",
+    { orderHash, settlementUnconfirmed: true, outcome: partial ? "partially-filled" : "submitted-unknown" }
+  );
+  const assertTime = () => {
+    if (deps.now() >= deadline) throw timeout();
+  };
+  const read2 = async (work) => {
+    assertTime();
+    const result = await bounded(work, Math.min(1e4, deadline - deps.now()), timeout);
+    assertTime();
+    return result;
+  };
+  const pause = async (ms) => {
+    assertTime();
+    await bounded(() => deps.sleep(Math.min(ms, deadline - deps.now())), deadline - deps.now(), timeout);
+    assertTime();
+  };
   let failures = 0;
   const published = /* @__PURE__ */ new Set();
   onStage?.("swapping");
   for (; ; ) {
-    if (deps.now() >= deadline) {
-      throw new OwneyError(
-        "SWAP_REQUEST_FAILED",
-        "Timed out waiting for the swap to settle. It may still complete \u2014 check the order status before retrying.",
-        // Marks the one failure that means "we stopped watching a live order",
-        // as opposed to a verdict or a prompt nobody answered. The executor
-        // checks the wallet before believing it: resolvers do not stop filling
-        // because we stopped looking (ROUT-242, comment 15980).
-        { orderHash, settlementUnconfirmed: true }
-      );
-    }
+    assertTime();
     let ready;
     try {
-      ready = await deps.readyForSecrets(orderHash);
+      ready = await read2(() => deps.readyForSecrets(orderHash));
     } catch {
       ready = {};
     }
+    assertTime();
     for (const fill of ready.fills ?? []) {
+      assertTime();
       if (published.has(fill.idx)) continue;
       const secret = secrets[fill.idx];
       if (secret === void 0) {
         throw new OwneyError(
           "SWAP_REQUEST_FAILED",
           `Swap needs a secret for fill ${fill.idx} that this session does not have. The order will refund once its timelock expires.`,
-          { orderHash, fillIndex: fill.idx }
+          { orderHash, fillIndex: fill.idx, settlementUnconfirmed: true, outcome: "submitted-unknown" }
         );
       }
       try {
-        await deps.submitSecret(orderHash, secret);
+        await read2(() => deps.submitSecret(orderHash, secret));
         published.add(fill.idx);
       } catch {
         failures += 1;
@@ -7843,29 +8290,34 @@ async function runFusionOrder(deps, options) {
     }
     let status;
     try {
-      ({ status } = await deps.orderStatus(orderHash));
+      const state = await read2(() => deps.orderStatus(orderHash));
+      status = state.status;
+      partial ||= status === "partially-filled" || !!state.fills?.length;
       failures = 0;
     } catch {
       failures += 1;
-      await deps.sleep(backoffFor(failures, pollIntervalMs));
+      await pause(backoffFor(failures, pollIntervalMs));
       continue;
     }
     if (status === "refunding") onStage?.("refunding");
     if (isSwapTerminal(status)) {
-      if (status === "executed") {
+      if (status === "executed" || status === "filled") {
         onStage?.("swapped");
         return { status, filled: true };
       }
-      if (status === "refunded") onStage?.("refunded");
+      if (status === "refunded") onStage?.(partial ? "swap-partial" : "refunded");
       throw new OwneyError(
         status === "refunded" ? "SWAP_ORDER_REFUNDED" : status === "cancelled" ? "SWAP_ORDER_CANCELLED" : "SWAP_ORDER_EXPIRED",
-        status === "refunded" ? "The swap did not complete and your funds have been returned." : "The swap did not complete in time. Your funds will be returned once the timelock expires.",
-        { orderHash, status }
+        partial ? "The swap filled partly. Check the order and both balances before retrying." : status === "refunded" ? "The swap did not complete and your funds have been returned." : "The swap did not complete in time. Your funds will be returned once the timelock expires.",
+        { orderHash, status, outcome: status === "refunded" && !partial ? "refunded" : partial ? "partially-filled" : "refund-pending" }
       );
     }
-    await deps.sleep(pollIntervalMs);
+    await pause(pollIntervalMs);
   }
 }
+function runFusionOrder(deps, options) {
+  return observeOrder(options.orderHash, () => runFusionOrderInternal(deps, options));
+}
 
 // src/lib/swap/swap.same-chain-runner.ts
 var DEFAULT_POLL_MS3 = 5e3;
@@ -7890,7 +8342,7 @@ function explain(status) {
       return "The swap did not complete. Nothing was exchanged.";
   }
 }
-async function runSameChainOrder(deps, options) {
+async function runSameChainOrderInternal(deps, options) {
   const {
     orderHash,
     onStage,
@@ -7898,23 +8350,39 @@ async function runSameChainOrder(deps, options) {
     timeoutMs = DEFAULT_TIMEOUT_MS3
   } = options;
   const deadline = deps.now() + timeoutMs;
+  let partial = options.hasPartialFill === true;
+  const timeout = () => new OwneyError(
+    "SWAP_REQUEST_FAILED",
+    "Swap settlement is not confirmed yet. Check its status before starting another swap.",
+    { orderHash, settlementUnconfirmed: true, outcome: partial ? "partially-filled" : "submitted-unknown" }
+  );
+  const assertTime = () => {
+    if (deps.now() >= deadline) throw timeout();
+  };
+  const read2 = async (work) => {
+    assertTime();
+    const result = await bounded(work, Math.min(1e4, deadline - deps.now()), timeout);
+    assertTime();
+    return result;
+  };
+  const pause = async (ms) => {
+    assertTime();
+    await bounded(() => deps.sleep(Math.min(ms, deadline - deps.now())), deadline - deps.now(), timeout);
+    assertTime();
+  };
   let failures = 0;
   onStage?.("swapping");
   for (; ; ) {
-    if (deps.now() >= deadline) {
-      throw new OwneyError(
-        "SWAP_ORDER_EXPIRED",
-        "No one filled the swap in time. Nothing was exchanged and your funds are still in your wallet.",
-        { orderHash }
-      );
-    }
+    assertTime();
     let status;
     try {
-      ({ status } = await deps.orderStatus(orderHash));
+      const state = await read2(() => deps.orderStatus(orderHash));
+      status = state.status;
+      partial ||= status === "partially-filled" || !!state.fills?.length;
       failures = 0;
     } catch {
       failures += 1;
-      await deps.sleep(backoffFor2(failures, pollIntervalMs));
+      await pause(backoffFor2(failures, pollIntervalMs));
       continue;
     }
     if (isSwapTerminal(status)) {
@@ -7924,17 +8392,19 @@ async function runSameChainOrder(deps, options) {
       }
       throw new OwneyError(
         status === "cancelled" ? "SWAP_ORDER_CANCELLED" : "SWAP_ORDER_EXPIRED",
-        explain(status),
-        { orderHash, status }
+        partial ? "The swap filled partly. Check the order and both balances before retrying." : explain(status),
+        { orderHash, status, outcome: partial ? "partially-filled" : "not-submitted" }
       );
     }
-    await deps.sleep(pollIntervalMs);
+    await pause(pollIntervalMs);
   }
 }
+function runSameChainOrder(deps, options) {
+  return observeOrder(options.orderHash, () => runSameChainOrderInternal(deps, options));
+}
 
 // src/lib/swap/swap.secret-store.ts
 var KEY_PREFIX4 = "owney.swap.order";
-var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var storage4 = () => {
   if (typeof window === "undefined") return null;
   try {
@@ -7946,10 +8416,13 @@ var storage4 = () => {
 var keyFor2 = (orderHash) => `${KEY_PREFIX4}.${orderHash}`;
 function saveOrder(order) {
   const store = storage4();
-  if (!store) return;
+  if (!store) return false;
   try {
-    store.setItem(keyFor2(order.orderHash), JSON.stringify(order));
+    const value = JSON.stringify(order);
+    store.setItem(keyFor2(order.orderHash), value);
+    return store.getItem(keyFor2(order.orderHash)) === value;
   } catch {
+    return false;
   }
 }
 function clearOrder(orderHash) {
@@ -7960,7 +8433,7 @@ function clearOrder(orderHash) {
   } catch {
   }
 }
-function listOrders(now = Date.now()) {
+function listOrders(_now = Date.now()) {
   const store = storage4();
   if (!store) return [];
   const out = [];
@@ -7975,10 +8448,6 @@ function listOrders(now = Date.now()) {
       if (!raw2) continue;
       try {
         const parsed = JSON.parse(raw2);
-        if (now - parsed.createdAt > MAX_AGE_MS) {
-          store.removeItem(key2);
-          continue;
-        }
         if (Array.isArray(parsed.secrets) && parsed.secrets.length > 0) {
           out.push(parsed);
         }
@@ -8019,12 +8488,11 @@ async function awaitWalletPrompt(prompt, what) {
     if (timer) clearTimeout(timer);
   }
 }
-function stoppedWatching(error) {
-  return error instanceof OwneyError && error.details?.settlementUnconfirmed === true;
-}
 var DEFAULT_SLIPPAGE = 1;
-async function affordableAmount(deps, quoted) {
-  const balance = await deps.readSourceBalance();
+async function affordableAmount(deps, quoted, reserve = 0n) {
+  const raw2 = await deps.readSourceBalance();
+  const balance = raw2 > reserve ? raw2 - reserve : 0n;
+  if (balance <= 0n) throw new OwneyError("SWAP_REQUEST_FAILED", "No spendable source funds remain for this swap.", { outcome: "not-submitted" });
   if (balance >= quoted) return quoted;
   debugLog("owney-sdk", "swap: trimming to the current source balance", {
     quoted: quoted.toString(),
@@ -8035,48 +8503,72 @@ async function affordableAmount(deps, quoted) {
 }
 async function executeSwap(deps, options) {
   const { quote, walletAddress, onStage } = options;
-  debugLog("owney-sdk", "swap: start", {
-    rail: quote.rail,
-    from: `${quote.src.amount} ${quote.src.symbol} on ${quote.src.chainId}`,
-    to: `${quote.dst.symbol} on ${quote.dst.chainId}`,
-    expected: quote.dst.amount,
-    floor: quote.dstAmountMin
-  });
-  const before = await deps.readTargetBalance();
-  debugLog("owney-sdk", "swap: target balance before", before.toString());
-  let result;
-  let railError;
+  let active2 = true;
+  const original = deps;
+  const assertActive = () => {
+    if (!active2) throw new OwneyError("SWAP_REQUEST_FAILED", "This swap attempt is no longer active.");
+  };
+  const call = async (work, write = false) => {
+    assertActive();
+    if (write) options.assertCurrent?.();
+    const value = await bounded(
+      work,
+      write ? 3e5 : 2e4,
+      () => new OwneyError(
+        "SWAP_REQUEST_FAILED",
+        "The swap step could not be confirmed. Check its status before retrying.",
+        { settlementUnconfirmed: write, outcome: write ? "submitted-unknown" : "not-submitted" }
+      )
+    );
+    assertActive();
+    if (write) options.assertCurrent?.();
+    return value;
+  };
+  deps = {
+    ...original,
+    api: {
+      ...original.api,
+      buildOrder: (args) => call(() => original.api.buildOrder(args)),
+      swapTx: (args) => call(() => original.api.swapTx(args)),
+      submitOrder: (args) => call(() => original.api.submitOrder(args), true)
+    },
+    readTargetBalance: () => call(original.readTargetBalance),
+    readSourceBalance: () => call(original.readSourceBalance),
+    readAllowance: (spender) => call(() => original.readAllowance(spender)),
+    ensureChain: (chain2) => call(() => original.ensureChain(chain2), true),
+    approve: (spender, amount) => call(() => original.approve(spender, amount), true),
+    sendTransaction: (tx) => call(() => original.sendTransaction(tx), true),
+    signTypedData: (data) => call(() => original.signTypedData(data), true),
+    ...original.buildPermit ? { buildPermit: (spender, amount) => call(() => original.buildPermit(spender, amount), true) } : {}
+  };
   try {
-    result = quote.rail === "classic" ? await runClassic(deps, options) : quote.rail === "fusion" ? await runSameChainFusion(deps, options, walletAddress) : await runFusion(deps, options, walletAddress);
-  } catch (error) {
-    if (!stoppedWatching(error)) throw error;
-    railError = error;
-    debugLog("owney-sdk", "swap: rail failed, checking whether funds landed", {
-      message: error instanceof Error ? error.message : String(error)
+    debugLog("owney-sdk", "swap: start", {
+      rail: quote.rail,
+      from: `${quote.src.amount} ${quote.src.symbol} on ${quote.src.chainId}`,
+      to: `${quote.dst.symbol} on ${quote.dst.chainId}`,
+      expected: quote.dst.amount,
+      floor: quote.dstAmountMin
     });
-  }
-  const { arrived } = await awaitBalanceIncrease({
-    readBalance: () => deps.readTargetBalance(),
-    baseline: before,
-    ...options.arrivalTimeoutMs === void 0 ? {} : { timeoutMs: options.arrivalTimeoutMs },
-    ...options.arrivalPollMs === void 0 ? {} : { pollMs: options.arrivalPollMs }
-  });
-  if (arrived === null) {
-    if (railError) throw railError;
-    throw new OwneyError(
-      "SWAP_REQUEST_FAILED",
-      "The swap completed but no funds arrived in the wallet. Check the transaction before retrying.",
-      { rail: quote.rail, ...result ?? {} }
-    );
-  }
-  if (railError) {
-    debugLog("owney-sdk", "swap: rail gave up but the funds are here", {
-      received: arrived.toString()
+    const before = await deps.readTargetBalance();
+    debugLog("owney-sdk", "swap: target balance before", before.toString());
+    const result = quote.rail === "classic" ? await runClassic(deps, options) : quote.rail === "fusion" ? await runSameChainFusion(deps, options, walletAddress) : await runFusion(deps, options, walletAddress);
+    const { arrived } = await awaitBalanceIncrease({
+      readBalance: () => deps.readTargetBalance(),
+      baseline: before,
+      ...options.arrivalTimeoutMs === void 0 ? {} : { timeoutMs: options.arrivalTimeoutMs },
+      ...options.arrivalPollMs === void 0 ? {} : { pollMs: options.arrivalPollMs }
     });
-    const orderHash = railError.details?.orderHash;
-    if (orderHash) clearOrder(orderHash);
+    if (arrived === null) {
+      throw new OwneyError(
+        "SWAP_REQUEST_FAILED",
+        "The swap completed but no funds arrived in the wallet. Check the transaction before retrying.",
+        { rail: quote.rail, ...result, outcome: "filled", settlementUnconfirmed: true }
+      );
+    }
+    return { received: arrived.toString(), ...result };
+  } finally {
+    active2 = false;
   }
-  return { received: arrived.toString(), ...result ?? {} };
 }
 async function runClassic(deps, options) {
   const {
@@ -8087,7 +8579,7 @@ async function runClassic(deps, options) {
     onStage
   } = options;
   const isNativeSource = quote.src.address.toLowerCase().startsWith("0xeeee");
-  const amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount));
+  let amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount), options.sourceReserve);
   const swapTxRequest = {
     from: {
       chainId: quote.src.chainId,
@@ -8119,25 +8611,36 @@ async function runClassic(deps, options) {
         "owney-sdk",
         "swap: re-fetching classic calldata after approval"
       );
+      amount = await affordableAmount(deps, amount, options.sourceReserve);
+      swapTxRequest.from.amount = amount.toString();
       ({ tx } = await deps.api.swapTx(swapTxRequest));
+      if (await deps.readAllowance(tx.to) < amount)
+        throw new OwneyError("SWAP_REQUEST_FAILED", "Swap approval was not confirmed for the current spender.", { outcome: "not-submitted" });
     }
   }
   onStage?.("signing");
   await deps.ensureChain(quote.src.chainId);
   debugLog("owney-sdk", "swap: sending classic swap tx", { to: tx.to });
+  options.assertCurrent?.();
+  options.onTransactionRequested?.();
   const txHash = await deps.sendTransaction({
     to: tx.to,
     data: tx.data,
     value: tx.value ?? "0"
+  }).catch((error) => {
+    if (error?.code === 4001 || error?.code === "ACTION_REJECTED")
+      throw new OwneyError("SWAP_REQUEST_FAILED", "The swap transaction was rejected in the wallet.", { outcome: "not-submitted" });
+    throw error;
   });
   onStage?.("swapped");
-  return { txHash };
+  return { txHash, spent: amount.toString() };
 }
 async function runSameChainFusion(deps, options, walletAddress) {
   const { quote, direction, onStage } = options;
   const isNativeSource = quote.src.address.toLowerCase().startsWith("0xeeee");
-  const amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount));
-  const permit = await authoriseSpend(deps, options, amount, isNativeSource);
+  let amount = isNativeSource ? BigInt(quote.src.amount) : await affordableAmount(deps, BigInt(quote.src.amount), options.sourceReserve);
+  const { permit, paid } = await authoriseSpend(deps, options, amount, isNativeSource);
+  amount = await authorisedAmount(deps, options, amount, paid);
   onStage?.("building");
   debugLog("owney-sdk", "swap: building same-chain fusion order");
   const built = await deps.api.buildOrder({
@@ -8161,36 +8664,42 @@ async function runSameChainFusion(deps, options, walletAddress) {
     "sign the swap"
   );
   debugLog("owney-sdk", "swap: signed, submitting same-chain order");
-  await deps.api.submitOrder({
-    // Without this the routing API hands the order to the Fusion+ relayer,
-    // which does not know it and answers with an error that names nothing.
-    rail: "fusion",
-    srcChainId: quote.src.chainId,
-    order: built.order,
-    signature,
-    quoteId: built.quoteId,
-    ...built.extension ? { extension: built.extension } : {}
-  });
+  options.assertCurrent?.();
+  options.onOrderPrepared?.(built.orderHash, { spent: amount.toString(), expected: built.dstAmount });
+  try {
+    await deps.api.submitOrder({
+      // Without this the routing API hands the order to the Fusion+ relayer,
+      // which does not know it and answers with an error that names nothing.
+      rail: "fusion",
+      srcChainId: quote.src.chainId,
+      order: built.order,
+      signature,
+      quoteId: built.quoteId,
+      ...built.extension ? { extension: built.extension } : {}
+    });
+  } catch (error) {
+    throw submissionUnknown(error, built.orderHash);
+  }
   try {
-    options.onOrderSubmitted?.(built.orderHash);
+    options.onOrderSubmitted?.(built.orderHash, { spent: amount.toString(), expected: built.dstAmount, durable: true });
   } catch {
   }
   await runSameChainOrder(deps.sameChainRunner ?? deps.runner, {
     orderHash: built.orderHash,
     ...onStage ? { onStage } : {}
   });
-  return { orderHash: built.orderHash };
+  return { orderHash: built.orderHash, spent: amount.toString() };
 }
 async function authoriseSpend(deps, options, amount, isNativeSource) {
   const { quote, onStage } = options;
-  if (!quote.spender || isNativeSource) return void 0;
+  if (!quote.spender || isNativeSource) return { paid: false };
   const current = await deps.readAllowance(quote.spender);
   debugLog("owney-sdk", "swap: fusion allowance", {
     spender: quote.spender,
     current: current.toString(),
     needed: amount.toString()
   });
-  if (current >= amount) return void 0;
+  if (current >= amount) return { paid: false };
   onStage?.("approving");
   await deps.ensureChain(quote.src.chainId);
   const permit = quote.permitSupported ? await awaitWalletPrompt(
@@ -8201,11 +8710,18 @@ async function authoriseSpend(deps, options, amount, isNativeSource) {
     debugLog("owney-sdk", "swap: permitting limit order protocol", {
       bytes: (permit.length - 2) / 2
     });
-    return permit;
+    return { permit, paid: false };
   }
   await deps.approve(quote.spender, MAX_UINT256);
   debugLog("owney-sdk", "swap: approved limit order protocol");
-  return void 0;
+  return { paid: true };
+}
+async function authorisedAmount(deps, options, amount, paid) {
+  if (!paid) return amount;
+  const remaining = await affordableAmount(deps, amount, options.sourceReserve);
+  if (!options.quote.spender || await deps.readAllowance(options.quote.spender) < remaining)
+    throw new OwneyError("SWAP_REQUEST_FAILED", "Swap approval was not confirmed.", { outcome: "not-submitted" });
+  return remaining;
 }
 async function runFusion(deps, options, walletAddress) {
   const { quote, direction, onStage } = options;
@@ -8217,8 +8733,9 @@ async function runFusion(deps, options, walletAddress) {
       { chainId: quote.src.chainId, symbol: quote.src.symbol }
     );
   }
-  const amount = await affordableAmount(deps, BigInt(quote.src.amount));
-  const permit = await authoriseSpend(deps, options, amount, false);
+  let amount = await affordableAmount(deps, BigInt(quote.src.amount), options.sourceReserve);
+  const { permit, paid } = await authoriseSpend(deps, options, amount, false);
+  amount = await authorisedAmount(deps, options, amount, paid);
   const { secrets, secretHashes } = mintSecrets(quote.secretsCount ?? 1);
   onStage?.("building");
   debugLog("owney-sdk", "swap: building fusion order", {
@@ -8237,8 +8754,9 @@ async function runFusion(deps, options, walletAddress) {
     ...direction ? { direction } : {},
     ...permit ? { permit } : {}
   });
-  saveOrder({
+  const durable = saveOrder({
     orderHash: built.orderHash,
+    walletAddress,
     secrets,
     srcChainId: quote.src.chainId,
     srcSymbol: quote.src.symbol,
@@ -8248,33 +8766,39 @@ async function runFusion(deps, options, walletAddress) {
     createdAt: Date.now()
   });
   debugLog("owney-sdk", "swap: order built", { orderHash: built.orderHash });
-  onStage?.("signing");
-  await deps.ensureChain(quote.src.chainId);
-  debugLog("owney-sdk", "swap: awaiting signature in wallet", {
-    signingOnChain: quote.src.chainId
-  });
-  const signature = await awaitWalletPrompt(
-    () => deps.signTypedData(built.typedData),
-    "sign the swap"
-  );
+  let signature;
+  try {
+    onStage?.("signing");
+    await deps.ensureChain(quote.src.chainId);
+    signature = await awaitWalletPrompt(() => deps.signTypedData(built.typedData), "sign the swap");
+    options.assertCurrent?.();
+    options.onOrderPrepared?.(built.orderHash, { spent: amount.toString(), expected: built.dstAmount });
+  } catch (error) {
+    clearOrder(built.orderHash);
+    throw error;
+  }
   debugLog("owney-sdk", "swap: signed, submitting to relayer");
-  await deps.api.submitOrder({
-    srcChainId: quote.src.chainId,
-    // The ORDER STRUCT, not the typed-data envelope we just signed. Sending
-    // the envelope here gets a bare 500 from the relayer.
-    order: built.order,
-    signature,
-    quoteId: built.quoteId,
-    // Single-fill orders must NOT carry secretHashes — the relayer rejects
-    // them with SECRET_HASHES_NOT_REQUIRED. The one hash is already inside the
-    // order's hashlock, so repeating it here is redundant, and only a
-    // multi-fill order (a Merkle tree of hashes) needs them listed.
-    ...secretHashes.length > 1 ? { secretHashes } : {},
-    ...built.extension ? { extension: built.extension } : {}
-  });
+  try {
+    await deps.api.submitOrder({
+      srcChainId: quote.src.chainId,
+      // The ORDER STRUCT, not the typed-data envelope we just signed. Sending
+      // the envelope here gets a bare 500 from the relayer.
+      order: built.order,
+      signature,
+      quoteId: built.quoteId,
+      // Single-fill orders must NOT carry secretHashes — the relayer rejects
+      // them with SECRET_HASHES_NOT_REQUIRED. The one hash is already inside the
+      // order's hashlock, so repeating it here is redundant, and only a
+      // multi-fill order (a Merkle tree of hashes) needs them listed.
+      ...secretHashes.length > 1 ? { secretHashes } : {},
+      ...built.extension ? { extension: built.extension } : {}
+    });
+  } catch (error) {
+    throw submissionUnknown(error, built.orderHash);
+  }
   debugLog("owney-sdk", "swap: order submitted, polling escrows");
   try {
-    options.onOrderSubmitted?.(built.orderHash);
+    options.onOrderSubmitted?.(built.orderHash, { spent: amount.toString(), expected: built.dstAmount, durable });
   } catch {
   }
   try {
@@ -8284,13 +8808,25 @@ async function runFusion(deps, options, walletAddress) {
       ...onStage ? { onStage } : {}
     });
   } catch (error) {
-    if (error instanceof OwneyError && (error.code === "SWAP_ORDER_REFUNDED" || error.code === "SWAP_ORDER_CANCELLED")) {
+    if (error instanceof OwneyError && error.code === "SWAP_ORDER_REFUNDED" && error.details?.outcome === "refunded") {
       clearOrder(built.orderHash);
     }
     throw error;
   }
   clearOrder(built.orderHash);
-  return { orderHash: built.orderHash };
+  return { orderHash: built.orderHash, spent: amount.toString() };
+}
+function submissionUnknown(error, orderHash) {
+  return new OwneyError(
+    "SWAP_REQUEST_FAILED",
+    "The order submission could not be confirmed. Check this order before starting another swap.",
+    {
+      orderHash,
+      settlementUnconfirmed: true,
+      outcome: "submitted-unknown",
+      ...error instanceof OwneyError ? { causeCode: error.code } : {}
+    }
+  );
 }
 
 // src/lib/swap/swap.withdrawal-settlement.ts
@@ -8300,8 +8836,8 @@ var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function awaitWithdrawalPayouts(options) {
   const payouts = new Map(Object.entries(options.results).map(([id, result]) => [id, { result, evidence: result.evidence }]));
   const timeoutMs = Math.max(0, options.timeoutMs ?? 18e4);
-  const deadline = Date.now() + timeoutMs;
-  let active = true;
+  const deadline = options.deadline ?? Date.now() + timeoutMs;
+  let active2 = true;
   let timer;
   const incomplete = (reason, agentId) => new OwneyError(
     "WITHDRAW_SWAP_INCOMPLETE",
@@ -8319,7 +8855,7 @@ async function awaitWithdrawalPayouts(options) {
   );
   const assertActive = () => {
     options.assertCurrent();
-    if (!active || Date.now() > deadline) throw incomplete("PAYOUT_CONFIRMATION_TIMEOUT");
+    if (!active2 || Date.now() > deadline) throw incomplete("PAYOUT_CONFIRMATION_TIMEOUT");
   };
   const pause = async () => {
     assertActive();
@@ -8330,10 +8866,11 @@ async function awaitWithdrawalPayouts(options) {
     if (evidence.agentId !== id || evidence.chainId !== options.chainId || evidence.token !== options.token || evidence.walletAddress.toLowerCase() !== options.walletAddress.toLowerCase())
       throw incomplete("PAYOUT_SCOPE_MISMATCH", id);
   };
-  const record = (id, payout, evidence) => {
+  const record2 = (id, payout, evidence) => {
     assertActive();
     validate(id, evidence);
     payout.evidence = evidence;
+    payout.result.evidence = evidence;
     if (evidence.transfer === "confirmed" && evidence.delivery === "confirmed") payout.amount = rawAmount(evidence.confirmedAmount);
     options.onProgress(evidence);
   };
@@ -8398,8 +8935,30 @@ async function awaitWithdrawalPayouts(options) {
         if (payout.amount === void 0 || payout.amount <= 0n) throw incomplete("INVALID_PAYOUT_AMOUNT", id);
         if (["yieldseeker", "zyfai"].includes(id) && (!hash(evidence.txHash) || rawAmount(evidence.blockNumber) === void 0 || !evidence.logIndexes?.length))
           throw incomplete("PAYOUT_RECEIPT_UNVERIFIED", id);
-        if (options.requested === void 0 && payout.result.completion === "unverified")
-          throw incomplete("MAX_COMPLETION_UNVERIFIED", id);
+        if (options.requested === void 0 && payout.result.completion === "unverified") {
+          if (!options.verifyCompletion || id === "yieldseeker" && !evidence.maxCompletion)
+            throw incomplete("MAX_COMPLETION_UNVERIFIED", id);
+          let proof = { status: "unavailable" };
+          try {
+            proof = await bounded(
+              () => options.verifyCompletion(evidence),
+              Math.min(1e4, deadline - Date.now()),
+              () => incomplete("MAX_COMPLETION_UNVERIFIED", id)
+            );
+          } catch {
+            assertActive();
+          }
+          assertActive();
+          evidence.maxCompletionCheck = proof;
+          options.onProgress(evidence);
+          if (proof.status === "remaining") throw incomplete("MAX_REMAINDER_VERIFIED", id);
+          if (proof.status !== "complete") {
+            await pause();
+            continue;
+          }
+          payout.result.completion = void 0;
+          payout.result.type = "full";
+        }
         const intended = rawAmount(evidence.intendedAmount);
         if (intended !== void 0 && payout.amount < intended && verifiedFee(payout) !== intended - payout.amount)
           throw incomplete("PAYOUT_SHORTFALL", id);
@@ -8409,24 +8968,24 @@ async function awaitWithdrawalPayouts(options) {
         let next = evidence;
         if (!next.txHash && (next.userOpHash || next.callsId)) {
           next = await options.resolve(next);
-          record(id, payout, next);
+          record2(id, payout, next);
         }
         if (next.transfer === "failed" || next.delivery === "failed") continue;
         if (next.txHash) {
           next = await options.inspect(next, false);
-          record(id, payout, next);
+          record2(id, payout, next);
           if (id === "zyfai" && next.transfer === "unknown" && rawAmount(next.blockNumber) !== void 0 && next.logIndexes?.length === 0 && next.transferLogs?.length === 0 && !next.userOpHash && !next.callsId) {
             const found = await findPayout(id, next);
             if (found) {
               next = found;
-              record(id, payout, next);
+              record2(id, payout, next);
             }
           }
         } else if (!next.userOpHash && !next.callsId) {
           const found = await findPayout(id, next);
           if (found) {
             next = found;
-            record(id, payout, next);
+            record2(id, payout, next);
           }
         }
         if (next.transfer === "confirmed" && next.delivery === "confirmed" || next.transfer === "failed" || next.delivery === "failed") continue;
@@ -8470,10 +9029,10 @@ async function awaitWithdrawalPayouts(options) {
   };
   try {
     return await Promise.race([read2(), new Promise((_, reject) => {
-      timer = setTimeout(() => reject(incomplete("PAYOUT_CONFIRMATION_TIMEOUT")), timeoutMs);
+      timer = setTimeout(() => reject(incomplete("PAYOUT_CONFIRMATION_TIMEOUT")), Math.max(0, deadline - Date.now()));
     })]);
   } finally {
-    active = false;
+    active2 = false;
     if (timer) clearTimeout(timer);
   }
 }
@@ -8494,10 +9053,10 @@ function verifiedFee(payout) {
 import {
   domainSeparator,
   encodeAbiParameters,
-  parseAbi as parseAbi4,
+  parseAbi as parseAbi5,
   parseSignature
 } from "viem";
-var PERMIT_ABI = parseAbi4([
+var PERMIT_ABI = parseAbi5([
   "function nonces(address owner) view returns (uint256)",
   "function name() view returns (string)",
   "function version() view returns (string)",
@@ -8595,7 +9154,7 @@ async function buildErc2612Permit(reads, input) {
 
 // src/lib/swap/swap.withdraw-swap.ts
 var KEY_PREFIX5 = "owney.swap.withdraw";
-var MAX_AGE_MS2 = 24 * 60 * 60 * 1e3;
+var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var storage5 = () => {
   if (typeof window === "undefined") return null;
   try {
@@ -8620,15 +9179,19 @@ var notify = () => {
     }
   }
 };
-function saveWithdrawSwap(record) {
+function saveWithdrawSwap(record2) {
   const store = storage5();
-  if (!store) return;
+  if (!store) return false;
   try {
-    store.setItem(keyFor3(record.orderHash), JSON.stringify(record));
+    const current = store.getItem(keyFor3(record2.orderHash));
+    const value = JSON.stringify({ ...current ? JSON.parse(current) : {}, ...record2 });
+    store.setItem(keyFor3(record2.orderHash), value);
+    if (store.getItem(keyFor3(record2.orderHash)) !== value) return false;
   } catch {
-    return;
+    return false;
   }
   notify();
+  return true;
 }
 function updateWithdrawSwap(orderHash, patch) {
   const store = storage5();
@@ -8651,13 +9214,17 @@ function clearWithdrawSwap(orderHash) {
   const store = storage5();
   if (!store) return;
   try {
-    store.removeItem(keyFor3(orderHash));
+    const raw2 = store.getItem(keyFor3(orderHash));
+    const record2 = raw2 ? JSON.parse(raw2) : void 0;
+    if (record2 && !["landed", "refunded", "not-swapped"].includes(record2.status))
+      store.setItem(keyFor3(orderHash), JSON.stringify({ ...record2, dismissed: true }));
+    else store.removeItem(keyFor3(orderHash));
   } catch {
     return;
   }
   notify();
 }
-function listWithdrawSwaps(now = Date.now()) {
+function listWithdrawSwaps(now = Date.now(), includeDismissed = false) {
   const store = storage5();
   if (!store) return [];
   const out = [];
@@ -8672,11 +9239,11 @@ function listWithdrawSwaps(now = Date.now()) {
       if (!raw2) continue;
       try {
         const parsed = JSON.parse(raw2);
-        if (now - parsed.createdAt > MAX_AGE_MS2) {
+        if (["landed", "refunded", "not-swapped"].includes(parsed.status) && now - (parsed.settledAt ?? parsed.createdAt) > MAX_AGE_MS) {
           store.removeItem(key2);
           continue;
         }
-        out.push(parsed);
+        if (includeDismissed || !parsed.dismissed) out.push(parsed);
       } catch {
         store.removeItem(key2);
       }
@@ -8686,10 +9253,15 @@ function listWithdrawSwaps(now = Date.now()) {
   }
   return out.sort((a, b) => b.createdAt - a.createdAt);
 }
+if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+  window.addEventListener("storage", (event) => {
+    if (event.key === null || event.key.startsWith(`${KEY_PREFIX5}.`)) notify();
+  });
+}
 
 // src/lib/swap/swap.pending-deposit.ts
 var KEY_PREFIX6 = "owney.swap.pending-deposit";
-var MAX_AGE_MS3 = 24 * 60 * 60 * 1e3;
+var MAX_AGE_MS2 = 24 * 60 * 60 * 1e3;
 var storage6 = () => {
   if (typeof window === "undefined") return null;
   try {
@@ -8732,7 +9304,7 @@ function listPendingDeposits(now = Date.now()) {
       if (!raw2) continue;
       try {
         const parsed = JSON.parse(raw2);
-        if (now - parsed.createdAt > MAX_AGE_MS3) {
+        if (now - parsed.createdAt > MAX_AGE_MS2) {
           store.removeItem(key2);
           continue;
         }
@@ -8781,7 +9353,7 @@ async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
 }
 
 // src/lib/helpers/withdraw-helper.ts
-import { parseUnits as parseUnits2 } from "viem";
+import { parseUnits as parseUnits3 } from "viem";
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
   return agents.map((agent) => {
     let invalidBalance = false;
@@ -8791,7 +9363,7 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
         return 0n;
       }
       const [whole, fraction] = value.split(".");
-      return raw2 ? BigInt(value) : parseUnits2(fraction === void 0 ? whole : `${whole}.${fraction.slice(0, decimals)}`, decimals);
+      return raw2 ? BigInt(value) : parseUnits3(fraction === void 0 ? whole : `${whole}.${fraction.slice(0, decimals)}`, decimals);
     };
     const agentBalance = aggregated[agent.id];
     const tokenBalance = agentBalance?.tokens.find(
@@ -8991,11 +9563,11 @@ function aggregateDailyEarnings(series, tokenSymbol) {
   const byAsset = /* @__PURE__ */ new Map();
   for (const account of series) {
     for (const { asset, points } of account.assets) {
-      const symbol = asset.toUpperCase();
-      if (!points.length || wanted && symbol !== wanted) continue;
-      const components = byAsset.get(symbol) ?? [];
+      const symbol2 = asset.toUpperCase();
+      if (!points.length || wanted && symbol2 !== wanted) continue;
+      const components = byAsset.get(symbol2) ?? [];
       components.push([...points].sort((a, b) => a.date.localeCompare(b.date)));
-      byAsset.set(symbol, components);
+      byAsset.set(symbol2, components);
     }
   }
   return [...byAsset.entries()].map(([asset, components]) => {
@@ -9024,7 +9596,7 @@ function aggregateDailyEarnings(series, tokenSymbol) {
 
 // src/client.ts
 import {
-  parseUnits as parseUnits3,
+  parseUnits as parseUnits4,
   createPublicClient as createPublicClient4,
   createWalletClient as createWalletClient5,
   custom as custom5,
@@ -9040,111 +9612,6 @@ import {
   parseTransaction,
   toBytes
 } from "viem";
-
-// src/lib/permit2-batch.ts
-import { parseAbi as parseAbi5, hashStruct } from "viem";
-var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var ERC2612_PERMIT_TYPES = {
-  Permit: [
-    { name: "owner", type: "address" },
-    { name: "spender", type: "address" },
-    { name: "value", type: "uint256" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ]
-};
-var ERC2612_READ_ABI = parseAbi5([
-  "function name() view returns (string)",
-  "function version() view returns (string)",
-  "function nonces(address owner) view returns (uint256)"
-]);
-function erc2612TypedData(input) {
-  return {
-    domain: {
-      name: input.permit.tokenName,
-      version: input.permit.tokenVersion,
-      chainId: input.chainId,
-      verifyingContract: input.token
-    },
-    types: ERC2612_PERMIT_TYPES,
-    primaryType: "Permit",
-    message: {
-      owner: input.owner,
-      spender: BATCH_PERMIT2_ADDRESS,
-      value: BigInt(input.permit.value),
-      nonce: BigInt(input.permit.nonce),
-      deadline: BigInt(input.permit.deadline)
-    }
-  };
-}
-var PERMIT_BATCH_TYPES = {
-  PermitBatchWitnessTransferFrom: [
-    { name: "permitted", type: "TokenPermissions[]" },
-    { name: "spender", type: "address" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" },
-    { name: "witness", type: "Deposit" }
-  ],
-  Deposit: [{ name: "recipients", type: "address[]" }],
-  TokenPermissions: [
-    { name: "token", type: "address" },
-    { name: "amount", type: "uint256" }
-  ]
-};
-var PERMIT2_BATCH_ABI = parseAbi5([
-  "struct TokenPermissions { address token; uint256 amount; }",
-  "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
-  "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
-  "function permitWitnessTransferFrom(PermitBatchTransferFrom permit,SignatureTransferDetails[] transferDetails,address owner,bytes32 witness,string witnessTypeString,bytes signature)",
-  "function nonceBitmap(address owner,uint256 wordPos) view returns (uint256)"
-]);
-function batchPermit(b) {
-  return {
-    permitted: b.transfers.map((t) => ({
-      token: b.token,
-      amount: BigInt(t.amount)
-    })),
-    nonce: BigInt(b.nonce),
-    deadline: BigInt(b.deadline)
-  };
-}
-function batchTypedData(b, spender) {
-  return {
-    domain: {
-      name: "Permit2",
-      chainId: b.chainId,
-      verifyingContract: BATCH_PERMIT2_ADDRESS
-    },
-    types: PERMIT_BATCH_TYPES,
-    primaryType: "PermitBatchWitnessTransferFrom",
-    message: {
-      ...batchPermit(b),
-      spender,
-      witness: { recipients: b.transfers.map((t) => t.to) }
-    }
-  };
-}
-var BATCH_WITNESS_TYPE = "Deposit witness)Deposit(address[] recipients)TokenPermissions(address token,uint256 amount)";
-function batchWitness(b) {
-  return hashStruct({
-    types: PERMIT_BATCH_TYPES,
-    primaryType: "Deposit",
-    data: { recipients: b.transfers.map((t) => t.to) }
-  });
-}
-function batchArgs(b) {
-  return [
-    batchPermit(b),
-    b.transfers.map((t) => ({ to: t.to, requestedAmount: BigInt(t.amount) })),
-    b.from,
-    batchWitness(b),
-    BATCH_WITNESS_TYPE,
-    b.signature
-  ];
-}
-
-// src/lib/sponsored-token-batch.ts
 var memory = /* @__PURE__ */ new Map();
 var settledRecords = /* @__PURE__ */ new Map();
 var expiredRecords = /* @__PURE__ */ new Map();
@@ -9172,14 +9639,14 @@ async function releaseExpiredTokenBatch(i) {
   let timer;
   let expired = false;
   const check = async () => {
-    let active = read(key2);
-    if (active && i.expectedTxHash) {
-      const current = JSON.parse(active);
+    let active2 = read(key2);
+    if (active2 && i.expectedTxHash) {
+      const current = JSON.parse(active2);
       if (!current.serializedTransaction || keccak2562(current.serializedTransaction).toLowerCase() !== i.expectedTxHash.toLowerCase())
-        active = void 0;
+        active2 = void 0;
     }
     const archiveKey = i.expectedTxHash ? `${key2}:expired:${i.expectedTxHash.toLowerCase()}` : void 0;
-    const saved = active ?? (archiveKey && (expiredRecords.get(archiveKey) ?? (typeof window === "undefined" ? void 0 : window.localStorage.getItem(archiveKey))));
+    const saved = active2 ?? (archiveKey && (expiredRecords.get(archiveKey) ?? (typeof window === "undefined" ? void 0 : window.localStorage.getItem(archiveKey))));
     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;
@@ -9203,8 +9670,8 @@ async function releaseExpiredTokenBatch(i) {
       args: [i.owner, nonce >> 8n],
       blockNumber: block.number
     });
-    if (expired || typeof bitmap !== "bigint" || bitmap < 0n || bitmap > MAX_UINT256 || (bitmap & 1n << (nonce & 255n)) !== 0n || active && read(key2) !== active) return;
-    if (active) {
+    if (expired || typeof bitmap !== "bigint" || bitmap < 0n || bitmap > MAX_UINT256 || (bitmap & 1n << (nonce & 255n)) !== 0n || active2 && read(key2) !== active2) return;
+    if (active2) {
       const terminalKey = `${key2}:expired:${txHash.toLowerCase()}`;
       expiredRecords.set(terminalKey, saved);
       let persisted = typeof window === "undefined";
@@ -9262,15 +9729,15 @@ function clear(key2, body) {
 function sponsorTokenBatch(i) {
   const key2 = pendingKey(i);
   const plan = planOf(i.transfers);
-  const active = inflight.get(key2);
-  if (active) {
-    if (active.plan !== plan || i.resumeTxHash && pendingTokenBatch(i)?.txHash !== i.resumeTxHash)
+  const active2 = inflight.get(key2);
+  if (active2) {
+    if (active2.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."
         )
       );
-    return active.promise;
+    return active2.promise;
   }
   const promise = execute(i, key2, plan).finally(() => inflight.delete(key2));
   inflight.set(key2, { plan, promise });
@@ -9424,7 +9891,7 @@ async function execute(i, key2, plan) {
       "DEPOSIT_INSUFFICIENT_BALANCE",
       "Insufficient token balance for this deposit."
     );
-  if (allowance < total && (i.chainId !== 8453 || !isAddressEqual2(i.token, BASE_USDC_ADDRESS)))
+  if (allowance < total && !supportsSponsoredErc2612(i.chainId, i.token))
     throw new OwneyError(
       "PERMIT2_APPROVAL_REQUIRED",
       "token deposits need a one-time Permit2 approval."
@@ -9460,7 +9927,7 @@ async function execute(i, key2, plan) {
     const signature2 = await i.wallet.signTypedData({
       account: i.owner,
       ...erc2612TypedData({
-        chainId: 8453,
+        chainId: i.chainId,
         token: i.token,
         owner: i.owner,
         permit: unsignedPermit
@@ -10088,12 +10555,12 @@ var OwneySDK = class {
     return [...this.getActiveAgents().keys()].sort();
   }
   getActiveAgents() {
-    const active = /* @__PURE__ */ new Map();
+    const active2 = /* @__PURE__ */ new Map();
     for (const id of this.activeAgents) {
       const agent = this.agents.get(id);
-      if (agent) active.set(id, agent);
+      if (agent) active2.set(id, agent);
     }
-    return active;
+    return active2;
   }
   /**
    * Read the org's agent policy once and reuse it. fetchOrgAgentConfig never
@@ -10676,10 +11143,10 @@ var OwneySDK = class {
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
    * two independent auto-recovery mechanisms:
    *
-   * 1. Missing Permit2 allowance outside the atomic Base-USDC path: when the
+   * 1. Missing Permit2 allowance outside the sponsored ERC-2612 path: when the
    *    app did not supply its own callback and the attempt fails with
    *    `PERMIT2_APPROVAL_REQUIRED`, this is the wallet's first Permit2 deposit
-   *    for that token. Base USDC bundles a gasless ERC-2612 approval inside
+   *    for that token. Native Base/Arbitrum USDC uses gasless ERC-2612 approval in
    *    its sponsored deposit and never reaches this branch. Other tokens send
    *    the one-time user-paid Permit2 approval via `approvePermit2()` and
    *    retry the SAME sponsored attempt once. Bounded to one approval attempt
@@ -11186,8 +11653,8 @@ var OwneySDK = class {
   async ensureSwapChain(chainId) {
     const provider = this.requireConnectedProvider();
     const state = this.requireState();
-    const chain = swapChain(chainId);
-    if (!chain) {
+    const chain2 = swapChain(chainId);
+    if (!chain2) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
         `Chain ${chainId} is not supported`,
@@ -11195,10 +11662,10 @@ var OwneySDK = class {
       );
     }
     await ensureWalletOnChain(
-      createPublicClient4({ chain, transport: custom5(provider) }),
+      createPublicClient4({ chain: chain2, transport: custom5(provider) }),
       createWalletClient5({
         account: state.walletAddress,
-        chain,
+        chain: chain2,
         transport: custom5(provider)
       }),
       chainId
@@ -11222,15 +11689,15 @@ var OwneySDK = class {
   async wrapNativeSource(quote, walletAddress, onStage, direction) {
     const wrapper = requireWrapper(quote);
     const chainId = quote.src.chainId;
-    const chain = swapChain(chainId);
+    const chain2 = swapChain(chainId);
     const provider = this.requireConnectedProvider();
     const publicClient = createPublicClient4({
-      chain,
+      chain: chain2,
       transport: swapReadTransport(chainId, this.zyfaiRpcUrls)
     });
     const wallet = createWalletClient5({
       account: walletAddress,
-      chain,
+      chain: chain2,
       transport: custom5(provider)
     });
     onStage?.("wrapping");
@@ -11257,7 +11724,7 @@ var OwneySDK = class {
             data: tx.data,
             value: BigInt(tx.value),
             account: walletAddress,
-            chain
+            chain: chain2
           });
           onSubmitted?.(hash2);
           const receipt = await publicClient.waitForTransactionReceipt({
@@ -11327,15 +11794,27 @@ var OwneySDK = class {
    * Kept as a builder rather than baked into the executor so the whole swap
    * flow stays testable without a provider — the executor never imports viem.
    */
-  buildSwapDeps(quote) {
+  buildSwapDeps(quote, assertOperation, onTransactionHash) {
     const state = this.requireState();
     const provider = this.requireConnectedProvider();
+    const revision = this.connectionRevision;
+    const assertWallet = () => {
+      assertOperation?.();
+      if (this.state !== state || this.connectionRevision !== revision)
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed before swap authorization.");
+    };
     const srcChain = swapChain(quote.src.chainId);
     const dstChain = swapChain(quote.dst.chainId);
     const wallet = createWalletClient5({
       account: state.walletAddress,
       chain: srcChain,
-      transport: custom5(provider)
+      // viem can await chain/account preparation before dispatching a wallet
+      // request. Recheck at the transport boundary so an expired attempt or
+      // replaced session cannot send after that internal await completes.
+      transport: custom5({ request: (args) => {
+        assertWallet();
+        return provider.request(args);
+      } }, { retryCount: 0 })
     });
     const srcPublic = createPublicClient4({
       chain: srcChain,
@@ -11364,6 +11843,7 @@ var OwneySDK = class {
         });
       },
       sendTransaction: async (tx) => {
+        assertWallet();
         const hash2 = await wallet.sendTransaction({
           to: tx.to,
           data: tx.data,
@@ -11371,24 +11851,34 @@ var OwneySDK = class {
           account: state.walletAddress,
           chain: srcChain
         });
+        onTransactionHash?.(hash2);
         const receipt = await srcPublic.waitForTransactionReceipt({
           timeout: receiptTimeoutMs(quote.src.chainId),
           hash: hash2,
           confirmations: 1
+        }).catch(() => {
+          throw new OwneyError(
+            "SWAP_REQUEST_FAILED",
+            "Swap receipt is not confirmed yet.",
+            { txHash: hash2, settlementUnconfirmed: true, outcome: "submitted-unknown" }
+          );
         });
         if (receipt.status !== "success") {
           throw new OwneyError(
             "SWAP_REQUEST_FAILED",
             `Swap transaction reverted (tx ${hash2})`,
-            { hash: hash2 }
+            { txHash: hash2, outcome: "not-submitted", executionFailed: true }
           );
         }
         return hash2;
       },
-      signTypedData: (typedData) => wallet.signTypedData({
-        account: state.walletAddress,
-        ...typedData
-      }),
+      signTypedData: (typedData) => {
+        assertWallet();
+        return wallet.signTypedData({
+          account: state.walletAddress,
+          ...typedData
+        });
+      },
       // Chain-bound like every other read here: the wallet provider's chain is
       // not ours to rely on mid-swap.
       readSourceBalance: async () => {
@@ -11410,6 +11900,7 @@ var OwneySDK = class {
         args: [state.walletAddress, spender]
       }),
       approve: async (spender, amount) => {
+        assertWallet();
         const hash2 = await wallet.writeContract({
           address: quote.src.address,
           abi: ERC20_ALLOWANCE_ABI,
@@ -11418,14 +11909,22 @@ var OwneySDK = class {
           account: state.walletAddress,
           chain: srcChain
         });
-        await srcPublic.waitForTransactionReceipt({
+        const receipt = await srcPublic.waitForTransactionReceipt({
           hash: hash2,
           confirmations: 1,
           timeout: receiptTimeoutMs(quote.src.chainId)
         });
+        if (receipt.status !== "success") throw new OwneyError(
+          "SWAP_REQUEST_FAILED",
+          "Swap approval reverted.",
+          { hash: hash2, phase: "approval", outcome: "not-submitted" }
+        );
         return hash2;
       },
-      ensureChain: (chainId) => this.ensureSwapChain(chainId),
+      ensureChain: (chainId) => {
+        assertWallet();
+        return this.ensureSwapChain(chainId);
+      },
       /**
        * Sign the approval instead of paying for it. Null means the token
        * cannot be permitted (WETH has no `permit`) or its domain could not be
@@ -11445,10 +11944,13 @@ var OwneySDK = class {
           spender,
           value: amount,
           chainId: quote.src.chainId,
-          signTypedData: (payload) => wallet.signTypedData({
-            account: state.walletAddress,
-            ...payload
-          })
+          signTypedData: (payload) => {
+            assertWallet();
+            return wallet.signTypedData({
+              account: state.walletAddress,
+              ...payload
+            });
+          }
         }
       ),
       /**
@@ -11498,36 +12000,20 @@ var OwneySDK = class {
     );
   }
   /**
-   * How much of a landed swap to actually deposit.
-   *
-   * The swap reports what ARRIVED, and the deposit used to be handed that
-   * figure directly. It is the entire arrival, so there is no slack: anything
-   * that spends the target asset between the two fails the deposit outright.
-   *
-   * Something does. A first WETH deposit needs a one-time Permit2 approval,
-   * and that approval is a transaction. A wallet holding no native gas token -
-   * the normal state of someone who just swapped everything INTO WETH - pays
-   * for it out of the WETH. The deposit then asked for ~2e12 wei more than was
-   * left and refused with DEPOSIT_INSUFFICIENT_BALANCE, under a wrapper saying
-   * the funds were safe but unadded (ROUT-242).
-   *
-   * So the approval happens here, before the amount is settled, and the amount
-   * comes from a read taken after it. Two things this deliberately is not:
-   *
-   * - It is not a balance sweep. `received` is a DELTA over the pre-swap
-   *   balance, so a wallet already holding WETH reads far above it; depositing
-   *   the balance would move funds the user never offered. The arrival is the
-   *   ceiling and the balance is only ever allowed to lower it.
-   * - It does not touch USDC, which moves on signed typed data and so spends
-   *   nothing of the user's in between, nor a paymaster-configured client,
-   *   where the sponsor covers the transfer and Permit2 never applies.
+   * Finish any user-paid Permit2 approval before measuring the deposit.
+   * Wallets can charge approval gas in the received token (ROUT-242/544).
+   * Cap the result at the swap arrival to preserve pre-existing wallet funds.
+   * Native Base/Arbitrum USDC uses sponsored ERC-2612; configured paymaster
+   * wallet calls also cover approval without spending the received tokens.
    */
-  async settleSwapDepositAmount(chainId, token, symbol, received) {
-    if (symbol !== "WETH" || this.paymasterServiceUrl) {
+  async settleSwapDepositAmount(chainId, token, symbol2, received) {
+    if (symbol2 !== "WETH" && symbol2 !== "USDC" || this.paymasterServiceUrl || supportsSponsoredErc2612(chainId, token)) {
       return received.toString();
     }
     const allowance = await this.readTokenPermit2Allowance(chainId, token);
-    if (allowance < received) await this.approvePermit2();
+    if (allowance < received) {
+      await this.approvePermit2(symbol2, received, chainId);
+    }
     const balance = await this.readTokenBalance(chainId, token);
     return (balance < received ? balance : received).toString();
   }
@@ -11654,21 +12140,30 @@ var OwneySDK = class {
    * Every order is attempted even if an earlier one throws: they are unrelated
    * escrows, and one ending badly must not abandon the next one's secrets.
    * `unfinished` is not a verdict — the order may still settle, so unless the
-   * chain has said refunded or cancelled its preimages are kept.
+   * provider has confirmed full settlement or refund, its preimages are kept.
    */
   async resumePendingSwaps(options = {}) {
-    const pending = listOrders();
-    if (pending.length === 0) {
-      await this.resumeSameChainSwaps(options);
-      return [];
-    }
+    await mapConcurrent(listWithdrawSwaps(Date.now(), true).filter((record2) => record2.txHash && record2.status === "unknown" && (!options.orderHash || options.orderHash === record2.orderHash)), async (record2) => {
+      try {
+        const rpc2 = createPublicClient4({ chain: swapChain(record2.srcChainId), transport: swapReadTransport(record2.srcChainId, this.zyfaiRpcUrls) });
+        const receipt = await bounded(
+          () => rpc2.getTransactionReceipt({ hash: record2.txHash }),
+          8e3,
+          () => new Error("Receipt unavailable")
+        );
+        updateWithdrawSwap(record2.orderHash, { status: receipt.status === "success" ? "landed" : "not-swapped" });
+      } catch {
+      }
+    });
+    const pending = listOrders().filter((order) => !isOrderObserved(order.orderHash) && (!options.orderHash || order.orderHash === options.orderHash));
     const runner = this.swapRunnerDeps();
-    const results = [];
-    for (const order of pending) {
+    const sameChain = this.resumeSameChainSwaps(options);
+    const results = await mapConcurrent(pending, async (order) => {
       try {
         await runFusionOrder(runner, {
           orderHash: order.orderHash,
           secrets: order.secrets,
+          hasPartialFill: listWithdrawSwaps(Date.now(), true).some((record2) => record2.orderHash === order.orderHash && record2.status === "partially-filled"),
           ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
           ...options.onStage ? {
             onStage: (stage) => options.onStage(order.orderHash, stage)
@@ -11676,25 +12171,23 @@ var OwneySDK = class {
         });
         clearOrder(order.orderHash);
         updateWithdrawSwap(order.orderHash, { status: "landed" });
-        results.push({
-          orderHash: order.orderHash,
-          status: "completed"
-        });
+        return { orderHash: order.orderHash, status: "completed" };
       } catch (error) {
-        if (error instanceof OwneyError && (error.code === "SWAP_ORDER_REFUNDED" || error.code === "SWAP_ORDER_CANCELLED")) {
+        if (error instanceof OwneyError && error.code === "SWAP_ORDER_REFUNDED" && error.details?.outcome === "refunded") {
           clearOrder(order.orderHash);
           updateWithdrawSwap(order.orderHash, { status: "refunded" });
         } else {
-          updateWithdrawSwap(order.orderHash, { status: "unknown" });
+          if (!(error instanceof OwneyError && error.details?.watchActive))
+            updateWithdrawSwap(order.orderHash, { status: error instanceof OwneyError && error.details?.outcome === "refund-pending" ? "refund-pending" : error instanceof OwneyError && error.details?.outcome === "partially-filled" ? "partially-filled" : "unknown" });
         }
-        results.push({
+        return {
           orderHash: order.orderHash,
           status: "unfinished",
           ...error instanceof OwneyError ? { error } : {}
-        });
+        };
       }
-    }
-    await this.resumeSameChainSwaps(options);
+    });
+    await sameChain;
     return results;
   }
   /**
@@ -11715,34 +12208,32 @@ var OwneySDK = class {
    * anything else.
    */
   async resumeSameChainSwaps(options = {}) {
-    const running = listWithdrawSwaps().filter(
-      (record) => record.status === "swapping" && record.srcChainId === record.dstChainId
-    );
-    for (const record of running) {
+    const running = listWithdrawSwaps(Date.now(), true).filter((record2) => ["swapping", "unknown", "partially-filled", "refund-pending"].includes(record2.status) && record2.srcChainId === record2.dstChainId && /^0x[0-9a-f]{64}$/i.test(record2.orderHash) && !isOrderObserved(record2.orderHash) && (!options.orderHash || record2.orderHash === options.orderHash));
+    await mapConcurrent(running, async (record2) => {
       const runner = {
         // The chain bound in. That product keys its orders per chain, and the
         // Fusion+ endpoint answers 404 for one — which would read as an order
         // that vanished rather than one still in the auction.
-        orderStatus: (h) => this.swapApi().orderStatus(h, record.srcChainId),
+        orderStatus: (h) => this.swapApi().orderStatus(h, record2.srcChainId),
         sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
         now: () => Date.now()
       };
       try {
         await runSameChainOrder(runner, {
-          orderHash: record.orderHash,
+          orderHash: record2.orderHash,
+          hasPartialFill: record2.status === "partially-filled",
           ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
           ...options.onStage ? {
-            onStage: (stage) => options.onStage(record.orderHash, stage)
+            onStage: (stage) => options.onStage(record2.orderHash, stage)
           } : {}
         });
-        updateWithdrawSwap(record.orderHash, { status: "landed" });
+        updateWithdrawSwap(record2.orderHash, { status: "landed" });
       } catch (error) {
-        const code = error instanceof OwneyError ? error.code : void 0;
-        updateWithdrawSwap(record.orderHash, {
-          status: code === "SWAP_ORDER_EXPIRED" || code === "SWAP_ORDER_CANCELLED" ? "refunded" : "unknown"
-        });
+        if (error instanceof OwneyError && error.details?.watchActive) return;
+        const outcome = error instanceof OwneyError ? error.details?.outcome : void 0;
+        updateWithdrawSwap(record2.orderHash, { status: outcome === "not-submitted" ? "not-swapped" : outcome === "partially-filled" ? "partially-filled" : "unknown" });
       }
-    }
+    });
   }
   /**
    * What the wallet actually holds, across every supported chain, restricted
@@ -11898,6 +12389,92 @@ var OwneySDK = class {
       );
     }
   }
+  /** Read-only confirmation of a saved pre-swap withdrawal. Never withdraws or swaps. */
+  async recheckWithdrawalSwap(id) {
+    const record2 = listWithdrawSwaps(Date.now(), true).find((row) => row.orderHash === id);
+    const state = this.requireState();
+    if (!record2?.recovery || record2.walletAddress?.toLowerCase() !== state.walletAddress.toLowerCase() || record2.srcChainId !== this.requireChainId() || record2.recovery.phase === "submitted")
+      throw new OwneyError("WITHDRAW_SWAP_INCOMPLETE", "Reconnect the original wallet and source chain to check this withdrawal.");
+    if (this.withdrawalSwapSubmissions.has(`${state.walletAddress.toLowerCase()}:${record2.srcChainId}:${record2.srcSymbol}`))
+      throw new OwneyError("WITHDRAW_IN_PROGRESS", "This withdrawal is still being observed by its original attempt.");
+    const revision = this.connectionRevision;
+    const asset = SupportedAssets.find((a) => a.chainId === record2.srcChainId && a.symbol === record2.srcSymbol);
+    if (!asset || !record2.recovery.results)
+      throw new OwneyError(
+        "WITHDRAW_SWAP_INCOMPLETE",
+        "Some withdrawal results remain unknown. Check Activity and balances before continuing.",
+        { reason: "WITHDRAWAL_RESULTS_UNAVAILABLE", swapSubmitted: false }
+      );
+    const rpc2 = createPublicClient4({
+      chain: VIEM_CHAIN2[record2.srcChainId],
+      transport: swapReadTransport(record2.srcChainId, this.zyfaiRpcUrls)
+    });
+    const recovery = record2.recovery;
+    const assertRecoveryCurrent = () => {
+      if (this.state !== state || this.connectionRevision !== revision)
+        throw new OwneyError("NOT_CONNECTED", "Wallet changed during confirmation.");
+      const latest = listWithdrawSwaps(Date.now(), true).find((row) => row.orderHash === id);
+      if (!latest?.recovery || latest.recovery.phase === "submitted")
+        throw new OwneyError("WITHDRAW_IN_PROGRESS", "This intent has already advanced. Check its current order.");
+    };
+    const persist = () => {
+      assertRecoveryCurrent();
+      saveWithdrawSwap(record2);
+    };
+    for (const [id2, result] of Object.entries(recovery.results)) {
+      const evidence = recovery.evidence[id2] ?? result.evidence;
+      if (evidence) result.evidence = { ...evidence, transfer: "pending", delivery: "pending" };
+      if (id2 === "yieldseeker" && recovery.requested === void 0) result.completion = "unverified";
+    }
+    try {
+      const arrived = await awaitWithdrawalPayouts({
+        results: recovery.results,
+        requested: recovery.requested === void 0 ? void 0 : BigInt(recovery.requested),
+        walletAddress: state.walletAddress,
+        chainId: record2.srcChainId,
+        token: asset.symbol,
+        submittedAt: recovery.submittedAt,
+        baseline: BigInt(recovery.baseline),
+        baselineBlock: BigInt(recovery.baselineBlock),
+        timeoutMs: 3e4,
+        assertCurrent: assertRecoveryCurrent,
+        readBalance: () => rpc2.readContract({ address: asset.address, abi: erc20Abi7, functionName: "balanceOf", args: [state.walletAddress] }),
+        inspect: (value, fromHistory) => this.inspectFunding(value, "withdraw", { requireAmountMatch: fromHistory, refreshBalance: false }),
+        resolve: (value) => this.resolveSponsoredWithdrawalEvidence(value, { submittedAt: recovery.submittedAt }),
+        history: (value, fromDate, filters) => this.getFundingHistory(value, fromDate, filters),
+        verifyCompletion: (value) => this.getAgent(value.agentId).verifyWithdrawalCompletion?.(state, value) ?? Promise.resolve({ status: "unavailable" }),
+        onProgress: (value) => {
+          recovery.evidence[value.agentId] = value;
+          persist();
+        }
+      });
+      record2.withdrawn = arrived.toString();
+      record2.status = "ready";
+      recovery.phase = "ready";
+      recovery.reason = void 0;
+      persist();
+      return record2;
+    } catch (error) {
+      record2.status = "withdrawal-incomplete";
+      recovery.reason = error instanceof OwneyError ? String(error.details?.reason ?? error.code) : "CONFIRMATION_UNAVAILABLE";
+      try {
+        persist();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  /** Explicit foreground continuation: spends verified payouts, never withdraws again. */
+  async continueWithdrawalSwap(id, callbacks = {}) {
+    const record2 = await this.recheckWithdrawalSwap(id);
+    return this.withdrawAndSwap({
+      from: { chainId: record2.srcChainId, symbol: record2.srcSymbol },
+      to: { chainId: record2.dstChainId, symbol: record2.dstSymbol, decimals: record2.dstDecimals },
+      ...record2.recovery?.agentId ? { agentId: record2.recovery.agentId } : {},
+      recoveryId: id,
+      ...callbacks
+    });
+  }
   /**
    * Withdraw from an agent and swap the proceeds into whatever the user wants
    * to hold, delivered to their own wallet.
@@ -11926,7 +12503,14 @@ var OwneySDK = class {
     const state = this.requireState();
     const activeChainId = this.requireChainId();
     const revision = this.connectionRevision;
+    let active2 = true;
+    let record2;
+    let hadDurableRecord = false;
+    const startedAt = Date.now();
+    let confirmationDeadline = Infinity;
     const assertCurrent = () => {
+      options.assertCurrent?.();
+      if (!active2) throw new OwneyError("WITHDRAW_SWAP_INCOMPLETE", "This withdrawal attempt is no longer active.", { swapSubmitted: false });
       if (this.state !== state || this.connectionRevision !== revision || state.chainId !== activeChainId)
         throw new OwneyError("NOT_CONNECTED", "Wallet changed during withdrawal and swap.");
     };
@@ -11968,30 +12552,95 @@ var OwneySDK = class {
         functionName: "balanceOf",
         args: [state.walletAddress]
       });
-      const baselineBlock = await srcPublic.getBlockNumber({ cacheTime: 0 });
-      const baseline = await readWalletBalance();
+      const saved = options.recoveryId ? listWithdrawSwaps(Date.now(), true).find((row) => row.orderHash === options.recoveryId) : void 0;
+      if (options.recoveryId && (!saved?.recovery?.results || saved.recovery.phase !== "ready" || saved.walletAddress?.toLowerCase() !== state.walletAddress.toLowerCase() || saved.srcChainId !== activeChainId || saved.srcSymbol !== asset.symbol || saved.dstChainId !== options.to.chainId || saved.dstSymbol !== options.to.symbol))
+        throw new OwneyError("WITHDRAW_SWAP_INCOMPLETE", "This withdrawal is not ready to continue.");
+      const prepareTimeout = () => new OwneyError(
+        "WITHDRAW_SWAP_INCOMPLETE",
+        "Could not read the source wallet. No new withdrawal was submitted.",
+        { reason: "BASELINE_UNAVAILABLE", swapSubmitted: false }
+      );
+      const baselineBlock = saved ? BigInt(saved.recovery.baselineBlock) : await bounded(() => srcPublic.getBlockNumber({ cacheTime: 0 }), 2e4, prepareTimeout);
+      const baseline = saved ? BigInt(saved.recovery.baseline) : await bounded(readWalletBalance, 2e4, prepareTimeout);
       assertCurrent();
       debugLog("owney-sdk", "withdrawAndSwap: baseline", {
         asset: `${asset.symbol}@${asset.chainId}`,
         baseline: baseline.toString()
       });
       options.onSwapProgress?.("withdrawing");
-      const submittedAt = Date.now();
-      const requested = options.amount === void 0 ? void 0 : parseUnits3(options.amount, asset.decimals);
+      const submittedAt = saved?.recovery?.submittedAt ?? Date.now();
+      const requested = saved ? saved.recovery.requested === void 0 ? void 0 : BigInt(saved.recovery.requested) : options.amount === void 0 ? void 0 : parseUnits4(options.amount, asset.decimals);
+      confirmationDeadline = Date.now() + (options.arrivalTimeoutMs ?? 18e4);
+      const attemptId = saved?.recovery?.attemptId ?? `withdraw-${globalThis.crypto.randomUUID()}`;
+      record2 = saved ?? {
+        orderHash: attemptId,
+        walletAddress: state.walletAddress,
+        status: "withdrawal-pending",
+        withdrawn: "0",
+        expected: "0",
+        createdAt: Date.now(),
+        srcSymbol: asset.symbol,
+        srcChainId: activeChainId,
+        srcDecimals: asset.decimals,
+        dstSymbol: options.to.symbol,
+        dstChainId: options.to.chainId,
+        dstDecimals: options.to.decimals ?? 18,
+        recovery: {
+          attemptId,
+          phase: "withdrawing",
+          baseline: baseline.toString(),
+          baselineBlock: baselineBlock.toString(),
+          submittedAt,
+          deadline: confirmationDeadline,
+          requested: requested?.toString(),
+          agentId: options.agentId,
+          evidence: {}
+        }
+      };
+      hadDurableRecord = saveWithdrawSwap(record2);
+      const assertSubmission = () => {
+        assertCurrent();
+        if (Date.now() >= confirmationDeadline) throw new OwneyError(
+          "WITHDRAW_SWAP_INCOMPLETE",
+          "Withdrawal confirmation timed out. Check Activity before retrying.",
+          { reason: "PAYOUT_CONFIRMATION_TIMEOUT", swapSubmitted: false }
+        );
+      };
       const evidence = /* @__PURE__ */ new Map();
       const onProgress = (next) => {
         if (next.chainId !== activeChainId || next.token !== asset.symbol || next.walletAddress.toLowerCase() !== state.walletAddress.toLowerCase()) return;
         evidence.set(next.agentId, next);
+        if (record2?.recovery) {
+          record2.recovery.evidence[next.agentId] = next;
+          if (active2) saveWithdrawSwap(record2);
+          else {
+            const latest = listWithdrawSwaps(Date.now(), true).find((row) => row.recovery?.attemptId === record2.recovery.attemptId);
+            if (latest?.recovery) updateWithdrawSwap(latest.orderHash, { recovery: {
+              ...latest.recovery,
+              evidence: { ...latest.recovery.evidence, [next.agentId]: next }
+            } });
+          }
+        }
         notifyFunding(options.onWithdrawalProgress, next);
       };
       let withdraw;
       try {
-        withdraw = await this.withdraw({
+        withdraw = saved ? { agentResult: saved.recovery.results, totalWithdrawn: null } : await bounded(() => this.withdraw({
           asset: asset.symbol,
           ...requested === void 0 ? {} : { amount: requested.toString() },
           ...options.agentId ? { agentId: options.agentId } : {},
-          onProgress
-        });
+          onProgress,
+          assertCurrent: assertSubmission,
+          onBeforeSubmission: (next) => {
+            assertSubmission();
+            onProgress(next);
+          },
+          observationDeadline: confirmationDeadline
+        }), Math.max(0, confirmationDeadline - Date.now()), () => new OwneyError(
+          "WITHDRAW_SWAP_INCOMPLETE",
+          "Withdrawal confirmation timed out. Check Activity and balances before trying again.",
+          { reason: "WITHDRAWAL_DISPATCH_TIMEOUT", swapSubmitted: false, withdrawalEvidence: Object.fromEntries(evidence) }
+        ));
       } catch (error) {
         const details = error instanceof OwneyError ? error.details : void 0;
         const moved = [...evidence.values()].some((value) => value.transfer !== "failed" && (value.delivery === "confirmed" || value.transfer === "unknown" || value.txHash || value.userOpHash || value.callsId || value.withdrawalRequest?.attempted));
@@ -12013,6 +12662,9 @@ var OwneySDK = class {
       const results = "agentResult" in withdraw ? withdraw.agentResult : {
         [options.agentId ?? withdraw.evidence?.agentId ?? "unknown"]: withdraw
       };
+      record2.recovery.results = results;
+      record2.recovery.phase = "verifying";
+      saveWithdrawSwap(record2);
       const arrived = await awaitWithdrawalPayouts({
         results,
         requested,
@@ -12024,7 +12676,8 @@ var OwneySDK = class {
         baselineBlock,
         assertCurrent,
         readBalance: readWalletBalance,
-        timeoutMs: options.arrivalTimeoutMs,
+        deadline: confirmationDeadline,
+        verifyCompletion: (value) => this.getAgent(value.agentId).verifyWithdrawalCompletion?.(state, value) ?? Promise.resolve({ status: "unavailable" }),
         inspect: (value, fromHistory) => this.inspectFunding(value, "withdraw", { requireAmountMatch: fromHistory, refreshBalance: false }),
         resolve: (value) => this.resolveSponsoredWithdrawalEvidence(value, { submittedAt }),
         history: (value, fromDate, filters) => this.getFundingHistory(value, fromDate, filters),
@@ -12032,34 +12685,89 @@ var OwneySDK = class {
       });
       assertCurrent();
       const withdrawn = arrived.toString();
+      record2.withdrawn = withdrawn;
+      record2.status = "ready";
+      record2.recovery.phase = "ready";
+      hadDurableRecord = saveWithdrawSwap(record2) || hadDurableRecord;
       options.onSwapProgress?.("withdrawn");
       try {
-        const quote = await this.swapApi().quote({
+        const quote = await bounded(() => this.swapApi().quote({
           from: { ...options.from, amount: withdrawn },
           to: options.to,
           direction: "withdraw",
           walletAddress: state.walletAddress
-        });
+        }), 2e4, () => new OwneyError("SWAP_REQUEST_FAILED", "Swap pricing timed out.", { outcome: "not-submitted" }));
         assertCurrent();
-        await this.ensureSwapChain(quote.src.chainId);
+        await bounded(
+          () => this.ensureSwapChain(quote.src.chainId),
+          18e4,
+          () => new OwneyError("SWAP_WALLET_PROMPT_TIMEOUT", "The wallet did not confirm its chain. No swap was submitted.", { outcome: "not-submitted" })
+        );
         assertCurrent();
-        const swap = await executeSwap(this.buildSwapDeps(quote), {
+        const swap = await executeSwap(this.buildSwapDeps(quote, assertCurrent, (hash2) => {
+          record2.txHash = hash2;
+          saveWithdrawSwap(record2);
+        }), {
+          onTransactionRequested: () => {
+            assertCurrent();
+            record2.status = "unknown";
+            record2.recovery.phase = "submitted";
+            if (!saveWithdrawSwap(record2) && hadDurableRecord)
+              throw new OwneyError("SWAP_REQUEST_FAILED", "Recovery storage is unavailable. No swap was submitted.", { outcome: "not-submitted" });
+          },
+          assertCurrent,
+          sourceReserve: baseline,
           quote,
           walletAddress: state.walletAddress,
           direction: "withdraw",
           ...options.slippage === void 0 ? {} : { slippage: options.slippage },
           ...options.onSwapProgress ? { onStage: options.onSwapProgress } : {},
-          onOrderSubmitted: (orderHash) => {
+          onOrderPrepared: (orderHash, details) => {
+            assertCurrent();
+            const previous = record2.orderHash;
+            record2.orderHash = orderHash;
+            record2.status = "unknown";
+            record2.recovery.phase = "submitted";
+            record2.spent = details.spent;
+            record2.expected = details.expected;
+            if (!saveWithdrawSwap(record2) && hadDurableRecord) {
+              record2.orderHash = previous;
+              throw new OwneyError("SWAP_REQUEST_FAILED", "Recovery storage is unavailable. No swap was submitted.", { outcome: "not-submitted" });
+            }
+            if (previous !== orderHash) {
+              updateWithdrawSwap(previous, { status: "not-swapped" });
+              clearWithdrawSwap(previous);
+            }
+          },
+          onOrderSubmitted: (orderHash, details) => {
             releaseSubmission();
-            options.onOrderSubmitted?.({ orderHash, withdrawn, expected: quote.dst.amount });
+            record2.orderHash = orderHash;
+            record2.status = "swapping";
+            record2.recovery.phase = "submitted";
+            record2.createdAt = Date.now();
+            const durable = saveWithdrawSwap(record2);
+            options.onOrderSubmitted?.({
+              orderHash,
+              withdrawn,
+              expected: details?.expected ?? quote.dst.amount,
+              spent: details?.spent,
+              durable: durable && details?.durable !== false
+            });
           }
         });
+        record2.status = "landed";
+        record2.received = swap.received;
+        record2.spent = swap.spent;
+        saveWithdrawSwap(record2);
         return { withdraw, withdrawn, swap };
       } catch (error) {
         throw new OwneyError(
           "WITHDRAW_SWAP_FAILED",
-          `Withdrew ${withdrawn} ${asset.symbol} to your wallet, but the swap to ${options.to.symbol} did not complete. The funds are in your wallet as ${asset.symbol}.`,
+          `The withdrawal completed, but the swap to ${options.to.symbol} could not be confirmed. Check the order and both balances before retrying.`,
           {
+            outcome: record2.recovery?.phase === "ready" ? "not-submitted" : "submitted-unknown",
+            ...error instanceof OwneyError ? error.details : {},
+            ...record2.orderHash.startsWith("0x") ? { orderHash: record2.orderHash, settlementUnconfirmed: true } : {},
             withdrawn,
             asset: asset.symbol,
             chainId: asset.chainId,
@@ -12070,7 +12778,25 @@ var OwneySDK = class {
           }
         );
       }
+    } catch (error) {
+      if (record2) {
+        if (error instanceof OwneyError && error.details) Object.assign(error.details, {
+          attemptId: record2.recovery?.attemptId,
+          phase: record2.recovery?.phase,
+          elapsedMs: Date.now() - startedAt,
+          txHash: record2.txHash,
+          withdrawalEvidence: record2.recovery?.evidence
+        });
+        const details = error instanceof OwneyError ? error.details : void 0;
+        const outcome = details?.outcome;
+        if (record2.recovery && outcome === "not-submitted") record2.recovery.phase = "ready";
+        record2.status = outcome === "refunded" ? "refunded" : outcome === "refund-pending" ? "refund-pending" : outcome === "partially-filled" ? "partially-filled" : record2.recovery?.phase === "submitted" || details?.settlementUnconfirmed ? "unknown" : record2.recovery?.phase === "ready" ? "ready" : "withdrawal-incomplete";
+        if (record2.recovery) record2.recovery.reason = typeof details?.reason === "string" ? details.reason : void 0;
+        saveWithdrawSwap(record2);
+      }
+      throw error;
     } finally {
+      active2 = false;
       releaseSubmission();
     }
   }
@@ -12103,7 +12829,15 @@ var OwneySDK = class {
     const attempted = /* @__PURE__ */ new Set();
     this.withdrawalSubmissions.add(submissionKey);
     try {
-      return await this.withdrawFromAgents(options, state, chainId, attempted);
+      return options.observationDeadline === void 0 ? await this.withdrawFromAgents(options, state, chainId, attempted) : await bounded(
+        () => this.withdrawFromAgents(options, state, chainId, attempted),
+        Math.max(0, options.observationDeadline - Date.now()),
+        () => new OwneyError(
+          "WITHDRAW_UNCONFIRMED",
+          "Withdrawal dispatch could not be confirmed before the deadline.",
+          { phase: "observe", reason: "WITHDRAWAL_DISPATCH_TIMEOUT" }
+        )
+      );
     } catch (error) {
       for (const id of ids) if (!attempted.has(id)) {
         notifyFunding(options.onProgress, {
@@ -12193,7 +12927,7 @@ var OwneySDK = class {
       progress(evidence);
       adapterReported = false;
       try {
-        if (options.onBeforeSubmission)
+        if (options.onBeforeSubmission || options.assertCurrent)
           return await agent.withdraw(
             state,
             chainId,
@@ -12201,7 +12935,8 @@ var OwneySDK = class {
             requested2,
             progress,
             options.gasMode ?? "auto",
-            (next) => options.onBeforeSubmission({ ...evidence, ...next })
+            options.onBeforeSubmission ? (next) => options.onBeforeSubmission({ ...evidence, ...next }) : void 0,
+            options.assertCurrent
           );
         return await (options.gasMode === void 0 ? agent.withdraw(state, chainId, token, requested2, progress) : agent.withdraw(state, chainId, token, requested2, progress, options.gasMode));
       } catch (error) {
@@ -12325,7 +13060,7 @@ var OwneySDK = class {
       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 || parseUnits3(total.amount, assetInfo.decimals) <= entry.balance) return;
+        if (!total || parseUnits4(total.amount, assetInfo.decimals) <= entry.balance) return;
       }
       try {
         const otherAvailable = indexedAvailable - entry.balance;