@strkfarm/sdk 1.1.70 → 2.0.0-dev.1

package/src/modules/avnu.ts

@@ -37,7 +37,7 @@ export class AvnuWrapper {
     excludeSources = ['Haiko(Solvers)']
   ): Promise<Quote> {
     const MAX_RETRY = 5;
-    // logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
+    logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
     const params: any = {
       sellTokenAddress: fromToken,
       buyTokenAddress: toToken,
@@ -100,9 +100,9 @@ export class AvnuWrapper {
     // swapInfo as expected by the strategy
     // fallback, max 1% slippage
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo: SwapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),
@@ -135,4 +135,17 @@ export class AvnuWrapper {
       routes: [],
     };
   }
+
+
+  async getSwapCallData(
+    quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>,
+    taker: string,
+  ) {
+    const calldata = await fetchBuildExecuteTransaction(quote.quoteId, taker, undefined, false);
+    const result = calldata.calls.map((call: Call) => {
+      const data = call.calldata as string[];
+      return data.map(x => BigInt(x));
+    });
+    return result;
+  }
 }

package/src/modules/ekubo-quoter.ts

@@ -2,6 +2,12 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo } from "@/interfaces/common";
 import { Swap } from "@/strategies";
 import axios from "axios";
+import { logger } from "@/utils";
+import { uint256 } from "starknet";
+import { Contract } from "starknet";
+import ERC4626Abi from "@/data/erc4626.abi.json";
+import { TokenMarketData } from "./token-market-data";
+import { PricerBase } from "./pricerBase";
 
 export interface EkuboRouteNode {
   pool_key: {
@@ -29,8 +35,11 @@ export interface EkuboQuote {
 
 export class EkuboQuoter {
   ENDPOINT = 'https://prod-api-quoter.ekubo.org/23448594291968334/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}'; // e.g. ETH/USDC'
-  
-  constructor(private readonly config: IConfig) {}
+  tokenMarketData: TokenMarketData;
+
+  constructor(private readonly config: IConfig, pricer: PricerBase) {
+    this.tokenMarketData = new TokenMarketData(pricer, config);
+  }
 
   /**
    * 
@@ -40,16 +49,17 @@ export class EkuboQuoter {
    * @returns 
    */
   async getQuote(fromToken: string, toToken: string, amount: Web3Number, retry = 0): Promise<EkuboQuote> {
-    let _fromToken = amount.gt(0) ? fromToken : toToken;
-    let _toToken = amount.gt(0) ? toToken : fromToken;
+    // let _fromToken = amount.gt(0) ? fromToken : toToken;
+    // let _toToken = amount.gt(0) ? toToken : fromToken;
 
     try {
-      const quote = await axios.get(this.ENDPOINT.replace("{{AMOUNT}}", amount.toWei()).replace("{{TOKEN_FROM_ADDRESS}}", _fromToken).replace("{{TOKEN_TO_ADDRESS}}", _toToken));
-      console.log(`Ekubo quote from ${_fromToken} to ${_toToken} for ${amount.toString()}: ${JSON.stringify(quote.data)}`);
-      return quote.data as EkuboQuote;
+      const url = this.ENDPOINT.replace("{{AMOUNT}}", amount.toFixed(0)).replace("{{TOKEN_FROM_ADDRESS}}", fromToken).replace("{{TOKEN_TO_ADDRESS}}", toToken);
+      console.log("url", url);
+      const quote = await axios.get(url);
+     return quote.data as EkuboQuote;
     } catch (error: any) {
-      console.error(error.message, 'dassf', error.data);
-      if (retry < 10) {
+      logger.error(`${error.message} dassf ${error.data}`);
+      if (retry < 3) {
         await new Promise((resolve) => setTimeout(resolve, (retry + 1) * 5000));
         return await this.getQuote(fromToken, toToken, amount, retry + 1);
       }
@@ -57,6 +67,83 @@ export class EkuboQuoter {
     }
   }
 
+  async getDexPrice(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number) {
+    const lstTokenInfo = baseToken;
+    const lstUnderlyingTokenInfo = quoteToken;
+    console.log("lstTokenInfo", lstTokenInfo);
+    console.log("lstUnderlyingTokenInfo", lstUnderlyingTokenInfo);
+    console.log("amount", amount);
+    const quote = await this.getQuote(
+      lstTokenInfo.address.address,
+      lstUnderlyingTokenInfo.address.address,
+      amount
+    );
+    console.log("quote", quote);
+    // in Underlying
+    const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
+    console.log("outputAmount", outputAmount);
+    console.log("amount", amount);
+    const price = outputAmount.toNumber() / amount.toNumber();
+    console.log("price", price);
+    logger.verbose(`${EkuboQuoter.name}:: LST Dex Price: ${price}`);
+    return price;
+  }
+
+  async getLSTTrueExchangeRate(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number) {
+    const lstTokenInfo = baseToken;
+    const lstABI = new Contract({
+      abi: ERC4626Abi,
+      address: lstTokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
+
+    const price: any = await lstABI.call('convert_to_assets', [uint256.bnToUint256((new Web3Number(1, lstTokenInfo.decimals)).toWei())]);
+    const exchangeRate = Number(uint256.uint256ToBN(price).toString()) / Math.pow(10, lstTokenInfo.decimals);
+    logger.verbose(`${EkuboQuoter.name}:: LST true Exchange Rate: ${exchangeRate}`);
+    return exchangeRate;
+  }
+  // debt collateral 
+  async getSwapLimitAmount(fromToken: TokenInfo, toToken: TokenInfo, amount: Web3Number, max_slippage: number = 0.002): Promise<Web3Number> {
+    const isExactAmountIn = amount.greaterThanOrEqualTo(0);
+    console.log("isExactAmountIn", isExactAmountIn);
+    logger.verbose(`${EkuboQuoter.name}::getSwapLimitAmount isExactAmountIn: ${isExactAmountIn}, fromToken: ${fromToken.symbol}, toToken: ${toToken.symbol}, amount: ${amount}`);
+    const isYieldToken = this.tokenMarketData.isAPYSupported(toToken);
+    console.log("isYieldToken", isYieldToken);
+    
+    // if LST, get true exchange rate else use dex price
+    // wbtc
+    const baseToken = isExactAmountIn ? toToken : fromToken; // fromToken -> wbtc, 
+    const quoteToken = isExactAmountIn ? fromToken : toToken; // toToken -> usdc, 
+    console.log("baseToken", baseToken);
+    console.log("quoteToken", quoteToken);
+    // need dex price of from token in toToken
+    // from baseToken to underlying token
+    // for withdraw, usdc to btc with amount negative
+    const dexPrice = await this.getDexPrice(baseToken, quoteToken, amount);
+    console.log("dexPrice", dexPrice);
+    const trueExchangeRate = isYieldToken ? await this.tokenMarketData.getTruePrice(baseToken) : dexPrice;
+    console.log("trueExchangeRate", trueExchangeRate);
+    if (isExactAmountIn) {
+      let minLSTReceived = amount.dividedBy(dexPrice).multipliedBy(1 - max_slippage); // used for increase
+      console.log("minLSTReceived", minLSTReceived);
+      const minLSTReceivedAsPerTruePrice = amount.dividedBy(trueExchangeRate); // execution output to be <= True LST price
+      if (minLSTReceived < minLSTReceivedAsPerTruePrice) {
+        minLSTReceived = minLSTReceivedAsPerTruePrice; // the execution shouldn't be bad than True price logi
+      }
+      logger.verbose(`${EkuboQuoter.name}::getModifyLeverCall minLSTReceivedAsPerTruePrice: ${minLSTReceivedAsPerTruePrice}, minLSTReceived: ${minLSTReceived}`);
+      return minLSTReceived;
+    }
+    
+    let maxUsedCollateral = amount.abs().dividedBy(dexPrice).multipliedBy(1 + max_slippage); // +ve for exact amount out, used for decrease
+    const maxUsedCollateralInLST = amount.abs().dividedBy(trueExchangeRate).multipliedBy(1.005); // 0.5% slippage, worst case based on true price
+    logger.verbose(`${EkuboQuoter.name}::getModifyLeverCall maxUsedCollateralInLST: ${maxUsedCollateralInLST}, maxUsedCollateral: ${maxUsedCollateral}`);
+    if (maxUsedCollateralInLST > maxUsedCollateral) {
+      maxUsedCollateral = maxUsedCollateralInLST;
+    }
+    
+    return maxUsedCollateral;
+  }
+
   /**
    * Formats Ekubo response for Vesu multiple use
    * @param quote 
@@ -65,8 +152,9 @@ export class EkuboQuoter {
    */
   getVesuMultiplyQuote(quote: EkuboQuote, fromTokenInfo: TokenInfo, toTokenInfo: TokenInfo): Swap[] {
     return quote.splits.map(split => {
-      const isNegativeAmount = BigInt(split.amount_specified) < 0n;
+      const isNegativeAmount = BigInt(split.amount_specified) <= 0n;
       const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
+      //console.log("token", token, isNegativeAmount);
       return {
         route: split.route.map(_route => ({
           pool_key: {

package/src/modules/erc20.ts

@@ -1,29 +1,75 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig } from "@/interfaces";
-import { Contract } from "starknet";
-import ERC20Abi from '@/data/erc20.abi.json';
+import { Contract, uint256 } from "starknet";
+import ERC20Abi from "@/data/erc20.abi.json";
 
 export class ERC20 {
-    readonly config: IConfig;
+  readonly config: IConfig;
 
-    constructor(config: IConfig) {
-        this.config = config;
-    }
+  constructor(config: IConfig) {
+    this.config = config;
+  }
 
-    contract(addr: string | ContractAddr) {
-        const _addr = typeof addr === 'string' ? addr : addr.address;
-        return new Contract({abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider});
-    }
+  contract(addr: string | ContractAddr) {
+    const _addr = typeof addr === "string" ? addr : addr.address;
+    return new Contract({
+      abi: ERC20Abi,
+      address: _addr,
+      providerOrAccount: this.config.provider,
+    });
+  }
 
-    async balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number) {
-        const contract = this.contract(token);
-        const balance = await contract.call('balanceOf', [address.toString()]);
-        return Web3Number.fromWei(balance.toString(), tokenDecimals);
-    }
+  async balanceOf(
+    token: string | ContractAddr,
+    address: string | ContractAddr,
+    tokenDecimals: number
+  ) {
+    const contract = this.contract(token);
+    const balance = await contract.call("balance_of", [address.toString()]);
+    return Web3Number.fromWei(balance.toString(), tokenDecimals);
+  }
 
-    async allowance(token: string | ContractAddr, owner: string | ContractAddr, spender: string | ContractAddr, tokenDecimals: number) {
-        const contract = this.contract(token);
-        const allowance = await contract.call('allowance', [owner.toString(), spender.toString()]);
-        return Web3Number.fromWei(allowance.toString(), tokenDecimals);
-    }
-}
+  async allowance(
+    token: string | ContractAddr,
+    owner: string | ContractAddr,
+    spender: string | ContractAddr,
+    tokenDecimals: number
+  ) {
+    const contract = this.contract(token);
+    const allowance = await contract.call("allowance", [
+      owner.toString(),
+      spender.toString(),
+    ]);
+    return Web3Number.fromWei(allowance.toString(), tokenDecimals);
+  }
+
+  transfer(
+    token: string | ContractAddr,
+    to: string | ContractAddr,
+    amount: Web3Number
+  ) {
+    const contract = this.contract(token);
+    const amountUint256 = uint256.bnToUint256(amount.toWei());
+    const transferCall =  contract.populate("transfer", [
+      to.toString(),
+      amountUint256.low.toString(),
+      amountUint256.high.toString(),
+    ]);
+    return transferCall;
+  }
+
+   approve(
+    token: string | ContractAddr,
+    spender: string | ContractAddr,
+    amount: Web3Number
+  ) {
+    const contract = this.contract(token);
+    const amountUint256 = uint256.bnToUint256(amount.toWei());
+    const approveCall = contract.populate("approve", [
+      spender.toString(),
+      amountUint256.low.toString(),
+      amountUint256.high.toString(),
+    ]);
+    return approveCall;
+  }
+}

package/src/modules/harvests.ts

@@ -29,36 +29,28 @@ export class Harvests {
 
     async getUnHarvestedRewards(addr: ContractAddr) {
         const rewards = await this.getHarvests(addr);
-        logger.verbose(`${Harvests.name}: getUnHarvestedRewards => rewards length: ${rewards.length}`);
         if (rewards.length == 0) return [];
 
         const unClaimed: HarvestInfo[] = [];
 
         // use the latest one
-        const sortedRewards = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
-        if (sortedRewards.length == 0) {
-            logger.verbose(`${Harvests.name}: no rewards found`);
-            return [];
-        }
-
-        const cls = await this.config.provider.getClassAt(sortedRewards[0].rewardsContract.address);
+        const reward = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime())[0];
 
-        for (const reward of sortedRewards) {
-            const contract = new Contract({abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider});
-            const isClaimed = await contract.call('is_claimed', [reward.claim.id]);
-            logger.verbose(`${Harvests.name}: isClaimed: ${isClaimed}, claim id: ${reward.claim.id}, address: ${reward.rewardsContract.address}`);
-            if (isClaimed) {
-                continue;
-            }
-            // rewards contract must have enough balance to claim
-            const bal = await (new ERC20(this.config)).balanceOf(reward.token, reward.rewardsContract.address, 18);
-            if (bal.lessThan(reward.claim.amount)) {
-                logger.verbose(`${Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
-                continue;
-            }
-
-            unClaimed.push(reward); // to ensure older harvest is first
+        const cls = await this.config.provider.getClassAt(reward.rewardsContract.address);
+        const contract = new Contract({abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider});
+        const isClaimed = await contract.call('is_claimed', [reward.claim.id]);
+        logger.verbose(`${Harvests.name}: isClaimed: ${isClaimed}`);
+        if (isClaimed) {
+            return unClaimed;
+        }
+        // rewards contract must have enough balance to claim
+        const bal = await (new ERC20(this.config)).balanceOf(reward.token, reward.rewardsContract.address, 18);
+        if (bal.lessThan(reward.claim.amount)) {
+            logger.verbose(`${Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
+            return unClaimed;
         }
+
+        unClaimed.unshift(reward); // to ensure older harvest is first
         return unClaimed;
     }
 }
@@ -67,11 +59,10 @@ const STRK = '0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d'
 
 export class EkuboHarvests extends Harvests {
     async getHarvests(addr: ContractAddr) {
-        logger.verbose(`${EkuboHarvests.name}: getHarvests => addr: ${addr.address}`);
         const EKUBO_API = `https://starknet-mainnet-api.ekubo.org/airdrops/${addr.address}?token=${STRK}`
         const resultEkubo = await fetch(EKUBO_API);
         const items = (await resultEkubo.json());
-        logger.verbose(`${EkuboHarvests.name}: getHarvests => items length: ${items.length}`);
+
         const rewards: HarvestInfo[] = [];
         for (let i=0; i<items.length; ++i) {
             const info = items[i];
@@ -110,10 +101,6 @@ export class VesuHarvests extends Harvests {
         logger.verbose(`${VesuHarvests.name}: claimed_amount: ${claimed_amount.toString()}`);
         
         const data = _data.data['defiSpring'];
-        if (!data) {
-            logger.verbose(`${VesuHarvests.name}: no defiSpring data found`);
-            return [];
-        }
 
         // get the actual reward
         const actualReward = Web3Number.fromWei(data.amount, 18).minus(claimed_amount);

package/src/modules/index.ts

@@ -1,3 +1,4 @@
+export * from './token-market-data';
 export * from './pricer';
 export * from './pragma';
 export * from './zkLend';
@@ -6,4 +7,7 @@ export * from './erc20';
 export * from './avnu';
 export * from './ekubo-quoter';
 export * from './pricer-lst';
-export * from './lst-apr';
+export * from './lst-apr';
+export * from './pricerBase';
+export * from './midas';
+export * from './ExtendedWrapperSDk';

package/src/modules/lst-apr.ts

@@ -1,4 +1,6 @@
 import { ContractAddr } from "@/dataTypes";
+import { Global } from "@/global";
+import { TokenInfo } from "@/interfaces";
 import { logger } from "@/utils";
 
 export interface LSTStats {
@@ -19,6 +21,19 @@ export class LSTAPRService {
   private static cacheTimestamp: number = 0;
   private static readonly CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
 
+  static lstMapping: Record<string, TokenInfo> = {};
+
+  static isLST(address: ContractAddr): boolean {
+    return this.lstMapping[address.address] !== undefined;
+  }
+  
+  static getUnderlyingFromLST(lstAddress: ContractAddr): TokenInfo {
+    const underlying = this.lstMapping[lstAddress.address];
+    if (!underlying) {
+      throw new Error(`Underlying token not found for ${lstAddress.address}`);
+    }
+    return underlying;
+  }
   /**
    * Fetches LST stats from Endur API with caching
    * @returns Promise<LSTStats[]> Array of LST statistics
@@ -138,3 +153,24 @@ export class LSTAPRService {
     logger.verbose(`LSTAPRService: Cache cleared`);
   }
 }
+
+
+// populate lstMapping
+const lstSymbolMapping: any = {
+  xSTRK: "STRK",
+  xWBTC: "WBTC",
+  xtBTC: "tBTC",
+  xsBTC: "solvBTC",
+  xLBTC: "LBTC",
+}
+Object.keys(lstSymbolMapping).forEach(key => {
+  const lst = Global.getDefaultTokens().find(t => t.symbol === key);
+  if (!lst) {
+    throw new Error(`LST token not found for ${key}`);
+  }
+  const underlying = Global.getDefaultTokens().find(t => t.symbol === lstSymbolMapping[key]);
+  if (!underlying) {
+    throw new Error(`Underlying token not found for ${key}`);
+  }
+  LSTAPRService.lstMapping[lst.address.address] = underlying;
+});

package/src/modules/midas.ts

@@ -0,0 +1,159 @@
+import axios from 'axios';
+import { ContractAddr } from '../dataTypes';
+import { logger } from '../utils/logger';
+
+/**
+ * Midas module for interacting with Midas API
+ * Provides functions to get APY, price, and TVL data for Midas tokens
+ */
+export class Midas {
+    // Static mapping of contract addresses to Midas API symbols
+    private static readonly CONTRACT_TO_SYMBOL: Record<string, string> = {
+        '0x4e4fb1a9ca7e84bae609b9dc0078ad7719e49187ae7e425bb47d131710eddac': 'mre7btc', // mRe7BTC
+        '0x4be8945e61dc3e19ebadd1579a6bd53b262f51ba89e6f8b0c4bc9a7e3c633fc': 'mre7', // mRe7YIELD
+    };
+
+    private static readonly BASE_URL = 'https://api-prod.midas.app/api/data';
+
+    /**
+     * Check if a contract address is supported by Midas
+     * @param contractAddr The contract address to check
+     * @returns True if the contract address is supported
+     */
+    static isSupported(contractAddr: ContractAddr): boolean {
+        return contractAddr.address in Midas.CONTRACT_TO_SYMBOL;
+    }
+
+    /**
+     * Get the Midas symbol for a given contract address
+     * @param contractAddr The contract address to look up
+     * @returns The Midas symbol for the contract
+     * @throws Error if contract address is not found
+     */
+    static getSymbolFromContract(contractAddr: ContractAddr): string {
+        const symbol = Midas.CONTRACT_TO_SYMBOL[contractAddr.address];
+        if (!symbol) {
+            throw new Error(`Contract address ${contractAddr.address} not found in Midas mapping`);
+        }
+        return symbol;
+    }
+
+    /**
+     * Get APY data for all Midas tokens
+     * @returns Object with token symbols as keys and APY values as numbers
+     * @throws Error if API request fails
+     */
+    static async getAPYs(): Promise<Record<string, number>> {
+        try {
+            const response = await axios.get(`${Midas.BASE_URL}/apys`);
+            return response.data;
+        } catch (error) {
+            logger.error('Failed to fetch APYs from Midas API:', error);
+            throw new Error(`Failed to fetch APYs: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+
+    /**
+     * Get APY for a specific token by contract address
+     * @param contractAddr The contract address of the token
+     * @returns The APY value for the token
+     * @throws Error if contract address not found or API request fails
+     */
+    static async getAPY(contractAddr: ContractAddr): Promise<number> {
+        const symbol = Midas.getSymbolFromContract(contractAddr);
+        const apys = await Midas.getAPYs();
+        
+        if (!(symbol in apys)) {
+            throw new Error(`Symbol ${symbol} not found in APY data`);
+        }
+        
+        return apys[symbol];
+    }
+
+    /**
+     * Get price data for a specific token
+     * @param contractAddr The contract address of the token
+     * @param timestampFrom Optional start timestamp (defaults to 30 days ago)
+     * @param timestampTo Optional end timestamp (defaults to now)
+     * @param environment Environment (defaults to 'mainnet')
+     * @returns The latest price for the token
+     * @throws Error if contract address not found or API request fails
+     */
+    static async getPrice(
+        contractAddr: ContractAddr,
+        timestampFrom?: number,
+        timestampTo?: number,
+        environment: string = 'mainnet'
+    ): Promise<number> {
+        const symbol = Midas.getSymbolFromContract(contractAddr);
+        
+        // Default to 30 days ago if not provided
+        const from = timestampFrom ?? Math.floor(Date.now() / 1000) - (30 * 24 * 60 * 60);
+        // Default to now if not provided
+        const to = timestampTo ?? Math.floor(Date.now() / 1000);
+        
+        try {
+            const response = await axios.get(`${Midas.BASE_URL}/${symbol}/price`, {
+                params: {
+                    timestampFrom: from,
+                    timestampTo: to,
+                    environment
+                }
+            });
+            
+            const priceData = response.data;
+            if (!Array.isArray(priceData) || priceData.length === 0) {
+                throw new Error(`No price data found for ${symbol}`);
+            }
+            
+            // Return the latest price (first item in the array)
+            return priceData[0].price;
+        } catch (error) {
+            logger.error(`Failed to fetch price for ${symbol}:`, error);
+            throw new Error(`Failed to fetch price for ${symbol}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+
+    /**
+     * Get TVL data for all tokens
+     * @param environment Environment (defaults to 'mainnet')
+     * @returns Object with TVL data including totalTvl and tokenTvl
+     * @throws Error if API request fails
+     */
+    static async getTVLData(environment: string = 'mainnet'): Promise<{
+        lastUpdatedAt: string;
+        totalTvl: number;
+        tokenTvl: Record<string, any>;
+    }> {
+        try {
+            const response = await axios.get(`${Midas.BASE_URL}/tvl`, {
+                params: { environment }
+            });
+            return response.data;
+        } catch (error) {
+            logger.error('Failed to fetch TVL data from Midas API:', error);
+            throw new Error(`Failed to fetch TVL data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+
+    /**
+     * Get TVL for a specific token by contract address
+     * @param contractAddr The contract address of the token
+     * @param environment Environment (defaults to 'mainnet')
+     * @returns The TVL data for the token (USD and native amounts)
+     * @throws Error if contract address not found or API request fails
+     */
+    static async getTVL(
+        contractAddr: ContractAddr,
+        environment: string = 'mainnet'
+    ): Promise<{ usd: number; native: number } | number> {
+        const symbol = Midas.getSymbolFromContract(contractAddr);
+        const tvlData = await Midas.getTVLData(environment);
+        
+        if (!(symbol in tvlData.tokenTvl)) {
+            throw new Error(`Symbol ${symbol} not found in TVL data`);
+        }
+        
+        return tvlData.tokenTvl[symbol];
+    }
+}

package/src/modules/pricer-from-api.ts

@@ -13,7 +13,7 @@ export class PricerFromApi extends PricerBase {
         try {
             return await this.getPriceFromMyAPI(tokenSymbol);
         } catch (e: any) {
-            logger.warn('getPriceFromMyAPI error', JSON.stringify(e.message || e));
+            logger.warn('getPriceFromMyAPI error', e);
         }
         logger.info('getPrice coinbase', tokenSymbol);
         let retry = 0;
@@ -41,7 +41,7 @@ export class PricerFromApi extends PricerBase {
     }
 
     async getPriceFromMyAPI(tokenSymbol: string) {
-        logger.verbose(`getPrice from redis: ${tokenSymbol}`);
+        logger.verbose(`getPrice from api: ${tokenSymbol}`);
         const endpoint = 'https://proxy.api.troves.fi'
         const url = `${endpoint}/api/price/${tokenSymbol}`;
         const priceInfoRes = await fetch(url);

package/src/modules/pricer-lst.ts

@@ -6,7 +6,7 @@ import axios from "axios";
 
 export class PricerLST extends Pricer {
   private tokenMaps: {lst: TokenInfo, underlying: TokenInfo}[];
-  protected EKUBO_API = 'https://prod-api-quoter.ekubo.org/23448594291968334/{{AMOUNT}}/{{TOKEN_ADDRESS}}/{{UNDERLYING_ADDRESS}}'; // e.g. xSTRK/STRK
+  protected EKUBO_API = 'https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/{{UNDERLYING_ADDRESS}}'; // e.g. xSTRK/STRK
 
   constructor(config: IConfig, tokenMaps: {lst: TokenInfo, underlying: TokenInfo}[]) {
     const refreshInterval = 5000;