@strkfarm/sdk 2.0.0-dev.27 → 2.0.0-dev.28

package/src/modules/apollo-client-config.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, InMemoryCache } from '@apollo/client';
+import { IConfig } from '@/interfaces';
+
+/**
+ * Creates an Apollo Client instance configured for the appropriate environment
+ * @param config - The application config containing network and stage information
+ * @returns Configured Apollo Client instance
+ */
+export function createApolloClient(config: IConfig) {
+  // Determine the URI based on the environment
+  const uri = config.stage === 'production' 
+    ? 'https://api.troves.fi/' 
+    : 'http://localhost:4000';
+
+  return new ApolloClient({
+    uri,
+    cache: new InMemoryCache(),
+  });
+}
+
+// Default client for backward compatibility
+const apolloClient = new ApolloClient({
+  uri: 'https://api.troves.fi/',
+  cache: new InMemoryCache(),
+});
+
+export default apolloClient;
+

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),

package/src/modules/ekubo-pricer.ts

@@ -0,0 +1,79 @@
+import { Contract, RpcProvider, BlockIdentifier } from "starknet";
+import EkuboPricerAbi from '@/data/ekubo-price-fethcer.abi.json';
+import { PricerBase } from "./pricerBase";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PriceInfo } from "./pricer";
+
+export class EkuboPricer extends PricerBase {
+    EKUBO_PRICE_FETCHER_ADDRESS = '0x04946fb4ad5237d97bbb1256eba2080c4fe1de156da6a7f83e3b4823bb6d7da1';
+    readonly contract: Contract;
+    private readonly USDC_ADDRESS = '0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8';
+    private readonly USDC_DECIMALS = 6;
+
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+        this.contract = new Contract({
+            abi: EkuboPricerAbi, 
+            address: this.EKUBO_PRICE_FETCHER_ADDRESS, 
+            providerOrAccount: config.provider as RpcProvider
+        });
+    }
+
+    private div2Power128(num: bigint): number {
+        return Number((num * BigInt(1e18)) / BigInt(2 ** 128)) / 1e18;
+    }
+
+    async getPrice(tokenAddr: string, blockIdentifier: BlockIdentifier = 'latest'): Promise<PriceInfo> {
+        if (!tokenAddr) {
+            throw new Error(`EkuboPricer:getPrice - no token`);
+        }
+
+        // get_prices arguments in order:
+        // - quote_token: USDC address (quote token for price calculation)
+        // - base_tokens: array containing the base token address/addresses
+        // - period: time period in seconds for TWAP (3600 = 1 hour)
+        // - min_token: minimum token amount threshold (min liquidity) in 6 Decimals = 1000000)
+        const result: any = await this.contract.call(
+            'get_prices',
+            [this.USDC_ADDRESS, [tokenAddr], 3600, 1000000],
+            { blockIdentifier }
+        );
+
+        if (!result || result.length === 0) {
+            throw new Error(`EkuboPricer: No price result returned for ${tokenAddr}`);
+        }
+
+        const priceResult = result[0];
+        
+        if (!priceResult?.variant?.Price) {
+            const variant = priceResult?.variant ? Object.keys(priceResult.variant)[0] : 'Unknown';
+            throw new Error(`EkuboPricer: Price fetch failed with variant: ${variant}`);
+        }
+
+        const rawPrice = typeof priceResult.variant.Price === 'string' 
+            ? BigInt(priceResult.variant.Price) 
+            : priceResult.variant.Price;
+
+        // Get token info to determine decimals from configured tokens
+        const tokenInfo = this.tokens.find(t => 
+            t.address.address.toLowerCase() === tokenAddr.toLowerCase()
+        );
+        
+        if (!tokenInfo) {
+            throw new Error(`Token ${tokenAddr} not found in global tokens`);
+        }
+
+        // Convert from x128 format
+        const priceAfterX128 = this.div2Power128(rawPrice);
+        
+        // Adjust for token decimals
+        const decimalAdjustment = 10 ** (tokenInfo.decimals - this.USDC_DECIMALS);
+        const price = priceAfterX128 * decimalAdjustment;
+
+        return {
+            price,
+            timestamp: new Date()
+        };
+    }
+}
+

package/src/modules/ekubo-quoter.ts

@@ -41,36 +41,55 @@ export class EkuboQuoter {
     this.tokenMarketData = new TokenMarketData(pricer, config);
   }
 
-  /**
-   * 
-   * @param fromToken 
-   * @param toToken 
-   * @param amount Can be negative too, which would mean to get exact amount out
-   * @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;
-
+  private async _callQuoterApi(fromToken: string, toToken: string, amount: Web3Number, retry = 0): Promise<EkuboQuote> {
     try {
-      const url = this.ENDPOINT.replace("{{AMOUNT}}", amount.toFixed(0)).replace("{{TOKEN_FROM_ADDRESS}}", fromToken).replace("{{TOKEN_TO_ADDRESS}}", toToken);
-      console.log("url", url);
+      const url = this.ENDPOINT.replace("{{AMOUNT}}", amount.toWei()).replace("{{TOKEN_FROM_ADDRESS}}", fromToken).replace("{{TOKEN_TO_ADDRESS}}", toToken);
+      logger.verbose(`EkuboQuoter::_callQuoterApi url: ${url}`);
       const quote = await axios.get(url);
-     return quote.data as EkuboQuote;
+      return quote.data as EkuboQuote;
     } catch (error: any) {
-      logger.error(`${error.message} dassf ${error.data}`);
+      logger.error(`EkuboQuoter::_callQuoterApi error: ${error.message}`);
       if (retry < 3) {
         await new Promise((resolve) => setTimeout(resolve, (retry + 1) * 5000));
-        return await this.getQuote(fromToken, toToken, amount, retry + 1);
+        return await this._callQuoterApi(fromToken, toToken, amount, retry + 1);
       }
       throw error;
     }
   }
 
+  /**
+   * Given exactly `inputAmount` of `fromToken`, how much `toToken` do I receive?
+   * @param fromToken - address of the token being sold
+   * @param toToken - address of the token being bought
+   * @param inputAmount - must be positive (the amount of fromToken to sell)
+   * @returns EkuboQuote where `total_calculated` is the output amount (positive)
+   */
+  async getQuoteExactInput(fromToken: string, toToken: string, inputAmount: Web3Number): Promise<EkuboQuote> {
+    if (inputAmount.isNegative() || inputAmount.isZero()) {
+      throw new Error(`EkuboQuoter::getQuoteExactInput inputAmount must be positive, got ${inputAmount.toFixed()}`);
+    }
+    return this._callQuoterApi(fromToken, toToken, inputAmount);
+  }
+
+  /**
+   * To receive exactly `outputAmount` of `toToken`, how much `fromToken` must I provide?
+   * @param fromToken - address of the token being sold
+   * @param toToken - address of the token being bought
+   * @param outputAmount - must be positive (the desired amount of toToken to receive)
+   * @returns EkuboQuote where `total_calculated` is the required input amount (negative per Ekubo convention)
+   */
+  async getQuoteExactOutput(fromToken: string, toToken: string, outputAmount: Web3Number): Promise<EkuboQuote> {
+    if (outputAmount.isNegative() || outputAmount.isZero()) {
+      throw new Error(`EkuboQuoter::getQuoteExactOutput outputAmount must be positive, got ${outputAmount.toFixed()}`);
+    }
+    const negatedAmount = new Web3Number(outputAmount.multipliedBy(-1).toFixed(Math.min(outputAmount.decimals, 15)), outputAmount.decimals);
+    return this._callQuoterApi(toToken, fromToken, negatedAmount);
+  }
+
   async getDexPrice(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number) {
     const lstTokenInfo = baseToken;
     const lstUnderlyingTokenInfo = quoteToken;
-    const quote = await this.getQuote(
+    const quote = await this.getQuoteExactInput(
       lstTokenInfo.address.address,
       lstUnderlyingTokenInfo.address.address,
       amount
@@ -95,26 +114,23 @@ export class EkuboQuoter {
     logger.verbose(`${EkuboQuoter.name}:: LST true Exchange Rate: ${exchangeRate}`);
     return exchangeRate;
   }
-  // debt collateral 
+  // debt collateral
   async getSwapLimitAmount(fromToken: TokenInfo, toToken: TokenInfo, amount: Web3Number, max_slippage: number = 0.002): Promise<Web3Number> {
     const isExactAmountIn = amount.greaterThanOrEqualTo(0);
     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, 
+    const baseToken = isExactAmountIn ? toToken : fromToken; // fromToken -> wbtc,
+    const quoteToken = isExactAmountIn ? fromToken : toToken; // toToken -> usdc,
     // 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);
     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
@@ -122,26 +138,26 @@ export class EkuboQuoter {
       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 
-   * @param fromTokenInfo 
-   * @returns 
+   * @param quote
+   * @param fromTokenInfo
+   * @returns
    */
   getVesuMultiplyQuote(quote: EkuboQuote, fromTokenInfo: TokenInfo, toTokenInfo: TokenInfo): Swap[] {
     return quote.splits.map(split => {
-      
+
       const isNegativeAmount = BigInt(split.amount_specified) <= 0n;
       const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
       return {

package/src/modules/erc20.ts

@@ -58,6 +58,23 @@ export class ERC20 {
     return transferCall;
   }
 
+  transferFrom(
+    token: string | ContractAddr,
+    from: string | ContractAddr,
+    to: string | ContractAddr,
+    amount: Web3Number
+  ) {
+    const contract = this.contract(token);
+    const amountUint256 = uint256.bnToUint256(amount.toWei());
+    const transferFromCall = contract.populate("transferFrom", [
+      from.toString(),
+      to.toString(),
+      amountUint256.low.toString(),
+      amountUint256.high.toString(),
+    ]);
+    return transferFromCall;
+  }
+
    approve(
     token: string | ContractAddr,
     spender: string | ContractAddr,

package/src/modules/harvests.ts

@@ -29,28 +29,36 @@ 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 reward = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime())[0];
-
-        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;
+        const sortedRewards = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
+        if (sortedRewards.length == 0) {
+            logger.verbose(`${Harvests.name}: no rewards found`);
+            return [];
         }
 
-        unClaimed.unshift(reward); // to ensure older harvest is first
+        const cls = await this.config.provider.getClassAt(sortedRewards[0].rewardsContract.address);
+
+        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
+        }
         return unClaimed;
     }
 }
@@ -59,26 +67,28 @@ const STRK = '0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d'
 
 export class EkuboHarvests extends Harvests {
     async getHarvests(addr: ContractAddr) {
-        const EKUBO_API = `https://starknet-mainnet-api.ekubo.org/airdrops/${addr.address}?token=${STRK}`
+        logger.verbose(`${EkuboHarvests.name}: getHarvests => addr: ${addr.address}`);
+        const EKUBO_API = `https://prod-api.ekubo.org/claims/${addr.address}`
         const resultEkubo = await fetch(EKUBO_API);
-        const items = (await resultEkubo.json());
-
+        const data = (await resultEkubo.json());
+        const claims = data.claims || [];
+        logger.verbose(`${EkuboHarvests.name}: getHarvests => claims length: ${claims.length}`);
         const rewards: HarvestInfo[] = [];
-        for (let i=0; i<items.length; ++i) {
-            const info = items[i];
-            assert(info.token == STRK, 'expected strk token only')
+        for (let i=0; i<claims.length; ++i) {
+            const claimData = claims[i];
+            assert(claimData.key.token == STRK, 'expected strk token only')
             rewards.push({
-                rewardsContract: ContractAddr.from(info.contract_address),
+                rewardsContract: ContractAddr.from(claimData.dropAddress),
                 token: ContractAddr.from(STRK),
-                startDate: new Date(info.start_date),
-                endDate: new Date(info.end_date),
+                startDate: new Date(0),
+                endDate: new Date(0),
                 claim: {
-                    id: info.claim.id,
-                    amount: Web3Number.fromWei(info.claim.amount, 18),
-                    claimee: ContractAddr.from(info.claim.claimee)
+                    id: claimData.claim.index,
+                    amount: Web3Number.fromWei(claimData.claim.amount, 18),
+                    claimee: ContractAddr.from(claimData.claim.account)
                 },
-                actualReward: Web3Number.fromWei(info.claim.amount, 18),
-                proof: info.proof
+                actualReward: Web3Number.fromWei(claimData.claim.amount, 18),
+                proof: claimData.proof
             });
         }
         return rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
@@ -101,6 +111,10 @@ 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/pragma.ts

@@ -1,22 +1,37 @@
-import { Contract, RpcProvider } from "starknet";
+import { Contract, RpcProvider, BlockIdentifier } from "starknet";
 import PragmaAbi from '@/data/pragma.abi.json';
 import { logger } from "@/utils/logger";
+import { PricerBase } from "./pricerBase";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PriceInfo } from "./pricer";
 
-export class Pragma {
+export class Pragma extends PricerBase {
     contractAddr = '0x023fb3afbff2c0e3399f896dcf7400acf1a161941cfb386e34a123f228c62832';
     readonly contract: Contract;
 
-    constructor(provider: RpcProvider) {
-        this.contract = new Contract({abi: PragmaAbi, address: this.contractAddr, providerOrAccount: provider});
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+        this.contract = new Contract({
+            abi: PragmaAbi,
+            address: this.contractAddr,
+            providerOrAccount: config.provider as RpcProvider
+        });
     }
 
-    async getPrice(tokenAddr: string) {
+    async getPrice(tokenAddr: string, blockIdentifier: BlockIdentifier = 'latest'): Promise<PriceInfo> {
         if (!tokenAddr) {
             throw new Error(`Pragma:getPrice - no token`)
         }
-        const result: any = await this.contract.call('get_price', [tokenAddr]);
+        const result: any = await this.contract.call(
+            'get_price', 
+            [tokenAddr],
+            { blockIdentifier }
+        );
         const price = Number(result.price) / 10**8;
-        logger.verbose(`Pragma:${tokenAddr}: ${price}`);
-        return price;
+        logger.verbose(`Pragma:${tokenAddr}: ${price} at block ${blockIdentifier}`);
+        return {
+            price,
+            timestamp: new Date()
+        };
     }
 }

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

@@ -1,21 +1,64 @@
-    import { PriceInfo } from "./pricer";
+import { PriceInfo } from "./pricer";
 import axios from "axios";
 import { IConfig, TokenInfo } from "@/interfaces";
 import { PricerBase } from "./pricerBase";
 import { logger } from "@/utils/logger";
+import { createApolloClient } from "./apollo-client-config";
+import { gql } from "@apollo/client";
+import { ContractAddr } from "@/dataTypes";
+import { Pragma } from "./pragma";
+import { EkuboPricer } from "./ekubo-pricer";
+import { BlockIdentifier } from "starknet";
 
 export class PricerFromApi extends PricerBase {
+    private apolloClient: ReturnType<typeof createApolloClient>;
+    private pragma: Pragma;
+    private ekuboPricer: EkuboPricer;
+
+    // Tokens supported by Pragma and GraphQL for historical prices (standardized addresses)
+    // Note: xSTRK is not supported by Pragma RPC, so it will use Ekubo pricer instead
+    private readonly PRAGMA_SUPPORTED_TOKENS = [
+        ContractAddr.from('0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac').address, // WBTC
+        ContractAddr.from('0x53c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8').address, // USDC
+        ContractAddr.from('0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d').address, // STRK
+        // xSTRK removed - not supported by Pragma RPC, will use Ekubo pricer
+        // ContractAddr.from('0x28d709c875c0ceac3dce7065bec5328186dc89fe254527084d1689910954b0a').address, // xSTRK
+        ContractAddr.from('0x68f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8').address, // USDT
+        ContractAddr.from('0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7').address, // ETH
+    ];
+
     constructor(config: IConfig, tokens: TokenInfo[]) {
         super(config, tokens);
+        this.apolloClient = createApolloClient(config);
+        this.pragma = new Pragma(config, tokens);
+        this.ekuboPricer = new EkuboPricer(config, tokens);
     }
 
-    async getPrice(tokenSymbol: string): Promise<PriceInfo> {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo> {
+        const tokenInfo = this.tokens.find(t => t.symbol === tokenSymbol);
+        if (!tokenInfo) {
+            throw new Error(`Token ${tokenSymbol} not found in configured tokens`);
+        }
+        const symbol = tokenInfo.priceProxySymbol || tokenInfo.symbol;
+        // If blockNumber is provided, fetch historical price from GraphQL
+        if (blockNumber !== undefined) {
+            try {
+                return await this.getHistoricalPrice(symbol, blockNumber);
+            } catch (e: any) {
+                logger.error(`Historical price fetch failed for ${tokenSymbol}: ${e.message}`);
+                throw new Error('Server Error in fetching historical price')
+                // Fall back to current price if historical price is not available
+            }
+        }
+
+        // Otherwise, fetch current price
         try {
-            return await this.getPriceFromMyAPI(tokenSymbol);
+            return await this.getPriceFromMyAPI(symbol);
         } catch (e: any) {
-            logger.warn('getPriceFromMyAPI error', e);
+            logger.warn(`API price fetch failed for ${tokenSymbol}: ${e.message}, trying coinbase`);
         }
-        logger.info('getPrice coinbase', tokenSymbol);
+
+        logger.info(`Using Coinbase price for ${tokenSymbol}`);
         let retry = 0;
         const MAX_RETRIES = 5;
         for (retry = 1; retry < MAX_RETRIES + 1; retry++) {
@@ -41,22 +84,120 @@ export class PricerFromApi extends PricerBase {
     }
 
     async getPriceFromMyAPI(tokenSymbol: string) {
-        logger.verbose(`getPrice from api: ${tokenSymbol}`);
         const endpoint = 'https://proxy.api.troves.fi'
         const url = `${endpoint}/api/price/${tokenSymbol}`;
         const priceInfoRes = await fetch(url);
         const priceInfo = await priceInfoRes.json();
-        const now = new Date();
-        const priceTime = new Date(priceInfo.timestamp);
-        // if (now.getTime() - priceTime.getTime() > 900000) {
-        //   // 15 mins
-        //   logger.verbose(`Price is stale: ${tokenSymbol}, timestamp: ${priceInfo.timestamp}, price: ${priceInfo.price}`);
-        //   throw new Error('Price is stale');
-        // }
         const price = Number(priceInfo.price);
         return {
             price,
             timestamp: new Date(priceInfo.timestamp)
         }
-      }
-}
+    }
+
+    /**
+     * Fetches historical price for a token at a specific block number
+     * @param tokenSymbol - The token symbol to get price for
+     * @param blockNumber - The block number to query
+     * @returns PriceInfo with price at the closest block <= blockNumber
+     */
+    async getHistoricalPrice(tokenSymbol: string, blockNumber: BlockIdentifier): Promise<PriceInfo> {
+        const tokenInfo = this.tokens.find(t => t.symbol === tokenSymbol);
+        if (!tokenInfo) {
+            throw new Error(`Token ${tokenSymbol} not found in configured tokens`);
+        }
+
+        // If blockNumber is not a number, fall back to current price
+        if (typeof blockNumber !== 'number') {
+            logger.info(`Non-numeric blockIdentifier '${blockNumber}' provided, fetching current price for ${tokenSymbol}`);
+            return await this.getPriceFromMyAPI(tokenSymbol);
+        }
+
+        const standardizedAddress = ContractAddr.from(tokenInfo.address.address).address;
+        const isPragmaSupported = this.PRAGMA_SUPPORTED_TOKENS.includes(standardizedAddress);
+
+        // Step 1: Try GraphQL first for ALL tokens
+        let data;
+        try {
+            const result = await this.apolloClient.query({
+                query: gql`
+                    query GetHistoricalPrice($asset: String!, $blockNumber: Int!) {
+                        findFirstPrices(
+                            where: {
+                                asset: { equals: $asset },
+                                block_number: { lte: $blockNumber }
+                            }
+                            orderBy: { block_number: desc }
+                        ) {
+                            price
+                            timestamp
+                            block_number
+                        }
+                    }
+                `,
+                variables: {
+                    asset: standardizedAddress,
+                    blockNumber: blockNumber,
+                },
+            });
+            data = result.data;
+        } catch (graphqlError: any) {
+            logger.error(`GraphQL query failed for ${tokenSymbol}: ${graphqlError.message}`);
+        }
+
+        // Step 2: If GraphQL has data, check block difference and use it if acceptable
+        if (data?.findFirstPrices) {
+            const priceData = data.findFirstPrices;
+            const blockDifference = blockNumber - priceData.block_number;
+            const MAX_BLOCK_DIFFERENCE = 6800; // ~6 hours worth of blocks
+
+            if (blockDifference <= MAX_BLOCK_DIFFERENCE) {
+                logger.info(`Using GraphQL price for ${tokenSymbol} at block ${priceData.block_number}`);
+                return {
+                    price: Number(priceData.price),
+                    timestamp: new Date(priceData.timestamp * 1000),
+                };
+            }
+
+            logger.info(
+                `Block difference ${blockDifference} exceeds limit for ${tokenSymbol}. ` +
+                `Will try fallback sources at block ${blockNumber}`
+            );
+        } else {
+            logger.info(`No GraphQL data for ${tokenSymbol} at block ${blockNumber}, trying fallback sources`);
+        }
+
+        // Step 3: Fallback to Pragma (for supported tokens) or Ekubo (for non-supported tokens)
+        if (isPragmaSupported) {
+            logger.info(`Attempting Pragma RPC fetch for ${tokenSymbol} at block ${blockNumber}`);
+            try {
+                const priceInfo = await this.pragma.getPrice(tokenInfo.address.address, blockNumber);
+                logger.info(`Using Pragma price for ${tokenSymbol}: ${priceInfo.price}`);
+                return {
+                    price: priceInfo.price,
+                    timestamp: priceInfo.timestamp,
+                };
+            } catch (error: any) {
+                logger.error(`Pragma RPC failed for ${tokenSymbol} at block ${blockNumber}: ${error.message}`);
+                throw new Error(`Server Error at Pragma token ${tokenSymbol} at block ${blockNumber}`);
+            }
+        } else {
+            // For non-Pragma tokens, use Ekubo pricer
+            logger.info(`Attempting Ekubo price fetch for ${tokenSymbol} at block ${blockNumber}`);
+            try {
+                const priceInfo = await this.ekuboPricer.getPrice(
+                    tokenInfo.address.address,
+                    blockNumber
+                );
+                logger.info(`Using Ekubo price for ${tokenSymbol}: ${priceInfo.price}`);
+                return {
+                    price: priceInfo.price,
+                    timestamp: priceInfo.timestamp,
+                };
+            } catch (error: any) {
+                logger.error(`Ekubo RPC failed for ${tokenSymbol} at block ${blockNumber}: ${error.message}`);
+                throw new Error(`Server Error at Ekubo token ${tokenSymbol} at block ${blockNumber}`);
+            }
+        }
+    }
+}

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://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/{{UNDERLYING_ADDRESS}}'; // e.g. xSTRK/STRK
+  protected EKUBO_API = 'https://prod-api-quoter.ekubo.org/23448594291968334/{{AMOUNT}}/{{TOKEN_ADDRESS}}/{{UNDERLYING_ADDRESS}}'; // e.g. xSTRK/STRK
 
   constructor(config: IConfig, tokenMaps: {lst: TokenInfo, underlying: TokenInfo}[]) {
     const refreshInterval = 5000;