@strkfarm/sdk 1.2.0 → 2.0.0-dev-strategy2.1

package/src/modules/erc20.ts

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

package/src/modules/harvests.ts

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

package/src/modules/index.ts

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

package/src/modules/lst-apr.ts

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

package/src/modules/midas.ts

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

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

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

package/src/modules/pricer-lst.ts

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

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;