@strkfarm/sdk 1.1.25 → 1.1.26

package/dist/index.browser.global.js

@@ -20191,7 +20191,7 @@ ${r2}}` : "}", l2;
         toHexString: () => toHexString2,
         toStorageKey: () => toStorageKey2
       });
-      var import_utils62 = require_utils2();
+      var import_utils63 = require_utils2();
       function isHex3(hex) {
         return /^0x[0-9a-f]*$/i.test(hex);
       }
@@ -20264,7 +20264,7 @@ ${r2}}` : "}", l2;
         if (adaptedValue.length % 2 !== 0) {
           adaptedValue = `0${adaptedValue}`;
         }
-        return (0, import_utils62.hexToBytes)(adaptedValue);
+        return (0, import_utils63.hexToBytes)(adaptedValue);
       }
       function addPercent2(number2, percent) {
         const bigIntNum = BigInt(number2);
@@ -28658,6 +28658,7 @@ ${r2}}` : "}", l2;
     HyperLSTStrategies: () => HyperLSTStrategies,
     ILending: () => ILending,
     Initializable: () => Initializable,
+    LSTAPRService: () => LSTAPRService,
     MarginType: () => MarginType,
     Network: () => Network,
     PRICE_ROUTER: () => PRICE_ROUTER,
@@ -53881,6 +53882,107 @@ ${JSON.stringify(data, null, 2)}`;
     }
   };
 
+  // src/modules/lst-apr.ts
+  var LSTAPRService = class {
+    // 5 minutes
+    /**
+     * Fetches LST stats from Endur API with caching
+     * @returns Promise<LSTStats[]> Array of LST statistics
+     */
+    static async getLSTStats() {
+      const now = Date.now();
+      if (this.cache && now - this.cacheTimestamp < this.CACHE_DURATION) {
+        logger2.verbose(`LSTAPRService: Returning cached LST stats`);
+        return this.cache;
+      }
+      try {
+        logger2.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 = await response.json();
+        if (!Array.isArray(data)) {
+          throw new Error("Invalid response format: expected array");
+        }
+        this.cache = data;
+        this.cacheTimestamp = now;
+        logger2.verbose(`LSTAPRService: Successfully fetched ${data.length} LST stats`);
+        return data;
+      } catch (error2) {
+        logger2.error(`LSTAPRService: Error fetching LST stats: ${error2}`);
+        if (this.cache) {
+          logger2.warn(`LSTAPRService: Returning stale cached data due to API error`);
+          return this.cache;
+        }
+        throw error2;
+      }
+    }
+    /**
+     * 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) {
+      const stats = await this.getLSTStats();
+      const lstStat = stats.find(
+        (stat) => ContractAddr.eqString(stat.assetAddress, assetAddress.address)
+      );
+      if (!lstStat) {
+        logger2.warn(`LSTAPRService: No LST stats found for asset address ${assetAddress.address}`);
+        return 0;
+      }
+      logger2.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) {
+      const stats = await this.getLSTStats();
+      const result2 = /* @__PURE__ */ new Map();
+      for (const assetAddress of assetAddresses) {
+        const lstStat = stats.find(
+          (stat) => ContractAddr.eqString(stat.assetAddress, assetAddress.address)
+        );
+        if (lstStat) {
+          result2.set(assetAddress.address, lstStat.apy);
+          logger2.verbose(`LSTAPRService: Found LST APR for ${lstStat.asset}: ${lstStat.apy}`);
+        } else {
+          result2.set(assetAddress.address, 0);
+          logger2.warn(`LSTAPRService: No LST stats found for asset address ${assetAddress.address}`);
+        }
+      }
+      return result2;
+    }
+    /**
+     * Gets all available LST assets and their APRs
+     * @returns Promise<Map<string, LSTStats>> Map of asset address to LST stats
+     */
+    static async getAllLSTStats() {
+      const stats = await this.getLSTStats();
+      const result2 = /* @__PURE__ */ new Map();
+      for (const stat of stats) {
+        result2.set(stat.assetAddress, stat);
+      }
+      return result2;
+    }
+    /**
+     * Clears the cache (useful for testing or forcing refresh)
+     */
+    static clearCache() {
+      this.cache = null;
+      this.cacheTimestamp = 0;
+      logger2.verbose(`LSTAPRService: Cache cleared`);
+    }
+  };
+  LSTAPRService.ENDUR_API_URL = "https://app.endur.fi/api/lst/stats";
+  LSTAPRService.cache = null;
+  LSTAPRService.cacheTimestamp = 0;
+  LSTAPRService.CACHE_DURATION = 5 * 60 * 1e3;
+
   // src/interfaces/common.tsx
   var import_jsx_runtime = __toESM(require_jsx_runtime());
   var RiskType = /* @__PURE__ */ ((RiskType2) => {
@@ -90613,12 +90715,21 @@ spurious results.`);
       logger2.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
       const baseAPYs = [];
       const rewardAPYs = [];
+      const collateralAddresses = vesuAdapters.map((adapter) => adapter.config.collateral.address);
+      let lstAPRs;
+      try {
+        lstAPRs = await LSTAPRService.getLSTAPRs(collateralAddresses);
+      } catch (error2) {
+        logger2.warn(`${this.metadata.name}::netAPY: Failed to fetch LST APRs from Endur API, using fallback: ${error2}`);
+        lstAPRs = /* @__PURE__ */ new Map();
+      }
       for (const [index, pool] of pools.entries()) {
         const vesuAdapter = vesuAdapters[index];
         const collateralAsset = pool.assets.find((a) => a.symbol.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats;
         const debtAsset = pool.assets.find((a) => 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;
+        const lstAPY = lstAPRs.get(vesuAdapter.config.collateral.address.address) || 0;
+        logger2.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]);
       }
@@ -90842,6 +90953,18 @@ spurious results.`);
     getTag() {
       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() {
+      try {
+        return await LSTAPRService.getLSTAPR(this.asset().address);
+      } catch (error2) {
+        logger2.warn(`${this.getTag()}: Failed to get LST APR: ${error2}`);
+        return 0;
+      }
+    }
     async getVesuHealthFactors() {
       return await Promise.all(this.getVesuAdapters().map((v) => v.getHealthFactor()));
     }

package/dist/index.browser.mjs

@@ -2279,6 +2279,107 @@ var PricerLST = class extends Pricer {
   }
 };
 
+// src/modules/lst-apr.ts
+var LSTAPRService = class {
+  // 5 minutes
+  /**
+   * Fetches LST stats from Endur API with caching
+   * @returns Promise<LSTStats[]> Array of LST statistics
+   */
+  static async getLSTStats() {
+    const now = Date.now();
+    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 = await response.json();
+      if (!Array.isArray(data)) {
+        throw new Error("Invalid response format: expected array");
+      }
+      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}`);
+      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) {
+    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) {
+    const stats = await this.getLSTStats();
+    const result = /* @__PURE__ */ new Map();
+    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() {
+    const stats = await this.getLSTStats();
+    const result = /* @__PURE__ */ new Map();
+    for (const stat of stats) {
+      result.set(stat.assetAddress, stat);
+    }
+    return result;
+  }
+  /**
+   * Clears the cache (useful for testing or forcing refresh)
+   */
+  static clearCache() {
+    this.cache = null;
+    this.cacheTimestamp = 0;
+    logger.verbose(`LSTAPRService: Cache cleared`);
+  }
+};
+LSTAPRService.ENDUR_API_URL = "https://app.endur.fi/api/lst/stats";
+LSTAPRService.cache = null;
+LSTAPRService.cacheTimestamp = 0;
+LSTAPRService.CACHE_DURATION = 5 * 60 * 1e3;
+
 // src/interfaces/common.tsx
 import { BlockTag, RpcProvider as RpcProvider2 } from "starknet";
 import { Fragment, jsx } from "react/jsx-runtime";
@@ -26705,12 +26806,21 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
     const baseAPYs = [];
     const rewardAPYs = [];
+    const collateralAddresses = vesuAdapters.map((adapter) => adapter.config.collateral.address);
+    let lstAPRs;
+    try {
+      lstAPRs = await LSTAPRService.getLSTAPRs(collateralAddresses);
+    } catch (error) {
+      logger.warn(`${this.metadata.name}::netAPY: Failed to fetch LST APRs from Endur API, using fallback: ${error}`);
+      lstAPRs = /* @__PURE__ */ new Map();
+    }
     for (const [index, pool] of pools.entries()) {
       const vesuAdapter = vesuAdapters[index];
       const collateralAsset = pool.assets.find((a) => a.symbol.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats;
       const debtAsset = pool.assets.find((a) => 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;
+      const lstAPY = lstAPRs.get(vesuAdapter.config.collateral.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]);
     }
@@ -26934,6 +27044,18 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   getTag() {
     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() {
+    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()));
   }
@@ -27982,6 +28104,7 @@ export {
   HyperLSTStrategies,
   ILending,
   Initializable,
+  LSTAPRService,
   MarginType,
   Network,
   PRICE_ROUTER,

package/dist/index.d.ts

@@ -1225,6 +1225,11 @@ declare class UniversalStrategy<S extends UniversalStrategySettings> extends Bas
         debtAmount: Web3Number;
     }): UniversalManageCall[];
     getTag(): string;
+    /**
+     * Gets LST APR for the strategy's underlying asset from Endur API
+     * @returns Promise<number> The LST APR (not divided by 1e18)
+     */
+    getLSTAPR(): Promise<number>;
     getVesuHealthFactors(): Promise<number[]>;
     computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
     private getNewHealthFactor;
@@ -1385,6 +1390,50 @@ declare class PricerLST extends Pricer {
     _getPriceEkubo(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;
 }
 
+interface LSTStats {
+    asset: string;
+    assetAddress: string;
+    lstAddress: string;
+    tvlUsd: number;
+    tvlAsset: number;
+    apy: number;
+    apyInPercentage: string;
+    exchangeRate: number;
+    preciseExchangeRate: string;
+}
+declare class LSTAPRService {
+    private static readonly ENDUR_API_URL;
+    private static cache;
+    private static cacheTimestamp;
+    private static readonly CACHE_DURATION;
+    /**
+     * Fetches LST stats from Endur API with caching
+     * @returns Promise<LSTStats[]> Array of LST statistics
+     */
+    static getLSTStats(): Promise<LSTStats[]>;
+    /**
+     * 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 getLSTAPR(assetAddress: ContractAddr): Promise<number>;
+    /**
+     * 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 getLSTAPRs(assetAddresses: ContractAddr[]): Promise<Map<string, number>>;
+    /**
+     * Gets all available LST assets and their APRs
+     * @returns Promise<Map<string, LSTStats>> Map of asset address to LST stats
+     */
+    static getAllLSTStats(): Promise<Map<string, LSTStats>>;
+    /**
+     * Clears the cache (useful for testing or forcing refresh)
+     */
+    static clearCache(): void;
+}
+
 declare class TelegramNotif {
     private subscribers;
     readonly bot: TelegramBot;
@@ -1535,4 +1584,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { AUMTypes, AVNU_MIDDLEWARE, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type ApproveCallParams, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FatalError, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HyperLSTStrategies, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerLST, PricerRedis, Protocols, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, VESU_SINGLETON, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, getAPIUsingHeadlessBrowser, getContractDetails, getDefaultStoreConfig, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, logger, toBigInt };
+export { AUMTypes, AVNU_MIDDLEWARE, type AccountInfo, type AdapterLeafType, type AllAccountsStore, type ApproveCallParams, AutoCompounderSTRK, type AvnuSwapCallParams, AvnuWrapper, BaseAdapter, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, type DecreaseLeverParams, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, type FAQ, FatalError, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, HyperLSTStrategies, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, Network, PRICE_ROUTER, PasswordJsonCryptoUtil, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerLST, PricerRedis, Protocols, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, type TokenAmount, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, VESU_SINGLETON, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuDefiSpringRewardsCallParams, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, getAPIUsingHeadlessBrowser, getContractDetails, getDefaultStoreConfig, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, logger, toBigInt };

package/dist/index.js

@@ -49,6 +49,7 @@ __export(index_exports, {
   HyperLSTStrategies: () => HyperLSTStrategies,
   ILending: () => ILending,
   Initializable: () => Initializable,
+  LSTAPRService: () => LSTAPRService,
   MarginType: () => MarginType,
   Network: () => Network,
   PRICE_ROUTER: () => PRICE_ROUTER,
@@ -26801,12 +26802,21 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
     const baseAPYs = [];
     const rewardAPYs = [];
+    const collateralAddresses = vesuAdapters.map((adapter) => adapter.config.collateral.address);
+    let lstAPRs;
+    try {
+      lstAPRs = await LSTAPRService.getLSTAPRs(collateralAddresses);
+    } catch (error) {
+      logger.warn(`${this.metadata.name}::netAPY: Failed to fetch LST APRs from Endur API, using fallback: ${error}`);
+      lstAPRs = /* @__PURE__ */ new Map();
+    }
     for (const [index, pool] of pools.entries()) {
       const vesuAdapter = vesuAdapters[index];
       const collateralAsset = pool.assets.find((a) => a.symbol.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats;
       const debtAsset = pool.assets.find((a) => 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;
+      const lstAPY = lstAPRs.get(vesuAdapter.config.collateral.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]);
     }
@@ -27030,6 +27040,18 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   getTag() {
     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() {
+    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()));
   }
@@ -28110,6 +28132,107 @@ var PricerLST2 = class extends Pricer {
   }
 };
 
+// src/modules/lst-apr.ts
+var LSTAPRService = class {
+  // 5 minutes
+  /**
+   * Fetches LST stats from Endur API with caching
+   * @returns Promise<LSTStats[]> Array of LST statistics
+   */
+  static async getLSTStats() {
+    const now = Date.now();
+    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 = await response.json();
+      if (!Array.isArray(data)) {
+        throw new Error("Invalid response format: expected array");
+      }
+      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}`);
+      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) {
+    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) {
+    const stats = await this.getLSTStats();
+    const result = /* @__PURE__ */ new Map();
+    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() {
+    const stats = await this.getLSTStats();
+    const result = /* @__PURE__ */ new Map();
+    for (const stat of stats) {
+      result.set(stat.assetAddress, stat);
+    }
+    return result;
+  }
+  /**
+   * Clears the cache (useful for testing or forcing refresh)
+   */
+  static clearCache() {
+    this.cache = null;
+    this.cacheTimestamp = 0;
+    logger.verbose(`LSTAPRService: Cache cleared`);
+  }
+};
+LSTAPRService.ENDUR_API_URL = "https://app.endur.fi/api/lst/stats";
+LSTAPRService.cache = null;
+LSTAPRService.cacheTimestamp = 0;
+LSTAPRService.CACHE_DURATION = 5 * 60 * 1e3;
+
 // src/notifs/telegram.ts
 var import_node_telegram_bot_api = __toESM(require("node-telegram-bot-api"));
 var TelegramNotif = class {
@@ -28638,6 +28761,7 @@ var deployer_default = Deployer;
   HyperLSTStrategies,
   ILending,
   Initializable,
+  LSTAPRService,
   MarginType,
   Network,
   PRICE_ROUTER,

package/dist/index.mjs

@@ -26704,12 +26704,21 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
     const baseAPYs = [];
     const rewardAPYs = [];
+    const collateralAddresses = vesuAdapters.map((adapter) => adapter.config.collateral.address);
+    let lstAPRs;
+    try {
+      lstAPRs = await LSTAPRService.getLSTAPRs(collateralAddresses);
+    } catch (error) {
+      logger.warn(`${this.metadata.name}::netAPY: Failed to fetch LST APRs from Endur API, using fallback: ${error}`);
+      lstAPRs = /* @__PURE__ */ new Map();
+    }
     for (const [index, pool] of pools.entries()) {
       const vesuAdapter = vesuAdapters[index];
       const collateralAsset = pool.assets.find((a) => a.symbol.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats;
       const debtAsset = pool.assets.find((a) => 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;
+      const lstAPY = lstAPRs.get(vesuAdapter.config.collateral.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]);
     }
@@ -26933,6 +26942,18 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   getTag() {
     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() {
+    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()));
   }
@@ -28013,6 +28034,107 @@ var PricerLST2 = class extends Pricer {
   }
 };
 
+// src/modules/lst-apr.ts
+var LSTAPRService = class {
+  // 5 minutes
+  /**
+   * Fetches LST stats from Endur API with caching
+   * @returns Promise<LSTStats[]> Array of LST statistics
+   */
+  static async getLSTStats() {
+    const now = Date.now();
+    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 = await response.json();
+      if (!Array.isArray(data)) {
+        throw new Error("Invalid response format: expected array");
+      }
+      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}`);
+      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) {
+    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) {
+    const stats = await this.getLSTStats();
+    const result = /* @__PURE__ */ new Map();
+    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() {
+    const stats = await this.getLSTStats();
+    const result = /* @__PURE__ */ new Map();
+    for (const stat of stats) {
+      result.set(stat.assetAddress, stat);
+    }
+    return result;
+  }
+  /**
+   * Clears the cache (useful for testing or forcing refresh)
+   */
+  static clearCache() {
+    this.cache = null;
+    this.cacheTimestamp = 0;
+    logger.verbose(`LSTAPRService: Cache cleared`);
+  }
+};
+LSTAPRService.ENDUR_API_URL = "https://app.endur.fi/api/lst/stats";
+LSTAPRService.cache = null;
+LSTAPRService.cacheTimestamp = 0;
+LSTAPRService.CACHE_DURATION = 5 * 60 * 1e3;
+
 // src/notifs/telegram.ts
 import TelegramBot from "node-telegram-bot-api";
 var TelegramNotif = class {
@@ -28540,6 +28662,7 @@ export {
   HyperLSTStrategies,
   ILending,
   Initializable,
+  LSTAPRService,
   MarginType,
   Network,
   PRICE_ROUTER,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.25",
+  "version": "1.1.26",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

package/src/modules/index.ts

@@ -5,4 +5,5 @@ export * from './pricer-from-api';
 export * from './erc20';
 export * from './avnu';
 export * from './ekubo-quoter';
-export * from './pricer-lst';
+export * from './pricer-lst';
+export * from './lst-apr';

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 collateralAddresses = vesuAdapters.map(adapter => adapter.config.collateral.address);
+    let lstAPRs: Map<string, number>;
+    try {
+      lstAPRs = await LSTAPRService.getLSTAPRs(collateralAddresses);
+    } 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.collateral.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()));
   }