@owney/sdk 0.7.12-beta.0 → 0.7.12-beta.2

package/dist/index.cjs

@@ -3,14 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res, err) => function __init() {
-  if (err) throw err[0];
-  try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  } catch (e) {
-    throw err = [e], e;
-  }
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -25,645 +17,6 @@ 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/lib/permit2.ts
-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]
-  });
-}
-async function readErc20Balance(publicClient, token, owner) {
-  return publicClient.readContract({
-    address: token,
-    abi: ERC20_ALLOWANCE_ABI,
-    functionName: "balanceOf",
-    args: [owner]
-  });
-}
-var import_viem4, PERMIT2_ADDRESS, MAX_UINT256, ERC20_ALLOWANCE_ABI;
-var init_permit2 = __esm({
-  "src/lib/permit2.ts"() {
-    "use strict";
-    import_viem4 = require("viem");
-    PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-    MAX_UINT256 = 2n ** 256n - 1n;
-    ERC20_ALLOWANCE_ABI = [
-      {
-        type: "function",
-        name: "allowance",
-        stateMutability: "view",
-        inputs: [
-          { name: "owner", type: "address" },
-          { name: "spender", type: "address" }
-        ],
-        outputs: [{ name: "", type: "uint256" }]
-      },
-      {
-        type: "function",
-        name: "approve",
-        stateMutability: "nonpayable",
-        inputs: [
-          { name: "spender", type: "address" },
-          { name: "amount", type: "uint256" }
-        ],
-        outputs: [{ name: "", type: "bool" }]
-      },
-      {
-        type: "function",
-        name: "balanceOf",
-        stateMutability: "view",
-        inputs: [{ name: "account", type: "address" }],
-        outputs: [{ name: "", type: "uint256" }]
-      }
-    ];
-  }
-});
-
-// src/agents/surfliquid/surfliquid.constants.ts
-var SURFLIQUID_CHAIN_ID, SURFLIQUID_CHAIN_NAME, SURFLIQUID_USDC_ADDRESS, SURFLIQUID_USDC_DECIMALS, SURFLIQUID_MIN_DEPOSIT, SURFLIQUID_APPROVAL_TARGET, 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_APPROVAL_TARGET = 100000000000n;
-    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;
-      }
-      eip1193Provider;
-      name = "owney";
-      get installed() {
-        return true;
-      }
-      resolveProvider() {
-        return this.eip1193Provider;
-      }
-    };
-  }
-});
-
-// src/agents/surfliquid/surfliquid.morpho.ts
-async function queryMorpho(query, vaultAddress, chainId) {
-  try {
-    const res = await fetch(MORPHO_API_URL, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        query,
-        variables: { address: vaultAddress, chainId }
-      })
-    });
-    if (!res.ok) return null;
-    const json = await res.json();
-    if (json.errors) return null;
-    return json.data ?? null;
-  } catch (error) {
-    console.warn("surfliquid: Morpho vault stats fetch failed", {
-      vaultAddress,
-      chainId,
-      error
-    });
-    return null;
-  }
-}
-function toStats(name, tvlUsd, liquidityUsd) {
-  if (typeof tvlUsd !== "number" || typeof liquidityUsd !== "number") {
-    return null;
-  }
-  return {
-    name: typeof name === "string" ? name : null,
-    tvlUsd,
-    liquidityUsd
-  };
-}
-async function fetchMorphoVaultStats(vaultAddress, chainId) {
-  const v1 = await queryMorpho(VAULT_STATS_QUERY, vaultAddress, chainId);
-  const vault = v1?.vaultByAddress;
-  const v1Stats = toStats(
-    vault?.name,
-    vault?.state?.totalAssetsUsd,
-    vault?.liquidity?.usd
-  );
-  if (v1Stats) return v1Stats;
-  const v2 = await queryMorpho(VAULT_V2_STATS_QUERY, vaultAddress, chainId);
-  const vaultV2 = v2?.vaultV2ByAddress;
-  return toStats(vaultV2?.name, vaultV2?.totalAssetsUsd, vaultV2?.liquidityUsd);
-}
-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, VAULT_V2_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 }
-    }
-  }
-`;
-    VAULT_V2_STATS_QUERY = `
-  query VaultV2Stats($address: String!, $chainId: Int!) {
-    vaultV2ByAddress(address: $address, chainId: $chainId) {
-      name
-      totalAssetsUsd
-      liquidityUsd
-    }
-  }
-`;
-  }
-});
-
-// src/agents/surfliquid/surfliquid.agent.ts
-var surfliquid_agent_exports = {};
-__export(surfliquid_agent_exports, {
-  SurfLiquidAgent: () => SurfLiquidAgent
-});
-var import_core_sdk2, import_viem6, import_chains2, 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_viem6 = require("viem");
-    import_chains2 = require("viem/chains");
-    init_errors();
-    init_surfliquid_constants();
-    init_permit2();
-    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;
-      }
-      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;
-      }
-      /**
-       * Grants the user's vault a standing USDC allowance so SurfLiquid's
-       * `autoApprove` has nothing to do — see {@link SURFLIQUID_APPROVAL_TARGET}
-       * for why one prompt per deposit is worth removing.
-       *
-       * Fails OPEN on a read error: if the allowance can't be checked we simply
-       * return and let SurfLiquid's own per-deposit approve run, because a flaky
-       * RPC must never block a deposit. A failed or rejected APPROVE does
-       * propagate — the user declined a transaction, and letting SurfLiquid
-       * immediately ask again for a smaller one is exactly the double prompt this
-       * removes.
-       */
-      async ensureVaultAllowance(state, vaultAddress, amount) {
-        const spender = vaultAddress;
-        const transport = (0, import_viem6.custom)(state.provider);
-        const publicClient = (0, import_viem6.createPublicClient)({ chain: import_chains2.base, transport });
-        let allowance;
-        try {
-          allowance = await publicClient.readContract({
-            address: SURFLIQUID_USDC_ADDRESS,
-            abi: ERC20_ALLOWANCE_ABI,
-            functionName: "allowance",
-            args: [state.walletAddress, spender]
-          });
-        } catch (error) {
-          console.warn(
-            "[owney-sdk] SurfLiquid allowance pre-check failed; deferring to its per-deposit approve:",
-            error instanceof Error ? error.message : String(error)
-          );
-          return;
-        }
-        if (allowance >= amount) return;
-        const target = amount > SURFLIQUID_APPROVAL_TARGET ? amount : SURFLIQUID_APPROVAL_TARGET;
-        const wallet = (0, import_viem6.createWalletClient)({
-          account: state.walletAddress,
-          chain: import_chains2.base,
-          transport
-        });
-        const hash = await wallet.writeContract({
-          address: SURFLIQUID_USDC_ADDRESS,
-          abi: ERC20_ALLOWANCE_ABI,
-          functionName: "approve",
-          args: [spender, target],
-          account: state.walletAddress,
-          chain: import_chains2.base
-        });
-        const receipt = await publicClient.waitForTransactionReceipt({
-          hash,
-          confirmations: 1
-        });
-        if (receipt.status !== "success") {
-          throw new Error(`SurfLiquid USDC approval reverted (tx ${hash})`);
-        }
-      }
-      // --- 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; asset is always USDC, callback ignored) ---
-      async deposit(state, _chainId, amount, _asset, _depositCallback) {
-        const surf = await this.connect(state);
-        const human = (0, import_viem6.formatUnits)(BigInt(amount), SURFLIQUID_USDC_DECIMALS);
-        const smartWallet = await this.resolveVaultAddress(
-          surf,
-          state.walletAddress
-        );
-        await this.ensureVaultAllowance(state, smartWallet, BigInt(amount));
-        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_viem6.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, _tokenSymbol) {
-        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, {
@@ -736,8 +89,56 @@ var SupportedAssets = [
   }
 ];
 
+// 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(
@@ -748,12 +149,6 @@ var isValidChainId = (chainId) => {
   }
   return chainId;
 };
-function isSameAsset(tokenSymbol, asset) {
-  const token = tokenSymbol.toLowerCase();
-  const target = asset.toLowerCase();
-  if (token === target) return true;
-  return target === "weth" && token === "eth" || target === "eth" && token === "weth";
-}
 function hexToDecimal(hex, decimals = 6) {
   const normalized = hex.startsWith("0x") || hex.startsWith("0X") ? hex : `0x${hex}`;
   const parsed = BigInt(normalized);
@@ -787,10 +182,6 @@ var DECIMALS_BY_SYMBOL = {
   wbtc: 8,
   cbbtc: 8
 };
-function canonicalSymbol(symbol) {
-  const upper = symbol.toUpperCase();
-  return upper === "ETH" ? "WETH" : upper;
-}
 function tokenDecimals(symbol, explicit) {
   if (typeof explicit === "number" && Number.isFinite(explicit))
     return explicit;
@@ -855,89 +246,55 @@ function mapPendingAllocations(raw) {
 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 = canonicalSymbol(p.token_symbol ?? "");
-    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 chainName2 = CHAIN_ID_TO_NAME[positionChainId] ?? "BASE";
     for (const [
       symbol,
       { balance, balanceWithFee, decimals }
     ] of Object.entries(tokensBySymbol ?? {})) {
-      const amount = hexToDecimal(
-        balanceWithFee ?? balance ?? "0",
-        tokenDecimals(symbol, decimals)
-      );
+      const amount = hexToDecimal(balanceWithFee ?? balance ?? "0", decimals);
       totalBalance += amount;
       tokens.push({
-        chain: chainName2,
+        chain: CHAIN_ID_TO_NAME[positionChainId] ?? "BASE",
         chainId: positionChainId,
         asset: symbol,
         amount: String(amount)
       });
-      const detail = detailByKey.get(
-        `${positionChainId}:${canonicalSymbol(symbol)}`
-      );
-      positions.push({
-        chain: chainName2,
-        protocol: detail?.protocol_name ?? detail?.protocol_id ?? "",
-        protocolId: detail?.protocol_id,
-        pool: detail?.pool,
-        // Report the token the way the rest of owney spells it ("WETH", as the
-        // pre-portfolioByChain mapper did), not Zyfai's internal "eth".
-        asset: canonicalSymbol(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
-      });
     }
   }
-  if (positions.length === 0) {
-    positions.push(
-      ...(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 ?? "",
-        // Fee-adjusted underlying amounts are decimal base-unit strings; the
-        // legacy `amount` fallback is hex. Runtime getBalances payloads often
-        // carry `decimals` (e.g. 18 for WETH) — prefer it when present,
-        // otherwise fall back to the per-symbol lookup.
-        amount: String(
-          p.underlyingAmountWithFee ?? p.underlyingAmount ? normalizeDecimalPlace(
-            p.underlyingAmountWithFee ?? p.underlyingAmount ?? "0",
-            tokenDecimals(
-              p.token_symbol,
-              p.decimals
-            )
-          ) : 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
-      }))
-    );
-  }
+  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 ?? "",
+    // Fee-adjusted underlying amounts are decimal base-unit strings. The
+    // legacy `amount` fallback is hex. Runtime
+    // getBalances payloads often carry one (e.g. 18 for WETH) — prefer that
+    // when present, otherwise fall back to the per-symbol lookup.
+    amount: String(
+      p.underlyingAmountWithFee ?? p.underlyingAmount ? normalizeDecimalPlace(
+        p.underlyingAmountWithFee ?? p.underlyingAmount ?? "0",
+        tokenDecimals(
+          p.token_symbol,
+          p.decimals
+        )
+      ) : 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
+  }));
   const pendingAllocations = mapPendingAllocations(
     portfolio.staleBalances
   );
@@ -1232,9 +589,6 @@ 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 = () => {
@@ -2023,37 +1377,6 @@ var ZyfaiAgent = class _ZyfaiAgent {
       );
     }
   }
-  /**
-   * Records the deposit with Zyfai, retrying transient failures.
-   *
-   * This runs AFTER the transfer has already landed on-chain, so it must never
-   * fail the deposit — the funds moved. But it is also the ONLY source of the
-   * "Top up wallet" entry the history is built from: Zyfai auto-deploys the
-   * balance it detects either way, so when this call is lost the user's deposit
-   * never appears in Activity (an earlier withdrawal stays the newest row) and
-   * nothing ever backfills it. Retry, then log loudly enough to be recoverable.
-   */
-  async logDepositWithRetry(chainId, txHash, amount, tokenAddress) {
-    const ATTEMPTS = 3;
-    const RETRY_DELAY_MS = 1e3;
-    for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
-      try {
-        await (tokenAddress ? this.sdk.logDeposit(chainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(chainId, txHash, amount));
-        return;
-      } catch (logError) {
-        if (attempt === ATTEMPTS) {
-          console.error(
-            "[owney-sdk] Deposit landed on-chain but logDeposit failed \u2014 it will be missing from Zyfai history:",
-            { txHash, chainId, amount, tokenAddress, error: logError }
-          );
-          return;
-        }
-        await new Promise(
-          (resolve) => setTimeout(resolve, RETRY_DELAY_MS * attempt)
-        );
-      }
-    }
-  }
   /**
    * True when `smartWallet` is the backend-managed pool wallet Zyfai assigned
    * to this EOA — the "new wallet" kind that is predeployed on the chains it
@@ -2357,12 +1680,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
         );
         const txHash = await depositCallback(smartWallet, validChainId, amount);
         const tokenAddress = asset === "WETH" ? WETH_ADDRESS_BY_CHAIN[validChainId] : void 0;
-        await this.logDepositWithRetry(
-          validChainId,
-          txHash,
-          amount,
-          tokenAddress
-        );
+        try {
+          await (tokenAddress ? this.sdk.logDeposit(validChainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(validChainId, txHash, amount));
+        } catch (logError) {
+          console.warn(
+            "[owney-sdk] Deposit landed on-chain but logDeposit failed (non-fatal):",
+            logError
+          );
+        }
         return { txHash, smartWallet, amount };
       }
       await this.ensureWalletDeployed(this.getAddress(), validChainId);
@@ -2543,11 +1868,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
 };
 
-// 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 fetchOrgAgentConfig(apiKey) {
   const url = `${ROUTING_API_BASE_URL}/api/v1/agent/org-config`;
@@ -2612,7 +1933,6 @@ 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 {
@@ -2648,10 +1968,11 @@ async function withFailureReporting(apiKey, agentType, fn) {
 // src/lib/helpers/withdraw-helper.ts
 var import_viem2 = require("viem");
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
+  const target = asset.toUpperCase();
   return agents.map((agent) => {
     const agentBalance = aggregated[agent.id];
     const tokenBalance = agentBalance?.tokens.find(
-      (t) => t.chainId === chainId && isSameAsset(t.asset, asset)
+      (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
     if (!tokenBalance) return { agent, balance: 0n };
     return { agent, balance: (0, import_viem2.parseUnits)(tokenBalance.amount, decimals) };
@@ -2761,11 +2082,8 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
 }
 
 // src/client.ts
-var import_viem7 = require("viem");
-var import_chains3 = require("viem/chains");
-
-// src/lib/sponsored-deposit.ts
-init_errors();
+var import_viem6 = require("viem");
+var import_chains2 = require("viem/chains");
 
 // src/lib/transfer-auth.ts
 var import_viem3 = require("viem");
@@ -2804,13 +2122,12 @@ 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 base4 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
-    res = await fetch(`${base4}/api/v1/sponsor/erc20-transfer-auth`, {
+    res = await fetch(`${base3}/api/v1/sponsor/erc20-transfer-auth`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -2847,10 +2164,10 @@ async function postSponsorTransferAuth(input) {
   return parsed.data;
 }
 async function postSponsorPermit2Transfer(input) {
-  const base4 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
-    res = await fetch(`${base4}/api/v1/sponsor/permit2-transfer`, {
+    res = await fetch(`${base3}/api/v1/sponsor/permit2-transfer`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -2885,11 +2202,11 @@ async function postSponsorPermit2Transfer(input) {
   return parsed.data;
 }
 async function getSponsorRelayerAddress(input) {
-  const base4 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
   let res;
   try {
     res = await fetch(
-      `${base4}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
+      `${base3}/api/v1/sponsor/relayer-address?chainId=${input.chainId}`,
       {
         headers: { "x-owney-api-key": input.apiKey }
       }
@@ -2921,11 +2238,85 @@ async function getSponsorRelayerAddress(input) {
   return parsed.data.relayer;
 }
 
-// src/lib/sponsored-deposit.ts
-init_permit2();
+// 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" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+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]
+  });
+}
+async function readErc20Balance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "balanceOf",
+    args: [owner]
+  });
+}
 
 // src/lib/chain-guard.ts
-init_errors();
 var CHAIN_NAMES = {
   1: "Ethereum",
   8453: "Base",
@@ -3039,8 +2430,6 @@ function makeSponsoredDepositCallback(deps) {
 }
 
 // src/lib/sponsored-weth-deposit.ts
-init_errors();
-init_permit2();
 var PERMIT_WINDOW_SECONDS = 15 * 60;
 function makeSponsoredWethCallback(deps) {
   const get = deps.httpGet ?? getSponsorRelayerAddress;
@@ -3125,7 +2514,6 @@ function makeSponsoredWethCallback(deps) {
 
 // src/lib/sponsored-calls-deposit.ts
 var import_viem5 = require("viem");
-init_errors();
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -3216,7 +2604,6 @@ function makeSponsoredCallsCallback(deps) {
 }
 
 // src/client.ts
-init_permit2();
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
 }
@@ -3243,11 +2630,10 @@ var SPONSORED_USDC_BY_CHAIN = {
   1: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
 };
 var VIEM_CHAIN2 = {
-  8453: import_chains3.base,
-  42161: import_chains3.arbitrum,
-  1: import_chains3.mainnet
+  8453: import_chains2.base,
+  42161: import_chains2.arbitrum,
+  1: import_chains2.mainnet
 };
-var AGENT_ELIGIBILITY_ORDER = ["surfliquid", "zyfai", "sail"];
 var SPONSORED_WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -3276,7 +2662,6 @@ var OwneySDK = class {
   zyfaiRpcUrls;
   routingApiBaseUrl;
   referralSource;
-  surfliquidApiBaseUrl;
   cachedSponsoredCallback = null;
   cachedWethSponsoredCallback = null;
   paymasterServiceUrl;
@@ -3289,7 +2674,6 @@ var OwneySDK = class {
     this.routingApiBaseUrl = config.routingApiBaseUrl;
     this.paymasterServiceUrl = config.paymasterServiceUrl;
     this.referralSource = config.referralSource;
-    this.surfliquidApiBaseUrl = config.surfliquidApiBaseUrl;
   }
   /**
    * Establish connection state for all subsequent SDK calls.
@@ -3389,14 +2773,14 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => (0, import_viem7.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem7.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem7.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem7.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedSponsoredCallback = callback;
@@ -3442,14 +2826,14 @@ var OwneySDK = class {
       // Casts work around viem's chain-narrowed Client vs the generic
       // PublicClient/WalletClient param types — structurally identical at
       // runtime, but the two share a name TS treats as unrelated.
-      getPublicClient: (cid) => (0, import_viem7.createPublicClient)({
+      getPublicClient: (cid) => (0, import_viem6.createPublicClient)({
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem7.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       }),
-      getWalletClient: (cid) => (0, import_viem7.createWalletClient)({
+      getWalletClient: (cid) => (0, import_viem6.createWalletClient)({
         account: owner,
         chain: VIEM_CHAIN2[cid],
-        transport: (0, import_viem7.custom)(provider)
+        transport: (0, import_viem6.custom)(provider)
       })
     });
     if (!onApproved) this.cachedWethSponsoredCallback = callback;
@@ -3519,8 +2903,8 @@ var OwneySDK = class {
       this.initializingAgentsPromise = (async () => {
         const agentKeys = await fetchAgentKeys(this.apiKey);
         this.disabledAgents.clear();
-        for (const { key: key2, agent_type, project_name, is_enabled } of agentKeys) {
-          const agent = await this.createAgent(agent_type, key2, project_name);
+        for (const { key: key2, agent_type, is_enabled } of agentKeys) {
+          const agent = this.createAgent(agent_type, key2);
           if (!agent) continue;
           this.agents.set(agent_type, agent);
           if (is_enabled === false) {
@@ -3541,22 +2925,10 @@ var OwneySDK = class {
       this.initializingAgentsPromise = null;
     }
   }
-  async createAgent(agentId, key2, projectName) {
+  createAgent(agentId, key2) {
     if (agentId === "zyfai") {
       return new ZyfaiAgent(key2, this.zyfaiRpcUrls, this.referralSource);
     }
-    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: key2,
-        // Same-origin proxy override — SurfLiquid auth is an httpOnly cookie,
-        // which WebKit (iOS) discards when it is third-party. See
-        // OwneySDKConfig.surfliquidApiBaseUrl.
-        apiBaseUrl: this.surfliquidApiBaseUrl
-      });
-    }
     return null;
   }
   // --- Account lifecycle ---
@@ -3606,12 +2978,7 @@ var OwneySDK = class {
         this.activeAgents.add(id);
       }
       state.chainId = chainId;
-      Promise.all(
-        agents.map(async (agent) => {
-          await agent.activateAgent(state, chainId);
-          await this.applyOrgPolicyTo(agent, state, chainId);
-        })
-      ).catch((error) => {
+      this.activateAgentsInTurn(agents, state, chainId).catch((error) => {
         console.error("activateAgent background init failed:", error);
       });
       return;
@@ -3634,14 +3001,48 @@ var OwneySDK = class {
     const enabledCompatible = compatible.filter(
       (agent) => !this.isAgentDisabled(agent.id)
     );
-    Promise.all(
-      enabledCompatible.map(async (agent) => {
+    this.activateAgentsInTurn(enabledCompatible, state, chainId).catch(
+      (error) => {
+        console.error("activateAgent background init failed:", error);
+      }
+    );
+  }
+  /**
+   * Activate agents ONE AT A TIME, each followed by its org policy.
+   *
+   * Every agent opens its activation with its own wallet signature, each
+   * exchanged for that agent's own backend session — Zyfai's SIWX for a JWT,
+   * Sail's SIWE. Run in parallel, that puts two `personal_sign` requests on one
+   * wallet connection in the same instant. Over WalletConnect both are
+   * delivered to the wallet, which renders one signing request at a time and
+   * queues or silently drops the other: neither promise settles, so activation
+   * hangs until the caller's timeout with no prompt the user can act on. The
+   * single-agent era never hit this — there was no second prompt to collide
+   * with — so it appeared the moment a second agent became eligible.
+   *
+   * Serializing costs no real wall-clock: the user can only approve one prompt
+   * at a time anyway.
+   *
+   * Every agent is attempted even if an earlier one fails, so one declined
+   * signature can't deny the remaining agents their turn. The first failure is
+   * rethrown (matching the previous `Promise.all` rejection) once all agents
+   * have had a chance to activate.
+   */
+  async activateAgentsInTurn(agents, state, chainId) {
+    let firstError = null;
+    for (const agent of agents) {
+      try {
         await agent.activateAgent(state, chainId);
         await this.applyOrgPolicyTo(agent, state, chainId);
-      })
-    ).catch((error) => {
-      console.error("activateAgent background init failed:", error);
-    });
+      } catch (error) {
+        if (firstError === null) {
+          firstError = error;
+        } else {
+          console.error(`activateAgent(${agent.id}) failed:`, error);
+        }
+      }
+    }
+    if (firstError !== null) throw firstError;
   }
   /**
    * Deposit funds into a specific agent, or split equally across all agents if agentId is omitted.
@@ -3711,30 +3112,18 @@ var OwneySDK = class {
       );
     }
     const agentResults = {};
-    const agentErrors = {};
     for (const { agent, amount: agentAmount } of agentAmounts) {
-      try {
-        agentResults[agent.id] = await this.depositWithFallback(
-          agent,
-          state,
-          chainId,
-          agentAmount,
-          asset,
-          effectiveCallback,
-          depositCallback
-        );
-      } 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 }
+      agentResults[agent.id] = await this.depositWithFallback(
+        agent,
+        state,
+        chainId,
+        agentAmount,
+        asset,
+        effectiveCallback,
+        depositCallback
       );
     }
-    return Object.keys(agentErrors).length > 0 ? { agentResults, agentErrors } : { agentResults };
+    return { agentResults };
   }
   /**
    * Invokes `agent.deposit` with the resolved sponsored callback, composing
@@ -3850,8 +3239,9 @@ var OwneySDK = class {
   async hasExistingBalance(agent, state, chainId, asset) {
     try {
       const balance = await agent.getBalances(state, chainId);
+      const target = asset.toLowerCase();
       const token = balance.tokens.find(
-        (t) => t.chainId === chainId && isSameAsset(t.asset, asset)
+        (t) => t.chainId === chainId && t.asset.toLowerCase() === target
       );
       return !!token && Number(token.amount) > 0;
     } catch {
@@ -3890,34 +3280,6 @@ var OwneySDK = class {
     }
     return eligible;
   }
-  /**
-   * Agent ids the routing API provisioned for this org that support the given
-   * chain + asset, ordered by preference ({@link AGENT_ELIGIBILITY_ORDER},
-   * surfliquid first). Returns `[]` when the org has no compatible agent — never
-   * throws on an empty org. Loads agent keys on first call (apiKey only, no
-   * wallet), so the UI can resolve which agent to use before the user connects.
-   *
-   * This is the source of truth for agent availability: an agent appears here
-   * iff the routing API returned its key. No per-app feature flags.
-   */
-  async getEligibleAgentIds(chainId, asset) {
-    try {
-      await this.ensureAgentsInitialized();
-    } catch (error) {
-      if (error instanceof OwneyError && error.code === "API_NO_AGENTS") {
-        return [];
-      }
-      throw error;
-    }
-    return [...this.agents.values()].filter((agent) => {
-      const chainAssets = agent.supportedAssets.find(
-        (sa) => sa.chainId === chainId
-      );
-      return chainAssets?.assets.some((a) => a.symbol === asset) ?? false;
-    }).map((agent) => agent.id).sort(
-      (a, b) => AGENT_ELIGIBILITY_ORDER.indexOf(a) - AGENT_ELIGIBILITY_ORDER.indexOf(b)
-    );
-  }
   // --- Fund operations ---
   /**
    * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
@@ -3953,17 +3315,9 @@ var OwneySDK = class {
     }
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
     if (!amount) {
-      const aggregated2 = await this.getBalances();
-      const funded = projectAgentBalancesForAsset(
-        eligibleAgents,
-        aggregated2.agentBalances,
-        chainId,
-        asset,
-        assetInfo.decimals
-      ).filter((b) => b.balance > 0n);
       const results2 = {};
       const agentErrors2 = {};
-      for (const { agent } of funded) {
+      for (const agent of eligibleAgents) {
         try {
           results2[agent.id] = await agent.withdraw(state, chainId, token);
         } catch (err) {
@@ -3980,10 +3334,9 @@ var OwneySDK = class {
           { asset, agentErrors: agentErrors2 }
         );
       }
-      const totalWithdrawn = funded.filter(({ agent }) => results2[agent.id] !== void 0).reduce((sum, { balance }) => sum + balance, 0n);
       return {
         agentResult: results2,
-        totalWithdrawn: totalWithdrawn.toString()
+        totalWithdrawn: sumWithdrawnAmount(results2).toString()
       };
     }
     const requested = BigInt(amount);
@@ -4375,10 +3728,10 @@ var OwneySDK = class {
       );
     }
     const provider = this.requireConnectedProvider();
-    const wallet = (0, import_viem7.createWalletClient)({
+    const wallet = (0, import_viem6.createWalletClient)({
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem7.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const hash = await wallet.writeContract({
       address: token,
@@ -4388,9 +3741,9 @@ var OwneySDK = class {
       account: state.walletAddress,
       chain: VIEM_CHAIN2[chainId]
     });
-    const publicClient = (0, import_viem7.createPublicClient)({
+    const publicClient = (0, import_viem6.createPublicClient)({
       chain: VIEM_CHAIN2[chainId],
-      transport: (0, import_viem7.custom)(provider)
+      transport: (0, import_viem6.custom)(provider)
     });
     const receipt = await publicClient.waitForTransactionReceipt({
       hash,
@@ -4498,11 +3851,8 @@ var OwneySDK = class {
   }
 };
 
-// src/index.ts
-init_errors();
-
 // src/agents/zyfai/zyfai.siwx.ts
-var import_viem8 = require("viem");
+var import_viem7 = require("viem");
 var import_siwe = require("siwe");
 var import_sdk2 = require("@zyfai/sdk");
 
@@ -4629,7 +3979,7 @@ function buildSIWXConfig(deps) {
       issuedAt,
       toString() {
         return new import_siwe.SiweMessage({
-          address: (0, import_viem8.getAddress)(accountAddress),
+          address: (0, import_viem7.getAddress)(accountAddress),
           chainId: numericChainId(chainId),
           domain,
           uri,