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

package/dist/index.js

@@ -2603,14 +2603,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 +2653,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 +2692,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 }
       }
@@ -3722,6 +3722,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 } 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 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: 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";
@@ -3794,7 +4192,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 +4218,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 +4231,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 +4477,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 +4493,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 +4516,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,6 +4549,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;
@@ -3982,7 +4585,7 @@ 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;
@@ -4016,6 +4619,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);
@@ -4039,6 +4643,7 @@ var YieldseekerAgent = class {
         }
         await this.waitForReceipt(state, chainId, response.transactionHash);
         confirmedMovement = true;
+        grossUnwound += assetsRaw;
         remaining -= assetsRaw;
       }
       if (remaining > 0n) {
@@ -4048,7 +4653,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",
@@ -4057,32 +4665,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 = 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 (evidence.transfer === "failed" && evidence.confirmedAmount === "0")
         throw new OwneyError(
@@ -4325,7 +4953,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 +5444,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 +5461,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 +5512,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 +5574,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 +5859,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 +5884,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 +5922,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 +6062,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 +6079,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 +6257,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 +6265,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 +6341,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 +6435,7 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: base4,
+  8453: base5,
   42161: arbitrum2,
   1: mainnet2
 };
@@ -5983,12 +6612,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 +6665,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 +6791,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,12 +7383,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);
@@ -6772,6 +7402,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 +7465,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 +7561,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" });
@@ -6897,6 +7599,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);
@@ -6998,6 +7701,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 +8201,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 +8370,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 +8497,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new SiweMessage2({
-          address: getAddress3(accountAddress),
+          address: getAddress5(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,