@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.51

package/src/modules/pricer.ts

@@ -1,16 +1,32 @@
 import axios from "axios";
 import { FatalError, Global } from "@/global";
-import { TokenInfo } from "@/interfaces/common";
+import { PriceMethod, TokenInfo } from "@/interfaces/common";
 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";
+import { PricerAvnuApi } from "./pricer-avnu-api";
+import {
+    convertQuoteAmountToUsd,
+    PRICER_USDC_ADDRESS,
+    resolveQuoteTokenConfig,
+} from "./pricer-quote-utils";
 
 export interface PriceInfo {
     price: number,
     timestamp: Date
 }
 
+const PRICE_METHOD_PRIORITY: PriceMethod[] = [
+    'AvnuApi',
+    'Coinbase',
+    'Coinmarketcap',
+    'Ekubo',
+    'Avnu',
+];
+
 export class Pricer extends PricerBase {
     protected prices: {
         [key: string]: PriceInfo
@@ -19,20 +35,24 @@ export class Pricer extends PricerBase {
     refreshInterval = 30000;
     staleTime = 60000;
 
+    protected readonly avnuApiPricer: PricerAvnuApi;
+
     // 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]: PriceMethod} = {};
 
     /**
      * 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}}/${PRICER_USDC_ADDRESS}`; // e.g. ETH/USDC
 
     constructor(config: IConfig, tokens: TokenInfo[], refreshInterval = 30000, staleTime = 60000) {
         super(config, tokens);
         this.refreshInterval = refreshInterval;
         this.staleTime = staleTime;
+        this.avnuApiPricer = new PricerAvnuApi(config, tokens);
     }
 
     isReady() {
@@ -66,6 +86,7 @@ export class Pricer extends PricerBase {
     }
 
     start() {
+        this.avnuApiPricer.start();
         this._loadPrices();
         setInterval(() => {
             this._loadPrices();
@@ -81,7 +102,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 +114,10 @@ export class Pricer extends PricerBase {
             let retry = 0;
             while (retry < MAX_RETRIES) {
                 try {
-                    if (token.symbol === 'USDT') {
+                    if (token.dontPrice) {
+                        return;
+                    }
+                    if (token.symbol === 'USDT' || token.symbol === 'USDC') {
                         this.prices[token.symbol] = {
                             price: 1,
                             timestamp: new Date()
@@ -142,47 +166,70 @@ export class Pricer extends PricerBase {
         }
     }
 
-    async _getPrice(token: TokenInfo, defaultMethod = 'all'): Promise<number> {
-        const methodToUse: string = this.methodToUse[token.symbol] || defaultMethod; // default start with coinbase
-        logger.verbose(`Fetching price of ${token.symbol} using ${methodToUse}`);
-        switch (methodToUse) {
-            case 'Coinbase':
-                // try {
-                //     const result = await this._getPriceCoinbase(token);
-                //     this.methodToUse[token.symbol] = 'Coinbase';
-                //     return result;
-                // } catch (error: any) {
-                //     console.warn(`Coinbase: price err: message [${token.symbol}]: `, error.message);
-                //     // do nothing, try next
-                // }
-            case 'Coinmarketcap':
-                try {
-                    const result = await this._getPriceCoinMarketCap(token);
-                    this.methodToUse[token.symbol] = 'Coinmarketcap';
-                    return result;
-                } catch (error: any) {
-                    console.warn(`CoinMarketCap: price err [${token.symbol}]: `, Object.keys(error));
-                    console.warn(`CoinMarketCap: price err [${token.symbol}]: `, error.message);
-                }
-            case 'Ekubo':
-                try {
-                    const result = await this._getPriceEkubo(token, new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals));
-                    this.methodToUse[token.symbol] = 'Ekubo';
-                    return result;
-                } catch (error: any) {
-                    console.warn(`Ekubo: price err [${token.symbol}]: `, error.message);
-                    console.warn(`Ekubo: price err [${token.symbol}]: `, Object.keys(error));
-                    // do nothing, try next
+    async _getPrice(token: TokenInfo): Promise<number> {
+        const methodsToTry = this._getMethodsToTry(token);
+
+        for (const method of methodsToTry) {
+            logger.verbose(`Fetching price of ${token.symbol} using ${method}`);
+            try {
+                const result = await this._tryPriceMethod(token, method);
+                if (!token.priceMethod) {
+                    this.methodToUse[token.symbol] = method;
                 }
+                return result;
+            } catch (error: any) {
+                console.warn(`${method}: price err [${token.symbol}]: `, error.message);
+            }
         }
 
-        // if methodToUse is the default one, pass Coinbase to try all from start
-        if (defaultMethod == 'all') {
-            // try again with coinbase
-            return await this._getPrice(token, 'Coinbase');
+        throw new FatalError(`Price not found for ${token.symbol}`);
+    }
+
+    protected _getMethodsToTry(token: TokenInfo): PriceMethod[] {
+        const methods: PriceMethod[] = [];
+
+        if (token.priceMethod) {
+            methods.push(token.priceMethod);
         }
 
-        throw new FatalError(`Price not found for ${token.symbol}`);
+        const pinned = this.methodToUse[token.symbol];
+        if (pinned && pinned !== token.priceMethod) {
+            methods.push(pinned);
+        }
+
+        for (const method of PRICE_METHOD_PRIORITY) {
+            if (!methods.includes(method)) {
+                methods.push(method);
+            }
+        }
+
+        return methods;
+    }
+
+    protected async _tryPriceMethod(token: TokenInfo, method: PriceMethod): Promise<number> {
+        switch (method) {
+            case 'AvnuApi':
+                return await this._getPriceAvnuApi(token);
+            case 'Coinbase':
+                return await this._getPriceCoinbase(token);
+            case 'Coinmarketcap':
+                return await this._getPriceCoinMarketCap(token);
+            case 'Ekubo':
+                return await this._getPriceEkubo(
+                    token,
+                    new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals),
+                );
+            case 'Avnu':
+                return await this._getAvnuPrice(
+                    token,
+                    new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals),
+                );
+        }
+    }
+
+    async _getPriceAvnuApi(token: TokenInfo): Promise<number> {
+        const priceInfo = await this.avnuApiPricer.getPrice(token.symbol);
+        return priceInfo.price;
     }
 
     async _getPriceCoinbase(token: TokenInfo) {
@@ -200,24 +247,80 @@ export class Pricer extends PricerBase {
         throw new Error("Not implemented");
     }
 
+    protected async _resolveQuoteTokenUsdPrice(symbol: string): Promise<number> {
+        const cached = this.prices[symbol];
+        if (cached && !this.isStale(cached.timestamp, symbol)) {
+            return cached.price;
+        }
+
+        const quoteToken = this.tokens.find((t) => t.symbol === symbol);
+        if (!quoteToken) {
+            throw new FatalError(`Quote token ${symbol} not found in pricer tokens`);
+        }
+
+        return await this._getPrice(quoteToken);
+    }
+
+    protected async _convertDexQuoteToUsd(
+        token: TokenInfo,
+        quoteAmount: number,
+    ): Promise<number> {
+        const quoteConfig = resolveQuoteTokenConfig(token, this.tokens);
+        const usdPrice = await convertQuoteAmountToUsd(
+            token.symbol,
+            quoteAmount,
+            quoteConfig,
+            this._resolveQuoteTokenUsdPrice.bind(this),
+        );
+        logger.verbose(
+            `${token.symbol}: ${quoteAmount} ${quoteConfig.symbol} -> $${usdPrice}`,
+        );
+        return usdPrice;
+    }
+
+    async _getAvnuPrice(token: TokenInfo, amountIn = new Web3Number(1, token.decimals), retry = 0): Promise<number> {
+        const quoteConfig = resolveQuoteTokenConfig(token, this.tokens);
+        logger.verbose(`Getting price of ${token.symbol} using Avnu, amountIn: ${amountIn.toWei()}`);
+
+        const avnuWrapper = new AvnuWrapper();
+        const quote = await avnuWrapper.getQuotes(
+            token.address.toString(),
+            quoteConfig.address,
+            amountIn.toWei(),
+            "0x1",
+        );
+        const multiplier = 1 / amountIn.toNumber();
+        const outputQuote = Number(
+            Web3Number.fromWei(quote.buyAmount.toString(), quoteConfig.decimals).toFixed(6),
+        ) * multiplier;
+        logger.verbose(`Avnu: ${token.symbol} -> ${quoteConfig.symbol}: ${outputQuote}, retry: ${retry}`);
+        if (outputQuote === 0 && retry < 3) {
+            const retryAmountIn = new Web3Number(100, token.decimals);
+            return await this._getAvnuPrice(token, retryAmountIn, retry + 1);
+        }
+
+        return await this._convertDexQuoteToUsd(token, outputQuote);
+    }
+
     async _getPriceEkubo(token: TokenInfo, amountIn = new Web3Number(1, token.decimals), retry = 0): Promise<number> {
-        const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address.toString()).replace("{{AMOUNT}}", amountIn.toWei());
+        const quoteConfig = resolveQuoteTokenConfig(token, this.tokens);
+        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())
+            .replace(PRICER_USDC_ADDRESS, quoteConfig.address);
         const result = await axios.get(url);
         const data: any = result.data;
         const multiplier = 1 / amountIn.toNumber();
-        const outputUSDC = Number(Web3Number.fromWei(data.total_calculated, 6).toFixed(6)) * multiplier;
-        logger.verbose(`Ekubo: ${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._getPriceEkubo(token, amountIn, retry + 1);
+        const outputQuote = Number(
+            Web3Number.fromWei(data.total_calculated, quoteConfig.decimals).toFixed(6),
+        ) * multiplier;
+        logger.verbose(`Ekubo: ${token.symbol} -> ${quoteConfig.symbol}: ${outputQuote}, retry: ${retry}`);
+        if (outputQuote === 0 && retry < 3) {
+            const retryAmountIn = new Web3Number(100, token.decimals);
+            return await this._getPriceEkubo(token, retryAmountIn, 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;
+        return await this._convertDexQuoteToUsd(token, outputQuote);
     }
 }

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/modules/zkLend.ts

@@ -2,7 +2,7 @@ import axios from "axios";
 import BigNumber from "bignumber.js";
 import { Web3Number } from "@/dataTypes/bignumber.browser";
 import { FatalError, Global } from "@/global";
-import { TokenInfo } from "@/interfaces";
+import { TokenIndexingType, TokenInfo } from "@/interfaces";
 import { ILending, ILendingPosition, LendingToken, MarginType } from "@/interfaces/lending";
 import { ContractAddr } from "@/dataTypes/address";
 import { IConfig } from "@/interfaces";
@@ -42,7 +42,8 @@ export class ZkLend extends ILending implements ILending {
                     decimals: pool.token.decimals,
                     borrowFactor: Web3Number.fromWei(pool.borrow_factor.value, pool.borrow_factor.decimals),
                     collareralFactor,
-                    displayDecimals: 2
+                    displayDecimals: 2,
+                    indexingType: TokenIndexingType.IGNORE,
                 }
                 this.tokens.push(token);
             });

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;
@@ -17,6 +18,7 @@ export class PricerRedis extends Pricer {
         await this.initRedis(redisUrl);
 
         logger.info(`Starting Pricer with Redis`);
+        this.avnuApiPricer.start();
         this._loadPrices(this._setRedisPrices.bind(this));
         setInterval(() => {
             this._loadPrices(this._setRedisPrices.bind(this));
@@ -51,7 +53,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,33 +29,87 @@ export interface DualTokenInfo {
     token1: SingleTokenInfo
 }
 
+export type StrategyInputMode = "single" | "dual";
+export type InputModeFromAction<T> = T extends DualActionAmount ? "dual" : "single";
+
+export interface NetAPYSplit {
+  apy: number;
+  id: string;
+}
+
+export interface NetAPYDetails {
+  net: number;
+  splits: NetAPYSplit[];
+}
+
+export type UserPositionCardSubValueColor = "default" | "positive" | "negative" | "info";
+
+export interface UserPositionCard {
+  title: string;
+  value: string;
+  tooltip?: string;
+  subValue?: string;
+  subValueColor?: UserPositionCardSubValueColor;
+}
+
+export interface UserPositionCardsInput {
+  user: ContractAddr;
+  investmentFlows?: Array<{ amount: string; type: string; timestamp: number; tx_hash: string }>;
+  usualTimeToEarnings?: string | null;
+  usualTimeToEarningsDescription?: string | null;
+}
+
 interface CacheData {
   timestamp: number;
   ttl: number;
   data: any;
 }
-export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
-    readonly config: IConfig;
-    readonly cache: Map<string, CacheData> = new Map();
+export class BaseStrategy<
+  TVLInfo,
+  DepositActionInfo,
+  WithdrawActionInfo = DepositActionInfo,
+> extends CacheClass {
+  readonly config: IConfig;
+  readonly cache: Map<string, CacheData> = new Map();
+  private readonly _depositInputMode: InputModeFromAction<DepositActionInfo>;
+  private readonly _withdrawInputMode: InputModeFromAction<WithdrawActionInfo>;
 
-    constructor(config: IConfig) {
+    constructor(
+      config: IConfig,
+      inputModes?: {
+        depositInputMode?: InputModeFromAction<DepositActionInfo>;
+        withdrawInputMode?: InputModeFromAction<WithdrawActionInfo>;
+      }
+    ) {
         super();
         this.config = config;
+        this._depositInputMode = (inputModes?.depositInputMode ??
+          ("single" as InputModeFromAction<DepositActionInfo>));
+        this._withdrawInputMode = (inputModes?.withdrawInputMode ??
+          ("single" as InputModeFromAction<WithdrawActionInfo>));
+    }
+
+    depositInputMode(): InputModeFromAction<DepositActionInfo> {
+      return this._depositInputMode;
+    }
+
+    withdrawInputMode(): InputModeFromAction<WithdrawActionInfo> {
+      return this._withdrawInputMode;
     }
 
-    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[]> {
+    async depositCall(amountInfo: DepositActionInfo, receiver: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
     }
 
-    async withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
+    async withdrawCall(amountInfo: WithdrawActionInfo, receiver: ContractAddr, owner: ContractAddr, isMaxWithdraw: boolean = false): Promise<Call[]> {
         throw new Error("Not implemented");
     }
 
@@ -62,19 +117,116 @@ 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 | string | 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");
+    async getUserPositionCards(_input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+      throw new Error("Not implemented");
     }
-}
+
+    async getMaxTVL() : Promise<Web3Number> {
+      // Can throw an error as well if needed, RN returning 0
+      return new Web3Number('0', 18)
+    }
+
+    protected formatTokenAmountForCard(amount: Web3Number, tokenInfo: TokenInfo): string {
+      const displayDecimals = tokenInfo.displayDecimals ?? 2;
+      const fixed = Number(amount.toFixed(displayDecimals));
+      const normalized = Number.isFinite(fixed) ? fixed : 0;
+      return `${normalized.toLocaleString("en-US", {
+        maximumFractionDigits: displayDecimals,
+        minimumFractionDigits: 0,
+      })} ${tokenInfo.symbol}`;
+    }
+
+    protected formatPercentForCard(value: number): string {
+      if (!Number.isFinite(value)) return "N/A";
+      return `${(value * 100).toFixed(2)}%`;
+    }
+
+    protected formatUSDForCard(value: number): string {
+      if (!Number.isFinite(value)) return "$0.00";
+      return new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: "USD",
+        maximumFractionDigits: 2,
+      }).format(value);
+    }
+
+    protected getSubValueColorFromSignedNumber(value: number): UserPositionCardSubValueColor {
+      if (!Number.isFinite(value)) return "default";
+      if (value > 0) return "positive";
+      if (value < 0) return "negative";
+      return "default";
+    }
+
+    /**
+     * 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,
+        };
+    }
+}

package/src/strategies/constants.ts

@@ -1,12 +1,17 @@
 import { ContractAddr } from "@/dataTypes";
 
-export const COMMON_CONTRACTS = [{
+export const MY_ACCESS_CONTROL = {
   address: ContractAddr.from("0x0636a3f51cc37f5729e4da4b1de6a8549a28f3c0d5bf3b17f150971e451ff9c2"),
   name: "Access Controller",
   sourceCodeUrl: "https://github.com/strkfarm/strkfarm-contracts/blob/main/src/components/accessControl.cairo",
-}];
+};
+
+export const COMMON_CONTRACTS = [MY_ACCESS_CONTROL];
 
 export const ENDPOINTS = {
   VESU_BASE: "https://proxy.api.troves.fi/vesu",
   VESU_BASE_STAGING: "https://proxy.api.troves.fi/vesu-staging"
-}
+}
+
+
+export const MAX_AVNU_RETRY_DELAY = Number(process.env.MAX_AVNU_RETRY_DELAY ?? 100);