@zyfai/sdk 0.2.22 → 0.2.24

package/dist/index.js

@@ -66,8 +66,8 @@ var ENDPOINTS = {
   // Data (v1)
   DATA_POSITION: (walletAddress) => `/data/position?walletAddress=${walletAddress}`,
   DATA_HISTORY: (walletAddress, chainId) => `/data/history?walletAddress=${walletAddress}&chainId=${chainId}`,
-  DATA_TVL: "/data/tvl",
-  DATA_VOLUME: "/data/volume",
+  DATA_TVL: "/data/usd-tvl",
+  DATA_VOLUME: (assetType) => `/data/volume?assetType=${assetType}`,
   DATA_FIRST_TOPUP: (walletAddress, chainId) => `/data/first-topup?walletAddress=${walletAddress}&chainId=${chainId}`,
   DATA_ACTIVE_WALLETS: (chainId) => `/data/active-wallets?chainId=${chainId}`,
   DATA_BY_EOA: (address) => `/data/by-eoa?address=${address}`,
@@ -86,25 +86,48 @@ var DATA_ENDPOINTS = {
   // User Initialization
   USER_INITIALIZE: "/api/earnings/initialize",
   // Earnings
-  ONCHAIN_EARNINGS: (walletAddress) => `/usercheck/onchain-earnings?walletAddress=${walletAddress}`,
-  CALCULATE_ONCHAIN_EARNINGS: "/usercheck/calculate-onchain-earnings",
+  ONCHAIN_EARNINGS: (walletAddress) => `/onchain-earnings/onchain-earnings?walletAddress=${walletAddress}`,
+  CALCULATE_ONCHAIN_EARNINGS: "/onchain-earnings/calculate-onchain-earnings",
   DAILY_EARNINGS: (walletAddress, startDate, endDate) => {
-    let url = `/usercheck/daily-earnings?walletAddress=${walletAddress}`;
+    let url = `/onchain-earnings/daily-earnings?walletAddress=${walletAddress}`;
     if (startDate) url += `&startDate=${startDate}`;
     if (endDate) url += `&endDate=${endDate}`;
     return url;
   },
-  // Portfolio
-  DEBANK_PORTFOLIO_MULTICHAIN: (address) => `/debank/portfolio/multichain/${address}`,
   // Opportunities
-  OPPORTUNITIES_SAFE: (chainId) => chainId ? `/opportunities/safe?chainId=${chainId}` : "/opportunities/safe",
-  OPPORTUNITIES_DEGEN: (chainId) => chainId ? `/opportunities/degen-strategies?chainId=${chainId}` : "/opportunities/degen-strategies",
+  OPPORTUNITIES_SAFE: (chainId, asset, status) => {
+    const params = [];
+    if (chainId !== void 0) params.push(`chainId=${chainId}`);
+    if (asset) params.push(`asset=${asset}`);
+    if (status) params.push(`status=${status}`);
+    return params.length > 0 ? `/opportunities/safe?${params.join("&")}` : "/opportunities/safe";
+  },
+  OPPORTUNITIES_DEGEN: (chainId, asset, status) => {
+    const params = [];
+    if (chainId !== void 0) params.push(`chainId=${chainId}`);
+    if (asset) params.push(`asset=${asset}`);
+    if (status) params.push(`status=${status}`);
+    return params.length > 0 ? `/opportunities/degen-strategies?${params.join("&")}` : "/opportunities/degen-strategies";
+  },
   // APY History
-  DAILY_APY_HISTORY_WEIGHTED: (walletAddress, days) => `/daily-apy-history/weighted/${walletAddress}${days ? `?days=${days}` : ""}`,
+  DAILY_APY_HISTORY_WEIGHTED: (walletAddress, days) => `/daily-apy-history/weighted-multi-asset/${walletAddress}${days ? `?days=${days}` : ""}`,
   // Rebalance
-  REBALANCE_INFO: (isCrossChain) => isCrossChain !== void 0 ? `/rebalance/rebalance-info?isCrossChain=${isCrossChain}` : "/rebalance/rebalance-info",
+  REBALANCE_INFO: (options) => {
+    const params = [];
+    if (options?.isCrossChain !== void 0) params.push(`isCrossChain=${options.isCrossChain}`);
+    if (options?.tokenSymbol) params.push(`tokenSymbol=${options.tokenSymbol}`);
+    return params.length > 0 ? `/rebalance/rebalance-info?${params.join("&")}` : "/rebalance/rebalance-info";
+  },
   // APY Per Strategy
-  APY_PER_STRATEGY: (isCrossChain = false, days = 7, strategy = "safe") => `/rebalance/rebalance-info?isCrossChain=${isCrossChain}&days=${days}&strategy=${strategy}`
+  APY_PER_STRATEGY: (options = {}) => {
+    const params = [];
+    if (options.isCrossChain !== void 0) params.push(`isCrossChain=${options.isCrossChain}`);
+    if (options.days !== void 0) params.push(`days=${options.days}`);
+    if (options.strategy) params.push(`strategy=${options.strategy}`);
+    if (options.chainId !== void 0) params.push(`chainId=${options.chainId}`);
+    if (options.tokenSymbol) params.push(`tokenSymbol=${options.tokenSymbol}`);
+    return params.length > 0 ? `/rebalance/rebalance-info?${params.join("&")}` : "/rebalance/rebalance-info";
+  }
 };
 
 // src/utils/http-client.ts
@@ -403,8 +426,71 @@ var DEFAULT_TOKEN_ADDRESSES = {
   9745: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb"
   // USDT on Plasma
 };
-var getDefaultTokenAddress = (chainId) => {
-  const address = DEFAULT_TOKEN_ADDRESSES[chainId];
+var ASSET_CONFIGS = {
+  USDC: {
+    symbol: "USDC",
+    assetType: "usdc",
+    displayName: "USDC",
+    icon: "/ai-dashboard/usdc-token.png",
+    decimals: 6,
+    tokenSymbols: ["USDC", "USDC.e", "USDT", "USDT0"],
+    tokenSymbolsByChainId: {
+      8453: "USDC",
+      42161: "USDC",
+      9745: "USDT0",
+      146: "USDC.e",
+      1: "USDC"
+    },
+    addresses: {
+      8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      // Base
+      42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      // Arbitrum
+      9745: "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
+      // Plasma
+      146: "0x29219dd400f2bf60e5a23d13be72b486d4038894",
+      // Sonic
+      59144: "0x176211869ca2b568f2a7d4ee941e073a821ee1ff",
+      // Linea
+      1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+      // Ethereum
+    },
+    enabled: true
+  },
+  WETH: {
+    symbol: "WETH",
+    assetType: "eth",
+    displayName: "WETH",
+    icon: "/ai-dashboard/eth-token.png",
+    decimals: 18,
+    tokenSymbols: ["WETH", "ETH"],
+    tokenSymbolsByChainId: {
+      8453: "WETH",
+      42161: "WETH",
+      9745: "WETH",
+      146: "WETH",
+      59144: "WETH",
+      1: "WETH"
+    },
+    addresses: {
+      8453: "0x4200000000000000000000000000000000000006",
+      // Base
+      42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+      // Arbitrum
+      9745: "0x4200000000000000000000000000000000000006",
+      // Plasma
+      146: "0x039e64f90d4199560e7533692f69448878db85c7",
+      // Sonic
+      59144: "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
+      // Linea
+      1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+      // Ethereum
+    },
+    enabled: true
+  }
+};
+var getDefaultTokenAddress = (chainId, asset) => {
+  const address = ASSET_CONFIGS[asset || "USDC"]?.addresses[chainId];
   if (!address || address === "0x0000000000000000000000000000000000000000") {
     throw new Error(
       `Default token address not configured for chain ${chainId}. Please provide tokenAddress explicitly.`
@@ -822,38 +908,39 @@ var _ZyfaiSDK = class _ZyfaiSDK {
   async updateUserProfile(request) {
     try {
       await this.authenticateUser();
-      const payload = { ...request };
-      if (payload.strategy) {
-        if (!isValidPublicStrategy(payload.strategy)) {
+      const asset = request.asset || "usdc";
+      let rebalanceStrategy;
+      if (request.strategy) {
+        if (!isValidPublicStrategy(request.strategy)) {
           throw new Error(
-            `Invalid strategy: ${payload.strategy}. Must be "conservative" or "aggressive".`
+            `Invalid strategy: ${request.strategy}. Must be "conservative" or "aggressive".`
           );
         }
-        payload.strategy = toInternalStrategy(
-          payload.strategy
+        rebalanceStrategy = toInternalStrategy(
+          request.strategy
         );
       }
-      const response = await this.httpClient.patch(
+      const assetSettings = {};
+      if (rebalanceStrategy !== void 0) assetSettings.rebalanceStrategy = rebalanceStrategy;
+      if (request.autocompounding !== void 0) assetSettings.autocompounding = request.autocompounding;
+      if (request.crosschainStrategy !== void 0) assetSettings.crosschainStrategy = request.crosschainStrategy;
+      if (request.splitting !== void 0) assetSettings.splitting = request.splitting;
+      if (request.minSplits !== void 0) assetSettings.minSplits = request.minSplits;
+      if (request.chains !== void 0) assetSettings.chains = request.chains;
+      if (request.autoSelectProtocols !== void 0) assetSettings.autoSelectProtocols = request.autoSelectProtocols;
+      if (request.protocols !== void 0) assetSettings.protocols = request.protocols;
+      const payload = {
+        assetTypeSettings: {
+          [asset]: assetSettings
+        }
+      };
+      if (request.omniAccount !== void 0) payload.omniAccount = request.omniAccount;
+      if (request.agentName !== void 0) payload.agentName = request.agentName;
+      await this.httpClient.patch(
         ENDPOINTS.USER_ME,
         payload
       );
-      return {
-        success: true,
-        userId: response.userId || response.id,
-        smartWallet: response.smartWallet,
-        chains: response.chains,
-        strategy: response.strategy,
-        protocols: response.protocols,
-        autoSelectProtocols: response.autoSelectProtocols,
-        omniAccount: response.omniAccount,
-        autocompounding: response.autocompounding,
-        agentName: response.agentName,
-        crosschainStrategy: response.crosschainStrategy,
-        executorProxy: response.executorProxy,
-        splitting: response.splitting,
-        minSplits: response.minSplits,
-        customization: response.customization
-      };
+      return await this.getUserDetails(asset);
     } catch (error) {
       throw new Error(
         `Failed to update user profile: ${error.message}`
@@ -880,7 +967,12 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    */
   async pauseAgent() {
     try {
+      await this.updateUserProfile({
+        asset: "usdc",
+        protocols: []
+      });
       const response = await this.updateUserProfile({
+        asset: "eth",
         protocols: []
       });
       return response;
@@ -889,49 +981,58 @@ var _ZyfaiSDK = class _ZyfaiSDK {
     }
   }
   /**
-  * Pause the agent by clearing all protocols
-  * Sets the user's protocols to an empty array, effectively pausing automated operations
-  *
-  * @returns Response indicating success and updated user details
-  *
-  * @example
-  * ```typescript
-  * const sdk = new ZyfaiSDK({ apiKey: 'your-api-key' });
-  *
-  * // Connect account first
-  * await sdk.connectAccount();
-  *
-  * // Pause the agent
-  * const result = await sdk.pauseAgent();
-  * console.log('Agent paused:', result.success);
-  * ```
-  */
+   * Resume the agent by restoring protocols based on user's strategy for each asset
+   * Fetches available protocols and assigns them based on each asset's strategy
+   *
+   * @returns Response indicating success and updated user details
+   *
+   * @example
+   * ```typescript
+   * const sdk = new ZyfaiSDK({ apiKey: 'your-api-key' });
+   *
+   * // Connect account first
+   * await sdk.connectAccount();
+   *
+   * // Resume the agent
+   * const result = await sdk.resumeAgent();
+   * console.log('Agent resumed:', result.success);
+   * ```
+   */
   async resumeAgent() {
     try {
-      const userDetails = await this.getUserDetails();
-      const userChains = userDetails.user.chains;
-      const strategy = userDetails.user.strategy || "safe_strategy";
-      const convertedStrategy = toInternalStrategy(strategy);
-      const chains = userChains && userChains.length > 0 ? userChains : [8453, 42161];
+      const userDetailsUSDC = await this.getUserDetails("usdc");
+      const userDetailsETH = await this.getUserDetails("eth");
+      const chains = userDetailsUSDC.chains && userDetailsUSDC.chains.length > 0 ? userDetailsUSDC.chains : [8453, 42161];
       const allProtocols = await this.httpClient.get(
         ENDPOINTS.PROTOCOLS()
       );
-      const filteredProtocolIds = allProtocols.filter((protocol) => {
-        const hasMatchingChain = protocol.chains.some(
-          (chain) => chains.includes(chain)
-        );
-        if (!hasMatchingChain) {
-          return false;
-        }
-        if (convertedStrategy === "degen_strategy") {
-          return protocol.strategies?.includes("safe_strategy") || protocol.strategies?.includes("degen_strategy");
-        }
-        return protocol.strategies?.includes("safe_strategy");
-      }).map((protocol) => protocol.id);
-      const response = await this.updateUserProfile({
-        protocols: filteredProtocolIds
+      const usdcStrategy = userDetailsUSDC.strategy || "safe_strategy";
+      const ethStrategy = userDetailsETH.strategy || "safe_strategy";
+      const filterProtocolsByStrategy = (strategy) => {
+        return allProtocols.filter((protocol) => {
+          const hasMatchingChain = protocol.chains.some(
+            (chain) => chains.includes(chain)
+          );
+          if (!hasMatchingChain) {
+            return false;
+          }
+          if (strategy === "degen_strategy") {
+            return protocol.strategies?.includes("safe_strategy") || protocol.strategies?.includes("degen_strategy");
+          }
+          return protocol.strategies?.includes("safe_strategy");
+        }).map((protocol) => protocol.id);
+      };
+      const usdcProtocols = filterProtocolsByStrategy(usdcStrategy);
+      const ethProtocols = filterProtocolsByStrategy(ethStrategy);
+      await this.updateUserProfile({
+        asset: "usdc",
+        protocols: usdcProtocols
       });
-      return response;
+      const updatedUserDetailsETH = await this.updateUserProfile({
+        asset: "eth",
+        protocols: ethProtocols
+      });
+      return updatedUserDetailsETH;
     } catch (error) {
       throw new Error(`Failed to resume agent: ${error.message}`);
     }
@@ -1518,14 +1619,20 @@ var _ZyfaiSDK = class _ZyfaiSDK {
   async updateUserProtocols(chainId) {
     try {
       const protocolsResponse = await this.getAvailableProtocols(chainId);
-      if (!protocolsResponse.protocols || protocolsResponse.protocols.length === 0) {
+      const userDetails = await this.getUserDetails();
+      const filteredProtocols = userDetails.strategy ? protocolsResponse.protocols.filter((p) => p.strategies?.includes(userDetails.strategy)) : protocolsResponse.protocols;
+      if (!filteredProtocols || filteredProtocols.length === 0) {
         console.warn(`No protocols available for chain ${chainId}`);
         return;
       }
-      const protocolIds = protocolsResponse.protocols.map((p) => p.id);
+      const protocolIds = filteredProtocols.map((p) => p.id);
       await this.updateUserProfile({
         protocols: protocolIds
       });
+      await this.updateUserProfile({
+        protocols: protocolIds,
+        asset: "eth"
+      });
     } catch (error) {
       console.warn(
         `Failed to update user protocols: ${error.message}`
@@ -1587,7 +1694,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * );
    * ```
    */
-  async depositFunds(userAddress, chainId, amount) {
+  async depositFunds(userAddress, chainId, amount, asset) {
     try {
       if (!userAddress) {
         throw new Error("User address is required");
@@ -1598,7 +1705,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
       if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
         throw new Error("Valid amount is required");
       }
-      const token = getDefaultTokenAddress(chainId);
+      const token = getDefaultTokenAddress(chainId, asset);
       const walletClient = this.getWalletClient();
       const chainConfig = getChainConfig(chainId, this.rpcUrls);
       const safeAddress = await getDeterministicSafeAddress({
@@ -1650,6 +1757,71 @@ var _ZyfaiSDK = class _ZyfaiSDK {
       throw new Error(`Deposit failed: ${error.message}`);
     }
   }
+  /**
+   * Log a deposit that was executed client-side
+   *
+   * Use this method when you execute the deposit transaction yourself (e.g., with Privy,
+   * sponsored transactions, or any custom wallet implementation) and need to register
+   * the deposit with the Zyfai backend for tracking and yield optimization.
+   *
+   * This is useful for partners who:
+   * - Use sponsored/gasless transactions (Privy, Biconomy, etc.)
+   * - Have custom wallet implementations
+   * - Need more control over transaction execution
+   *
+   * Token is automatically selected based on chain if not provided:
+   * - Base (8453) and Arbitrum (42161): USDC
+   * - Plasma (9745): USDT
+   *
+   * @param chainId - Chain ID where the deposit was made
+   * @param txHash - Transaction hash of the deposit
+   * @param amount - Amount in least decimal units (e.g., "100000000" for 100 USDC with 6 decimals)
+   * @param tokenAddress - Optional: Token address (auto-selected based on chain if not provided)
+   * @returns Log deposit response with success status
+   *
+   * @example
+   * ```typescript
+   * // Execute deposit with Privy (sponsored transaction)
+   * const txHash = await privyWallet.sendTransaction({
+   *   to: safeAddress,
+   *   data: transferData,
+   * });
+   *
+   * // Log the deposit to Zyfai backend
+   * const result = await sdk.logDeposit(
+   *   8453,           // chainId
+   *   txHash,         // transaction hash from Privy
+   *   "100000000"     // 100 USDC
+   * );
+   * console.log(result.success); // true
+   * ```
+   */
+  async logDeposit(chainId, txHash, amount, tokenAddress) {
+    try {
+      if (!isSupportedChain(chainId)) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+      }
+      if (!txHash || !txHash.startsWith("0x")) {
+        throw new Error("Valid transaction hash is required");
+      }
+      if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
+        throw new Error("Valid amount is required");
+      }
+      const token = tokenAddress || getDefaultTokenAddress(chainId);
+      await this.httpClient.post(ENDPOINTS.LOG_DEPOSIT, {
+        chainId,
+        transaction: txHash,
+        token,
+        amount
+      });
+      return {
+        success: true,
+        message: "Deposit logged successfully"
+      };
+    } catch (error) {
+      throw new Error(`Log deposit failed: ${error.message}`);
+    }
+  }
   /**
    * Withdraw funds from Safe smart wallet
    * Initiates a withdrawal request to the Zyfai API
@@ -1675,7 +1847,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * );
    * ```
    */
-  async withdrawFunds(userAddress, chainId, amount) {
+  async withdrawFunds(userAddress, chainId, amount, tokenSymbol) {
     try {
       if (!userAddress) {
         throw new Error("User address is required");
@@ -1717,12 +1889,15 @@ var _ZyfaiSDK = class _ZyfaiSDK {
       if (amount) {
         response = await this.httpClient.post(ENDPOINTS.PARTIAL_WITHDRAW, {
           chainId,
-          amount
+          amount,
+          tokenSymbol
         });
       } else {
+        console.log("Full withdrawal", tokenSymbol);
         response = await this.httpClient.get(ENDPOINTS.USER_WITHDRAW, {
-          params: { chainId }
+          params: { chainId, tokenSymbol }
         });
+        console.log(JSON.stringify(response, null, 2));
       }
       const success = response?.success ?? true;
       const message = response?.message || "Withdrawal request sent";
@@ -1833,35 +2008,27 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * console.log("Chains:", user.user.chains);
    * ```
    */
-  async getUserDetails() {
+  async getUserDetails(asset = "usdc") {
     try {
       await this.authenticateUser();
       const response = await this.httpClient.get(ENDPOINTS.USER_ME);
       const convertedResponse = convertStrategyToPublic(response);
       return {
         success: true,
-        user: {
-          id: convertedResponse.id,
-          address: convertedResponse.address,
-          smartWallet: convertedResponse.smartWallet,
-          chains: convertedResponse.chains || [],
-          protocols: convertedResponse.protocols || [],
-          hasActiveSessionKey: convertedResponse.hasActiveSessionKey || false,
-          email: convertedResponse.email,
-          strategy: convertedResponse.strategy,
-          telegramId: convertedResponse.telegramId,
-          walletType: convertedResponse.walletType,
-          autoSelectProtocols: convertedResponse.autoSelectProtocols || false,
-          autocompounding: convertedResponse.autocompounding,
-          omniAccount: convertedResponse.omniAccount,
-          crosschainStrategy: convertedResponse.crosschainStrategy,
-          agentName: convertedResponse.agentName,
-          customization: convertedResponse.customization,
-          executorProxy: convertedResponse.executorProxy,
-          splitting: convertedResponse.splitting,
-          minSplits: convertedResponse.minSplits,
-          registered: convertedResponse.registered
-        }
+        agentName: convertedResponse.agentName,
+        smartWallet: convertedResponse.smartWallet,
+        chains: convertedResponse.assetTypeSettings?.[asset]?.chains || [],
+        hasActiveSessionKey: convertedResponse.hasActiveSessionKey || false,
+        omniAccount: convertedResponse.omniAccount,
+        asset,
+        autoSelectProtocols: convertedResponse.assetTypeSettings?.[asset]?.autoSelectProtocols,
+        strategy: convertedResponse.assetTypeSettings?.[asset]?.rebalanceStrategy,
+        autocompounding: convertedResponse.assetTypeSettings?.[asset]?.autocompounding,
+        crosschainStrategy: convertedResponse.assetTypeSettings?.[asset]?.crosschainStrategy,
+        splitting: convertedResponse.assetTypeSettings?.[asset]?.splitting,
+        minSplits: convertedResponse.assetTypeSettings?.[asset]?.minSplits || 0,
+        protocols: convertedResponse.assetTypeSettings?.[asset]?.protocols || [],
+        customization: convertedResponse.customization
       };
     } catch (error) {
       throw new Error(
@@ -1886,18 +2053,9 @@ var _ZyfaiSDK = class _ZyfaiSDK {
   async getTVL() {
     try {
       const response = await this.httpClient.get(ENDPOINTS.DATA_TVL);
-      const byChain = {};
-      for (const key of Object.keys(response)) {
-        const numKey = parseInt(key, 10);
-        if (!isNaN(numKey) && typeof response[key] === "number") {
-          byChain[numKey] = response[key];
-        }
-      }
       return {
         success: true,
-        totalTvl: response.total || response.totalTvl || response.tvl || 0,
-        byChain,
-        breakdown: response.breakdown
+        totalTvl: response.total || 0
       };
     } catch (error) {
       throw new Error(`Failed to get TVL: ${error.message}`);
@@ -1912,20 +2070,28 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * @param crossChain - Whether to get cross-chain APY (true = omni account, false = simple account)
    * @param days - Time period: 7, 14, or 30
    * @param strategy - Strategy type: "conservative" (default) or "aggressive"
+   * @param chainId - Optional chain ID filter
+   * @param tokenSymbol - Optional token symbol filter (e.g. "USDC", "WETH", "WBTC")
    * @returns APY per strategy for a specific chain
    *
    * @example
    * ```typescript
-   * const apyPerStrategy = await sdk.getAPYPerStrategy(false, 7, "conservative");
+   * const apyPerStrategy = await sdk.getAPYPerStrategy(false, 7, "conservative", 8453, "USDC");
    * console.log("APY per strategy per chain:", apyPerStrategy.data);
    * ```
    */
-  async getAPYPerStrategy(crossChain = false, days = 7, strategy = "conservative") {
+  async getAPYPerStrategy(crossChain = false, days = 7, strategy = "conservative", chainId, tokenSymbol) {
     try {
       const internalStrategy = toInternalStrategy(strategy);
       const internalStrategyShort = internalStrategy === "safe_strategy" ? "safe" : "degen";
       const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.APY_PER_STRATEGY(crossChain, days, internalStrategyShort)
+        DATA_ENDPOINTS.APY_PER_STRATEGY({
+          isCrossChain: crossChain,
+          days,
+          strategy: internalStrategyShort,
+          chainId,
+          tokenSymbol
+        })
       );
       const convertedData = convertStrategiesToPublicAndNaming(
         response.data || []
@@ -1952,9 +2118,9 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * console.log("Total Volume:", volume.volumeInUSD);
    * ```
    */
-  async getVolume() {
+  async getVolume(assetType = "usdc") {
     try {
-      const response = await this.httpClient.get(ENDPOINTS.DATA_VOLUME);
+      const response = await this.httpClient.get(ENDPOINTS.DATA_VOLUME(assetType));
       return {
         success: true,
         volumeInUSD: response.volumeInUSD || "0"
@@ -2121,12 +2287,12 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * Get onchain earnings for a wallet
    *
    * @param walletAddress - Smart wallet address
-   * @returns Onchain earnings data including total, current, and lifetime
+   * @returns Onchain earnings data with per-token breakdowns
    *
    * @example
    * ```typescript
    * const earnings = await sdk.getOnchainEarnings("0x...");
-   * console.log("Total earnings:", earnings.data.totalEarnings);
+   * console.log("Total USDC:", earnings.data.totalEarningsByToken["USDC"]);
    * ```
    */
   async getOnchainEarnings(walletAddress) {
@@ -2141,13 +2307,12 @@ var _ZyfaiSDK = class _ZyfaiSDK {
         success: true,
         data: {
           walletAddress,
-          totalEarnings: response.total_earnings || response.totalEarnings || 0,
-          currentEarnings: response.current_earnings || response.currentEarnings || 0,
-          lifetimeEarnings: response.lifetime_earnings || response.lifetimeEarnings || 0,
-          unrealizedEarnings: response.unrealized_earnings,
-          currentEarningsByChain: response.current_earnings_by_chain,
-          unrealizedEarningsByChain: response.unrealized_earnings_by_chain,
-          lastCheckTimestamp: response.last_check_timestamp
+          totalEarningsByToken: response.total_earnings_by_token || {},
+          lifetimeEarningsByToken: response.lifetime_earnings_by_token || {},
+          currentEarningsByChain: response.current_earnings_by_chain || {},
+          unrealizedEarnings: response.unrealized_earnings || {},
+          lastCheckTimestamp: response.last_check_timestamp,
+          lastLogDate: response.last_log_date
         }
       };
     } catch (error) {
@@ -2161,12 +2326,12 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * This triggers a recalculation of earnings on the backend
    *
    * @param walletAddress - Smart wallet address
-   * @returns Updated onchain earnings data
+   * @returns Updated onchain earnings data with per-token breakdowns
    *
    * @example
    * ```typescript
    * const earnings = await sdk.calculateOnchainEarnings("0x...");
-   * console.log("Calculated earnings:", earnings.data.totalEarnings);
+   * console.log("Total USDC:", earnings.data.totalEarningsByToken["USDC"]);
    * ```
    */
   async calculateOnchainEarnings(walletAddress) {
@@ -2183,11 +2348,12 @@ var _ZyfaiSDK = class _ZyfaiSDK {
         success: true,
         data: {
           walletAddress,
-          totalEarnings: data.total_earnings || data.totalEarnings || 0,
-          currentEarnings: data.current_earnings || data.currentEarnings || 0,
-          lifetimeEarnings: data.lifetime_earnings || data.lifetimeEarnings || 0,
-          unrealizedEarnings: data.unrealized_earnings,
-          lastCheckTimestamp: data.last_check_timestamp
+          totalEarningsByToken: data.total_earnings_by_token || {},
+          lifetimeEarningsByToken: data.lifetime_earnings_by_token || {},
+          currentEarningsByChain: data.current_earnings_by_chain || {},
+          unrealizedEarnings: data.unrealized_earnings || {},
+          lastCheckTimestamp: data.last_check_timestamp,
+          lastLogDate: data.last_log_date
         }
       };
     } catch (error) {
@@ -2207,7 +2373,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * @example
    * ```typescript
    * const daily = await sdk.getDailyEarnings("0x...", "2024-01-01", "2024-01-31");
-   * daily.data.forEach(d => console.log(d.date, d.earnings));
+   * daily.data.forEach(d => console.log(d.snapshot_date, d.total_earnings_by_token));
    * ```
    */
   async getDailyEarnings(walletAddress, startDate, endDate) {
@@ -2235,61 +2401,25 @@ var _ZyfaiSDK = class _ZyfaiSDK {
     }
   }
   // ============================================================================
-  // Portfolio Methods (Data API v2)
-  // ============================================================================
-  /**
-   * Get Debank portfolio for a wallet across multiple chains
-   * Note: This is a paid endpoint and may require authorization
-   *
-   * @param walletAddress - Smart wallet address
-   * @returns Multi-chain portfolio data
-   *
-   * @example
-   * ```typescript
-   * const portfolio = await sdk.getDebankPortfolio("0x...");
-   * console.log("Total value:", portfolio.totalValueUsd);
-   * ```
-   */
-  async getDebankPortfolio(walletAddress) {
-    try {
-      if (!walletAddress) {
-        throw new Error("Wallet address is required");
-      }
-      const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.DEBANK_PORTFOLIO_MULTICHAIN(walletAddress)
-      );
-      const data = response.data || response;
-      return {
-        success: true,
-        walletAddress,
-        totalValueUsd: data.totalValueUsd || 0,
-        chains: data.chains || data
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get Debank portfolio: ${error.message}`
-      );
-    }
-  }
-  // ============================================================================
   // Opportunities Methods (Data API v2)
   // ============================================================================
   /**
    * Get conservative (low-risk) yield opportunities
    *
    * @param chainId - Optional chain ID filter
+   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
    * @returns List of conservative yield opportunities
    *
    * @example
    * ```typescript
-   * const opportunities = await sdk.getConservativeOpportunities(8453);
+   * const opportunities = await sdk.getConservativeOpportunities(8453, "USDC");
    * opportunities.data.forEach(o => console.log(o.protocolName, o.apy));
    * ```
    */
-  async getConservativeOpportunities(chainId) {
+  async getConservativeOpportunities(chainId, asset, status) {
     try {
       const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_SAFE(chainId)
+        DATA_ENDPOINTS.OPPORTUNITIES_SAFE(chainId, asset, status)
       );
       const data = response.data || response || [];
       return {
@@ -2302,7 +2432,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
           protocolName: o.protocol_name || o.protocolName,
           poolName: o.pool_name || o.poolName,
           chainId: o.chain_id || o.chainId,
-          apy: o.apy || o.pool_apy || 0,
+          apy: o.combined_apy || 0,
           tvl: o.tvl || o.zyfiTvl,
           asset: o.asset || o.underlying_token,
           risk: o.risk,
@@ -2320,18 +2450,19 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * Get aggressive (high-risk, high-reward) yield opportunities
    *
    * @param chainId - Optional chain ID filter
+   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
    * @returns List of aggressive opportunities
    *
    * @example
    * ```typescript
-   * const opportunities = await sdk.getAggressiveOpportunities(8453);
+   * const opportunities = await sdk.getAggressiveOpportunities(8453, "WETH");
    * opportunities.data.forEach(o => console.log(o.protocolName, o.apy));
    * ```
    */
-  async getAggressiveOpportunities(chainId) {
+  async getAggressiveOpportunities(chainId, asset, status) {
     try {
       const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_DEGEN(chainId)
+        DATA_ENDPOINTS.OPPORTUNITIES_DEGEN(chainId, asset, status)
       );
       const data = response.data || response || [];
       return {
@@ -2344,7 +2475,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
           protocolName: o.protocol_name || o.protocolName,
           poolName: o.pool_name || o.poolName,
           chainId: o.chain_id || o.chainId,
-          apy: o.apy || o.pool_apy || 0,
+          apy: o.combined_apy || 0,
           tvl: o.tvl || o.zyfiTvl,
           asset: o.asset || o.underlying_token,
           risk: o.risk,
@@ -2363,6 +2494,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * Returns pool info, liquidity depth (true if > 1M), utilization rate, stability metrics, avg APY, and collateral
    *
    * @param chainId - Optional chain ID filter
+   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
    * @returns Active conservative opportunities with risk data
    *
    * @example
@@ -2371,10 +2503,10 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * console.log(JSON.stringify(opps, null, 2));
    * ```
    */
-  async getActiveConservativeOppsRisk(chainId) {
+  async getActiveConservativeOppsRisk(chainId, asset) {
     try {
       const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_SAFE(chainId)
+        DATA_ENDPOINTS.OPPORTUNITIES_SAFE(chainId, asset)
       );
       const data = response.data || response || [];
       const active = Array.isArray(data) ? data.filter((o) => o.status === "live").map((o) => {
@@ -2408,6 +2540,7 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * Returns pool info, liquidity depth (true if > 1M), utilization rate, stability metrics, avg APY, and collateral
    *
    * @param chainId - Optional chain ID filter
+   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
    * @returns Active aggressive opportunities with risk data
    *
    * @example
@@ -2416,10 +2549,10 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * console.log(JSON.stringify(opps, null, 2));
    * ```
    */
-  async getActiveAggressiveOppsRisk(chainId) {
+  async getActiveAggressiveOppsRisk(chainId, asset) {
     try {
       const response = await this.httpClient.dataGet(
-        DATA_ENDPOINTS.OPPORTUNITIES_DEGEN(chainId)
+        DATA_ENDPOINTS.OPPORTUNITIES_DEGEN(chainId, asset)
       );
       const data = response.data || response || [];
       const active = Array.isArray(data) ? data.filter((o) => o.status === "live").map((o) => {
@@ -2453,10 +2586,11 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * Builds on getActiveConservativeOppsRisk and computes higher-level status indicators
    *
    * @param chainId - Optional chain ID filter
+   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
    * @returns Conservative pools with status data
    */
-  async getConservativePoolStatus(chainId) {
-    const pools = await this.getActiveConservativeOppsRisk(chainId);
+  async getConservativePoolStatus(chainId, asset) {
+    const pools = await this.getActiveConservativeOppsRisk(chainId, asset);
     return pools.map((p) => this.derivePoolStatus(p));
   }
   /**
@@ -2464,10 +2598,11 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    * Builds on getActiveAggressiveOppsRisk and computes higher-level status indicators
    *
    * @param chainId - Optional chain ID filter
+   * @param asset - Optional asset filter (e.g. "USDC", "WETH", "WBTC")
    * @returns Aggressive pools with status data
    */
-  async getAggressivePoolStatus(chainId) {
-    const pools = await this.getActiveAggressiveOppsRisk(chainId);
+  async getAggressivePoolStatus(chainId, asset) {
+    const pools = await this.getActiveAggressiveOppsRisk(chainId, asset);
     return pools.map((p) => this.derivePoolStatus(p));
   }
   derivePoolStatus(p) {
@@ -2516,12 +2651,12 @@ var _ZyfaiSDK = class _ZyfaiSDK {
    *
    * @param walletAddress - Smart wallet address
    * @param days - Period: "7D", "14D", or "30D" (default: "7D")
-   * @returns Daily APY history with weighted averages
+   * @returns Daily APY history with per-position breakdowns and weighted averages
    *
    * @example
    * ```typescript
    * const apyHistory = await sdk.getDailyApyHistory("0x...", "30D");
-   * console.log("Average APY:", apyHistory.averageWeightedApy);
+   * console.log("Weighted APY after fee:", apyHistory.weightedApyAfterFee); // { "USDC": 4.64, "WETH": 1.94 }
    * ```
    */
   async getDailyApyHistory(walletAddress, days = "7D") {