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

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/lib/funding-evidence.ts
 import { decodeEventLog, decodeFunctionData, erc20Abi, parseAbi } from "viem";
+import { entryPoint06Abi, entryPoint07Abi, getUserOperationHash, toUserOperation } from "viem/account-abstraction";
 function notifyFunding(callback, evidence) {
   try {
     void Promise.resolve(callback?.({ ...evidence })).catch(() => {
@@ -9,11 +10,53 @@ function notifyFunding(callback, evidence) {
 }
 var fullWithdrawalAbi = parseAbi(["function withdrawAllAssetToUser(address recipient, address asset)"]);
 var withdrawalEventAbi = parseAbi(["event WithdrewTokenToUser(address indexed owner, address indexed recipient, address indexed token, uint256 amount)"]);
-function isFullYieldseekerWithdrawal(transaction, evidence, tokenAddress) {
-  if (evidence.agentId !== "yieldseeker" || transaction.chainId !== evidence.chainId || transaction.hash.toLowerCase() !== evidence.txHash?.toLowerCase() || transaction.to?.toLowerCase() !== evidence.agentWallet?.toLowerCase() || transaction.from.toLowerCase() !== evidence.walletAddress.toLowerCase()) return false;
+var accountExecutionAbi = parseAbi([
+  "function execute(address target,uint256 value,bytes data)",
+  "function executeBatch((address target,uint256 value,bytes data)[] calls)"
+]);
+var entryPoint06 = "0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789";
+var entryPoint07 = "0x0000000071727de22e5e9d8baf0edac6f37da032";
+function isFullYieldseekerWithdrawal(transaction, evidence, tokenAddress, receipt) {
+  if (evidence.agentId !== "yieldseeker" || transaction.chainId !== evidence.chainId || transaction.hash.toLowerCase() !== evidence.txHash?.toLowerCase() || !evidence.agentWallet) return false;
+  const matchesFullCall = (data) => {
+    try {
+      const decoded = decodeFunctionData({ abi: fullWithdrawalAbi, data });
+      return decoded.args[0].toLowerCase() === evidence.walletAddress.toLowerCase() && decoded.args[1].toLowerCase() === tokenAddress.toLowerCase();
+    } catch {
+      return false;
+    }
+  };
+  if (transaction.to?.toLowerCase() === evidence.agentWallet.toLowerCase() && transaction.from.toLowerCase() === evidence.walletAddress.toLowerCase()) return matchesFullCall(transaction.input);
   try {
-    const decoded = decodeFunctionData({ abi: fullWithdrawalAbi, data: transaction.input });
-    return decoded.args[0].toLowerCase() === evidence.walletAddress.toLowerCase() && decoded.args[1].toLowerCase() === tokenAddress.toLowerCase();
+    const address = transaction.to?.toLowerCase();
+    if (address !== entryPoint06 && address !== entryPoint07) return false;
+    const version = address === entryPoint06 ? "0.6" : "0.7";
+    const decoded = decodeFunctionData({ abi: version === "0.6" ? entryPoint06Abi : entryPoint07Abi, data: transaction.input });
+    if (decoded.functionName !== "handleOps") return false;
+    const operations = decoded.args[0].filter((operation2) => [evidence.agentWallet.toLowerCase(), evidence.walletAddress.toLowerCase()].includes(operation2.sender.toLowerCase()));
+    if (operations.length !== 1) return false;
+    const operation = operations[0];
+    const userOperation = toUserOperation(operation);
+    const hash = getUserOperationHash({
+      chainId: evidence.chainId,
+      entryPointAddress: transaction.to,
+      entryPointVersion: version,
+      userOperation
+    });
+    if (evidence.userOpHash && hash.toLowerCase() !== evidence.userOpHash.toLowerCase()) return false;
+    if (!receipt?.logs.some((log) => {
+      if (log.address.toLowerCase() !== address) return false;
+      try {
+        const event = decodeEventLog({ abi: entryPoint06Abi, data: log.data, topics: log.topics });
+        return event.eventName === "UserOperationEvent" && event.args.userOpHash.toLowerCase() === hash.toLowerCase() && event.args.sender.toLowerCase() === operation.sender.toLowerCase() && event.args.success;
+      } catch {
+        return false;
+      }
+    })) return false;
+    if (operation.sender.toLowerCase() === evidence.agentWallet.toLowerCase()) return matchesFullCall(operation.callData);
+    const execution = decodeFunctionData({ abi: accountExecutionAbi, data: operation.callData });
+    const calls = execution.functionName === "execute" ? [{ target: execution.args[0], value: execution.args[1], data: execution.args[2] }] : execution.args[0];
+    return calls.length === 1 && calls[0].value === 0n && calls[0].target.toLowerCase() === evidence.agentWallet.toLowerCase() && matchesFullCall(calls[0].data);
   } catch {
     return false;
   }
@@ -2603,14 +2646,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
 // src/agents/yieldseeker/yieldseeker.agent.ts
 import {
   createPublicClient as createPublicClient3,
-  createWalletClient as createWalletClient2,
-  custom as custom2,
+  createWalletClient as createWalletClient3,
+  custom as custom3,
   encodeFunctionData,
   erc20Abi as erc20Abi2,
-  getAddress as getAddress2,
+  getAddress as getAddress4,
   isAddress as isAddress2
 } from "viem";
-import { base as base3 } from "viem/chains";
+import { base as base4 } from "viem/chains";
 
 // src/lib/chain-guard.ts
 var CHAIN_NAMES = {
@@ -2653,10 +2696,10 @@ import { bytesToHex } from "viem";
 // src/lib/sponsor-client.ts
 var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function postPaymasterIntent(input) {
-  const base5 = input.baseUrl ?? ROUTING_API_BASE_URL;
+  const base6 = input.baseUrl ?? ROUTING_API_BASE_URL;
   let res;
   try {
-    res = await fetch(`${base5}/api/v1/sponsor/paymaster-intent`, {
+    res = await fetch(`${base6}/api/v1/sponsor/paymaster-intent`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -2692,11 +2735,11 @@ async function postPaymasterIntent(input) {
   return parsed.data;
 }
 async function getSponsorRelayerAddress(input) {
-  const base5 = input.baseUrl ?? ROUTING_API_BASE_URL;
+  const base6 = input.baseUrl ?? ROUTING_API_BASE_URL;
   let res;
   try {
     res = await fetch(
-      `${base5}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
+      `${base6}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
       {
         headers: { "x-owney-api-key": input.apiKey }
       }
@@ -3532,6 +3575,49 @@ function actionEntry(action) {
     rebalanceLog: []
   };
 }
+function allocationEntry(action, context) {
+  if (action.actionType.toLowerCase() !== "autoseek") return void 0;
+  const hash = action.details?.depositTransactionHash;
+  const deposits = action.details?.deposits;
+  if (typeof hash !== "string" || !/^0x[a-fA-F0-9]{64}$/.test(hash) || !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;
+    if (typeof leg.vaultAddress !== "string" || !isAddress(leg.vaultAddress)) return void 0;
+    const rawAmount = typeof leg.rawAmount === "string" && /^\d+$/.test(leg.rawAmount) ? BigInt(leg.rawAmount) : typeof leg.rawAmount === "number" && Number.isSafeInteger(leg.rawAmount) ? BigInt(leg.rawAmount) : void 0;
+    if (rawAmount === void 0 || rawAmount <= 0n) return void 0;
+    const option = context.positions.find((position2) => position2.yieldOption.address.toLowerCase() === leg.vaultAddress.toLowerCase())?.yieldOption;
+    positions.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: formatUnits2(rawAmount, YIELDSEEKER_ASSET_METADATA[context.asset].decimals)
+    });
+    amountRaw += rawAmount;
+  }
+  return {
+    agent: "yieldseeker",
+    action: "Deposit",
+    date: action.createdDate,
+    oldApy: null,
+    newApy: null,
+    positions,
+    rebalanceLog: [],
+    transactions: [{
+      txHashes: [hash],
+      chainId: context.agent.chainId,
+      tokenAddress: context.agent.assetAddress,
+      tokenSymbol: context.asset,
+      agentWallet: context.wallet.walletAddress,
+      amountRaw: String(amountRaw),
+      amount: formatUnits2(amountRaw, YIELDSEEKER_ASSET_METADATA[context.asset].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;
@@ -3599,20 +3685,30 @@ function mapYieldseekerHistory(contexts, options) {
       seenMovements.add(key2);
       return true;
     });
-    return [
-      ...movements.map(
-        (movement) => movementEntry(
-          movement,
-          context.wallet,
-          context.agent,
-          context.asset,
-          options.ownerAddress,
-          options.vaultAddresses,
-          depositDestination(context, movement)
-        )
-      ),
-      ...(context.actions ?? []).map(actionEntry)
-    ].filter((entry) => entry !== void 0);
+    const movementEntries = movements.map(
+      (movement) => movementEntry(
+        movement,
+        context.wallet,
+        context.agent,
+        context.asset,
+        options.ownerAddress,
+        options.vaultAddresses,
+        depositDestination(context, movement)
+      )
+    ).filter((entry) => entry !== void 0);
+    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 hash = allocation.transactions[0].txHashes[0].toLowerCase();
+        if (deposits.has(hash)) return [];
+        deposits.add(hash);
+        return [allocation];
+      }
+      const entry = actionEntry(action);
+      return entry ? [entry] : [];
+    });
+    return [...movementEntries, ...actions];
   });
   const grouped = /* @__PURE__ */ new Map();
   const ungrouped = [];
@@ -3722,6 +3818,404 @@ function mapYieldseekerAgentApy(options, days) {
   };
 }
 
+// src/agents/yieldseeker/yieldseeker.wallet-version.ts
+import {
+  getAddress as getAddress2,
+  isAddressEqual,
+  parseAbi as parseAbi3
+} from "viem";
+var YIELDSEEKER_FACTORY = "0x9c7410a0faCAC60850C46eE5b58B518daec95130";
+var YIELDSEEKER_V1_IMPLEMENTATION = "0x32403455357589523435dB18b414057D7cE05051";
+var YIELDSEEKER_V2_IMPLEMENTATION = "0x613Db9c924ADB7A7A90c11b02Cce20c913E3Fe50";
+var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+var walletAbi = parseAbi3([
+  "function owner() view returns (address)",
+  "function ownerAgentIndex() view returns (uint256)",
+  "function baseAsset() view returns (address)",
+  "function FACTORY() view returns (address)",
+  "function upgradeToLatest()"
+]);
+var factoryAbi = parseAbi3([
+  "function userWallets(address owner, uint256 index) view returns (address)",
+  "function agentWalletImplementation() view returns (address)"
+]);
+function yieldseekerOwnerPath(code) {
+  return !code || code === "0x" || /^0xef0100[0-9a-f]{40}$/i.test(code) ? "eoa" : "smart";
+}
+async function readYieldseekerWalletStatus(client, wallet, owner, asset) {
+  const agentWallet = getAddress2(wallet);
+  const expectedOwner = getAddress2(owner);
+  const expectedAsset = getAddress2(asset);
+  const [code, ownerCode, slot, actualOwner, index, actualAsset, actualFactory, latest] = await Promise.all([
+    client.getBytecode({ address: agentWallet }),
+    client.getBytecode({ address: expectedOwner }),
+    client.getStorageAt({ address: agentWallet, slot: ERC1967_IMPLEMENTATION_SLOT }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "owner" }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "ownerAgentIndex" }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "baseAsset" }),
+    client.readContract({ address: agentWallet, abi: walletAbi, functionName: "FACTORY" }),
+    client.readContract({ address: YIELDSEEKER_FACTORY, abi: factoryAbi, functionName: "agentWalletImplementation" })
+  ]);
+  if (!code || code === "0x" || !slot || /^0x0+$/.test(slot)) {
+    throw new Error("Yieldseeker wallet is not a deployed ERC1967 proxy");
+  }
+  const implementation = getAddress2(`0x${slot.slice(-40)}`);
+  const mapped = await client.readContract({
+    address: YIELDSEEKER_FACTORY,
+    abi: factoryAbi,
+    functionName: "userWallets",
+    args: [expectedOwner, index]
+  });
+  const verified = isAddressEqual(actualOwner, expectedOwner) && isAddressEqual(actualAsset, expectedAsset) && isAddressEqual(actualFactory, YIELDSEEKER_FACTORY) && isAddressEqual(mapped, agentWallet);
+  const version = !verified ? "unknown" : isAddressEqual(implementation, YIELDSEEKER_V2_IMPLEMENTATION) ? "v2" : isAddressEqual(implementation, YIELDSEEKER_V1_IMPLEMENTATION) ? "v1" : "unknown";
+  return {
+    agentWallet,
+    owner: actualOwner,
+    ownerPath: yieldseekerOwnerPath(ownerCode),
+    asset: actualAsset,
+    implementation,
+    version,
+    verified,
+    upgradeAvailable: version === "v1" && isAddressEqual(latest, YIELDSEEKER_V2_IMPLEMENTATION)
+  };
+}
+var YIELDSEEKER_UPGRADE_ABI = walletAbi;
+
+// src/agents/yieldseeker/yieldseeker.sponsored-withdraw.ts
+import {
+  createWalletClient as createWalletClient2,
+  custom as custom2,
+  getAddress as getAddress3,
+  toHex
+} from "viem";
+import { getUserOperationHash as getUserOperationHash2 } from "viem/account-abstraction";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { base as base3 } from "viem/chains";
+var ENTRY_POINT_V06 = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
+var USER_OP_FEE_HEADROOM = 2n;
+var ENTRY_POINT_NONCE_ABI = [
+  { type: "function", name: "getNonce", stateMutability: "view", inputs: [
+    { name: "sender", type: "address" },
+    { name: "key", type: "uint192" }
+  ], outputs: [{ type: "uint256" }] }
+];
+var DEFAULT_ROUTING_API = "https://owney-routing-api-243946518160.europe-west4.run.app";
+var SIMULATION_ACCOUNT = privateKeyToAccount(generatePrivateKey());
+function operationHash(operation) {
+  return getUserOperationHash2({
+    chainId: 8453,
+    entryPointAddress: ENTRY_POINT_V06,
+    entryPointVersion: "0.6",
+    userOperation: {
+      sender: operation.sender,
+      nonce: BigInt(operation.nonce),
+      initCode: operation.initCode,
+      callData: operation.callData,
+      callGasLimit: BigInt(operation.callGasLimit),
+      verificationGasLimit: BigInt(operation.verificationGasLimit),
+      preVerificationGas: BigInt(operation.preVerificationGas),
+      maxFeePerGas: BigInt(operation.maxFeePerGas),
+      maxPriorityFeePerGas: BigInt(operation.maxPriorityFeePerGas),
+      paymasterAndData: operation.paymasterAndData,
+      signature: operation.signature
+    }
+  });
+}
+function sponsorError(message, safeToFallback, details = {}) {
+  return new OwneyError(
+    "SPONSOR_REQUEST_FAILED",
+    message,
+    { safeToFallback, ...details },
+    "yieldseeker"
+  );
+}
+async function requestIntent(input) {
+  const baseUrl = (input.routingApiBaseUrl ?? DEFAULT_ROUTING_API).replace(/\/$/, "");
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/api/v1/sponsor/yieldseeker-withdraw/intent`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-owney-api-key": input.apiKey,
+        Authorization: `Signature ${input.yieldseekerSignature}`
+      },
+      body: JSON.stringify({
+        chainId: 8453,
+        owner: input.owner,
+        recipient: input.owner,
+        agentWallet: input.agentWallet,
+        asset: input.asset,
+        callData: input.callData,
+        action: input.action,
+        yieldseekerUserId: input.userId,
+        yieldseekerAgentId: input.agentId
+      })
+    });
+  } catch {
+    throw sponsorError("Withdrawal sponsorship could not be requested.", true);
+  }
+  const envelope = await response.json().catch(() => null);
+  const intent = envelope?.data;
+  if (!response.ok || !envelope?.success || !intent?.intent || !["eoa", "smart"].includes(intent.ownerPath)) {
+    throw sponsorError(
+      "Withdrawal sponsorship is currently unavailable.",
+      true,
+      { statusCode: response.status }
+    );
+  }
+  const url = new URL(`${baseUrl}/api/v1/sponsor/yieldseeker-withdraw/rpc`);
+  url.searchParams.set("intent", intent.intent);
+  return { intent, rpcUrl: url.toString() };
+}
+async function rpc(url, method, params, phase) {
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+    });
+  } catch {
+    throw sponsorError("Withdrawal sponsorship request status is unknown.", phase === "prepare");
+  }
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || payload?.error || payload?.result === void 0) {
+    const rejection = payload?.error;
+    const definitiveRejection = phase === "send" && response.status < 500 && !!rejection && (rejection.data?.rejectedBeforeSubmission === true || [-32501, -32502, -32503, -32504, -32505, -32507].includes(rejection.code ?? 0) || /maxFeePerGas.*(?:too low|lower than|less than|must be at least)/i.test(rejection.message ?? ""));
+    throw sponsorError(
+      phase !== "prepare" && !definitiveRejection ? "Sponsored withdrawal submission status is unknown." : "Withdrawal sponsorship was declined before submission.",
+      phase === "prepare" || definitiveRejection,
+      { statusCode: response.status, rpcCode: payload?.error?.code, rpcMethod: method }
+    );
+  }
+  return payload.result;
+}
+async function waitForTransaction(client, txHash) {
+  const receipt = await client.waitForTransactionReceipt({ hash: txHash, confirmations: 1 });
+  if (receipt.status !== "success")
+    throw new OwneyError(
+      "AGENT_TRANSACTION_REVERTED",
+      `Yieldseeker withdrawal reverted (${txHash}).`,
+      { transactionHash: txHash },
+      "yieldseeker"
+    );
+  return receipt;
+}
+async function submitEoa(input) {
+  let nonce;
+  let fees;
+  try {
+    nonce = await input.client.readContract({
+      address: ENTRY_POINT_V06,
+      abi: ENTRY_POINT_NONCE_ABI,
+      functionName: "getNonce",
+      args: [input.agentWallet, 0n]
+    });
+    fees = await input.client.estimateFeesPerGas();
+  } catch {
+    throw sponsorError("Could not prepare the sponsored withdrawal.", true);
+  }
+  if (fees.maxFeePerGas === void 0 || fees.maxPriorityFeePerGas === void 0)
+    throw sponsorError("Base did not return EIP-1559 gas fees.", true);
+  let operation = {
+    sender: input.agentWallet,
+    nonce: toHex(nonce),
+    initCode: "0x",
+    callData: input.callData,
+    callGasLimit: toHex(3e5),
+    verificationGasLimit: toHex(3e5),
+    preVerificationGas: toHex(6e4),
+    maxFeePerGas: toHex(fees.maxFeePerGas * USER_OP_FEE_HEADROOM),
+    maxPriorityFeePerGas: toHex(fees.maxPriorityFeePerGas),
+    paymasterAndData: "0x",
+    signature: "0x"
+  };
+  operation.signature = await SIMULATION_ACCOUNT.signMessage({ message: { raw: operationHash(operation) } });
+  const stub = await rpc(
+    input.rpcUrl,
+    "pm_getPaymasterStubData",
+    [operation, ENTRY_POINT_V06, toHex(8453), {}],
+    "prepare"
+  );
+  if (!stub.paymasterAndData?.startsWith("0x"))
+    throw sponsorError("CDP did not return v0.6 paymaster data.", true);
+  operation = { ...operation, paymasterAndData: stub.paymasterAndData };
+  operation.signature = await SIMULATION_ACCOUNT.signMessage({ message: { raw: operationHash(operation) } });
+  const gas = await rpc(input.rpcUrl, "eth_estimateUserOperationGas", [operation, ENTRY_POINT_V06], "prepare");
+  if (!gas.callGasLimit || !gas.verificationGasLimit || !gas.preVerificationGas)
+    throw sponsorError("CDP did not return UserOperation gas estimates.", true);
+  operation = { ...operation, ...gas };
+  if (!stub.isFinal) {
+    const final = await rpc(
+      input.rpcUrl,
+      "pm_getPaymasterData",
+      [operation, ENTRY_POINT_V06, toHex(8453), {}],
+      "prepare"
+    );
+    if (!final.paymasterAndData?.startsWith("0x"))
+      throw sponsorError("CDP did not return final paymaster data.", true);
+    operation = { ...operation, paymasterAndData: final.paymasterAndData };
+  }
+  const userOpHash = operationHash(operation);
+  const wallet = createWalletClient2({
+    account: input.owner,
+    chain: base3,
+    transport: custom2(input.state.provider)
+  });
+  const signature = await wallet.signMessage({ message: { raw: userOpHash } });
+  operation = { ...operation, signature };
+  input.onPending?.({ userOpHash });
+  const submittedHash = await rpc(
+    input.rpcUrl,
+    "eth_sendUserOperation",
+    [operation, ENTRY_POINT_V06],
+    "send"
+  );
+  if (submittedHash.toLowerCase() !== userOpHash.toLowerCase())
+    throw sponsorError(
+      "Bundler returned a different UserOperation hash.",
+      false,
+      { userOpHash, submittedHash }
+    );
+  for (let poll = 0; poll < 40; poll++) {
+    const response = await rpc(input.rpcUrl, "eth_getUserOperationReceipt", [userOpHash], "observe");
+    const txHash = response?.receipt?.transactionHash;
+    if (txHash) {
+      input.onPending?.({ userOpHash, txHash });
+      if (response?.success === false)
+        throw new OwneyError(
+          "AGENT_TRANSACTION_REVERTED",
+          "Sponsored withdrawal execution reverted.",
+          { userOpHash, transactionHash: txHash },
+          "yieldseeker"
+        );
+      return { txHash, receipt: await waitForTransaction(input.client, txHash) };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+  }
+  throw sponsorError(
+    "Sponsored withdrawal is still pending; check status before retrying.",
+    false,
+    { userOpHash }
+  );
+}
+async function submitSmart(input) {
+  let capabilities;
+  try {
+    capabilities = await input.state.provider.request({
+      method: "wallet_getCapabilities",
+      params: [input.owner]
+    });
+  } catch {
+    throw sponsorError("This account cannot check paymaster support on Base.", true);
+  }
+  if (!capabilities?.[toHex(8453)]?.paymasterService?.supported && !capabilities?.["8453"]?.paymasterService?.supported)
+    throw sponsorError("This account cannot use a paymaster on Base.", true);
+  let sent;
+  try {
+    input.onPending?.({});
+  } catch {
+    throw sponsorError("Upgrade or withdrawal status cannot be saved.", true);
+  }
+  try {
+    sent = await input.state.provider.request({
+      method: "wallet_sendCalls",
+      params: [{
+        version: "2.0.0",
+        from: input.owner,
+        chainId: toHex(8453),
+        atomicRequired: false,
+        calls: [{ to: input.agentWallet, value: "0x0", data: input.callData }],
+        capabilities: { paymasterService: { url: input.rpcUrl } }
+      }]
+    });
+  } catch (error) {
+    if (error?.code === 4001) throw error;
+    if ([4200, -32601].includes(Number(error?.code)))
+      throw sponsorError("This account does not support sponsored calls.", true);
+    throw sponsorError("Wallet submission status is unknown. Check activity before retrying.", false);
+  }
+  const callsId = typeof sent === "string" ? sent : sent?.id;
+  if (!callsId) throw sponsorError("Wallet returned no calls ID; submission status is unknown.", false);
+  try {
+    input.onPending?.({ callsId });
+  } catch {
+    throw sponsorError("Submitted call status could not be saved.", false, { callsId });
+  }
+  for (let poll = 0; poll < 40; poll++) {
+    let status;
+    try {
+      status = await input.state.provider.request({
+        method: "wallet_getCallsStatus",
+        params: [callsId]
+      });
+    } catch {
+      throw sponsorError("Sponsored withdrawal status is unknown.", false, { callsId });
+    }
+    if (status?.status === 400 || status?.status === 500)
+      throw sponsorError(
+        "Sponsored withdrawal failed in the wallet.",
+        false,
+        { callsId, executionFailed: true }
+      );
+    const txHash = status?.receipts?.[0]?.transactionHash;
+    if (txHash) {
+      try {
+        input.onPending?.({ callsId, txHash });
+      } catch {
+        throw sponsorError(
+          "Submitted call receipt could not be saved.",
+          false,
+          { callsId, txHash }
+        );
+      }
+      return { txHash, receipt: await waitForTransaction(input.client, txHash) };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+  }
+  throw sponsorError(
+    "Sponsored withdrawal is still pending; check status before retrying.",
+    false,
+    { callsId }
+  );
+}
+async function submitYieldseekerSponsoredWithdrawal(input) {
+  const owner = getAddress3(input.state.walletAddress);
+  const { intent, rpcUrl } = await requestIntent({
+    apiKey: input.apiKey,
+    routingApiBaseUrl: input.routingApiBaseUrl,
+    yieldseekerSignature: input.yieldseekerSignature,
+    userId: input.userId,
+    agentId: input.agentId,
+    owner,
+    agentWallet: input.agentWallet,
+    asset: input.asset,
+    callData: input.callData,
+    action: "withdraw"
+  });
+  const args = { ...input, owner, rpcUrl };
+  return intent.ownerPath === "eoa" ? submitEoa(args) : submitSmart(args);
+}
+async function submitYieldseekerSponsoredUpgrade(input) {
+  const owner = getAddress3(input.state.walletAddress);
+  const { intent, rpcUrl } = await requestIntent({
+    apiKey: input.apiKey,
+    routingApiBaseUrl: input.routingApiBaseUrl,
+    yieldseekerSignature: input.yieldseekerSignature,
+    userId: input.userId,
+    agentId: input.agentId,
+    owner,
+    agentWallet: input.agentWallet,
+    asset: input.asset,
+    callData: input.callData,
+    action: "upgrade"
+  });
+  if (intent.ownerPath !== "smart")
+    throw sponsorError("V1 upgrade sponsorship requires a Base Account owner.", true);
+  return submitSmart({ ...input, owner, rpcUrl });
+}
+
 // src/agents/yieldseeker/yieldseeker.agent.ts
 var OWNEY_AGENT_NAME = "owney";
 var OWNEY_AGENT_RULE_PRESET = "explorative";
@@ -3736,6 +4230,7 @@ var YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS = 15e3;
 var YIELDSEEKER_READ_FAILURE_COOLDOWN_MS = 6e4;
 var YIELDSEEKER_SETTLEMENT_WINDOW_MS = 5 * 6e4;
 var YIELDSEEKER_ACTIVITY_CACHE_MS = 6e4;
+var YIELDSEEKER_MAX_WITHDRAW_SWEEPS = 3;
 function generateYieldseekerUsername() {
   const suffix = globalThis.crypto.randomUUID().replaceAll("-", "").slice(0, YIELDSEEKER_USERNAME_RANDOM_LENGTH).toLowerCase();
   return `${YIELDSEEKER_USERNAME_PREFIX}${suffix}`;
@@ -3794,7 +4289,11 @@ var YieldseekerAgent = class {
   api;
   auth;
   rpcUrls;
+  owneyApiKey;
+  routingApiBaseUrl;
   receiptClient;
+  // A client preparation hint only; the routing API still checks live identity.
+  withdrawalVersionCache = /* @__PURE__ */ new Map();
   transactionExecutor;
   unwindReceiptWaiter;
   agentContexts = /* @__PURE__ */ new Map();
@@ -3816,6 +4315,8 @@ var YieldseekerAgent = class {
   yieldOptions = /* @__PURE__ */ new Map();
   pendingYieldOptions = /* @__PURE__ */ new Map();
   constructor(owneyApiKey, options = {}) {
+    this.owneyApiKey = owneyApiKey;
+    this.routingApiBaseUrl = options.routingApiBaseUrl;
     this.api = new YieldseekerApiClient(
       owneyApiKey,
       options.baseUrl ?? getYieldseekerProxyBaseUrl(),
@@ -3827,10 +4328,182 @@ var YieldseekerAgent = class {
     this.unwindReceiptWaiter = options.unwindReceiptWaiter;
   }
   getReceiptClient() {
-    this.receiptClient ??= createPaidRpcClient(base3, this.rpcUrls);
+    this.receiptClient ??= createPaidRpcClient(base4, this.rpcUrls);
     return this.receiptClient;
   }
+  /** Reads the actual proxy implementation; Yieldseeker's API walletType is not a version check. */
+  async getWalletStatus(state, chainId, asset, useCachedV2 = false) {
+    this.assertChain(chainId);
+    this.assertAsset(asset);
+    const context = await this.findAgent(state, chainId, asset);
+    if (!context) return null;
+    const key2 = `${chainId}:${state.walletAddress.toLowerCase()}:${context.wallet.walletAddress.toLowerCase()}:${asset}`;
+    const cached = this.withdrawalVersionCache.get(key2);
+    if (useCachedV2 && cached && Date.now() - cached.at < 15 * 6e4) return { ...cached.status };
+    const status = await readYieldseekerWalletStatus(
+      this.getReceiptClient(),
+      getAddress4(context.wallet.walletAddress),
+      getAddress4(state.walletAddress),
+      YIELDSEEKER_ASSET_METADATA[asset].address
+    );
+    if (status.verified && status.version === "v2") {
+      this.withdrawalVersionCache.set(key2, { at: Date.now(), status: { ...status } });
+      if (this.withdrawalVersionCache.size > 128)
+        this.withdrawalVersionCache.delete(this.withdrawalVersionCache.keys().next().value);
+    } else this.withdrawalVersionCache.delete(key2);
+    return status;
+  }
+  /** Explicit owner action. This never runs as a side effect of withdrawal. */
+  async upgradeWallet(state, chainId, asset, gasMode = "paid") {
+    const before = await this.getWalletStatus(state, chainId, asset);
+    if (!before?.verified || !before.upgradeAvailable) {
+      throw new OwneyError(
+        "WITHDRAW_FAILED",
+        "This Yieldseeker wallet cannot be upgraded to the reviewed V2 implementation.",
+        { version: before?.version ?? "missing" },
+        this.id
+      );
+    }
+    const data = encodeFunctionData({ abi: YIELDSEEKER_UPGRADE_ABI, functionName: "upgradeToLatest" });
+    let txHash;
+    if (gasMode === "sponsored") {
+      if (before.ownerPath !== "smart")
+        throw new OwneyError(
+          "SPONSOR_REQUEST_FAILED",
+          "EOA owners pay Base gas for the V1 upgrade.",
+          { safeToFallback: true },
+          this.id
+        );
+      let storage5;
+      try {
+        storage5 = typeof window === "undefined" ? void 0 : window.localStorage;
+      } catch {
+        storage5 = void 0;
+      }
+      if (!storage5)
+        throw new OwneyError(
+          "SPONSOR_REQUEST_FAILED",
+          "Upgrade status cannot be saved in this browser.",
+          { safeToFallback: true },
+          this.id
+        );
+      const pendingKey = `owney.yieldseeker.upgrade:${state.walletAddress.toLowerCase()}:${before.agentWallet.toLowerCase()}`;
+      let prior = null;
+      let saved;
+      try {
+        saved = storage5.getItem(pendingKey);
+      } catch {
+        throw new OwneyError(
+          "SPONSOR_REQUEST_FAILED",
+          "Upgrade status cannot be read in this browser.",
+          { safeToFallback: true },
+          this.id
+        );
+      }
+      try {
+        prior = JSON.parse(saved ?? "null");
+      } catch {
+        prior = { callsId: void 0 };
+      }
+      if (prior) {
+        if (!prior.callsId)
+          throw new OwneyError(
+            "SPONSOR_REQUEST_FAILED",
+            "An earlier upgrade submission is unresolved. Check wallet activity before retrying.",
+            { safeToFallback: false },
+            this.id
+          );
+        let callsStatus;
+        try {
+          callsStatus = await state.provider.request({
+            method: "wallet_getCallsStatus",
+            params: [prior.callsId]
+          });
+        } catch {
+          throw new OwneyError(
+            "SPONSOR_REQUEST_FAILED",
+            "The earlier upgrade status could not be checked.",
+            { safeToFallback: false, callsId: prior.callsId },
+            this.id
+          );
+        }
+        if (callsStatus?.status === 400 || callsStatus?.status === 500) {
+          storage5.removeItem(pendingKey);
+          throw new OwneyError(
+            "SPONSOR_REQUEST_FAILED",
+            "The earlier sponsored upgrade failed.",
+            { safeToFallback: true, callsId: prior.callsId },
+            this.id
+          );
+        }
+        const earlierHash = callsStatus?.receipts?.[0]?.transactionHash;
+        if (earlierHash) {
+          await this.waitForReceipt(state, chainId, earlierHash);
+          const earlierStatus = await this.getWalletStatus(state, chainId, asset);
+          if (earlierStatus?.version === "v2" && earlierStatus.verified) {
+            storage5.removeItem(pendingKey);
+            return { txHash: earlierHash, status: earlierStatus };
+          }
+        }
+        throw new OwneyError(
+          "SPONSOR_REQUEST_FAILED",
+          "An earlier upgrade is still pending.",
+          { safeToFallback: false, callsId: prior.callsId },
+          this.id
+        );
+      }
+      const context = await this.findAgent(state, chainId, asset);
+      if (!context) throw new OwneyError("NOT_CONNECTED", "Yieldseeker agent is unavailable.");
+      try {
+        const upgraded = await submitYieldseekerSponsoredUpgrade({
+          state,
+          client: this.getReceiptClient(),
+          apiKey: this.owneyApiKey,
+          routingApiBaseUrl: this.routingApiBaseUrl,
+          yieldseekerSignature: await this.auth.getToken(state, chainId),
+          userId: context.user.userId,
+          agentId: context.agent.agentId,
+          agentWallet: before.agentWallet,
+          asset: YIELDSEEKER_ASSET_METADATA[asset].address,
+          callData: data,
+          onPending: (pending) => {
+            const current = storage5.getItem(pendingKey);
+            storage5.setItem(pendingKey, JSON.stringify({
+              startedAt: Date.now(),
+              ...current ? JSON.parse(current) : {},
+              ...pending
+            }));
+          }
+        });
+        txHash = upgraded.txHash;
+      } catch (error) {
+        if (error?.code === 4001 || error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)) storage5.removeItem(pendingKey);
+        throw error;
+      }
+    } else {
+      txHash = await this.submitTransaction(state, chainId, {
+        from: getAddress4(state.walletAddress),
+        to: before.agentWallet,
+        data,
+        value: "0",
+        chainId
+      });
+    }
+    const status = await this.getWalletStatus(state, chainId, asset);
+    if (!status?.verified || status.version !== "v2") {
+      throw new OwneyError(
+        "WITHDRAW_FAILED",
+        "Yieldseeker wallet upgrade was not confirmed as V2.",
+        { txHash, version: status?.version ?? "missing" },
+        this.id
+      );
+    }
+    if (gasMode === "sponsored" && typeof window !== "undefined")
+      window.localStorage.removeItem(`owney.yieldseeker.upgrade:${state.walletAddress.toLowerCase()}:${before.agentWallet.toLowerCase()}`);
+    return { txHash, status };
+  }
   async disconnect() {
+    this.withdrawalVersionCache.clear();
     this.readGeneration += 1;
     this.auth.clear();
     for (const key2 of this.users.keys()) {
@@ -3901,12 +4574,12 @@ var YieldseekerAgent = class {
       receipt = await this.waitForReceipt(state, chainId, txHash);
     } else {
       txHash = await this.submitTransaction(state, chainId, {
-        from: getAddress2(state.walletAddress),
+        from: getAddress4(state.walletAddress),
         to: YIELDSEEKER_ASSET_METADATA[asset].address,
         data: encodeFunctionData({
           abi: erc20Abi2,
           functionName: "transfer",
-          args: [getAddress2(context.wallet.walletAddress), BigInt(amount)]
+          args: [getAddress4(context.wallet.walletAddress), BigInt(amount)]
         }),
         value: "0",
         chainId
@@ -3917,12 +4590,12 @@ var YieldseekerAgent = class {
     if (this.readGeneration === generation) {
       void this.refreshSnapshotAfterMovement(state, chainId, context, "deposit", movement);
     }
-    const base5 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount, confirmedAmount: amount, txHash, transfer: "confirmed", registration: "not-applicable", delivery: "not-applicable" };
-    const evidence = receipt ? inspectFundingReceipt(receipt, base5, YIELDSEEKER_ASSET_METADATA[asset].address, "deposit") : base5;
+    const base6 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount, confirmedAmount: amount, txHash, transfer: "confirmed", registration: "not-applicable", delivery: "not-applicable" };
+    const evidence = receipt ? inspectFundingReceipt(receipt, base6, YIELDSEEKER_ASSET_METADATA[asset].address, "deposit") : base6;
     notifyFunding(onProgress, evidence);
     return { txHash, smartWallet: context.wallet.walletAddress, amount, evidence };
   }
-  async withdraw(state, chainId, asset, amount, onProgress) {
+  async withdraw(state, chainId, asset, amount, onProgress, gasMode = "auto") {
     let ownerTransferAttempted = false;
     let evidence = {
       agentId: this.id,
@@ -3940,14 +4613,20 @@ var YieldseekerAgent = class {
         notifyFunding(onProgress, evidence);
       }, () => {
         ownerTransferAttempted = true;
-      });
+      }, gasMode);
     } catch (error) {
-      if (!ownerTransferAttempted || error instanceof OwneyError && error.code === "AGENT_TRANSACTION_REVERTED")
-        notifyFunding(onProgress, { ...evidence, transfer: "failed", delivery: "failed" });
+      if (error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED") this.withdrawalVersionCache.clear();
+      if (!ownerTransferAttempted || error?.code === 4001 || error instanceof OwneyError && (error.code === "AGENT_TRANSACTION_REVERTED" || error.code === "SPONSOR_REQUEST_FAILED" && (error.details?.safeToFallback === true || error.details?.executionFailed === true)))
+        notifyFunding(onProgress, {
+          ...evidence,
+          ...error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && error.details?.safeToFallback === true ? { userOpHash: void 0, callsId: void 0 } : {},
+          transfer: "failed",
+          delivery: "failed"
+        });
       throw error;
     }
   }
-  async withdrawInternal(state, chainId, asset, amount, onProgress, onOwnerTransferAttempted) {
+  async withdrawInternal(state, chainId, asset, amount, onProgress, onOwnerTransferAttempted, gasMode = "auto") {
     this.assertChain(chainId);
     this.assertAsset(asset);
     if (amount !== void 0 && BigInt(amount) <= 0n) {
@@ -3967,10 +4646,32 @@ var YieldseekerAgent = class {
         this.id
       );
     }
+    let sponsor = false;
+    if (gasMode !== "paid") {
+      const status = await this.getWalletStatus(state, chainId, asset, true).catch(() => {
+        if (gasMode === "sponsored")
+          throw new OwneyError(
+            "SPONSOR_REQUEST_FAILED",
+            "Could not verify the Yieldseeker wallet for sponsorship.",
+            { safeToFallback: true, version: "unknown" },
+            this.id
+          );
+        return null;
+      });
+      sponsor = !!status?.verified && status.version === "v2";
+      if (gasMode === "sponsored" && !sponsor)
+        throw new OwneyError(
+          "SPONSOR_REQUEST_FAILED",
+          "Only a verified Yieldseeker V2 Agent Wallet can use sponsored withdrawals.",
+          { safeToFallback: true, version: status?.version ?? "unknown" },
+          this.id
+        );
+    }
     const generation = this.readGeneration;
     let confirmedMovement = false;
     let settlement = null;
     try {
+      if (amount === void 0) this.advancePortfolioVersion(this.contextKey(state, chainId, asset));
       const portfolio = await this.loadPortfolioContext(
         state,
         chainId,
@@ -3982,13 +4683,41 @@ var YieldseekerAgent = class {
           address: metadata.address,
           abi: erc20Abi2,
           functionName: "balanceOf",
-          args: [getAddress2(context.wallet.walletAddress)]
+          args: [getAddress4(context.wallet.walletAddress)]
         }), chainId, "eth_call", this.id);
         this.assertSession(generation, chainId, asset);
         return balance;
       };
       const idle = await readIdle();
-      const deployed = portfolio.positions.reduce(
+      let positions = portfolio.positions;
+      let positionsStatus = "empty";
+      const validatePositions = (values) => {
+        const seen = /* @__PURE__ */ new Set();
+        for (const value of values) {
+          const address = value?.yieldOption?.address;
+          if (typeof address !== "string" || !isAddress2(address) || seen.has(address.toLowerCase()) || typeof value.assetsRaw !== "string" || !/^\d+$/.test(value.assetsRaw) || typeof value.withdrawableAssetsRaw !== "string" || !/^\d+$/.test(value.withdrawableAssetsRaw))
+            throw this.invalidResponse("yield positions");
+          seen.add(address.toLowerCase());
+        }
+        return values;
+      };
+      const hasPositions = (values) => values.some((position2) => BigInt(position2.assetsRaw) > 0n || BigInt(position2.withdrawableAssetsRaw) > 0n);
+      const refreshPositions = async () => {
+        this.assertSession(generation, chainId, asset);
+        const response = await this.walletRequest(
+          state,
+          chainId,
+          this.agentPath(context, "yield-positions")
+        );
+        this.assertSession(generation, chainId, asset);
+        if (!Array.isArray(response?.yieldPositions)) throw this.invalidResponse("yield positions");
+        return validatePositions(response.yieldPositions);
+      };
+      if (amount === void 0) {
+        validatePositions(positions);
+        positionsStatus = hasPositions(positions) ? "remaining" : "empty";
+      }
+      const deployed = positions.reduce(
         (total, position2) => total + BigInt(position2.withdrawableAssetsRaw),
         0n
       );
@@ -3996,6 +4725,13 @@ var YieldseekerAgent = class {
       const requested = amount === void 0 ? totalAvailable : BigInt(amount);
       if (requested === 0n) {
         this.invalidateFundingRead(state, chainId, asset);
+        if (amount === void 0 && positionsStatus === "remaining")
+          throw new OwneyError(
+            "WITHDRAW_FAILED",
+            "Yieldseeker vault funds are not currently withdrawable.",
+            { asset, remainingPositions: positions.map((position2) => position2.yieldOption.address) },
+            this.id
+          );
         throw new OwneyError(
           "WITHDRAW_INSUFFICIENT_BALANCE",
           "No Yieldseeker funds are available to withdraw.",
@@ -4016,40 +4752,74 @@ var YieldseekerAgent = class {
         );
       }
       let remaining = requested > idle ? requested - idle : 0n;
-      for (const position2 of portfolio.positions) {
-        if (remaining === 0n) break;
-        const available = BigInt(position2.withdrawableAssetsRaw);
-        if (available <= 0n) continue;
-        const assetsRaw = available < remaining ? available : remaining;
+      let grossUnwound = 0n;
+      const unwind = async (position2, assetsRaw) => {
+        this.assertSession(generation, chainId, asset);
         const response = await this.walletRequest(
           state,
           chainId,
           this.agentPath(context, "withdraw-from-position"),
           {
             method: "POST",
-            body: {
-              chainId,
-              vaultAddress: position2.yieldOption.address,
-              assetsRaw: assetsRaw.toString()
-            }
+            body: { chainId, vaultAddress: position2.yieldOption.address, assetsRaw: assetsRaw.toString() }
           }
         );
-        if (!this.isTransactionHash(response?.transactionHash)) {
-          throw this.invalidResponse("position withdrawal");
-        }
+        if (!this.isTransactionHash(response?.transactionHash)) throw this.invalidResponse("position withdrawal");
         await this.waitForReceipt(state, chainId, response.transactionHash);
         confirmedMovement = true;
-        remaining -= assetsRaw;
+        this.assertSession(generation, chainId, asset);
+        grossUnwound += assetsRaw;
+      };
+      if (amount === void 0) {
+        for (let sweep = 0; sweep < YIELDSEEKER_MAX_WITHDRAW_SWEEPS && hasPositions(positions); sweep++) {
+          const before = new Map(positions.map((position2) => [position2.yieldOption.address.toLowerCase(), BigInt(position2.assetsRaw)]));
+          let unwound = false;
+          for (const position2 of positions) {
+            const available = BigInt(position2.withdrawableAssetsRaw);
+            if (available <= 0n) continue;
+            await unwind(position2, available);
+            unwound = true;
+          }
+          if (!unwound) break;
+          try {
+            positions = await refreshPositions();
+            positionsStatus = hasPositions(positions) ? "remaining" : "empty";
+          } catch {
+            this.assertSession(generation, chainId, asset);
+            positionsStatus = "unavailable";
+            break;
+          }
+          if (positions.some((position2) => BigInt(position2.assetsRaw) > 0n && before.has(position2.yieldOption.address.toLowerCase()) && BigInt(position2.assetsRaw) >= before.get(position2.yieldOption.address.toLowerCase()))) break;
+        }
+      } else {
+        for (const position2 of positions) {
+          if (remaining === 0n) break;
+          const available = BigInt(position2.withdrawableAssetsRaw);
+          if (available <= 0n) continue;
+          const assetsRaw = available < remaining ? available : remaining;
+          await unwind(position2, assetsRaw);
+          remaining -= assetsRaw;
+        }
       }
-      if (remaining > 0n) {
+      if (amount !== void 0 && remaining > 0n) {
         throw this.invalidResponse("yield positions", {
           reason: "Withdrawable positions could not cover the request.",
           remaining: remaining.toString()
         });
       }
       const availableForOwner = confirmedMovement ? await readIdle() : idle;
-      if (availableForOwner === 0n || amount !== void 0 && availableForOwner < requested) {
+      const feeRate = portfolio.snapshot.feeRateBps;
+      const maxFee = confirmedMovement && Number.isInteger(feeRate) && feeRate >= 0 && feeRate <= 1e3 ? (grossUnwound * BigInt(feeRate) + 9999n) / 10000n : 0n;
+      const shortfall = availableForOwner < requested ? requested - availableForOwner : 0n;
+      if (availableForOwner === 0n || amount !== void 0 && shortfall > maxFee) {
         this.invalidateFundingRead(state, chainId, asset);
+        if (amount === void 0 && positionsStatus !== "empty")
+          throw new OwneyError(
+            "WITHDRAW_FAILED",
+            "Yieldseeker vault funds could not be cleared for the owner transfer.",
+            { asset, positionsStatus },
+            this.id
+          );
         throw new OwneyError(
           "WITHDRAW_INSUFFICIENT_BALANCE",
           "Yieldseeker funds are not available for the owner transfer.",
@@ -4057,33 +4827,80 @@ var YieldseekerAgent = class {
           this.id
         );
       }
-      const payout = amount === void 0 ? availableForOwner : requested;
+      const payout = amount === void 0 || availableForOwner < requested ? availableForOwner : requested;
       const plannedMovement = this.snapshotMovement(state, chainId, context, -payout);
-      const account = getAddress2(state.walletAddress);
+      const account = getAddress4(state.walletAddress);
       let receipt;
-      const base5 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount === void 0 ? "MAX" : requested.toString(), transfer: "pending", registration: "not-applicable", delivery: "pending" };
-      onOwnerTransferAttempted?.();
-      const txHash = await this.submitTransaction(state, chainId, {
-        from: account,
-        to: getAddress2(context.wallet.walletAddress),
-        data: amount === void 0 ? encodeFunctionData({
-          abi: YIELDSEEKER_AGENT_WALLET_ABI,
-          functionName: "withdrawAllAssetToUser",
-          args: [account, metadata.address]
-        }) : encodeFunctionData({
-          abi: YIELDSEEKER_AGENT_WALLET_ABI,
-          functionName: "withdrawAssetToUser",
-          args: [account, metadata.address, requested]
-        }),
-        value: "0",
-        chainId
-      }, (hash) => notifyFunding(onProgress, { ...base5, txHash: hash }), (value) => {
-        receipt = value;
+      const base6 = { agentId: this.id, chainId, token: asset, walletAddress: state.walletAddress, agentWallet: context.wallet.walletAddress, intendedAmount: amount === void 0 ? "MAX" : payout.toString(), transfer: "pending", registration: "not-applicable", delivery: "pending" };
+      const data = amount === void 0 ? encodeFunctionData({
+        abi: YIELDSEEKER_AGENT_WALLET_ABI,
+        functionName: "withdrawAllAssetToUser",
+        args: [account, metadata.address]
+      }) : encodeFunctionData({
+        abi: YIELDSEEKER_AGENT_WALLET_ABI,
+        functionName: "withdrawAssetToUser",
+        args: [account, metadata.address, payout]
       });
+      onOwnerTransferAttempted?.();
+      let txHash;
+      if (sponsor) {
+        const submitted = await submitYieldseekerSponsoredWithdrawal({
+          state,
+          client: this.getReceiptClient(),
+          apiKey: this.owneyApiKey,
+          routingApiBaseUrl: this.routingApiBaseUrl,
+          yieldseekerSignature: await this.auth.getToken(state, chainId),
+          userId: context.user.userId,
+          agentId: context.agent.agentId,
+          agentWallet: getAddress4(context.wallet.walletAddress),
+          asset: metadata.address,
+          callData: data,
+          onPending: (pending) => notifyFunding(onProgress, { ...base6, ...pending })
+        });
+        txHash = submitted.txHash;
+        receipt = submitted.receipt;
+      } else {
+        txHash = await this.submitTransaction(state, chainId, {
+          from: account,
+          to: getAddress4(context.wallet.walletAddress),
+          data,
+          value: "0",
+          chainId
+        }, (hash) => notifyFunding(onProgress, { ...base6, txHash: hash }), (value) => {
+          receipt = value;
+        });
+      }
       confirmedMovement = true;
       settlement = plannedMovement;
-      const evidence = receipt ? inspectFundingReceipt(receipt, { ...base5, txHash }, metadata.address, "withdraw") : { ...base5, txHash, confirmedAmount: payout.toString(), transfer: "confirmed", delivery: "confirmed" };
+      const evidence = receipt ? inspectFundingReceipt(receipt, { ...base6, txHash }, metadata.address, "withdraw") : { ...base6, txHash, confirmedAmount: payout.toString(), transfer: "confirmed", delivery: "confirmed" };
       notifyFunding(onProgress, evidence);
+      if (amount === void 0) {
+        try {
+          positions = await refreshPositions();
+          positionsStatus = hasPositions(positions) ? "remaining" : "empty";
+        } catch {
+          positionsStatus = "unavailable";
+        }
+        if (positionsStatus !== "empty") {
+          const result = { txHash, type: "partial", amount: evidence.confirmedAmount ?? payout.toString(), evidence };
+          throw new OwneyError(
+            "WITHDRAW_PARTIAL_FAILURE",
+            "Yieldseeker MAX could not confirm that all vault positions were cleared.",
+            {
+              reason: "YIELDSEEKER_MAX_INCOMPLETE",
+              asset,
+              positionsStatus,
+              remainingPositions: positionsStatus === "remaining" ? positions.map((position2) => ({
+                vaultAddress: position2.yieldOption.address,
+                sharesRaw: position2.assetsRaw,
+                withdrawableAmountRaw: position2.withdrawableAssetsRaw
+              })) : void 0,
+              partialResults: { [this.id]: result }
+            },
+            this.id
+          );
+        }
+      }
       if (evidence.transfer === "failed" && evidence.confirmedAmount === "0")
         throw new OwneyError(
           "WITHDRAW_INSUFFICIENT_BALANCE",
@@ -4325,7 +5142,7 @@ var YieldseekerAgent = class {
       this.users.set(key2, persisted);
       return persisted;
     }
-    const walletAddress = getAddress2(state.walletAddress);
+    const walletAddress = getAddress4(state.walletAddress);
     const generation = this.readGeneration;
     let user = null;
     try {
@@ -4816,15 +5633,15 @@ var YieldseekerAgent = class {
       return hash2;
     }
     this.assertTransaction(transaction, state, chainId);
-    const account = getAddress2(state.walletAddress);
-    const walletClient = createWalletClient2({
+    const account = getAddress4(state.walletAddress);
+    const walletClient = createWalletClient3({
       account,
-      chain: base3,
-      transport: custom2(state.provider)
+      chain: base4,
+      transport: custom3(state.provider)
     });
     const walletChainClient = createPublicClient3({
-      chain: base3,
-      transport: custom2(state.provider)
+      chain: base4,
+      transport: custom3(state.provider)
     });
     await ensureWalletOnChain(
       walletChainClient,
@@ -4833,8 +5650,8 @@ var YieldseekerAgent = class {
     );
     const hash = await walletClient.sendTransaction({
       account,
-      chain: base3,
-      to: getAddress2(transaction.to),
+      chain: base4,
+      to: getAddress4(transaction.to),
       data: transaction.data,
       value: BigInt(transaction.value)
     });
@@ -4884,7 +5701,7 @@ var YieldseekerAgent = class {
     return receipt;
   }
   assertTransaction(transaction, state, chainId) {
-    if (!transaction || typeof transaction.from !== "string" || !isAddress2(transaction.from) || typeof transaction.to !== "string" || !isAddress2(transaction.to) || typeof transaction.data !== "string" || !/^0x[a-fA-F0-9]*$/.test(transaction.data) || typeof transaction.value !== "string" || !/^[0-9]+$/.test(transaction.value) || transaction.chainId !== chainId || getAddress2(transaction.from) !== getAddress2(state.walletAddress)) {
+    if (!transaction || typeof transaction.from !== "string" || !isAddress2(transaction.from) || typeof transaction.to !== "string" || !isAddress2(transaction.to) || typeof transaction.data !== "string" || !/^0x[a-fA-F0-9]*$/.test(transaction.data) || typeof transaction.value !== "string" || !/^[0-9]+$/.test(transaction.value) || transaction.chainId !== chainId || getAddress4(transaction.from) !== getAddress4(state.walletAddress)) {
       throw this.invalidResponse("transaction");
     }
   }
@@ -4946,6 +5763,7 @@ var YieldseekerAgent = class {
 
 // src/lib/routing-api.ts
 var ROUTING_API_BASE_URL2 = "https://owney-routing-api-243946518160.europe-west4.run.app";
+var getRoutingApiBaseUrl = (override) => override ?? ROUTING_API_BASE_URL2;
 async function fetchOrgAgentConfig(apiKey, baseUrl = ROUTING_API_BASE_URL2) {
   const url = `${baseUrl}/api/v1/agent/org-config`;
   try {
@@ -5230,20 +6048,20 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 // src/client.ts
 import {
   createPublicClient as createPublicClient4,
-  createWalletClient as createWalletClient3,
-  custom as custom3
+  createWalletClient as createWalletClient4,
+  custom as custom4
 } from "viem";
-import { base as base4, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
+import { base as base5, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
 
 // src/lib/sponsored-token-batch.ts
 import {
-  isAddressEqual,
+  isAddressEqual as isAddressEqual2,
   keccak256,
   toBytes
 } from "viem";
 
 // src/lib/permit2-batch.ts
-import { parseAbi as parseAbi3, hashStruct } from "viem";
+import { parseAbi as parseAbi4, hashStruct } from "viem";
 var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 var ERC2612_PERMIT_TYPES = {
@@ -5255,7 +6073,7 @@ var ERC2612_PERMIT_TYPES = {
     { name: "deadline", type: "uint256" }
   ]
 };
-var ERC2612_READ_ABI = parseAbi3([
+var ERC2612_READ_ABI = parseAbi4([
   "function name() view returns (string)",
   "function version() view returns (string)",
   "function nonces(address owner) view returns (uint256)"
@@ -5293,7 +6111,7 @@ var PERMIT_BATCH_TYPES = {
     { name: "amount", type: "uint256" }
   ]
 };
-var PERMIT2_BATCH_ABI = parseAbi3([
+var PERMIT2_BATCH_ABI = parseAbi4([
   "struct TokenPermissions { address token; uint256 amount; }",
   "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
   "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
@@ -5433,7 +6251,7 @@ async function execute(i, key2, plan) {
   const saved = read(key2);
   if (saved) {
     const previous = JSON.parse(saved);
-    if (previous.chainId !== i.chainId || !isAddressEqual(previous.from, i.owner) || !isAddressEqual(previous.token, i.token) || planOf(previous.transfers) !== plan)
+    if (previous.chainId !== i.chainId || !isAddressEqual2(previous.from, i.owner) || !isAddressEqual2(previous.token, i.token) || planOf(previous.transfers) !== plan)
       throw new Error(
         "Retry the previous token deposit and agent split first to reconcile its status."
       );
@@ -5450,7 +6268,7 @@ async function execute(i, key2, plan) {
       "DEPOSIT_INSUFFICIENT_BALANCE",
       "Insufficient token balance for this deposit."
     );
-  if (allowance < total && (i.chainId !== 8453 || !isAddressEqual(i.token, BASE_USDC_ADDRESS)))
+  if (allowance < total && (i.chainId !== 8453 || !isAddressEqual2(i.token, BASE_USDC_ADDRESS)))
     throw new OwneyError(
       "PERMIT2_APPROVAL_REQUIRED",
       "token deposits need a one-time Permit2 approval."
@@ -5628,7 +6446,7 @@ async function runAgentDepositBatch(chainId, legs, transfer) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi3, toHex } from "viem";
+import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi3, toHex as toHex2 } from "viem";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -5636,7 +6454,7 @@ async function paymasterSupported(provider, owner, chainId) {
     method: "wallet_getCapabilities",
     params: [owner]
   });
-  const forChain = caps?.[toHex(chainId)] ?? caps?.[String(chainId)];
+  const forChain = caps?.[toHex2(chainId)] ?? caps?.[String(chainId)];
   return Boolean(forChain?.paymasterService?.supported);
 }
 function makeSponsoredCallsCallback(deps) {
@@ -5712,7 +6530,7 @@ function makeSponsoredCallsCallback(deps) {
         {
           version: "2.0.0",
           from: deps.ownerAddress,
-          chainId: toHex(chainId),
+          chainId: toHex2(chainId),
           atomicRequired: transfers.length > 1,
           calls,
           capabilities: {
@@ -5806,7 +6624,7 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: base4,
+  8453: base5,
   42161: arbitrum2,
   1: mainnet2
 };
@@ -5983,12 +6801,12 @@ var OwneySDK = class {
       getPublicClient: (cid) => this.getPaidRpcClient(cid),
       getWalletChainClient: (cid) => createPublicClient4({
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom4(provider)
       }),
-      getWalletClient: (cid) => createWalletClient3({
+      getWalletClient: (cid) => createWalletClient4({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom4(provider)
       })
     });
     if (!onApproved && !onSubmitted) this.cachedSponsoredCallback = callback;
@@ -6036,12 +6854,12 @@ var OwneySDK = class {
       getPublicClient: (cid) => this.getPaidRpcClient(cid),
       getWalletChainClient: (cid) => createPublicClient4({
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom4(provider)
       }),
-      getWalletClient: (cid) => createWalletClient3({
+      getWalletClient: (cid) => createWalletClient4({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom4(provider)
       })
     });
     if (!onApproved && !onSubmitted) this.cachedWethSponsoredCallback = callback;
@@ -6162,6 +6980,7 @@ var OwneySDK = class {
     }
     if (agentId === "yieldseeker") {
       return new YieldseekerAgent(this.apiKey, {
+        routingApiBaseUrl: this.routingApiBaseUrl,
         auth: { origin: this.yieldseekerSiweOrigin },
         baseUrl: this.yieldseekerApiBaseUrl ?? getYieldseekerProxyBaseUrl(this.routingApiBaseUrl),
         rpcUrls: this.rpcUrls
@@ -6753,14 +7572,14 @@ var OwneySDK = class {
       throw new OwneyError("AGENT_API_ERROR", "Funding wallet does not match this account.");
     const token = SupportedAssets.find((t) => t.chainId === chainId && t.symbol === evidence.token);
     if (!token) throw new OwneyError("CHAIN_UNSUPPORTED", "Unsupported funding asset.");
-    const rpc = this.getPaidRpcClient(chainId);
-    const receipt = await rpc.getTransactionReceipt({ hash: evidence.txHash });
+    const rpc2 = this.getPaidRpcClient(chainId);
+    const receipt = await rpc2.getTransactionReceipt({ hash: evidence.txHash });
     assertCurrent();
     let verified = inspectFundingReceipt(receipt, { ...evidence, agentWallet }, token.address, direction);
     if (direction === "withdraw" && evidence.agentId === "yieldseeker" && verified.transfer === "unknown" && verified.confirmedAmount && BigInt(verified.confirmedAmount) > 0n) {
-      const transaction = await rpc.getTransaction({ hash: evidence.txHash });
+      const transaction = await rpc2.getTransaction({ hash: evidence.txHash });
       assertCurrent();
-      if (isFullYieldseekerWithdrawal(transaction, { ...evidence, agentWallet }, token.address))
+      if (isFullYieldseekerWithdrawal(transaction, { ...evidence, agentWallet }, token.address, receipt))
         verified = inspectFundingReceipt(receipt, { ...evidence, agentWallet, intendedAmount: "MAX" }, token.address, direction);
     }
     const key2 = `${state.walletAddress.toLowerCase()}:${chainId}:${evidence.agentId}:${evidence.token}:${evidence.txHash}`;
@@ -6772,6 +7591,45 @@ var OwneySDK = class {
     }
     return verified;
   }
+  /** Resolve a saved sponsored-withdrawal ID without opening a wallet prompt. */
+  async resolveSponsoredWithdrawalEvidence(evidence) {
+    const { state, chainId, assertCurrent } = this.captureReadScope(evidence.chainId);
+    if (evidence.agentId !== "yieldseeker" || chainId !== 8453 || evidence.txHash || state.walletAddress.toLowerCase() !== evidence.walletAddress.toLowerCase()) return evidence;
+    const agent = this.getAgent("yieldseeker");
+    const wallet = await agent.getFundingWallet?.(state, chainId, evidence.token);
+    if (!wallet || wallet.toLowerCase() !== evidence.agentWallet?.toLowerCase()) return evidence;
+    let txHash;
+    let executionFailed = false;
+    if (evidence.userOpHash && /^0x[0-9a-fA-F]{64}$/.test(evidence.userOpHash)) {
+      const response = await fetch(`${getRoutingApiBaseUrl(this.routingApiBaseUrl).replace(/\/$/, "")}/api/v1/sponsor/yieldseeker-withdraw/resolve`, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-owney-api-key": this.apiKey },
+        body: JSON.stringify({
+          owner: state.walletAddress,
+          agentWallet: wallet,
+          asset: SupportedAssets.find((t) => t.chainId === chainId && t.symbol === evidence.token)?.address,
+          userOpHash: evidence.userOpHash
+        })
+      });
+      if (!response.ok) throw new OwneyError("AGENT_API_ERROR", "Could not resolve sponsored withdrawal status.");
+      const payload = await response.json();
+      txHash = payload.data?.txHash ?? void 0;
+      executionFailed = payload.data?.executionFailed === true;
+    } else if (evidence.callsId) {
+      const status = await state.provider.request({ method: "wallet_getCallsStatus", params: [evidence.callsId] });
+      if (status?.id && status.id !== evidence.callsId || status?.chainId && Number(status.chainId) !== chainId) return evidence;
+      executionFailed = status?.status === 400 || status?.status === 500;
+      txHash = status?.receipts?.[0]?.transactionHash;
+    }
+    assertCurrent();
+    if (executionFailed) return {
+      ...evidence,
+      ...txHash && /^0x[0-9a-fA-F]{64}$/.test(txHash) ? { txHash } : {},
+      transfer: "failed",
+      delivery: "failed"
+    };
+    return txHash && /^0x[0-9a-fA-F]{64}$/.test(txHash) ? { ...evidence, txHash } : evidence;
+  }
   /** A display acknowledgement controls polling only; it never confirms a financial outcome. */
   endFundingBalanceRefresh(evidence, read2) {
     const { state, chainId } = this.captureReadScope(evidence.chainId);
@@ -6796,6 +7654,39 @@ var OwneySDK = class {
     return this.getAgent("zyfai").retryDepositRegistration(this.requireState(), verified);
   }
   // --- Fund operations ---
+  /** On-chain version and ownership status for this owner's Yieldseeker agent. */
+  async getYieldseekerWalletStatus(asset) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const agent = this.getAgent("yieldseeker");
+    return agent.getWalletStatus(state, chainId, asset);
+  }
+  /** Deployment gate; an unavailable response keeps the current paid path. */
+  async isYieldseekerWithdrawalSponsorshipAvailable() {
+    return this.isYieldseekerSponsorshipAvailable("withdraw");
+  }
+  async isYieldseekerUpgradeSponsorshipAvailable() {
+    return this.isYieldseekerSponsorshipAvailable("upgrade");
+  }
+  async isYieldseekerSponsorshipAvailable(action) {
+    const baseUrl = getRoutingApiBaseUrl(this.routingApiBaseUrl).replace(/\/$/, "");
+    try {
+      const owner = this.requireState().walletAddress;
+      const response = await fetch(`${baseUrl}/api/v1/sponsor/yieldseeker-withdraw/availability?owner=${encodeURIComponent(owner)}&action=${action}`);
+      if (!response.ok) return false;
+      const payload = await response.json();
+      return payload.data?.enabled === true;
+    } catch {
+      return false;
+    }
+  }
+  /** Explicit V1-to-V2 upgrade, confirmed on chain before returning. */
+  async upgradeYieldseekerWallet(asset, gasMode = "paid") {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const agent = this.getAgent("yieldseeker");
+    return agent.upgradeWallet(state, chainId, asset, gasMode);
+  }
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
    * Validates that the asset is supported by the target agent(s) on the active chain.
@@ -6859,7 +7750,7 @@ var OwneySDK = class {
       };
       progress(evidence);
       try {
-        return await agent.withdraw(state, chainId, token, requested2, progress);
+        return await (options.gasMode === void 0 ? agent.withdraw(state, chainId, token, requested2, progress) : agent.withdraw(state, chainId, token, requested2, progress, options.gasMode));
       } catch (error) {
         if (!evidence.txHash && (this.isUserRejectedWithdrawal(error) || /insufficient (balance|funds)/i.test(error instanceof Error ? error.message : "")))
           progress({ ...evidence, transfer: "failed", delivery: "failed" });
@@ -6892,13 +7783,23 @@ var OwneySDK = class {
     if (!amount) {
       const results2 = {};
       const agentErrors2 = {};
+      const incompleteWithdrawals = {};
       for (const agent of withdrawalAgents) {
         try {
           results2[agent.id] = await submit(agent);
           notifyAgentResult(agent.id, results2[agent.id]);
         } catch (err) {
+          if (err instanceof OwneyError && err.code === "SPONSOR_REQUEST_FAILED" && err.details?.safeToFallback === true) throw err;
           if (this.isUserRejectedWithdrawal(err)) throw err;
           if (err instanceof OwneyError && err.code === "WITHDRAW_INSUFFICIENT_BALANCE" && err.details?.available === "0" && submissionEvidence.get(agent.id)?.transfer === "failed") continue;
+          if (agent.id === "yieldseeker" && err instanceof OwneyError && err.code === "WITHDRAW_PARTIAL_FAILURE" && err.details?.reason === "YIELDSEEKER_MAX_INCOMPLETE") {
+            incompleteWithdrawals[agent.id] = { positionsStatus: err.details.positionsStatus };
+            const evidence = submissionEvidence.get(agent.id);
+            if (evidence?.agentId === agent.id && evidence.chainId === chainId && evidence.token === token && evidence.walletAddress.toLowerCase() === state.walletAddress.toLowerCase() && evidence.intendedAmount === "MAX" && evidence.transfer === "confirmed" && evidence.delivery === "confirmed" && evidence.txHash && /^0x[\da-f]{64}$/i.test(evidence.txHash) && evidence.confirmedAmount && /^\d+$/.test(evidence.confirmedAmount) && BigInt(evidence.confirmedAmount) > 0n) {
+              results2[agent.id] = { txHash: evidence.txHash, type: "partial", amount: evidence.confirmedAmount, evidence };
+              notifyAgentResult(agent.id, results2[agent.id]);
+            }
+          }
           console.error(`withdraw failed for agent "${agent.id}":`, err);
           agentErrors2[agent.id] = err instanceof Error ? err.message : String(err);
           const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
@@ -6921,7 +7822,7 @@ var OwneySDK = class {
         throw new OwneyError(
           "WITHDRAW_PARTIAL_FAILURE",
           "Some agents could not complete the withdrawal.",
-          { asset, partialResults: results2, agentErrors: agentErrors2 }
+          { asset, partialResults: results2, agentErrors: agentErrors2, ...Object.keys(incompleteWithdrawals).length ? { incompleteWithdrawals } : {} }
         );
       }
       const amountsKnown = Object.values(results2).every(
@@ -6998,6 +7899,7 @@ var OwneySDK = class {
         results[p.agent.id] = await submit(p.agent, p.planned.toString());
         notifyAgentResult(p.agent.id, results[p.agent.id]);
       } catch (err) {
+        if (err instanceof OwneyError && err.code === "SPONSOR_REQUEST_FAILED" && err.details?.safeToFallback === true) throw err;
         if (this.isUserRejectedWithdrawal(err)) throw err;
         console.error(`withdraw failed for agent "${p.agent.id}":`, err);
         agentErrors[p.agent.id] = err instanceof Error ? err.message : String(err);
@@ -7497,14 +8399,14 @@ var OwneySDK = class {
     const provider = this.requireConnectedProvider();
     const walletChainClient = createPublicClient4({
       chain: VIEM_CHAIN2[chainId],
-      transport: custom3(provider)
+      transport: custom4(provider)
     });
     const publicClient = this.getPaidRpcClient(chainId);
     const approvalAmount = permit2ApprovalAmount(requiredAmount);
-    const wallet = createWalletClient3({
+    const wallet = createWalletClient4({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: custom3(provider)
+      transport: custom4(provider)
     });
     await ensureWalletOnChain(walletChainClient, wallet, chainId);
     const hash = await wallet.writeContract({
@@ -7666,7 +8568,7 @@ var OwneySDK = class {
 };
 
 // src/agents/zyfai/zyfai.siwx.ts
-import { getAddress as getAddress3 } from "viem";
+import { getAddress as getAddress5 } from "viem";
 import { SiweMessage as SiweMessage2 } from "siwe";
 import { ZyfaiSDK as ZyfaiSDK2 } from "@zyfai/sdk";
 
@@ -7793,7 +8695,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new SiweMessage2({
-          address: getAddress3(accountAddress),
+          address: getAddress5(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,