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

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');
     }
 }

package/src/node/deployer.ts

@@ -4,6 +4,7 @@ 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'
@@ -207,13 +208,47 @@ 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
+    executeTransactions,
+    myWaitForTransaction
 }
 
 export default Deployer;

package/src/node/pricer-redis.ts

@@ -4,6 +4,7 @@ import { PriceInfo, Pricer } from '@/modules/pricer';
 import { createClient } from 'redis';
 import type { RedisClientType } from 'redis'
 import { logger } from "@/utils/logger";
+import { BlockIdentifier } from "starknet";
 
 export class PricerRedis extends Pricer {
     private redisClient: RedisClientType | null = null;
@@ -51,7 +52,7 @@ export class PricerRedis extends Pricer {
     }
 
     /** Returns price from redis */
-    async getPrice(tokenSymbol: string) {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier) {
         const STALE_TIME = 60000;
         if (!this.redisClient) {
             throw new FatalError(`Redis client not initialised`);

package/src/strategies/base-strategy.ts

@@ -1,8 +1,9 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo, VaultPosition } from "@/interfaces";
 import { CacheClass } from "@/utils/cacheClass";
-import { Call } from "starknet";
 import { PositionInfo } from "./universal-adapters";
+import { Call, BlockIdentifier } from "starknet";
+import { HarvestInfo } from "@/modules/harvests";
 
 export interface SingleActionAmount {
     tokenInfo: TokenInfo,
@@ -28,6 +29,16 @@ export interface DualTokenInfo {
     token1: SingleTokenInfo
 }
 
+export interface NetAPYSplit {
+  apy: number;
+  id: string;
+}
+
+export interface NetAPYDetails {
+  net: number;
+  splits: NetAPYSplit[];
+}
+
 interface CacheData {
   timestamp: number;
   ttl: number;
@@ -42,13 +53,13 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
         this.config = config;
     }
 
-    async getUserTVL(user: ContractAddr): Promise<TVLInfo> {
+    async getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<TVLInfo> {
         throw new Error("Not implemented");
     }
 
     async getTVL(): Promise<TVLInfo> {
         throw new Error("Not implemented");
-    }   
+    }
 
     async depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
@@ -62,19 +73,76 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
         throw new Error("Not implemented");
     }
 
-    async getUnusedBalance(): Promise<SingleTokenInfo> {
+    async netAPY(
+        blockIdentifier?: BlockIdentifier,
+        sinceBlocks?: number,
+        timeperiod?: "24h" | "7d" | "30d" | "3m"
+    ): Promise<number | NetAPYDetails> {
         throw new Error("Not implemented");
     }
 
-    async netAPY(): Promise<APYInfo> {
-        throw new Error("Not implemented");
+    async getPendingRewards(): Promise<HarvestInfo[]> {
+        return [];
     }
 
-    async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[]}> {
+    async getUserRealizedAPY(
+        blockIdentifier?: BlockIdentifier,
+        sinceBlocks?: number
+    ): Promise<number> {
         throw new Error("Not implemented");
     }
 
-    async getHealthFactors(): Promise<number[]> {
-        throw new Error("Not implemented");
+    /**
+     * Calculate lifetime earnings for a user based on provided data from client
+     * Formula: lifetimeEarnings = currentValue + totalWithdrawals - totalDeposits
+     *
+     * @param userTVL - The user's current TVL (SingleTokenInfo with amount, usdValue, tokenInfo)
+     * @param investmentFlows - Array of investment flow transactions from client
+     * @returns Object containing lifetime earnings, current value, and total deposits/withdrawals
+     */
+    getLifetimeEarnings(
+        userTVL: SingleTokenInfo,
+        investmentFlows: Array<{ amount: string; type: string; timestamp: number; tx_hash: string }>
+    ): {
+        tokenInfo: SingleTokenInfo;
+        lifetimeEarnings: Web3Number;
+        currentValue: Web3Number;
+        totalDeposits: Web3Number;
+        totalWithdrawals: Web3Number;
+    } {
+        // Get token decimals from userTVL
+        const tokenDecimals = userTVL.tokenInfo.decimals;
+
+        // Initialize totals
+        let totalDeposits = Web3Number.fromWei("0", tokenDecimals);
+        let totalWithdrawals = Web3Number.fromWei("0", tokenDecimals);
+
+        // Process investment flows
+        for (const flow of investmentFlows) {
+            const amount = Web3Number.fromWei(flow.amount, tokenDecimals);
+
+            if (flow.type === 'deposit') {
+                totalDeposits = totalDeposits.plus(amount);
+            } else if (flow.type === 'withdraw' || flow.type === 'redeem') {
+                totalWithdrawals = totalWithdrawals.plus(amount);
+            }
+        }
+
+        // Calculate lifetime earnings: current value + withdrawals - deposits
+        const lifetimeEarnings = userTVL.amount
+            .plus(totalWithdrawals)
+            .minus(totalDeposits);
+
+        return {
+            tokenInfo: {
+                tokenInfo: userTVL.tokenInfo,
+                amount: lifetimeEarnings,
+                usdValue: 0, // Lifetime earnings are not converted to USD
+            },
+            lifetimeEarnings,
+            currentValue: userTVL.amount,
+            totalDeposits,
+            totalWithdrawals,
+        };
     }
-}
+}