@owney/sdk 0.2.9 → 0.2.11

package/dist/index.cjs

@@ -42,17 +42,20 @@ var SupportedAssets = [
   {
     address: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`,
     symbol: "USDC",
-    chainId: 8453
+    chainId: 8453,
+    decimals: 6
   },
   {
     address: `0xaf88d065e77c8cC2239327C5EDb3A432268e5831`,
     symbol: "USDC",
-    chainId: 42161
+    chainId: 42161,
+    decimals: 6
   },
   {
     address: `0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9`,
     symbol: "USDT",
-    chainId: 42161
+    chainId: 42161,
+    decimals: 6
   }
 ];
 
@@ -60,11 +63,13 @@ var SupportedAssets = [
 var OwneyError = class extends Error {
   code;
   details;
-  constructor(code, message, details) {
-    super(message);
+  agentId;
+  constructor(code, message, details, agentId) {
+    super(agentId ? `[agent:${agentId}] ${message}` : message);
     this.name = "OwneyError";
     this.code = code;
     this.details = details;
+    this.agentId = agentId;
   }
 };
 var AgentNotFoundError = class extends OwneyError {
@@ -72,7 +77,8 @@ var AgentNotFoundError = class extends OwneyError {
     super(
       "AGENT_NOT_FOUND",
       `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
-      { agentId, available }
+      { agentId, available },
+      agentId
     );
     this.name = "AgentNotFoundError";
   }
@@ -339,7 +345,9 @@ var ZyfaiAgent = class {
     if (!this.connectedAddress) {
       throw new OwneyError(
         "NOT_CONNECTED",
-        "Wallet not connected. Call sdk.connect() first."
+        "Wallet not connected. Call sdk.connect() first.",
+        void 0,
+        this.id
       );
     }
     return this.connectedAddress;
@@ -445,13 +453,14 @@ var ZyfaiAgent = class {
     }
   }
   // --- IAgent: Fund operations ---
-  async withdraw(state, chainId, amount) {
+  async withdraw(state, chainId, token, amount) {
     await this.connectFull(state, chainId);
     const validChainId = isValidChainId(chainId);
     const raw = await this.sdk.withdrawFunds(
       this.getAddress(),
       validChainId,
-      amount
+      amount,
+      token
     );
     return mapWithdraw(raw);
   }
@@ -505,659 +514,6 @@ var ZyfaiAgent = class {
   }
 };
 
-// src/agents/sail/sail.mapper.ts
-function mapDeposit2(raw) {
-  return {
-    txHash: raw.txHash,
-    smartWallet: raw.smartWallet,
-    amount: raw.amount
-  };
-}
-function mapWithdraw2(raw) {
-  return {
-    txHash: raw.txHash,
-    type: raw.type,
-    amount: raw.amount
-  };
-}
-function mapPortfolioBalances(raw, smartWallet) {
-  let total = 0;
-  const tokens = [];
-  for (const item of raw.tokens) {
-    total += item.balanceFormatted;
-    tokens.push({
-      chain: SUPPORTED_CHAINS[item.chain],
-      chainId: item.chain,
-      asset: item.symbol === "USD\u20AE0" ? "USDT" : item.symbol,
-      amount: item.balance
-    });
-  }
-  return {
-    smartWallet,
-    totalBalance: String(total),
-    tokens
-  };
-}
-function mapEarnings2(raw, smartWallet) {
-  return {
-    smartWallet,
-    lifetimeEarnings: raw.result
-  };
-}
-function mapApyHistory2(raw, walletAddress) {
-  const apyPerAsset = remapApyPerAssetToSymbols(raw.result.apy_per_asset);
-  return {
-    walletAddress,
-    weightedApyAfterFee: raw.result.apy,
-    weightedApyAfterFeeDetails: apyPerAsset ? { apyPerAsset } : void 0
-  };
-}
-function mapSailTransaction(tx) {
-  switch (tx.type) {
-    case "deposit":
-    case "redeem":
-      return {
-        txHashes: tx.tx_hashes,
-        chainId: tx.chain_id,
-        tokenSymbol: tx.asset,
-        amount: String(tx.amount)
-      };
-    case "swap":
-      return {
-        txHashes: tx.tx_hashes,
-        chainId: tx.chain_id,
-        tokenSymbol: tx.from_asset,
-        amount: String(tx.amount)
-      };
-    case "bridge":
-      return {
-        txHashes: tx.tx_hashes,
-        chainId: Number(tx.from_chain_id),
-        tokenSymbol: tx.asset,
-        amount: String(tx.amount)
-      };
-  }
-}
-function buildRebalanceLogs(transactions, failedTransactions) {
-  const redeems = transactions.filter(
-    (tx) => tx.type === "redeem"
-  );
-  const deposits = transactions.filter(
-    (tx) => tx.type === "deposit"
-  );
-  const failedRedeems = failedTransactions.filter(
-    (tx) => tx.type === "redeem"
-  );
-  const failedDeposits = failedTransactions.filter(
-    (tx) => tx.type === "deposit"
-  );
-  const logs = [];
-  const matchedDeposits = /* @__PURE__ */ new Set();
-  const matchedRedeems = /* @__PURE__ */ new Set();
-  for (let r = 0; r < redeems.length; r++) {
-    const idx = deposits.findIndex(
-      (d, i) => !matchedDeposits.has(i) && d.amount === redeems[r].amount
-    );
-    if (idx !== -1) {
-      matchedDeposits.add(idx);
-      matchedRedeems.add(r);
-      logs.push({
-        fromProtocol: redeems[r].protocol_name,
-        toProtocol: deposits[idx].protocol_name,
-        tokenSymbol: redeems[r].asset,
-        amount: String(redeems[r].amount),
-        status: "success"
-      });
-    }
-  }
-  for (let i = 0; i < deposits.length; i++) {
-    if (matchedDeposits.has(i))
-      continue;
-    const failedRedeem = failedRedeems.find(
-      (fr) => fr.amount === deposits[i].amount
-    );
-    logs.push({
-      fromProtocol: failedRedeem ? failedRedeem.protocol_name : "Wallet",
-      toProtocol: deposits[i].protocol_name,
-      tokenSymbol: deposits[i].asset,
-      amount: String(deposits[i].amount),
-      status: failedRedeem ? "failed" : "success"
-    });
-  }
-  for (let i = 0; i < redeems.length; i++) {
-    if (matchedRedeems.has(i))
-      continue;
-    const failedDeposit = failedDeposits.find(
-      (fd) => fd.amount === redeems[i].amount
-    );
-    logs.push({
-      fromProtocol: redeems[i].protocol_name,
-      toProtocol: failedDeposit ? failedDeposit.protocol_name : "Wallet",
-      tokenSymbol: redeems[i].asset,
-      amount: String(redeems[i].amount),
-      status: failedDeposit ? "failed" : "success"
-    });
-  }
-  return logs;
-}
-function mapHistory2(raw) {
-  const actionMap = {
-    execution: "Rebalance",
-    deposit: "Top up",
-    withdraw: "Withdraw",
-    rewards: "Earned"
-  };
-  const filtered = raw.result.items.filter(
-    (i) => !(i.type === "execution" && (i.status === "failed" || !i.transactions.length))
-  );
-  return {
-    total: filtered.length,
-    data: filtered.map((entry) => ({
-      agent: "sail",
-      action: actionMap[entry.type] ?? entry.type,
-      date: entry.time,
-      newApy: String(entry.new_apy),
-      oldApy: String(entry.previous_apy),
-      transactions: (entry.transactions ?? []).map(mapSailTransaction),
-      rebalanceLog: buildRebalanceLogs(
-        entry.transactions ?? [],
-        entry.failed_transactions ?? []
-      )
-    }))
-  };
-}
-function mapAgentStatus2(raw) {
-  return {
-    success: raw.success,
-    strategy: raw.strategy,
-    protocols: raw.protocols
-  };
-}
-function mapUserProfile2(raw) {
-  return {
-    address: raw.result.smart_account,
-    smartWallet: raw.result.smart_account,
-    chains: [],
-    hasActiveSessionKey: false,
-    protocols: []
-  };
-}
-function mapApyByStrategy2(raw) {
-  const apyPerAsset = remapApyPerAssetToSymbols(raw.result.apy_per_asset);
-  return {
-    averageApy: raw.result.apy,
-    detailedApys: apyPerAsset ? { apyPerAsset } : void 0
-  };
-}
-function remapApyPerAssetToSymbols(raw) {
-  if (!raw)
-    return void 0;
-  const remapped = {};
-  for (const asset of SupportedAssets) {
-    const chainKey = asset.chainId;
-    const apyByAddress = raw[String(chainKey)];
-    if (!apyByAddress)
-      continue;
-    const apy = apyByAddress[asset.address] ?? apyByAddress[asset.address.toLowerCase()];
-    if (apy === void 0)
-      continue;
-    const bucket = remapped[chainKey] ?? {};
-    bucket[asset.symbol] = apy;
-    remapped[chainKey] = bucket;
-  }
-  return Object.keys(remapped).length > 0 ? remapped : void 0;
-}
-
-// src/agents/sail/sail.agent.ts
-var SAIL_API_BASE = "https://app.sail.money";
-var PROJECT_ID = "sail";
-var PAGE_ID = "home";
-var SAIL_PORTFOLIO_TIMEOUT_MS = 8e3;
-var SailAgent = class {
-  id = "sail";
-  minDepositAmount = "4800000000";
-  supportedChainIds = [8453, 42161];
-  supportedAssets = [
-    {
-      chainId: 8453,
-      chain: "BASE",
-      assets: ["USDC"]
-    },
-    {
-      chainId: 42161,
-      chain: "ARBITRUM",
-      assets: ["USDC", "USDT"]
-    }
-  ];
-  apiKey;
-  authToken = null;
-  accountToken = null;
-  connectedAddress = null;
-  smartWalletAddress = null;
-  connectedChainId = null;
-  connectPromise = null;
-  constructor(apiKey) {
-    this.apiKey = apiKey;
-  }
-  // --- Private helpers ---
-  async request(method, path, body, timeoutMs) {
-    const headers = {
-      "Content-Type": "application/json",
-      "X-Business-API-Key": this.apiKey
-    };
-    if (this.authToken) {
-      headers["Authorization"] = `Bearer ${this.authToken}`;
-    }
-    if (this.accountToken) {
-      headers["X-Account-Token"] = this.accountToken;
-    }
-    const controller = new AbortController();
-    const timeoutId = typeof timeoutMs === "number" && timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
-    let res;
-    try {
-      res = await fetch(`${SAIL_API_BASE}${path}`, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal
-      });
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError" && timeoutMs) {
-        throw new OwneyError(
-          "API_SAIL_TIMEOUT",
-          `Sail API timeout ${timeoutMs}ms: ${method} ${path}`,
-          { timeoutMs, method, path }
-        );
-      }
-      throw error;
-    } finally {
-      if (timeoutId)
-        clearTimeout(timeoutId);
-    }
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new OwneyError(
-        "API_SAIL_ERROR",
-        `Sail API error ${res.status}: ${text}`,
-        { statusCode: res.status, method, path, responseBody: text }
-      );
-    }
-    return res.json();
-  }
-  /** Initiate SIWE and sign with the user's wallet. */
-  async signSiwe(state, chainId) {
-    const initiate = await this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/auth/initiate`,
-      {
-        method: "siwe",
-        address: state.walletAddress,
-        chainId,
-        identityMode: "byWallet"
-      }
-    );
-    const signature = await state.provider.request({
-      method: "personal_sign",
-      params: [initiate.message, state.walletAddress]
-    });
-    return {
-      sessionId: initiate.sessionId,
-      message: initiate.message,
-      signature
-    };
-  }
-  /** Full connect: auth handles smart account creation via SIWE flow. */
-  async connectFull(state, chainId) {
-    if (this.connectedAddress && this.connectedChainId === chainId) {
-      return;
-    }
-    if (this.connectPromise) {
-      await this.connectPromise;
-      return;
-    }
-    if (!state.walletAddress) {
-      throw new OwneyError(
-        "WALLET_ADDRESS_REQUIRED",
-        "Wallet address is required. Call sdk.connect(provider) first."
-      );
-    }
-    this.connectPromise = (async () => {
-      const { sessionId, signature, message } = await this.signSiwe(
-        state,
-        chainId
-      );
-      const complete = await this.request(
-        "POST",
-        `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/auth/complete`,
-        {
-          method: "custom",
-          sessionId,
-          signature,
-          walletAddress: state.walletAddress,
-          identityMode: "byWallet"
-        }
-      );
-      this.authToken = complete.token;
-      this.accountToken = complete.accountToken;
-      this.connectedAddress = state.walletAddress;
-      this.smartWalletAddress = complete.walletAddress;
-      this.connectedChainId = chainId;
-    })();
-    try {
-      await this.connectPromise;
-    } finally {
-      this.connectPromise = null;
-    }
-  }
-  async resolveSmartWallet(state, chainId) {
-    await this.connectFull(state, chainId);
-    const validChainId = isValidChainId(chainId);
-    if (!this.smartWalletAddress) {
-      throw new OwneyError(
-        "NOT_CONNECTED",
-        "Wallet not connected. Call sdk.connect() first."
-      );
-    }
-    return {
-      smartWallet: this.smartWalletAddress,
-      chainId: validChainId
-    };
-  }
-  // --- IAgent: Connection lifecycle ---
-  async disconnect() {
-    this.authToken = null;
-    this.accountToken = null;
-    this.connectedAddress = null;
-    this.smartWalletAddress = null;
-    this.connectedChainId = null;
-  }
-  // --- IAgent: Account lifecycle ---
-  async activateAgent(state, chainId) {
-    try {
-      await this.connectFull(state, chainId);
-    } catch (error) {
-      await this.disconnect();
-      throw error;
-    }
-  }
-  async deposit(state, chainId, amount, depositCallback) {
-    if (!depositCallback) {
-      throw new OwneyError(
-        "DEPOSIT_CALLBACK_REQUIRED",
-        "depositCallback is required for Sail. Provide a callback that transfers tokens and returns the transaction hash."
-      );
-    }
-    try {
-      const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-      const depositInfo = await this.getDepositInfo();
-      const resolvedTokenAddress = depositInfo.permittedTokens[0]?.address;
-      if (!resolvedTokenAddress) {
-        throw new OwneyError(
-          "DEPOSIT_NO_PERMITTED_TOKENS",
-          "No permitted tokens available for deposit."
-        );
-      }
-      await this.executePreHooks(resolvedTokenAddress, amount, chainId);
-      const txHash = await depositCallback(smartWallet, chainId, amount);
-      if (!txHash) {
-        throw new OwneyError(
-          "DEPOSIT_CALLBACK_INVALID",
-          "depositCallback must return a transaction hash (txHash) for Sail deposits."
-        );
-      }
-      const postResult = await this.executePostHooks(
-        resolvedTokenAddress,
-        amount,
-        chainId,
-        txHash
-      );
-      return mapDeposit2({
-        txHash: postResult.transactionHash,
-        smartWallet,
-        amount
-      });
-    } catch (error) {
-      await this.disconnect();
-      throw error;
-    }
-  }
-  // --- Private deposit flow helpers ---
-  async getDepositInfo() {
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/deposit-info`
-    );
-  }
-  async executePreHooks(tokenAddress, amount, chainId) {
-    return this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/deposit/pre-hooks`,
-      { tokenAddress, amount, chainId }
-    );
-  }
-  async executePostHooks(tokenAddress, amount, chainId, txHash) {
-    return this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/deposit/post-hooks`,
-      { tokenAddress, amount, chainId, txHash }
-    );
-  }
-  // --- Private withdraw flow helpers ---
-  async getWithdrawInfo() {
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/withdraw-info`
-    );
-  }
-  // --- IAgent: Fund operations ---
-  async withdraw(state, chainId, amount) {
-    await this.connectFull(state, chainId);
-    const withdrawInfo = await this.getWithdrawInfo();
-    const tokenAddress = withdrawInfo.permittedTokens[0]?.address;
-    if (!tokenAddress) {
-      throw new OwneyError(
-        "WITHDRAW_NO_PERMITTED_TOKENS",
-        "No permitted tokens available for withdrawal."
-      );
-    }
-    const resolvedAmount = amount ?? withdrawInfo.currentBalance;
-    const { signature: adminWalletSignature, message: adminWalletPayload } = await this.signSiwe(state, chainId);
-    const payload = {
-      amount: String(resolvedAmount),
-      tokenAddress,
-      chainId,
-      adminWalletSignature,
-      adminWalletPayload
-    };
-    const raw = await this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/withdraw`,
-      payload
-    );
-    return mapWithdraw2({
-      txHash: raw.transactionHash,
-      type: amount ? "partial" : "full",
-      amount: resolvedAmount
-    });
-  }
-  // --- IAgent: Portfolio reads ---
-  async getBalances(state, chainId) {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    try {
-      const raw = await this.getPortfolio();
-      return mapPortfolioBalances(raw, smartWallet);
-    } catch (error) {
-      if (error instanceof OwneyError && error.code === "API_SAIL_TIMEOUT") {
-        console.warn(
-          "Sail portfolio request timed out; using empty snapshot.",
-          {
-            chainId
-          }
-        );
-        return mapPortfolioBalances(
-          { message: "timeout", tokens: [] },
-          smartWallet
-        );
-      }
-      throw error;
-    }
-  }
-  async getEarnings(state, chainId) {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.getMetricsEarnings(state, chainId);
-    return mapEarnings2(raw, smartWallet);
-  }
-  async getAccountApy(state, chainId, days) {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.getMetricsYield(days, state, chainId);
-    return mapApyHistory2(raw, smartWallet);
-  }
-  async getHistory(state, chainId, options) {
-    const raw = await this.getMetricsHistory(state, chainId, options);
-    return mapHistory2(raw);
-  }
-  // -- Sail-specific: Metrics ---
-  async getMetricsPortfolio(state, chainId) {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/portfolio?${smartWallet ? `smart_account=${smartWallet}` : ""}`,
-      void 0,
-      SAIL_PORTFOLIO_TIMEOUT_MS
-    );
-  }
-  async getPortfolio() {
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/portfolio/tokens`,
-      void 0,
-      SAIL_PORTFOLIO_TIMEOUT_MS
-    );
-  }
-  async getMetricsEarnings(state, chainId) {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/earnings?smart_account=${smartWallet}`
-    );
-  }
-  async getMetricsBalance(state, chainId, currency = "usd") {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/balance?smart_account=${smartWallet}&currency=${currency}&limit=1000`
-    );
-  }
-  async getMetricsHistory(state, chainId, filters) {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const params = new URLSearchParams();
-    params.set("smart_account", smartWallet);
-    if (filters?.fromDate) {
-      params.set("start_date", filters.fromDate);
-    }
-    if (filters?.toDate) {
-      params.set("end_date", filters.toDate);
-    }
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/history?${params.toString()}`
-    );
-  }
-  async getMetricsUser(state, chainId, currency) {
-    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/user-metrics?smart_account=${smartWallet}&currency=${currency}`
-    );
-  }
-  async getMetricsYield(days, state, chainId) {
-    let walletAddress = "";
-    if (state && chainId) {
-      const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-      walletAddress = smartWallet;
-    }
-    const dayCount = DayFilterMapping[days];
-    if (dayCount === void 0) {
-      throw new OwneyError(
-        "VALIDATION_INVALID_DAYS",
-        `Invalid days value: "${days}". Expected one of: "7D", "14D", "30D".`,
-        { days }
-      );
-    }
-    const now = /* @__PURE__ */ new Date();
-    const end = now.toISOString().split("T")[0];
-    const start = new Date(now.getTime() - dayCount * 864e5).toISOString().split("T")[0];
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/yield?start=${start}&end=${end}${walletAddress ? `&smart_account=${walletAddress}` : ""}`
-    );
-  }
-  // --- Sail-specific: Automation jobs ---
-  async getAutomationStatus(state, chainId) {
-    await this.connectFull(state, chainId);
-    return this.request(
-      "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/automation/status`
-    );
-  }
-  async startAutomation(state, chainId, graphId, prompt, options) {
-    await this.connectFull(state, chainId);
-    return this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/automation/start`,
-      {
-        graphId,
-        prompt,
-        paramValues: options?.paramValues ?? {},
-        iterations: options?.iterations ?? 1,
-        branchId: options?.branchId
-      }
-    );
-  }
-  async pauseAutomation(state, chainId) {
-    await this.connectFull(state, chainId);
-    return this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/automation/pause`
-    );
-  }
-  async resumeAutomation(state, chainId) {
-    await this.connectFull(state, chainId);
-    return this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/automation/resume`
-    );
-  }
-  async stopAutomation(state, chainId) {
-    await this.connectFull(state, chainId);
-    return this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/automation/stop`
-    );
-  }
-  // --- IAgent: Agent control ---
-  async pause(state, chainId) {
-    await this.connectFull(state, chainId);
-    await this.pauseAutomation(state, chainId);
-    return mapAgentStatus2({ success: true });
-  }
-  async resume(state, chainId) {
-    await this.connectFull(state, chainId);
-    await this.resumeAutomation(state, chainId);
-    return mapAgentStatus2({ success: true });
-  }
-  async getUserProfile(state, chainId) {
-    await this.connectFull(state, chainId);
-    const raw = await this.getMetricsUser(state, chainId, "usd");
-    return mapUserProfile2(raw);
-  }
-  // --- IAgent: Discovery (no wallet required) ---
-  async getAgentApy(days, _options) {
-    const raw = await this.getMetricsYield(days);
-    return mapApyByStrategy2(raw);
-  }
-};
-
 // src/lib/routing-api.ts
 var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function fetchAgentKeys(apiKey) {
@@ -1188,7 +544,65 @@ async function fetchAgentKeys(apiKey) {
   return json.data;
 }
 
+// src/lib/helpers/withdraw-helper.ts
+function planProportionalShares(balances, requested, totalAvailable) {
+  const plans = balances.map(({ agent, balance }) => ({
+    agent,
+    balance,
+    planned: totalAvailable > 0n ? balance * requested / totalAvailable : 0n
+  }));
+  const assigned = plans.reduce((s, p) => s + p.planned, 0n);
+  let remainder = requested - assigned;
+  const byHeadroom = [...plans].sort((a, b) => {
+    const diff = b.balance - b.planned - (a.balance - a.planned);
+    return diff > 0n ? 1 : diff < 0n ? -1 : 0;
+  });
+  for (const p of byHeadroom) {
+    if (remainder === 0n)
+      break;
+    const headroom = p.balance - p.planned;
+    if (headroom <= 0n)
+      continue;
+    const take = headroom < remainder ? headroom : remainder;
+    p.planned += take;
+    remainder -= take;
+  }
+  return plans;
+}
+function redistributeShare(plans, fromIndex, amount) {
+  const candidates = plans.slice(fromIndex + 1).filter((c) => c.balance - c.planned > 0n);
+  const totalHeadroom = candidates.reduce(
+    (s, c) => s + (c.balance - c.planned),
+    0n
+  );
+  if (totalHeadroom === 0n)
+    return;
+  let distributed = 0n;
+  for (const c of candidates) {
+    const headroom = c.balance - c.planned;
+    const proportional = headroom * amount / totalHeadroom;
+    const give = proportional > headroom ? headroom : proportional;
+    c.planned += give;
+    distributed += give;
+  }
+  let leftover = amount - distributed;
+  for (const c of candidates) {
+    if (leftover === 0n)
+      break;
+    const headroom = c.balance - c.planned;
+    if (headroom <= 0n)
+      continue;
+    const take = headroom < leftover ? headroom : leftover;
+    c.planned += take;
+    leftover -= take;
+  }
+}
+function sumWithdrawnAmount(results) {
+  return Object.values(results).reduce((sum, r) => sum + BigInt(r.amount), 0n);
+}
+
 // src/client.ts
+var import_viem = require("viem");
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
@@ -1305,9 +719,6 @@ var OwneySDK = class {
     if (agentId === "zyfai") {
       return new ZyfaiAgent(key, this.zyfaiRpcUrls);
     }
-    if (agentId === "sail") {
-      return new SailAgent(key);
-    }
     return null;
   }
   // --- Account lifecycle ---
@@ -1464,7 +875,8 @@ var OwneySDK = class {
       throw new OwneyError(
         "ASSET_UNSUPPORTED",
         `Agent "${agent.id}" does not support asset "${asset}" on chain ${chainId}.`,
-        { agentId: agent.id, asset, chainId }
+        { agentId: agent.id, asset, chainId },
+        agent.id
       );
     }
   }
@@ -1498,34 +910,99 @@ var OwneySDK = class {
     const { asset, amount, agentId } = options;
     const state = this.requireState();
     const chainId = this.requireChainId();
+    const token = asset;
+    const assetInfo = SupportedAssets.find(
+      (a) => a.chainId === chainId && a.symbol === token
+    );
+    if (!assetInfo) {
+      throw new OwneyError(
+        "WITHDRAW_NO_PERMITTED_TOKENS",
+        "Asset selected is not supported"
+      );
+    }
     if (agentId) {
       const agent = this.getAgent(agentId);
       this.validateAssetSupport(agent, chainId, asset);
-      return agent.withdraw(state, chainId, amount);
+      return agent.withdraw(state, chainId, token, amount);
     }
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
     if (!amount) {
       const results2 = {};
       for (const agent of eligibleAgents) {
-        results2[agent.id] = await agent.withdraw(state, chainId);
+        results2[agent.id] = await agent.withdraw(state, chainId, token);
       }
       return { agentResult: results2 };
     }
+    const requested = BigInt(amount);
+    const aggregated = await this.getBalances();
+    const balances = eligibleAgents.map((agent) => {
+      const agentBalance = aggregated.agentBalances[agent.id];
+      const tokenBalance = agentBalance?.tokens.find(
+        (t) => t.chainId === chainId && t.asset === asset
+      );
+      if (!tokenBalance)
+        return { agent, balance: 0n };
+      const balance = (0, import_viem.parseUnits)(tokenBalance.amount, assetInfo.decimals);
+      return { agent, balance };
+    });
+    const totalAvailable = balances.reduce((sum, x) => sum + x.balance, 0n);
+    if (totalAvailable < requested) {
+      throw new OwneyError(
+        "WITHDRAW_INSUFFICIENT_BALANCE",
+        `Requested withdrawal "${amount}" exceeds available balance "${totalAvailable.toString()}" for asset "${asset}".`,
+        {
+          asset,
+          requested: amount,
+          available: totalAvailable.toString()
+        }
+      );
+    }
+    const plans = planProportionalShares(balances, requested, totalAvailable);
     const results = {};
-    let lastError;
-    for (const agent of eligibleAgents) {
+    const agentErrors = {};
+    for (let i = 0; i < plans.length; i++) {
+      const p = plans[i];
+      if (p.planned === 0n)
+        continue;
       try {
-        results[agent.id] = await agent.withdraw(state, chainId, amount);
-        return { agentResult: results };
+        results[p.agent.id] = await p.agent.withdraw(
+          state,
+          chainId,
+          token,
+          p.planned.toString()
+        );
       } catch (err) {
-        lastError = err;
+        console.error(`withdraw failed for agent "${p.agent.id}":`, err);
+        agentErrors[p.agent.id] = err instanceof Error ? err.message : String(err);
+        redistributeShare(plans, i, p.planned);
       }
     }
-    if (lastError)
-      throw lastError;
-    return {
-      agentResult: results
-    };
+    if (Object.keys(results).length === 0) {
+      throw new OwneyError(
+        "WITHDRAW_ALL_FAILED",
+        `Failed to withdraw "${amount}" of "${asset}" from all eligible agents.`,
+        {
+          asset,
+          amount,
+          agentErrors
+        }
+      );
+    }
+    const withdrawn = sumWithdrawnAmount(results);
+    if (withdrawn < requested) {
+      throw new OwneyError(
+        "WITHDRAW_PARTIAL_FAILURE",
+        `Withdrew "${withdrawn.toString()}" of requested "${amount}" of "${asset}". One or more agents failed; remaining balance could not cover the shortfall.`,
+        {
+          asset,
+          requested: amount,
+          withdrawn: withdrawn.toString(),
+          partialResults: results,
+          agentErrors
+        }
+      );
+    }
+    return { agentResult: results };
   }
   // --- Portfolio reads ---
   /**
@@ -1550,7 +1027,10 @@ var OwneySDK = class {
       })
     );
     let successCount = 0;
-    for (const settledResult of balanceResults) {
+    const agentErrors = {};
+    for (let i = 0; i < balanceResults.length; i++) {
+      const settledResult = balanceResults[i];
+      const [agentId2] = entries[i];
       if (settledResult.status === "fulfilled") {
         const [id, b] = settledResult.value;
         results[id] = b;
@@ -1558,12 +1038,14 @@ var OwneySDK = class {
         successCount += 1;
         continue;
       }
-      console.error("getBalances agent failed:", settledResult.reason);
+      const reason = settledResult.reason;
+      agentErrors[agentId2] = reason instanceof Error ? reason.message : String(reason);
     }
     if (successCount === 0) {
       throw new OwneyError(
         "BALANCE_ALL_FAILED",
-        "Failed to fetch balances for all active agents."
+        "Failed to fetch balances for all active agents.",
+        { agentErrors }
       );
     }
     return {
@@ -1658,10 +1140,6 @@ var OwneySDK = class {
         totalApy += agentApy * weight;
       }
     }
-    console.log("account apy", {
-      totalApy: String(totalApy),
-      agentApy: results
-    });
     return {
       totalApy: String(totalApy),
       agentApy: results
@@ -1753,7 +1231,7 @@ var OwneySDK = class {
    * @param options.days - Lookback period: "7D", "14D", or "30D"
    * @param options.tokenSymbol - Optional asset symbol ("USDC" / "WETH") to
    *   scope the APY to a specific asset+chain. Agents whose backends do not
-   *   support per-asset APY (currently Sail) ignore this.
+   *   support per-asset APY ignore this.
    * @param options.chainId - Optional chain id for per-asset APY lookups.
    *   Typically paired with `tokenSymbol`.
    * @returns {AgentApy} for a single agent, or {OwneyAgentApy} with per-agent APY
@@ -1802,20 +1280,26 @@ var OwneySDK = class {
       })
     );
     let successCount = 0;
-    for (const settledResult of balanceResults) {
+    const agentErrors = {};
+    for (let i = 0; i < balanceResults.length; i++) {
+      const settledResult = balanceResults[i];
+      const [agentId] = entries[i];
       if (settledResult.status === "fulfilled") {
         const [id, bal] = settledResult.value;
         balances[id] = bal;
         totalBalance += bal;
         successCount += 1;
       } else {
-        console.error("getAgentAllocation agent failed:", settledResult.reason);
+        const reason = settledResult.reason;
+        agentErrors[agentId] = reason instanceof Error ? reason.message : String(reason);
+        console.error(`getAgentAllocation agent "${agentId}" failed:`, reason);
       }
     }
     if (successCount === 0) {
       throw new OwneyError(
         "ALLOCATION_ALL_FAILED",
-        "Failed to fetch allocation: all agents failed."
+        "Failed to fetch allocation: all agents failed.",
+        { agentErrors }
       );
     }
     const allocation = {};