@owney/sdk 0.6.6-beta.1 → 0.6.6-beta.3

package/dist/index.js

@@ -1,21 +1,14 @@
-import {
-  AgentChainIncompatibleError,
-  AgentNotFoundError,
-  NotConnectedError,
-  OwneyError
-} from "./chunk-GMNQBWUB.js";
-
 // src/agents/zyfai/zyfai.agent.ts
 import { ZyfaiSDK } from "@zyfai/sdk";
 import { createPublicClient, http } from "viem";
-import { base, arbitrum } from "viem/chains";
+import { base, arbitrum, mainnet } from "viem/chains";
 
 // src/types/config.ts
 var P_SUPPORTED_CHAINS = {
-  chainIds: [8453, 42161],
-  chains: ["BASE", "ARBITRUM"]
+  chainIds: [8453, 42161, 1],
+  chains: ["BASE", "ARBITRUM", "ETHEREUM"]
 };
-var SUPPORTED_TOKENS = ["USDC", "USDT"];
+var SUPPORTED_TOKENS = ["USDC", "USDT", "WETH"];
 var SUPPORTED_CHAIN_IDS = P_SUPPORTED_CHAINS.chainIds;
 var SUPPORTED_CHAINS = P_SUPPORTED_CHAINS.chains;
 var SupportedAssets = [
@@ -36,9 +29,82 @@ var SupportedAssets = [
     symbol: "USDT",
     chainId: 42161,
     decimals: 6
+  },
+  {
+    address: `0x4200000000000000000000000000000000000006`,
+    symbol: "WETH",
+    chainId: 8453,
+    decimals: 18
+  },
+  {
+    address: `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`,
+    symbol: "WETH",
+    chainId: 42161,
+    decimals: 18
+  },
+  {
+    address: `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`,
+    symbol: "USDC",
+    chainId: 1,
+    decimals: 6
+  },
+  {
+    address: `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`,
+    symbol: "WETH",
+    chainId: 1,
+    decimals: 18
   }
 ];
 
+// src/errors.ts
+var OwneyError = class extends Error {
+  code;
+  details;
+  agentId;
+  constructor(code, message, details, agentId) {
+    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
+    super(`${prefix} ${message}`);
+    this.name = "OwneyError";
+    this.code = code;
+    this.details = details;
+    this.agentId = agentId;
+  }
+};
+var AgentNotFoundError = class extends OwneyError {
+  constructor(agentId, available) {
+    super(
+      "AGENT_NOT_FOUND",
+      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+      { agentId, available },
+      agentId
+    );
+    this.name = "AgentNotFoundError";
+  }
+};
+var NotConnectedError = class extends OwneyError {
+  constructor() {
+    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
+  }
+};
+var AgentChainIncompatibleError = class extends OwneyError {
+  incompatibleAgents;
+  connectedChainId;
+  constructor(incompatibleAgents, connectedChainId) {
+    const details = incompatibleAgents.map(
+      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+    ).join("; ");
+    super(
+      "AGENT_CHAIN_INCOMPATIBLE",
+      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+      { incompatibleAgents, connectedChainId }
+    );
+    this.name = "AgentChainIncompatibleError";
+    this.incompatibleAgents = incompatibleAgents;
+    this.connectedChainId = connectedChainId;
+  }
+};
+
 // src/lib/utils.ts
 var isValidChainId = (chainId) => {
   if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
@@ -53,8 +119,7 @@ var isValidChainId = (chainId) => {
 function hexToDecimal(hex, decimals = 6) {
   const normalized = hex.startsWith("0x") || hex.startsWith("0X") ? hex : `0x${hex}`;
   const parsed = BigInt(normalized);
-  if (decimals <= 0)
-    return Number(parsed);
+  if (decimals <= 0) return Number(parsed);
   const divisor = BigInt(10 ** decimals);
   const whole = parsed / divisor;
   const remainder = parsed % divisor;
@@ -67,6 +132,20 @@ var DayFilterMapping = {
 };
 
 // src/agents/zyfai/zyfai.mapper.ts
+var DECIMALS_BY_SYMBOL = {
+  usdc: 6,
+  usdt: 6,
+  weth: 18,
+  eth: 18,
+  cbeth: 18,
+  wbtc: 8,
+  cbbtc: 8
+};
+function tokenDecimals(symbol, explicit) {
+  if (typeof explicit === "number" && Number.isFinite(explicit))
+    return explicit;
+  return DECIMALS_BY_SYMBOL[(symbol ?? "").toLowerCase()] ?? 6;
+}
 function mapDeposit(raw) {
   return {
     txHash: raw.txHash,
@@ -83,7 +162,8 @@ function mapWithdraw(raw) {
 }
 var CHAIN_ID_TO_NAME = {
   8453: "BASE",
-  42161: "ARBITRUM"
+  42161: "ARBITRUM",
+  1: "ETHEREUM"
 };
 var NAME_TO_CHAIN_ID = Object.entries(
   CHAIN_ID_TO_NAME
@@ -93,54 +173,52 @@ var NAME_TO_CHAIN_ID = Object.entries(
 }, {});
 function resolveChainId(chain) {
   const asNum = Number(chain);
-  if (Number.isFinite(asNum) && asNum > 0)
-    return asNum;
+  if (Number.isFinite(asNum) && asNum > 0) return asNum;
   return NAME_TO_CHAIN_ID[chain.trim().toLowerCase()] ?? NaN;
 }
 function mapBalances(raw, _chainId, smartWallet) {
   const portfolio = raw.portfolio;
   const portfolioByChain = portfolio.portfolioByChain ?? {};
-  const rawPositions = portfolio.positions ?? [];
-  const detailByKey = /* @__PURE__ */ new Map();
-  for (const p of rawPositions) {
-    const cid = resolveChainId(p.chain ?? "");
-    const symbol = (p.token_symbol ?? "").toUpperCase();
-    if (Number.isFinite(cid) && symbol)
-      detailByKey.set(`${cid}:${symbol}`, p);
-  }
   let totalBalance = 0;
   const tokens = [];
-  const positions = [];
   for (const [chainIdKey, tokensBySymbol] of Object.entries(portfolioByChain)) {
     const positionChainId = Number(chainIdKey);
-    const chainName = CHAIN_ID_TO_NAME[positionChainId] ?? "BASE";
     for (const [symbol, { balance, decimals }] of Object.entries(
       tokensBySymbol ?? {}
     )) {
       const amount = hexToDecimal(balance || "0", decimals);
       totalBalance += amount;
       tokens.push({
-        chain: chainName,
+        chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
         chainId: positionChainId,
         asset: symbol,
         amount: String(amount)
       });
-      const detail = detailByKey.get(`${positionChainId}:${symbol.toUpperCase()}`);
-      positions.push({
-        chain: chainName,
-        protocol: detail?.protocol_name ?? detail?.protocol_id ?? "",
-        protocolId: detail?.protocol_id,
-        pool: detail?.pool,
-        asset: symbol,
-        amount: String(amount),
-        apy: detail?.pool_apy,
-        tvl: detail?.pool_tvl,
-        // PositionSlot has no `liquidity` field yet; Zyfai will add it. Narrow
-        // structural read keeps it undefined today and auto-populates later.
-        liquidity: detail?.liquidity
-      });
     }
   }
+  const positions = (portfolio.positions ?? []).map((p) => ({
+    chain: p.chain ?? "",
+    protocol: p.protocol_name ?? p.protocol_id ?? "",
+    protocolId: p.protocol_id,
+    pool: p.pool,
+    asset: p.token_symbol ?? "",
+    // Position amount is hex-encoded base units (like the token balances
+    // above). `PositionSlot` doesn't type a `decimals` field, but runtime
+    // getBalances payloads often carry one (e.g. 18 for WETH) — prefer that
+    // when present, otherwise fall back to the per-symbol lookup so
+    // non-6-decimal assets like WETH don't render 1e12 too large.
+    amount: String(
+      hexToDecimal(
+        p.amount || "0",
+        tokenDecimals(p.token_symbol, p.decimals)
+      )
+    ),
+    apy: p.pool_apy,
+    tvl: p.pool_tvl,
+    // PositionSlot has no `liquidity` field yet; Zyfai will add it. Narrow
+    // structural read keeps it undefined today and auto-populates later.
+    liquidity: p.liquidity
+  }));
   return {
     smartWallet,
     totalBalance: String(totalBalance),
@@ -179,41 +257,39 @@ function mapEarnings(raw, smartWallet) {
   };
 }
 function mapWeightedApyByChain(raw) {
-  if (!raw)
-    return void 0;
+  if (!raw) return void 0;
   const out = {};
   for (const [chainKey, tokenApy] of Object.entries(raw)) {
     const chainId = Number(chainKey);
-    if (!SUPPORTED_CHAIN_IDS.includes(chainId))
-      continue;
+    if (!SUPPORTED_CHAIN_IDS.includes(chainId)) continue;
     const perAsset = {};
     for (const [symbol, apy] of Object.entries(tokenApy)) {
       const token = symbol;
-      if (!SUPPORTED_TOKENS.includes(token))
-        continue;
+      if (!SUPPORTED_TOKENS.includes(token)) continue;
       perAsset[token] = apy;
     }
-    if (Object.keys(perAsset).length > 0)
-      out[chainId] = perAsset;
+    if (Object.keys(perAsset).length > 0) out[chainId] = perAsset;
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
-function rawPoolApyForChain(entry, chainId) {
+function rawPoolApyForChain(entry, chainId, tokenSymbol) {
   let weightedSum = 0;
   let totalBalance = 0;
   for (const p of entry.positions ?? []) {
-    if (p.chainId !== chainId)
-      continue;
+    if (p.chainId !== chainId) continue;
+    if (tokenSymbol && p.tokenSymbol !== tokenSymbol) continue;
     const balance = p.balance ?? 0;
-    if (balance <= 0 || typeof p.apy !== "number")
-      continue;
+    if (balance <= 0 || typeof p.apy !== "number") continue;
     weightedSum += p.apy * balance;
     totalBalance += balance;
   }
   return totalBalance > 0 ? weightedSum / totalBalance : null;
 }
-function mapApyHistory(raw, chainId) {
-  const history = Object.entries(raw.history ?? {}).map(([date, entry]) => ({ date, apy: rawPoolApyForChain(entry, chainId) })).filter((p) => p.apy !== null).sort((a, b) => a.date.localeCompare(b.date));
+function mapApyHistory(raw, chainId, tokenSymbol) {
+  const history = Object.entries(raw.history ?? {}).map(([date, entry]) => ({
+    date,
+    apy: rawPoolApyForChain(entry, chainId, tokenSymbol)
+  })).filter((p) => p.apy !== null).sort((a, b) => a.date.localeCompare(b.date));
   return {
     walletAddress: raw.walletAddress,
     weightedApyAfterFee: raw.weightedApyAfterFee ? sumTokenValues(raw.weightedApyAfterFee) : void 0,
@@ -236,6 +312,7 @@ function mapEntries(rawEntries, chainId) {
     "Withdraw from protocol": "Withdraw",
     Rebalance: "Rebalance"
   };
+  void chainId;
   return rawEntries.map((entry) => {
     const rawLog = entry.rebalanceLog;
     const positions = entry.positions ?? [];
@@ -257,7 +334,15 @@ function mapEntries(rawEntries, chainId) {
           fromPool: from.pool,
           toPool: to.pool,
           tokenSymbol: matched?.token_symbol ?? "",
-          amount: matched ? String(hexToDecimal(matched.amount || "0x")) : "",
+          amount: matched ? String(
+            hexToDecimal(
+              matched.amount || "0x",
+              tokenDecimals(
+                matched.token_symbol,
+                matched.decimals
+              )
+            )
+          ) : "",
           status: "success"
         }
       ];
@@ -276,7 +361,12 @@ function mapEntries(rawEntries, chainId) {
           txHashes: entry.transactionHash ? [entry.transactionHash] : [],
           chainId: entry.chainId,
           tokenSymbol: entry?.positions?.[0]?.token_symbol,
-          amount: hasAmount ? String(hexToDecimal(rawAmount)) : void 0
+          amount: hasAmount ? String(
+            hexToDecimal(
+              rawAmount,
+              tokenDecimals(entry?.positions?.[0]?.token_symbol)
+            )
+          ) : void 0
         }
       ],
       rebalanceLog
@@ -301,8 +391,7 @@ function mapApyByStrategy(raw) {
     const supported = SupportedAssets.find(
       (asset) => asset.chainId === entry.chain_id && asset.symbol === entry.token_symbol
     );
-    if (!supported)
-      continue;
+    if (!supported) continue;
     const chainKey = supported.chainId;
     const symbolKey = supported.symbol;
     const bucket = apyPerAsset[chainKey] ?? {};
@@ -332,10 +421,8 @@ function computeAllocationApy(positions) {
     totalValue += value;
     const chainId = resolveChainId(p.chain);
     const token = p.asset;
-    if (!SUPPORTED_CHAIN_IDS.includes(chainId))
-      continue;
-    if (!SUPPORTED_TOKENS.includes(token))
-      continue;
+    if (!SUPPORTED_CHAIN_IDS.includes(chainId)) continue;
+    if (!SUPPORTED_TOKENS.includes(token)) continue;
     const perAsset = buckets[chainId] ?? {};
     const cell = perAsset[token] ?? { weightedSum: 0, value: 0 };
     cell.weightedSum += apy * value;
@@ -352,8 +439,7 @@ function computeAllocationApy(positions) {
         out[token] = cell.weightedSum / cell.value;
       }
     }
-    if (Object.keys(out).length > 0)
-      apyByChainAndAsset[chainId] = out;
+    if (Object.keys(out).length > 0) apyByChainAndAsset[chainId] = out;
   }
   const totalApy = totalValue > 0 ? String(weightedSum / totalValue) : "0";
   return { totalApy, apyByChainAndAsset };
@@ -370,19 +456,14 @@ function extractWithdrawnAmount(logs, recipient, token, decimals) {
   let total = 0n;
   let matched = false;
   for (const log of logs) {
-    if (log.address.toLowerCase() !== wantToken)
-      continue;
-    if ((log.topics[0] ?? "").toLowerCase() !== TRANSFER_TOPIC)
-      continue;
-    if (topicToAddress(log.topics[2]) !== wantRecipient)
-      continue;
-    if (!log.data || log.data === "0x")
-      continue;
+    if (log.address.toLowerCase() !== wantToken) continue;
+    if ((log.topics[0] ?? "").toLowerCase() !== TRANSFER_TOPIC) continue;
+    if (topicToAddress(log.topics[2]) !== wantRecipient) continue;
+    if (!log.data || log.data === "0x") continue;
     total += BigInt(log.data);
     matched = true;
   }
-  if (!matched)
-    return void 0;
+  if (!matched) return void 0;
   return String(hexToDecimal(`0x${total.toString(16)}`, decimals));
 }
 
@@ -398,8 +479,7 @@ function encodeHistoryCursor(payload) {
   return Buffer.from(JSON.stringify(payload), "utf8").toString("base64");
 }
 function decodeHistoryCursor(token) {
-  if (!token)
-    throw new InvalidHistoryCursorError("Cursor is empty.");
+  if (!token) throw new InvalidHistoryCursorError("Cursor is empty.");
   let parsed;
   try {
     const json = Buffer.from(token, "base64").toString("utf8");
@@ -416,8 +496,7 @@ function decodeHistoryCursor(token) {
 // src/agents/zyfai/zyfai.auth-cache.ts
 var KEY_PREFIX = "owney.zyfai.session";
 var storage = () => {
-  if (typeof window === "undefined")
-    return null;
+  if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
   } catch {
@@ -427,15 +506,13 @@ var storage = () => {
 var buildKey = (address, chainId) => `${KEY_PREFIX}:${address.toLowerCase()}:${chainId}`;
 var isJwtExpired = (token) => {
   const parts = token.split(".");
-  if (parts.length !== 3)
-    return false;
+  if (parts.length !== 3) return false;
   try {
     const payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
     const padded = payload + "=".repeat((4 - payload.length % 4) % 4);
     const decoded = typeof atob === "function" ? atob(padded) : Buffer.from(padded, "base64").toString("utf8");
     const claims = JSON.parse(decoded);
-    if (typeof claims.exp !== "number")
-      return false;
+    if (typeof claims.exp !== "number") return false;
     return Date.now() / 1e3 >= claims.exp - 30;
   } catch {
     return false;
@@ -443,11 +520,9 @@ var isJwtExpired = (token) => {
 };
 var readSession = (address, chainId) => {
   const store = storage();
-  if (!store)
-    return null;
+  if (!store) return null;
   const raw = store.getItem(buildKey(address, chainId));
-  if (!raw)
-    return null;
+  if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
     if (!parsed.token || isJwtExpired(parsed.token)) {
@@ -462,8 +537,7 @@ var readSession = (address, chainId) => {
 };
 var writeSession = (address, chainId, session) => {
   const store = storage();
-  if (!store)
-    return;
+  if (!store) return;
   try {
     store.setItem(buildKey(address, chainId), JSON.stringify(session));
   } catch {
@@ -471,33 +545,67 @@ var writeSession = (address, chainId, session) => {
 };
 var clearSession = (address, chainId) => {
   const store = storage();
-  if (!store)
-    return;
+  if (!store) return;
   try {
     store.removeItem(buildKey(address, chainId));
   } catch {
   }
 };
 
+// src/agents/zyfai/autoSelect.ts
+function buildAutoSelectUpdate(current, asset) {
+  if (current.autoSelectProtocols === true) return null;
+  return {
+    asset,
+    autoSelectProtocols: true,
+    ...current.chains ? { chains: current.chains } : {}
+  };
+}
+
 // src/agents/zyfai/zyfai.agent.ts
 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"
+  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",
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 };
-var VIEM_CHAIN = { 8453: base, 42161: arbitrum };
+var VIEM_CHAIN = { 8453: base, 42161: arbitrum, 1: mainnet };
 var ZyfaiAgent = class {
   id = "zyfai";
-  supportedChainIds = [8453, 42161];
+  supportedChainIds = [8453, 42161, 1];
   supportedAssets = [
     {
       chainId: 8453,
       chain: "BASE",
-      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
+      assets: [
+        { symbol: "USDC", minDepositAmount: "1500000" },
+        { symbol: "WETH", minDepositAmount: "500000000000000" }
+      ]
     },
     {
       chainId: 42161,
       chain: "ARBITRUM",
-      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
+      assets: [
+        { symbol: "USDC", minDepositAmount: "1500000" },
+        { symbol: "WETH", minDepositAmount: "500000000000000" }
+      ]
+    },
+    {
+      chainId: 1,
+      chain: "ETHEREUM",
+      // Zyfai enforces per-asset minimum portfolios on Ethereum mainnet, keyed
+      // by MIN_PORTFOLIO_BALANCE[1] in @zyfai/sdk. Lowered in @zyfai/sdk@0.2.40.
+      // USDC: 100 (100 * 1e6). WETH: 0.005 (5 * 1e15).
+      // NOTE: the @zyfai/sdk README claims WETH has no minimum — that's stale;
+      // the shipped code enforces 0.005 WETH, so match it or deposits reject on-chain.
+      assets: [
+        { symbol: "USDC", minDepositAmount: "100000000" },
+        { symbol: "WETH", minDepositAmount: "5000000000000000" }
+      ]
     }
   ];
   sdk;
@@ -521,8 +629,7 @@ var ZyfaiAgent = class {
   }
   getPublicClient(chainId) {
     const cached = this.publicClients.get(chainId);
-    if (cached)
-      return cached;
+    if (cached) return cached;
     const client = createPublicClient({
       chain: VIEM_CHAIN[chainId],
       transport: http(this.rpcUrls[chainId])
@@ -532,33 +639,43 @@ var ZyfaiAgent = class {
   }
   /**
    * Fills in the true withdrawn amount for `Withdraw` entries by decoding the
-   * USDC `Transfer` that lands in the user's wallet on-chain. The Zyfai history
+   * on-chain `Transfer` that lands in the user's wallet. The Zyfai history
    * payload only reports the *remaining* position for a partial withdraw (see
    * the note in `mapEntries`), so without this the UI shows the leftover
    * balance instead of the amount withdrawn.
    *
+   * The withdrawn asset varies per entry (USDC or WETH), so it's resolved
+   * from `tx.tokenSymbol` (set by `mapEntries` from the entry's own
+   * position) rather than assumed to always be USDC. Zyfai sometimes
+   * denominates WETH as lowercase "eth" — that's normalized to WETH.
+   * Entries with no symbol (older payload shapes) fall back to USDC to
+   * preserve prior behavior.
+   *
    * Mutates `entries` in place. Runs all lookups concurrently and is tolerant
    * of RPC failures: an entry whose amount can't be resolved keeps
    * `amount: undefined`, which consumers render as a hidden/retryable row
    * rather than a wrong number.
    */
   async resolveWithdrawnAmounts(entries, chainId, recipient) {
-    const asset = SupportedAssets.find(
-      (a) => a.chainId === chainId && a.symbol === "USDC"
-    );
-    if (!asset)
-      return;
     const withdrawals = entries.filter(
       (e) => e.action === "Withdraw" && e.transactions[0]?.txHashes[0]
     );
-    if (withdrawals.length === 0)
-      return;
+    if (withdrawals.length === 0) return;
     const client = this.getPublicClient(chainId);
     await Promise.all(
       withdrawals.map(async (entry) => {
         const tx = entry.transactions[0];
         const txHash = tx.txHashes[0];
-        const cached = this.withdrawAmountCache.get(txHash);
+        const rawSymbol = tx.tokenSymbol;
+        const normalizedSymbol = rawSymbol ? rawSymbol.toLowerCase() === "eth" ? "WETH" : rawSymbol.toUpperCase() : "USDC";
+        const asset = SupportedAssets.find(
+          (a) => a.chainId === chainId && a.symbol === normalizedSymbol
+        ) ?? SupportedAssets.find(
+          (a) => a.chainId === chainId && a.symbol === "USDC"
+        );
+        if (!asset) return;
+        const cacheKey = `${txHash}:${asset.address}`;
+        const cached = this.withdrawAmountCache.get(cacheKey);
         if (cached !== void 0) {
           tx.amount = cached;
           return;
@@ -574,7 +691,7 @@ var ZyfaiAgent = class {
             asset.decimals
           );
           if (amount !== void 0) {
-            this.withdrawAmountCache.set(txHash, amount);
+            this.withdrawAmountCache.set(cacheKey, amount);
             tx.amount = amount;
           }
         } catch {
@@ -593,13 +710,11 @@ var ZyfaiAgent = class {
    * for some apps and the patch only matters in the browser anyway.
    */
   installAuthCache() {
-    if (typeof window === "undefined")
-      return;
+    if (typeof window === "undefined") return;
     const internals = this.sdk;
     const original = internals.authenticateUser.bind(internals);
     internals.authenticateUser = async () => {
-      if (internals.authenticatedUserId !== null)
-        return;
+      if (internals.authenticatedUserId !== null) return;
       const address = internals.walletClient?.account?.address;
       const chainId = internals.currentChainId;
       if (address && chainId) {
@@ -674,12 +789,10 @@ var ZyfaiAgent = class {
       return await this.sdk.connectAccount(provider, chainId);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (!message.toLowerCase().includes("unauthorized"))
-        throw error;
+      if (!message.toLowerCase().includes("unauthorized")) throw error;
       const internals = this.sdk;
       const address = internals.walletClient?.account?.address;
-      if (address)
-        clearSession(address, chainId);
+      if (address) clearSession(address, chainId);
       return await this.sdk.connectAccount(provider, chainId);
     }
   }
@@ -692,6 +805,22 @@ var ZyfaiAgent = class {
     this.smartWalletCache.set(`${address}_${validChainId}`, wallet.address);
     if (!wallet.isDeployed) {
       await this.sdk.deploySafe(address, validChainId, "aggressive", true);
+      try {
+        if (validChainId === 42161) {
+          await this.sdk.updateUserProfile({
+            asset: "WETH",
+            chains: [validChainId],
+            protocols: ["c24a33fa-4a87-4376-b756-93bd3957d3ea"],
+            // AAVE protocol ID
+            autoSelectProtocols: false
+          });
+        }
+      } catch (err) {
+        console.warn(
+          "Failed to configure AAVE protocol after Safe deployment:",
+          err instanceof Error ? err.message : String(err)
+        );
+      }
     }
     const user = await this.sdk.getUserDetails();
     if (!user.hasActiveSessionKey) {
@@ -733,7 +862,7 @@ var ZyfaiAgent = class {
       throw error;
     }
   }
-  async deposit(state, chainId, amount, depositCallback) {
+  async deposit(state, chainId, amount, asset, depositCallback) {
     try {
       await this.connectFull(state, chainId);
       const validChainId = isValidChainId(chainId);
@@ -747,13 +876,15 @@ var ZyfaiAgent = class {
           validChainId,
           amount
         );
-        await this.sdk.logDeposit(validChainId, txHash, amount);
+        const tokenAddress = asset === "WETH" ? WETH_ADDRESS_BY_CHAIN[validChainId] : void 0;
+        await (tokenAddress ? this.sdk.logDeposit(validChainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(validChainId, txHash, amount));
         return { txHash, smartWallet: wallet.address, amount };
       }
       const raw = await this.sdk.depositFunds(
         this.getAddress(),
         validChainId,
-        amount
+        amount,
+        asset
       );
       return mapDeposit(raw);
     } catch (error) {
@@ -791,10 +922,10 @@ var ZyfaiAgent = class {
     const raw = await this.sdk.getOnchainEarnings(smartWallet);
     return mapEarnings(raw, smartWallet);
   }
-  async getAccountApy(state, chainId, days) {
+  async getAccountApy(state, chainId, days, tokenSymbol) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
     const raw = await this.sdk.getDailyApyHistory(smartWallet, days);
-    return mapApyHistory(raw, chainId);
+    return mapApyHistory(raw, chainId, tokenSymbol);
   }
   async getHistory(state, chainId, options) {
     const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
@@ -849,6 +980,20 @@ var ZyfaiAgent = class {
     }
     return mapUserProfile(raw, this.connectedAddress);
   }
+  async ensureAutoSelectProtocols(state, chainId, asset) {
+    await this.connectAuth(state, chainId);
+    const current = await this.sdk.getUserDetails(asset);
+    const update = buildAutoSelectUpdate(
+      {
+        autoSelectProtocols: current.autoSelectProtocols,
+        chains: current.chains
+      },
+      asset
+    );
+    if (!update) return false;
+    await this.sdk.updateUserProfile(update);
+    return true;
+  }
   // --- IAgent: Discovery (no wallet required) ---
   async getAgentApy(days, options) {
     const raw = await this.sdk.getAPYPerStrategy(
@@ -934,8 +1079,7 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
     const tokenBalance = agentBalance?.tokens.find(
       (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
-    if (!tokenBalance)
-      return { agent, balance: 0n };
+    if (!tokenBalance) return { agent, balance: 0n };
     return { agent, balance: parseUnits(tokenBalance.amount, decimals) };
   });
 }
@@ -952,11 +1096,9 @@ function planProportionalShares(balances, requested, totalAvailable) {
     return diff > 0n ? 1 : diff < 0n ? -1 : 0;
   });
   for (const p of byHeadroom) {
-    if (remainder === 0n)
-      break;
+    if (remainder === 0n) break;
     const headroom = p.balance - p.planned;
-    if (headroom <= 0n)
-      continue;
+    if (headroom <= 0n) continue;
     const take = headroom < remainder ? headroom : remainder;
     p.planned += take;
     remainder -= take;
@@ -985,8 +1127,7 @@ function redistributeShare(plans, fromIndex, amount, candidatePool) {
     (s, c) => s + (c.balance - c.planned),
     0n
   );
-  if (totalHeadroom === 0n)
-    return;
+  if (totalHeadroom === 0n) return;
   let distributed = 0n;
   for (const c of candidates) {
     const headroom = c.balance - c.planned;
@@ -997,11 +1138,9 @@ function redistributeShare(plans, fromIndex, amount, candidatePool) {
   }
   let leftover = amount - distributed;
   for (const c of candidates) {
-    if (leftover === 0n)
-      break;
+    if (leftover === 0n) break;
     const headroom = c.balance - c.planned;
-    if (headroom <= 0n)
-      continue;
+    if (headroom <= 0n) continue;
     const take = headroom < leftover ? headroom : leftover;
     c.planned += take;
     leftover -= take;
@@ -1018,16 +1157,13 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
   for (const id of Object.keys(agentApys)) {
     const cells = agentApys[id].apyByChainAndAsset;
     const balance = agentBalances[id] ?? 0;
-    if (!cells || balance <= 0)
-      continue;
+    if (!cells || balance <= 0) continue;
     for (const [chainKey, perAsset] of Object.entries(cells)) {
-      if (!perAsset)
-        continue;
+      if (!perAsset) continue;
       const chainId = Number(chainKey);
       for (const [asset, apyValue] of Object.entries(perAsset)) {
         const apy = Number(apyValue ?? 0);
-        if (apy === 0)
-          continue;
+        if (apy === 0) continue;
         sums[chainId] ??= {};
         weights[chainId] ??= {};
         sums[chainId][asset] = (sums[chainId][asset] ?? 0) + apy * balance;
@@ -1041,8 +1177,7 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
     const perAssetOut = {};
     for (const asset of Object.keys(sums[chainId])) {
       const w = weights[chainId][asset];
-      if (w > 0)
-        perAssetOut[asset] = sums[chainId][asset] / w;
+      if (w > 0) perAssetOut[asset] = sums[chainId][asset] / w;
     }
     if (Object.keys(perAssetOut).length > 0) {
       out[chainId] = perAssetOut;
@@ -1057,7 +1192,7 @@ import {
   createWalletClient,
   custom
 } from "viem";
-import { base as base2, arbitrum as arbitrum2 } from "viem/chains";
+import { base as base2, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
 
 // src/lib/transfer-auth.ts
 import { bytesToHex } from "viem";
@@ -1103,7 +1238,10 @@ async function postSponsorTransferAuth(input) {
   try {
     res = await fetch(`${base3}/api/v1/sponsor/erc20-transfer-auth`, {
       method: "POST",
-      headers: { "content-type": "application/json", "x-owney-api-key": input.apiKey },
+      headers: {
+        "content-type": "application/json",
+        "x-owney-api-key": input.apiKey
+      },
       body: JSON.stringify(input.body)
     });
   } catch (networkError) {
@@ -1123,11 +1261,91 @@ async function postSponsorTransferAuth(input) {
     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) }
+      {
+        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;
+}
 
 // src/lib/sponsored-deposit.ts
 var AUTH_WINDOW_SECONDS = 15 * 60;
@@ -1179,6 +1397,114 @@ function makeSponsoredDepositCallback(deps) {
   };
 }
 
+// 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" }]
+  }
+];
+function buildPermitTransferFromTypedData(input) {
+  return {
+    domain: { name: "Permit2", chainId: input.chainId, verifyingContract: PERMIT2_ADDRESS },
+    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
+  };
+}
+function randomPermit2Nonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return BigInt(bytesToHex2(bytes));
+}
+async function readPermit2Allowance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "allowance",
+    args: [owner, PERMIT2_ADDRESS]
+  });
+}
+
+// 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}`);
+    }
+    const amountWei = BigInt(amount);
+    const pub = deps.getPublicClient(cid);
+    const allowance = await readPermit2Allowance(pub, token, deps.ownerAddress);
+    if (allowance < amountWei) {
+      throw new OwneyError(
+        "PERMIT2_APPROVAL_REQUIRED",
+        "WETH gasless deposits need a one-time Permit2 approval; call approvePermit2() first",
+        { token, chainId: cid, allowance: allowance.toString(), amount }
+      );
+    }
+    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 wallet = deps.getWalletClient(cid);
+    const signature = await wallet.signTypedData(
+      { account: deps.ownerAddress, ...typedData }
+    );
+    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/client.ts
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
@@ -1202,13 +1528,22 @@ function decodeMultiAgentCursor(token) {
 }
 var SPONSORED_USDC_BY_CHAIN = {
   8453: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831"
+  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+  1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
   8453: base2,
-  42161: arbitrum2
+  42161: arbitrum2,
+  1: mainnet2
+};
+var SPONSORED_WETH_BY_CHAIN = {
+  8453: "0x4200000000000000000000000000000000000006",
+  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 };
-var AGENT_ELIGIBILITY_ORDER = ["surfliquid", "zyfai", "sail"];
+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;
+}
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
@@ -1221,11 +1556,14 @@ var OwneySDK = class {
   state = null;
   apiKey;
   zyfaiRpcUrls;
+  routingApiBaseUrl;
   cachedSponsoredCallback = null;
+  cachedWethSponsoredCallback = null;
   initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.zyfaiRpcUrls = config.zyfaiRpcUrls;
+    this.routingApiBaseUrl = config.routingApiBaseUrl;
   }
   /**
    * Establish connection state for all subsequent SDK calls.
@@ -1246,6 +1584,7 @@ var OwneySDK = class {
     }
     this.state = { provider, walletAddress, chainId: null };
     this.cachedSponsoredCallback = null;
+    this.cachedWethSponsoredCallback = null;
   }
   /**
    * Disconnect from all agents and clear connection state.
@@ -1259,6 +1598,7 @@ var OwneySDK = class {
     this.disabledAgents.clear();
     this.state = null;
     this.cachedSponsoredCallback = null;
+    this.cachedWethSponsoredCallback = null;
   }
   isAgentDisabled(agentId) {
     return this.disabledAgents.has(agentId);
@@ -1278,8 +1618,7 @@ var OwneySDK = class {
     return this.state?.chainId ?? null;
   }
   requireState() {
-    if (!this.state)
-      throw new NotConnectedError();
+    if (!this.state) throw new NotConnectedError();
     return this.state;
   }
   requireChainId() {
@@ -1309,12 +1648,12 @@ var OwneySDK = class {
    * `TransferWithAuthorization`, then POSTs to the sponsor API.
    */
   getDefaultSponsoredCallback() {
-    if (this.cachedSponsoredCallback)
-      return this.cachedSponsoredCallback;
+    if (this.cachedSponsoredCallback) return this.cachedSponsoredCallback;
     const provider = this.requireConnectedProvider();
     const owner = this.state.walletAddress;
     this.cachedSponsoredCallback = makeSponsoredDepositCallback({
       apiKey: this.apiKey,
+      baseUrl: this.routingApiBaseUrl,
       ownerAddress: owner,
       tokenAddressByChain: SPONSORED_USDC_BY_CHAIN,
       // Casts work around viem's chain-narrowed Client vs the generic
@@ -1332,6 +1671,37 @@ var OwneySDK = class {
     });
     return this.cachedSponsoredCallback;
   }
+  /**
+   * 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.
+   */
+  getDefaultWethSponsoredCallback() {
+    if (this.cachedWethSponsoredCallback)
+      return this.cachedWethSponsoredCallback;
+    const provider = this.requireConnectedProvider();
+    const owner = this.state.walletAddress;
+    this.cachedWethSponsoredCallback = makeSponsoredWethCallback({
+      apiKey: this.apiKey,
+      baseUrl: this.routingApiBaseUrl,
+      ownerAddress: owner,
+      tokenAddressByChain: SPONSORED_WETH_BY_CHAIN,
+      // 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) => createPublicClient2({
+        chain: VIEM_CHAIN2[cid],
+        transport: custom(provider)
+      }),
+      getWalletClient: (cid) => createWalletClient({
+        account: owner,
+        chain: VIEM_CHAIN2[cid],
+        transport: custom(provider)
+      })
+    });
+    return this.cachedWethSponsoredCallback;
+  }
   getAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -1343,22 +1713,19 @@ var OwneySDK = class {
     const active = /* @__PURE__ */ new Map();
     for (const id of this.activeAgents) {
       const agent = this.agents.get(id);
-      if (agent)
-        active.set(id, agent);
+      if (agent) active.set(id, agent);
     }
     return active;
   }
   async ensureAgentsInitialized() {
-    if (this.agents.size > 0)
-      return;
+    if (this.agents.size > 0) return;
     if (!this.initializingAgentsPromise) {
       this.initializingAgentsPromise = (async () => {
         const agentKeys = await fetchAgentKeys(this.apiKey);
         this.disabledAgents.clear();
-        for (const { key, agent_type, project_name, is_enabled } of agentKeys) {
-          const agent = await this.createAgent(agent_type, key, project_name);
-          if (!agent)
-            continue;
+        for (const { key, agent_type, is_enabled } of agentKeys) {
+          const agent = this.createAgent(agent_type, key);
+          if (!agent) continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
             this.disabledAgents.add(agent_type);
@@ -1378,16 +1745,10 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  async createAgent(agentId, key, projectName) {
+  createAgent(agentId, key) {
     if (agentId === "zyfai") {
       return new ZyfaiAgent(key, this.zyfaiRpcUrls);
     }
-    if (agentId === "surfliquid") {
-      if (!projectName)
-        return null;
-      const { SurfLiquidAgent } = await import("./surfliquid.agent-EPFISJPR.js");
-      return new SurfLiquidAgent({ projectName, appId: key });
-    }
     return null;
   }
   // --- Account lifecycle ---
@@ -1491,7 +1852,7 @@ var OwneySDK = class {
     }
     const state = this.requireState();
     const chainId = this.requireChainId();
-    const effectiveCallback = depositCallback ?? this.getDefaultSponsoredCallback();
+    const effectiveCallback = depositCallback ?? (asset === "WETH" ? this.getDefaultWethSponsoredCallback() : this.getDefaultSponsoredCallback());
     if (agentId) {
       if (this.isAgentDisabled(agentId)) {
         throw new OwneyError(
@@ -1503,10 +1864,14 @@ var OwneySDK = class {
       const agent = this.getAgent(agentId);
       this.validateAssetSupport(agent, chainId, asset);
       await this.validateMinDepositAmount(agent, state, chainId, asset, amount);
-      return withFailureReporting(
-        this.apiKey,
-        agent.id,
-        () => agent.deposit(state, chainId, amount, effectiveCallback)
+      return this.depositWithFallback(
+        agent,
+        state,
+        chainId,
+        amount,
+        asset,
+        effectiveCallback,
+        depositCallback
       );
     }
     const totalAmount = BigInt(amount);
@@ -1536,26 +1901,77 @@ var OwneySDK = class {
       );
     }
     const agentResults = {};
-    const agentErrors = {};
     for (const { agent, amount: agentAmount } of agentAmounts) {
+      agentResults[agent.id] = await this.depositWithFallback(
+        agent,
+        state,
+        chainId,
+        agentAmount,
+        asset,
+        effectiveCallback,
+        depositCallback
+      );
+    }
+    return { agentResults };
+  }
+  /**
+   * Invokes `agent.deposit` with the resolved sponsored callback, composing
+   * two independent auto-recovery mechanisms:
+   *
+   * 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.
+   *    the user rejects the wallet prompt), that error propagates as-is —
+   *    the user said no to a transaction, so we must not turn around and ask
+   *    them to pay for a different one via the fallback below.
+   * 2. `shouldFallbackToUserPaid`: the SDK's own WETH sponsor path failed at
+   *    the infrastructure layer in a provably safe-to-retry way, so we warn
+   *    and retry once with `undefined`, falling through to a user-paid
+   *    native deposit. This still applies after a successful Permit2
+   *    approval retry (the retried sponsored attempt can itself hit a safe
+   *    sponsor failure).
+   *
+   * Any other error — an app-supplied callback's own failure in particular —
+   * propagates unchanged. Scoped per agent invocation so one agent's failure
+   * doesn't force a retry of sibling agents in a multi-agent split.
+   */
+  async depositWithFallback(agent, state, chainId, amount, asset, effectiveCallback, appCallback) {
+    const attempt = (callback) => withFailureReporting(
+      this.apiKey,
+      agent.id,
+      () => agent.deposit(
+        state,
+        chainId,
+        amount,
+        asset,
+        callback
+      )
+    );
+    let approvalAttempted = false;
+    for (; ; ) {
       try {
-        agentResults[agent.id] = await withFailureReporting(
-          this.apiKey,
-          agent.id,
-          () => agent.deposit(state, chainId, agentAmount, effectiveCallback)
-        );
+        return await attempt(effectiveCallback);
       } catch (error) {
-        agentErrors[agent.id] = error instanceof Error ? error.message : String(error);
+        if (!approvalAttempted && appCallback === void 0 && asset === "WETH" && error instanceof OwneyError && error.code === "PERMIT2_APPROVAL_REQUIRED") {
+          approvalAttempted = true;
+          console.warn(
+            "[owney-sdk] First WETH deposit: sending one-time Permit2 approval..."
+          );
+          await this.approvePermit2();
+          continue;
+        }
+        if (!shouldFallbackToUserPaid(error, asset, appCallback)) throw error;
+        console.warn(
+          `[owney-sdk] ${asset} sponsorship unavailable, falling back to user-paid deposit:`,
+          error
+        );
+        return attempt(void 0);
       }
     }
-    if (Object.keys(agentResults).length === 0) {
-      throw new OwneyError(
-        "DEPOSIT_ALL_FAILED",
-        `All ${agentAmounts.length} agent deposit(s) failed.`,
-        { agentErrors }
-      );
-    }
-    return Object.keys(agentErrors).length > 0 ? { agentResults, agentErrors } : { agentResults };
   }
   getMinDepositAmount(agent, chainId, asset) {
     const chainAssets = agent.supportedAssets.find(
@@ -1565,8 +1981,7 @@ var OwneySDK = class {
     return BigInt(assetEntry?.minDepositAmount ?? "0");
   }
   splitDepositAmount(totalAmount, agents, chainId, asset, exempt = /* @__PURE__ */ new Set()) {
-    if (agents.length === 0)
-      return [];
+    if (agents.length === 0) return [];
     const perAgent = totalAmount / BigInt(agents.length);
     const remainder = totalAmount % BigInt(agents.length);
     const splits = agents.map((agent, i) => ({
@@ -1590,10 +2005,8 @@ var OwneySDK = class {
   async validateMinDepositAmount(agent, state, chainId, asset, amount) {
     const minDepositAmount = this.getMinDepositAmount(agent, chainId, asset);
     const parsedAmount = BigInt(amount);
-    if (parsedAmount >= minDepositAmount)
-      return;
-    if (await this.hasExistingBalance(agent, state, chainId, asset))
-      return;
+    if (parsedAmount >= minDepositAmount) return;
+    if (await this.hasExistingBalance(agent, state, chainId, asset)) return;
     throw new OwneyError(
       "DEPOSIT_AMOUNT_BELOW_MINIMUM",
       `Amount "${amount}" is below the required minimum deposit "${minDepositAmount.toString()}" for agent "${agent.id}" on chain ${chainId} for asset "${asset}".`,
@@ -1656,34 +2069,6 @@ var OwneySDK = class {
     }
     return eligible;
   }
-  /**
-   * Agent ids the routing API provisioned for this org that support the given
-   * chain + asset, ordered by preference ({@link AGENT_ELIGIBILITY_ORDER},
-   * surfliquid first). Returns `[]` when the org has no compatible agent — never
-   * throws on an empty org. Loads agent keys on first call (apiKey only, no
-   * wallet), so the UI can resolve which agent to use before the user connects.
-   *
-   * This is the source of truth for agent availability: an agent appears here
-   * iff the routing API returned its key. No per-app feature flags.
-   */
-  async getEligibleAgentIds(chainId, asset) {
-    try {
-      await this.ensureAgentsInitialized();
-    } catch (error) {
-      if (error instanceof OwneyError && error.code === "API_NO_AGENTS") {
-        return [];
-      }
-      throw error;
-    }
-    return [...this.agents.values()].filter((agent) => {
-      const chainAssets = agent.supportedAssets.find(
-        (sa) => sa.chainId === chainId
-      );
-      return chainAssets?.assets.some((a) => a.symbol === asset) ?? false;
-    }).map((agent) => agent.id).sort(
-      (a, b) => AGENT_ELIGIBILITY_ORDER.indexOf(a) - AGENT_ELIGIBILITY_ORDER.indexOf(b)
-    );
-  }
   // --- Fund operations ---
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
@@ -1719,17 +2104,9 @@ var OwneySDK = class {
     }
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
     if (!amount) {
-      const aggregated2 = await this.getBalances();
-      const funded = projectAgentBalancesForAsset(
-        eligibleAgents,
-        aggregated2.agentBalances,
-        chainId,
-        asset,
-        assetInfo.decimals
-      ).filter((b) => b.balance > 0n);
       const results2 = {};
       const agentErrors2 = {};
-      for (const { agent } of funded) {
+      for (const agent of eligibleAgents) {
         try {
           results2[agent.id] = await agent.withdraw(state, chainId, token);
         } catch (err) {
@@ -1746,10 +2123,9 @@ var OwneySDK = class {
           { asset, agentErrors: agentErrors2 }
         );
       }
-      const totalWithdrawn = funded.filter(({ agent }) => results2[agent.id] !== void 0).reduce((sum, { balance }) => sum + balance, 0n);
       return {
         agentResult: results2,
-        totalWithdrawn: totalWithdrawn.toString()
+        totalWithdrawn: sumWithdrawnAmount(results2).toString()
       };
     }
     const requested = BigInt(amount);
@@ -1794,8 +2170,7 @@ var OwneySDK = class {
     const agentErrors = {};
     for (let i = 0; i < plans.length; i++) {
       const p = plans[i];
-      if (p.planned === 0n)
-        continue;
+      if (p.planned === 0n) continue;
       try {
         results[p.agent.id] = await p.agent.withdraw(
           state,
@@ -1929,19 +2304,30 @@ var OwneySDK = class {
    */
   async getAccountApy({
     agentId,
-    days
+    days,
+    tokenSymbol
   }) {
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      return this.getAgent(agentId).getAccountApy(state, chainId, days);
+      return this.getAgent(agentId).getAccountApy(
+        state,
+        chainId,
+        days,
+        tokenSymbol
+      );
     }
     const activeAgents = this.getActiveAgents();
     const entries = [...activeAgents.entries()];
     const [apyResults, balanceResults] = await Promise.all([
       Promise.all(
         entries.map(async ([id, agent]) => {
-          const apy = await agent.getAccountApy(state, chainId, days);
+          const apy = await agent.getAccountApy(
+            state,
+            chainId,
+            days,
+            tokenSymbol
+          );
           return [id, apy];
         })
       ),
@@ -1964,15 +2350,13 @@ var OwneySDK = class {
     let relevantBalance = 0;
     for (const id of Object.keys(results)) {
       const agentApy = Number(results[id].weightedApyAfterFee ?? 0);
-      if (agentApy === 0)
-        continue;
+      if (agentApy === 0) continue;
       relevantBalance += balances[id];
     }
     if (relevantBalance > 0) {
       for (const id of Object.keys(results)) {
         const agentApy = Number(results[id].weightedApyAfterFee ?? 0);
-        if (agentApy === 0)
-          continue;
+        if (agentApy === 0) continue;
         const weight = balances[id] / relevantBalance;
         totalApy += agentApy * weight;
       }
@@ -2027,8 +2411,7 @@ var OwneySDK = class {
     const nextCursorMap = {};
     let hasMore = false;
     for (const { agentId: id, page } of perAgent) {
-      if (!page)
-        continue;
+      if (!page) continue;
       merged.push(...page.data);
       if (page.hasMore && page.nextCursor) {
         nextCursorMap[id] = page.nextCursor;
@@ -2037,16 +2420,12 @@ var OwneySDK = class {
     }
     merged.sort((a, b) => {
       const dateDiff = new Date(b.date).getTime() - new Date(a.date).getTime();
-      if (dateDiff !== 0)
-        return dateDiff;
-      if (a.agent !== b.agent)
-        return a.agent < b.agent ? -1 : 1;
+      if (dateDiff !== 0) return dateDiff;
+      if (a.agent !== b.agent) return a.agent < b.agent ? -1 : 1;
       const aTx = a.transactions?.[0]?.txHashes?.[0] ?? "";
       const bTx = b.transactions?.[0]?.txHashes?.[0] ?? "";
-      if (aTx !== bTx)
-        return aTx < bTx ? -1 : 1;
-      if (a.action !== b.action)
-        return a.action < b.action ? -1 : 1;
+      if (aTx !== bTx) return aTx < bTx ? -1 : 1;
+      if (a.action !== b.action) return a.action < b.action ? -1 : 1;
       return 0;
     });
     return {
@@ -2081,6 +2460,67 @@ var OwneySDK = class {
       agentUserProfile: results
     };
   }
+  /**
+   * Ensure the given asset uses backend protocol auto-selection for the active
+   * chain's account. No-op (returns false) for agents that don't support it.
+   * @param asset - "USDC" or "WETH".
+   * @param agentId - Agent to target. Defaults to "zyfai".
+   * @returns whether a profile write occurred.
+   */
+  async ensureAutoSelectProtocols(asset, agentId = "zyfai") {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const agent = this.getAgent(agentId);
+    if (typeof agent.ensureAutoSelectProtocols !== "function") return false;
+    return agent.ensureAutoSelectProtocols(state, chainId, asset);
+  }
+  /**
+   * 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") {
+    void asset;
+    const state = this.requireState();
+    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 WETH on chain ${chainId}`
+      );
+    }
+    const provider = this.requireConnectedProvider();
+    const wallet = createWalletClient({
+      account: state.walletAddress,
+      chain: VIEM_CHAIN2[chainId],
+      transport: custom(provider)
+    });
+    const hash = await wallet.writeContract({
+      address: token,
+      abi: ERC20_ALLOWANCE_ABI,
+      functionName: "approve",
+      args: [PERMIT2_ADDRESS, MAX_UINT256],
+      account: state.walletAddress,
+      chain: VIEM_CHAIN2[chainId]
+    });
+    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})`);
+    }
+    return hash;
+  }
   // --- Discovery (no wallet required) ---
   /**
    * Get the agent's average APY performance over a time period. Does not require a wallet connection.
@@ -2186,8 +2626,7 @@ import { ZyfaiSDK as ZyfaiSDK2 } from "@zyfai/sdk";
 // src/agents/zyfai/zyfai.siwx-cache.ts
 var KEY_PREFIX2 = "owney.siwx.session";
 var storage2 = () => {
-  if (typeof window === "undefined")
-    return null;
+  if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
   } catch {
@@ -2197,11 +2636,9 @@ var storage2 = () => {
 var buildKey2 = (address, chainId) => `${KEY_PREFIX2}:${address.toLowerCase()}:${chainId}`;
 var readSiwxSession = (address, chainId) => {
   const store = storage2();
-  if (!store)
-    return null;
+  if (!store) return null;
   const raw = store.getItem(buildKey2(address, chainId));
-  if (!raw)
-    return null;
+  if (!raw) return null;
   try {
     return JSON.parse(raw);
   } catch {
@@ -2211,8 +2648,7 @@ var readSiwxSession = (address, chainId) => {
 };
 var writeSiwxSession = (address, chainId, session) => {
   const store = storage2();
-  if (!store)
-    return;
+  if (!store) return;
   try {
     store.setItem(buildKey2(address, chainId), JSON.stringify(session));
   } catch {
@@ -2220,8 +2656,7 @@ var writeSiwxSession = (address, chainId, session) => {
 };
 var clearSiwxSession = (address, chainId) => {
   const store = storage2();
-  if (!store)
-    return;
+  if (!store) return;
   try {
     store.removeItem(buildKey2(address, chainId));
   } catch {
@@ -2284,12 +2719,10 @@ function buildSIWXConfig(deps) {
     const jwt = readSession(address, id);
     const stored = readSiwxSession(address, id);
     if (!jwt) {
-      if (stored)
-        clearSiwxSession(address, id);
+      if (stored) clearSiwxSession(address, id);
       return [];
     }
-    if (!stored)
-      return [];
+    if (!stored) return [];
     const session = {
       // `stored.data.chainId` is a plain string in the cache (kept AppKit-free);
       // it always holds a valid CaipNetworkId here, so narrow at the boundary.