@strkfarm/sdk 2.0.0-dev.4 → 2.0.0-dev.40

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): 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);