@strkfarm/sdk 2.0.0-staging.6 → 2.0.0-staging.61

package/src/modules/erc20.ts

@@ -2,7 +2,7 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig } from "@/interfaces";
 import { Contract } from "starknet";
 import ERC20Abi from '@/data/erc20.abi.json';
-
+import { uint256 } from "starknet";
 export class ERC20 {
     readonly config: IConfig;
 
@@ -12,7 +12,7 @@ export class ERC20 {
 
     contract(addr: string | ContractAddr) {
         const _addr = typeof addr === 'string' ? addr : addr.address;
-        return new Contract({abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider});
+        return new Contract({ abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider });
     }
 
     async balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number) {
@@ -26,4 +26,20 @@ export class ERC20 {
         const allowance = await contract.call('allowance', [owner.toString(), spender.toString()]);
         return Web3Number.fromWei(allowance.toString(), tokenDecimals);
     }
+
+    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/index.ts

@@ -6,4 +6,5 @@ export * from './erc20';
 export * from './avnu';
 export * from './ekubo-quoter';
 export * from './pricer-lst';
-export * from './lst-apr';
+export * from './lst-apr';
+export * from './ekubo-pricer'

package/src/strategies/base-strategy.ts

@@ -23,6 +23,9 @@ 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;
@@ -33,18 +36,59 @@ export interface NetAPYDetails {
   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, blockIdentifier?: BlockIdentifier): Promise<TVLInfo> {
@@ -55,11 +99,11 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
         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");
     }
 
@@ -71,11 +115,112 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
         blockIdentifier?: BlockIdentifier,
         sinceBlocks?: number,
         timeperiod?: "24h" | "7d" | "30d" | "3m"
-    ): Promise<number | NetAPYDetails> {
+    ): Promise<number | string | NetAPYDetails> {
         throw new Error("Not implemented");
     }
 
     async getPendingRewards(): Promise<HarvestInfo[]> {
         return [];
     }
-}
+
+    async getUserRealizedAPY(
+        blockIdentifier?: BlockIdentifier,
+        sinceBlocks?: number
+    ): 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,10 +1,10 @@
 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 ENDPOINTS = {
   VESU_BASE: "https://proxy.api.troves.fi/vesu",