@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

package/src/utils/health-factor-math.ts

@@ -1,6 +1,5 @@
 import { Web3Number } from "@/dataTypes";
 import { TokenInfo } from "@/interfaces";
-import { logger } from "@/utils/logger";
 
 export class HealthFactorMath {
   static getCollateralRequired(
@@ -53,18 +52,13 @@ export class HealthFactorMath {
     debtTokenInfo: TokenInfo
   ) {
     // lets say debt usd value is X
-    // HF = ((ca * cp) + X) * maxLTV / (X)
-    // => X * HF = ((ca * cp) + X) * maxLTV
-    // => X * (HF - maxLTV) = ca * cp * maxLTV
-    // => X = ca * cp * maxLTV / (HF - maxLTV)
+    // HF = ((1 * cp) + X) * maxLTV / (X)
+    // => X * HF = ((1 * cp) + X) * maxLTV
+    // => X * (HF - maxLTV) = 1 * cp * maxLTV
+    // => X = 1 * cp * maxLTV / (HF - maxLTV)
     const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
-    logger.verbose(`HealthFactorMath: Max debt amount on looping numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
     const denominator = targetHF - maxLTV;
-    logger.verbose(`HealthFactorMath: Max debt amount on looping denominator: ${denominator}`);
-    const debtAmountUSD = numerator.dividedBy(denominator);
-    logger.verbose(`HealthFactorMath: Max debt amount on looping debtAmountUSD: ${debtAmountUSD.toNumber()}`);
-    const debtAmount = debtAmountUSD.dividedBy(debtPrice);
-    logger.verbose(`HealthFactorMath: Max debt amount on looping debtAmount: ${debtAmount.toNumber()}`);
+    const debtAmount = numerator.dividedBy(denominator);
     return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
   }
 

package/src/utils/index.ts

@@ -1,16 +1,16 @@
-
-export * from '@/utils/logger';
-export * from './oz-merkle';
+export * from "@/utils/logger";
+export * from "./oz-merkle";
+export * from "./strategy-utils";
 
 // Utility type to make all optional properties required
 export type RequiredFields<T> = {
-    [K in keyof T]-?: T[K]
-}
+    [K in keyof T]-?: T[K];
+};
 
 // Utility type to get only the required fields of a type
 export type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K
-}[keyof T]
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
 
 export function assert(condition: boolean, message: string) {
     if (!condition) {
@@ -19,6 +19,5 @@ export function assert(condition: boolean, message: string) {
 }
 
 export function getTrovesEndpoint(): string {
-    return process.env.TROVES_ENDPOINT || 'https://app.troves.fi';
+    return process.env.TROVES_ENDPOINT || "https://app.troves.fi";
 }
-

package/src/utils/strategy-utils.ts

@@ -0,0 +1,57 @@
+import { SingleTokenInfo, DualTokenInfo } from "../strategies/base-strategy";
+import { BaseStrategy } from "../strategies/base-strategy";
+import { AmountsInfo, StrategyCapabilities, TokenInfo } from "@/interfaces";
+import { Web3Number } from "@/dataTypes";
+
+/**
+ * Convert SDK TVL info (SingleTokenInfo or DualTokenInfo) to client AmountsInfo format
+ */
+export function toAmountsInfo(tvlInfo: SingleTokenInfo | DualTokenInfo): Omit<
+    AmountsInfo,
+    "amounts"
+> & {
+    amounts: Array<{
+        amount: Web3Number;
+        tokenInfo: TokenInfo;
+    }>;
+} {
+    if ("token0" in tvlInfo) {
+        // Dual token
+        return {
+            usdValue: tvlInfo.usdValue,
+            amounts: [tvlInfo.token0, tvlInfo.token1]
+        };
+    } else {
+        // Single token
+        return {
+            usdValue: tvlInfo.usdValue,
+            amounts: [tvlInfo]
+        };
+    }
+}
+
+/**
+ * Detect what capabilities a strategy instance has
+ */
+export function detectCapabilities(
+    strategy: BaseStrategy<any, any>
+): StrategyCapabilities {
+    return {
+        hasMatchInputAmounts:
+            typeof (strategy as any).matchInputAmounts === "function",
+        hasNetAPY: typeof (strategy as any).netAPY === "function",
+        hasGetInvestmentFlows:
+            typeof (strategy as any).getInvestmentFlows === "function",
+        hasGetPendingRewards: typeof strategy.getPendingRewards === "function",
+        hasHarvest: typeof (strategy as any).harvest === "function",
+        hasRebalance: typeof (strategy as any).getRebalanceCall === "function"
+    };
+}
+
+/**
+ * Check if a strategy is a dual-token strategy
+ */
+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";
+}