@strkfarm/sdk 2.0.0-dev.3 → 2.0.0-dev.30

package/src/utils/strategy-utils.ts

@@ -0,0 +1,61 @@
+import { SingleTokenInfo, DualTokenInfo } from "../strategies/base-strategy";
+import { BaseStrategy } from "../strategies/base-strategy";
+import { AmountsInfo, StrategyCapabilities, TokenInfo } from "@/interfaces";
+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
+ */
+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";
+}

package/src/strategies/universal-adapters/unused-balance-adapter.ts

@@ -1,109 +0,0 @@
-import { ContractAddr, Web3Number } from "@/dataTypes";
-import { APYType, BaseAdapter, BaseAdapterConfig, DepositParams, ManageCall, PositionAmount, PositionAPY, PositionInfo, SupportedPosition, WithdrawParams } from "./baseAdapter";
-import { Contract, uint256 } from "starknet";
-import erc20Abi from "@/data/erc20.abi.json";
-import { ERC20, TokenMarketData } from "@/modules";
-import { Protocols } from "@/interfaces";
-
-export interface UnusedBalanceAdapterConfig extends BaseAdapterConfig {}
-
-export class UnusedBalanceAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
-  readonly config: UnusedBalanceAdapterConfig;
-  readonly tokenMarketData: TokenMarketData;
-
-  constructor(config: UnusedBalanceAdapterConfig) {
-    super(config, UnusedBalanceAdapter.name, Protocols.NONE);
-    this.config = config;
-    this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
-  }
-
-  protected async getAPY(_supportedPosition: SupportedPosition): Promise<PositionAPY> {
-    const isSupported = this.tokenMarketData.isAPYSupported(this.config.baseToken);
-    const apy = isSupported ? await this.tokenMarketData.getAPY(this.config.baseToken) : 0;
-    return { apy: apy, type: isSupported ? APYType.LST : APYType.BASE };
-  }
-
-  protected async getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount> {
-    try {
-      const balance = await (new ERC20(this.config.networkConfig)).balanceOf(supportedPosition.asset.address, this.config.vaultAllocator.address, supportedPosition.asset.decimals);
-      return {
-        amount: balance,
-        remarks: "Unused balance"
-      }
-    } catch (_e) {
-      throw new Error(`${UnusedBalanceAdapter.name}: Failed to get position for ${supportedPosition.asset.symbol}`);
-    }
-  }
-
-  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
-    const baseToken = this.config.baseToken;
-    if (!amount) {
-      const infinite = new Web3Number('999999999999999999999999999', baseToken.decimals);
-      return {
-        tokenInfo: baseToken,
-        amount: infinite,
-        usdValue: Number.POSITIVE_INFINITY,
-        remarks: "Max deposit (infinity)",
-        apy: await this.getAPY({ asset: baseToken, isDebt: false }),
-        protocol: this.protocol
-      };
-    }
-    const usdValue = await this.getUSDValue(baseToken, amount);
-    return {
-      tokenInfo: baseToken,
-      amount,
-      usdValue,
-      remarks: "Deposit amount",
-      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
-      protocol: this.protocol
-    };
-  }
-
-  async maxWithdraw(): Promise<PositionInfo> {
-    const baseToken = this.config.baseToken;
-    const current = await this.getPosition({ asset: baseToken, isDebt: false });
-    const usdValue = await this.getUSDValue(baseToken, current.amount);
-    return {
-      tokenInfo: baseToken,
-      amount: current.amount,
-      usdValue,
-      remarks: "Max withdraw",
-      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
-      protocol: this.protocol
-    };
-  }
-
-  protected _getDepositLeaf(): {
-    target: ContractAddr,
-    method: string,
-    packedArguments: bigint[];
-    sanitizer: ContractAddr,
-    id: string
-  }[] {
-    return [];
-  }
-
-  protected _getWithdrawLeaf(): {
-    target: ContractAddr,
-    method: string,
-    packedArguments: bigint[];
-    sanitizer: ContractAddr,
-    id: string
-  }[] {
-    return [];
-  }
-
-  async getHealthFactor(): Promise<number> {
-   return Promise.resolve(10);
-  }
-
-  getDepositCall(params: DepositParams): Promise<ManageCall[]> {
-    return Promise.resolve([]);
-  }
-
-  getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
-    return Promise.resolve([]);
-  }
-}
-
-