@strkfarm/sdk 1.1.70 → 2.0.0-dev.2

package/src/modules/pricer.ts

@@ -5,7 +5,6 @@ import { IConfig } from "@/interfaces/common";
 import { Web3Number } from "@/dataTypes";
 import { PricerBase } from "./pricerBase";
 import { logger } from "@/utils/logger";
-import { AvnuWrapper } from "./avnu";
 
 export interface PriceInfo {
     price: number,
@@ -22,14 +21,13 @@ 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' | 'Avnu'} = {};
+    protected methodToUse: {[tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap'} = {};
 
     /**
      * 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://prod-api-quoter.ekubo.org/23448594291968334/{{AMOUNT}}/{{TOKEN_ADDRESS}}/0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb'; // e.g. ETH/USDC
+    protected EKUBO_API = 'https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8'; // e.g. ETH/USDC
 
     constructor(config: IConfig, tokens: TokenInfo[], refreshInterval = 30000, staleTime = 60000) {
         super(config, tokens);
@@ -95,7 +93,7 @@ export class Pricer extends PricerBase {
             let retry = 0;
             while (retry < MAX_RETRIES) {
                 try {
-                    if (token.symbol === 'USDT' || token.symbol === 'USDC') {
+                    if (token.symbol === 'USDT') {
                         this.prices[token.symbol] = {
                             price: 1,
                             timestamp: new Date()
@@ -176,15 +174,6 @@ 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
@@ -211,31 +200,7 @@ 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/token-market-data.ts

@@ -0,0 +1,202 @@
+import { ContractAddr, Web3Number } from '../dataTypes';
+import { TokenInfo, IConfig } from '../interfaces';
+import { PricerBase } from './pricerBase';
+import { LSTAPRService } from './lst-apr';
+import { Midas } from './midas';
+import { SingleTokenInfo } from '../strategies/base-strategy';
+import { logger } from '../utils/logger';
+import { Contract } from 'starknet';
+import { uint256 } from 'starknet';
+import ERC4626Abi from '../data/erc4626.abi.json';
+
+/**
+ * TokenMarketData class that combines LST APR and Midas modules
+ * to provide unified APY, price, and TVL functions for tokens
+ */
+export class TokenMarketData {
+    private pricer: PricerBase;
+    private config: IConfig;
+
+    constructor(pricer: PricerBase, config: IConfig) {
+        this.pricer = pricer;
+        this.config = config;
+    }
+
+    /**
+     * Get APY for a token
+     * - If it's an LST token, returns LST APY
+     * - If it's a Midas token, returns Midas APY
+     * - Otherwise returns 0
+     * @param tokenInfo The token to get APY for
+     * @returns APY in absolute terms (not percentage)
+     */
+    async getAPY(tokenInfo: TokenInfo): Promise<number> {
+        try {
+            // Check if it's an LST token
+            if (LSTAPRService.isLST(tokenInfo.address)) {
+                const underlying = LSTAPRService.getUnderlyingFromLST(tokenInfo.address);
+                const lstApr = await LSTAPRService.getLSTAPR(underlying.address);
+                logger.verbose(`TokenMarketData: LST APY for ${tokenInfo.symbol}: ${lstApr}`);
+                return lstApr;
+            }
+
+            // Check if it's a Midas token by trying to get symbol
+            if (Midas.isSupported(tokenInfo.address)) {
+                const midasApy = await Midas.getAPY(tokenInfo.address);
+                logger.verbose(`TokenMarketData: Midas APY for ${tokenInfo.symbol}: ${midasApy}`);
+                return midasApy;
+            }
+
+            // Default to 0 for unsupported tokens
+            logger.verbose(`TokenMarketData: No APY data available for ${tokenInfo.symbol}, returning 0`);
+            return 0;
+        } catch (error) {
+            logger.error(`TokenMarketData: Error getting APY for ${tokenInfo.symbol}:`, error);
+            return 0;
+        }
+    }
+
+    /**
+     * Get price for a token using the pricer module
+     * @param tokenInfo The token to get price for
+     * @returns Price as a number
+     * @throws Error if price is 0 or unavailable
+     */
+    async getPrice(tokenInfo: TokenInfo): Promise<number> {
+        try {
+            const priceInfo = await this.pricer.getPrice(tokenInfo.symbol);
+            
+            if (priceInfo.price === 0) {
+                throw new Error(`Price is 0 for token ${tokenInfo.symbol}`);
+            }
+
+            logger.verbose(`TokenMarketData: Price for ${tokenInfo.symbol}: ${priceInfo.price}`);
+            return priceInfo.price;
+        } catch (error) {
+            logger.error(`TokenMarketData: Error getting price for ${tokenInfo.symbol}:`, error);
+            throw new Error(`Failed to get price for ${tokenInfo.symbol}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+
+    /**
+     * Get true price for a token
+     * - For LST tokens: Uses convert_to_assets to get true exchange rate
+     * - For Midas tokens: Uses Midas price API
+     * - For other tokens: Falls back to regular pricer
+     * @param tokenInfo The token to get true price for
+     * @returns True price as a number
+     * @throws Error if price is 0 or unavailable
+     */
+    async getTruePrice(tokenInfo: TokenInfo): Promise<number> {
+        try {
+            // For LST tokens, use convert_to_assets
+            if (LSTAPRService.isLST(tokenInfo.address)) {
+                const lstABI = new Contract({
+                    abi: ERC4626Abi,
+                    address: tokenInfo.address.address,
+                    providerOrAccount: this.config.provider
+                });
+
+                const price: any = await lstABI.call('convert_to_assets', [
+                    uint256.bnToUint256((new Web3Number(1, tokenInfo.decimals)).toWei())
+                ]);
+                const exchangeRate = Number(uint256.uint256ToBN(price).toString()) / Math.pow(10, tokenInfo.decimals);
+                
+                if (exchangeRate === 0) {
+                    throw new Error(`True price is 0 for LST token ${tokenInfo.symbol}`);
+                }
+
+                logger.verbose(`TokenMarketData: LST true price for ${tokenInfo.symbol}: ${exchangeRate}`);
+                return exchangeRate;
+            }
+
+            // For Midas tokens, use Midas price API
+            if (Midas.isSupported(tokenInfo.address)) {
+                const midasPrice = await Midas.getPrice(tokenInfo.address);
+                
+                if (midasPrice === 0) {
+                    throw new Error(`True price is 0 for Midas token ${tokenInfo.symbol}`);
+                }
+
+                logger.verbose(`TokenMarketData: Midas true price for ${tokenInfo.symbol}: ${midasPrice}`);
+                return midasPrice;
+            }
+
+            // For other tokens, fall back to regular pricer
+            const price = await this.getPrice(tokenInfo);
+            
+            if (price === 0) {
+                throw new Error(`True price is 0 for token ${tokenInfo.symbol}`);
+            }
+
+            logger.verbose(`TokenMarketData: Regular price for ${tokenInfo.symbol}: ${price}`);
+            return price;
+        } catch (error) {
+            logger.error(`TokenMarketData: Error getting true price for ${tokenInfo.symbol}:`, error);
+            throw new Error(`Failed to get true price for ${tokenInfo.symbol}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+
+    /**
+     * Get TVL for a token
+     * - If it's a Midas token, returns Midas TVL data
+     * - Otherwise returns 0
+     * @param tokenInfo The token to get TVL for
+     * @returns TVL as SingleTokenInfo or 0
+     */
+    async getTVL(tokenInfo: TokenInfo): Promise<SingleTokenInfo> {
+      // Check if it's a Midas token by trying to get TVL
+      if (Midas.isSupported(tokenInfo.address)) {
+        const midasTvl = await Midas.getTVL(tokenInfo.address);
+        
+        // Handle different TVL response formats
+        let usdValue: number;
+        let nativeAmount: number;
+
+        if (typeof midasTvl === 'number') {
+            // Simple number format (e.g., mre7: 18193466)
+            usdValue = midasTvl;
+            nativeAmount = 0; // We don't have native amount in this format
+        } else if (typeof midasTvl === 'object' && 'usd' in midasTvl && 'native' in midasTvl) {
+            // Object format with usd and native (e.g., mre7btc: {usd: 998826, native: 9.3228})
+            usdValue = midasTvl.usd;
+            nativeAmount = midasTvl.native;
+        } else {
+            throw new Error(`Unexpected TVL format for ${tokenInfo.symbol}`);
+        }
+
+        const tvlInfo: SingleTokenInfo = {
+            tokenInfo,
+            amount: Web3Number.fromWei(nativeAmount, tokenInfo.decimals),
+            usdValue
+        };
+
+        logger.verbose(`TokenMarketData: Midas TVL for ${tokenInfo.symbol}: USD=${usdValue}, Native=${nativeAmount}`);
+        return tvlInfo;
+      }
+      
+      return {
+        tokenInfo,
+        amount: Web3Number.fromWei('0', tokenInfo.decimals),
+        usdValue: 0
+      }
+    }
+
+    /**
+     * Check if a token is supported for APY data
+     * @param tokenInfo The token to check
+     * @returns True if the token has APY data available
+     */
+    isAPYSupported(tokenInfo: TokenInfo): boolean {
+        return LSTAPRService.isLST(tokenInfo.address) || Midas.isSupported(tokenInfo.address);
+    }
+
+    /**
+     * Check if a token is supported for TVL data
+     * @param tokenInfo The token to check
+     * @returns True if the token has TVL data available
+     */
+    isTVLSupported(tokenInfo: TokenInfo): boolean {
+        return Midas.isSupported(tokenInfo.address);
+    }
+}

package/src/node/deployer.ts

@@ -4,7 +4,6 @@ import { readFileSync, existsSync, writeFileSync } from 'fs'
 import { IConfig } from '../interfaces';
 import { Store, getDefaultStoreConfig } from '../utils/store';
 import { add } from 'winston';
-import { logger } from '@/utils';
 
 function getContracts() {
     const PATH = './contracts.json'
@@ -208,47 +207,13 @@ async function executeTransactions(
     return tx;
 }
 
-async function myWaitForTransaction(
-    transaction_hash: string,
-    provider: RpcProvider,
-    retry = 0
-) {
-    const MAX_RETRIES = 60;
-    logger.verbose(`Waiting for transaction: ${transaction_hash}, retry: ${retry}`);
-    try {
-        const status = await provider.getTransactionStatus(transaction_hash);
-        logger.verbose(`Transaction status: ${JSON.stringify(status.execution_status)}`);
-        if (status.execution_status == TransactionExecutionStatus.SUCCEEDED) {
-            return true;
-        }
-        if (status.execution_status == TransactionExecutionStatus.REVERTED) {
-            throw new Error(`Transaction reverted: ${transaction_hash}`);
-        }
-        if (retry > MAX_RETRIES) {
-            throw new Error(`Transaction not found: ${transaction_hash}`);
-        }
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        return myWaitForTransaction(transaction_hash, provider, retry + 1);
-    } catch (error) {
-        if (error instanceof Error && error.message.includes('Transaction reverted')) {
-            throw new Error(`Transaction reverted: ${transaction_hash}`);
-        }
-        if (retry > MAX_RETRIES) {
-            throw error;
-        }
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        return myWaitForTransaction(transaction_hash, provider, retry + 1);
-    }
-}
-
 const Deployer = {
     getAccount,
     myDeclare,
     deployContract,
     prepareMultiDeployContracts,
     executeDeployCalls,
-    executeTransactions,
-    myWaitForTransaction
+    executeTransactions
 }
 
 export default Deployer;

package/src/strategies/autoCompounderStrk.ts

@@ -48,7 +48,7 @@ export class AutoCompounderSTRK {
 
     /** Returns shares of user */
     async balanceOf(user: ContractAddr) {
-        const result = await this.contract!.balanceOf(user.address);
+        const result = await this.contract!.balance_of(user.address);
         return Web3Number.fromWei(result.toString(), this.metadata.decimals);
     }
 

package/src/strategies/base-strategy.ts

@@ -1,8 +1,8 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo, VaultPosition } from "@/interfaces";
-import { HarvestInfo } from "@/modules/harvests";
 import { CacheClass } from "@/utils/cacheClass";
 import { Call } from "starknet";
+import { PositionInfo } from "./universal-adapters";
 
 export interface SingleActionAmount {
     tokenInfo: TokenInfo,
@@ -13,6 +13,11 @@ export interface SingleTokenInfo extends SingleActionAmount {
     usdValue: number
 };
 
+export interface APYInfo {
+    net: number;
+    splits: { apy: number; id: string; }[];
+};
+
 export interface DualActionAmount {
     token0: SingleActionAmount,
     token1: SingleActionAmount
@@ -57,7 +62,19 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
         throw new Error("Not implemented");
     }
 
-    async getPendingRewards(): Promise<HarvestInfo[]> {
-        return [];
+    async getUnusedBalance(): Promise<SingleTokenInfo> {
+        throw new Error("Not implemented");
+    }
+
+    async netAPY(): Promise<APYInfo> {
+        throw new Error("Not implemented");
+    }
+
+    async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[]}> {
+        throw new Error("Not implemented");
+    }
+
+    async getHealthFactors(): Promise<number[]> {
+        throw new Error("Not implemented");
     }
 }