@owney/sdk 0.6.5 → 0.6.6-beta.1

package/dist/index.cjs

@@ -3,6 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,9 +20,486 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/errors.ts
+var OwneyError, AgentNotFoundError, NotConnectedError, AgentChainIncompatibleError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    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;
+      }
+    };
+    AgentNotFoundError = class extends OwneyError {
+      constructor(agentId, available) {
+        super(
+          "AGENT_NOT_FOUND",
+          `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+          { agentId, available },
+          agentId
+        );
+        this.name = "AgentNotFoundError";
+      }
+    };
+    NotConnectedError = class extends OwneyError {
+      constructor() {
+        super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+        this.name = "NotConnectedError";
+      }
+    };
+    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/agents/surfliquid/surfliquid.constants.ts
+var SURFLIQUID_CHAIN_ID, SURFLIQUID_CHAIN_NAME, SURFLIQUID_USDC_ADDRESS, SURFLIQUID_USDC_DECIMALS, SURFLIQUID_MIN_DEPOSIT, SURFLIQUID_SUPPORTED_ASSETS, SURFLIQUID_ACTION_MAP;
+var init_surfliquid_constants = __esm({
+  "src/agents/surfliquid/surfliquid.constants.ts"() {
+    "use strict";
+    SURFLIQUID_CHAIN_ID = 8453;
+    SURFLIQUID_CHAIN_NAME = "BASE";
+    SURFLIQUID_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+    SURFLIQUID_USDC_DECIMALS = 6;
+    SURFLIQUID_MIN_DEPOSIT = "0";
+    SURFLIQUID_SUPPORTED_ASSETS = [
+      {
+        chainId: SURFLIQUID_CHAIN_ID,
+        chain: SURFLIQUID_CHAIN_NAME,
+        assets: [{ symbol: "USDC", minDepositAmount: SURFLIQUID_MIN_DEPOSIT }]
+      }
+    ];
+    SURFLIQUID_ACTION_MAP = {
+      // INITIAL_DEPOSIT is the user's real first deposit, so surface it like any
+      // other funding ("Top up"). The mini-app intentionally hides the "Deposit"
+      // action (it marks Zyfai's smart-account-creation event), which would
+      // otherwise drop a SurfLiquid user's only history row.
+      INITIAL_DEPOSIT: "Top up",
+      DEPOSIT: "Top up",
+      USER_DEPOSIT: "Top up",
+      WITHDRAWAL: "Withdraw",
+      USER_WITHDRAWAL: "Withdraw",
+      REBALANCE: "Rebalance",
+      REBALANCE_COMPLETED: "Rebalance",
+      CROSS_CHAIN_REBALANCE: "Rebalance",
+      MERKL_CLAIM: "Earned"
+    };
+  }
+});
+
+// src/agents/surfliquid/surfliquid.mapper.ts
+function mapMessage(message) {
+  const action = SURFLIQUID_ACTION_MAP[message.transactionType];
+  if (!action)
+    return null;
+  return {
+    agent: "surfliquid",
+    action,
+    date: message.timestamp,
+    oldApy: message.apyBefore != null ? String(message.apyBefore) : null,
+    newApy: message.apyAfter != null ? String(message.apyAfter) : null,
+    transactions: [
+      {
+        txHashes: [message.txHash],
+        chainId: message.chainId,
+        tokenSymbol: message.token ?? void 0,
+        amount: message.amount != null ? String(message.amount) : void 0
+      }
+    ],
+    rebalanceLog: []
+  };
+}
+function mapHistory(result, _chainId) {
+  const data = result.messages.map(mapMessage).filter((entry) => entry !== null);
+  const hasMore = result.page < result.pages;
+  return {
+    data,
+    hasMore,
+    nextCursor: hasMore ? String(result.page + 1) : void 0
+  };
+}
+function mapBalances2(vault, chainId, morphoStats) {
+  const assets = (vault.assets ?? []).filter(
+    (asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId
+  );
+  const tokens = assets.map((asset) => ({
+    chain: SURFLIQUID_CHAIN_NAME,
+    chainId: SURFLIQUID_CHAIN_ID,
+    asset: "USDC",
+    amount: String(asset.currentValueUSD)
+  }));
+  const positions = assets.map((asset) => {
+    const stats = morphoStats?.get(asset.morphoVaultAddress?.toLowerCase() ?? "");
+    return {
+      chain: SURFLIQUID_CHAIN_NAME,
+      protocol: "Morpho",
+      // The specific MetaMorpho vault (e.g. "Gauntlet USDC Frontier"), read from
+      // Morpho — renders as "Morpho <vault>" alongside zyfai's vault detail.
+      pool: stats?.name ?? void 0,
+      asset: "USDC",
+      amount: String(asset.currentValueUSD),
+      apy: asset.currentAPY,
+      // TVL + liquidity come straight from Morpho (SurfLiquid's API omits them).
+      tvl: stats?.tvlUsd,
+      liquidity: stats?.liquidityUsd
+    };
+  });
+  const total = assets.reduce(
+    (sum, asset) => sum + asset.currentValueUSD,
+    0
+  );
+  return {
+    smartWallet: vault.userVaultAddress ?? void 0,
+    totalBalance: String(total),
+    totalBalanceAsset: "usdc",
+    tokens,
+    positions
+  };
+}
+function mapAccountApy(vault, days) {
+  const breakdown = vault.apyBreakdown;
+  const windowed = breakdown ? breakdown[APY_WINDOW_KEY[days]] : void 0;
+  const apy = windowed != null ? windowed : breakdown?.currentAPY ?? 0;
+  return {
+    walletAddress: vault.walletAddress ?? "",
+    weightedApyAfterFee: apy,
+    apyByChainAndAsset: { [SURFLIQUID_CHAIN_ID]: { USDC: apy } },
+    // Parity with Sail: SurfLiquid's core-sdk exposes no daily net-APY series.
+    history: []
+  };
+}
+function mapEarnings2(vault, vaultAddress) {
+  return {
+    smartWallet: vaultAddress,
+    lifetimeEarnings: vault.earned?.totalEarningsUSD ?? 0,
+    tokens: []
+  };
+}
+function mapUserProfile2(vault, address) {
+  return {
+    address,
+    smartWallet: vault.userVaultAddress ?? "",
+    chains: [SURFLIQUID_CHAIN_ID],
+    // SurfLiquid uses cookie-based session auth — no session-key concept.
+    hasActiveSessionKey: false,
+    protocols: ["SurfLiquid"]
+  };
+}
+var APY_WINDOW_KEY;
+var init_surfliquid_mapper = __esm({
+  "src/agents/surfliquid/surfliquid.mapper.ts"() {
+    "use strict";
+    init_surfliquid_constants();
+    APY_WINDOW_KEY = {
+      "7D": "apy7d",
+      "14D": "apy14d",
+      "30D": "apy30d"
+    };
+  }
+});
+
+// src/agents/surfliquid/surfliquid.wallet-adapter.ts
+var import_core_sdk, OwneyWalletAdapter;
+var init_surfliquid_wallet_adapter = __esm({
+  "src/agents/surfliquid/surfliquid.wallet-adapter.ts"() {
+    "use strict";
+    import_core_sdk = require("@surf_liquid/core-sdk");
+    OwneyWalletAdapter = class extends import_core_sdk.BaseWalletAdapter {
+      constructor(eip1193Provider) {
+        super();
+        this.eip1193Provider = eip1193Provider;
+      }
+      name = "owney";
+      get installed() {
+        return true;
+      }
+      resolveProvider() {
+        return this.eip1193Provider;
+      }
+    };
+  }
+});
+
+// src/agents/surfliquid/surfliquid.morpho.ts
+async function fetchMorphoVaultStats(vaultAddress, chainId) {
+  try {
+    const res = await fetch(MORPHO_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query: VAULT_STATS_QUERY,
+        variables: { address: vaultAddress, chainId }
+      })
+    });
+    if (!res.ok)
+      return null;
+    const json = await res.json();
+    if (json.errors)
+      return null;
+    const vault = json.data?.vaultByAddress;
+    const tvlUsd = vault?.state?.totalAssetsUsd;
+    const liquidityUsd = vault?.liquidity?.usd;
+    if (typeof tvlUsd !== "number" || typeof liquidityUsd !== "number") {
+      return null;
+    }
+    const name = typeof vault?.name === "string" ? vault.name : null;
+    return { name, tvlUsd, liquidityUsd };
+  } catch (error) {
+    console.warn("surfliquid: Morpho vault stats fetch failed", {
+      vaultAddress,
+      chainId,
+      error
+    });
+    return null;
+  }
+}
+async function fetchMorphoStatsByVault(vaultAddresses, chainId) {
+  const unique = [...new Set(vaultAddresses.map((a) => a.toLowerCase()))];
+  const entries = await Promise.all(
+    unique.map(
+      async (address) => [address, await fetchMorphoVaultStats(address, chainId)]
+    )
+  );
+  const byVault = /* @__PURE__ */ new Map();
+  for (const [address, stats] of entries) {
+    if (stats)
+      byVault.set(address, stats);
+  }
+  return byVault;
+}
+var MORPHO_API_URL, VAULT_STATS_QUERY;
+var init_surfliquid_morpho = __esm({
+  "src/agents/surfliquid/surfliquid.morpho.ts"() {
+    "use strict";
+    MORPHO_API_URL = "https://api.morpho.org/graphql";
+    VAULT_STATS_QUERY = `
+  query VaultStats($address: String!, $chainId: Int!) {
+    vaultByAddress(address: $address, chainId: $chainId) {
+      name
+      state { totalAssetsUsd }
+      liquidity { usd }
+    }
+  }
+`;
+  }
+});
+
+// src/agents/surfliquid/surfliquid.agent.ts
+var surfliquid_agent_exports = {};
+__export(surfliquid_agent_exports, {
+  SurfLiquidAgent: () => SurfLiquidAgent
+});
+var import_core_sdk2, import_viem4, APY_WINDOW_KEY2, SurfLiquidAgent;
+var init_surfliquid_agent = __esm({
+  "src/agents/surfliquid/surfliquid.agent.ts"() {
+    "use strict";
+    import_core_sdk2 = require("@surf_liquid/core-sdk");
+    import_viem4 = require("viem");
+    init_errors();
+    init_surfliquid_constants();
+    init_surfliquid_mapper();
+    init_surfliquid_wallet_adapter();
+    init_surfliquid_morpho();
+    APY_WINDOW_KEY2 = {
+      "7D": "apy7d",
+      "14D": "apy14d",
+      "30D": "apy30d"
+    };
+    SurfLiquidAgent = class {
+      constructor(config) {
+        this.config = config;
+      }
+      id = "surfliquid";
+      supportedChainIds = [SURFLIQUID_CHAIN_ID];
+      supportedAssets = SURFLIQUID_SUPPORTED_ASSETS;
+      surf = null;
+      connectedAddress = null;
+      // In-flight connect+auth, shared by concurrent callers to dedupe SIWE.
+      connectPromise = null;
+      ensureSurf() {
+        if (this.surf)
+          return this.surf;
+        this.surf = import_core_sdk2.SurfClient.create({
+          projectName: this.config.projectName,
+          appId: this.config.appId,
+          environment: "mainnet",
+          chainId: SURFLIQUID_CHAIN_ID,
+          apiBaseUrl: this.config.apiBaseUrl,
+          rpcUrl: this.config.rpcUrl,
+          // Let the SDK auto-approve USDC to the vault before depositing.
+          autoApprove: true
+        });
+        return this.surf;
+      }
+      /**
+       * Connects + authenticates the SurfClient against owney's provider. Skips the
+       * SIWE prompt when already authenticated for this wallet (cookie session).
+       */
+      async connect(state) {
+        const surf = this.ensureSurf();
+        const sameWallet = this.connectedAddress?.toLowerCase() === state.walletAddress.toLowerCase();
+        if (sameWallet && surf.getAuthState().authenticated) {
+          return surf;
+        }
+        if (this.connectPromise)
+          return this.connectPromise;
+        this.connectPromise = (async () => {
+          surf.registerWalletAdapter(
+            "owney",
+            new OwneyWalletAdapter(state.provider)
+          );
+          await surf.connectWallet("owney");
+          await surf.authenticate();
+          this.connectedAddress = state.walletAddress;
+          return surf;
+        })();
+        try {
+          return await this.connectPromise;
+        } finally {
+          this.connectPromise = null;
+        }
+      }
+      /**
+       * Returns the user's vault address, deploying one on first use. SurfLiquid's
+       * deposit requires the vault to exist, so this must run before depositing.
+       * Existing vault → returned as-is; otherwise `deployVault()` is sent
+       * (user-pays) and the freshly deployed address is returned.
+       */
+      async resolveVaultAddress(surf, owner) {
+        const vault = await surf.getVault(owner).catch(() => null);
+        if (vault?.exists && vault.userVaultAddress) {
+          return vault.userVaultAddress;
+        }
+        const { vaultAddress } = await surf.deployVault();
+        return vaultAddress;
+      }
+      // --- IAgent: lifecycle ---
+      async disconnect() {
+        if (this.surf) {
+          await this.surf.disconnectWallet();
+        }
+        this.connectedAddress = null;
+      }
+      async activateAgent(state) {
+        await this.connect(state);
+      }
+      // --- IAgent: funds (user-pays; depositCallback intentionally ignored) ---
+      async deposit(state, _chainId, amount, _depositCallback) {
+        const surf = await this.connect(state);
+        const human = (0, import_viem4.formatUnits)(BigInt(amount), SURFLIQUID_USDC_DECIMALS);
+        const smartWallet = await this.resolveVaultAddress(
+          surf,
+          state.walletAddress
+        );
+        const tx = await surf.deposit({
+          asset: SURFLIQUID_USDC_ADDRESS,
+          amount: human
+        });
+        await tx.wait();
+        return { txHash: tx.hash, smartWallet, amount };
+      }
+      async withdraw(state, _chainId, _token, amount) {
+        const surf = await this.connect(state);
+        const human = amount != null ? (0, import_viem4.formatUnits)(BigInt(amount), SURFLIQUID_USDC_DECIMALS) : void 0;
+        try {
+          const tx = await surf.withdraw({
+            asset: SURFLIQUID_USDC_ADDRESS,
+            amount: human
+          });
+          await tx.wait();
+          return {
+            txHash: tx.hash,
+            type: amount != null ? "partial" : "full",
+            amount: amount ?? "0"
+          };
+        } catch (error) {
+          throw new OwneyError(
+            "WITHDRAW_FAILED",
+            error instanceof Error ? error.message : "SurfLiquid withdraw failed.",
+            { chainId: SURFLIQUID_CHAIN_ID, amount },
+            this.id
+          );
+        }
+      }
+      // --- IAgent: portfolio reads ---
+      async getBalances(state, chainId) {
+        const surf = await this.connect(state);
+        const vault = await surf.getVault(state.walletAddress);
+        const morphoVaultAddresses = (vault.assets ?? []).filter((asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId).map((asset) => asset.morphoVaultAddress).filter((address) => Boolean(address));
+        const morphoStats = await fetchMorphoStatsByVault(
+          morphoVaultAddresses,
+          chainId
+        );
+        return mapBalances2(vault, chainId, morphoStats);
+      }
+      async getEarnings(state) {
+        const surf = await this.connect(state);
+        const vault = await surf.getVault(state.walletAddress);
+        return mapEarnings2(vault, vault.userVaultAddress ?? state.walletAddress);
+      }
+      async getAccountApy(state, _chainId, days) {
+        const surf = await this.connect(state);
+        const vault = await surf.getVault(state.walletAddress);
+        return mapAccountApy(vault, days);
+      }
+      async getHistory(state, chainId, options) {
+        const surf = await this.connect(state);
+        const page = options?.cursor ? Number(options.cursor) : 1;
+        const limit = options?.limit ?? 10;
+        const result = await surf.getAgentMessages(
+          state.walletAddress,
+          page,
+          limit,
+          options?.fromDate,
+          options?.toDate
+        );
+        return mapHistory(result, chainId);
+      }
+      async getUserProfile(state) {
+        const surf = await this.connect(state);
+        const vault = await surf.getVault(state.walletAddress);
+        return mapUserProfile2(vault, state.walletAddress);
+      }
+      // --- IAgent: discovery (no wallet) ---
+      async getAgentApy(days, _options) {
+        const surf = this.ensureSurf();
+        const assets = await surf.getSupportedAssets(SURFLIQUID_CHAIN_ID);
+        const usdc = assets.find((asset) => asset.assetSymbol === "USDC");
+        if (!usdc)
+          return { averageApy: 0 };
+        const windowed = usdc[APY_WINDOW_KEY2[days]];
+        return { averageApy: windowed != null ? windowed : usdc.currentAPY };
+      }
+    };
+  }
+});
+
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   AgentChainIncompatibleError: () => AgentChainIncompatibleError,
   AgentNotFoundError: () => AgentNotFoundError,
   InvalidHistoryCursorError: () => InvalidHistoryCursorError,
@@ -28,7 +508,7 @@ __export(index_exports, {
   OwneySDK: () => OwneySDK,
   createOwneySIWX: () => createOwneySIWX
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/agents/zyfai/zyfai.agent.ts
 var import_sdk = require("@zyfai/sdk");
@@ -37,10 +517,10 @@ var import_chains = require("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 = [
@@ -61,83 +541,11 @@ 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
+init_errors();
 var isValidChainId = (chainId) => {
   if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
     throw new OwneyError(
@@ -151,7 +559,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;
@@ -164,20 +573,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,
@@ -194,8 +589,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
@@ -205,52 +599,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),
@@ -289,39 +685,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,
@@ -344,7 +742,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 ?? [];
@@ -366,15 +763,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"
         }
       ];
@@ -393,12 +782,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
@@ -423,7 +807,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] ?? {};
@@ -453,8 +838,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;
@@ -471,7 +858,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 };
@@ -488,14 +876,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));
 }
 
@@ -511,7 +904,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");
@@ -525,10 +919,14 @@ function decodeHistoryCursor(token) {
   return parsed;
 }
 
+// src/agents/zyfai/zyfai.agent.ts
+init_errors();
+
 // 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 {
@@ -538,13 +936,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;
@@ -552,9 +952,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)) {
@@ -569,7 +971,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 {
@@ -577,67 +980,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"
+  42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
 };
-var WETH_ADDRESS_BY_CHAIN = {
-  8453: "0x4200000000000000000000000000000000000006",
-  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-};
-var VIEM_CHAIN = { 8453: import_chains.base, 42161: import_chains.arbitrum, 1: import_chains.mainnet };
+var VIEM_CHAIN = { 8453: import_chains.base, 42161: import_chains.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;
@@ -661,7 +1030,8 @@ var ZyfaiAgent = class {
   }
   getPublicClient(chainId) {
     const cached = this.publicClients.get(chainId);
-    if (cached) return cached;
+    if (cached)
+      return cached;
     const client = (0, import_viem.createPublicClient)({
       chain: VIEM_CHAIN[chainId],
       transport: (0, import_viem.http)(this.rpcUrls[chainId])
@@ -671,43 +1041,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;
@@ -723,7 +1083,7 @@ var ZyfaiAgent = class {
             asset.decimals
           );
           if (amount !== void 0) {
-            this.withdrawAmountCache.set(cacheKey, amount);
+            this.withdrawAmountCache.set(txHash, amount);
             tx.amount = amount;
           }
         } catch {
@@ -742,11 +1102,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) {
@@ -821,10 +1183,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);
     }
   }
@@ -837,22 +1201,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) {
@@ -894,7 +1242,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);
@@ -908,15 +1256,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) {
@@ -954,10 +1300,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);
@@ -1012,20 +1358,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(
@@ -1039,7 +1371,11 @@ var ZyfaiAgent = class {
   }
 };
 
+// src/client.ts
+init_errors();
+
 // src/lib/routing-api.ts
+init_errors();
 var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function fetchAgentKeys(apiKey) {
   const url = `${ROUTING_API_BASE_URL}/api/v1/agent/keys`;
@@ -1070,6 +1406,7 @@ async function fetchAgentKeys(apiKey) {
 }
 
 // src/lib/health-report.ts
+init_errors();
 var ROUTING_API_BASE_URL2 = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function reportAgentFailure(apiKey, agentType, errorCode) {
   try {
@@ -1111,7 +1448,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: (0, import_viem2.parseUnits)(tokenBalance.amount, decimals) };
   });
 }
@@ -1128,9 +1466,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;
@@ -1159,7 +1499,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;
@@ -1170,9 +1511,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;
@@ -1189,13 +1532,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;
@@ -1209,7 +1555,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;
@@ -1222,6 +1569,9 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 var import_viem5 = require("viem");
 var import_chains2 = require("viem/chains");
 
+// src/lib/sponsored-deposit.ts
+init_errors();
+
 // src/lib/transfer-auth.ts
 var import_viem3 = require("viem");
 var ERC20_META_ABI = [
@@ -1259,6 +1609,7 @@ function randomAuthNonce() {
 }
 
 // src/lib/sponsor-client.ts
+init_errors();
 var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function postSponsorTransferAuth(input) {
   const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
@@ -1266,10 +1617,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) {
@@ -1289,91 +1637,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;
@@ -1425,114 +1693,6 @@ function makeSponsoredDepositCallback(deps) {
   };
 }
 
-// src/lib/permit2.ts
-var import_viem4 = require("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((0, import_viem4.bytesToHex)(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");
@@ -1556,22 +1716,13 @@ function decodeMultiAgentCursor(token) {
 }
 var SPONSORED_USDC_BY_CHAIN = {
   8453: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
-  1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831"
 };
 var VIEM_CHAIN2 = {
   8453: import_chains2.base,
-  42161: import_chains2.arbitrum,
-  1: import_chains2.mainnet
-};
-var SPONSORED_WETH_BY_CHAIN = {
-  8453: "0x4200000000000000000000000000000000000006",
-  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+  42161: import_chains2.arbitrum
 };
-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();
@@ -1584,14 +1735,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.
@@ -1612,7 +1760,6 @@ var OwneySDK = class {
     }
     this.state = { provider, walletAddress, chainId: null };
     this.cachedSponsoredCallback = null;
-    this.cachedWethSponsoredCallback = null;
   }
   /**
    * Disconnect from all agents and clear connection state.
@@ -1626,7 +1773,6 @@ var OwneySDK = class {
     this.disabledAgents.clear();
     this.state = null;
     this.cachedSponsoredCallback = null;
-    this.cachedWethSponsoredCallback = null;
   }
   isAgentDisabled(agentId) {
     return this.disabledAgents.has(agentId);
@@ -1646,7 +1792,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() {
@@ -1676,12 +1823,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
@@ -1699,37 +1846,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) => (0, import_viem5.createPublicClient)({
-        chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem5.custom)(provider)
-      }),
-      getWalletClient: (cid) => (0, import_viem5.createWalletClient)({
-        account: owner,
-        chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem5.custom)(provider)
-      })
-    });
-    return this.cachedWethSponsoredCallback;
-  }
   getAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -1741,19 +1857,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);
@@ -1773,10 +1892,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: SurfLiquidAgent2 } = await Promise.resolve().then(() => (init_surfliquid_agent(), surfliquid_agent_exports));
+      return new SurfLiquidAgent2({ projectName, appId: key });
+    }
     return null;
   }
   // --- Account lifecycle ---
@@ -1880,7 +2005,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(
@@ -1892,14 +2017,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);
@@ -1929,77 +2050,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(
@@ -2009,7 +2079,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) => ({
@@ -2033,8 +2104,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}".`,
@@ -2097,6 +2170,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.
@@ -2132,9 +2233,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) {
@@ -2151,9 +2260,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);
@@ -2198,7 +2308,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,
@@ -2332,30 +2443,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];
         })
       ),
@@ -2378,13 +2478,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;
       }
@@ -2439,7 +2541,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;
@@ -2448,12 +2551,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 {
@@ -2488,67 +2595,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 = (0, import_viem5.createWalletClient)({
-      account: state.walletAddress,
-      chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem5.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 = (0, import_viem5.createPublicClient)({
-      chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem5.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.
@@ -2646,6 +2692,9 @@ var OwneySDK = class {
   }
 };
 
+// src/index.ts
+init_errors();
+
 // src/agents/zyfai/zyfai.siwx.ts
 var import_viem6 = require("viem");
 var import_siwe = require("siwe");
@@ -2654,7 +2703,8 @@ var import_sdk2 = require("@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 {
@@ -2664,9 +2714,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 {
@@ -2676,7 +2728,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 {
@@ -2684,7 +2737,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 {
@@ -2747,10 +2801,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.