@strkfarm/sdk 1.1.25 → 1.1.27

package/src/modules/lst-apr.ts

@@ -0,0 +1,140 @@
+import { ContractAddr } from "@/dataTypes";
+import { logger } from "@/utils";
+
+export interface LSTStats {
+  asset: string;
+  assetAddress: string;
+  lstAddress: string;
+  tvlUsd: number;
+  tvlAsset: number;
+  apy: number;
+  apyInPercentage: string;
+  exchangeRate: number;
+  preciseExchangeRate: string;
+}
+
+export class LSTAPRService {
+  private static readonly ENDUR_API_URL = 'https://app.endur.fi/api/lst/stats';
+  private static cache: LSTStats[] | null = null;
+  private static cacheTimestamp: number = 0;
+  private static readonly CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+
+  /**
+   * Fetches LST stats from Endur API with caching
+   * @returns Promise<LSTStats[]> Array of LST statistics
+   */
+  static async getLSTStats(): Promise<LSTStats[]> {
+    const now = Date.now();
+    
+    // Return cached data if still valid
+    if (this.cache && (now - this.cacheTimestamp) < this.CACHE_DURATION) {
+      logger.verbose(`LSTAPRService: Returning cached LST stats`);
+      return this.cache;
+    }
+
+    try {
+      logger.verbose(`LSTAPRService: Fetching LST stats from Endur API`);
+      const response = await fetch(this.ENDUR_API_URL);
+      
+      if (!response.ok) {
+        throw new Error(`Failed to fetch LST stats: ${response.status} ${response.statusText}`);
+      }
+
+      const data: LSTStats[] = await response.json();
+      
+      // Validate the response structure
+      if (!Array.isArray(data)) {
+        throw new Error('Invalid response format: expected array');
+      }
+
+      // Cache the data
+      this.cache = data;
+      this.cacheTimestamp = now;
+      
+      logger.verbose(`LSTAPRService: Successfully fetched ${data.length} LST stats`);
+      return data;
+      
+    } catch (error) {
+      logger.error(`LSTAPRService: Error fetching LST stats: ${error}`);
+      
+      // Return cached data if available, even if expired
+      if (this.cache) {
+        logger.warn(`LSTAPRService: Returning stale cached data due to API error`);
+        return this.cache;
+      }
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Gets LST APR for a specific asset address
+   * @param assetAddress - The contract address of the underlying asset
+   * @returns Promise<number> The LST APR (not divided by 1e18)
+   */
+  static async getLSTAPR(assetAddress: ContractAddr): Promise<number> {
+    const stats = await this.getLSTStats();
+    
+    const lstStat = stats.find(stat => 
+      ContractAddr.eqString(stat.assetAddress, assetAddress.address)
+    );
+
+    if (!lstStat) {
+      logger.warn(`LSTAPRService: No LST stats found for asset address ${assetAddress.address}`);
+      return 0;
+    }
+
+    logger.verbose(`LSTAPRService: Found LST APR for ${lstStat.asset}: ${lstStat.apy} (${lstStat.apyInPercentage})`);
+    return lstStat.apy;
+  }
+
+  /**
+   * Gets LST APR for multiple asset addresses
+   * @param assetAddresses - Array of contract addresses
+   * @returns Promise<Map<string, number>> Map of asset address to LST APR
+   */
+  static async getLSTAPRs(assetAddresses: ContractAddr[]): Promise<Map<string, number>> {
+    const stats = await this.getLSTStats();
+    const result = new Map<string, number>();
+
+    for (const assetAddress of assetAddresses) {
+      const lstStat = stats.find(stat => 
+        ContractAddr.eqString(stat.assetAddress, assetAddress.address)
+      );
+
+      if (lstStat) {
+        result.set(assetAddress.address, lstStat.apy);
+        logger.verbose(`LSTAPRService: Found LST APR for ${lstStat.asset}: ${lstStat.apy}`);
+      } else {
+        result.set(assetAddress.address, 0);
+        logger.warn(`LSTAPRService: No LST stats found for asset address ${assetAddress.address}`);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Gets all available LST assets and their APRs
+   * @returns Promise<Map<string, LSTStats>> Map of asset address to LST stats
+   */
+  static async getAllLSTStats(): Promise<Map<string, LSTStats>> {
+    const stats = await this.getLSTStats();
+    const result = new Map<string, LSTStats>();
+
+    for (const stat of stats) {
+      result.set(stat.assetAddress, stat);
+    }
+
+    return result;
+  }
+
+  /**
+   * Clears the cache (useful for testing or forcing refresh)
+   */
+  static clearCache(): void {
+    this.cache = null;
+    this.cacheTimestamp = 0;
+    logger.verbose(`LSTAPRService: Cache cleared`);
+  }
+}

package/src/strategies/universal-strategy.tsx

@@ -9,7 +9,7 @@ import UniversalVaultAbi from '../data/universal-vault.abi.json';
 import ManagerAbi from '../data/vault-manager.abi.json';
 import { ApproveCallParams, AvnuSwapCallParams, BaseAdapter, CommonAdapter, FlashloanCallParams, GenerateCallFn, LeafAdapterFn, ManageCall, VesuAdapter, VesuDefiSpringRewardsCallParams, VesuModifyPositionCallParams, VesuPools } from "./universal-adapters";
 import { Global } from "@/global";
-import { AvnuWrapper, ERC20 } from "@/modules";
+import { AvnuWrapper, ERC20, LSTAPRService } from "@/modules";
 import { AVNU_MIDDLEWARE, VESU_SINGLETON } from "./universal-adapters/adapter-utils";
 import { VesuHarvests } from "@/modules/harvests";
 
@@ -227,12 +227,28 @@ export class UniversalStrategy<
     logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
     const baseAPYs: number[] = [];
     const rewardAPYs: number[] = [];
+    
+    // Get LST APRs for all collateral assets with fallback
+    const underlyingAddresses = vesuAdapters.map(adapter => adapter.config.debt.address);
+    let lstAPRs: Map<string, number>;
+    try {
+      lstAPRs = await LSTAPRService.getLSTAPRs(underlyingAddresses);
+    } catch (error) {
+      logger.warn(`${this.metadata.name}::netAPY: Failed to fetch LST APRs from Endur API, using fallback: ${error}`);
+      // Fallback: create empty map (will result in 0 LST APR)
+      lstAPRs = new Map();
+    }
+    
     for (const [index, pool] of pools.entries()) {
       const vesuAdapter = vesuAdapters[index];
       const collateralAsset = pool.assets.find((a: any) => a.symbol.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats!;
       const debtAsset = pool.assets.find((a: any) => a.symbol.toLowerCase() === vesuAdapter.config.debt.symbol.toLowerCase())?.stats!;
       const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
-      const lstAPY = Number(collateralAsset.lstApr?.value || 0) / 1e18;
+      
+      // Use LST APR from Endur API instead of Vesu's lstApr
+      const lstAPY = lstAPRs.get(vesuAdapter.config.debt.address.address) || 0;
+      logger.verbose(`${this.metadata.name}::netAPY: ${vesuAdapter.config.collateral.symbol} LST APR from Endur: ${lstAPY}`);
+      
       baseAPYs.push(...[supplyApy + lstAPY, Number(debtAsset.borrowApr.value) / 1e18]);
       rewardAPYs.push(...[Number(collateralAsset.defiSpringSupplyApr?.value || "0") / 1e18, 0]);
     }
@@ -501,6 +517,19 @@ export class UniversalStrategy<
     return `${UniversalStrategy.name}:${this.metadata.name}`;
   }
 
+  /**
+   * Gets LST APR for the strategy's underlying asset from Endur API
+   * @returns Promise<number> The LST APR (not divided by 1e18)
+   */
+  async getLSTAPR(): Promise<number> {
+    try {
+      return await LSTAPRService.getLSTAPR(this.asset().address);
+    } catch (error) {
+      logger.warn(`${this.getTag()}: Failed to get LST APR: ${error}`);
+      return 0;
+    }
+  }
+
   async getVesuHealthFactors() {
     return await Promise.all(this.getVesuAdapters().map(v => v.getHealthFactor()));
   }