@owney/sdk 0.7.25-beta.9 → 0.7.25

package/dist/index.js

@@ -1,23 +1,3 @@
-// src/lib/deposit-batch-callback.ts
-var batchCallbacks = /* @__PURE__ */ new WeakMap();
-var getDepositBatchTransfer = (callback) => callback ? batchCallbacks.get(callback) : void 0;
-function toBatchTransfer(to, amount, verification) {
-  return {
-    to,
-    amount,
-    ...verification ? {
-      yieldseeker: {
-        signature: verification.signature,
-        userId: verification.userId,
-        agentId: verification.yieldseekerAgentId
-      }
-    } : {}
-  };
-}
-function registerDepositBatch(callback, transfer) {
-  batchCallbacks.set(callback, transfer);
-}
-
 // src/errors.ts
 var OwneyError = class extends Error {
   code;
@@ -125,34 +105,6 @@ function rateLimitDelay(error, now = Date.now()) {
 }
 
 // src/lib/agent-reads.ts
-function rateLimitDiagnostics(error) {
-  const seen = /* @__PURE__ */ new Set();
-  let details = {};
-  function visit(value, depth = 0) {
-    if (depth > 6 || !value || typeof value !== "object" || seen.has(value))
-      return;
-    seen.add(value);
-    const record = value;
-    for (const key2 of [
-      "rpcSource",
-      "chainId",
-      "rpcMethod",
-      "providerRequestId",
-      "statusCode"
-    ]) {
-      const candidate = record[key2];
-      if (candidate !== void 0 && details[key2] === void 0)
-        details = { ...details, [key2]: candidate };
-    }
-    for (const key2 of ["details", "cause", "response", "fields", "error"])
-      visit(record[key2], depth + 1);
-  }
-  visit(error);
-  return {
-    rpcSource: details.rpcSource ?? "agent-api",
-    ...details
-  };
-}
 var AgentReads = class {
   inFlight = /* @__PURE__ */ new Map();
   cooldowns = /* @__PURE__ */ new Map();
@@ -160,15 +112,14 @@ var AgentReads = class {
   clearInFlight() {
     this.inFlight.clear();
   }
-  limited(agentId, until, diagnostics) {
+  limited(agentId, until) {
     return new OwneyError(
       "AGENT_RATE_LIMITED",
       "Too many requests. Please wait before trying again.",
       {
         statusCode: 429,
         retryAt: until,
-        retryAfterSeconds: Math.max(0, Math.ceil((until - Date.now()) / 1e3)),
-        ...diagnostics
+        retryAfterSeconds: Math.max(0, Math.ceil((until - Date.now()) / 1e3))
       },
       agentId
     );
@@ -176,9 +127,7 @@ var AgentReads = class {
   run(agentId, key2, fetch2) {
     const cooldown = this.cooldowns.get(agentId);
     if (cooldown && cooldown.until > Date.now()) {
-      return Promise.reject(
-        this.limited(agentId, cooldown.until, cooldown.diagnostics)
-      );
+      return Promise.reject(this.limited(agentId, cooldown.until));
     }
     const requestKey = JSON.stringify([agentId, key2]);
     const existing = this.inFlight.get(requestKey);
@@ -199,9 +148,8 @@ var AgentReads = class {
           Math.min(3e4 * 2 ** (failures - 1), 3e5)
         );
         const until = Math.max(previous?.until ?? 0, Date.now() + delay);
-        const diagnostics = rateLimitDiagnostics(error);
-        this.cooldowns.set(agentId, { until, failures, diagnostics });
-        throw this.limited(agentId, until, diagnostics);
+        this.cooldowns.set(agentId, { until, failures });
+        throw this.limited(agentId, until);
       }
     ).finally(() => {
       if (this.inFlight.get(requestKey) === promise)
@@ -214,7 +162,7 @@ var AgentReads = class {
 
 // src/agents/zyfai/zyfai.agent.ts
 import { SMART_SESSIONS_VALIDATOR, ZyfaiSDK } from "@zyfai/sdk";
-import { parseAbi } from "viem";
+import { createPublicClient, http, parseAbi } from "viem";
 import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/types/config.ts
@@ -329,18 +277,18 @@ function tokenDecimals(symbol, explicit) {
     return explicit;
   return DECIMALS_BY_SYMBOL[(symbol ?? "").toLowerCase()] ?? 6;
 }
-function mapDeposit(raw2) {
+function mapDeposit(raw) {
   return {
-    txHash: raw2.txHash,
-    smartWallet: raw2.smartWallet,
-    amount: raw2.amount
+    txHash: raw.txHash,
+    smartWallet: raw.smartWallet,
+    amount: raw.amount
   };
 }
-function mapWithdraw(raw2) {
+function mapWithdraw(raw) {
   return {
-    txHash: raw2.txHash,
-    type: raw2.type,
-    amount: raw2.amount
+    txHash: raw.txHash,
+    type: raw.type,
+    amount: raw.amount
   };
 }
 var CHAIN_ID_TO_NAME = {
@@ -359,10 +307,10 @@ function resolveChainId(chain) {
   if (Number.isFinite(asNum) && asNum > 0) return asNum;
   return NAME_TO_CHAIN_ID[chain.trim().toLowerCase()] ?? NaN;
 }
-function mapPendingAllocations(raw2) {
-  if (!Array.isArray(raw2)) return void 0;
+function mapPendingAllocations(raw) {
+  if (!Array.isArray(raw)) return void 0;
   const pending = [];
-  for (const entry of raw2) {
+  for (const entry of raw) {
     if (typeof entry !== "object" || entry === null) continue;
     const e = entry;
     if (typeof e.chainId !== "number" || !Number.isFinite(e.chainId)) continue;
@@ -385,8 +333,8 @@ function mapPendingAllocations(raw2) {
   }
   return pending.length > 0 ? pending : void 0;
 }
-function mapBalances(raw2, _chainId, smartWallet) {
-  const portfolio = raw2.portfolio;
+function mapBalances(raw, _chainId, smartWallet) {
+  const portfolio = raw.portfolio;
   const portfolioByChain = portfolio.portfolioByChain ?? {};
   let totalBalance = 0;
   const tokens = [];
@@ -455,8 +403,8 @@ function sumTokenValues(tokens) {
 function sumTokenEarnings(tokens) {
   return Object.values(tokens).reduce((sum, val) => sum + Number(val), 0);
 }
-function mapEarnings(raw2, smartWallet) {
-  const totalEarningsByChain = raw2.data.totalEarningsByChainWithFee ?? raw2.data.totalEarningsByChain ?? {};
+function mapEarnings(raw, smartWallet) {
+  const totalEarningsByChain = raw.data.totalEarningsByChainWithFee ?? raw.data.totalEarningsByChain ?? {};
   const tokens = [];
   for (const [chainIdKey, tokensBySymbol] of Object.entries(
     totalEarningsByChain
@@ -475,15 +423,15 @@ function mapEarnings(raw2, smartWallet) {
   return {
     smartWallet,
     lifetimeEarnings: sumTokenEarnings(
-      raw2.data.totalEarningsByTokenWithFee ?? raw2.data.totalEarningsByToken
+      raw.data.totalEarningsByTokenWithFee ?? raw.data.totalEarningsByToken
     ),
     tokens
   };
 }
-function mapWeightedApyByChain(raw2) {
-  if (!raw2) return void 0;
+function mapWeightedApyByChain(raw) {
+  if (!raw) return void 0;
   const out = {};
-  for (const [chainKey, tokenApy] of Object.entries(raw2)) {
+  for (const [chainKey, tokenApy] of Object.entries(raw)) {
     const chainId = Number(chainKey);
     if (!SUPPORTED_CHAIN_IDS.includes(chainId)) continue;
     const perAsset = {};
@@ -523,8 +471,8 @@ function rawPoolApyForChain(entry, chainId, tokenSymbol) {
   }
   return totalBalance > 0 ? weightedSum / totalBalance : null;
 }
-function mapApyHistory(raw2, chainId, tokenSymbol) {
-  const history = Object.entries(raw2.history ?? {}).map(([date, entry]) => ({
+function mapApyHistory(raw, chainId, tokenSymbol) {
+  const history = Object.entries(raw.history ?? {}).map(([date, entry]) => ({
     date,
     apy: rawPoolApyForChain(entry, chainId, tokenSymbol),
     // Provider position balances are treated as decimal amounts of the
@@ -540,9 +488,9 @@ function mapApyHistory(raw2, chainId, tokenSymbol) {
     } : {}
   })).filter((p) => p.apy !== null).sort((a, b) => a.date.localeCompare(b.date));
   return {
-    walletAddress: raw2.walletAddress,
-    weightedApyAfterFee: raw2.weightedApyAfterFee ? sumTokenValues(raw2.weightedApyAfterFee) : void 0,
-    apyByChainAndAsset: mapWeightedApyByChain(raw2.weightedApyAfterFeeByChain),
+    walletAddress: raw.walletAddress,
+    weightedApyAfterFee: raw.weightedApyAfterFee ? sumTokenValues(raw.weightedApyAfterFee) : void 0,
+    apyByChainAndAsset: mapWeightedApyByChain(raw.weightedApyAfterFeeByChain),
     history
   };
 }
@@ -638,23 +586,23 @@ function mapEntries(rawEntries, chainId) {
     };
   });
 }
-function mapUserProfile(raw2, userAddress) {
+function mapUserProfile(raw, userAddress) {
   return {
     address: userAddress,
-    smartWallet: raw2.smartWallet || "",
-    chains: raw2.chains || [],
-    strategy: raw2.strategy,
-    hasActiveSessionKey: raw2.hasActiveSessionKey || false,
-    protocols: raw2.protocols || [],
-    splitting: raw2.splitting,
-    minSplits: raw2.minSplits
+    smartWallet: raw.smartWallet || "",
+    chains: raw.chains || [],
+    strategy: raw.strategy,
+    hasActiveSessionKey: raw.hasActiveSessionKey || false,
+    protocols: raw.protocols || [],
+    splitting: raw.splitting,
+    minSplits: raw.minSplits
   };
 }
-function mapApyByStrategy(raw2) {
+function mapApyByStrategy(raw) {
   const apyPerAsset = {};
   let apySum = 0;
   let apyCount = 0;
-  for (const entry of raw2.data) {
+  for (const entry of raw.data) {
     const supported = SupportedAssets.find(
       (asset) => asset.chainId === entry.chain_id && asset.symbol === entry.token_symbol
     );
@@ -766,9 +714,9 @@ function netDeltaForSnapshot(entry, chainId, asset) {
   debugLog("zyfai:earnings", "gross fallback for daily earnings", { gross });
   return gross;
 }
-function mapDailyEarnings(raw2, chainId, tokenSymbol) {
+function mapDailyEarnings(raw, chainId, tokenSymbol) {
   const wanted = tokenSymbol?.toUpperCase();
-  const snapshots = [...raw2.data ?? []].sort(
+  const snapshots = [...raw.data ?? []].sort(
     (a, b) => a.snapshot_date.localeCompare(b.snapshot_date)
   );
   const byAsset = /* @__PURE__ */ new Map();
@@ -783,7 +731,7 @@ function mapDailyEarnings(raw2, chainId, tokenSymbol) {
     }
   }
   const assets = [...byAsset.entries()].map(([asset, series]) => ({ asset, points: series.points })).sort((a, b) => a.asset.localeCompare(b.asset));
-  return { walletAddress: raw2.walletAddress, chainId, assets };
+  return { walletAddress: raw.walletAddress, chainId, assets };
 }
 
 // src/agents/zyfai/zyfai.withdraw-amount.ts
@@ -894,15 +842,15 @@ var readSession = (address, _chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey(address);
   const store = storage();
-  let raw2 = null;
+  let raw = null;
   try {
-    raw2 = store?.getItem(key2) ?? null;
+    raw = store?.getItem(key2) ?? null;
   } catch {
-    raw2 = null;
+    raw = null;
   }
-  if (raw2) {
+  if (raw) {
     try {
-      const parsed = JSON.parse(raw2);
+      const parsed = JSON.parse(raw);
       if (isFreshSession(parsed)) return parsed;
     } catch {
     }
@@ -1070,8 +1018,8 @@ function buildChainsByProtocol(protocols, dashboardChainIds) {
   }
   return result;
 }
-function flattenAvailablePools(raw2) {
-  const byChain = raw2 ?? {};
+function flattenAvailablePools(raw) {
+  const byChain = raw ?? {};
   const names = [];
   for (const byToken of Object.values(byChain ?? {})) {
     for (const entry of Object.values(byToken ?? {})) {
@@ -1095,148 +1043,15 @@ function protocolsPolicyNeedsUpdate(current, desiredProtocols, desiredAutoSelect
   return !protocolListsEqual(current.protocols, desiredProtocols);
 }
 
-// src/lib/paid-rpc.ts
-import {
-  createPublicClient,
-  http
-} from "viem";
-var PAID_RPC_RETRY_COUNT = 3;
-var PAID_RPC_RETRY_DELAY_MS = 1e3;
-function configuredRpcProxyBaseUrl(baseUrl) {
-  const configured = (baseUrl ?? "")?.trim();
-  if (!configured) {
-    throw new Error(
-      "OWNEY_ROUTING_API_BASE_URL is required for RPC proxy requests unless routingApiBaseUrl or all rpcUrls are configured."
-    );
-  }
-  return configured;
-}
-function rpcProxyUrl(chainId, apiKey, baseUrl) {
-  const url = new URL(
-    `${configuredRpcProxyBaseUrl(baseUrl).replace(/\/$/, "")}/api/v1/rpc/${chainId}`
-  );
-  if (apiKey) url.searchParams.set("apiKey", apiKey);
-  return url.toString();
-}
-function resolveRpcUrl(rpcUrls, chainId, apiKey = "", baseUrl) {
-  const url = rpcUrls?.[chainId]?.trim();
-  if (url) return url;
-  return rpcProxyUrl(chainId, apiKey, baseUrl);
-}
-function resolveRpcUrls(rpcUrls, apiKey = "", baseUrl) {
-  return {
-    1: resolveRpcUrl(rpcUrls, 1, apiKey, baseUrl),
-    8453: resolveRpcUrl(rpcUrls, 8453, apiKey, baseUrl),
-    42161: resolveRpcUrl(rpcUrls, 42161, apiKey, baseUrl)
-  };
-}
-function createPaidRpcClient(chain, rpcUrls) {
-  const url = resolveRpcUrl(
-    rpcUrls,
-    chain.id
-  );
-  return createPublicClient({
-    chain,
-    transport: http(url, {
-      retryCount: PAID_RPC_RETRY_COUNT,
-      retryDelay: PAID_RPC_RETRY_DELAY_MS
-    })
-  });
-}
-function headerValue(error, name) {
-  const seen = /* @__PURE__ */ new Set();
-  let value;
-  function visit(candidate, depth = 0) {
-    if (value || depth > 6 || !candidate || typeof candidate !== "object")
-      return;
-    if (seen.has(candidate)) return;
-    seen.add(candidate);
-    const record = candidate;
-    const headers = record.headers;
-    let found;
-    if (typeof headers?.get === "function") {
-      found = headers.get(name);
-    } else {
-      const headerRecord = headers;
-      found = headerRecord?.[name] ?? headerRecord?.[name.toLowerCase()];
-    }
-    if (typeof found === "string" && found) {
-      value = found;
-      return;
-    }
-    for (const key2 of ["cause", "details", "response", "error"])
-      visit(record[key2], depth + 1);
-  }
-  visit(error);
-  return value;
-}
-function statusCode(error) {
-  const seen = /* @__PURE__ */ new Set();
-  let status;
-  function visit(candidate, depth = 0) {
-    if (status || depth > 6 || !candidate || typeof candidate !== "object")
-      return;
-    if (seen.has(candidate)) return;
-    seen.add(candidate);
-    const record = candidate;
-    for (const key2 of ["status", "statusCode"]) {
-      const parsed = Number(record[key2]);
-      if (Number.isInteger(parsed) && parsed >= 100 && parsed <= 599) {
-        status = parsed;
-        return;
-      }
-    }
-    for (const key2 of ["cause", "details", "response", "error"])
-      visit(record[key2], depth + 1);
-  }
-  visit(error);
-  return status;
-}
-function paidRpcError(error, chainId, rpcMethod, agentId) {
-  const delay = rateLimitDelay(error);
-  const providerRequestId = headerValue(error, "x-alchemy-request-id") ?? headerValue(error, "x-request-id");
-  if (delay === void 0) {
-    return new OwneyError(
-      "AGENT_API_ERROR",
-      "The blockchain RPC request failed.",
-      {
-        rpcSource: "paid-rpc",
-        chainId,
-        rpcMethod,
-        ...statusCode(error) ? { statusCode: statusCode(error) } : {},
-        ...providerRequestId ? { providerRequestId } : {}
-      },
-      agentId
-    );
-  }
-  const retryAt = Date.now() + delay;
-  return new OwneyError(
-    "AGENT_RATE_LIMITED",
-    "The blockchain RPC is rate limited. Please wait before trying again.",
-    {
-      rpcSource: "paid-rpc",
-      chainId,
-      rpcMethod,
-      statusCode: 429,
-      retryAt,
-      retryAfterSeconds: Math.max(0, Math.ceil(delay / 1e3)),
-      ...providerRequestId ? { providerRequestId } : {}
-    },
-    agentId
-  );
-}
-async function withPaidRpcDiagnostics(operation, chainId, rpcMethod, agentId) {
-  try {
-    return await operation();
-  } catch (error) {
-    throw paidRpcError(error, chainId, rpcMethod, agentId);
-  }
-}
-
 // src/agents/zyfai/zyfai.agent.ts
 var ERC7579_IS_MODULE_INSTALLED_ABI = parseAbi([
   "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)"
 ]);
+var DEFAULT_ZYFAI_RPC_URLS = {
+  8453: "https://base-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
+  42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
+  1: "https://eth-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
+};
 var WETH_ADDRESS_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -1302,7 +1117,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
   earningsSnapshot = null;
   earningsGeneration = 0;
   constructor(apiKey, rpcUrls, referralSource) {
-    this.rpcUrls = resolveRpcUrls(rpcUrls);
+    this.rpcUrls = rpcUrls ?? DEFAULT_ZYFAI_RPC_URLS;
     this.sdk = new ZyfaiSDK({
       apiKey,
       rpcUrls: this.rpcUrls,
@@ -1316,10 +1131,10 @@ var ZyfaiAgent = class _ZyfaiAgent {
   getPublicClient(chainId) {
     const cached = this.publicClients.get(chainId);
     if (cached) return cached;
-    const client = createPaidRpcClient(
-      VIEM_CHAIN[chainId],
-      this.rpcUrls
-    );
+    const client = createPublicClient({
+      chain: VIEM_CHAIN[chainId],
+      transport: http(this.rpcUrls[chainId])
+    });
     this.publicClients.set(chainId, client);
     return client;
   }
@@ -1489,7 +1304,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
    * chain/account switch fires the provider's `accountsChanged` →
    * `disconnectAccount` (nulls walletClient + authenticatedUserId) while our
    * own `connectAuth` guard still believes this chain is connected and
-   * early-returns. Without this, authenticated calls (depositFunds,
+   * early-returns. Without this, authenticated calls (sendDeposit,
    * withdrawFunds) fail with "No account connected".
    */
   async ensureConnected(state, chainId) {
@@ -1707,8 +1522,8 @@ var ZyfaiAgent = class _ZyfaiAgent {
       const poolResults = await Promise.all(
         universe.map(async (protocol) => {
           try {
-            const raw2 = await this.sdk.getAvailablePools(protocol.id, strategy);
-            return [protocol.id, flattenAvailablePools(raw2)];
+            const raw = await this.sdk.getAvailablePools(protocol.id, strategy);
+            return [protocol.id, flattenAvailablePools(raw)];
           } catch (error) {
             console.warn(
               `[zyfai] applyPoolPolicy: getAvailablePools(${protocol.id}) failed, skipping this protocol (non-fatal):`,
@@ -1774,14 +1589,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
   async readWalletState(ownerAddress) {
     try {
       const { portfolio } = await this.sdk.getPositions(ownerAddress);
-      const raw2 = portfolio;
+      const raw = portfolio;
       debugLog("zyfai:onboard", "wallet state from getPositions", {
-        predeployed: raw2?.predeployed,
-        hasActiveSessionKey: raw2?.hasActiveSessionKey
+        predeployed: raw?.predeployed,
+        hasActiveSessionKey: raw?.hasActiveSessionKey
       });
       return {
-        predeployed: raw2?.predeployed,
-        hasActiveSessionKey: raw2?.hasActiveSessionKey
+        predeployed: raw?.predeployed,
+        hasActiveSessionKey: raw?.hasActiveSessionKey
       };
     } catch (error) {
       console.warn(
@@ -2067,14 +1882,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
         return { txHash, smartWallet, amount };
       }
       await this.ensureWalletDeployed(this.getAddress(), validChainId);
-      const raw2 = await this.sdk.depositFunds(
+      const raw = await this.sdk.sendDeposit(
         this.getAddress(),
         validChainId,
         amount,
         asset,
         "aggressive"
       );
-      return mapDeposit(raw2);
+      return mapDeposit(raw);
     } catch (error) {
       throw error;
     }
@@ -2083,27 +1898,27 @@ var ZyfaiAgent = class _ZyfaiAgent {
   async withdraw(state, chainId, token, amount) {
     const validChainId = isValidChainId(chainId);
     await this.ensureConnected(state, validChainId);
-    const raw2 = await this.sdk.withdrawFunds(
+    const raw = await this.sdk.withdrawFunds(
       this.getAddress(),
       validChainId,
       amount,
       token
     );
-    if (!raw2.success) {
+    if (!raw.success) {
       throw new OwneyError(
         "WITHDRAW_FAILED",
-        raw2.message || "Zyfai withdraw failed.",
-        { chainId: validChainId, token, amount, response: raw2 },
+        raw.message || "Zyfai withdraw failed.",
+        { chainId: validChainId, token, amount, response: raw },
         this.id
       );
     }
-    return mapWithdraw(raw2);
+    return mapWithdraw(raw);
   }
   // --- IAgent: Portfolio reads ---
   async getBalances(state, chainId) {
     const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
-    const raw2 = await this.sdk.getPortfolio(this.getAddress());
-    return mapBalances(raw2, validChainId, smartWallet);
+    const raw = await this.sdk.getPortfolio(this.getAddress());
+    return mapBalances(raw, validChainId, smartWallet);
   }
   earningsKey(state, chainId, smartWallet) {
     return JSON.stringify([
@@ -2116,11 +1931,11 @@ var ZyfaiAgent = class _ZyfaiAgent {
     const existing = this.earningsReads.get(key2);
     if (existing) return existing;
     const generation = this.earningsGeneration;
-    const pending = Promise.resolve().then(() => this.sdk.getOnchainEarnings(smartWallet)).then((raw2) => {
+    const pending = Promise.resolve().then(() => this.sdk.getOnchainEarnings(smartWallet)).then((raw) => {
       if (generation === this.earningsGeneration) {
-        this.earningsSnapshot = { key: key2, raw: raw2, at: Date.now() };
+        this.earningsSnapshot = { key: key2, raw, at: Date.now() };
       }
-      return raw2;
+      return raw;
     }).finally(() => {
       if (this.earningsReads.get(key2) === pending)
         this.earningsReads.delete(key2);
@@ -2130,11 +1945,11 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   async getEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw2 = await this.readEarnings(
+    const raw = await this.readEarnings(
       this.earningsKey(state, chainId, smartWallet),
       smartWallet
     );
-    return mapEarnings(raw2, smartWallet);
+    return mapEarnings(raw, smartWallet);
   }
   async refreshEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
@@ -2161,17 +1976,17 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   async getAccountApy(state, chainId, days, tokenSymbol) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw2 = await this.sdk.getDailyApyHistory(smartWallet, days);
-    return mapApyHistory(raw2, chainId, tokenSymbol);
+    const raw = await this.sdk.getDailyApyHistory(smartWallet, days);
+    return mapApyHistory(raw, chainId, tokenSymbol);
   }
   async getDailyEarnings(state, chainId, days, tokenSymbol) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
     const start = new Date(Date.now() - (DayFilterMapping[days] + 1) * 864e5);
-    const raw2 = await this.sdk.getDailyEarnings(
+    const raw = await this.sdk.getDailyEarnings(
       smartWallet,
       start.toISOString().slice(0, 10)
     );
-    return mapDailyEarnings(raw2, chainId, tokenSymbol);
+    return mapDailyEarnings(raw, chainId, tokenSymbol);
   }
   /**
    * Owney speaks asset symbols ("USDC" / "WETH"); Zyfai's history endpoint
@@ -2206,7 +2021,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
     const matched = [];
     let backendExhausted = false;
     for (let i = 0; i < MAX_BACKEND_CALLS && matched.length < limit; i++) {
-      const raw2 = await this.sdk.getHistory(smartWallet, validChainId, {
+      const raw = await this.sdk.getHistory(smartWallet, validChainId, {
         limit: backendPageSize,
         offset,
         fromDate: options?.fromDate,
@@ -2217,13 +2032,13 @@ var ZyfaiAgent = class _ZyfaiAgent {
         // asset's rows and handing back a page that filters to nothing.
         assetType
       });
-      raw2.data.forEach((entry, idx) => {
+      raw.data.forEach((entry, idx) => {
         if (entry.chainId === validChainId) {
           matched.push({ entry, rawIdx: offset + idx });
         }
       });
-      offset += raw2.data.length;
-      if (raw2.data.length < backendPageSize) {
+      offset += raw.data.length;
+      if (raw.data.length < backendPageSize) {
         backendExhausted = true;
         break;
       }
@@ -2245,18 +2060,18 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   async getUserProfile(state, chainId) {
     await this.connectAuth(state, chainId);
-    const raw2 = await this.sdk.getUserDetails();
+    const raw = await this.sdk.getUserDetails();
     debugLog("zyfai:profile", "getUserProfile \u2014 Zyfai reports", {
       asset: "USDC (default \u2014 no asset passed)",
-      splitting: raw2.splitting,
-      minSplits: raw2.minSplits,
-      strategy: raw2.strategy,
-      chains: raw2.chains,
-      protocolCount: raw2.protocols?.length,
-      hasActiveSessionKey: raw2.hasActiveSessionKey,
-      smartWallet: raw2.smartWallet
+      splitting: raw.splitting,
+      minSplits: raw.minSplits,
+      strategy: raw.strategy,
+      chains: raw.chains,
+      protocolCount: raw.protocols?.length,
+      hasActiveSessionKey: raw.hasActiveSessionKey,
+      smartWallet: raw.smartWallet
     });
-    return mapUserProfile(raw2, this.connectedAddress);
+    return mapUserProfile(raw, this.connectedAddress);
   }
   async ensureAutoSelectProtocols(state, chainId, asset) {
     await this.connectAuth(state, chainId);
@@ -2275,2242 +2090,111 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   // --- IAgent: Discovery (no wallet required) ---
   async getAgentApy(days, options) {
-    const raw2 = await this.sdk.getAPYPerStrategy(
+    const raw = await this.sdk.getAPYPerStrategy(
       false,
       DayFilterMapping[days],
       "aggressive",
       options?.chainId,
       options?.tokenSymbol
     );
-    return mapApyByStrategy(raw2);
+    return mapApyByStrategy(raw);
   }
 };
 
-// src/agents/yieldseeker/yieldseeker.agent.ts
-import {
-  createPublicClient as createPublicClient3,
-  createWalletClient as createWalletClient2,
-  custom as custom2,
-  encodeFunctionData,
-  erc20Abi,
-  getAddress as getAddress2,
-  isAddress as isAddress2
-} from "viem";
-import { base as base3 } from "viem/chains";
-
-// src/lib/chain-guard.ts
-var CHAIN_NAMES = {
-  1: "Ethereum",
-  8453: "Base",
-  42161: "Arbitrum"
-};
-function chainName(chainId) {
-  return CHAIN_NAMES[chainId] ?? `chain ${chainId}`;
-}
-async function ensureWalletOnChain(pub, wallet, expected) {
-  const actual = await pub.getChainId();
-  if (actual === expected) return;
+// src/lib/routing-api.ts
+var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function fetchOrgAgentConfig(apiKey, baseUrl = ROUTING_API_BASE_URL) {
+  const url = `${baseUrl}/api/v1/agent/org-config`;
   try {
-    await wallet.switchChain({ id: expected });
+    const res = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-owney-api-key": `${apiKey}`
+      }
+    });
+    if (!res.ok) {
+      if (res.status !== 404) {
+        console.warn(
+          `[owney-sdk] Could not read org agent config (${res.status}); leaving user profiles unchanged.`
+        );
+      }
+      return null;
+    }
+    const json = await res.json();
+    const policy = json.success ? json.data ?? null : null;
+    debugLog(
+      "owney-sdk",
+      policy ? "org agent config: loaded" : "org agent config: none set by this partner \u2014 user profiles will be left as they are",
+      policy ?? void 0
+    );
+    return policy;
   } catch (error) {
+    console.warn(
+      "[owney-sdk] Could not read org agent config (non-fatal):",
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL) {
+  const url = `${baseUrl}/api/v1/agent/keys`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "x-owney-api-key": `${apiKey}`
+    }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
     throw new OwneyError(
-      "CHAIN_MISMATCH",
-      `Your wallet is on ${chainName(actual)}. Switch it to ${chainName(expected)} and try again.`,
-      {
-        expectedChainId: expected,
-        actualChainId: actual,
-        cause: error instanceof Error ? error.message : String(error)
-      }
+      "API_ROUTING_ERROR",
+      `Routing API error ${res.status}: ${text}`,
+      { statusCode: res.status, responseBody: text }
     );
   }
-  const after = await pub.getChainId();
-  if (after !== expected) {
+  const json = await res.json();
+  if (!json.success) {
     throw new OwneyError(
-      "CHAIN_MISMATCH",
-      `Your wallet is still on ${chainName(after)}. Switch it to ${chainName(expected)} and try again.`,
-      { expectedChainId: expected, actualChainId: after }
+      "API_ROUTING_FAILED",
+      `Routing API request failed: ${json.message}`,
+      { message: json.message }
     );
   }
+  return json.data;
 }
 
-// src/lib/transfer-auth.ts
-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;
-  let res;
+// src/lib/health-report.ts
+var ROUTING_API_BASE_URL2 = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function reportAgentFailure(apiKey, agentType, errorCode, baseUrl = ROUTING_API_BASE_URL2) {
   try {
-    res = await fetch(`${base5}/api/v1/sponsor/paymaster-intent`, {
+    await fetch(`${baseUrl}/api/v1/agent/health-report`, {
       method: "POST",
       headers: {
-        "content-type": "application/json",
-        "x-owney-api-key": input.apiKey,
-        Authorization: `Signature ${input.yieldseekerSignature}`
+        "Content-Type": "application/json",
+        "x-owney-api-key": apiKey
       },
-      body: JSON.stringify(input.body)
+      body: JSON.stringify({
+        agent_type: agentType,
+        error_code: errorCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
     });
-  } catch (networkError) {
-    throw new OwneyError(
-      "SPONSOR_REQUEST_FAILED",
-      `Paymaster intent network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
-      { cause: String(networkError), safeToFallback: true }
-    );
-  }
-  const text = await res.text();
-  let parsed = null;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-  }
-  if (!res.ok || !parsed?.success || typeof parsed.data?.intent !== "string" || typeof parsed.data.expiresAt !== "number") {
-    throw new OwneyError(
-      "SPONSOR_REQUEST_FAILED",
-      `Paymaster intent API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
-      {
-        statusCode: res.status,
-        responseBody: text.slice(0, 500),
-        safeToFallback: true
-      }
-    );
-  }
-  return parsed.data;
-}
-async function getSponsorRelayerAddress(input) {
-  const base5 = input.baseUrl ?? ROUTING_API_BASE_URL;
-  let res;
-  try {
-    res = await fetch(
-      `${base5}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
-      {
-        headers: { "x-owney-api-key": input.apiKey }
-      }
-    );
-  } catch (networkError) {
-    throw new OwneyError(
-      "SPONSOR_REQUEST_FAILED",
-      `Sponsor API network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
-      { cause: String(networkError), safeToFallback: true }
-    );
-  }
-  const text = await res.text();
-  let parsed = null;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-  }
-  if (!res.ok || !parsed?.success || !parsed.data?.relayer) {
-    throw new OwneyError(
-      "SPONSOR_REQUEST_FAILED",
-      `Sponsor API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
-      {
-        statusCode: res.status,
-        responseBody: text.slice(0, 500),
-        safeToFallback: true
-      }
+  } catch (err) {
+    console.warn(
+      `[owney-sdk] health-report failed for agent "${agentType}":`,
+      err instanceof Error ? err.message : err
     );
   }
-  return parsed.data.relayer;
 }
-async function postSponsorBatchTransfer(input) {
-  let res;
+async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
   try {
-    res = await fetch(
-      `${input.baseUrl ?? ROUTING_API_BASE_URL}/api/v1/sponsor/permit2-batch`,
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-owney-api-key": input.apiKey
-        },
-        body: JSON.stringify(input.body)
-      }
-    );
-  } catch {
-    throw new OwneyError(
-      "SPONSOR_REQUEST_FAILED",
-      "Deposit status is unknown. Retry the same amount to check it.",
-      { safeToFallback: false }
-    );
-  }
-  const parsed = await res.json().catch(() => null);
-  if (!res.ok || !parsed?.success || !/^0x[0-9a-fA-F]{64}$/.test(parsed.data?.txHash ?? "")) {
-    throw new OwneyError(
-      "SPONSOR_REQUEST_FAILED",
-      "Deposit could not be confirmed. Retry the same amount to check its status.",
-      {
-        statusCode: res.status,
-        safeToFallback: false,
-        notSubmitted: parsed?.notSubmitted === true || parsed?.error?.notSubmitted === true || parsed?.error?.details?.notSubmitted === true
-      }
-    );
-  }
-  return parsed.data;
-}
-
-// src/lib/permit2.ts
-import { bytesToHex as bytesToHex2 } from "viem";
-var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var MAX_UINT256 = 2n ** 256n - 1n;
-function permit2ApprovalAmount(requiredAmount) {
-  if (requiredAmount <= 0n) {
-    throw new Error("Permit2 approval requires a positive deposit amount");
-  }
-  return MAX_UINT256;
-}
-var ERC20_ALLOWANCE_ABI = [
-  {
-    type: "function",
-    name: "allowance",
-    stateMutability: "view",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    type: "function",
-    name: "approve",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }]
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }]
-  }
-];
-function randomPermit2Nonce() {
-  const bytes = new Uint8Array(32);
-  globalThis.crypto.getRandomValues(bytes);
-  return BigInt(bytesToHex2(bytes));
-}
-async function readPermit2Allowance(publicClient, token, owner, blockNumber) {
-  return publicClient.readContract({
-    address: token,
-    abi: ERC20_ALLOWANCE_ABI,
-    functionName: "allowance",
-    args: [owner, PERMIT2_ADDRESS],
-    ...blockNumber === void 0 ? {} : { blockNumber }
-  });
-}
-async function readErc20Balance(publicClient, token, owner) {
-  return publicClient.readContract({
-    address: token,
-    abi: ERC20_ALLOWANCE_ABI,
-    functionName: "balanceOf",
-    args: [owner]
-  });
-}
-
-// src/lib/sponsored-deposit.ts
-var AUTH_WINDOW_SECONDS = 15 * 60;
-var verificationSetter = /* @__PURE__ */ Symbol("owney.depositVerificationSetter");
-function provideDepositVerificationContext(callback, context) {
-  callback[verificationSetter]?.(context);
-}
-function makeVerificationAwareDepositCallback(implementation) {
-  let nextVerification;
-  const callback = async (smartWallet, chainId, amount) => {
-    const verification = nextVerification;
-    nextVerification = void 0;
-    return implementation(smartWallet, chainId, amount, verification);
-  };
-  Object.defineProperty(callback, verificationSetter, {
-    value: (context) => {
-      nextVerification = context;
-    }
-  });
-  return callback;
-}
-
-// src/agents/yieldseeker/yieldseeker.auth.ts
-import { SiweMessage, generateNonce } from "siwe";
-import {
-  createPublicClient as createPublicClient2,
-  createWalletClient,
-  custom,
-  getAddress
-} from "viem";
-import { base as base2 } from "viem/chains";
-
-// src/agents/yieldseeker/yieldseeker.auth-cache.ts
-var KEY_PREFIX2 = "owney.yieldseeker.session.v5";
-var INVALIDATED_KEY_PREFIXES = [
-  "owney.yieldseeker.session",
-  "owney.yieldseeker.session.v3",
-  "owney.yieldseeker.session.v4"
-];
-var storage2 = () => {
-  if (typeof window === "undefined") return null;
-  try {
-    return window.localStorage;
-  } catch {
-    return null;
-  }
-};
-var buildKey2 = (address, chainId) => `${KEY_PREFIX2}:${address.toLowerCase()}:${chainId}`;
-var invalidatedKeys = (address, chainId) => INVALIDATED_KEY_PREFIXES.map(
-  (prefix) => `${prefix}:${address.toLowerCase()}:${chainId}`
-);
-var clearInvalidatedSessions = (store, address, chainId) => {
-  for (const key2 of invalidatedKeys(address, chainId)) {
-    memorySessions2.delete(key2);
-    try {
-      store?.removeItem(key2);
-    } catch {
-    }
-  }
-};
-var memorySessions2 = /* @__PURE__ */ new Map();
-var isValidSession = (session) => {
-  if (!session?.token) return false;
-  try {
-    const parsed = JSON.parse(atob(session.token));
-    return typeof parsed.message === "string" && typeof parsed.signature === "string" && parsed.signature.startsWith("0x");
-  } catch {
-    return false;
-  }
-};
-var readYieldseekerSession = (address, chainId) => {
-  if (typeof window === "undefined") return null;
-  const key2 = buildKey2(address, chainId);
-  const store = storage2();
-  clearInvalidatedSessions(store, address, chainId);
-  let raw2 = null;
-  try {
-    raw2 = store?.getItem(key2) ?? null;
-  } catch {
-    raw2 = null;
-  }
-  if (raw2) {
-    try {
-      const parsed = JSON.parse(raw2);
-      if (isValidSession(parsed)) return parsed.token;
-    } catch {
-    }
-    memorySessions2.delete(key2);
-    try {
-      store?.removeItem(key2);
-    } catch {
-    }
-    return null;
-  }
-  const cached = memorySessions2.get(key2);
-  if (isValidSession(cached)) return cached.token;
-  if (cached) memorySessions2.delete(key2);
-  return null;
-};
-var writeYieldseekerSession = (address, chainId, token) => {
-  if (typeof window === "undefined") return;
-  const session = { token };
-  if (!isValidSession(session)) return;
-  const key2 = buildKey2(address, chainId);
-  memorySessions2.set(key2, session);
-  const store = storage2();
-  try {
-    store?.setItem(key2, JSON.stringify(session));
-  } catch {
-  }
-};
-var clearYieldseekerSession = (address, chainId) => {
-  const key2 = buildKey2(address, chainId);
-  memorySessions2.delete(key2);
-  const store = storage2();
-  clearInvalidatedSessions(store, address, chainId);
-  try {
-    store?.removeItem(key2);
-  } catch {
-  }
-};
-
-// src/agents/yieldseeker/yieldseeker.auth.ts
-function resolveSiweOrigin(override) {
-  const origin = override?.trim() || (typeof window !== "undefined" ? window.location?.origin : void 0);
-  if (!origin || origin === "null") {
-    throw new Error("Yieldseeker sign-in requires the requesting app's browser origin.");
-  }
-  const url = new URL(origin);
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new Error("Yieldseeker sign-in requires an HTTP or HTTPS app origin.");
-  }
-  if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
-    throw new Error("Yieldseeker SIWE override must be an origin without credentials, path, query, or fragment.");
-  }
-  return url;
-}
-function createYieldseekerSiweMessage(address, chainId, dependencies = {}) {
-  const url = resolveSiweOrigin(dependencies.origin);
-  return new SiweMessage({
-    scheme: url.protocol.slice(0, -1),
-    domain: url.host,
-    address: getAddress(address),
-    uri: url.origin,
-    version: "1",
-    chainId,
-    nonce: (dependencies.nonce ?? generateNonce)(),
-    issuedAt: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
-  }).prepareMessage();
-}
-function encodeYieldseekerAuthToken(token) {
-  const bytes = new TextEncoder().encode(JSON.stringify(token));
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
-}
-var YieldseekerAuth = class {
-  constructor(dependencies = {}) {
-    this.dependencies = dependencies;
-  }
-  dependencies;
-  tokens = /* @__PURE__ */ new Map();
-  pending = /* @__PURE__ */ new Map();
-  scopes = /* @__PURE__ */ new Map();
-  key(state, chainId) {
-    return `${state.walletAddress.toLowerCase()}:${chainId}:${resolveSiweOrigin(this.dependencies.origin).origin}`;
-  }
-  async getToken(state, chainId) {
-    const key2 = this.key(state, chainId);
-    const scope = { address: state.walletAddress, chainId };
-    this.scopes.set(key2, scope);
-    const cached = this.tokens.get(key2);
-    if (cached) return cached;
-    const persisted = readYieldseekerSession(scope.address, scope.chainId);
-    if (persisted && this.matchesOrigin(persisted)) {
-      this.tokens.set(key2, persisted);
-      return persisted;
-    }
-    if (persisted) clearYieldseekerSession(scope.address, scope.chainId);
-    const inFlight = this.pending.get(key2);
-    if (inFlight) return inFlight;
-    const request = this.sign(state, chainId).then((token) => {
-      if (this.pending.get(key2) !== request) throw new Error("Wallet sign-in session changed. Please try again.");
-      this.tokens.set(key2, token);
-      writeYieldseekerSession(scope.address, scope.chainId, token);
-      return token;
-    });
-    this.pending.set(key2, request);
-    try {
-      return await request;
-    } finally {
-      if (this.pending.get(key2) === request) this.pending.delete(key2);
-    }
-  }
-  async refreshToken(state, chainId, rejectedToken) {
-    const key2 = this.key(state, chainId);
-    if (this.tokens.get(key2) === rejectedToken) {
-      this.tokens.delete(key2);
-      clearYieldseekerSession(state.walletAddress, chainId);
-    }
-    return this.getToken(state, chainId);
-  }
-  matchesOrigin(token) {
-    try {
-      const message = new SiweMessage(JSON.parse(atob(token)).message);
-      const url = resolveSiweOrigin(this.dependencies.origin);
-      return message.domain === url.host && message.uri === url.origin && message.scheme === url.protocol.slice(0, -1);
-    } catch {
-      return false;
-    }
-  }
-  clear(state, chainId) {
-    if (!state || chainId === void 0) {
-      for (const scope of this.scopes.values()) {
-        clearYieldseekerSession(scope.address, scope.chainId);
-      }
-      this.tokens.clear();
-      this.pending.clear();
-      this.scopes.clear();
-      return;
-    }
-    const key2 = this.key(state, chainId);
-    this.tokens.delete(key2);
-    this.pending.delete(key2);
-    this.scopes.delete(key2);
-    clearYieldseekerSession(state.walletAddress, chainId);
-  }
-  async sign(state, chainId) {
-    const account = getAddress(state.walletAddress);
-    const publicClient = createPublicClient2({
-      chain: base2,
-      transport: custom(state.provider)
-    });
-    const walletClient = createWalletClient({
-      account,
-      chain: base2,
-      transport: custom(state.provider)
-    });
-    await ensureWalletOnChain(
-      publicClient,
-      walletClient,
-      8453
-    );
-    const message = createYieldseekerSiweMessage(
-      account,
-      chainId,
-      this.dependencies
-    );
-    const signature = await walletClient.signMessage({ account, message });
-    return encodeYieldseekerAuthToken({ message, signature });
-  }
-};
-
-// src/agents/yieldseeker/yieldseeker.identity-cache.ts
-var KEY_PREFIX3 = "owney.yieldseeker.identity.v1";
-var YIELDSEEKER_IDENTITY_TTL_MS = 24 * 60 * 60 * 1e3;
-var memoryIdentities = /* @__PURE__ */ new Map();
-var storage3 = () => {
-  if (typeof window === "undefined") return null;
-  try {
-    return window.localStorage;
-  } catch {
-    return null;
-  }
-};
-var keyFor = (walletAddress, chainId) => `${KEY_PREFIX3}:${walletAddress.toLowerCase()}:${chainId}`;
-function valid(value, walletAddress, chainId, now) {
-  return Boolean(
-    value && typeof value.userId === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(value.userId) && value.walletAddress.toLowerCase() === walletAddress.toLowerCase() && value.chainId === chainId && Number.isSafeInteger(value.expiresAt) && value.expiresAt > now
-  );
-}
-function readYieldseekerIdentity(walletAddress, chainId, now = Date.now()) {
-  if (typeof window === "undefined") return null;
-  const key2 = keyFor(walletAddress, chainId);
-  const store = storage3();
-  let parsed = null;
-  try {
-    const raw2 = store?.getItem(key2);
-    parsed = raw2 ? JSON.parse(raw2) : null;
-  } catch {
-    parsed = null;
-  }
-  const candidate = parsed ?? memoryIdentities.get(key2);
-  if (valid(candidate, walletAddress, chainId, now)) {
-    memoryIdentities.set(key2, candidate);
-    return { userId: candidate.userId };
-  }
-  memoryIdentities.delete(key2);
-  try {
-    store?.removeItem(key2);
-  } catch {
-  }
-  return null;
-}
-function writeYieldseekerIdentity(walletAddress, chainId, userId, now = Date.now()) {
-  if (typeof window === "undefined") return;
-  const identity = {
-    userId,
-    walletAddress,
-    chainId,
-    expiresAt: now + YIELDSEEKER_IDENTITY_TTL_MS
-  };
-  if (!valid(identity, walletAddress, chainId, now)) return;
-  const key2 = keyFor(walletAddress, chainId);
-  memoryIdentities.set(key2, identity);
-  try {
-    storage3()?.setItem(key2, JSON.stringify(identity));
-  } catch {
-  }
-}
-function clearYieldseekerIdentity(walletAddress, chainId) {
-  const key2 = keyFor(walletAddress, chainId);
-  memoryIdentities.delete(key2);
-  try {
-    storage3()?.removeItem(key2);
-  } catch {
-  }
-}
-
-// src/agents/yieldseeker/yieldseeker.client.ts
-var DEFAULT_ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
-function getYieldseekerProxyBaseUrl(routingApiBaseUrl = DEFAULT_ROUTING_API_BASE_URL) {
-  return `${routingApiBaseUrl.replace(/\/$/, "")}/api/v1/agent/yieldseeker`;
-}
-var YIELDSEEKER_API_BASE_URL = getYieldseekerProxyBaseUrl();
-var YieldseekerApiError = class extends Error {
-  constructor(status, providerCode, responseFields) {
-    super(`Yieldseeker request failed (${status}): ${providerCode}`);
-    this.status = status;
-    this.providerCode = providerCode;
-    this.responseFields = responseFields;
-    this.name = "YieldseekerApiError";
-  }
-  status;
-  providerCode;
-  responseFields;
-  get isAuthenticationError() {
-    return this.status === 401 || this.status === 403;
-  }
-};
-function providerError(body, fallback) {
-  if (!body || typeof body !== "object") return { code: fallback };
-  const record = body;
-  return {
-    code: typeof record.message === "string" ? record.message : fallback,
-    fields: record.fields && typeof record.fields === "object" ? record.fields : void 0
-  };
-}
-var YieldseekerApiClient = class {
-  constructor(owneyApiKey, baseUrl = YIELDSEEKER_API_BASE_URL, fetchFn = fetch.bind(globalThis)) {
-    this.owneyApiKey = owneyApiKey;
-    this.baseUrl = baseUrl;
-    this.fetchFn = fetchFn;
-  }
-  owneyApiKey;
-  baseUrl;
-  fetchFn;
-  async request(path, options = {}) {
-    const controller = new AbortController();
-    const timer = setTimeout(
-      () => controller.abort(),
-      options.timeoutMs ?? 15e3
-    );
-    try {
-      const response = await this.fetchFn(`${this.baseUrl}${path}`, {
-        method: options.method ?? "GET",
-        headers: {
-          "Content-Type": "application/json",
-          "x-owney-api-key": this.owneyApiKey,
-          ...options.signature ? { Authorization: `Signature ${options.signature}` } : {}
-        },
-        body: options.body ? JSON.stringify(options.body) : void 0,
-        signal: controller.signal
-      });
-      const payload = await response.json().catch(() => null);
-      if (!response.ok) {
-        const error = providerError(payload, `HTTP_${response.status}`);
-        const retryAfter = response.headers.get("Retry-After");
-        throw new YieldseekerApiError(
-          response.status,
-          error.code,
-          retryAfter ? { ...error.fields, headers: { "Retry-After": retryAfter } } : error.fields
-        );
-      }
-      if (payload && typeof payload === "object" && payload.success === true && "data" in payload) {
-        return payload.data;
-      }
-      return payload;
-    } catch (error) {
-      if (error instanceof YieldseekerApiError) throw error;
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw new YieldseekerApiError(408, "REQUEST_TIMEOUT");
-      }
-      throw new YieldseekerApiError(0, "NETWORK_ERROR", {
-        cause: error instanceof Error ? error.message : String(error)
-      });
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-};
-
-// src/agents/yieldseeker/yieldseeker.mapper.ts
-import { formatUnits, isAddress } from "viem";
-
-// src/lib/helpers/snapshot-apy.ts
-var DAY_MS = 864e5;
-function snapshotTime(date) {
-  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return void 0;
-  const time = Date.parse(date);
-  return Number.isFinite(time) && new Date(time).toISOString().slice(0, 10) === date ? time : void 0;
-}
-function returnFactor(value) {
-  if (typeof value !== "number" && typeof value !== "string") return void 0;
-  if (typeof value === "string" && value.trim() === "") return void 0;
-  const factor = Number(value);
-  return Number.isFinite(factor) && factor >= 0 ? factor : void 0;
-}
-function calculateSnapshotApy(snapshots, lookbackDays, now = Date.now()) {
-  if (!Number.isFinite(lookbackDays) || lookbackDays <= 0 || !Number.isFinite(now)) {
-    return void 0;
-  }
-  const points = snapshots.flatMap((snapshot) => {
-    const time = snapshotTime(snapshot.date);
-    return time !== void 0 && time <= now ? [{ snapshot, time }] : [];
-  }).sort((a, b) => a.time - b.time);
-  const end = points.at(-1);
-  if (!end) return void 0;
-  const cutoff = end.time - lookbackDays * DAY_MS;
-  const start = points.find((point) => point.time >= cutoff);
-  const actualDays = (end.time - start.time) / DAY_MS;
-  if (actualDays <= 0) return void 0;
-  const startFactor = returnFactor(start.snapshot.cumulativeReturnFactor);
-  const endFactor = returnFactor(end.snapshot.cumulativeReturnFactor);
-  if (startFactor === void 0 || startFactor === 0 || endFactor === void 0) {
-    return void 0;
-  }
-  const periodReturn = endFactor / startFactor - 1;
-  const apy = Math.pow(1 + periodReturn, 365 / actualDays) - 1;
-  return Number.isFinite(apy) ? apy : void 0;
-}
-
-// src/agents/yieldseeker/yieldseeker.types.ts
-var YIELDSEEKER_ASSET_METADATA = {
-  USDC: {
-    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    decimals: 6
-  },
-  WETH: {
-    address: "0x4200000000000000000000000000000000000006",
-    decimals: 18
-  }
-};
-
-// src/agents/yieldseeker/yieldseeker.mapper.ts
-function invalid(endpoint, detail) {
-  throw new OwneyError(
-    "AGENT_INVALID_RESPONSE",
-    `Yieldseeker returned an invalid ${endpoint} response: ${detail}.`,
-    { endpoint, detail },
-    "yieldseeker"
-  );
-}
-function raw(value, endpoint) {
-  if (typeof value !== "string" || !/^-?[0-9]+$/.test(value)) {
-    return invalid(endpoint, "expected a base-10 integer string");
-  }
-  return BigInt(value);
-}
-function decimal(value, decimals, endpoint) {
-  return formatUnits(raw(value, endpoint), decimals);
-}
-function usd(rawAmount, decimals, price) {
-  return Number(formatUnits(rawAmount, decimals)) * price;
-}
-function percent(value) {
-  const result = Number(value);
-  return Number.isFinite(result) ? result * 100 : 0;
-}
-var YIELDSEEKER_POSITIVE_YIELD_FEE_RATE = 0.1;
-function publicApyAfterYieldseekerFee(value) {
-  const grossPercent = percent(value);
-  if (grossPercent <= 0) return grossPercent;
-  const netPercent = grossPercent * (1 - YIELDSEEKER_POSITIVE_YIELD_FEE_RATE);
-  return Math.round(netPercent * 1e12) / 1e12;
-}
-function riskAdjustedApyForDays(option, days) {
-  if (days === "7D") return option.riskAdjustedApy7dAverage;
-  if (days === "30D") return option.riskAdjustedApy30dAverage;
-  return (option.riskAdjustedApy7dAverage + option.riskAdjustedApy30dAverage) / 2;
-}
-function assetAddressValue(record, address) {
-  const entry = Object.entries(record).find(
-    ([key2]) => key2.toLowerCase() === address.toLowerCase()
-  );
-  return entry?.[1] ?? "0";
-}
-function position(value, asset, baseAssetDecimals) {
-  const option = value?.yieldOption;
-  if (!option || typeof option.provider !== "string" || typeof option.name !== "string" || typeof option.address !== "string" || !isAddress(option.address)) {
-    return invalid("yield positions", "missing vault metadata");
-  }
-  return {
-    chain: "BASE",
-    protocol: option.provider,
-    protocolId: option.address,
-    pool: option.name,
-    asset,
-    // `assetsRaw` is the ERC-4626 vault-share quantity, whose decimals can
-    // differ from the underlying asset. Yieldseeker already converts it to
-    // underlying base-asset units in `assetsBase`; pair that value with the
-    // snapshot's corresponding `baseAssetDecimals` for display. Keep the raw
-    // share quantity separate from the withdrawable underlying asset amount.
-    amount: decimal(
-      value.assetsBase,
-      baseAssetDecimals,
-      "yield positions"
-    ),
-    amountRaw: String(value.assetsRaw),
-    withdrawableAmountRaw: String(value.withdrawableAssetsRaw),
-    apy: percent(option.riskAdjustedApy),
-    tvl: Number(option.totalDepositsUsd),
-    liquidity: Number(option.withdrawableDepositsUsd)
-  };
-}
-function mapYieldseekerBalances(contexts) {
-  const tokens = [];
-  const assetBalances = [];
-  const positions = [];
-  let totalUsd = 0;
-  for (const context of contexts) {
-    const metadata = YIELDSEEKER_ASSET_METADATA[context.asset];
-    assetBalances.push({
-      chain: "BASE",
-      chainId: 8453,
-      asset: context.asset,
-      amount: decimal(context.snapshot.totalValueBase, context.snapshot.baseAssetDecimals, "snapshot")
-    });
-    const idle = assetAddressValue(
-      context.snapshot.tokenBalances,
-      metadata.address
-    );
-    tokens.push({
-      chain: "BASE",
-      chainId: 8453,
-      asset: context.asset,
-      amount: decimal(idle, metadata.decimals, "snapshot")
-    });
-    positions.push(
-      ...context.positions.map(
-        (entry) => position(
-          entry,
-          context.asset,
-          context.snapshot.baseAssetDecimals
-        )
-      )
-    );
-    totalUsd += usd(
-      raw(context.snapshot.totalValueBase, "snapshot"),
-      context.snapshot.baseAssetDecimals,
-      context.snapshot.baseAssetPriceUsd
-    );
-  }
-  return {
-    ...contexts.length === 1 ? { smartWallet: contexts[0].wallet.walletAddress } : {},
-    totalBalance: String(totalUsd),
-    totalBalanceAsset: "usdc",
-    assetBalances,
-    tokens,
-    positions
-  };
-}
-function mapYieldseekerEarnings(contexts) {
-  const tokens = [];
-  let lifetimeEarnings = 0;
-  for (const context of contexts) {
-    const amount = raw(context.snapshot.cumulativeYieldBase, "snapshot");
-    tokens.push({
-      chain: "BASE",
-      chainId: 8453,
-      asset: context.asset,
-      amount: formatUnits(amount, context.snapshot.baseAssetDecimals)
-    });
-    lifetimeEarnings += usd(
-      amount,
-      context.snapshot.baseAssetDecimals,
-      context.snapshot.baseAssetPriceUsd
-    );
-  }
-  return {
-    smartWallet: contexts[0]?.wallet.walletAddress ?? "0x0000000000000000000000000000000000000000",
-    lifetimeEarnings,
-    tokens
-  };
-}
-function apyForDays(context, days, now) {
-  if (days === "7D") return percent(context.snapshot.apy7d);
-  if (days === "30D") return percent(context.snapshot.apy30d);
-  const apy = calculateSnapshotApy(context.historic?.dailyYieldSnapshots ?? [], 14, now);
-  const apyPercent = apy === void 0 ? void 0 : apy * 100;
-  return apyPercent !== void 0 && Number.isFinite(apyPercent) ? apyPercent : void 0;
-}
-function dailyApy(point) {
-  const total = raw(point.totalValueBase, "historic position");
-  const earned = raw(point.dailyYieldBase, "historic position");
-  const principal = total - earned;
-  if (principal <= 0n || earned === 0n) return 0;
-  return Number(earned) / Number(principal) * 365 * 100;
-}
-function aggregateHistory(contexts, dayCount, now) {
-  const today = new Date(now).toISOString().slice(0, 10);
-  const cutoff = new Date(Date.parse(today) - (dayCount - 1) * 864e5).toISOString().slice(0, 10);
-  const assets = new Set(contexts.map((context) => context.asset.toUpperCase()));
-  const unit = assets.size === 1 ? [...assets][0] : "USD";
-  const byDate = /* @__PURE__ */ new Map();
-  for (const context of contexts) {
-    const points = context.historic?.dailyYieldSnapshots ?? [];
-    for (const point of points) {
-      if (!/^\d{4}-\d{2}-\d{2}$/.test(point.date) || !Number.isFinite(Date.parse(point.date)) || point.date < cutoff || point.date > today) continue;
-      const tokens = Number(decimal(point.totalValueBase, point.baseAssetDecimals, "historic position"));
-      const amount = assets.size === 1 ? tokens : tokens * point.baseAssetPriceUsd;
-      if (!Number.isFinite(amount) || amount < 0) {
-        invalid("historic position", "expected a finite non-negative balance");
-      }
-      const current = byDate.get(point.date) ?? { weighted: 0, amount: 0 };
-      current.weighted += dailyApy(point) * amount;
-      current.amount += amount;
-      byDate.set(point.date, current);
-    }
-  }
-  return [...byDate.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([date, value]) => ({
-    date,
-    apy: value.amount > 0 ? value.weighted / value.amount : 0,
-    historicalBalance: { amount: value.amount, unit }
-  }));
-}
-function mapYieldseekerApy(walletAddress, contexts, days, now = Date.now()) {
-  let weighted = 0;
-  let totalUsd = 0;
-  const byAsset = {};
-  for (const context of contexts) {
-    const valueUsd = usd(
-      raw(context.snapshot.totalValueBase, "snapshot"),
-      context.snapshot.baseAssetDecimals,
-      context.snapshot.baseAssetPriceUsd
-    );
-    const apy = apyForDays(context, days, now);
-    if (apy === void 0) continue;
-    weighted += apy * valueUsd;
-    totalUsd += valueUsd;
-    byAsset[context.asset] = apy;
-  }
-  const dayCount = Number(days.slice(0, -1));
-  return {
-    walletAddress,
-    ...days !== "14D" || Object.keys(byAsset).length > 0 ? { weightedApyAfterFee: totalUsd > 0 ? weighted / totalUsd : 0 } : {},
-    apyByChainAndAsset: { 8453: byAsset },
-    history: aggregateHistory(contexts, dayCount, now)
-  };
-}
-function actionType(value) {
-  const normalized = value.toLowerCase();
-  if (normalized.includes("deposit")) return "Deposit";
-  if (normalized.includes("withdraw")) return "Withdraw";
-  if (normalized.includes("yield") || normalized.includes("earn"))
-    return "Earned";
-  return "Rebalance";
-}
-function transactionHashes(details) {
-  if (!details) return [];
-  const values = [
-    details.transactionHash,
-    details.txHash,
-    ...Array.isArray(details.transactionHashes) ? details.transactionHashes : [],
-    ...Array.isArray(details.txHashes) ? details.txHashes : []
-  ];
-  return values.filter(
-    (value) => typeof value === "string" && /^0x[a-fA-F0-9]{64}$/.test(value)
-  ).filter((value, index, all) => all.indexOf(value) === index);
-}
-function actionEntry(action) {
-  if (action.actionType.toLowerCase().includes("withdraw")) return void 0;
-  return {
-    agent: "yieldseeker",
-    action: actionType(action.actionType),
-    date: action.createdDate,
-    oldApy: null,
-    newApy: null,
-    transactions: [
-      {
-        txHashes: transactionHashes(action.details),
-        chainId: 8453
-      }
-    ],
-    rebalanceLog: []
-  };
-}
-function depositDestination(context, movement) {
-  const to = movement.toAddress.toLowerCase();
-  const option = context.positions.find(({ yieldOption }) => yieldOption.chainId === movement.chainId && yieldOption.assetAddress.toLowerCase() === context.agent.assetAddress.toLowerCase() && yieldOption.address.toLowerCase() === to)?.yieldOption;
-  if (option) return { protocol: option.provider || "Vault", pool: option.name, tokenSymbol: context.asset };
-  const receipt = context.historic?.assets.find((asset) => asset.chainId === movement.chainId && !asset.isSpam && asset.address.toLowerCase() === to && asset.address.toLowerCase() !== context.agent.assetAddress.toLowerCase());
-  const minted = receipt && context.historic?.movements.some((candidate) => candidate.chainId === movement.chainId && candidate.transactionHash.toLowerCase() === movement.transactionHash.toLowerCase() && candidate.assetAddress.toLowerCase() === receipt.address.toLowerCase() && candidate.fromAddress.toLowerCase() === "0x0000000000000000000000000000000000000000" && candidate.toAddress.toLowerCase() === context.wallet.walletAddress.toLowerCase() && raw(candidate.assetAmount, "historic position") > 0n);
-  if (receipt && minted) return { protocol: "Vault", pool: receipt.name || receipt.symbol, tokenSymbol: context.asset };
-  return void 0;
-}
-function movementEntry(movement, wallet, agent, asset, ownerAddress, vaultAddresses, destination) {
-  const from = movement.fromAddress.toLowerCase();
-  const to = movement.toAddress.toLowerCase();
-  const owner = ownerAddress.toLowerCase();
-  const agentWallet = wallet.walletAddress.toLowerCase();
-  const baseAsset = agent.assetAddress.toLowerCase();
-  if (movement.chainId !== agent.chainId || movement.assetAddress.toLowerCase() !== baseAsset) {
-    return void 0;
-  }
-  let action;
-  if (to === agentWallet && !vaultAddresses.has(from)) {
-    action = "Top up";
-  } else if (from === agentWallet && to === owner) {
-    action = "Withdraw";
-  } else if (from === agentWallet && destination) {
-    action = "Deposit";
-  }
-  if (!action) return void 0;
-  return {
-    agent: "yieldseeker",
-    action,
-    ...action === "Deposit" && destination ? { positions: [{
-      ...destination,
-      amount: decimal(movement.assetAmount, YIELDSEEKER_ASSET_METADATA[asset].decimals, "historic position")
-    }] } : {},
-    date: movement.blockDate,
-    oldApy: null,
-    newApy: null,
-    transactions: [
-      {
-        txHashes: [movement.transactionHash],
-        chainId: agent.chainId,
-        tokenSymbol: asset,
-        amount: decimal(
-          movement.assetAmount,
-          YIELDSEEKER_ASSET_METADATA[asset].decimals,
-          "historic position"
-        )
-      }
-    ],
-    rebalanceLog: []
-  };
-}
-function mapYieldseekerHistory(contexts, options) {
-  const entries = contexts.flatMap((context) => {
-    const seenMovements = /* @__PURE__ */ new Set();
-    const movements = (context.historic?.movements ?? []).filter((movement) => {
-      const key2 = `${movement.chainId}:${movement.transactionHash.toLowerCase()}:${movement.logIndex}`;
-      if (seenMovements.has(key2)) return false;
-      seenMovements.add(key2);
-      return true;
-    });
-    return [
-      ...movements.map(
-        (movement) => movementEntry(
-          movement,
-          context.wallet,
-          context.agent,
-          context.asset,
-          options.ownerAddress,
-          options.vaultAddresses,
-          depositDestination(context, movement)
-        )
-      ),
-      ...(context.actions ?? []).map(actionEntry)
-    ].filter((entry) => entry !== void 0);
-  });
-  const grouped = /* @__PURE__ */ new Map();
-  const ungrouped = [];
-  for (const entry of entries) {
-    const tx = entry.transactions[0];
-    const hash = tx?.txHashes[0];
-    if (!hash) {
-      ungrouped.push(entry);
-      continue;
-    }
-    const key2 = `${entry.agent}:${entry.action}:${tx.chainId}:${hash.toLowerCase()}`;
-    const previous = grouped.get(key2);
-    if (!previous) {
-      grouped.set(key2, entry);
-      continue;
-    }
-    if (entry.action === "Deposit" && entry.positions?.length) {
-      if (!previous.positions?.length) {
-        grouped.set(key2, entry);
-        continue;
-      }
-      previous.positions.push(...entry.positions);
-      previous.transactions.push(...entry.transactions);
-    }
-  }
-  const filtered = [...grouped.values(), ...ungrouped].filter((entry) => (!options.fromDate || entry.date >= options.fromDate) && (!options.toDate || entry.date <= options.toDate)).sort((left, right) => right.date.localeCompare(left.date));
-  return {
-    data: filtered.slice(0, options.limit),
-    // v1 returns the whole action/movement collection and defines no cursor.
-    // Report a terminal page so callers never loop over the same prefix.
-    hasMore: false
-  };
-}
-function mapYieldseekerProfile(address, contexts) {
-  const protocols = /* @__PURE__ */ new Set();
-  for (const context of contexts) {
-    for (const current of context.positions) {
-      if (current.yieldOption?.provider) {
-        protocols.add(String(current.yieldOption.provider));
-      }
-    }
-  }
-  return {
-    address,
-    smartWallet: contexts[0]?.wallet.walletAddress ?? "0x0000000000000000000000000000000000000000",
-    chains: contexts.length > 0 ? [8453] : [],
-    hasActiveSessionKey: contexts.some(
-      (context) => context.wallet.initializedDate != null
-    ),
-    protocols: [...protocols]
-  };
-}
-function mapYieldseekerAgentApy(options, days) {
-  const perAsset = {};
-  const all = [];
-  for (const entry of options) {
-    const apys = entry.yieldOptions.map(
-      (option) => publicApyAfterYieldseekerFee(riskAdjustedApyForDays(option, days))
-    ).filter(Number.isFinite);
-    if (apys.length === 0) continue;
-    const average = apys.reduce((sum, value) => sum + value, 0) / apys.length;
-    perAsset[entry.asset] = average;
-    all.push(average);
-  }
-  return {
-    averageApy: all.length > 0 ? all.reduce((sum, value) => sum + value, 0) / all.length : 0,
-    detailedApys: { apyPerAsset: { 8453: perAsset } }
-  };
-}
-
-// src/agents/yieldseeker/yieldseeker.agent.ts
-var OWNEY_AGENT_NAME = "owney";
-var YIELDSEEKER_USERNAME_PREFIX = "owney_";
-var YIELDSEEKER_USERNAME_RANDOM_LENGTH = 14;
-var YIELDSEEKER_USERNAME_CREATE_ATTEMPTS = 3;
-var YIELDSEEKER_YIELD_OPTIONS_CACHE_MS = 6e4;
-var YIELDSEEKER_AGENT_LIST_CACHE_MS = 12e4;
-var YIELDSEEKER_PORTFOLIO_CACHE_MS = 12e4;
-var YIELDSEEKER_SETTLEMENT_CACHE_MS = 5e3;
-var YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS = 15e3;
-var YIELDSEEKER_READ_FAILURE_COOLDOWN_MS = 6e4;
-var YIELDSEEKER_SETTLEMENT_WINDOW_MS = 5 * 6e4;
-var YIELDSEEKER_ACTIVITY_CACHE_MS = 6e4;
-function generateYieldseekerUsername() {
-  const suffix = globalThis.crypto.randomUUID().replaceAll("-", "").slice(0, YIELDSEEKER_USERNAME_RANDOM_LENGTH).toLowerCase();
-  return `${YIELDSEEKER_USERNAME_PREFIX}${suffix}`;
-}
-function isUsernameConflict(error) {
-  if (!(error instanceof YieldseekerApiError)) return false;
-  const code = error.providerCode.toUpperCase();
-  return code.includes("USERNAME") && (code.includes("TAKEN") || code.includes("EXIST") || code.includes("UNAVAILABLE") || code.includes("IN_USE"));
-}
-var YIELDSEEKER_AGENT_WALLET_ABI = [
-  {
-    type: "function",
-    name: "withdrawAssetToUser",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "recipient", type: "address" },
-      { name: "asset", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: []
-  },
-  {
-    type: "function",
-    name: "withdrawAllAssetToUser",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "recipient", type: "address" },
-      { name: "asset", type: "address" }
-    ],
-    outputs: []
-  }
-];
-function query(params) {
-  const search = new URLSearchParams();
-  for (const [key2, value] of Object.entries(params)) {
-    if (value !== void 0) search.set(key2, String(value));
-  }
-  const encoded = search.toString();
-  return encoded ? `?${encoded}` : "";
-}
-var YieldseekerAgent = class {
-  id = "yieldseeker";
-  balanceComposition = "tokens-plus-positions";
-  withdrawalRequiresWalletApproval = true;
-  supportedChainIds = [8453];
-  supportedAssets = [
-    {
-      chainId: 8453,
-      chain: "BASE",
-      assets: [
-        { symbol: "USDC", minDepositAmount: "10000000" },
-        { symbol: "WETH", minDepositAmount: "1" }
-      ]
-    }
-  ];
-  api;
-  auth;
-  rpcUrls;
-  receiptClient;
-  transactionExecutor;
-  unwindReceiptWaiter;
-  agentContexts = /* @__PURE__ */ new Map();
-  users = /* @__PURE__ */ new Map();
-  pendingAgents = /* @__PURE__ */ new Map();
-  pendingWalletContexts = /* @__PURE__ */ new Map();
-  readCache = /* @__PURE__ */ new Map();
-  pendingReads = /* @__PURE__ */ new Map();
-  readGeneration = 0;
-  portfolioVersions = /* @__PURE__ */ new Map();
-  snapshotFailures = /* @__PURE__ */ new Map();
-  standardReadFailures = /* @__PURE__ */ new Map();
-  reconcileUntil = /* @__PURE__ */ new Map();
-  activityRefreshUntil = /* @__PURE__ */ new Map();
-  // null means a confirmed movement has no reliable baseline. Do not guess
-  // settlement; keep slow reconciliation after the fast window expires.
-  snapshotMovements = /* @__PURE__ */ new Map();
-  movementEpochs = /* @__PURE__ */ new Map();
-  yieldOptions = /* @__PURE__ */ new Map();
-  pendingYieldOptions = /* @__PURE__ */ new Map();
-  constructor(owneyApiKey, options = {}) {
-    this.api = new YieldseekerApiClient(
-      owneyApiKey,
-      options.baseUrl ?? getYieldseekerProxyBaseUrl(),
-      options.fetchFn
-    );
-    this.auth = new YieldseekerAuth(options.auth);
-    this.rpcUrls = options.rpcUrls;
-    this.transactionExecutor = options.transactionExecutor;
-    this.unwindReceiptWaiter = options.unwindReceiptWaiter;
-  }
-  getReceiptClient() {
-    this.receiptClient ??= createPaidRpcClient(base3, this.rpcUrls);
-    return this.receiptClient;
-  }
-  async disconnect() {
-    this.readGeneration += 1;
-    this.auth.clear();
-    for (const key2 of this.users.keys()) {
-      const [walletAddress, chainId] = key2.split(":");
-      clearYieldseekerIdentity(walletAddress, Number(chainId));
-    }
-    this.users.clear();
-    this.agentContexts.clear();
-    this.pendingAgents.clear();
-    this.pendingWalletContexts.clear();
-    this.readCache.clear();
-    this.pendingReads.clear();
-    this.portfolioVersions.clear();
-    this.snapshotFailures.clear();
-    this.standardReadFailures.clear();
-    this.reconcileUntil.clear();
-    this.activityRefreshUntil.clear();
-    this.snapshotMovements.clear();
-    this.movementEpochs.clear();
-  }
-  async activateAgent(state, chainId, asset) {
-    this.assertChain(chainId);
-    const targetAsset = asset ?? "USDC";
-    this.assertAsset(targetAsset);
-    await this.ensureAgent(state, chainId, targetAsset);
-  }
-  async deposit(state, chainId, amount, asset, depositCallback) {
-    this.assertChain(chainId);
-    this.assertAsset(asset);
-    if (BigInt(amount) <= 0n) {
-      throw new OwneyError(
-        "DEPOSIT_AMOUNT_BELOW_MINIMUM",
-        "Yieldseeker deposits must be greater than zero.",
-        { amount, minDepositAmount: "1" },
-        this.id
-      );
-    }
-    const context = await this.ensureAgent(state, chainId, asset);
-    const generation = this.readGeneration;
-    const movement = this.snapshotMovement(state, chainId, context, BigInt(amount));
-    let txHash;
-    if (depositCallback) {
-      provideDepositVerificationContext(depositCallback, {
-        agentId: "yieldseeker",
-        signature: await this.auth.getToken(state, chainId),
-        userId: context.user.userId,
-        yieldseekerAgentId: context.agent.agentId
-      });
-      txHash = await depositCallback(
-        context.wallet.walletAddress,
-        chainId,
-        amount
-      );
-      await this.waitForReceipt(state, chainId, txHash);
-    } else {
-      txHash = await this.submitTransaction(state, chainId, {
-        from: getAddress2(state.walletAddress),
-        to: YIELDSEEKER_ASSET_METADATA[asset].address,
-        data: encodeFunctionData({
-          abi: erc20Abi,
-          functionName: "transfer",
-          args: [getAddress2(context.wallet.walletAddress), BigInt(amount)]
-        }),
-        value: "0",
-        chainId
-      });
-    }
-    if (this.readGeneration === generation) {
-      await this.refreshSnapshotAfterMovement(state, chainId, context, "deposit", movement);
-    }
-    return {
-      txHash,
-      smartWallet: context.wallet.walletAddress,
-      amount
-    };
-  }
-  async withdraw(state, chainId, asset, amount) {
-    this.assertChain(chainId);
-    this.assertAsset(asset);
-    if (amount !== void 0 && BigInt(amount) <= 0n) {
-      throw new OwneyError(
-        "WITHDRAW_FAILED",
-        "Yieldseeker withdrawals must be greater than zero.",
-        { amount },
-        this.id
-      );
-    }
-    const context = await this.findAgent(state, chainId, asset);
-    if (!context) {
-      throw new OwneyError(
-        "WITHDRAW_INSUFFICIENT_BALANCE",
-        `No Yieldseeker ${asset} agent exists for this wallet.`,
-        { asset, available: "0" },
-        this.id
-      );
-    }
-    const generation = this.readGeneration;
-    let confirmedMovement = false;
-    let settlement = null;
-    try {
-      const portfolio = await this.loadPortfolioContext(
-        state,
-        chainId,
-        context
-      );
-      const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-      const idleEntry = Object.entries(portfolio.snapshot.tokenBalances).find(
-        ([address]) => address.toLowerCase() === metadata.address.toLowerCase()
-      );
-      const idle = BigInt(idleEntry?.[1] ?? "0");
-      const deployed = portfolio.positions.reduce(
-        (total, position2) => total + BigInt(position2.withdrawableAssetsRaw),
-        0n
-      );
-      const totalAvailable = idle + deployed;
-      const requested = amount === void 0 ? totalAvailable : BigInt(amount);
-      const plannedMovement = this.snapshotMovement(state, chainId, context, -requested);
-      if (requested > totalAvailable) {
-        throw new OwneyError(
-          "WITHDRAW_INSUFFICIENT_BALANCE",
-          `Requested withdrawal "${requested}" exceeds available Yieldseeker balance "${totalAvailable}" for asset "${asset}".`,
-          {
-            asset,
-            requested: requested.toString(),
-            available: totalAvailable.toString()
-          },
-          this.id
-        );
-      }
-      let remaining = requested > idle ? requested - idle : 0n;
-      for (const position2 of portfolio.positions) {
-        if (remaining === 0n) break;
-        const available = BigInt(position2.withdrawableAssetsRaw);
-        if (available <= 0n) continue;
-        const assetsRaw = available < remaining ? available : remaining;
-        const response = await this.walletRequest(
-          state,
-          chainId,
-          this.agentPath(context, "withdraw-from-position"),
-          {
-            method: "POST",
-            body: {
-              chainId,
-              vaultAddress: position2.yieldOption.address,
-              assetsRaw: assetsRaw.toString()
-            }
-          }
-        );
-        if (!this.isTransactionHash(response?.transactionHash)) {
-          throw this.invalidResponse("position withdrawal");
-        }
-        await this.waitForReceipt(state, chainId, response.transactionHash);
-        confirmedMovement = true;
-        remaining -= assetsRaw;
-      }
-      if (remaining > 0n) {
-        throw this.invalidResponse("yield positions", {
-          reason: "Withdrawable positions could not cover the request.",
-          remaining: remaining.toString()
-        });
-      }
-      const account = getAddress2(state.walletAddress);
-      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
-      });
-      confirmedMovement = true;
-      settlement = plannedMovement;
-      return {
-        txHash,
-        type: amount === void 0 ? "full" : "partial",
-        amount: requested.toString()
-      };
-    } finally {
-      if (confirmedMovement && this.readGeneration === generation) {
-        await this.refreshSnapshotAfterMovement(
-          state,
-          chainId,
-          context,
-          "withdrawal",
-          settlement
-        );
-      }
-    }
-  }
-  async getBalances(state, chainId) {
-    this.assertChain(chainId);
-    return mapYieldseekerBalances(await this.loadPortfolio(state, chainId, {}));
-  }
-  async getEarnings(state, chainId) {
-    this.assertChain(chainId);
-    return mapYieldseekerEarnings(await this.loadPortfolio(state, chainId, {}));
-  }
-  async getAccountApy(state, chainId, days, tokenSymbol) {
-    this.assertChain(chainId);
-    const asset = tokenSymbol?.toUpperCase();
-    if (asset !== void 0) this.assertAsset(asset);
-    const contexts = await this.loadPortfolio(state, chainId, {
-      ...asset ? { asset } : {},
-      historic: true
-    });
-    return mapYieldseekerApy(state.walletAddress, contexts, days);
-  }
-  async getHistory(state, chainId, options) {
-    this.assertChain(chainId);
-    const asset = options?.tokenSymbol?.toUpperCase();
-    if (asset !== void 0) this.assertAsset(asset);
-    const contexts = await this.loadPortfolio(state, chainId, {
-      ...asset ? { asset } : {},
-      historic: true,
-      actions: true
-    });
-    const catalog = await Promise.all(
-      [...new Set(contexts.map((context) => context.asset))].map(
-        (contextAsset) => this.loadYieldOptions(contextAsset)
-      )
-    );
-    const vaultAddresses = new Set(
-      catalog.flat().filter(
-        (yieldOption) => yieldOption.chainId === chainId && isAddress2(yieldOption.address)
-      ).map((yieldOption) => yieldOption.address.toLowerCase())
-    );
-    return mapYieldseekerHistory(contexts, {
-      limit: options?.limit ?? 10,
-      ownerAddress: state.walletAddress,
-      vaultAddresses,
-      ...options?.fromDate ? { fromDate: options.fromDate } : {},
-      ...options?.toDate ? { toDate: options.toDate } : {}
-    });
-  }
-  async getUserProfile(state, chainId) {
-    this.assertChain(chainId);
-    return mapYieldseekerProfile(
-      state.walletAddress,
-      await this.loadPortfolio(state, chainId, {})
-    );
-  }
-  async getAgentApy(days, options) {
-    this.assertOptionalChain(options?.chainId);
-    const requested = options?.tokenSymbol?.toUpperCase();
-    if (requested !== void 0) this.assertAsset(requested);
-    const assets = requested ? [requested] : ["USDC", "WETH"];
-    const values = await Promise.all(
-      assets.map(async (asset) => {
-        return { asset, yieldOptions: await this.loadYieldOptions(asset) };
-      })
-    );
-    return mapYieldseekerAgentApy(values, days);
-  }
-  async loadYieldOptions(asset) {
-    const cached = this.yieldOptions.get(asset);
-    if (cached && cached.expiresAt > Date.now()) return cached.value;
-    const pending = this.pendingYieldOptions.get(asset);
-    if (pending) return pending;
-    const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-    const request = this.api.request(
-      `/chains/8453/assets/${metadata.address}/yield-options`
-    ).then((response) => {
-      if (!Array.isArray(response?.yieldOptions)) {
-        throw this.invalidResponse("yield options");
-      }
-      this.yieldOptions.set(asset, {
-        expiresAt: Date.now() + YIELDSEEKER_YIELD_OPTIONS_CACHE_MS,
-        value: response.yieldOptions
-      });
-      return response.yieldOptions;
-    }).finally(() => this.pendingYieldOptions.delete(asset));
-    this.pendingYieldOptions.set(asset, request);
-    return request;
-  }
-  userKey(state, chainId) {
-    return `${state.walletAddress.toLowerCase()}:${chainId}`;
-  }
-  contextKey(state, chainId, asset) {
-    return `${this.userKey(state, chainId)}:${asset}`;
-  }
-  assertSession(generation, chainId, asset) {
-    if (this.readGeneration !== generation) {
-      throw new OwneyError(
-        "NOT_CONNECTED",
-        "Wallet session changed during the Yieldseeker request.",
-        { rpcSource: "agent-api", chainId, ...asset ? { asset } : {} },
-        this.id
-      );
-    }
-  }
-  cachedRead(key2, ttlMs, read2) {
-    const cached = this.readCache.get(key2);
-    if (cached && cached.expiresAt > Date.now()) {
-      return Promise.resolve(cached.value);
-    }
-    const pending = this.pendingReads.get(key2);
-    if (pending) return pending;
-    const generation = this.readGeneration;
-    const request = Promise.resolve().then(read2).then((value) => {
-      if (this.readGeneration === generation && this.pendingReads.get(key2) === request) {
-        this.readCache.set(key2, {
-          expiresAt: Date.now() + ttlMs,
-          value
-        });
-      }
-      return value;
-    }).finally(() => {
-      if (this.pendingReads.get(key2) === request) {
-        this.pendingReads.delete(key2);
-      }
-    });
-    this.pendingReads.set(key2, request);
-    return request;
-  }
-  agentListKey(state, chainId) {
-    return `agents:${this.userKey(state, chainId)}`;
-  }
-  async listAgents(state, chainId, user) {
-    const response = await this.cachedRead(
-      this.agentListKey(state, chainId),
-      YIELDSEEKER_AGENT_LIST_CACHE_MS,
-      async () => {
-        const response2 = await this.walletRequest(
-          state,
-          chainId,
-          `/users/${user.userId}/agents`
-        );
-        if (!Array.isArray(response2?.agents)) {
-          throw this.invalidResponse("agent list");
-        }
-        return response2;
-      }
-    );
-    return response.agents;
-  }
-  async contextForAgent(state, chainId, user, agent, asset) {
-    const key2 = this.contextKey(state, chainId, asset);
-    const cached = this.agentContexts.get(key2);
-    if (cached?.agent.agentId === agent.agentId) return cached;
-    const pending = this.pendingWalletContexts.get(key2);
-    if (pending) return pending;
-    const generation = this.readGeneration;
-    const request = this.walletRequest(
-      state,
-      chainId,
-      `/users/${user.userId}/agents/${agent.agentId}/wallet`
-    ).then((walletResponse) => {
-      this.assertSession(generation, chainId, asset);
-      if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
-        throw this.invalidResponse("agent wallet");
-      }
-      const context = {
-        user,
-        agent,
-        wallet: walletResponse.agentWallet,
-        asset
-      };
-      this.agentContexts.set(key2, context);
-      return context;
-    });
-    this.pendingWalletContexts.set(key2, request);
-    try {
-      return await request;
-    } finally {
-      if (this.pendingWalletContexts.get(key2) === request) {
-        this.pendingWalletContexts.delete(key2);
-      }
-    }
-  }
-  async resolveUser(state, chainId) {
-    const key2 = this.userKey(state, chainId);
-    const inMemory = this.users.get(key2);
-    if (inMemory) return inMemory;
-    const persisted = readYieldseekerIdentity(state.walletAddress, chainId);
-    if (persisted) {
-      this.users.set(key2, persisted);
-      return persisted;
-    }
-    const walletAddress = getAddress2(state.walletAddress);
-    const generation = this.readGeneration;
-    let user = null;
-    try {
-      const login = await this.providerRequest(
-        state,
-        chainId,
-        "/users/login-with-wallet",
-        { method: "POST", body: { walletAddress } }
-      );
-      user = login?.user ?? null;
-      if (!user) {
-        throw this.invalidResponse("wallet login", {
-          reason: "A successful login returned no user."
-        });
-      }
-    } catch (error) {
-      if (!(error instanceof YieldseekerApiError) || error.providerCode !== "NO_USER") {
-        if (error instanceof OwneyError) throw error;
-        throw this.mapApiError(error);
-      }
-      let created;
-      for (let attempt = 0; attempt < YIELDSEEKER_USERNAME_CREATE_ATTEMPTS; attempt += 1) {
-        try {
-          created = await this.providerRequest(
-            state,
-            chainId,
-            "/users",
-            {
-              method: "POST",
-              body: {
-                walletAddress,
-                username: generateYieldseekerUsername()
-              }
-            }
-          );
-          break;
-        } catch (createError) {
-          const canRetry = isUsernameConflict(createError) && attempt + 1 < YIELDSEEKER_USERNAME_CREATE_ATTEMPTS;
-          if (canRetry) continue;
-          throw this.mapApiError(createError);
-        }
-      }
-      user = created?.user ?? null;
-    }
-    if (!user || !/^[a-zA-Z0-9_-]{1,128}$/.test(user.userId)) {
-      throw this.invalidResponse("wallet identity");
-    }
-    this.assertSession(generation, chainId);
-    const resolved = { userId: user.userId };
-    this.users.set(key2, resolved);
-    writeYieldseekerIdentity(state.walletAddress, chainId, resolved.userId);
-    return resolved;
-  }
-  forgetUser(state, chainId) {
-    this.users.delete(this.userKey(state, chainId));
-    clearYieldseekerIdentity(state.walletAddress, chainId);
-  }
-  async ensureAgent(state, chainId, asset) {
-    const key2 = this.contextKey(state, chainId, asset);
-    const cached = this.agentContexts.get(key2);
-    if (cached) return cached;
-    const pending = this.pendingAgents.get(key2);
-    if (pending) return pending;
-    const generation = this.readGeneration;
-    const request = this.resolveAgent(state, chainId, asset, true).then(
-      async (context) => {
-        this.assertSession(generation, chainId, asset);
-        if (!context) throw this.invalidResponse("agent creation");
-        await this.deployAgent(state, chainId, context);
-        this.assertSession(generation, chainId, asset);
-        this.agentContexts.set(key2, context);
-        return context;
-      }
-    );
-    this.pendingAgents.set(key2, request);
-    try {
-      return await request;
-    } finally {
-      if (this.pendingAgents.get(key2) === request) this.pendingAgents.delete(key2);
-    }
-  }
-  async findAgent(state, chainId, asset) {
-    const key2 = this.contextKey(state, chainId, asset);
-    const cached = this.agentContexts.get(key2);
-    if (cached) return cached;
-    const generation = this.readGeneration;
-    const context = await this.resolveAgent(state, chainId, asset, false);
-    this.assertSession(generation, chainId, asset);
-    if (context) this.agentContexts.set(key2, context);
-    return context;
-  }
-  async resolveAgent(state, chainId, asset, createIfMissing) {
-    const generation = this.readGeneration;
-    const user = await this.resolveUser(state, chainId);
-    this.assertSession(generation, chainId, asset);
-    const agents = await this.listAgents(state, chainId, user);
-    this.assertSession(generation, chainId, asset);
-    const metadata = YIELDSEEKER_ASSET_METADATA[asset];
-    let agent = agents.find(
-      (candidate) => this.isOwneyAgent(candidate) && candidate.chainId === chainId && candidate.type === "vault" && candidate.assetAddress.toLowerCase() === metadata.address.toLowerCase()
-    );
-    if (!agent && createIfMissing) {
-      const created = await this.walletRequest(
-        state,
-        chainId,
-        `/users/${user.userId}/agents`,
-        {
-          method: "POST",
-          body: {
-            name: OWNEY_AGENT_NAME,
-            emoji: "\u{1F989}",
-            chainId,
-            assetAddress: metadata.address,
-            type: "vault",
-            rulePreset: null
-          }
-        }
-      );
-      this.assertSession(generation, chainId, asset);
-      agent = created?.agent;
-      if (agent) {
-        this.readCache.set(this.agentListKey(state, chainId), {
-          expiresAt: Date.now() + YIELDSEEKER_AGENT_LIST_CACHE_MS,
-          value: {
-            agents: [...agents, agent]
-          }
-        });
-      }
-    }
-    if (!agent) return null;
-    this.assertAgent(agent);
-    return this.contextForAgent(state, chainId, user, agent, asset);
-  }
-  async loadPortfolio(state, chainId, options) {
-    const generation = this.readGeneration;
-    const user = await this.resolveUser(state, chainId);
-    this.assertSession(generation, chainId);
-    const agents = await this.listAgents(state, chainId, user);
-    this.assertSession(generation, chainId);
-    const contexts = [];
-    for (const agent of agents) {
-      const asset = this.assetForAgent(agent);
-      if (!this.isOwneyAgent(agent) || !asset || agent.chainId !== chainId || agent.type !== "vault" || options.asset && options.asset !== asset) {
-        continue;
-      }
-      this.assertAgent(agent);
-      contexts.push(this.contextForAgent(state, chainId, user, agent, asset));
-    }
-    const resolvedContexts = await Promise.all(contexts);
-    this.assertSession(generation, chainId);
-    return Promise.all(
-      resolvedContexts.map(
-        (context) => this.loadPortfolioContext(state, chainId, context, options)
-      )
-    );
-  }
-  portfolioVersion(contextKey) {
-    return this.portfolioVersions.get(contextKey) ?? 0;
-  }
-  portfolioCacheMs(contextKey) {
-    return (this.reconcileUntil.get(contextKey) ?? 0) > Date.now() ? YIELDSEEKER_SETTLEMENT_CACHE_MS : YIELDSEEKER_PORTFOLIO_CACHE_MS;
-  }
-  snapshotMovement(state, chainId, context, delta) {
-    const key2 = this.contextKey(state, chainId, context.asset);
-    const previous = this.snapshotMovements.get(key2);
-    if (this.snapshotMovements.has(key2)) {
-      if (!previous || previous.delta > 0n !== delta > 0n) return null;
-      return {
-        ...previous,
-        epoch: this.movementEpochs.get(key2) ?? 0,
-        delta: previous.delta + delta,
-        expectedBalance: previous.expectedBalance + delta,
-        expectedNetDeposits: previous.expectedNetDeposits + delta
-      };
-    }
-    const cached = this.readCache.get(`snapshot:${key2}`);
-    if (!cached || cached.expiresAt <= Date.now()) return null;
-    const snapshot = cached.value.agentSnapshot;
-    if (snapshot.baseAssetDecimals !== YIELDSEEKER_ASSET_METADATA[context.asset].decimals) return null;
-    if (!/^-?\d+$/.test(snapshot.netDepositsBase) || !/^\d+$/.test(snapshot.totalValueBase)) return null;
-    return {
-      epoch: this.movementEpochs.get(key2) ?? 0,
-      delta,
-      decimals: snapshot.baseAssetDecimals,
-      expectedBalance: BigInt(snapshot.totalValueBase) + delta,
-      expectedNetDeposits: BigInt(snapshot.netDepositsBase) + delta
-    };
-  }
-  advancePortfolioVersion(contextKey) {
-    const version = this.portfolioVersion(contextKey) + 1;
-    this.portfolioVersions.set(contextKey, version);
-    this.snapshotFailures.delete(contextKey);
-    for (const kind of ["snapshot", "positions", "historic", "actions"]) {
-      const key2 = `${kind}:${contextKey}`;
-      this.readCache.delete(key2);
-      this.pendingReads.delete(key2);
-    }
-    return version;
-  }
-  requestPortfolioSnapshot(state, chainId, context, contextKey, version, generation, forceRefresh = false) {
-    return this.walletRequest(
-      state,
-      chainId,
-      `${this.agentPath(context, "snapshot")}${query(forceRefresh ? { shouldForceRefresh: true } : { shouldOnlyUseRecentValue: true, shouldAllowStaleOnError: true })}`
-    ).then((response) => {
-      if (!response?.agentSnapshot) {
-        throw this.invalidResponse("agent snapshot");
-      }
-      if (this.readGeneration === generation && this.portfolioVersion(contextKey) === version) {
-        this.snapshotFailures.delete(contextKey);
-        const movement = this.snapshotMovements.get(contextKey);
-        const snapshot = response.agentSnapshot;
-        if (movement && snapshot.baseAssetDecimals === movement.decimals && /^-?\d+$/.test(snapshot.netDepositsBase) && /^\d+$/.test(snapshot.totalValueBase)) {
-          const balance = BigInt(snapshot.totalValueBase);
-          const netDeposits = BigInt(snapshot.netDepositsBase);
-          const reconciled = movement.delta > 0n ? balance >= movement.expectedBalance && netDeposits >= movement.expectedNetDeposits : balance <= movement.expectedBalance && netDeposits <= movement.expectedNetDeposits;
-          if (reconciled) {
-            this.snapshotMovements.delete(contextKey);
-            this.reconcileUntil.delete(contextKey);
-          }
-        }
-      }
-      return response;
-    }).catch((error) => {
-      if (this.readGeneration === generation && this.portfolioVersion(contextKey) === version) {
-        this.snapshotFailures.set(contextKey, {
-          retryAt: Date.now() + Math.max(YIELDSEEKER_READ_FAILURE_COOLDOWN_MS, rateLimitDelay(error) ?? 0),
-          error
-        });
-      }
-      throw error;
-    });
-  }
-  portfolioSnapshot(state, chainId, context, contextKey) {
-    const key2 = `snapshot:${contextKey}`;
-    const cached = this.readCache.get(key2);
-    if ((!cached || cached.expiresAt <= Date.now()) && !this.pendingReads.has(key2)) {
-      const failure = this.snapshotFailures.get(contextKey);
-      if (failure && failure.retryAt > Date.now()) throw failure.error;
-      this.advancePortfolioVersion(contextKey);
-    }
-    const version = this.portfolioVersion(contextKey);
-    const generation = this.readGeneration;
-    return {
-      version,
-      read: this.cachedRead(key2, this.portfolioCacheMs(contextKey), () => (
-        // Force only during the bounded post-transaction window. Keep unknown
-        // or unreconciled movements for verification, but do not let them turn
-        // routine polling into forced refreshes indefinitely.
-        this.requestPortfolioSnapshot(
-          state,
-          chainId,
-          context,
-          contextKey,
-          version,
-          generation,
-          this.snapshotMovements.has(contextKey) && (this.reconcileUntil.get(contextKey) ?? 0) > Date.now()
-        )
-      ))
-    };
-  }
-  async loadPortfolioContext(state, chainId, context, options = {}) {
-    const contextKey = this.contextKey(state, chainId, context.asset);
-    const generation = this.readGeneration;
-    const assertSession = () => this.assertSession(generation, chainId, context.asset);
-    for (let attempt = 0; attempt < 2; attempt++) {
-      const { version, read: read2 } = this.portfolioSnapshot(state, chainId, context, contextKey);
-      try {
-        const snapshot = await read2;
-        assertSession();
-        if (this.portfolioVersion(contextKey) !== version) continue;
-        const [positions, historic, actions] = await Promise.all([
-          this.cachedRead(
-            `positions:${contextKey}`,
-            this.portfolioCacheMs(contextKey),
-            async () => {
-              const response = await this.walletRequest(
-                state,
-                chainId,
-                this.agentPath(context, "yield-positions")
-              );
-              if (!Array.isArray(response?.yieldPositions)) {
-                throw this.invalidResponse("yield positions");
-              }
-              return response;
-            }
-          ),
-          options.historic ? this.cachedRead(
-            `historic:${contextKey}`,
-            (this.activityRefreshUntil.get(contextKey) ?? 0) > Date.now() ? YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS : YIELDSEEKER_ACTIVITY_CACHE_MS,
-            () => this.walletRequest(
-              state,
-              chainId,
-              this.agentPath(context, "wallet/historic-position")
-            )
-          ) : Promise.resolve(void 0),
-          options.actions ? this.cachedRead(
-            `actions:${contextKey}`,
-            (this.activityRefreshUntil.get(contextKey) ?? 0) > Date.now() ? YIELDSEEKER_SETTLEMENT_ACTIVITY_CACHE_MS : YIELDSEEKER_ACTIVITY_CACHE_MS,
-            () => this.walletRequest(
-              state,
-              chainId,
-              this.agentPath(context, "actions")
-            )
-          ) : Promise.resolve(void 0)
-        ]);
-        assertSession();
-        if (this.portfolioVersion(contextKey) !== version) continue;
-        if (!Array.isArray(positions?.yieldPositions)) {
-          throw this.invalidResponse("yield positions");
-        }
-        return {
-          ...context,
-          snapshot: snapshot.agentSnapshot,
-          positions: positions.yieldPositions,
-          ...historic?.position ? { historic: historic.position } : {},
-          ...actions?.actions ? { actions: actions.actions } : {}
-        };
-      } catch (error) {
-        assertSession();
-        if (this.portfolioVersion(contextKey) !== version) continue;
-        throw error;
-      }
-    }
-    throw new OwneyError(
-      "AGENT_API_ERROR",
-      "Yieldseeker portfolio changed during the read. Please retry.",
-      { rpcSource: "agent-api", chainId, asset: context.asset },
-      this.id
-    );
-  }
-  async deployAgent(state, chainId, context) {
-    if (context.wallet.initializedDate != null) return;
-    const walletAddress = context.wallet.walletAddress.toLowerCase();
-    const deployed = await this.walletRequest(
-      state,
-      chainId,
-      this.agentPath(context, "deploy"),
-      { method: "POST", body: {} }
-    );
-    if (!deployed?.agentWallet || !isAddress2(deployed.agentWallet.walletAddress) || deployed.agentWallet.walletAddress.toLowerCase() !== walletAddress) {
-      throw this.invalidResponse("agent deployment", {
-        reason: "Deploy did not return the expected Agent Wallet."
-      });
-    }
-    context.wallet = deployed.agentWallet;
-  }
-  async refreshSnapshotAfterMovement(state, chainId, context, movement, settlement) {
-    const contextKey = this.contextKey(state, chainId, context.asset);
-    this.reconcileUntil.set(contextKey, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
-    this.activityRefreshUntil.set(contextKey, Date.now() + YIELDSEEKER_SETTLEMENT_WINDOW_MS);
-    const epoch = this.movementEpochs.get(contextKey) ?? 0;
-    this.snapshotMovements.set(contextKey, settlement?.epoch === epoch ? settlement : null);
-    this.movementEpochs.set(contextKey, epoch + 1);
-    const version = this.advancePortfolioVersion(contextKey);
-    const generation = this.readGeneration;
-    try {
-      await this.cachedRead(
-        `snapshot:${contextKey}`,
-        YIELDSEEKER_SETTLEMENT_CACHE_MS,
-        () => this.requestPortfolioSnapshot(state, chainId, context, contextKey, version, generation, true)
-      );
-    } catch (error) {
-      console.warn(
-        `[owney-sdk] Yieldseeker ${movement} snapshot refresh failed:`,
-        error
-      );
-    }
-  }
-  agentPath(context, suffix) {
-    return `/users/${context.user.userId}/agents/${context.agent.agentId}/${suffix}`;
-  }
-  async walletRequest(state, chainId, path, options = {}) {
-    const read2 = (options.method ?? "GET") === "GET";
-    const userKey = this.userKey(state, chainId);
-    if (read2) {
-      const failure = this.standardReadFailures.get(userKey);
-      if (failure && failure.retryAt > Date.now()) throw failure.error;
-      if (failure) this.standardReadFailures.delete(userKey);
-    }
-    const generation = this.readGeneration;
-    try {
-      return await this.providerRequest(state, chainId, path, options);
-    } catch (error) {
-      const mapped = this.mapApiError(error);
-      const delay = read2 ? rateLimitDelay(mapped) : void 0;
-      if (delay !== void 0 && this.readGeneration === generation) {
-        this.standardReadFailures.set(userKey, {
-          retryAt: Date.now() + Math.max(YIELDSEEKER_READ_FAILURE_COOLDOWN_MS, delay),
-          error: mapped
-        });
-      }
-      throw mapped;
-    }
-  }
-  async providerRequest(state, chainId, path, options = {}) {
-    this.assertChain(chainId);
-    const request = (signature2) => this.api.request(path, {
-      ...options,
-      signature: signature2
-    });
-    let signature = await this.auth.getToken(state, chainId);
-    try {
-      return await request(signature);
-    } catch (error) {
-      if (!(error instanceof YieldseekerApiError)) throw error;
-      if (error.providerCode === "NO_USER") throw error;
-      if (!error.isAuthenticationError) throw error;
-      signature = await this.auth.refreshToken(state, chainId, signature);
-      try {
-        return await request(signature);
-      } catch (retryError) {
-        if (retryError instanceof YieldseekerApiError && retryError.isAuthenticationError) {
-          this.forgetUser(state, chainId);
-        }
-        throw retryError;
-      }
-    }
-  }
-  mapApiError(error) {
-    if (!(error instanceof YieldseekerApiError)) {
-      return new OwneyError(
-        "AGENT_API_ERROR",
-        "Yieldseeker request failed.",
-        { cause: error instanceof Error ? error.message : String(error) },
-        this.id
-      );
-    }
-    const code = error.isAuthenticationError ? "AGENT_AUTH_FAILED" : error.providerCode === "REQUEST_TIMEOUT" ? "AGENT_TIMEOUT" : "AGENT_API_ERROR";
-    return new OwneyError(
-      code,
-      `Yieldseeker request failed: ${error.providerCode}.`,
-      {
-        rpcSource: "agent-api",
-        statusCode: error.status,
-        providerCode: error.providerCode,
-        ...error.responseFields ? { fields: error.responseFields } : {}
-      },
-      this.id
-    );
-  }
-  async submitTransaction(state, chainId, transaction) {
-    if (this.transactionExecutor) {
-      return this.transactionExecutor(state, chainId, transaction);
-    }
-    this.assertTransaction(transaction, state, chainId);
-    const account = getAddress2(state.walletAddress);
-    const walletClient = createWalletClient2({
-      account,
-      chain: base3,
-      transport: custom2(state.provider)
-    });
-    const walletChainClient = createPublicClient3({
-      chain: base3,
-      transport: custom2(state.provider)
-    });
-    await ensureWalletOnChain(
-      walletChainClient,
-      walletClient,
-      8453
-    );
-    const hash = await walletClient.sendTransaction({
-      account,
-      chain: base3,
-      to: getAddress2(transaction.to),
-      data: transaction.data,
-      value: BigInt(transaction.value)
-    });
-    const receipt = await withPaidRpcDiagnostics(
-      () => this.getReceiptClient().waitForTransactionReceipt({
-        hash,
-        confirmations: 1
-      }),
-      8453,
-      "eth_getTransactionReceipt",
-      this.id
-    );
-    if (receipt.status !== "success") {
-      throw new OwneyError(
-        "AGENT_TRANSACTION_REVERTED",
-        `Yieldseeker transaction reverted (${hash}).`,
-        { transactionHash: hash },
-        this.id
-      );
-    }
-    return hash;
-  }
-  async waitForReceipt(state, chainId, transactionHash) {
-    if (this.unwindReceiptWaiter) {
-      await this.unwindReceiptWaiter(state, chainId, transactionHash);
-      return;
-    }
-    const receipt = await withPaidRpcDiagnostics(
-      () => this.getReceiptClient().waitForTransactionReceipt({
-        hash: transactionHash,
-        confirmations: 1
-      }),
-      8453,
-      "eth_getTransactionReceipt",
-      this.id
-    );
-    if (receipt.status !== "success") {
-      throw new OwneyError(
-        "AGENT_TRANSACTION_REVERTED",
-        `Yieldseeker transaction reverted (${transactionHash}).`,
-        { transactionHash },
-        this.id
-      );
-    }
-  }
-  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)) {
-      throw this.invalidResponse("transaction");
-    }
-  }
-  assertAgent(agent) {
-    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !isAddress2(agent.assetAddress) || agent.chainId !== 8453) {
-      throw this.invalidResponse("agent");
-    }
-  }
-  isOwneyAgent(agent) {
-    return typeof agent.name === "string" && agent.name.trim().toLowerCase() === OWNEY_AGENT_NAME;
-  }
-  assetForAgent(agent) {
-    for (const asset of ["USDC", "WETH"]) {
-      if (agent.assetAddress.toLowerCase() === YIELDSEEKER_ASSET_METADATA[asset].address.toLowerCase()) {
-        return asset;
-      }
-    }
-    return null;
-  }
-  isTransactionHash(value) {
-    return typeof value === "string" && /^0x[a-fA-F0-9]{64}$/.test(value);
-  }
-  assertChain(chainId) {
-    if (chainId !== 8453) {
-      throw new OwneyError(
-        "CHAIN_UNSUPPORTED",
-        `Yieldseeker does not support chain ${chainId}.`,
-        { chainId, supportedChainIds: [8453] },
-        this.id
-      );
-    }
-  }
-  assertOptionalChain(chainId) {
-    if (chainId !== void 0) this.assertChain(chainId);
-  }
-  assertAsset(asset) {
-    if (asset !== "USDC" && asset !== "WETH") {
-      throw new OwneyError(
-        "ASSET_UNSUPPORTED",
-        `Yieldseeker does not support asset ${asset} in the Owney rollout.`,
-        {
-          asset,
-          supportedAssets: ["USDC", "WETH"],
-          providerAlsoAdvertises: ["cbBTC"]
-        },
-        this.id
-      );
-    }
-  }
-  invalidResponse(operation, details = {}) {
-    return new OwneyError(
-      "AGENT_INVALID_RESPONSE",
-      `Yieldseeker returned an invalid ${operation} response.`,
-      details,
-      this.id
-    );
-  }
-};
-
-// src/lib/routing-api.ts
-var ROUTING_API_BASE_URL2 = "https://owney-routing-api-243946518160.europe-west4.run.app";
-async function fetchOrgAgentConfig(apiKey, baseUrl = ROUTING_API_BASE_URL2) {
-  const url = `${baseUrl}/api/v1/agent/org-config`;
-  try {
-    const res = await fetch(url, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        "x-owney-api-key": `${apiKey}`
-      }
-    });
-    if (!res.ok) {
-      if (res.status !== 404) {
-        console.warn(
-          `[owney-sdk] Could not read org agent config (${res.status}); leaving user profiles unchanged.`
-        );
-      }
-      return null;
-    }
-    const json = await res.json();
-    const policy = json.success ? json.data ?? null : null;
-    debugLog(
-      "owney-sdk",
-      policy ? "org agent config: loaded" : "org agent config: none set by this partner \u2014 user profiles will be left as they are",
-      policy ?? void 0
-    );
-    return policy;
-  } catch (error) {
-    console.warn(
-      "[owney-sdk] Could not read org agent config (non-fatal):",
-      error instanceof Error ? error.message : String(error)
-    );
-    return null;
-  }
-}
-async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL2) {
-  const url = `${baseUrl}/api/v1/agent/keys`;
-  const res = await fetch(url, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-      "x-owney-api-key": `${apiKey}`
-    }
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new OwneyError(
-      "API_ROUTING_ERROR",
-      `Routing API error ${res.status}: ${text}`,
-      { statusCode: res.status, responseBody: text }
-    );
-  }
-  const json = await res.json();
-  if (!json.success) {
-    throw new OwneyError(
-      "API_ROUTING_FAILED",
-      `Routing API request failed: ${json.message}`,
-      { message: json.message }
-    );
-  }
-  return json.data;
-}
-
-// src/lib/health-report.ts
-var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
-async function reportAgentFailure(apiKey, agentType, errorCode, baseUrl = ROUTING_API_BASE_URL3) {
-  try {
-    await fetch(`${baseUrl}/api/v1/agent/health-report`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-owney-api-key": apiKey
-      },
-      body: JSON.stringify({
-        agent_type: agentType,
-        error_code: errorCode,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })
-    });
-  } catch (err) {
-    console.warn(
-      `[owney-sdk] health-report failed for agent "${agentType}":`,
-      err instanceof Error ? err.message : err
-    );
-  }
-}
-async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
-  try {
-    return await fn();
-  } catch (err) {
-    const errorCode = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
-    void reportAgentFailure(apiKey, agentType, errorCode, baseUrl);
-    throw err;
+    return await fn();
+  } catch (err) {
+    const errorCode = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
+    void reportAgentFailure(apiKey, agentType, errorCode, baseUrl);
+    throw err;
   }
 }
 
@@ -4523,29 +2207,8 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
     const tokenBalance = agentBalance?.tokens.find(
       (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
-    let balance = tokenBalance ? parseUnits(tokenBalance.amount, decimals) : 0n;
-    if (agent.balanceComposition === "tokens-plus-positions") {
-      const chainNameById = {
-        1: "ETHEREUM",
-        8453: "BASE",
-        42161: "ARBITRUM"
-      };
-      const targetChain = chainNameById[chainId];
-      for (const position2 of agentBalance?.positions ?? []) {
-        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) : parseUnits(position2.amount, decimals);
-      }
-    }
-    const assetTotal = agentBalance?.assetBalances?.find(
-      (t) => t.chainId === chainId && t.asset.toUpperCase() === target
-    );
-    if (assetTotal) {
-      const total = parseUnits(assetTotal.amount, decimals);
-      if (total < balance) balance = total > 0n ? total : 0n;
-    }
-    return { agent, balance };
+    if (!tokenBalance) return { agent, balance: 0n };
+    return { agent, balance: parseUnits(tokenBalance.amount, decimals) };
   });
 }
 function planProportionalShares(balances, requested, totalAvailable) {
@@ -4571,9 +2234,7 @@ function planProportionalShares(balances, requested, totalAvailable) {
   return plans;
 }
 function planDisabledDrain(disabled, requested) {
-  const sorted = [...disabled].filter((d) => d.balance > 0n).sort(
-    (a, b) => b.balance > a.balance ? 1 : b.balance < a.balance ? -1 : 0
-  );
+  const sorted = [...disabled].filter((d) => d.balance > 0n).sort((a, b) => b.balance > a.balance ? 1 : b.balance < a.balance ? -1 : 0);
   const plans = [];
   let remaining = requested;
   for (const { agent, balance } of sorted) {
@@ -4624,13 +2285,6 @@ function balanceForApyScope(balance, chainId, tokenSymbol) {
     return Number.isFinite(total) && total > 0 ? total : 0;
   }
   const normalizedToken = tokenSymbol.toUpperCase();
-  const snapshots = balance.assetBalances?.filter(
-    (token) => Number(token.chainId) === chainId && String(token.asset).toUpperCase() === normalizedToken
-  );
-  if (snapshots?.length) {
-    const amount = snapshots.reduce((sum, token) => sum + Number(token.amount), 0);
-    if (Number.isFinite(amount)) return Math.max(0, amount);
-  }
   return balance.tokens.reduce((total, token) => {
     if (Number(token.chainId) !== chainId || String(token.asset).toUpperCase() !== normalizedToken) {
       return total;
@@ -4702,386 +2356,441 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 
 // src/client.ts
 import {
-  createPublicClient as createPublicClient4,
-  createWalletClient as createWalletClient3,
-  custom as custom3
-} from "viem";
-import { base as base4, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
-
-// src/lib/sponsored-token-batch.ts
-import {
-  isAddressEqual,
-  keccak256,
-  toBytes
+  createPublicClient as createPublicClient2,
+  createWalletClient,
+  custom
 } from "viem";
+import { base as base2, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
 
-// src/lib/permit2-batch.ts
-import { parseAbi as parseAbi2, hashStruct } from "viem";
-var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
-var ERC2612_PERMIT_TYPES = {
-  Permit: [
-    { name: "owner", type: "address" },
-    { name: "spender", type: "address" },
-    { name: "value", type: "uint256" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ]
-};
-var ERC2612_READ_ABI = parseAbi2([
-  "function name() view returns (string)",
-  "function version() view returns (string)",
-  "function nonces(address owner) view returns (uint256)"
-]);
-function erc2612TypedData(input) {
+// src/lib/transfer-auth.ts
+import { bytesToHex } from "viem";
+var ERC20_META_ABI = [
+  { type: "function", name: "name", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] },
+  { type: "function", name: "version", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] }
+];
+function buildTransferWithAuthorizationTypedData(input) {
   return {
-    domain: {
-      name: input.permit.tokenName,
-      version: input.permit.tokenVersion,
-      chainId: input.chainId,
-      verifyingContract: input.token
+    domain: { name: input.tokenName, version: input.tokenVersion, chainId: input.chainId, verifyingContract: input.token },
+    types: {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
     },
-    types: ERC2612_PERMIT_TYPES,
-    primaryType: "Permit",
-    message: {
-      owner: input.owner,
-      spender: BATCH_PERMIT2_ADDRESS,
-      value: BigInt(input.permit.value),
-      nonce: BigInt(input.permit.nonce),
-      deadline: BigInt(input.permit.deadline)
-    }
+    primaryType: "TransferWithAuthorization",
+    message: input.message
   };
 }
-var PERMIT_BATCH_TYPES = {
-  PermitBatchWitnessTransferFrom: [
-    { name: "permitted", type: "TokenPermissions[]" },
-    { name: "spender", type: "address" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" },
-    { name: "witness", type: "Deposit" }
-  ],
-  Deposit: [{ name: "recipients", type: "address[]" }],
-  TokenPermissions: [
-    { name: "token", type: "address" },
-    { name: "amount", type: "uint256" }
-  ]
-};
-var PERMIT2_BATCH_ABI = parseAbi2([
-  "struct TokenPermissions { address token; uint256 amount; }",
-  "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
-  "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
-  "function permitWitnessTransferFrom(PermitBatchTransferFrom permit,SignatureTransferDetails[] transferDetails,address owner,bytes32 witness,string witnessTypeString,bytes signature)",
-  "function nonceBitmap(address owner,uint256 wordPos) view returns (uint256)"
-]);
-function batchPermit(b) {
-  return {
-    permitted: b.transfers.map((t) => ({
-      token: b.token,
-      amount: BigInt(t.amount)
-    })),
-    nonce: BigInt(b.nonce),
-    deadline: BigInt(b.deadline)
-  };
+async function readTokenMeta(publicClient, token) {
+  const [tokenName, tokenVersion] = await Promise.all([
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "name" }),
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "version" }).catch(() => "2")
+  ]);
+  return { tokenName, tokenVersion };
+}
+function randomAuthNonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return bytesToHex(bytes);
+}
+
+// src/lib/sponsor-client.ts
+var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function postSponsorTransferAuth(input) {
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  let res;
+  try {
+    res = await fetch(`${base3}/api/v1/sponsor/erc20-transfer-auth`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-owney-api-key": input.apiKey
+      },
+      body: JSON.stringify(input.body)
+    });
+  } catch (networkError) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
+      { cause: String(networkError) }
+    );
+  }
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok || !parsed?.success || !parsed.data) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
+      {
+        statusCode: res.status,
+        responseBody: text.slice(0, 500),
+        // 503 SPONSOR_UNAVAILABLE = relayer out of gas; the tx was rejected
+        // before broadcast, so it is safe to fall back to a user-paid deposit.
+        safeToFallback: res.status === 503
+      }
+    );
+  }
+  return parsed.data;
+}
+async function postSponsorPermit2Transfer(input) {
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  let res;
+  try {
+    res = await fetch(`${base3}/api/v1/sponsor/permit2-transfer`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-owney-api-key": input.apiKey
+      },
+      body: JSON.stringify(input.body)
+    });
+  } catch (networkError) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
+      { cause: String(networkError), safeToFallback: false }
+    );
+  }
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok || !parsed?.success || !parsed.data) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
+      {
+        statusCode: res.status,
+        responseBody: text.slice(0, 500),
+        safeToFallback: res.status >= 400 && res.status < 500 || res.status === 503
+      }
+    );
+  }
+  return parsed.data;
+}
+async function getSponsorRelayerAddress(input) {
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  let res;
+  try {
+    res = await fetch(
+      `${base3}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
+      {
+        headers: { "x-owney-api-key": input.apiKey }
+      }
+    );
+  } catch (networkError) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
+      { cause: String(networkError), safeToFallback: true }
+    );
+  }
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok || !parsed?.success || !parsed.data?.relayer) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
+      {
+        statusCode: res.status,
+        responseBody: text.slice(0, 500),
+        safeToFallback: true
+      }
+    );
+  }
+  return parsed.data.relayer;
 }
-function batchTypedData(b, spender) {
+
+// src/lib/permit2.ts
+import { bytesToHex as bytesToHex2 } from "viem";
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var MAX_UINT256 = 2n ** 256n - 1n;
+var ERC20_ALLOWANCE_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function buildPermitTransferFromTypedData(input) {
   return {
     domain: {
       name: "Permit2",
-      chainId: b.chainId,
-      verifyingContract: BATCH_PERMIT2_ADDRESS
+      chainId: input.chainId,
+      verifyingContract: PERMIT2_ADDRESS
     },
-    types: PERMIT_BATCH_TYPES,
-    primaryType: "PermitBatchWitnessTransferFrom",
-    message: {
-      ...batchPermit(b),
-      spender,
-      witness: { recipients: b.transfers.map((t) => t.to) }
-    }
+    types: {
+      PermitTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ]
+    },
+    primaryType: "PermitTransferFrom",
+    message: input.message
   };
 }
-
-// src/lib/sponsored-token-batch.ts
-var memory = /* @__PURE__ */ new Map();
-var inflight = /* @__PURE__ */ new Map();
-var planOf = (transfers) => JSON.stringify(
-  transfers.map((t) => ({
-    to: t.to.toLowerCase(),
-    amount: BigInt(t.amount).toString()
-  }))
-);
-function read(key2) {
-  return typeof window === "undefined" ? memory.get(key2) : window.localStorage.getItem(key2);
+function randomPermit2Nonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return BigInt(bytesToHex2(bytes));
 }
-function save(key2, body) {
-  const value = JSON.stringify({
-    ...body,
-    transfers: body.transfers.map(({ to, amount }) => ({ to, amount }))
+async function readPermit2Allowance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "allowance",
+    args: [owner, PERMIT2_ADDRESS]
   });
-  if (typeof window === "undefined") memory.set(key2, value);
-  else window.localStorage.setItem(key2, value);
 }
-function clear(key2) {
-  if (typeof window === "undefined") memory.delete(key2);
-  else window.localStorage.removeItem(key2);
+async function readErc20Balance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "balanceOf",
+    args: [owner]
+  });
 }
-function sponsorTokenBatch(i) {
-  const key2 = `owney.token-batch.v1:${keccak256(toBytes(i.apiKey))}:${i.baseUrl ?? "default"}:${i.chainId}:${i.owner.toLowerCase()}:${i.token.toLowerCase()}`;
-  const plan = planOf(i.transfers);
-  const active = inflight.get(key2);
-  if (active) {
-    if (active.plan !== plan)
-      return Promise.reject(
-        new Error(
-          "A token deposit is already in progress. Wait for its result before depositing again."
-        )
-      );
-    return active.promise;
-  }
-  const promise = execute(i, key2, plan).finally(() => inflight.delete(key2));
-  inflight.set(key2, { plan, promise });
-  return promise;
+
+// src/lib/chain-guard.ts
+var CHAIN_NAMES = {
+  1: "Ethereum",
+  8453: "Base",
+  42161: "Arbitrum"
+};
+function chainName(chainId) {
+  return CHAIN_NAMES[chainId] ?? `chain ${chainId}`;
 }
-async function execute(i, key2, plan) {
-  if (!i.transfers.length || i.transfers.length > 16 || i.transfers.some(
-    (t) => BigInt(t.amount) <= 0n || BigInt(t.amount) >= 1n << 256n
-  ) || new Set(i.transfers.map((t) => t.to.toLowerCase())).size !== i.transfers.length)
-    throw new Error("Invalid token deposit shares.");
-  const send = async (initial) => {
-    let body = initial;
-    save(key2, body);
-    try {
-      if (!body.serializedTransaction) {
-        const prepared = await postSponsorBatchTransfer({
-          apiKey: i.apiKey,
-          baseUrl: i.baseUrl,
-          body
-        });
-        if (!prepared.serializedTransaction || keccak256(prepared.serializedTransaction) !== prepared.txHash)
-          throw new Error(
-            "Sponsorship API did not return a valid prepared transaction."
-          );
-        body = {
-          ...body,
-          serializedTransaction: prepared.serializedTransaction
-        };
-        save(key2, body);
-      }
-      const result = await postSponsorBatchTransfer({
-        apiKey: i.apiKey,
-        baseUrl: i.baseUrl,
-        body
-      });
-      if (result.txHash !== keccak256(body.serializedTransaction))
-        throw new Error(
-          "Sponsorship receipt does not match the pending transaction."
-        );
-      clear(key2);
-      return result.txHash;
-    } catch (error) {
-      if (!body.serializedTransaction || error instanceof OwneyError && error.details?.notSubmitted === true)
-        clear(key2);
-      throw error;
-    }
-  };
-  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)
-      throw new Error(
-        "Retry the previous token deposit and agent split first to reconcile its status."
-      );
-    i.onApproved?.();
-    return send({ ...previous, transfers: i.transfers });
-  }
-  const total = i.transfers.reduce((sum, t) => sum + BigInt(t.amount), 0n);
-  const [balance, allowance] = await Promise.all([
-    readErc20Balance(i.pub, i.token, i.owner),
-    readPermit2Allowance(i.pub, i.token, i.owner)
-  ]);
-  if (balance < total)
+async function ensureWalletOnChain(pub, wallet, expected) {
+  const actual = await pub.getChainId();
+  if (actual === expected) return;
+  try {
+    await wallet.switchChain({ id: expected });
+  } catch (error) {
     throw new OwneyError(
-      "DEPOSIT_INSUFFICIENT_BALANCE",
-      "Insufficient token balance for this deposit."
+      "CHAIN_MISMATCH",
+      `Your wallet is on ${chainName(actual)}. Switch it to ${chainName(expected)} and try again.`,
+      {
+        expectedChainId: expected,
+        actualChainId: actual,
+        cause: error instanceof Error ? error.message : String(error)
+      }
     );
-  if (allowance < total && (i.chainId !== 8453 || !isAddressEqual(i.token, BASE_USDC_ADDRESS)))
+  }
+  const after = await pub.getChainId();
+  if (after !== expected) {
     throw new OwneyError(
-      "PERMIT2_APPROVAL_REQUIRED",
-      "token deposits need a one-time Permit2 approval."
+      "CHAIN_MISMATCH",
+      `Your wallet is still on ${chainName(after)}. Switch it to ${chainName(expected)} and try again.`,
+      { expectedChainId: expected, actualChainId: after }
     );
-  const now = (await i.pub.getBlock()).timestamp;
-  let erc2612Permit;
-  if (allowance < total) {
-    const [tokenName, tokenVersion, permitNonce] = await Promise.all([
-      i.pub.readContract({
-        address: i.token,
-        abi: ERC2612_READ_ABI,
-        functionName: "name"
-      }),
-      i.pub.readContract({
-        address: i.token,
-        abi: ERC2612_READ_ABI,
-        functionName: "version"
-      }),
-      i.pub.readContract({
-        address: i.token,
-        abi: ERC2612_READ_ABI,
-        functionName: "nonces",
-        args: [i.owner]
-      })
-    ]);
-    const unsignedPermit = {
-      value: MAX_UINT256.toString(),
-      nonce: permitNonce.toString(),
-      deadline: (now + 900n).toString(),
-      tokenName,
-      tokenVersion
-    };
-    const signature2 = await i.wallet.signTypedData({
-      account: i.owner,
-      ...erc2612TypedData({
-        chainId: 8453,
-        token: i.token,
-        owner: i.owner,
-        permit: unsignedPermit
-      })
-    });
-    erc2612Permit = { ...unsignedPermit, signature: signature2 };
   }
-  const spender = erc2612Permit ? MULTICALL3_ADDRESS : await getSponsorRelayerAddress({
-    apiKey: i.apiKey,
-    baseUrl: i.baseUrl,
-    chainId: i.chainId
-  });
-  const unsigned = {
-    chainId: i.chainId,
-    token: i.token,
-    from: i.owner,
-    transfers: i.transfers,
-    nonce: randomPermit2Nonce().toString(),
-    deadline: (now + 900n).toString(),
-    ...erc2612Permit ? { erc2612Permit } : {}
-  };
-  const signature = await i.wallet.signTypedData({
-    account: i.owner,
-    ...batchTypedData(unsigned, spender)
-  });
-  i.onApproved?.();
-  return send({ ...unsigned, signature });
 }
 
-// src/lib/sponsored-token-deposit.ts
-function makeSponsoredTokenCallback(deps) {
-  const batch = async (chainId, transfers) => {
-    if (chainId !== 8453 && chainId !== 42161 && chainId !== 1)
+// src/lib/sponsored-deposit.ts
+var AUTH_WINDOW_SECONDS = 15 * 60;
+function makeSponsoredDepositCallback(deps) {
+  const post = deps.httpPost ?? postSponsorTransferAuth;
+  return async (smartWallet, chainId, amount) => {
+    const cid = chainId;
+    const token = deps.tokenAddressByChain[cid];
+    if (!token) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
         `No sponsored token configured for chain ${chainId}`
       );
-    const token = deps.tokenAddressByChain[chainId];
-    if (!token)
-      throw new OwneyError(
-        "CHAIN_UNSUPPORTED",
-        `No sponsored token configured for chain ${chainId}`
+    }
+    const pub = deps.getPublicClient(cid);
+    const wallet = deps.getWalletClient(cid);
+    await ensureWalletOnChain(pub, wallet, cid);
+    try {
+      const balance = await readErc20Balance(pub, token, deps.ownerAddress);
+      if (balance < BigInt(amount)) {
+        throw new OwneyError(
+          "DEPOSIT_INSUFFICIENT_BALANCE",
+          "Insufficient balance for this deposit.",
+          { token, chainId: cid, balance: balance.toString(), amount }
+        );
+      }
+    } catch (err) {
+      if (err instanceof OwneyError) throw err;
+      console.warn(
+        "[owney-sdk] Deposit balance pre-check failed (non-fatal):",
+        err instanceof Error ? err.message : String(err)
       );
-    const pub = deps.getPublicClient(chainId), walletChain = deps.getWalletChainClient?.(chainId) ?? pub, wallet = deps.getWalletClient(chainId);
-    await ensureWalletOnChain(walletChain, wallet, chainId);
-    return sponsorTokenBatch({
-      apiKey: deps.apiKey,
-      baseUrl: deps.baseUrl,
-      owner: deps.ownerAddress,
+    }
+    const { tokenName, tokenVersion } = await readTokenMeta(pub, token);
+    const validAfter = 0n;
+    const validBefore = BigInt(
+      Math.floor(Date.now() / 1e3) + AUTH_WINDOW_SECONDS
+    );
+    const nonce = randomAuthNonce();
+    const typedData = buildTransferWithAuthorizationTypedData({
       token,
-      chainId,
-      transfers,
-      pub,
-      wallet,
-      onApproved: deps.onApproved
+      chainId: cid,
+      tokenName,
+      tokenVersion,
+      message: {
+        from: deps.ownerAddress,
+        to: smartWallet,
+        value: BigInt(amount),
+        validAfter,
+        validBefore,
+        nonce
+      }
+    });
+    const authSignature = await wallet.signTypedData({
+      account: deps.ownerAddress,
+      ...typedData
+    });
+    deps.onApproved?.();
+    const result = await post({
+      baseUrl: deps.baseUrl,
+      apiKey: deps.apiKey,
+      body: {
+        chainId: cid,
+        token,
+        from: deps.ownerAddress,
+        to: smartWallet,
+        value: amount,
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce,
+        authSignature,
+        tokenName,
+        tokenVersion
+      }
     });
+    return result.txHash;
   };
-  const callback = makeVerificationAwareDepositCallback(
-    (to, chainId, amount, verification) => batch(chainId, [toBatchTransfer(to, amount, verification)])
-  );
-  registerDepositBatch(callback, batch);
-  return callback;
 }
 
-// src/lib/agent-deposit-batch.ts
-function deferred() {
-  let resolve, reject;
-  const promise = new Promise((yes, no) => {
-    resolve = yes;
-    reject = no;
-  });
-  void promise.catch(() => {
-  });
-  return { promise, resolve, reject };
-}
-async function runAgentDepositBatch(chainId, legs, transfer) {
-  const funding = deferred();
-  const tasks = [];
-  const transfers = [];
-  try {
-    for (const leg of legs) {
-      const ready = deferred();
-      let entered = false;
-      const callback = makeVerificationAwareDepositCallback(
-        (to, cid, amount, verification) => {
-          if (entered || cid !== chainId || BigInt(amount) !== BigInt(leg.amount)) {
-            const error = new Error(
-              "Agent changed its prepared deposit share."
-            );
-            ready.reject(error);
-            throw error;
-          }
-          entered = true;
-          ready.resolve(toBatchTransfer(to, amount, verification));
-          return funding.promise;
-        }
-      );
-      const task = Promise.resolve().then(() => leg.run(callback));
-      tasks.push(task);
-      void task.then(
-        () => {
-          if (!entered)
-            ready.reject(
-              new Error("Agent did not prepare a deposit transfer.")
-            );
-        },
-        (error) => ready.reject(error)
+// src/lib/sponsored-weth-deposit.ts
+var PERMIT_WINDOW_SECONDS = 15 * 60;
+function makeSponsoredWethCallback(deps) {
+  const get = deps.httpGet ?? getSponsorRelayerAddress;
+  const post = deps.httpPost ?? postSponsorPermit2Transfer;
+  return async (smartWallet, chainId, amount) => {
+    const cid = chainId;
+    const token = deps.tokenAddressByChain[cid];
+    if (!token) {
+      throw new OwneyError(
+        "CHAIN_UNSUPPORTED",
+        `No sponsored WETH configured for chain ${chainId}`
       );
-      transfers.push(await ready.promise);
     }
-    const txHash = await transfer(chainId, transfers);
-    funding.resolve(txHash);
-    const settled = await Promise.allSettled(tasks);
-    const agentResults = {};
-    const failures = [];
-    for (const [index, result] of settled.entries()) {
-      if (result.status === "fulfilled")
-        agentResults[legs[index].id] = result.value;
-      else failures.push(legs[index].id);
+    const amountWei = BigInt(amount);
+    const pub = deps.getPublicClient(cid);
+    const wallet = deps.getWalletClient(cid);
+    await ensureWalletOnChain(pub, wallet, cid);
+    try {
+      const balance = await readErc20Balance(pub, token, deps.ownerAddress);
+      if (balance < amountWei) {
+        throw new OwneyError(
+          "DEPOSIT_INSUFFICIENT_BALANCE",
+          "Insufficient WETH balance for this deposit.",
+          { token, chainId: cid, balance: balance.toString(), amount }
+        );
+      }
+    } catch (err) {
+      if (err instanceof OwneyError) throw err;
+      console.warn(
+        "[owney-sdk] WETH balance pre-check failed (non-fatal):",
+        err instanceof Error ? err.message : String(err)
+      );
     }
-    if (failures.length)
+    const allowance = await readPermit2Allowance(pub, token, deps.ownerAddress);
+    if (allowance < amountWei) {
       throw new OwneyError(
-        "DEPOSIT_PARTIAL_FAILURE",
-        "The deposit was sent to all agents, but some agent updates could not be confirmed. Check activity before depositing again.",
-        {
-          txHash,
-          fundsSubmitted: true,
-          agentResults,
-          failedAgentIds: failures
-        }
+        "PERMIT2_APPROVAL_REQUIRED",
+        "WETH gasless deposits need a one-time Permit2 approval; call approvePermit2() first",
+        { token, chainId: cid, allowance: allowance.toString(), amount }
       );
-    return { agentResults };
-  } catch (error) {
-    funding.reject(error);
-    await Promise.allSettled(tasks);
-    throw error;
-  }
+    }
+    const relayer = await get({
+      baseUrl: deps.baseUrl,
+      apiKey: deps.apiKey,
+      chainId: cid
+    });
+    const nonce = randomPermit2Nonce();
+    const deadline = BigInt(
+      Math.floor(Date.now() / 1e3) + PERMIT_WINDOW_SECONDS
+    );
+    const typedData = buildPermitTransferFromTypedData({
+      chainId: cid,
+      message: {
+        permitted: { token, amount: amountWei },
+        spender: relayer,
+        nonce,
+        deadline
+      }
+    });
+    const signature = await wallet.signTypedData({
+      account: deps.ownerAddress,
+      ...typedData
+    });
+    deps.onApproved?.();
+    const result = await post({
+      baseUrl: deps.baseUrl,
+      apiKey: deps.apiKey,
+      body: {
+        chainId: cid,
+        token,
+        from: deps.ownerAddress,
+        to: smartWallet,
+        amount,
+        nonce: nonce.toString(),
+        deadline: deadline.toString(),
+        signature
+      }
+    });
+    return result.txHash;
+  };
 }
 
 // src/lib/sponsored-calls-deposit.ts
-import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi2, toHex } from "viem";
+import { encodeFunctionData, erc20Abi, toHex } from "viem";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -5107,7 +2816,7 @@ function makeSponsoredCallsCallback(deps) {
     }
     return new URL(configured, origin).toString();
   };
-  const batch = async (chainId, transfers) => {
+  return async (smartWallet, chainId, amount) => {
     const cid = chainId;
     const token = deps.tokenAddressByChain[cid];
     if (!token) {
@@ -5123,42 +2832,11 @@ function makeSponsoredCallsCallback(deps) {
         { chainId }
       );
     }
-    const calls = transfers.map((transfer) => ({
-      to: token,
-      value: "0x0",
-      data: encodeFunctionData2({
-        abi: erc20Abi2,
-        functionName: "transfer",
-        args: [transfer.to, BigInt(transfer.amount)]
-      })
-    }));
-    let paymasterUrl = absolutePaymasterUrl();
-    for (const transfer of transfers) {
-      const verification = transfer.yieldseeker;
-      if (!verification) continue;
-      if (chainId !== 8453)
-        throw new OwneyError(
-          "CHAIN_UNSUPPORTED",
-          `Yieldseeker sponsorship is not available on chain ${chainId}.`
-        );
-      const { intent } = await postPaymasterIntent({
-        baseUrl: deps.routingApiBaseUrl,
-        apiKey: deps.apiKey,
-        yieldseekerSignature: verification.signature,
-        body: {
-          chainId,
-          token,
-          from: deps.ownerAddress,
-          to: transfer.to,
-          amount: transfer.amount,
-          yieldseekerUserId: verification.userId,
-          yieldseekerAgentId: verification.agentId
-        }
-      });
-      const url = new URL(paymasterUrl);
-      url.searchParams.append("owneyIntent", intent);
-      paymasterUrl = url.toString();
-    }
+    const data = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [smartWallet, BigInt(amount)]
+    });
     const sendResult = await deps.provider.request({
       method: "wallet_sendCalls",
       params: [
@@ -5166,10 +2844,10 @@ function makeSponsoredCallsCallback(deps) {
           version: "2.0.0",
           from: deps.ownerAddress,
           chainId: toHex(chainId),
-          atomicRequired: transfers.length > 1,
-          calls,
+          atomicRequired: false,
+          calls: [{ to: token, value: "0x0", data }],
           capabilities: {
-            paymasterService: { url: paymasterUrl }
+            paymasterService: { url: absolutePaymasterUrl() }
           }
         }
       ]
@@ -5189,24 +2867,7 @@ function makeSponsoredCallsCallback(deps) {
         params: [callsId]
       });
       const txHash = status?.receipts?.[0]?.transactionHash;
-      if (status?.receipts?.some((receipt) => receipt.status === "0x0") || typeof status?.status === "number" && status.status >= 400) {
-        throw new OwneyError(
-          "SPONSOR_REQUEST_FAILED",
-          "The sponsored deposit did not complete successfully.",
-          { chainId, callsId, safeToFallback: false }
-        );
-      }
-      if (txHash && (transfers.length === 1 || status?.status === 200 || status?.status === "CONFIRMED")) {
-        if (status?.receipts?.some(
-          (receipt) => receipt.transactionHash !== txHash
-        ))
-          throw new OwneyError(
-            "SPONSORED_CALLS_NO_RECEIPT",
-            "The wallet returned multiple transactions for an atomic deposit. Check activity before trying again.",
-            { chainId, callsId }
-          );
-        return txHash;
-      }
+      if (txHash) return txHash;
       if (pollIntervalMs > 0) {
         await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
       }
@@ -5217,16 +2878,9 @@ function makeSponsoredCallsCallback(deps) {
       { chainId, callsId }
     );
   };
-  const callback = makeVerificationAwareDepositCallback(
-    (to, chainId, amount, verification) => batch(chainId, [toBatchTransfer(to, amount, verification)])
-  );
-  registerDepositBatch(callback, batch);
-  return callback;
 }
 
 // src/client.ts
-var PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS = 6;
-var PERMIT2_ALLOWANCE_VERIFY_DELAY_MS = 250;
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
 }
@@ -5253,7 +2907,7 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: base4,
+  8453: base2,
   42161: arbitrum2,
   1: mainnet2
 };
@@ -5262,11 +2916,6 @@ var SPONSORED_WETH_BY_CHAIN = {
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
   1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 };
-var SPONSORED_TOKENS_BY_ASSET = { USDC: SPONSORED_USDC_BY_CHAIN, WETH: SPONSORED_WETH_BY_CHAIN };
-function sponsoredTokensFor(asset) {
-  if (!Object.prototype.hasOwnProperty.call(SPONSORED_TOKENS_BY_ASSET, asset)) throw new OwneyError("ASSET_UNSUPPORTED", `No sponsored token configured for ${asset}`);
-  return SPONSORED_TOKENS_BY_ASSET[asset];
-}
 function shouldFallbackToUserPaid(error, asset, appCallback) {
   return (asset === "WETH" || asset === "USDC") && appCallback === void 0 && error instanceof OwneyError && error.code === "SPONSOR_REQUEST_FAILED" && error.details?.safeToFallback === true;
 }
@@ -5287,10 +2936,7 @@ var OwneySDK = class {
   // leave every user's agent profile alone.
   orgAgentConfig;
   orgAgentConfigPromise = null;
-  rpcUrls;
   zyfaiRpcUrls;
-  yieldseekerApiBaseUrl;
-  yieldseekerSiweOrigin;
   routingApiBaseUrl;
   referralSource;
   cachedSponsoredCallback = null;
@@ -5312,14 +2958,7 @@ var OwneySDK = class {
   constructor(config) {
     this.apiKey = config.apiKey;
     if (config.debug) setOwneyDebug(true);
-    this.rpcUrls = resolveRpcUrls(
-      config.rpcUrls,
-      config.apiKey,
-      config.routingApiBaseUrl
-    );
-    this.zyfaiRpcUrls = config.rpcUrls ? void 0 : config.zyfaiRpcUrls;
-    this.yieldseekerApiBaseUrl = config.yieldseekerApiBaseUrl;
-    this.yieldseekerSiweOrigin = config.yieldseekerSiweOrigin;
+    this.zyfaiRpcUrls = config.zyfaiRpcUrls;
     this.routingApiBaseUrl = config.routingApiBaseUrl;
     this.paymasterServiceUrl = config.paymasterServiceUrl;
     this.referralSource = config.referralSource;
@@ -5353,7 +2992,6 @@ var OwneySDK = class {
    * After calling this, `connect()` must be called again before using agent methods.
    */
   async disconnect() {
-    this.state = null;
     for (const agent of this.agents.values()) {
       await agent.disconnect();
     }
@@ -5407,16 +3045,18 @@ var OwneySDK = class {
     }
     return this.state.provider;
   }
-  getPaidRpcClient(chainId) {
-    return createPaidRpcClient(VIEM_CHAIN2[chainId], this.rpcUrls);
-  }
-  /** Builds the default USDC batch callback for the connected wallet. */
+  /**
+   * Lazily builds (and caches) the default EIP-3009 sponsored deposit callback
+   * used when the caller omits `depositCallback`. Wraps the connected EIP-1193
+   * provider with viem `custom(provider)` to read token meta and sign the
+   * `TransferWithAuthorization`, then POSTs to the sponsor API.
+   */
   getDefaultSponsoredCallback(onApproved) {
     if (!onApproved && this.cachedSponsoredCallback)
       return this.cachedSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
-    const callback = makeSponsoredTokenCallback({
+    const callback = makeSponsoredDepositCallback({
       apiKey: this.apiKey,
       baseUrl: this.routingApiBaseUrl,
       ownerAddress: owner,
@@ -5425,33 +3065,35 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // 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) => createPublicClient4({
+      getPublicClient: (cid) => createPublicClient2({
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom(provider)
       }),
-      getWalletClient: (cid) => createWalletClient3({
+      getWalletClient: (cid) => createWalletClient({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom(provider)
       })
     });
     if (!onApproved) this.cachedSponsoredCallback = callback;
     return callback;
   }
-  /** Builds the wallet-native sponsored calls callback for compatible paymasters. */
+  /**
+   * Lazily builds (and caches) the default Permit2 sponsored WETH deposit
+   * callback used when the caller omits `depositCallback` for a WETH
+   * deposit. Mirrors `getDefaultSponsoredCallback()` but signs a Permit2
+   * `PermitTransferFrom` instead of an EIP-3009 authorization.
+   */
   getDefaultSponsoredCallsCallback(asset, onApproved) {
     const cached = this.cachedSponsoredCallsCallbacks.get(asset);
     if (!onApproved && cached) return cached;
     const provider = this.requireConnectedProvider();
     const callback = makeSponsoredCallsCallback({
-      apiKey: this.apiKey,
-      routingApiBaseUrl: this.routingApiBaseUrl,
       provider,
       ownerAddress: this.state.walletAddress,
       paymasterServiceUrl: this.paymasterServiceUrl,
       onApproved,
-      tokenAddressByChain: sponsoredTokensFor(asset)
+      tokenAddressByChain: asset === "WETH" ? SPONSORED_WETH_BY_CHAIN : SPONSORED_USDC_BY_CHAIN
     });
     if (!onApproved) this.cachedSponsoredCallsCallbacks.set(asset, callback);
     return callback;
@@ -5460,14 +3102,14 @@ var OwneySDK = class {
    * Lazily builds (and caches) the default Permit2 sponsored WETH deposit
    * callback used when the caller omits `depositCallback` for a WETH deposit.
    * Mirrors `getDefaultSponsoredCallback()` but signs a Permit2
-   * single-use batch authorization instead of an EIP-3009 authorization.
+   * `PermitTransferFrom` instead of an EIP-3009 authorization.
    */
   getDefaultWethSponsoredCallback(onApproved) {
     if (!onApproved && this.cachedWethSponsoredCallback)
       return this.cachedWethSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
-    const callback = makeSponsoredTokenCallback({
+    const callback = makeSponsoredWethCallback({
       apiKey: this.apiKey,
       baseUrl: this.routingApiBaseUrl,
       ownerAddress: owner,
@@ -5476,15 +3118,14 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // 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) => createPublicClient4({
+      getPublicClient: (cid) => createPublicClient2({
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom(provider)
       }),
-      getWalletClient: (cid) => createWalletClient3({
+      getWalletClient: (cid) => createWalletClient({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: custom3(provider)
+        transport: custom(provider)
       })
     });
     if (!onApproved) this.cachedWethSponsoredCallback = callback;
@@ -5515,10 +3156,12 @@ var OwneySDK = class {
       this.orgAgentConfigPromise = fetchOrgAgentConfig(
         this.apiKey,
         this.routingApiBaseUrl
-      ).then((config) => {
-        this.orgAgentConfig = config;
-        return config;
-      });
+      ).then(
+        (config) => {
+          this.orgAgentConfig = config;
+          return config;
+        }
+      );
     }
     return this.orgAgentConfigPromise;
   }
@@ -5558,14 +3201,7 @@ var OwneySDK = class {
           this.routingApiBaseUrl
         );
         this.disabledAgents.clear();
-        for (const {
-          key: key2,
-          agent_type,
-          is_enabled,
-          is_configured
-        } of agentKeys) {
-          const configured = is_configured ?? Boolean(key2);
-          if (!configured) continue;
+        for (const { key: key2, agent_type, is_enabled } of agentKeys) {
           const agent = this.createAgent(agent_type, key2);
           if (!agent) continue;
           this.agents.set(agent_type, agent);
@@ -5589,23 +3225,7 @@ var OwneySDK = class {
   }
   createAgent(agentId, key2) {
     if (agentId === "zyfai") {
-      if (!key2) return null;
-      return new ZyfaiAgent(
-        key2,
-        this.zyfaiRpcUrls ? resolveRpcUrls(
-          this.zyfaiRpcUrls,
-          this.apiKey,
-          this.routingApiBaseUrl
-        ) : this.rpcUrls,
-        this.referralSource
-      );
-    }
-    if (agentId === "yieldseeker") {
-      return new YieldseekerAgent(this.apiKey, {
-        auth: { origin: this.yieldseekerSiweOrigin },
-        baseUrl: this.yieldseekerApiBaseUrl ?? getYieldseekerProxyBaseUrl(this.routingApiBaseUrl),
-        rpcUrls: this.rpcUrls
-      });
+      return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
     }
     return null;
   }
@@ -5651,10 +3271,9 @@ var OwneySDK = class {
    *   If provided, ALL specified agents must support the chainId or the call
    *   throws before activating any agent.
    */
-  async activateAgent(chainId, agentId, asset) {
+  async activateAgent(chainId, agentId) {
     const state = this.requireState();
     await this.ensureAgentsInitialized();
-    this.assertActivationSession(state);
     if (agentId !== void 0) {
       if (agentId.length === 0) {
         throw new OwneyError(
@@ -5688,7 +3307,7 @@ var OwneySDK = class {
         this.activeAgents.add(id);
       }
       state.chainId = chainId;
-      await this.activateAgentsInTurn(agents, state, chainId, asset);
+      await this.activateAgentsInTurn(agents, state, chainId);
       return;
     }
     const compatible = [...this.agents.values()].filter(
@@ -5709,12 +3328,7 @@ var OwneySDK = class {
     const enabledCompatible = compatible.filter(
       (agent) => !this.isAgentDisabled(agent.id)
     );
-    await this.activateAgentsInTurn(enabledCompatible, state, chainId, asset);
-  }
-  assertActivationSession(state) {
-    if (this.state !== state) {
-      throw new OwneyError("NOT_CONNECTED", "Wallet connection changed. Please try again.");
-    }
+    await this.activateAgentsInTurn(enabledCompatible, state, chainId);
   }
   /**
    * Activate agents ONE AT A TIME, each followed by its org policy.
@@ -5729,51 +3343,26 @@ var OwneySDK = class {
    * Serializing costs no real wall-clock: the user can only approve one prompt
    * at a time anyway.
    *
-   * Stop at the first failure so a canceled sign-in does not open another
-   * agent's wallet prompt. Report any earlier successes for diagnostics; the
-   * app discards the session when the complete sign-in does not succeed.
+   * Every agent is attempted even if an earlier one fails, so one declined
+   * signature can't deny the remaining agents their turn. The first failure is
+   * rethrown (matching the previous `Promise.all` rejection) once all agents
+   * have had a chance to activate.
    */
-  async activateAgentsInTurn(agents, state, chainId, asset) {
+  async activateAgentsInTurn(agents, state, chainId) {
     let firstError = null;
-    const activatedAgentIds = [];
-    const failedAgents = [];
     for (const agent of agents) {
-      this.assertActivationSession(state);
       try {
-        await agent.activateAgent(state, chainId, asset);
-        this.assertActivationSession(state);
+        await agent.activateAgent(state, chainId);
         await this.applyOrgPolicyTo(agent, state, chainId);
-        this.assertActivationSession(state);
-        activatedAgentIds.push(agent.id);
       } catch (error) {
-        this.assertActivationSession(state);
-        const message = error !== null && typeof error === "object" && "message" in error && typeof error.message === "string" ? error.message : typeof error === "string" ? error : "No activation error message was returned.";
-        failedAgents.push({
-          agentId: agent.id,
-          code: error instanceof OwneyError ? error.code : void 0,
-          message,
-          ...error instanceof OwneyError && error.details ? { details: error.details } : {}
-        });
         if (firstError === null) {
           firstError = error;
         } else {
           console.error(`activateAgent(${agent.id}) failed:`, error);
         }
-        break;
       }
     }
-    if (firstError === null) return;
-    if (activatedAgentIds.length === 0) throw firstError;
-    const failedAgentIds = failedAgents.map(({ agentId }) => agentId);
-    const activeNames = activatedAgentIds.map(this.formatAgentName).join(", ");
-    const failureMessages = failedAgents.map(
-      ({ agentId, message }) => `${this.formatAgentName(agentId)} activation failed: ${message}`
-    ).join(" ");
-    throw new OwneyError(
-      "AGENT_ACTIVATION_PARTIAL_FAILURE",
-      `${activeNames} activated. ${failureMessages}`,
-      { activatedAgentIds, failedAgentIds, failures: failedAgents }
-    );
+    if (firstError !== null) throw firstError;
   }
   /**
    * Deposit into a specific agent, or distribute across all eligible agents.
@@ -5783,8 +3372,7 @@ var OwneySDK = class {
    * @param options.asset - Asset symbol to deposit (e.g. "USDC")
    * @param options.depositCallback - Callback that performs the token transfer and returns a tx hash.
    *   When agentId is omitted, this callback is invoked once per eligible agent with that agent's
-   *   split amount and smart wallet address. Default sponsored deposits batch
-   *   all shares into one signature; custom callbacks still run once per agent.
+   *   split amount and smart wallet address — expect multiple wallet prompts.
    * @param options.agentId - Optional explicit target. Otherwise split equally,
    *   or fund remaining agents when a recovery deposit cannot meet every minimum.
    * @returns {OwneyDepositResult} for a single agent, or {OwneyMultiDepositResult} with per-agent results
@@ -5869,40 +3457,6 @@ var OwneySDK = class {
         }
       );
     }
-    const batchTransfer = getDepositBatchTransfer(effectiveCallback);
-    if (!depositCallback && batchTransfer) {
-      return runAgentDepositBatch(
-        chainId,
-        agentAmounts.map(({ agent, amount: amount2 }) => ({
-          id: agent.id,
-          amount: amount2,
-          run: (callback) => withFailureReporting(
-            this.apiKey,
-            agent.id,
-            () => agent.deposit(state, chainId, amount2, asset, callback),
-            this.routingApiBaseUrl
-          )
-        })),
-        async (cid, transfers) => {
-          try {
-            return await batchTransfer(cid, transfers);
-          } catch (error) {
-            if (!(error instanceof OwneyError) || error.code !== "PERMIT2_APPROVAL_REQUIRED")
-              throw error;
-            const requiredAmount = transfers.reduce(
-              (sum, transfer) => sum + BigInt(transfer.amount),
-              0n
-            );
-            await this.approvePermit2(
-              asset,
-              requiredAmount,
-              cid
-            );
-            return batchTransfer(cid, transfers);
-          }
-        }
-      );
-    }
     const agentResults = {};
     for (const [
       index,
@@ -5940,12 +3494,10 @@ var OwneySDK = class {
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
    * two independent auto-recovery mechanisms:
    *
-   * 1. Missing Permit2 allowance outside the atomic Base-USDC path: when the
-   *    app did not supply its own callback and the attempt fails with
-   *    `PERMIT2_APPROVAL_REQUIRED`, this is the wallet's first Permit2 deposit
-   *    for that token. Base USDC bundles a gasless ERC-2612 approval inside
-   *    its sponsored deposit and never reaches this branch. Other tokens send
-   *    the one-time user-paid Permit2 approval via `approvePermit2()` and
+   * 1. Missing Permit2 allowance: when the app did not supply its own
+   *    callback and the attempt fails with `PERMIT2_APPROVAL_REQUIRED` on a
+   *    WETH deposit, this is the wallet's first gasless WETH deposit. We send
+   *    the one-time (user-paid) Permit2 approval via `approvePermit2()` and
    *    retry the SAME sponsored attempt once. Bounded to one approval attempt
    *    per call so a wallet/agent that keeps reporting the allowance as
    *    missing can't loop forever. If `approvePermit2()` itself throws (e.g.
@@ -5981,16 +3533,12 @@ var OwneySDK = class {
       try {
         return await attempt(effectiveCallback);
       } catch (error) {
-        if (!approvalAttempted && appCallback === void 0 && (asset === "WETH" || asset === "USDC") && error instanceof OwneyError && error.code === "PERMIT2_APPROVAL_REQUIRED") {
+        if (!approvalAttempted && appCallback === void 0 && asset === "WETH" && error instanceof OwneyError && error.code === "PERMIT2_APPROVAL_REQUIRED") {
           approvalAttempted = true;
           console.warn(
-            "[owney-sdk] First token deposit: sending one-time Permit2 approval..."
-          );
-          await this.approvePermit2(
-            asset,
-            BigInt(amount),
-            chainId
+            "[owney-sdk] First WETH deposit: sending one-time Permit2 approval..."
           );
+          await this.approvePermit2();
           continue;
         }
         if (!shouldFallbackToUserPaid(error, asset, appCallback)) throw error;
@@ -6028,10 +3576,10 @@ var OwneySDK = class {
       agent,
       amount: i === agents.length - 1 ? perAgent + remainder : perAgent
     }));
-    const valid2 = splits.filter(
+    const valid = splits.filter(
       (s) => s.amount > 0n && (exempt.has(s.agent.id) || s.amount >= this.getMinDepositAmount(s.agent, chainId, asset))
     );
-    if (valid2.length === agents.length) {
+    if (valid.length === agents.length) {
       return splits.map((s) => ({ agent: s.agent, amount: String(s.amount) }));
     }
     const targets = agentsRequiringActivation.length > 0 ? agentsRequiringActivation : agents;
@@ -6050,11 +3598,6 @@ var OwneySDK = class {
       )
     }));
   }
-  formatAgentName(agentId) {
-    if (agentId === "zyfai") return "Zyfai";
-    if (agentId === "yieldseeker") return "Yieldseeker";
-    return agentId;
-  }
   async validateMinDepositAmount(agent, state, chainId, asset, amount) {
     const minDepositAmount = this.getMinDepositAmount(agent, chainId, asset);
     const parsedAmount = BigInt(amount);
@@ -6086,12 +3629,12 @@ var OwneySDK = class {
         (t) => t.chainId === chainId && t.asset.toLowerCase() === target
       );
       const targetChainName = agent.supportedAssets.find((entry) => entry.chainId === chainId)?.chain?.trim().toUpperCase();
-      const position2 = (balance.positions ?? []).find((p) => {
+      const position = (balance.positions ?? []).find((p) => {
         const positionChain = p.chain.trim().toUpperCase();
         const matchesChain = positionChain === String(chainId) || targetChainName !== void 0 && positionChain === targetChainName;
         return matchesChain && p.asset.toLowerCase() === target && Number(p.amount) > 0;
       });
-      return !!token && Number(token.amount) > 0 || !!position2;
+      return !!token && Number(token.amount) > 0 || !!position;
     } catch (error) {
       if (requireReliableRead) {
         throw new OwneyError(
@@ -6136,32 +3679,6 @@ var OwneySDK = class {
     }
     return eligible;
   }
-  /**
-   * Run owner-approved withdrawals before relayer-only withdrawals. Wallet
-   * approval is the only point at which the user can cancel the aggregate
-   * operation, so no relayer leg should commit before it has completed.
-   */
-  orderAgentsForWithdrawal(agents) {
-    return agents.map((agent, index) => ({ agent, index })).sort((left, right) => {
-      const approvalOrder = Number(Boolean(right.agent.withdrawalRequiresWalletApproval)) - Number(Boolean(left.agent.withdrawalRequiresWalletApproval));
-      return approvalOrder || left.index - right.index;
-    }).map(({ agent }) => agent);
-  }
-  isUserRejectedWithdrawal(error) {
-    let current = error;
-    const seen = /* @__PURE__ */ new Set();
-    while (current && typeof current === "object" && !seen.has(current)) {
-      seen.add(current);
-      const candidate = current;
-      if (candidate.code === 4001 || candidate.code === "4001") return true;
-      const message = [candidate.message, candidate.shortMessage].filter((value) => typeof value === "string").join(" ");
-      if (/user (?:rejected|denied)|rejected by user/i.test(message)) {
-        return true;
-      }
-      current = candidate.cause;
-    }
-    return false;
-  }
   // --- Fund operations ---
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
@@ -6173,14 +3690,7 @@ var OwneySDK = class {
    * @returns {AgentWithdrawResult} for a single agent, or {OwneyWithdrawResult} with per-agent results
    */
   async withdraw(options) {
-    const { asset, amount, agentId, onAgentResult } = options;
-    const notifyAgentResult = (id, result) => {
-      try {
-        onAgentResult?.(id, result);
-      } catch (error) {
-        console.warn("Withdrawal result observer failed:", error);
-      }
-    };
+    const { asset, amount, agentId } = options;
     const state = this.requireState();
     const chainId = this.requireChainId();
     const token = asset;
@@ -6196,26 +3706,21 @@ var OwneySDK = class {
     if (agentId) {
       const agent = this.getAgent(agentId);
       this.validateAssetSupport(agent, chainId, asset);
-      const result = await withFailureReporting(
+      return withFailureReporting(
         this.apiKey,
         agent.id,
         () => agent.withdraw(state, chainId, token, amount),
         this.routingApiBaseUrl
       );
-      notifyAgentResult(agent.id, result);
-      return result;
     }
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
-    const withdrawalAgents = this.orderAgentsForWithdrawal(eligibleAgents);
     if (!amount) {
       const results2 = {};
       const agentErrors2 = {};
-      for (const agent of withdrawalAgents) {
+      for (const agent of eligibleAgents) {
         try {
           results2[agent.id] = await agent.withdraw(state, chainId, token);
-          notifyAgentResult(agent.id, results2[agent.id]);
         } catch (err) {
-          if (this.isUserRejectedWithdrawal(err)) throw err;
           console.error(`withdraw failed for agent "${agent.id}":`, err);
           agentErrors2[agent.id] = err instanceof Error ? err.message : String(err);
           const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
@@ -6244,10 +3749,6 @@ var OwneySDK = class {
     }
     const requested = BigInt(amount);
     const aggregated = await this.getBalances();
-    const unavailableAgents = eligibleAgents.filter(
-      (agent) => !(agent.id in aggregated.agentBalances)
-    );
-    const unavailableAgentIds = unavailableAgents.map((agent) => agent.id);
     const balances = projectAgentBalancesForAsset(
       eligibleAgents,
       aggregated.agentBalances,
@@ -6256,18 +3757,7 @@ var OwneySDK = class {
       assetInfo.decimals
     );
     const totalAvailable = balances.reduce((sum, x) => sum + x.balance, 0n);
-    if (totalAvailable === 0n && unavailableAgents.length > 0) {
-      throw new OwneyError(
-        "WITHDRAW_BALANCE_UNAVAILABLE",
-        `Cannot safely plan the withdrawal because balance data is unavailable for: ${unavailableAgentIds.join(", ")}.`,
-        {
-          asset,
-          unavailableAgents: unavailableAgentIds,
-          agentErrors: aggregated.agentErrors
-        }
-      );
-    }
-    if (totalAvailable < requested && unavailableAgents.length === 0) {
+    if (totalAvailable < requested) {
       throw new OwneyError(
         "WITHDRAW_INSUFFICIENT_BALANCE",
         `Requested withdrawal "${amount}" exceeds available balance "${totalAvailable.toString()}" for asset "${asset}".`,
@@ -6278,7 +3768,6 @@ var OwneySDK = class {
         }
       );
     }
-    const plannedTarget = totalAvailable < requested ? totalAvailable : requested;
     const disabledBalances = balances.filter(
       (b) => this.isAgentDisabled(b.agent.id)
     );
@@ -6287,7 +3776,7 @@ var OwneySDK = class {
     );
     const { plans: disabledPlans, remaining: afterDrain } = planDisabledDrain(
       disabledBalances,
-      plannedTarget
+      requested
     );
     const enabledTotal = enabledBalances.reduce((s, b) => s + b.balance, 0n);
     const enabledPlans = afterDrain > 0n ? planProportionalShares(enabledBalances, afterDrain, enabledTotal) : enabledBalances.map(({ agent, balance }) => ({
@@ -6296,13 +3785,10 @@ var OwneySDK = class {
       planned: 0n
     }));
     const plans = [...disabledPlans, ...enabledPlans];
-    const orderedPlans = this.orderAgentsForWithdrawal(plans.map((p) => p.agent)).map((agent) => plans.find((plan) => plan.agent === agent));
     const results = {};
-    const agentErrors = {
-      ...aggregated.agentErrors ?? {}
-    };
-    for (let i = 0; i < orderedPlans.length; i++) {
-      const p = orderedPlans[i];
+    const agentErrors = {};
+    for (let i = 0; i < plans.length; i++) {
+      const p = plans[i];
       if (p.planned === 0n) continue;
       try {
         results[p.agent.id] = await p.agent.withdraw(
@@ -6311,9 +3797,7 @@ var OwneySDK = class {
           token,
           p.planned.toString()
         );
-        notifyAgentResult(p.agent.id, results[p.agent.id]);
       } catch (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);
         const code = err instanceof OwneyError ? err.code : "SDK_AGENT_FAILURE";
@@ -6325,7 +3809,7 @@ var OwneySDK = class {
         );
         const failedAmount = p.planned;
         p.planned = 0n;
-        redistributeShare(orderedPlans, i, failedAmount);
+        redistributeShare(plans, i, failedAmount);
       }
     }
     if (Object.keys(results).length === 0) {
@@ -6349,8 +3833,7 @@ var OwneySDK = class {
           requested: amount,
           withdrawn: withdrawn.toString(),
           partialResults: results,
-          agentErrors,
-          ...unavailableAgentIds.length > 0 ? { unavailableAgents: unavailableAgentIds } : {}
+          agentErrors
         }
       );
     }
@@ -6368,10 +3851,7 @@ var OwneySDK = class {
     if (agentId) {
       const agent = this.getAgent(agentId);
       const result = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
-      return {
-        ...result,
-        balanceComposition: agent.balanceComposition ?? "tokens-include-positions"
-      };
+      return result;
     }
     let totalBalance = 0;
     const results = {};
@@ -6379,13 +3859,7 @@ var OwneySDK = class {
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
         const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
-        return [
-          id,
-          {
-            ...b,
-            balanceComposition: agent.balanceComposition ?? "tokens-include-positions"
-          }
-        ];
+        return [id, b];
       })
     );
     let successCount = 0;
@@ -6407,7 +3881,6 @@ var OwneySDK = class {
       const retryDelay = rateLimitDelay(reason);
       if (retryDelay !== void 0) agentRetryAt[agentId2] = Date.now() + retryDelay;
       agentErrors[agentId2] = reason instanceof Error ? reason.message : String(reason);
-      console.error(`[owney-sdk] Balance fetch failed for agent "${agentId2}":`, reason);
     }
     if (successCount === 0) {
       throw new OwneyError(
@@ -6586,10 +4059,7 @@ var OwneySDK = class {
       Promise.all(
         entries.map(async ([id, agent]) => {
           const b = await this.readAgent(agent, "balances", () => agent.getBalances(state, chainId));
-          return [
-            id,
-            balanceForApyScope(b, chainId, tokenSymbol)
-          ];
+          return [id, balanceForApyScope(b, chainId, tokenSymbol)];
         })
       )
     ]);
@@ -6750,95 +4220,51 @@ var OwneySDK = class {
     return pending;
   }
   /**
-   * User-paid approval of Permit2 on the selected token for the active chain.
-   * Grants the maximum ERC20 allowance so later deposits do not require another
-   * approval. Resolves after one confirmation so the subsequent deposit attempt
-   * sees the new allowance. Deposit retries pass their captured chain id so a
-   * concurrent activation cannot redirect the approval to another network.
-   *
-   * @param requiredAmount Raw base-unit amount the pending deposit must cover.
-   * @param expectedChainId Chain captured by the deposit that requested approval.
+   * One-time, user-paid approval of Permit2 on the sponsored WETH token for
+   * the active chain. Required once per wallet per chain before gasless WETH
+   * deposits; afterwards deposit() is signature-only. Resolves only after the
+   * approval transaction is mined (1 confirmation), so a subsequent deposit()
+   * will see the new allowance; throws if the transaction reverted.
    * @returns the approval transaction hash.
    */
-  async approvePermit2(asset = "WETH", requiredAmount = 0n, expectedChainId) {
+  async approvePermit2(asset = "WETH") {
+    void asset;
     const state = this.requireState();
-    const chainId = expectedChainId ?? this.requireChainId();
-    this.getEligibleAgents(chainId, asset, { excludeDisabled: true });
-    const token = sponsoredTokensFor(asset)[chainId];
+    const chainId = this.requireChainId();
+    this.validateAssetSupport(this.getAgent("zyfai"), chainId, "WETH");
+    const token = SPONSORED_WETH_BY_CHAIN[chainId];
     if (!token) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
-        `No sponsored token on chain ${chainId}`
+        `No sponsored WETH on chain ${chainId}`
       );
     }
     const provider = this.requireConnectedProvider();
-    const walletChainClient = createPublicClient4({
-      chain: VIEM_CHAIN2[chainId],
-      transport: custom3(provider)
-    });
-    const publicClient = this.getPaidRpcClient(chainId);
-    const approvalAmount = permit2ApprovalAmount(requiredAmount);
-    const wallet = createWalletClient3({
+    const wallet = createWalletClient({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: custom3(provider)
+      transport: custom(provider)
     });
-    await ensureWalletOnChain(walletChainClient, wallet, chainId);
     const hash = await wallet.writeContract({
       address: token,
       abi: ERC20_ALLOWANCE_ABI,
       functionName: "approve",
-      args: [PERMIT2_ADDRESS, approvalAmount],
+      args: [PERMIT2_ADDRESS, MAX_UINT256],
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const receipt = await withPaidRpcDiagnostics(
-      () => publicClient.waitForTransactionReceipt({
-        hash,
-        confirmations: 1
-      }),
-      chainId,
-      "eth_getTransactionReceipt"
-    );
+    const publicClient = createPublicClient2({
+      chain: VIEM_CHAIN2[chainId],
+      transport: custom(provider)
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash,
+      confirmations: 1
+    });
     if (receipt.status !== "success") {
       throw new Error(`Permit2 approval reverted (tx ${hash})`);
     }
-    let observedAllowance = 0n;
-    let verificationError;
-    for (let attempt = 0; attempt < PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS; attempt += 1) {
-      try {
-        observedAllowance = await readPermit2Allowance(
-          publicClient,
-          token,
-          state.walletAddress,
-          attempt === 0 ? receipt.blockNumber : void 0
-        );
-        verificationError = void 0;
-        if (observedAllowance >= requiredAmount) return hash;
-      } catch (error) {
-        verificationError = error;
-      }
-      if (attempt + 1 < PERMIT2_ALLOWANCE_VERIFY_ATTEMPTS) {
-        await new Promise(
-          (resolve) => setTimeout(resolve, PERMIT2_ALLOWANCE_VERIFY_DELAY_MS)
-        );
-      }
-    }
-    throw new OwneyError(
-      "PERMIT2_APPROVAL_REQUIRED",
-      "Permit2 approval was confirmed, but the required token allowance was not observable.",
-      {
-        approvalConfirmed: true,
-        approvalTxHash: hash,
-        owner: state.walletAddress,
-        token,
-        spender: PERMIT2_ADDRESS,
-        chainId,
-        requiredAmount: requiredAmount.toString(),
-        observedAllowance: observedAllowance.toString(),
-        ...verificationError instanceof Error ? { verificationError: verificationError.message } : {}
-      }
-    );
+    return hash;
   }
   // --- Discovery (no wallet required) ---
   /**
@@ -6866,9 +4292,7 @@ var OwneySDK = class {
       return this.readAgent(agent, "agentApy", () => agent.getAgentApy(days, agentOptions), { days, ...agentOptions });
     }
     const results = {};
-    const agentEntries = [...this.agents.entries()].filter(
-      ([id]) => !this.isAgentDisabled(id)
-    );
+    const agentEntries = [...this.agents.entries()];
     const apyResults = await Promise.all(
       agentEntries.map(async ([id, agent]) => {
         const apy = await this.readAgent(agent, "agentApy", () => agent.getAgentApy(days, agentOptions), { days, ...agentOptions });
@@ -6943,13 +4367,13 @@ var OwneySDK = class {
 };
 
 // src/agents/zyfai/zyfai.siwx.ts
-import { getAddress as getAddress3 } from "viem";
-import { SiweMessage as SiweMessage2 } from "siwe";
+import { getAddress } from "viem";
+import { SiweMessage } from "siwe";
 import { ZyfaiSDK as ZyfaiSDK2 } from "@zyfai/sdk";
 
 // src/agents/zyfai/zyfai.siwx-cache.ts
-var KEY_PREFIX4 = "owney.siwx.session";
-var storage4 = () => {
+var KEY_PREFIX2 = "owney.siwx.session";
+var storage2 = () => {
   if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
@@ -6957,8 +4381,8 @@ var storage4 = () => {
     return null;
   }
 };
-var buildKey3 = (address) => `${KEY_PREFIX4}:${address.toLowerCase()}`;
-var legacyKeyPrefix2 = (address) => `${KEY_PREFIX4}:${address.toLowerCase()}:`;
+var buildKey2 = (address) => `${KEY_PREFIX2}:${address.toLowerCase()}`;
+var legacyKeyPrefix2 = (address) => `${KEY_PREFIX2}:${address.toLowerCase()}:`;
 var memorySiwxSessions = /* @__PURE__ */ new Map();
 var readLegacySiwxSession = (store, address) => {
   if (!store) return null;
@@ -6989,17 +4413,17 @@ var readLegacySiwxSession = (store, address) => {
 };
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
-  const key2 = buildKey3(address);
-  const store = storage4();
-  let raw2 = null;
+  const key2 = buildKey2(address);
+  const store = storage2();
+  let raw = null;
   try {
-    raw2 = store?.getItem(key2) ?? null;
+    raw = store?.getItem(key2) ?? null;
   } catch {
-    raw2 = null;
+    raw = null;
   }
-  if (raw2) {
+  if (raw) {
     try {
-      return JSON.parse(raw2);
+      return JSON.parse(raw);
     } catch {
       memorySiwxSessions.delete(key2);
       try {
@@ -7018,18 +4442,18 @@ var readSiwxSession = (address, chainId) => {
 };
 var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
-  const key2 = buildKey3(address);
+  const key2 = buildKey2(address);
   memorySiwxSessions.set(key2, session);
-  const store = storage4();
+  const store = storage2();
   try {
     store?.setItem(key2, JSON.stringify(session));
   } catch {
   }
 };
 var clearSiwxSession = (address, _chainId) => {
-  const key2 = buildKey3(address);
+  const key2 = buildKey2(address);
   memorySiwxSessions.delete(key2);
-  const store = storage4();
+  const store = storage2();
   try {
     store?.removeItem(key2);
   } catch {
@@ -7069,8 +4493,8 @@ function buildSIWXConfig(deps) {
       statement: STATEMENT,
       issuedAt,
       toString() {
-        return new SiweMessage2({
-          address: getAddress3(accountAddress),
+        return new SiweMessage({
+          address: getAddress(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,
@@ -7112,7 +4536,7 @@ function buildSIWXConfig(deps) {
   const persistSession = async (session) => {
     const address = session.data.accountAddress;
     const id = numericChainId(session.data.chainId);
-    const message = new SiweMessage2(session.message);
+    const message = new SiweMessage(session.message);
     const login = await post("/auth/login", {
       message,
       signature: session.signature,
@@ -7161,7 +4585,6 @@ export {
   NotConnectedError,
   OwneyError,
   OwneySDK,
-  YieldseekerAgent,
   createOwneySIWX,
   setOwneyDebug
 };