@strkfarm/sdk 2.0.0-staging.20 → 2.0.0-staging.21

package/dist/index.browser.global.js

@@ -92270,6 +92270,40 @@ spurious results.`);
     async getUserRealizedAPY(blockIdentifier, sinceBlocks) {
       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, investmentFlows) {
+      const tokenDecimals = userTVL.tokenInfo.decimals;
+      let totalDeposits = Web3Number.fromWei("0", tokenDecimals);
+      let totalWithdrawals = Web3Number.fromWei("0", tokenDecimals);
+      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);
+        }
+      }
+      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
+      };
+    }
   };
 
   // src/node/headless.browser.ts
@@ -104000,6 +104034,13 @@ spurious results.`);
       ) / 1e4;
       return apyForGivenBlocks * (365 * 24 * 3600) / timeDiffSeconds;
     }
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Ekubo CL Vault strategy
+     */
+    getLifetimeEarnings(userTVL, investmentFlows) {
+      throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+    }
     /**
      * Calculates realized APY based on TVL per share growth, always valued in USDC.
      * This is a vault-level metric (same for all users) and works for all strategies,
@@ -115656,6 +115697,13 @@ spurious results.`);
       this.setCache(CACHE_KEY, price);
       return price;
     }
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Sensei Vault strategy
+     */
+    getLifetimeEarnings(userTVL, investmentFlows) {
+      throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+    }
     async netAPY() {
       try {
         const { pools } = await VesuAdapter.getVesuPools();

package/dist/index.browser.mjs

@@ -4846,6 +4846,40 @@ var BaseStrategy = class extends CacheClass {
   async getUserRealizedAPY(blockIdentifier, sinceBlocks) {
     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, investmentFlows) {
+    const tokenDecimals = userTVL.tokenInfo.decimals;
+    let totalDeposits = Web3Number.fromWei("0", tokenDecimals);
+    let totalWithdrawals = Web3Number.fromWei("0", tokenDecimals);
+    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);
+      }
+    }
+    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
+    };
+  }
 };
 
 // src/node/headless.browser.ts
@@ -16589,6 +16623,13 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     ) / 1e4;
     return apyForGivenBlocks * (365 * 24 * 3600) / timeDiffSeconds;
   }
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Ekubo CL Vault strategy
+   */
+  getLifetimeEarnings(userTVL, investmentFlows) {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
   /**
    * Calculates realized APY based on TVL per share growth, always valued in USDC.
    * This is a vault-level metric (same for all users) and works for all strategies,
@@ -28252,6 +28293,13 @@ var SenseiVault = class _SenseiVault extends BaseStrategy {
     this.setCache(CACHE_KEY, price);
     return price;
   }
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Sensei Vault strategy
+   */
+  getLifetimeEarnings(userTVL, investmentFlows) {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
   async netAPY() {
     try {
       const { pools } = await VesuAdapter.getVesuPools();

package/dist/index.d.ts

@@ -615,6 +615,26 @@ declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     netAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number, timeperiod?: "24h" | "7d" | "30d" | "3m"): Promise<number | NetAPYDetails>;
     getPendingRewards(): Promise<HarvestInfo[]>;
     getUserRealizedAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    /**
+     * 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;
+    };
 }
 
 interface PoolProps {
@@ -908,6 +928,16 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
         history: FeeHistory[];
     }>;
     netSharesBasedTrueAPY(blockIdentifier?: BlockIdentifier, sinceBlocks?: number): Promise<number>;
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Ekubo CL Vault strategy
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): any;
     /**
      * Calculates realized APY based on TVL per share growth, always valued in USDC.
      * This is a vault-level metric (same for all users) and works for all strategies,
@@ -1109,6 +1139,16 @@ declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmou
     }>;
     getSecondaryTokenPriceRelativeToMain(retry?: number): Promise<number>;
     getSettings: () => Promise<starknet.CallResult>;
+    /**
+     * Calculate lifetime earnings for a user
+     * Not yet implemented for Sensei Vault strategy
+     */
+    getLifetimeEarnings(userTVL: SingleTokenInfo, investmentFlows: Array<{
+        amount: string;
+        type: string;
+        timestamp: number;
+        tx_hash: string;
+    }>): any;
     netAPY(): Promise<number>;
     /**
      * Calculates user realized APY based on position growth accounting for deposits and withdrawals.

package/dist/index.js

@@ -4882,6 +4882,40 @@ var BaseStrategy = class extends CacheClass {
   async getUserRealizedAPY(blockIdentifier, sinceBlocks) {
     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, investmentFlows) {
+    const tokenDecimals = userTVL.tokenInfo.decimals;
+    let totalDeposits = Web3Number.fromWei("0", tokenDecimals);
+    let totalWithdrawals = Web3Number.fromWei("0", tokenDecimals);
+    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);
+      }
+    }
+    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
+    };
+  }
 };
 
 // src/node/headless.browser.ts
@@ -16621,6 +16655,13 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     ) / 1e4;
     return apyForGivenBlocks * (365 * 24 * 3600) / timeDiffSeconds;
   }
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Ekubo CL Vault strategy
+   */
+  getLifetimeEarnings(userTVL, investmentFlows) {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
   /**
    * Calculates realized APY based on TVL per share growth, always valued in USDC.
    * This is a vault-level metric (same for all users) and works for all strategies,
@@ -28385,6 +28426,13 @@ var SenseiVault = class _SenseiVault extends BaseStrategy {
     this.setCache(CACHE_KEY, price);
     return price;
   }
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Sensei Vault strategy
+   */
+  getLifetimeEarnings(userTVL, investmentFlows) {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
   async netAPY() {
     try {
       const { pools } = await VesuAdapter.getVesuPools();

package/dist/index.mjs

@@ -4748,6 +4748,40 @@ var BaseStrategy = class extends CacheClass {
   async getUserRealizedAPY(blockIdentifier, sinceBlocks) {
     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, investmentFlows) {
+    const tokenDecimals = userTVL.tokenInfo.decimals;
+    let totalDeposits = Web3Number.fromWei("0", tokenDecimals);
+    let totalWithdrawals = Web3Number.fromWei("0", tokenDecimals);
+    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);
+      }
+    }
+    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
+    };
+  }
 };
 
 // src/node/headless.browser.ts
@@ -16491,6 +16525,13 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     ) / 1e4;
     return apyForGivenBlocks * (365 * 24 * 3600) / timeDiffSeconds;
   }
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Ekubo CL Vault strategy
+   */
+  getLifetimeEarnings(userTVL, investmentFlows) {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
   /**
    * Calculates realized APY based on TVL per share growth, always valued in USDC.
    * This is a vault-level metric (same for all users) and works for all strategies,
@@ -28255,6 +28296,13 @@ var SenseiVault = class _SenseiVault extends BaseStrategy {
     this.setCache(CACHE_KEY, price);
     return price;
   }
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Sensei Vault strategy
+   */
+  getLifetimeEarnings(userTVL, investmentFlows) {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
   async netAPY() {
     try {
       const { pools } = await VesuAdapter.getVesuPools();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@strkfarm/sdk",
-    "version": "2.0.0-staging.20",
+    "version": "2.0.0-staging.21",
     "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
     "typings": "dist/index.d.ts",
     "types": "dist/index.d.ts",

package/src/strategies/base-strategy.ts

@@ -85,4 +85,58 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     ): 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,
+        };
+    }
 }

package/src/strategies/ekubo-cl-vault.tsx

@@ -36,7 +36,7 @@ import EkuboMathAbi from "@/data/ekubo-math.abi.json";
 import ERC4626Abi from "@/data/erc4626.abi.json";
 import { Global } from "@/global";
 import { AvnuWrapper, ERC20, SwapInfo } from "@/modules";
-import { BaseStrategy } from "./base-strategy";
+import { BaseStrategy, SingleTokenInfo } from "./base-strategy";
 import { DualActionAmount } from "./base-strategy";
 import { DualTokenInfo } from "./base-strategy";
 import { log } from "winston";
@@ -488,6 +488,17 @@ export class EkuboCLVault extends BaseStrategy<
     return (apyForGivenBlocks * (365 * 24 * 3600)) / timeDiffSeconds;
   }
 
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Ekubo CL Vault strategy
+   */
+  getLifetimeEarnings(
+    userTVL: SingleTokenInfo,
+    investmentFlows: Array<{ amount: string; type: string; timestamp: number; tx_hash: string }>
+  ): any {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
+
   /**
    * Calculates realized APY based on TVL per share growth, always valued in USDC.
    * This is a vault-level metric (same for all users) and works for all strategies,

package/src/strategies/sensei.ts

@@ -238,6 +238,17 @@ export class SenseiVault extends BaseStrategy<
     return settings;
   };
 
+  /**
+   * Calculate lifetime earnings for a user
+   * Not yet implemented for Sensei Vault strategy
+   */
+  getLifetimeEarnings(
+    userTVL: SingleTokenInfo,
+    investmentFlows: Array<{ amount: string; type: string; timestamp: number; tx_hash: string }>
+  ): any {
+    throw new Error("getLifetimeEarnings is not implemented yet for this strategy");
+  }
+
   async netAPY(): Promise<number> {
     try {
       // Fetch Vesu pools and select the Re7 xSTRK pool
@@ -654,4 +665,4 @@ export const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[] =
         toolTip: "This strategy holds xSTRK. Earn 3-4x Endur points on your xSTRK due to the leverage. Points can be found on endur.fi.",
       }]
     },
-  ];
+  ];

package/src/utils/strategy-utils.ts

@@ -1,7 +1,11 @@
 import { SingleTokenInfo, DualTokenInfo } from "../strategies/base-strategy";
 import { BaseStrategy } from "../strategies/base-strategy";
 import { AmountsInfo, StrategyCapabilities, TokenInfo } from "@/interfaces";
-import { Web3Number } from "@/dataTypes";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { gql } from "@apollo/client";
+import apolloClient from "@/modules/apollo-client";
+import { num } from "starknet";
+import { logger } from "./logger";
 
 /**
  * Convert SDK TVL info (SingleTokenInfo or DualTokenInfo) to client AmountsInfo format
@@ -54,4 +58,4 @@ export function detectCapabilities(
 export function isDualTokenStrategy(strategy: BaseStrategy<any, any>): boolean {
     // Check if strategy has matchInputAmounts (dual token strategies have this)
     return typeof (strategy as any).matchInputAmounts === "function";
-}
+}