@owney/sdk 0.2.5

package/dist/index.cjs

@@ -0,0 +1,1465 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AgentChainIncompatibleError: () => AgentChainIncompatibleError,
+  AgentNotFoundError: () => AgentNotFoundError,
+  NotConnectedError: () => NotConnectedError,
+  OwneySDK: () => OwneySDK
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/agents/zyfai/zyfai.agent.ts
+var import_sdk = require("@zyfai/sdk");
+
+// src/types/config.ts
+var P_SUPPORTED_CHAINS = {
+  chainIds: [8453, 42161],
+  chains: ["BASE", "ARBITRUM"]
+};
+var SUPPORTED_CHAIN_IDS = P_SUPPORTED_CHAINS.chainIds;
+var SUPPORTED_CHAINS = P_SUPPORTED_CHAINS.chains;
+
+// src/lib/utils.ts
+var isValidChainId = (chainId) => {
+  if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
+    throw new Error(
+      `Unsupported chain ID: ${chainId}. Supported chains: ${SUPPORTED_CHAIN_IDS.join(", ")}`
+    );
+  }
+  return 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);
+  const divisor = BigInt(10 ** decimals);
+  const whole = parsed / divisor;
+  const remainder = parsed % divisor;
+  return Number(whole) + Number(remainder) / Number(divisor);
+}
+var DayFilterMapping = {
+  "30D": 30,
+  "14D": 14,
+  "7D": 7
+};
+
+// src/agents/zyfai/zyfai.mapper.ts
+function mapDeposit(raw) {
+  return {
+    txHash: raw.txHash,
+    smartWallet: raw.smartWallet,
+    amount: raw.amount
+  };
+}
+function mapWithdraw(raw) {
+  return {
+    txHash: raw.txHash,
+    type: raw.type,
+    amount: raw.amount
+  };
+}
+var CHAIN_ID_TO_NAME = {
+  8453: "BASE",
+  42161: "ARBITRUM"
+};
+var CHAIN_NAME_TO_ID = {
+  BASE: 8453,
+  ARBITRUM: 42161
+};
+function mapBalances(raw, chainId) {
+  const portfolio = raw.portfolio;
+  const tokenMap = /* @__PURE__ */ new Map();
+  for (const p of portfolio.positions || []) {
+    const symbol = p.token_symbol || "USDC";
+    const positionChainId = (p.chain ? CHAIN_NAME_TO_ID[p.chain.toUpperCase()] : void 0) ?? chainId;
+    const key = `${symbol}:${positionChainId}`;
+    const current = tokenMap.get(key);
+    tokenMap.set(key, {
+      symbol,
+      chainId: positionChainId,
+      amount: (current?.amount ?? 0) + hexToDecimal(p.amount || "0")
+    });
+  }
+  for (const s of portfolio.staleBalances || []) {
+    const symbol = s.tokenSymbol || "USDC";
+    const staleChainId = s.chainId ?? chainId;
+    const key = `${symbol}:${staleChainId}`;
+    const current = tokenMap.get(key);
+    tokenMap.set(key, {
+      symbol,
+      chainId: staleChainId,
+      amount: (current?.amount ?? 0) + hexToDecimal(s.balance || "0")
+    });
+  }
+  let totalBalance = 0;
+  const tokens = [];
+  for (const [, entry] of tokenMap) {
+    totalBalance += entry.amount;
+    tokens.push({
+      chain: CHAIN_ID_TO_NAME[entry.chainId] ?? "BASE",
+      chainId: entry.chainId,
+      asset: entry.symbol,
+      amount: String(entry.amount)
+    });
+  }
+  return {
+    smartWallet: portfolio.smartWallet,
+    totalBalance: String(totalBalance),
+    tokens
+  };
+}
+function sumTokenValues(tokens) {
+  return Object.values(tokens).reduce((sum, val) => sum + val, 0);
+}
+function sumTokenEarnings(tokens) {
+  return Object.values(tokens).reduce((sum, val) => sum + Number(val), 0);
+}
+function mapEarnings(raw, smartWallet) {
+  return {
+    smartWallet,
+    lifetimeEarnings: sumTokenEarnings(raw.data.totalEarningsByToken)
+  };
+}
+function mapApyHistory(raw) {
+  return {
+    walletAddress: raw.walletAddress,
+    weightedApyAfterFee: raw.weightedApyAfterFee ? sumTokenValues(raw.weightedApyAfterFee) : void 0
+  };
+}
+function mapHistory(raw) {
+  const actionMap = {
+    "Deposit to protocol": "Deposit",
+    "Top up wallet": "Top up",
+    "Withdraw from protocol": "Withdraw",
+    Rebalance: "Rebalance"
+  };
+  return {
+    total: raw.total,
+    data: raw.data.map((entry) => {
+      const rawLog = entry.rebalanceLog;
+      const positions = entry.positions ?? [];
+      let rebalanceLog = [];
+      let oldApy = null;
+      let newApy = null;
+      if (rawLog) {
+        const matched = positions.find(
+          (p) => p.protocol_name ? rawLog.newOpportunity.includes(`${p.protocol_name} (${p.pool})`) : false
+        );
+        oldApy = Number(rawLog.oldApy);
+        newApy = Number(rawLog.newApy);
+        rebalanceLog = [
+          {
+            fromProtocol: rawLog.oldOpportunity.replace(/\s*\(.*?\)/g, "").trim(),
+            toProtocol: rawLog.newOpportunity.replace(/\s*\(.*?\)/g, "").trim(),
+            tokenSymbol: matched?.token_symbol ?? "",
+            amount: matched ? String(hexToDecimal(matched.amount || "0x")) : "",
+            status: "success"
+          }
+        ];
+      }
+      return {
+        agent: "zyfai",
+        action: (entry.action ? actionMap[entry.action] : void 0) ?? entry.action,
+        date: entry.date || "",
+        newApy: String(newApy),
+        oldApy: String(oldApy),
+        transactions: [
+          {
+            txHashes: entry.transactionHash ? [entry.transactionHash] : [],
+            chainId: entry.chainId,
+            tokenSymbol: entry?.positions?.[0]?.token_symbol,
+            amount: String(hexToDecimal(entry?.positions?.[0]?.amount || "0x"))
+          }
+        ],
+        rebalanceLog
+      };
+    })
+  };
+}
+function mapAgentStatus(raw) {
+  return {
+    success: raw.success,
+    strategy: raw.strategy,
+    protocols: raw.protocols
+  };
+}
+function mapUserProfile(raw, userAddress) {
+  return {
+    address: userAddress,
+    smartWallet: raw.smartWallet || "",
+    chains: raw.chains || [],
+    strategy: raw.strategy,
+    hasActiveSessionKey: raw.hasActiveSessionKey || false,
+    protocols: raw.protocols || []
+  };
+}
+function mapApyByStrategy(raw) {
+  const first = raw.data[0];
+  return {
+    averageApy: first?.average_apy ?? 0
+  };
+}
+
+// src/agents/zyfai/zyfai.agent.ts
+var ZyfaiAgent = class {
+  id = "zyfai";
+  supportedChainIds = [8453, 42161];
+  supportedAssets = [
+    {
+      chainId: 8453,
+      chain: "BASE",
+      assets: ["USDC"]
+    },
+    {
+      chainId: 42161,
+      chain: "ARBITRUM",
+      assets: ["USDC"]
+    }
+  ];
+  sdk;
+  connectedAddress = null;
+  connectedChainId = null;
+  constructor(apiKey) {
+    this.sdk = new import_sdk.ZyfaiSDK({ apiKey });
+  }
+  // --- Private helpers ---
+  getAddress() {
+    if (!this.connectedAddress) {
+      throw new Error("Wallet not connected. Call sdk.connect() first.");
+    }
+    return this.connectedAddress;
+  }
+  /** Light connect: SIWE auth only. Re-auths if chain changed. */
+  async connectAuth(state, chainId) {
+    const validChainId = isValidChainId(chainId);
+    if (!this.connectedAddress || this.connectedChainId !== validChainId) {
+      const address = await this.sdk.connectAccount(
+        state.provider,
+        validChainId
+      );
+      this.connectedAddress = address;
+      this.connectedChainId = validChainId;
+    }
+  }
+  /** Full connect: SIWE auth + Safe deploy check + session key. */
+  async connectFull(state, chainId) {
+    await this.connectAuth(state, chainId);
+    const validChainId = isValidChainId(chainId);
+    const address = this.getAddress();
+    const wallet = await this.sdk.getSmartWalletAddress(address, validChainId);
+    if (!wallet.isDeployed) {
+      await this.sdk.deploySafe(address, validChainId, "aggressive", true);
+    }
+    const user = await this.sdk.getUserDetails();
+    if (!user.hasActiveSessionKey) {
+      await this.sdk.createSessionKey(address, validChainId);
+    }
+  }
+  /** Connect + resolve smart wallet address for read operations. */
+  async resolveSmartWallet(state, chainId) {
+    await this.connectAuth(state, chainId);
+    const validChainId = isValidChainId(chainId);
+    const { address } = await this.sdk.getSmartWalletAddress(
+      this.getAddress(),
+      validChainId
+    );
+    return { smartWallet: address, chainId: validChainId };
+  }
+  // --- IAgent: Connection lifecycle ---
+  async disconnect() {
+    await this.sdk.disconnectAccount();
+    this.connectedAddress = 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) {
+    try {
+      await this.connectFull(state, chainId);
+      const validChainId = isValidChainId(chainId);
+      if (depositCallback) {
+        const wallet = await this.sdk.getSmartWalletAddress(
+          this.getAddress(),
+          validChainId
+        );
+        const txHash = await depositCallback(
+          wallet.address,
+          validChainId,
+          amount
+        );
+        await this.sdk.logDeposit(validChainId, txHash, amount);
+        return { txHash, smartWallet: wallet.address, amount };
+      }
+      const raw = await this.sdk.depositFunds(
+        this.getAddress(),
+        validChainId,
+        amount
+      );
+      return mapDeposit(raw);
+    } catch (error) {
+      await this.disconnect();
+      throw error;
+    }
+  }
+  // --- IAgent: Fund operations ---
+  async withdraw(state, chainId, amount) {
+    await this.connectFull(state, chainId);
+    const validChainId = isValidChainId(chainId);
+    const raw = await this.sdk.withdrawFunds(
+      this.getAddress(),
+      validChainId,
+      amount
+    );
+    return mapWithdraw(raw);
+  }
+  // --- IAgent: Portfolio reads ---
+  async getBalances(state, chainId) {
+    await this.connectAuth(state, chainId);
+    const validChainId = isValidChainId(chainId);
+    const raw = await this.sdk.getPositions(this.getAddress(), validChainId);
+    return mapBalances(raw, validChainId);
+  }
+  async getEarnings(state, chainId) {
+    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
+    const raw = await this.sdk.calculateOnchainEarnings(smartWallet);
+    return mapEarnings(raw, smartWallet);
+  }
+  async getAccountApy(state, chainId, days) {
+    const { smartWallet } = await this.resolveSmartWallet(state, chainId);
+    const raw = await this.sdk.getDailyApyHistory(smartWallet, days);
+    return mapApyHistory(raw);
+  }
+  async getHistory(state, chainId, options) {
+    const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
+    const raw = await this.sdk.getHistory(smartWallet, validChainId, options);
+    return mapHistory(raw);
+  }
+  // --- IAgent: Agent control ---
+  async pause(state, chainId) {
+    await this.connectAuth(state, chainId);
+    const raw = await this.sdk.pauseAgent();
+    return mapAgentStatus(raw);
+  }
+  async resume(state, chainId) {
+    await this.connectAuth(state, chainId);
+    const raw = await this.sdk.resumeAgent();
+    return mapAgentStatus(raw);
+  }
+  async getUserProfile(state, chainId) {
+    await this.connectAuth(state, chainId);
+    const raw = await this.sdk.getUserDetails();
+    return mapUserProfile(raw, this.connectedAddress);
+  }
+  // --- IAgent: Discovery (no wallet required) ---
+  async getAgentApy(days) {
+    const raw = await this.sdk.getAPYPerStrategy(
+      false,
+      DayFilterMapping[days],
+      "aggressive"
+    );
+    return mapApyByStrategy(raw);
+  }
+};
+
+// 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.result) {
+    total += item.usd_value;
+    tokens.push({
+      chain: item.chain.toUpperCase(),
+      chainId: item.chain_id,
+      asset: item.token === "USD\u20AE0" ? "USDT" : item.token,
+      amount: String(item.usd_value)
+    });
+  }
+  return {
+    smartWallet,
+    totalBalance: String(total),
+    tokens
+  };
+}
+function mapEarnings2(raw, smartWallet) {
+  return {
+    smartWallet,
+    lifetimeEarnings: raw.result
+  };
+}
+function mapApyHistory2(raw, walletAddress) {
+  return {
+    walletAddress,
+    weightedApyAfterFee: raw.result
+  };
+}
+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.status === "success" && 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) {
+  return {
+    averageApy: raw.result
+  };
+}
+
+// src/agents/sail/sail.agent.ts
+var SAIL_API_BASE = "https://app.sail.money";
+var PROJECT_ID = "sail";
+var PAGE_ID = "home";
+var SailAgent = class {
+  id = "sail";
+  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;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  // --- Private helpers ---
+  async request(method, path, body) {
+    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 res = await fetch(`${SAIL_API_BASE}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Sail API error ${res.status}: ${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
+      }
+    );
+    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 (!state.walletAddress) {
+      throw new Error("Wallet address is required");
+    }
+    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
+      }
+    );
+    this.authToken = complete.token;
+    this.accountToken = complete.accountToken;
+    this.connectedAddress = state.walletAddress;
+    this.smartWalletAddress = complete.walletAddress;
+    this.connectedChainId = chainId;
+  }
+  async resolveSmartWallet(state, chainId) {
+    await this.connectFull(state, chainId);
+    const validChainId = isValidChainId(chainId);
+    if (!this.smartWalletAddress) {
+      throw new Error("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 Error(
+        "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 Error("No permitted tokens available for deposit.");
+      }
+      await this.executePreHooks(resolvedTokenAddress, amount, chainId);
+      const txHash = await depositCallback(smartWallet, chainId, amount);
+      if (!txHash) {
+        throw new Error(
+          "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 Error("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);
+    const raw = await this.getMetricsPortfolio(state, chainId);
+    return mapPortfolioBalances(raw, smartWallet);
+  }
+  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}` : ""}`
+    );
+  }
+  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) {
+    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 Error(
+        `Invalid days value: "${days}". Expected one of: "7D", "14D", "30D".`
+      );
+    }
+    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) {
+    const raw = await this.getMetricsYield(days);
+    return mapApyByStrategy2(raw);
+  }
+};
+
+// src/errors.ts
+var AgentNotFoundError = class extends Error {
+  constructor(agentId, available) {
+    super(
+      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`
+    );
+    this.name = "AgentNotFoundError";
+  }
+};
+var NotConnectedError = class extends Error {
+  constructor() {
+    super("Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
+  }
+};
+var AgentChainIncompatibleError = class extends Error {
+  incompatibleAgents;
+  connectedChainId;
+  constructor(incompatibleAgents, connectedChainId) {
+    const details = incompatibleAgents.map(
+      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+    ).join("; ");
+    super(
+      `Chain ${connectedChainId} is not supported by the following agents: ${details}`
+    );
+    this.name = "AgentChainIncompatibleError";
+    this.incompatibleAgents = incompatibleAgents;
+    this.connectedChainId = connectedChainId;
+  }
+};
+
+// src/lib/routing-api.ts
+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`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "x-owney-api-key": `${apiKey}`
+    }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Routing API error ${res.status}: ${text}`);
+  }
+  const json = await res.json();
+  if (!json.success) {
+    throw new Error(`Routing API request failed: ${json.message}`);
+  }
+  return json.data;
+}
+
+// src/client.ts
+var AGENT_CONSTRUCTORS = {
+  zyfai: ZyfaiAgent,
+  sail: SailAgent
+};
+var OwneySDK = class {
+  agents = /* @__PURE__ */ new Map();
+  activeAgents = /* @__PURE__ */ new Set();
+  state = null;
+  apiKey;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+  }
+  /**
+   * Establish connection state for all subsequent SDK calls.
+   * Must be called once before any agent operation that requires a wallet.
+   * @param provider - EIP-1193 wallet provider
+   */
+  // TODO: replace with a proper EIP-1193 Provider type
+  async connect(provider) {
+    const accounts = await provider.request({
+      method: "eth_accounts"
+    });
+    const walletAddress = accounts[0];
+    if (!walletAddress) {
+      throw new Error(
+        "No accounts found. Ensure the wallet is unlocked and connected."
+      );
+    }
+    this.state = { provider, walletAddress, chainId: null };
+  }
+  /**
+   * Disconnect from all agents and clear connection state.
+   * After calling this, `connect()` must be called again before using agent methods.
+   */
+  async disconnect() {
+    for (const agent of this.agents.values()) {
+      await agent.disconnect();
+    }
+    this.activeAgents.clear();
+    this.state = null;
+  }
+  /**
+   * Check if the SDK has an active connection state.
+   * @returns `true` if `connect()` has been called and `disconnect()` has not
+   */
+  isConnected() {
+    return this.state !== null;
+  }
+  /**
+   * Get the currently active chain ID, set by `activateAgent`.
+   * @returns The active chain ID, or `null` if `activateAgent` has not been called
+   */
+  getActiveChainId() {
+    return this.state?.chainId ?? null;
+  }
+  requireState() {
+    if (!this.state)
+      throw new NotConnectedError();
+    return this.state;
+  }
+  requireChainId() {
+    const chainId = this.state?.chainId ?? null;
+    if (chainId === null) {
+      throw new Error(
+        "No active chain. Call sdk.activateAgent(chainId) first."
+      );
+    }
+    return chainId;
+  }
+  getAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) {
+      throw new AgentNotFoundError(agentId, [...this.agents.keys()]);
+    }
+    return agent;
+  }
+  getActiveAgents() {
+    const active = /* @__PURE__ */ new Map();
+    for (const id of this.activeAgents) {
+      const agent = this.agents.get(id);
+      if (agent)
+        active.set(id, agent);
+    }
+    return active;
+  }
+  // --- Account lifecycle ---
+  /**
+   * Activate the user's smart wallet for the specified agents, or all chain-compatible agents if omitted.
+   * Deploys the Safe contract and creates a session key if not already set up.
+   * Saves the chainId for use by all subsequent SDK calls.
+   * @param chainId - Target chain ID (e.g. 8453 for Base, 42161 for Arbitrum)
+   * @param agentId - Optional. One or more agent IDs to activate. Omit to activate all agents
+   *   that support the given chainId (incompatible agents are silently skipped).
+   *   If provided, ALL specified agents must support the chainId or the call
+   *   throws before activating any agent.
+   */
+  async activateAgent(chainId, agentId) {
+    const state = this.requireState();
+    if (this.agents.size === 0) {
+      const agentKeys = await fetchAgentKeys(this.apiKey);
+      for (const { key, agent_type } of agentKeys) {
+        const AgentClass = AGENT_CONSTRUCTORS[agent_type];
+        if (!AgentClass)
+          continue;
+        const agent = new AgentClass(key);
+        this.agents.set(agent_type, agent);
+      }
+      if (this.agents.size === 0) {
+        throw new Error(
+          "No supported agents returned by the routing API. Check your API key and routing configuration."
+        );
+      }
+    }
+    if (agentId !== void 0) {
+      if (agentId.length === 0) {
+        throw new Error(
+          "agentId array must not be empty. Omit the argument to activate all compatible agents."
+        );
+      }
+      const uniqueIds = [...new Set(agentId)];
+      const agents = uniqueIds.map((id) => this.getAgent(id));
+      const incompatibleAgents = agents.filter(
+        (agent) => !agent.supportedChainIds.includes(chainId)
+      ).map((agent) => ({
+        agentId: agent.id,
+        supportedChainIds: agent.supportedChainIds
+      }));
+      if (incompatibleAgents.length > 0) {
+        throw new AgentChainIncompatibleError(incompatibleAgents, chainId);
+      }
+      for (const agent of agents) {
+        await agent.activateAgent(state, chainId);
+      }
+      this.activeAgents.clear();
+      for (const id of uniqueIds) {
+        this.activeAgents.add(id);
+      }
+      state.chainId = chainId;
+      return;
+    }
+    const compatible = [...this.agents.values()].filter(
+      (agent) => agent.supportedChainIds.includes(chainId)
+    );
+    if (compatible.length === 0) {
+      throw new Error(`No agents support chain ${chainId}.`);
+    }
+    for (const agent of compatible) {
+      await agent.activateAgent(state, chainId);
+    }
+    this.activeAgents.clear();
+    for (const agent of compatible) {
+      this.activeAgents.add(agent.id);
+    }
+    state.chainId = chainId;
+  }
+  /**
+   * Deposit funds into a specific agent, or split equally across all agents if agentId is omitted.
+   * Validates that the asset is supported by the target agent(s) on the active chain.
+   * @param options - Deposit parameters
+   * @param options.amount - Amount to deposit in smallest unit (e.g. "100000000" for 100 USDC)
+   * @param options.asset - Asset symbol to deposit (e.g. "USDC")
+   * @param options.depositCallback - Callback that performs the token transfer and returns a tx hash.
+   *   When agentId is omitted, this callback is invoked once per eligible agent with that agent's
+   *   split amount and smart wallet address — expect multiple wallet prompts.
+   * @param options.agentId - Optional. Target agent. Omit to split equally across all agents.
+   * @returns {OwneyDepositResult} for a single agent, or {OwneyMultiDepositResult} with per-agent results
+   */
+  async deposit(options) {
+    const { amount, asset, depositCallback, agentId } = options;
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    if (agentId) {
+      const agent = this.getAgent(agentId);
+      this.validateAssetSupport(agent, chainId, asset);
+      return agent.deposit(state, chainId, amount, depositCallback);
+    }
+    const eligibleAgents = this.getEligibleAgents(chainId, asset);
+    const totalAmount = BigInt(amount);
+    if (totalAmount < BigInt(eligibleAgents.length)) {
+      throw new Error(
+        `Amount "${amount}" is too small to split across ${eligibleAgents.length} agents.`
+      );
+    }
+    const perAgent = totalAmount / BigInt(eligibleAgents.length);
+    const remainder = totalAmount % BigInt(eligibleAgents.length);
+    const agentResults = {};
+    for (let i = 0; i < eligibleAgents.length; i++) {
+      const agent = eligibleAgents[i];
+      const agentAmount = i === eligibleAgents.length - 1 ? String(perAgent + remainder) : String(perAgent);
+      agentResults[agent.id] = await agent.deposit(
+        state,
+        chainId,
+        agentAmount,
+        depositCallback
+      );
+    }
+    return { agentResults };
+  }
+  validateAssetSupport(agent, chainId, asset) {
+    const chainAssets = agent.supportedAssets.find(
+      (sa) => sa.chainId === chainId
+    );
+    if (!chainAssets || !chainAssets.assets.includes(asset)) {
+      throw new Error(
+        `Agent "${agent.id}" does not support asset "${asset}" on chain ${chainId}.`
+      );
+    }
+  }
+  getEligibleAgents(chainId, asset) {
+    const eligible = [...this.agents.values()].filter((agent) => {
+      const chainAssets = agent.supportedAssets.find(
+        (sa) => sa.chainId === chainId
+      );
+      return chainAssets && chainAssets.assets.includes(asset);
+    });
+    if (eligible.length === 0) {
+      throw new Error(
+        `No agents support asset "${asset}" on chain ${chainId}.`
+      );
+    }
+    return eligible;
+  }
+  // --- Fund operations ---
+  /**
+   * Withdraw funds from a specific agent, or all agents that support the active chain+asset if agentId is omitted.
+   * Validates that the asset is supported by the target agent(s) on the active chain.
+   * @param options - Withdraw parameters
+   * @param options.asset - Asset symbol (e.g. "USDC")
+   * @param options.amount - Optional. Amount to withdraw. Omit for full withdrawal.
+   * @param options.agentId - Optional. Target agent. Omit to withdraw from all agents.
+   * @returns {AgentWithdrawResult} for a single agent, or {OwneyWithdrawResult} with per-agent results
+   */
+  async withdraw(options) {
+    const { asset, amount, agentId } = options;
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    if (agentId) {
+      const agent = this.getAgent(agentId);
+      this.validateAssetSupport(agent, chainId, asset);
+      return agent.withdraw(state, chainId, amount);
+    }
+    const eligibleAgents = this.getEligibleAgents(chainId, asset);
+    const results = {};
+    for (const agent of eligibleAgents) {
+      results[agent.id] = await agent.withdraw(state, chainId, amount);
+    }
+    return {
+      agentResult: results
+    };
+  }
+  // --- Portfolio reads ---
+  /**
+   * Get the user's balances for a specific agent, or aggregated across all agents.
+   * @param agentId - Optional. Agent to query. Omit for aggregated balances.
+   * @returns {AgentBalance} for a single agent, or {OwneyBalances} with totalBalance and per-agent breakdown
+   */
+  async getBalances(agentId) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    if (agentId) {
+      return this.getAgent(agentId).getBalances(state, chainId);
+    }
+    let totalBalance = 0;
+    const results = {};
+    for (const [id, agent] of this.getActiveAgents()) {
+      results[id] = await agent.getBalances(state, chainId);
+      totalBalance = totalBalance + Number(results[id].totalBalance);
+    }
+    return {
+      totalBalance: String(totalBalance),
+      agentBalances: results
+    };
+  }
+  /**
+   * Get the user's on-chain earnings for a specific agent, or aggregated across all agents.
+   * @param agentId - Optional. Agent to query. Omit for aggregated earnings.
+   * @returns {AgentEarnings} for a single agent, or {OwneyEarnings} with totalEarnings and per-agent breakdown
+   */
+  async getEarnings(agentId) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    if (agentId) {
+      return this.getAgent(agentId).getEarnings(state, chainId);
+    }
+    let totalEarnings = 0;
+    const results = {};
+    for (const [id, agent] of this.getActiveAgents()) {
+      results[id] = await agent.getEarnings(state, chainId);
+      totalEarnings = totalEarnings + Number(results[id].lifetimeEarnings);
+    }
+    return {
+      totalEarnings: String(totalEarnings),
+      agentEarnings: results
+    };
+  }
+  /**
+   * Get the weighted APY for the user's account over a time period.
+   * When querying all agents, the total APY is a balance-weighted average.
+   * @param options - Contains agentId (optional) and days ("7D", "14D", or "30D")
+   * @param options.agentId - Optional. Agent to query. Omit for balance-weighted total APY.
+   * @param options.days - Lookback period: "7D", "14D", or "30D"
+   * @returns {AccountAgentApy} for a single agent, or {OwneyAccountApy} with totalApy and per-agent breakdown
+   */
+  async getAccountApy({
+    agentId,
+    days
+  }) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    if (agentId) {
+      return this.getAgent(agentId).getAccountApy(state, chainId, days);
+    }
+    const activeAgents = this.getActiveAgents();
+    const results = {};
+    for (const [id, agent] of activeAgents) {
+      results[id] = await agent.getAccountApy(state, chainId, days);
+    }
+    const balances = {};
+    let totalBalance = 0;
+    for (const [id, agent] of activeAgents) {
+      const b = await agent.getBalances(state, chainId);
+      balances[id] = Number(b.totalBalance);
+      totalBalance += balances[id];
+    }
+    let totalApy = 0;
+    if (totalBalance > 0) {
+      for (const id of Object.keys(results)) {
+        const weight = balances[id] / totalBalance;
+        totalApy += Number(results[id].weightedApyAfterFee ?? 0) * weight;
+      }
+    }
+    return {
+      totalApy: String(totalApy),
+      agentApy: results
+    };
+  }
+  /**
+   * Get transaction history for a specific agent, or all agents.
+   * @param params - Optional. Contains agentId and filters.
+   * @param params.agentId - Optional. Agent to query. Omit for all agents.
+   * @param params.filters - Optional. Pagination and date filters (fromDate, toDate)
+   * @returns {OwneyAgentHistory} with per-agent history
+   */
+  async getHistory(params) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const { agentId, filters } = params ?? {};
+    if (agentId) {
+      return this.getAgent(agentId).getHistory(state, chainId, filters);
+    }
+    let results = [];
+    for (const [, agent] of this.getActiveAgents()) {
+      const { data } = await agent.getHistory(state, chainId, filters);
+      results = [...results, ...data];
+    }
+    results.sort(
+      (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+    );
+    return {
+      total: results.length,
+      data: results
+    };
+  }
+  // --- Agent control ---
+  /**
+   * Pause an agent's automated operations. The agent will stop rebalancing until resumed.
+   * @param agentId - The agent to pause (e.g. "zyfai")
+   * @returns OwneyAgentStatus with success flag
+   */
+  async pauseAgent(agentId) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    return this.getAgent(agentId).pause(state, chainId);
+  }
+  /**
+   * Resume an agent's automated operations.
+   * @param agentId - The agent to resume (e.g. "zyfai")
+   * @returns OwneyAgentStatus with success flag
+   */
+  async resumeAgent(agentId) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    return this.getAgent(agentId).resume(state, chainId);
+  }
+  /**
+   * Get the user's profile for a specific agent, or all agents.
+   * @param agentId - Optional. Agent to query. Omit for all agents.
+   * @returns {AgentUserProfile} for a single agent, or {OwneyUserProfile} with per-agent profiles
+   */
+  async getUserProfile(agentId) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    if (agentId) {
+      return this.getAgent(agentId).getUserProfile(state, chainId);
+    }
+    const results = {};
+    for (const [id, agent] of this.getActiveAgents()) {
+      results[id] = await agent.getUserProfile(state, chainId);
+    }
+    return {
+      agentUserProfile: results
+    };
+  }
+  // --- Discovery (no wallet required) ---
+  /**
+   * Get the agent's average APY performance over a time period. Does not require a wallet connection.
+   * @param options - Contains agentId (optional) and days ("7D", "14D", or "30D")
+   * @param options.agentId - Optional. Agent to query. Omit for all agents.
+   * @param options.days - Lookback period: "7D", "14D", or "30D"
+   * @returns {AgentApy} for a single agent, or {OwneyAgentApy} with per-agent APY
+   */
+  async getAgentApy({
+    agentId,
+    days
+  }) {
+    if (agentId) {
+      return this.getAgent(agentId).getAgentApy(days);
+    }
+    const results = {};
+    for (const [id, agent] of this.agents) {
+      results[id] = await agent.getAgentApy(days);
+    }
+    return {
+      agentApy: results
+    };
+  }
+  /**
+   * Get the current fund allocation percentages across agents.
+   * @returns Object with agent names as keys and allocation percentages as values
+   */
+  async getAgentAllocation() {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const activeAgents = this.getActiveAgents();
+    const balances = {};
+    let totalBalance = 0;
+    for (const [id, agent] of activeAgents) {
+      const b = await agent.getBalances(state, chainId);
+      balances[id] = Number(b.totalBalance);
+      totalBalance += balances[id];
+    }
+    const allocation = {};
+    if (totalBalance === 0) {
+      for (const id of activeAgents.keys()) {
+        allocation[id] = 0;
+      }
+    } else {
+      for (const id of activeAgents.keys()) {
+        allocation[id] = balances[id] > 0 ? Math.max(1, Math.floor(balances[id] / totalBalance * 100)) : 0;
+      }
+      const remainder = 100 - Object.values(allocation).reduce((a, b) => a + b, 0);
+      if (remainder > 0) {
+        const largestId = [...activeAgents.keys()].reduce(
+          (a, b) => balances[a] >= balances[b] ? a : b
+        );
+        allocation[largestId] += remainder;
+      }
+    }
+    return {
+      agentAllocation: allocation
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentChainIncompatibleError,
+  AgentNotFoundError,
+  NotConnectedError,
+  OwneySDK
+});