@owney/sdk 0.6.5 → 0.6.6-beta.1

package/dist/index.js

@@ -1,14 +1,21 @@
+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, mainnet } from "viem/chains";
+import { base, arbitrum } from "viem/chains";
 
 // src/types/config.ts
 var P_SUPPORTED_CHAINS = {
-  chainIds: [8453, 42161, 1],
-  chains: ["BASE", "ARBITRUM", "ETHEREUM"]
+  chainIds: [8453, 42161],
+  chains: ["BASE", "ARBITRUM"]
 };
-var SUPPORTED_TOKENS = ["USDC", "USDT", "WETH"];
+var SUPPORTED_TOKENS = ["USDC", "USDT"];
 var SUPPORTED_CHAIN_IDS = P_SUPPORTED_CHAINS.chainIds;
 var SUPPORTED_CHAINS = P_SUPPORTED_CHAINS.chains;
 var SupportedAssets = [
@@ -29,82 +36,9 @@ 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)) {
@@ -119,7 +53,8 @@ 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;
@@ -132,20 +67,6 @@ 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,
@@ -162,8 +83,7 @@ function mapWithdraw(raw) {
 }
 var CHAIN_ID_TO_NAME = {
   8453: "BASE",
-  42161: "ARBITRUM",
-  1: "ETHEREUM"
+  42161: "ARBITRUM"
 };
 var NAME_TO_CHAIN_ID = Object.entries(
   CHAIN_ID_TO_NAME
@@ -173,52 +93,54 @@ 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: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
+        chain: chainName,
         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),
@@ -257,39 +179,41 @@ 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, tokenSymbol) {
+function rawPoolApyForChain(entry, chainId) {
   let weightedSum = 0;
   let totalBalance = 0;
   for (const p of entry.positions ?? []) {
-    if (p.chainId !== chainId) continue;
-    if (tokenSymbol && p.tokenSymbol !== tokenSymbol) continue;
+    if (p.chainId !== chainId)
+      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, 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));
+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));
   return {
     walletAddress: raw.walletAddress,
     weightedApyAfterFee: raw.weightedApyAfterFee ? sumTokenValues(raw.weightedApyAfterFee) : void 0,
@@ -312,7 +236,6 @@ function mapEntries(rawEntries, chainId) {
     "Withdraw from protocol": "Withdraw",
     Rebalance: "Rebalance"
   };
-  void chainId;
   return rawEntries.map((entry) => {
     const rawLog = entry.rebalanceLog;
     const positions = entry.positions ?? [];
@@ -334,15 +257,7 @@ function mapEntries(rawEntries, chainId) {
           fromPool: from.pool,
           toPool: to.pool,
           tokenSymbol: matched?.token_symbol ?? "",
-          amount: matched ? String(
-            hexToDecimal(
-              matched.amount || "0x",
-              tokenDecimals(
-                matched.token_symbol,
-                matched.decimals
-              )
-            )
-          ) : "",
+          amount: matched ? String(hexToDecimal(matched.amount || "0x")) : "",
           status: "success"
         }
       ];
@@ -361,12 +276,7 @@ function mapEntries(rawEntries, chainId) {
           txHashes: entry.transactionHash ? [entry.transactionHash] : [],
           chainId: entry.chainId,
           tokenSymbol: entry?.positions?.[0]?.token_symbol,
-          amount: hasAmount ? String(
-            hexToDecimal(
-              rawAmount,
-              tokenDecimals(entry?.positions?.[0]?.token_symbol)
-            )
-          ) : void 0
+          amount: hasAmount ? String(hexToDecimal(rawAmount)) : void 0
         }
       ],
       rebalanceLog
@@ -391,7 +301,8 @@ 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] ?? {};
@@ -421,8 +332,10 @@ 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;
@@ -439,7 +352,8 @@ 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 };
@@ -456,14 +370,19 @@ 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));
 }
 
@@ -479,7 +398,8 @@ 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");
@@ -496,7 +416,8 @@ 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 {
@@ -506,13 +427,15 @@ 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;
@@ -520,9 +443,11 @@ 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)) {
@@ -537,7 +462,8 @@ 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 {
@@ -545,67 +471,33 @@ 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",
-  1: "https://eth-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
-};
-var WETH_ADDRESS_BY_CHAIN = {
-  8453: "0x4200000000000000000000000000000000000006",
-  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+  42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
 };
-var VIEM_CHAIN = { 8453: base, 42161: arbitrum, 1: mainnet };
+var VIEM_CHAIN = { 8453: base, 42161: arbitrum };
 var ZyfaiAgent = class {
   id = "zyfai";
-  supportedChainIds = [8453, 42161, 1];
+  supportedChainIds = [8453, 42161];
   supportedAssets = [
     {
       chainId: 8453,
       chain: "BASE",
-      assets: [
-        { symbol: "USDC", minDepositAmount: "1500000" },
-        { symbol: "WETH", minDepositAmount: "500000000000000" }
-      ]
+      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
     },
     {
       chainId: 42161,
       chain: "ARBITRUM",
-      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 (mainnet gas only pays off on
-      // large positions). USDC: 10,000 (10_000 * 1e6). WETH: 5 (5 * 1e18).
-      // NOTE: the @zyfai/sdk README claims WETH has no minimum — that's stale;
-      // the shipped code enforces 5 WETH, so match it or deposits reject on-chain.
-      assets: [
-        { symbol: "USDC", minDepositAmount: "10000000000" },
-        { symbol: "WETH", minDepositAmount: "5000000000000000000" }
-      ]
+      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
     }
   ];
   sdk;
@@ -629,7 +521,8 @@ 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])
@@ -639,43 +532,33 @@ var ZyfaiAgent = class {
   }
   /**
    * Fills in the true withdrawn amount for `Withdraw` entries by decoding the
-   * on-chain `Transfer` that lands in the user's wallet. The Zyfai history
+   * USDC `Transfer` that lands in the user's wallet on-chain. 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 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);
+        const cached = this.withdrawAmountCache.get(txHash);
         if (cached !== void 0) {
           tx.amount = cached;
           return;
@@ -691,7 +574,7 @@ var ZyfaiAgent = class {
             asset.decimals
           );
           if (amount !== void 0) {
-            this.withdrawAmountCache.set(cacheKey, amount);
+            this.withdrawAmountCache.set(txHash, amount);
             tx.amount = amount;
           }
         } catch {
@@ -710,11 +593,13 @@ 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) {
@@ -789,10 +674,12 @@ 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);
     }
   }
@@ -805,22 +692,6 @@ 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) {
@@ -862,7 +733,7 @@ var ZyfaiAgent = class {
       throw error;
     }
   }
-  async deposit(state, chainId, amount, asset, depositCallback) {
+  async deposit(state, chainId, amount, depositCallback) {
     try {
       await this.connectFull(state, chainId);
       const validChainId = isValidChainId(chainId);
@@ -876,15 +747,13 @@ var ZyfaiAgent = class {
           validChainId,
           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));
+        await this.sdk.logDeposit(validChainId, txHash, amount);
         return { txHash, smartWallet: wallet.address, amount };
       }
       const raw = await this.sdk.depositFunds(
         this.getAddress(),
         validChainId,
-        amount,
-        asset
+        amount
       );
       return mapDeposit(raw);
     } catch (error) {
@@ -922,10 +791,10 @@ var ZyfaiAgent = class {
     const raw = await this.sdk.getOnchainEarnings(smartWallet);
     return mapEarnings(raw, smartWallet);
   }
-  async getAccountApy(state, chainId, days, tokenSymbol) {
+  async getAccountApy(state, chainId, days) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
     const raw = await this.sdk.getDailyApyHistory(smartWallet, days);
-    return mapApyHistory(raw, chainId, tokenSymbol);
+    return mapApyHistory(raw, chainId);
   }
   async getHistory(state, chainId, options) {
     const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
@@ -980,20 +849,6 @@ 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(
@@ -1079,7 +934,8 @@ 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) };
   });
 }
@@ -1096,9 +952,11 @@ 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;
@@ -1127,7 +985,8 @@ 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;
@@ -1138,9 +997,11 @@ 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;
@@ -1157,13 +1018,16 @@ 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;
@@ -1177,7 +1041,8 @@ 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;
@@ -1192,7 +1057,7 @@ import {
   createWalletClient,
   custom
 } from "viem";
-import { base as base2, arbitrum as arbitrum2, mainnet as mainnet2 } from "viem/chains";
+import { base as base2, arbitrum as arbitrum2 } from "viem/chains";
 
 // src/lib/transfer-auth.ts
 import { bytesToHex } from "viem";
@@ -1238,10 +1103,7 @@ 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) {
@@ -1261,91 +1123,11 @@ 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),
-        // 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
-      }
+      { statusCode: res.status, responseBody: text.slice(0, 500) }
     );
   }
   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;
@@ -1397,114 +1179,6 @@ 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");
@@ -1528,22 +1202,13 @@ function decodeMultiAgentCursor(token) {
 }
 var SPONSORED_USDC_BY_CHAIN = {
   8453: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
-  1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831"
 };
 var VIEM_CHAIN2 = {
   8453: base2,
-  42161: arbitrum2,
-  1: mainnet2
-};
-var SPONSORED_WETH_BY_CHAIN = {
-  8453: "0x4200000000000000000000000000000000000006",
-  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+  42161: arbitrum2
 };
-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 AGENT_ELIGIBILITY_ORDER = ["surfliquid", "zyfai", "sail"];
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
@@ -1556,14 +1221,11 @@ 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.
@@ -1584,7 +1246,6 @@ var OwneySDK = class {
     }
     this.state = { provider, walletAddress, chainId: null };
     this.cachedSponsoredCallback = null;
-    this.cachedWethSponsoredCallback = null;
   }
   /**
    * Disconnect from all agents and clear connection state.
@@ -1598,7 +1259,6 @@ var OwneySDK = class {
     this.disabledAgents.clear();
     this.state = null;
     this.cachedSponsoredCallback = null;
-    this.cachedWethSponsoredCallback = null;
   }
   isAgentDisabled(agentId) {
     return this.disabledAgents.has(agentId);
@@ -1618,7 +1278,8 @@ 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() {
@@ -1648,12 +1309,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
@@ -1671,37 +1332,6 @@ 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) {
@@ -1713,19 +1343,22 @@ 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, is_enabled } of agentKeys) {
-          const agent = this.createAgent(agent_type, key);
-          if (!agent) continue;
+        for (const { key, agent_type, project_name, is_enabled } of agentKeys) {
+          const agent = await this.createAgent(agent_type, key, project_name);
+          if (!agent)
+            continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
             this.disabledAgents.add(agent_type);
@@ -1745,10 +1378,16 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  createAgent(agentId, key) {
+  async createAgent(agentId, key, projectName) {
     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 ---
@@ -1852,7 +1491,7 @@ var OwneySDK = class {
     }
     const state = this.requireState();
     const chainId = this.requireChainId();
-    const effectiveCallback = depositCallback ?? (asset === "WETH" ? this.getDefaultWethSponsoredCallback() : this.getDefaultSponsoredCallback());
+    const effectiveCallback = depositCallback ?? this.getDefaultSponsoredCallback();
     if (agentId) {
       if (this.isAgentDisabled(agentId)) {
         throw new OwneyError(
@@ -1864,14 +1503,10 @@ var OwneySDK = class {
       const agent = this.getAgent(agentId);
       this.validateAssetSupport(agent, chainId, asset);
       await this.validateMinDepositAmount(agent, state, chainId, asset, amount);
-      return this.depositWithFallback(
-        agent,
-        state,
-        chainId,
-        amount,
-        asset,
-        effectiveCallback,
-        depositCallback
+      return withFailureReporting(
+        this.apiKey,
+        agent.id,
+        () => agent.deposit(state, chainId, amount, effectiveCallback)
       );
     }
     const totalAmount = BigInt(amount);
@@ -1901,77 +1536,26 @@ 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 {
-        return await attempt(effectiveCallback);
-      } catch (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
+        agentResults[agent.id] = await withFailureReporting(
+          this.apiKey,
+          agent.id,
+          () => agent.deposit(state, chainId, agentAmount, effectiveCallback)
         );
-        return attempt(void 0);
+      } catch (error) {
+        agentErrors[agent.id] = error instanceof Error ? error.message : String(error);
       }
     }
+    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(
@@ -1981,7 +1565,8 @@ 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) => ({
@@ -2005,8 +1590,10 @@ 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}".`,
@@ -2069,6 +1656,34 @@ 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.
@@ -2104,9 +1719,17 @@ 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 eligibleAgents) {
+      for (const { agent } of funded) {
         try {
           results2[agent.id] = await agent.withdraw(state, chainId, token);
         } catch (err) {
@@ -2123,9 +1746,10 @@ 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: sumWithdrawnAmount(results2).toString()
+        totalWithdrawn: totalWithdrawn.toString()
       };
     }
     const requested = BigInt(amount);
@@ -2170,7 +1794,8 @@ 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,
@@ -2304,30 +1929,19 @@ var OwneySDK = class {
    */
   async getAccountApy({
     agentId,
-    days,
-    tokenSymbol
+    days
   }) {
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      return this.getAgent(agentId).getAccountApy(
-        state,
-        chainId,
-        days,
-        tokenSymbol
-      );
+      return this.getAgent(agentId).getAccountApy(state, chainId, days);
     }
     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,
-            tokenSymbol
-          );
+          const apy = await agent.getAccountApy(state, chainId, days);
           return [id, apy];
         })
       ),
@@ -2350,13 +1964,15 @@ 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;
       }
@@ -2411,7 +2027,8 @@ 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;
@@ -2420,12 +2037,16 @@ 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 {
@@ -2460,67 +2081,6 @@ 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.
@@ -2626,7 +2186,8 @@ 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 {
@@ -2636,9 +2197,11 @@ 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 {
@@ -2648,7 +2211,8 @@ 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 {
@@ -2656,7 +2220,8 @@ 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 {
@@ -2719,10 +2284,12 @@ 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.