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

package/dist/index.cjs

@@ -2632,8 +2632,8 @@ var ZyfaiAgent = class _ZyfaiAgent {
 };
 
 // src/agents/yieldseeker/yieldseeker.agent.ts
-var import_viem8 = require("viem");
-var import_chains3 = require("viem/chains");
+var import_viem10 = require("viem");
+var import_chains4 = require("viem/chains");
 
 // src/lib/chain-guard.ts
 var CHAIN_NAMES = {
@@ -2676,10 +2676,10 @@ var import_viem4 = require("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",
@@ -2715,11 +2715,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 }
       }
@@ -3740,6 +3740,395 @@ function mapYieldseekerAgentApy(options, days) {
   };
 }
 
+// src/agents/yieldseeker/yieldseeker.wallet-version.ts
+var import_viem8 = require("viem");
+var YIELDSEEKER_FACTORY = "0x9c7410a0faCAC60850C46eE5b58B518daec95130";
+var YIELDSEEKER_V1_IMPLEMENTATION = "0x32403455357589523435dB18b414057D7cE05051";
+var YIELDSEEKER_V2_IMPLEMENTATION = "0x613Db9c924ADB7A7A90c11b02Cce20c913E3Fe50";
+var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+var walletAbi = (0, import_viem8.parseAbi)([
+  "function owner() view returns (address)",
+  "function ownerAgentIndex() view returns (uint256)",
+  "function baseAsset() view returns (address)",
+  "function FACTORY() view returns (address)",
+  "function upgradeToLatest()"
+]);
+var factoryAbi = (0, import_viem8.parseAbi)([
+  "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 = (0, import_viem8.getAddress)(wallet);
+  const expectedOwner = (0, import_viem8.getAddress)(owner);
+  const expectedAsset = (0, import_viem8.getAddress)(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 = (0, import_viem8.getAddress)(`0x${slot.slice(-40)}`);
+  const mapped = await client.readContract({
+    address: YIELDSEEKER_FACTORY,
+    abi: factoryAbi,
+    functionName: "userWallets",
+    args: [expectedOwner, index]
+  });
+  const verified = (0, import_viem8.isAddressEqual)(actualOwner, expectedOwner) && (0, import_viem8.isAddressEqual)(actualAsset, expectedAsset) && (0, import_viem8.isAddressEqual)(actualFactory, YIELDSEEKER_FACTORY) && (0, import_viem8.isAddressEqual)(mapped, agentWallet);
+  const version = !verified ? "unknown" : (0, import_viem8.isAddressEqual)(implementation, YIELDSEEKER_V2_IMPLEMENTATION) ? "v2" : (0, import_viem8.isAddressEqual)(implementation, YIELDSEEKER_V1_IMPLEMENTATION) ? "v1" : "unknown";
+  return {
+    agentWallet,
+    owner: actualOwner,
+    ownerPath: yieldseekerOwnerPath(ownerCode),
+    asset: actualAsset,
+    implementation,
+    version,
+    verified,
+    upgradeAvailable: version === "v1" && (0, import_viem8.isAddressEqual)(latest, YIELDSEEKER_V2_IMPLEMENTATION)
+  };
+}
+var YIELDSEEKER_UPGRADE_ABI = walletAbi;
+
+// src/agents/yieldseeker/yieldseeker.sponsored-withdraw.ts
+var import_viem9 = require("viem");
+var import_account_abstraction = require("viem/account-abstraction");
+var import_accounts = require("viem/accounts");
+var import_chains3 = require("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 = (0, import_accounts.privateKeyToAccount)((0, import_accounts.generatePrivateKey)());
+function operationHash(operation) {
+  return (0, import_account_abstraction.getUserOperationHash)({
+    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: (0, import_viem9.toHex)(nonce),
+    initCode: "0x",
+    callData: input.callData,
+    callGasLimit: (0, import_viem9.toHex)(3e5),
+    verificationGasLimit: (0, import_viem9.toHex)(3e5),
+    preVerificationGas: (0, import_viem9.toHex)(6e4),
+    maxFeePerGas: (0, import_viem9.toHex)(fees.maxFeePerGas * USER_OP_FEE_HEADROOM),
+    maxPriorityFeePerGas: (0, import_viem9.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, (0, import_viem9.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, (0, import_viem9.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 = (0, import_viem9.createWalletClient)({
+    account: input.owner,
+    chain: import_chains3.base,
+    transport: (0, import_viem9.custom)(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?.[(0, import_viem9.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: (0, import_viem9.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 = (0, import_viem9.getAddress)(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 = (0, import_viem9.getAddress)(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";
@@ -3812,7 +4201,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();
@@ -3834,6 +4227,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(),
@@ -3845,10 +4240,182 @@ var YieldseekerAgent = class {
     this.unwindReceiptWaiter = options.unwindReceiptWaiter;
   }
   getReceiptClient() {
-    this.receiptClient ??= createPaidRpcClient(import_chains3.base, this.rpcUrls);
+    this.receiptClient ??= createPaidRpcClient(import_chains4.base, 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(),
+      (0, import_viem10.getAddress)(context.wallet.walletAddress),
+      (0, import_viem10.getAddress)(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 = (0, import_viem10.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: (0, import_viem10.getAddress)(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()) {
@@ -3919,12 +4486,12 @@ var YieldseekerAgent = class {
       receipt = await this.waitForReceipt(state, chainId, txHash);
     } else {
       txHash = await this.submitTransaction(state, chainId, {
-        from: (0, import_viem8.getAddress)(state.walletAddress),
+        from: (0, import_viem10.getAddress)(state.walletAddress),
         to: YIELDSEEKER_ASSET_METADATA[asset].address,
-        data: (0, import_viem8.encodeFunctionData)({
-          abi: import_viem8.erc20Abi,
+        data: (0, import_viem10.encodeFunctionData)({
+          abi: import_viem10.erc20Abi,
           functionName: "transfer",
-          args: [(0, import_viem8.getAddress)(context.wallet.walletAddress), BigInt(amount)]
+          args: [(0, import_viem10.getAddress)(context.wallet.walletAddress), BigInt(amount)]
         }),
         value: "0",
         chainId
@@ -3935,12 +4502,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,
@@ -3958,14 +4525,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) {
@@ -3985,6 +4558,27 @@ 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;
@@ -3998,9 +4592,9 @@ var YieldseekerAgent = class {
       const readIdle = async () => {
         const balance = await withPaidRpcDiagnostics(() => this.getReceiptClient().readContract({
           address: metadata.address,
-          abi: import_viem8.erc20Abi,
+          abi: import_viem10.erc20Abi,
           functionName: "balanceOf",
-          args: [(0, import_viem8.getAddress)(context.wallet.walletAddress)]
+          args: [(0, import_viem10.getAddress)(context.wallet.walletAddress)]
         }), chainId, "eth_call", this.id);
         this.assertSession(generation, chainId, asset);
         return balance;
@@ -4034,6 +4628,7 @@ var YieldseekerAgent = class {
         );
       }
       let remaining = requested > idle ? requested - idle : 0n;
+      let grossUnwound = 0n;
       for (const position2 of portfolio.positions) {
         if (remaining === 0n) break;
         const available = BigInt(position2.withdrawableAssetsRaw);
@@ -4057,6 +4652,7 @@ var YieldseekerAgent = class {
         }
         await this.waitForReceipt(state, chainId, response.transactionHash);
         confirmedMovement = true;
+        grossUnwound += assetsRaw;
         remaining -= assetsRaw;
       }
       if (remaining > 0n) {
@@ -4066,7 +4662,10 @@ var YieldseekerAgent = class {
         });
       }
       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);
         throw new OwneyError(
           "WITHDRAW_INSUFFICIENT_BALANCE",
@@ -4075,32 +4674,52 @@ 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 = (0, import_viem8.getAddress)(state.walletAddress);
+      const account = (0, import_viem10.getAddress)(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: (0, import_viem8.getAddress)(context.wallet.walletAddress),
-        data: amount === void 0 ? (0, import_viem8.encodeFunctionData)({
-          abi: YIELDSEEKER_AGENT_WALLET_ABI,
-          functionName: "withdrawAllAssetToUser",
-          args: [account, metadata.address]
-        }) : (0, import_viem8.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 ? (0, import_viem10.encodeFunctionData)({
+        abi: YIELDSEEKER_AGENT_WALLET_ABI,
+        functionName: "withdrawAllAssetToUser",
+        args: [account, metadata.address]
+      }) : (0, import_viem10.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: (0, import_viem10.getAddress)(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: (0, import_viem10.getAddress)(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 (evidence.transfer === "failed" && evidence.confirmedAmount === "0")
         throw new OwneyError(
@@ -4186,7 +4805,7 @@ var YieldseekerAgent = class {
     );
     const vaultAddresses = new Set(
       catalog.flat().filter(
-        (yieldOption) => yieldOption.chainId === chainId && (0, import_viem8.isAddress)(yieldOption.address)
+        (yieldOption) => yieldOption.chainId === chainId && (0, import_viem10.isAddress)(yieldOption.address)
       ).map((yieldOption) => yieldOption.address.toLowerCase())
     );
     return mapYieldseekerHistory(contexts, {
@@ -4313,7 +4932,7 @@ var YieldseekerAgent = class {
       `/users/${user.userId}/agents/${agent.agentId}/wallet`
     ).then((walletResponse) => {
       this.assertSession(generation, chainId, asset);
-      if (!walletResponse?.agentWallet || !(0, import_viem8.isAddress)(walletResponse.agentWallet.walletAddress)) {
+      if (!walletResponse?.agentWallet || !(0, import_viem10.isAddress)(walletResponse.agentWallet.walletAddress)) {
         throw this.invalidResponse("agent wallet");
       }
       const context = {
@@ -4343,7 +4962,7 @@ var YieldseekerAgent = class {
       this.users.set(key2, persisted);
       return persisted;
     }
-    const walletAddress = (0, import_viem8.getAddress)(state.walletAddress);
+    const walletAddress = (0, import_viem10.getAddress)(state.walletAddress);
     const generation = this.readGeneration;
     let user = null;
     try {
@@ -4726,7 +5345,7 @@ var YieldseekerAgent = class {
       this.agentPath(context, "deploy"),
       { method: "POST", body: {} }
     );
-    if (!deployed?.agentWallet || !(0, import_viem8.isAddress)(deployed.agentWallet.walletAddress) || deployed.agentWallet.walletAddress.toLowerCase() !== walletAddress) {
+    if (!deployed?.agentWallet || !(0, import_viem10.isAddress)(deployed.agentWallet.walletAddress) || deployed.agentWallet.walletAddress.toLowerCase() !== walletAddress) {
       throw this.invalidResponse("agent deployment", {
         reason: "Deploy did not return the expected Agent Wallet."
       });
@@ -4834,15 +5453,15 @@ var YieldseekerAgent = class {
       return hash2;
     }
     this.assertTransaction(transaction, state, chainId);
-    const account = (0, import_viem8.getAddress)(state.walletAddress);
-    const walletClient = (0, import_viem8.createWalletClient)({
+    const account = (0, import_viem10.getAddress)(state.walletAddress);
+    const walletClient = (0, import_viem10.createWalletClient)({
       account,
-      chain: import_chains3.base,
-      transport: (0, import_viem8.custom)(state.provider)
+      chain: import_chains4.base,
+      transport: (0, import_viem10.custom)(state.provider)
     });
-    const walletChainClient = (0, import_viem8.createPublicClient)({
-      chain: import_chains3.base,
-      transport: (0, import_viem8.custom)(state.provider)
+    const walletChainClient = (0, import_viem10.createPublicClient)({
+      chain: import_chains4.base,
+      transport: (0, import_viem10.custom)(state.provider)
     });
     await ensureWalletOnChain(
       walletChainClient,
@@ -4851,8 +5470,8 @@ var YieldseekerAgent = class {
     );
     const hash = await walletClient.sendTransaction({
       account,
-      chain: import_chains3.base,
-      to: (0, import_viem8.getAddress)(transaction.to),
+      chain: import_chains4.base,
+      to: (0, import_viem10.getAddress)(transaction.to),
       data: transaction.data,
       value: BigInt(transaction.value)
     });
@@ -4902,12 +5521,12 @@ var YieldseekerAgent = class {
     return receipt;
   }
   assertTransaction(transaction, state, chainId) {
-    if (!transaction || typeof transaction.from !== "string" || !(0, import_viem8.isAddress)(transaction.from) || typeof transaction.to !== "string" || !(0, import_viem8.isAddress)(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 || (0, import_viem8.getAddress)(transaction.from) !== (0, import_viem8.getAddress)(state.walletAddress)) {
+    if (!transaction || typeof transaction.from !== "string" || !(0, import_viem10.isAddress)(transaction.from) || typeof transaction.to !== "string" || !(0, import_viem10.isAddress)(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 || (0, import_viem10.getAddress)(transaction.from) !== (0, import_viem10.getAddress)(state.walletAddress)) {
       throw this.invalidResponse("transaction");
     }
   }
   assertAgent(agent) {
-    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !(0, import_viem8.isAddress)(agent.assetAddress) || agent.chainId !== 8453) {
+    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !(0, import_viem10.isAddress)(agent.assetAddress) || agent.chainId !== 8453) {
       throw this.invalidResponse("agent");
     }
   }
@@ -4964,6 +5583,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 {
@@ -5060,7 +5680,7 @@ async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
 }
 
 // src/lib/helpers/withdraw-helper.ts
-var import_viem9 = require("viem");
+var import_viem11 = require("viem");
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
   const target = asset.toUpperCase();
   return agents.map((agent) => {
@@ -5068,7 +5688,7 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
     const tokenBalance = agentBalance?.tokens.find(
       (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
-    let balance = tokenBalance ? (0, import_viem9.parseUnits)(tokenBalance.amount, decimals) : 0n;
+    let balance = tokenBalance ? (0, import_viem11.parseUnits)(tokenBalance.amount, decimals) : 0n;
     if (agent.balanceComposition === "tokens-plus-positions") {
       const chainNameById = {
         1: "ETHEREUM",
@@ -5080,14 +5700,14 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
         const positionChain = position2.chain.trim().toUpperCase();
         const matchesChain = positionChain === String(chainId) || targetChain !== void 0 && positionChain === targetChain;
         if (!matchesChain || position2.asset.toUpperCase() !== target) continue;
-        balance += position2.withdrawableAmountRaw !== void 0 ? BigInt(position2.withdrawableAmountRaw) : (0, import_viem9.parseUnits)(position2.amount, decimals);
+        balance += position2.withdrawableAmountRaw !== void 0 ? BigInt(position2.withdrawableAmountRaw) : (0, import_viem11.parseUnits)(position2.amount, decimals);
       }
     }
     const assetTotal = agentBalance?.assetBalances?.find(
       (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
     if (assetTotal) {
-      const total = (0, import_viem9.parseUnits)(assetTotal.amount, decimals);
+      const total = (0, import_viem11.parseUnits)(assetTotal.amount, decimals);
       if (total < balance) balance = total > 0n ? total : 0n;
     }
     return { agent, balance };
@@ -5246,17 +5866,16 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 }
 
 // src/client.ts
-var import_viem13 = require("viem");
-var import_chains4 = require("viem/chains");
+var import_viem15 = require("viem");
+var import_chains5 = require("viem/chains");
 
 // src/lib/sponsored-token-batch.ts
-var import_viem11 = require("viem");
+var import_viem13 = require("viem");
 
 // src/lib/permit2-batch.ts
-var import_viem10 = require("viem");
+var import_viem12 = require("viem");
 var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
 var ERC2612_PERMIT_TYPES = {
   Permit: [
     { name: "owner", type: "address" },
@@ -5266,7 +5885,7 @@ var ERC2612_PERMIT_TYPES = {
     { name: "deadline", type: "uint256" }
   ]
 };
-var ERC2612_READ_ABI = (0, import_viem10.parseAbi)([
+var ERC2612_READ_ABI = (0, import_viem12.parseAbi)([
   "function name() view returns (string)",
   "function version() view returns (string)",
   "function nonces(address owner) view returns (uint256)"
@@ -5304,7 +5923,7 @@ var PERMIT_BATCH_TYPES = {
     { name: "amount", type: "uint256" }
   ]
 };
-var PERMIT2_BATCH_ABI = (0, import_viem10.parseAbi)([
+var PERMIT2_BATCH_ABI = (0, import_viem12.parseAbi)([
   "struct TokenPermissions { address token; uint256 amount; }",
   "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
   "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
@@ -5363,7 +5982,7 @@ function clear(key2) {
   else window.localStorage.removeItem(key2);
 }
 function sponsorTokenBatch(i) {
-  const key2 = `owney.token-batch.v1:${(0, import_viem11.keccak256)((0, import_viem11.toBytes)(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
+  const key2 = `owney.token-batch.v1:${(0, import_viem13.keccak256)((0, import_viem13.toBytes)(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
   const plan = planOf(i.transfers);
   const active = inflight.get(key2);
   if (active) {
@@ -5388,13 +6007,29 @@ async function execute(i, key2, plan) {
     let body = initial;
     save(key2, body);
     try {
+      if (body.erc2612Permit && !body.serializedPermitTransaction) {
+        const preparedPermit = await postSponsorBatchTransfer({
+          apiKey: i.apiKey,
+          baseUrl: i.baseUrl,
+          body
+        });
+        if (!preparedPermit.serializedPermitTransaction || !preparedPermit.permitTxHash || (0, import_viem13.keccak256)(preparedPermit.serializedPermitTransaction) !== preparedPermit.permitTxHash)
+          throw new Error(
+            "Sponsorship API did not return a valid prepared permit transaction."
+          );
+        body = {
+          ...body,
+          serializedPermitTransaction: preparedPermit.serializedPermitTransaction
+        };
+        save(key2, body);
+      }
       if (!body.serializedTransaction) {
         const prepared = await postSponsorBatchTransfer({
           apiKey: i.apiKey,
           baseUrl: i.baseUrl,
           body
         });
-        if (!prepared.serializedTransaction || (0, import_viem11.keccak256)(prepared.serializedTransaction) !== prepared.txHash)
+        if (!prepared.serializedTransaction || (0, import_viem13.keccak256)(prepared.serializedTransaction) !== prepared.txHash)
           throw new Error(
             "Sponsorship API did not return a valid prepared transaction."
           );
@@ -5405,7 +6040,7 @@ async function execute(i, key2, plan) {
         save(key2, body);
       }
       try {
-        i.onSubmitted?.((0, import_viem11.keccak256)(body.serializedTransaction));
+        i.onSubmitted?.((0, import_viem13.keccak256)(body.serializedTransaction));
       } catch {
       }
       const result = await postSponsorBatchTransfer({
@@ -5413,7 +6048,7 @@ async function execute(i, key2, plan) {
         baseUrl: i.baseUrl,
         body
       });
-      if (result.txHash !== (0, import_viem11.keccak256)(body.serializedTransaction))
+      if (result.txHash !== (0, import_viem13.keccak256)(body.serializedTransaction))
         throw new Error(
           "Sponsorship receipt does not match the pending transaction."
         );
@@ -5428,7 +6063,7 @@ async function execute(i, key2, plan) {
   const saved = read(key2);
   if (saved) {
     const previous = JSON.parse(saved);
-    if (previous.chainId !== i.chainId || !(0, import_viem11.isAddressEqual)(previous.from, i.owner) || !(0, import_viem11.isAddressEqual)(previous.token, i.token) || planOf(previous.transfers) !== plan)
+    if (previous.chainId !== i.chainId || !(0, import_viem13.isAddressEqual)(previous.from, i.owner) || !(0, import_viem13.isAddressEqual)(previous.token, i.token) || planOf(previous.transfers) !== plan)
       throw new Error(
         "Retry the previous token deposit and agent split first to reconcile its status."
       );
@@ -5445,7 +6080,7 @@ async function execute(i, key2, plan) {
       "DEPOSIT_INSUFFICIENT_BALANCE",
       "Insufficient token balance for this deposit."
     );
-  if (allowance < total && (i.chainId !== 8453 || !(0, import_viem11.isAddressEqual)(i.token, BASE_USDC_ADDRESS)))
+  if (allowance < total && (i.chainId !== 8453 || !(0, import_viem13.isAddressEqual)(i.token, BASE_USDC_ADDRESS)))
     throw new OwneyError(
       "PERMIT2_APPROVAL_REQUIRED",
       "token deposits need a one-time Permit2 approval."
@@ -5489,7 +6124,7 @@ async function execute(i, key2, plan) {
     });
     erc2612Permit = { ...unsignedPermit, signature: signature2 };
   }
-  const spender = erc2612Permit ? MULTICALL3_ADDRESS : await getSponsorRelayerAddress({
+  const spender = await getSponsorRelayerAddress({
     apiKey: i.apiKey,
     baseUrl: i.baseUrl,
     chainId: i.chainId
@@ -5623,7 +6258,7 @@ async function runAgentDepositBatch(chainId, legs, transfer) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-var import_viem12 = require("viem");
+var import_viem14 = require("viem");
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -5631,7 +6266,7 @@ async function paymasterSupported(provider, owner, chainId) {
     method: "wallet_getCapabilities",
     params: [owner]
   });
-  const forChain = caps?.[(0, import_viem12.toHex)(chainId)] ?? caps?.[String(chainId)];
+  const forChain = caps?.[(0, import_viem14.toHex)(chainId)] ?? caps?.[String(chainId)];
   return Boolean(forChain?.paymasterService?.supported);
 }
 function makeSponsoredCallsCallback(deps) {
@@ -5668,8 +6303,8 @@ function makeSponsoredCallsCallback(deps) {
     const calls = transfers.map((transfer) => ({
       to: token,
       value: "0x0",
-      data: (0, import_viem12.encodeFunctionData)({
-        abi: import_viem12.erc20Abi,
+      data: (0, import_viem14.encodeFunctionData)({
+        abi: import_viem14.erc20Abi,
         functionName: "transfer",
         args: [transfer.to, BigInt(transfer.amount)]
       })
@@ -5707,7 +6342,7 @@ function makeSponsoredCallsCallback(deps) {
         {
           version: "2.0.0",
           from: deps.ownerAddress,
-          chainId: (0, import_viem12.toHex)(chainId),
+          chainId: (0, import_viem14.toHex)(chainId),
           atomicRequired: transfers.length > 1,
           calls,
           capabilities: {
@@ -5801,9 +6436,9 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: import_chains4.base,
-  42161: import_chains4.arbitrum,
-  1: import_chains4.mainnet
+  8453: import_chains5.base,
+  42161: import_chains5.arbitrum,
+  1: import_chains5.mainnet
 };
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
@@ -5976,14 +6611,14 @@ var OwneySDK = class {
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
       getPublicClient: (cid) => this.getPaidRpcClient(cid),
-      getWalletChainClient: (cid) => (0, import_viem13.createPublicClient)({
+      getWalletChainClient: (cid) => (0, import_viem15.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem13.custom)(provider)
+        transport: (0, import_viem15.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem13.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem15.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem13.custom)(provider)
+        transport: (0, import_viem15.custom)(provider)
       })
     });
     if (!onApproved && !onSubmitted) this.cachedSponsoredCallback = callback;
@@ -6029,14 +6664,14 @@ var OwneySDK = class {
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
       getPublicClient: (cid) => this.getPaidRpcClient(cid),
-      getWalletChainClient: (cid) => (0, import_viem13.createPublicClient)({
+      getWalletChainClient: (cid) => (0, import_viem15.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem13.custom)(provider)
+        transport: (0, import_viem15.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem13.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem15.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem13.custom)(provider)
+        transport: (0, import_viem15.custom)(provider)
       })
     });
     if (!onApproved && !onSubmitted) this.cachedWethSponsoredCallback = callback;
@@ -6157,6 +6792,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
@@ -6748,12 +7384,12 @@ 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))
         verified = inspectFundingReceipt(receipt, { ...evidence, agentWallet, intendedAmount: "MAX" }, token.address, direction);
@@ -6767,6 +7403,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);
@@ -6791,6 +7466,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.
@@ -6854,7 +7562,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,6 +7600,7 @@ var OwneySDK = class {
           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;
           console.error(`withdraw failed for agent "${agent.id}":`, err);
@@ -6993,6 +7702,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);
@@ -7490,16 +8200,16 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const walletChainClient = (0, import_viem13.createPublicClient)({
+    const walletChainClient = (0, import_viem15.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem13.custom)(provider)
+      transport: (0, import_viem15.custom)(provider)
     });
     const publicClient = this.getPaidRpcClient(chainId);
     const approvalAmount = permit2ApprovalAmount(requiredAmount);
-    const wallet = (0, import_viem13.createWalletClient)({
+    const wallet = (0, import_viem15.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem13.custom)(provider)
+      transport: (0, import_viem15.custom)(provider)
     });
     await ensureWalletOnChain(walletChainClient, wallet, chainId);
     const hash = await wallet.writeContract({
@@ -7661,7 +8371,7 @@ var OwneySDK = class {
 };
 
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem14 = require("viem");
+var import_viem16 = require("viem");
 var import_siwe2 = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
@@ -7788,7 +8498,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe2.SiweMessage({
-          address: (0, import_viem14.getAddress)(accountAddress),
+          address: (0, import_viem16.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,