@owney/sdk 0.2.5 → 0.2.6

package/dist/index.cjs

@@ -37,6 +37,23 @@ var P_SUPPORTED_CHAINS = {
 };
 var SUPPORTED_CHAIN_IDS = P_SUPPORTED_CHAINS.chainIds;
 var SUPPORTED_CHAINS = P_SUPPORTED_CHAINS.chains;
+var SupportedAssets = [
+  {
+    address: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`,
+    symbol: "USDC",
+    chainId: 8453
+  },
+  {
+    address: `0xaf88d065e77c8cC2239327C5EDb3A432268e5831`,
+    symbol: "USDC",
+    chainId: 42161
+  },
+  {
+    address: `0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9`,
+    symbol: "USDT",
+    chainId: 42161
+  }
+];
 
 // src/lib/utils.ts
 var isValidChainId = (chainId) => {
@@ -214,13 +231,41 @@ function mapUserProfile(raw, userAddress) {
   };
 }
 function mapApyByStrategy(raw) {
-  const first = raw.data[0];
+  const apyPerAsset = {};
+  let apySum = 0;
+  let apyCount = 0;
+  for (const entry of raw.data) {
+    const supported = SupportedAssets.find(
+      (asset) => asset.chainId === entry.chain_id && asset.symbol === entry.token_symbol
+    );
+    if (!supported)
+      continue;
+    const chainKey = supported.chainId;
+    const symbolKey = supported.symbol;
+    const bucket = apyPerAsset[chainKey] ?? {};
+    bucket[symbolKey] = entry.average_apy;
+    apyPerAsset[chainKey] = bucket;
+    apySum += entry.average_apy;
+    apyCount += 1;
+  }
+  const averageApy = apyCount > 0 ? apySum / apyCount : 0;
+  const hasDetails = Object.keys(apyPerAsset).length > 0;
   return {
-    averageApy: first?.average_apy ?? 0
+    averageApy,
+    detailedApys: hasDetails ? { apyPerAsset } : void 0
   };
 }
 
 // src/agents/zyfai/zyfai.agent.ts
+var ZYFAI_TIMING_PREFIX = "[AgentTiming][zyfai]";
+function logTiming(label, startedAt, meta) {
+  const elapsedMs = Date.now() - startedAt;
+  if (meta) {
+    console.log(`${ZYFAI_TIMING_PREFIX} ${label} ${elapsedMs}ms`, meta);
+    return;
+  }
+  console.log(`${ZYFAI_TIMING_PREFIX} ${label} ${elapsedMs}ms`);
+}
 var ZyfaiAgent = class {
   id = "zyfai";
   supportedChainIds = [8453, 42161];
@@ -239,6 +284,8 @@ var ZyfaiAgent = class {
   sdk;
   connectedAddress = null;
   connectedChainId = null;
+  smartWalletCache = /* @__PURE__ */ new Map();
+  connectAuthPromise = null;
   constructor(apiKey) {
     this.sdk = new import_sdk.ZyfaiSDK({ apiKey });
   }
@@ -251,50 +298,105 @@ var ZyfaiAgent = class {
   }
   /** Light connect: SIWE auth only. Re-auths if chain changed. */
   async connectAuth(state, chainId) {
+    const startedAt = Date.now();
     const validChainId = isValidChainId(chainId);
-    if (!this.connectedAddress || this.connectedChainId !== validChainId) {
+    if (this.connectedAddress && this.connectedChainId === validChainId) {
+      logTiming("connectAuth cache-hit", startedAt, { chainId: validChainId });
+      return;
+    }
+    if (this.connectAuthPromise) {
+      await this.connectAuthPromise;
+      logTiming("connectAuth awaited-inflight", startedAt, {
+        chainId: validChainId
+      });
+      return;
+    }
+    this.connectAuthPromise = (async () => {
       const address = await this.sdk.connectAccount(
         state.provider,
         validChainId
       );
       this.connectedAddress = address;
       this.connectedChainId = validChainId;
+    })();
+    try {
+      await this.connectAuthPromise;
+      logTiming("connectAuth success", startedAt, { chainId: validChainId });
+    } finally {
+      this.connectAuthPromise = null;
     }
   }
   /** Full connect: SIWE auth + Safe deploy check + session key. */
   async connectFull(state, chainId) {
+    const startedAt = Date.now();
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
     const address = this.getAddress();
+    const walletLookupStart = Date.now();
     const wallet = await this.sdk.getSmartWalletAddress(address, validChainId);
+    logTiming("connectFull getSmartWalletAddress", walletLookupStart, {
+      chainId: validChainId
+    });
+    this.smartWalletCache.set(`${address}_${validChainId}`, wallet.address);
     if (!wallet.isDeployed) {
+      const deployStart = Date.now();
       await this.sdk.deploySafe(address, validChainId, "aggressive", true);
+      logTiming("connectFull deploySafe", deployStart, {
+        chainId: validChainId
+      });
     }
+    const userDetailsStart = Date.now();
     const user = await this.sdk.getUserDetails();
+    logTiming("connectFull getUserDetails", userDetailsStart, {
+      chainId: validChainId
+    });
     if (!user.hasActiveSessionKey) {
+      const sessionKeyStart = Date.now();
       await this.sdk.createSessionKey(address, validChainId);
+      logTiming("connectFull createSessionKey", sessionKeyStart, {
+        chainId: validChainId
+      });
     }
+    logTiming("connectFull success", startedAt, { chainId: validChainId });
   }
   /** Connect + resolve smart wallet address for read operations. */
   async resolveSmartWallet(state, chainId) {
+    const startedAt = Date.now();
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
-    const { address } = await this.sdk.getSmartWalletAddress(
-      this.getAddress(),
-      validChainId
-    );
-    return { smartWallet: address, chainId: validChainId };
+    const ownerAddress = this.getAddress();
+    const cacheKey = `${ownerAddress}_${validChainId}`;
+    let smartWallet = this.smartWalletCache.get(cacheKey);
+    if (!smartWallet) {
+      const lookupStart = Date.now();
+      const { address } = await this.sdk.getSmartWalletAddress(
+        ownerAddress,
+        validChainId
+      );
+      logTiming("resolveSmartWallet remote-lookup", lookupStart, {
+        chainId: validChainId
+      });
+      smartWallet = address;
+      this.smartWalletCache.set(cacheKey, smartWallet);
+    } else {
+      logTiming("resolveSmartWallet cache-hit", startedAt, {
+        chainId: validChainId
+      });
+    }
+    logTiming("resolveSmartWallet ready", startedAt, { chainId: validChainId });
+    return { smartWallet, chainId: validChainId };
   }
   // --- IAgent: Connection lifecycle ---
   async disconnect() {
     await this.sdk.disconnectAccount();
     this.connectedAddress = null;
     this.connectedChainId = null;
+    this.smartWalletCache.clear();
   }
   // --- IAgent: Account lifecycle ---
   async activateAgent(state, chainId) {
     try {
-      await this.connectFull(state, chainId);
+      await this.connectAuth(state, chainId);
     } catch (error) {
       await this.disconnect();
       throw error;
@@ -341,9 +443,15 @@ var ZyfaiAgent = class {
   }
   // --- IAgent: Portfolio reads ---
   async getBalances(state, chainId) {
+    const startedAt = Date.now();
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
+    const positionsStart = Date.now();
     const raw = await this.sdk.getPositions(this.getAddress(), validChainId);
+    logTiming("getBalances getPositions", positionsStart, {
+      chainId: validChainId
+    });
+    logTiming("getBalances success", startedAt, { chainId: validChainId });
     return mapBalances(raw, validChainId);
   }
   async getEarnings(state, chainId) {
@@ -378,11 +486,13 @@ var ZyfaiAgent = class {
     return mapUserProfile(raw, this.connectedAddress);
   }
   // --- IAgent: Discovery (no wallet required) ---
-  async getAgentApy(days) {
+  async getAgentApy(days, options) {
     const raw = await this.sdk.getAPYPerStrategy(
       false,
       DayFilterMapping[days],
-      "aggressive"
+      "aggressive",
+      options?.chainId,
+      options?.tokenSymbol
     );
     return mapApyByStrategy(raw);
   }
@@ -428,9 +538,11 @@ function mapEarnings2(raw, smartWallet) {
   };
 }
 function mapApyHistory2(raw, walletAddress) {
+  const apyPerAsset = remapApyPerAssetToSymbols(raw.result.apy_per_asset);
   return {
     walletAddress,
-    weightedApyAfterFee: raw.result
+    weightedApyAfterFee: raw.result.apy,
+    weightedApyAfterFeeDetails: apyPerAsset ? { apyPerAsset } : void 0
   };
 }
 function mapSailTransaction(tx) {
@@ -564,15 +676,45 @@ function mapUserProfile2(raw) {
   };
 }
 function mapApyByStrategy2(raw) {
+  const apyPerAsset = remapApyPerAssetToSymbols(raw.result.apy_per_asset);
   return {
-    averageApy: raw.result
+    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_TIMING_PREFIX = "[AgentTiming][sail]";
+var SAIL_PORTFOLIO_TIMEOUT_MS = 8e3;
+function logTiming2(label, startedAt, meta) {
+  const elapsedMs = Date.now() - startedAt;
+  if (meta) {
+    console.log(`${SAIL_TIMING_PREFIX} ${label} ${elapsedMs}ms`, meta);
+    return;
+  }
+  console.log(`${SAIL_TIMING_PREFIX} ${label} ${elapsedMs}ms`);
+}
 var SailAgent = class {
   id = "sail";
   supportedChainIds = [8453, 42161];
@@ -594,11 +736,12 @@ var SailAgent = class {
   connectedAddress = null;
   smartWalletAddress = null;
   connectedChainId = null;
+  connectPromise = null;
   constructor(apiKey) {
     this.apiKey = apiKey;
   }
   // --- Private helpers ---
-  async request(method, path, body) {
+  async request(method, path, body, timeoutMs) {
     const headers = {
       "Content-Type": "application/json",
       "X-Business-API-Key": this.apiKey
@@ -609,11 +752,25 @@ var SailAgent = class {
     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
-    });
+    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 Error(`Sail API timeout ${timeoutMs}ms: ${method} ${path}`);
+      }
+      throw error;
+    } finally {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+    }
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new Error(`Sail API error ${res.status}: ${text}`);
@@ -622,19 +779,22 @@ var SailAgent = class {
   }
   /** Initiate SIWE and sign with the user's wallet. */
   async signSiwe(state, chainId) {
+    const startedAt = Date.now();
     const initiate = await this.request(
       "POST",
       `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/auth/initiate`,
       {
         method: "siwe",
         address: state.walletAddress,
-        chainId
+        chainId,
+        identityMode: "byWallet"
       }
     );
     const signature = await state.provider.request({
       method: "personal_sign",
       params: [initiate.message, state.walletAddress]
     });
+    logTiming2("signSiwe success", startedAt, { chainId });
     return {
       sessionId: initiate.sessionId,
       message: initiate.message,
@@ -643,38 +803,56 @@ var SailAgent = class {
   }
   /** Full connect: auth handles smart account creation via SIWE flow. */
   async connectFull(state, chainId) {
+    const startedAt = Date.now();
     if (this.connectedAddress && this.connectedChainId === chainId) {
+      logTiming2("connectFull cache-hit", startedAt, { chainId });
+      return;
+    }
+    if (this.connectPromise) {
+      await this.connectPromise;
+      logTiming2("connectFull awaited-inflight", startedAt, { 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;
+    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;
+      logTiming2("connectFull success", startedAt, { chainId });
+    } finally {
+      this.connectPromise = null;
+    }
   }
   async resolveSmartWallet(state, chainId) {
+    const startedAt = Date.now();
     await this.connectFull(state, chainId);
     const validChainId = isValidChainId(chainId);
     if (!this.smartWalletAddress) {
       throw new Error("Wallet not connected. Call sdk.connect() first.");
     }
+    logTiming2("resolveSmartWallet ready", startedAt, { chainId: validChainId });
     return {
       smartWallet: this.smartWalletAddress,
       chainId: validChainId
@@ -791,9 +969,30 @@ var SailAgent = class {
   }
   // --- IAgent: Portfolio reads ---
   async getBalances(state, chainId) {
+    const startedAt = Date.now();
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.getMetricsPortfolio(state, chainId);
-    return mapPortfolioBalances(raw, smartWallet);
+    const portfolioStart = Date.now();
+    try {
+      const raw = await this.getMetricsPortfolio(state, chainId);
+      logTiming2("getBalances getMetricsPortfolio", portfolioStart, { chainId });
+      logTiming2("getBalances success", startedAt, { chainId });
+      return mapPortfolioBalances(raw, smartWallet);
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("Sail API timeout")) {
+        console.warn(
+          "Sail portfolio request timed out; using empty snapshot.",
+          {
+            chainId
+          }
+        );
+        logTiming2("getBalances timeout-fallback", startedAt, { chainId });
+        return mapPortfolioBalances(
+          { message: "timeout", result: [] },
+          smartWallet
+        );
+      }
+      throw error;
+    }
   }
   async getEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
@@ -814,7 +1013,9 @@ var SailAgent = class {
     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}` : ""}`
+      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/portfolio?${smartWallet ? `smart_account=${smartWallet}` : ""}`,
+      void 0,
+      SAIL_PORTFOLIO_TIMEOUT_MS
     );
   }
   async getMetricsEarnings(state, chainId) {
@@ -933,7 +1134,7 @@ var SailAgent = class {
     return mapUserProfile2(raw);
   }
   // --- IAgent: Discovery (no wallet required) ---
-  async getAgentApy(days) {
+  async getAgentApy(days, _options) {
     const raw = await this.getMetricsYield(days);
     return mapApyByStrategy2(raw);
   }
@@ -997,11 +1198,21 @@ var AGENT_CONSTRUCTORS = {
   zyfai: ZyfaiAgent,
   sail: SailAgent
 };
+var SDK_TIMING_PREFIX = "[OwneySDKTiming]";
+function logTiming3(label, startedAt, meta) {
+  const elapsedMs = Date.now() - startedAt;
+  if (meta) {
+    console.log(`${SDK_TIMING_PREFIX} ${label} ${elapsedMs}ms`, meta);
+    return;
+  }
+  console.log(`${SDK_TIMING_PREFIX} ${label} ${elapsedMs}ms`);
+}
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
   state = null;
   apiKey;
+  initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
   }
@@ -1078,6 +1289,32 @@ var OwneySDK = class {
     }
     return active;
   }
+  async ensureAgentsInitialized() {
+    if (this.agents.size > 0)
+      return;
+    if (!this.initializingAgentsPromise) {
+      this.initializingAgentsPromise = (async () => {
+        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."
+          );
+        }
+      })();
+    }
+    try {
+      await this.initializingAgentsPromise;
+    } finally {
+      this.initializingAgentsPromise = null;
+    }
+  }
   // --- Account lifecycle ---
   /**
    * Activate the user's smart wallet for the specified agents, or all chain-compatible agents if omitted.
@@ -1090,22 +1327,9 @@ var OwneySDK = class {
    *   throws before activating any agent.
    */
   async activateAgent(chainId, agentId) {
+    const startedAt = Date.now();
     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."
-        );
-      }
-    }
+    await this.ensureAgentsInitialized();
     if (agentId !== void 0) {
       if (agentId.length === 0) {
         throw new Error(
@@ -1123,14 +1347,27 @@ var OwneySDK = class {
       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;
+      Promise.all(
+        agents.map(async (agent) => {
+          const agentStart = Date.now();
+          await agent.activateAgent(state, chainId);
+          logTiming3("activateAgent background-agent-ready", agentStart, {
+            chainId,
+            agentId: agent.id
+          });
+        })
+      ).catch((error) => {
+        console.error("activateAgent background init failed:", error);
+      });
+      logTiming3("activateAgent scheduled", startedAt, {
+        chainId,
+        agentIds: uniqueIds
+      });
       return;
     }
     const compatible = [...this.agents.values()].filter(
@@ -1139,14 +1376,27 @@ var OwneySDK = class {
     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;
+    Promise.all(
+      compatible.map(async (agent) => {
+        const agentStart = Date.now();
+        await agent.activateAgent(state, chainId);
+        logTiming3("activateAgent background-agent-ready", agentStart, {
+          chainId,
+          agentId: agent.id
+        });
+      })
+    ).catch((error) => {
+      console.error("activateAgent background init failed:", error);
+    });
+    logTiming3("activateAgent scheduled", startedAt, {
+      chainId,
+      agentIds: compatible.map((agent) => agent.id)
+    });
   }
   /**
    * Deposit funds into a specific agent, or split equally across all agents if agentId is omitted.
@@ -1250,17 +1500,47 @@ var OwneySDK = class {
    * @returns {AgentBalance} for a single agent, or {OwneyBalances} with totalBalance and per-agent breakdown
    */
   async getBalances(agentId) {
+    const startedAt = Date.now();
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      return this.getAgent(agentId).getBalances(state, chainId);
+      const result = await this.getAgent(agentId).getBalances(state, chainId);
+      logTiming3("getBalances single-agent", startedAt, { chainId, agentId });
+      return result;
     }
     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);
+    const entries = [...this.getActiveAgents().entries()];
+    const balanceResults = await Promise.allSettled(
+      entries.map(async ([id, agent]) => {
+        const agentStartedAt = Date.now();
+        const b = await agent.getBalances(state, chainId);
+        logTiming3("getBalances per-agent", agentStartedAt, {
+          chainId,
+          agentId: id
+        });
+        return [id, b];
+      })
+    );
+    let successCount = 0;
+    for (const settledResult of balanceResults) {
+      if (settledResult.status === "fulfilled") {
+        const [id, b] = settledResult.value;
+        results[id] = b;
+        totalBalance += Number(b.totalBalance);
+        successCount += 1;
+        continue;
+      }
+      console.error("getBalances agent failed:", settledResult.reason);
+    }
+    if (successCount === 0) {
+      throw new Error("Failed to fetch balances for all active agents.");
     }
+    logTiming3("getBalances aggregate", startedAt, {
+      chainId,
+      totalAgents: entries.length,
+      successCount
+    });
     return {
       totalBalance: String(totalBalance),
       agentBalances: results
@@ -1279,9 +1559,16 @@ var OwneySDK = class {
     }
     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);
+    const entries = [...this.getActiveAgents().entries()];
+    const earningsResults = await Promise.all(
+      entries.map(async ([id, agent]) => {
+        const e = await agent.getEarnings(state, chainId);
+        return [id, e];
+      })
+    );
+    for (const [id, e] of earningsResults) {
+      results[id] = e;
+      totalEarnings += Number(e.lifetimeEarnings);
     }
     return {
       totalEarnings: String(totalEarnings),
@@ -1306,16 +1593,30 @@ var OwneySDK = class {
       return this.getAgent(agentId).getAccountApy(state, chainId, days);
     }
     const activeAgents = this.getActiveAgents();
+    const entries = [...activeAgents.entries()];
+    const [apyResults, balanceResults] = await Promise.all([
+      Promise.all(
+        entries.map(async ([id, agent]) => {
+          const apy = await agent.getAccountApy(state, chainId, days);
+          return [id, apy];
+        })
+      ),
+      Promise.all(
+        entries.map(async ([id, agent]) => {
+          const b = await agent.getBalances(state, chainId);
+          return [id, Number(b.totalBalance)];
+        })
+      )
+    ]);
     const results = {};
-    for (const [id, agent] of activeAgents) {
-      results[id] = await agent.getAccountApy(state, chainId, days);
+    for (const [id, apy] of apyResults) {
+      results[id] = apy;
     }
     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];
+    for (const [id, bal] of balanceResults) {
+      balances[id] = bal;
+      totalBalance += bal;
     }
     let totalApy = 0;
     if (totalBalance > 0) {
@@ -1343,9 +1644,13 @@ var OwneySDK = class {
     if (agentId) {
       return this.getAgent(agentId).getHistory(state, chainId, filters);
     }
+    const historyResults = await Promise.all(
+      [...this.getActiveAgents().values()].map(
+        (agent) => agent.getHistory(state, chainId, filters)
+      )
+    );
     let results = [];
-    for (const [, agent] of this.getActiveAgents()) {
-      const { data } = await agent.getHistory(state, chainId, filters);
+    for (const { data } of historyResults) {
       results = [...results, ...data];
     }
     results.sort(
@@ -1389,8 +1694,15 @@ var OwneySDK = class {
       return this.getAgent(agentId).getUserProfile(state, chainId);
     }
     const results = {};
-    for (const [id, agent] of this.getActiveAgents()) {
-      results[id] = await agent.getUserProfile(state, chainId);
+    const entries = [...this.getActiveAgents().entries()];
+    const profileResults = await Promise.all(
+      entries.map(async ([id, agent]) => {
+        const p = await agent.getUserProfile(state, chainId);
+        return [id, p];
+      })
+    );
+    for (const [id, p] of profileResults) {
+      results[id] = p;
     }
     return {
       agentUserProfile: results
@@ -1402,18 +1714,34 @@ var OwneySDK = class {
    * @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"
+   * @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.
+   * @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
    */
   async getAgentApy({
     agentId,
-    days
+    days,
+    tokenSymbol,
+    chainId
   }) {
+    await this.ensureAgentsInitialized();
+    const agentOptions = { tokenSymbol, chainId };
     if (agentId) {
-      return this.getAgent(agentId).getAgentApy(days);
+      return this.getAgent(agentId).getAgentApy(days, agentOptions);
     }
     const results = {};
-    for (const [id, agent] of this.agents) {
-      results[id] = await agent.getAgentApy(days);
+    const agentEntries = [...this.agents.entries()];
+    const apyResults = await Promise.all(
+      agentEntries.map(async ([id, agent]) => {
+        const apy = await agent.getAgentApy(days, agentOptions);
+        return [id, apy];
+      })
+    );
+    for (const [id, apy] of apyResults) {
+      results[id] = apy;
     }
     return {
       agentApy: results
@@ -1429,10 +1757,26 @@ var OwneySDK = class {
     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 entries = [...activeAgents.entries()];
+    const balanceResults = await Promise.allSettled(
+      entries.map(async ([id, agent]) => {
+        const b = await agent.getBalances(state, chainId);
+        return [id, Number(b.totalBalance)];
+      })
+    );
+    let successCount = 0;
+    for (const settledResult of balanceResults) {
+      if (settledResult.status === "fulfilled") {
+        const [id, bal] = settledResult.value;
+        balances[id] = bal;
+        totalBalance += bal;
+        successCount += 1;
+      } else {
+        console.error("getAgentAllocation agent failed:", settledResult.reason);
+      }
+    }
+    if (successCount === 0) {
+      throw new Error("Failed to fetch allocation: all agents failed.");
     }
     const allocation = {};
     if (totalBalance === 0) {