@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

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

@@ -2,12 +2,6 @@ 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: {
@@ -34,12 +28,9 @@ 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'
-  tokenMarketData: TokenMarketData;
-
-  constructor(private readonly config: IConfig, pricer: PricerBase) {
-    this.tokenMarketData = new TokenMarketData(pricer, config);
-  }
+  ENDPOINT = 'https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}'; // e.g. ETH/USDC'
+  
+  constructor(private readonly config: IConfig) {}
 
   /**
    * 
@@ -49,17 +40,16 @@ 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 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;
+      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;
     } catch (error: any) {
-      logger.error(`${error.message} dassf ${error.data}`);
-      if (retry < 3) {
+      console.error(error.message, 'dassf', error.data);
+      if (retry < 10) {
         await new Promise((resolve) => setTimeout(resolve, (retry + 1) * 5000));
         return await this.getQuote(fromToken, toToken, amount, retry + 1);
       }
@@ -67,72 +57,6 @@ export class EkuboQuoter {
     }
   }
 
-  async getDexPrice(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number) {
-    const lstTokenInfo = baseToken;
-    const lstUnderlyingTokenInfo = quoteToken;
-    const quote = await this.getQuote(
-      lstTokenInfo.address.address,
-      lstUnderlyingTokenInfo.address.address,
-      amount
-    );
-    // in Underlying
-    const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
-    const price = outputAmount.toNumber() / amount.toNumber();
-    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);
-    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, 
-    // 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
-      }
-      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 
@@ -141,8 +65,7 @@ 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;
       return {
         route: split.route.map(_route => ({

package/src/modules/erc20.ts

@@ -1,75 +1,29 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig } from "@/interfaces";
-import { Contract, uint256 } from "starknet";
-import ERC20Abi from "@/data/erc20.abi.json";
+import { Contract } 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("balance_of", [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('balanceOf', [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);
-  }
-
-  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;
-  }
-}
+    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);
+    }
+}

package/src/modules/harvests.ts

@@ -34,23 +34,30 @@ export class Harvests {
         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;
     }
 }
@@ -101,6 +108,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/index.ts

@@ -1,13 +1,11 @@
-export * from './token-market-data';
-export * from './pricer';
-export * from './pragma';
-export * from './zkLend';
-export * from './pricer-from-api';
-export * from './erc20';
-export * from './avnu';
-export * from './ekubo-quoter';
-export * from './pricer-lst';
-export * from './lst-apr';
-export * from './pricerBase';
-export * from './midas';
-export * from './ExtendedWrapperSDk';
+export * from "./pricerBase";
+export * from "./pricer";
+export * from "./pragma";
+export * from "./zkLend";
+export * from "./pricer-from-api";
+export * from "./erc20";
+export * from "./avnu";
+export * from "./ekubo-quoter";
+export * from "./ekubo-pricer";
+export * from "./pricer-lst";
+export * from "./lst-apr";

package/src/modules/lst-apr.ts

@@ -1,6 +1,4 @@
 import { ContractAddr } from "@/dataTypes";
-import { Global } from "@/global";
-import { TokenInfo } from "@/interfaces";
 import { logger } from "@/utils";
 
 export interface LSTStats {
@@ -21,19 +19,6 @@ 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
@@ -153,24 +138,3 @@ 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/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()
+        };
     }
 }