@strkfarm/sdk 2.0.0-dev.3 → 2.0.0-dev.31

package/src/modules/ekubo-quoter.ts

@@ -41,36 +41,57 @@ 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;
+      // console.log('quote', quote.data);
+      // console.log('')
+      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 +116,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 +140,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;

package/src/modules/pricer.ts

@@ -5,6 +5,8 @@ import { IConfig } from "@/interfaces/common";
 import { Web3Number } from "@/dataTypes";
 import { PricerBase } from "./pricerBase";
 import { logger } from "@/utils/logger";
+import { AvnuWrapper } from "./avnu";
+import { BlockIdentifier } from "starknet";
 
 export interface PriceInfo {
     price: number,
@@ -21,13 +23,14 @@ export class Pricer extends PricerBase {
 
     // code populates this map during runtime to determine which method to use for a given token
     // The method set will be the first one to try after first attempt
-    protected methodToUse: {[tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap'} = {};
+    protected methodToUse: {[tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap' | 'Avnu'} = {};
 
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
      */
+    // ! switch to USDC (new) later
     protected PRICE_API = `https://api.coinbase.com/v2/prices/{{PRICER_KEY}}/buy`;
-    protected EKUBO_API = 'https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8'; // e.g. ETH/USDC
+    protected EKUBO_API = 'https://prod-api-quoter.ekubo.org/23448594291968334/{{AMOUNT}}/{{TOKEN_ADDRESS}}/0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb'; // e.g. ETH/USDC
 
     constructor(config: IConfig, tokens: TokenInfo[], refreshInterval = 30000, staleTime = 60000) {
         super(config, tokens);
@@ -81,7 +84,7 @@ export class Pricer extends PricerBase {
         Global.assert(!this.isStale(timestamp, tokenName), `Price of ${tokenName} is stale`);
 
     }
-    async getPrice(tokenSymbol: string) {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier) {
         Global.assert(this.prices[tokenSymbol], `Price of ${tokenSymbol} not found`);
        this.assertNotStale(this.prices[tokenSymbol].timestamp, tokenSymbol);
         return this.prices[tokenSymbol];
@@ -93,7 +96,7 @@ export class Pricer extends PricerBase {
             let retry = 0;
             while (retry < MAX_RETRIES) {
                 try {
-                    if (token.symbol === 'USDT') {
+                    if (token.symbol === 'USDT' || token.symbol === 'USDC') {
                         this.prices[token.symbol] = {
                             price: 1,
                             timestamp: new Date()
@@ -174,6 +177,15 @@ export class Pricer extends PricerBase {
                     console.warn(`Ekubo: price err [${token.symbol}]: `, Object.keys(error));
                     // do nothing, try next
                 }
+            case 'Avnu':
+                try {
+                    const result = await this._getAvnuPrice(token, new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals));
+                    this.methodToUse[token.symbol] = 'Avnu';
+                    return result;
+                } catch (error: any) {
+                    console.warn(`Avnu: price err [${token.symbol}]: `, error.message);
+                    console.warn(`Avnu: price err [${token.symbol}]: `, Object.keys(error));
+                }
         }
 
         // if methodToUse is the default one, pass Coinbase to try all from start
@@ -200,7 +212,31 @@ export class Pricer extends PricerBase {
         throw new Error("Not implemented");
     }
 
+    async _getAvnuPrice(token: TokenInfo, amountIn = new Web3Number(1, token.decimals), retry = 0): Promise<number> {
+        logger.verbose(`Getting price of ${token.symbol} using Ekubo, amountIn: ${amountIn.toWei()}`);
+      
+        const avnuWrapper = new AvnuWrapper();
+        const usdcAddress = '0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb';
+        const quote = await avnuWrapper.getQuotes(token.address.toString(), usdcAddress, amountIn.toWei(), '0x1');
+        const multiplier = 1 / amountIn.toNumber();
+        const outputUSDC = Number(Web3Number.fromWei(quote.buyAmount.toString(), 6).toFixed(6)) * multiplier;
+        logger.verbose(`Avnu: ${token.symbol} -> USDC: ${outputUSDC}, retry: ${retry}`);
+        if (outputUSDC === 0 && retry < 3) {
+            // try again with a higher amount
+            const amountIn = new Web3Number(100, token.decimals); // 100 unit of token
+            return await this._getAvnuPrice(token, amountIn, retry + 1);
+        }
+
+        // if usdc depegs, it will not longer be 1 USD
+        // so we need to get the price of USDC in USD
+        // and then convert the outputUSDC to USD
+        const usdcPrice = 1; // (await this.getPrice('USDC')).price;
+        logger.verbose(`USDC Price: ${usdcPrice}`);
+        return outputUSDC * usdcPrice;
+    }
+
     async _getPriceEkubo(token: TokenInfo, amountIn = new Web3Number(1, token.decimals), retry = 0): Promise<number> {
+        logger.verbose(`Getting price of ${token.symbol} using Ekubo, amountIn: ${amountIn.toWei()}`);
         const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address.toString()).replace("{{AMOUNT}}", amountIn.toWei());
         const result = await axios.get(url);
         const data: any = result.data;

package/src/modules/pricerBase.ts

@@ -1,5 +1,6 @@
 import { IConfig, TokenInfo } from "@/interfaces";
 import { PriceInfo } from "./pricer";
+import { BlockIdentifier } from "starknet";
 
 export abstract class PricerBase {
     readonly config: IConfig;
@@ -9,7 +10,7 @@ export abstract class PricerBase {
         this.tokens = tokens;
     }
 
-    async getPrice(tokenSymbol: string): Promise<PriceInfo> {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo> {
         throw new Error('Method not implemented');
     }
 }