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

package/src/modules/token-market-data.ts

@@ -1,202 +0,0 @@
-import { ContractAddr, Web3Number } from '../dataTypes';
-import { TokenInfo, IConfig } from '../interfaces';
-import { PricerBase } from './pricerBase';
-import { LSTAPRService } from './lst-apr';
-import { Midas } from './midas';
-import { SingleTokenInfo } from '../strategies/base-strategy';
-import { logger } from '../utils/logger';
-import { Contract } from 'starknet';
-import { uint256 } from 'starknet';
-import ERC4626Abi from '../data/erc4626.abi.json';
-
-/**
- * TokenMarketData class that combines LST APR and Midas modules
- * to provide unified APY, price, and TVL functions for tokens
- */
-export class TokenMarketData {
-    private pricer: PricerBase;
-    private config: IConfig;
-
-    constructor(pricer: PricerBase, config: IConfig) {
-        this.pricer = pricer;
-        this.config = config;
-    }
-
-    /**
-     * Get APY for a token
-     * - If it's an LST token, returns LST APY
-     * - If it's a Midas token, returns Midas APY
-     * - Otherwise returns 0
-     * @param tokenInfo The token to get APY for
-     * @returns APY in absolute terms (not percentage)
-     */
-    async getAPY(tokenInfo: TokenInfo): Promise<number> {
-        try {
-            // Check if it's an LST token
-            if (LSTAPRService.isLST(tokenInfo.address)) {
-                const underlying = LSTAPRService.getUnderlyingFromLST(tokenInfo.address);
-                const lstApr = await LSTAPRService.getLSTAPR(underlying.address);
-                logger.verbose(`TokenMarketData: LST APY for ${tokenInfo.symbol}: ${lstApr}`);
-                return lstApr;
-            }
-
-            // Check if it's a Midas token by trying to get symbol
-            if (Midas.isSupported(tokenInfo.address)) {
-                const midasApy = await Midas.getAPY(tokenInfo.address);
-                logger.verbose(`TokenMarketData: Midas APY for ${tokenInfo.symbol}: ${midasApy}`);
-                return midasApy;
-            }
-
-            // Default to 0 for unsupported tokens
-            logger.verbose(`TokenMarketData: No APY data available for ${tokenInfo.symbol}, returning 0`);
-            return 0;
-        } catch (error) {
-            logger.error(`TokenMarketData: Error getting APY for ${tokenInfo.symbol}:`, error);
-            return 0;
-        }
-    }
-
-    /**
-     * Get price for a token using the pricer module
-     * @param tokenInfo The token to get price for
-     * @returns Price as a number
-     * @throws Error if price is 0 or unavailable
-     */
-    async getPrice(tokenInfo: TokenInfo): Promise<number> {
-        try {
-            const priceInfo = await this.pricer.getPrice(tokenInfo.symbol);
-            
-            if (priceInfo.price === 0) {
-                throw new Error(`Price is 0 for token ${tokenInfo.symbol}`);
-            }
-
-            logger.verbose(`TokenMarketData: Price for ${tokenInfo.symbol}: ${priceInfo.price}`);
-            return priceInfo.price;
-        } catch (error) {
-            logger.error(`TokenMarketData: Error getting price for ${tokenInfo.symbol}:`, error);
-            throw new Error(`Failed to get price for ${tokenInfo.symbol}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-
-    /**
-     * Get true price for a token
-     * - For LST tokens: Uses convert_to_assets to get true exchange rate
-     * - For Midas tokens: Uses Midas price API
-     * - For other tokens: Falls back to regular pricer
-     * @param tokenInfo The token to get true price for
-     * @returns True price as a number
-     * @throws Error if price is 0 or unavailable
-     */
-    async getTruePrice(tokenInfo: TokenInfo): Promise<number> {
-        try {
-            // For LST tokens, use convert_to_assets
-            if (LSTAPRService.isLST(tokenInfo.address)) {
-                const lstABI = new Contract({
-                    abi: ERC4626Abi,
-                    address: tokenInfo.address.address,
-                    providerOrAccount: this.config.provider
-                });
-
-                const price: any = await lstABI.call('convert_to_assets', [
-                    uint256.bnToUint256((new Web3Number(1, tokenInfo.decimals)).toWei())
-                ]);
-                const exchangeRate = Number(uint256.uint256ToBN(price).toString()) / Math.pow(10, tokenInfo.decimals);
-                
-                if (exchangeRate === 0) {
-                    throw new Error(`True price is 0 for LST token ${tokenInfo.symbol}`);
-                }
-
-                logger.verbose(`TokenMarketData: LST true price for ${tokenInfo.symbol}: ${exchangeRate}`);
-                return exchangeRate;
-            }
-
-            // For Midas tokens, use Midas price API
-            if (Midas.isSupported(tokenInfo.address)) {
-                const midasPrice = await Midas.getPrice(tokenInfo.address);
-                
-                if (midasPrice === 0) {
-                    throw new Error(`True price is 0 for Midas token ${tokenInfo.symbol}`);
-                }
-
-                logger.verbose(`TokenMarketData: Midas true price for ${tokenInfo.symbol}: ${midasPrice}`);
-                return midasPrice;
-            }
-
-            // For other tokens, fall back to regular pricer
-            const price = await this.getPrice(tokenInfo);
-            
-            if (price === 0) {
-                throw new Error(`True price is 0 for token ${tokenInfo.symbol}`);
-            }
-
-            logger.verbose(`TokenMarketData: Regular price for ${tokenInfo.symbol}: ${price}`);
-            return price;
-        } catch (error) {
-            logger.error(`TokenMarketData: Error getting true price for ${tokenInfo.symbol}:`, error);
-            throw new Error(`Failed to get true price for ${tokenInfo.symbol}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-
-    /**
-     * Get TVL for a token
-     * - If it's a Midas token, returns Midas TVL data
-     * - Otherwise returns 0
-     * @param tokenInfo The token to get TVL for
-     * @returns TVL as SingleTokenInfo or 0
-     */
-    async getTVL(tokenInfo: TokenInfo): Promise<SingleTokenInfo> {
-      // Check if it's a Midas token by trying to get TVL
-      if (Midas.isSupported(tokenInfo.address)) {
-        const midasTvl = await Midas.getTVL(tokenInfo.address);
-        
-        // Handle different TVL response formats
-        let usdValue: number;
-        let nativeAmount: number;
-
-        if (typeof midasTvl === 'number') {
-            // Simple number format (e.g., mre7: 18193466)
-            usdValue = midasTvl;
-            nativeAmount = 0; // We don't have native amount in this format
-        } else if (typeof midasTvl === 'object' && 'usd' in midasTvl && 'native' in midasTvl) {
-            // Object format with usd and native (e.g., mre7btc: {usd: 998826, native: 9.3228})
-            usdValue = midasTvl.usd;
-            nativeAmount = midasTvl.native;
-        } else {
-            throw new Error(`Unexpected TVL format for ${tokenInfo.symbol}`);
-        }
-
-        const tvlInfo: SingleTokenInfo = {
-            tokenInfo,
-            amount: Web3Number.fromWei(nativeAmount, tokenInfo.decimals),
-            usdValue
-        };
-
-        logger.verbose(`TokenMarketData: Midas TVL for ${tokenInfo.symbol}: USD=${usdValue}, Native=${nativeAmount}`);
-        return tvlInfo;
-      }
-      
-      return {
-        tokenInfo,
-        amount: Web3Number.fromWei('0', tokenInfo.decimals),
-        usdValue: 0
-      }
-    }
-
-    /**
-     * Check if a token is supported for APY data
-     * @param tokenInfo The token to check
-     * @returns True if the token has APY data available
-     */
-    isAPYSupported(tokenInfo: TokenInfo): boolean {
-        return LSTAPRService.isLST(tokenInfo.address) || Midas.isSupported(tokenInfo.address);
-    }
-
-    /**
-     * Check if a token is supported for TVL data
-     * @param tokenInfo The token to check
-     * @returns True if the token has TVL data available
-     */
-    isTVLSupported(tokenInfo: TokenInfo): boolean {
-        return Midas.isSupported(tokenInfo.address);
-    }
-}

package/src/strategies/svk-strategy.ts

@@ -1,247 +0,0 @@
-import { ContractAddr, Web3Number } from "@/dataTypes";
-import { IConfig, IStrategyMetadata, TokenInfo, VaultPosition } from "@/interfaces";
-import { PricerBase } from "@/modules/pricerBase";
-import { ERC20 } from "@/modules";
-import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
-import { Call, Contract, num } from "starknet";
-import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
-import { UniversalStrategySettings } from "./universal-strategy";
-import { UNIVERSAL_MANAGE_IDS } from "./universal-strategy";
-import UniversalVaultAbi from '../data/universal-vault.abi.json';
-import ManagerAbi from '../data/vault-manager.abi.json';
-import { ManageCall, PositionInfo } from "./universal-adapters";
-
-/**
- * Base class for all SVK (Starknet Vault Kit) strategies.
- * Contains common functions that are shared across all SVK strategies.
- */
-export abstract class SVKStrategy<S extends UniversalStrategySettings> 
-  extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
-  
-  /** Contract address of the strategy */
-  readonly address: ContractAddr;
-  /** Pricer instance for token price calculations */
-  readonly pricer: PricerBase;
-  /** Metadata containing strategy information */
-  readonly metadata: IStrategyMetadata<S>;
-  /** Contract instance for interacting with the strategy */
-  readonly contract: Contract;
-  /** Manager contract instance for merkle verification */
-  readonly managerContract: Contract;
-  /** Cached merkle tree instance */
-  merkleTree: StandardMerkleTree | undefined;
-
-  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>) {
-    super(config);
-    this.pricer = pricer;
-    this.metadata = metadata;
-    this.address = metadata.address;
-    
-    this.contract = new Contract({
-      abi: UniversalVaultAbi,
-      address: this.address.address,
-      providerOrAccount: this.config.provider
-    });
-    
-    this.managerContract = new Contract({
-      abi: ManagerAbi,
-      address: this.metadata.additionalInfo.manager.address,
-      providerOrAccount: this.config.provider
-    });
-  }
-
-  /**
-   * Returns the asset token for this strategy
-   */
-  asset(): TokenInfo {
-    return this.metadata.depositTokens[0];
-  }
-
-  /**
-   * Returns the unused balance in the vault allocator.
-   * Note: This function is common for any SVK strategy.
-   */
-  async getUnusedBalance(): Promise<SingleTokenInfo> {
-    const balance = await (new ERC20(this.config)).balanceOf(
-      this.asset().address, 
-      this.metadata.additionalInfo.vaultAllocator, 
-      this.asset().decimals
-    );
-    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
-    const usdValue = Number(balance.toFixed(6)) * price.price;
-    return {
-      tokenInfo: this.asset(),
-      amount: balance,
-      usdValue
-    };
-  }
-
-  /**
-   * Bridges liquidity from the vault allocator back to the vault.
-   * Note: This function is common for any SVK strategy.
-   */
-  async getBringLiquidityCall(params: { amount: Web3Number }): Promise<Call> {
-    // Find approve leaf adapter
-    const approveAdapter = this.metadata.additionalInfo.leafAdapters.find(
-      adapter => adapter().leaves.find(leaf => leaf.readableId === UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY)
-    );
-    
-    if (!approveAdapter) {
-      throw new Error(`${this.getTag()}::getBringLiquidityCall: approve adapter not found`);
-    }
-    
-    // Find bring liquidity leaf adapter
-    const bringLiquidityAdapter = this.metadata.additionalInfo.leafAdapters.find(
-      adapter => adapter().leaves.find(leaf => leaf.readableId === UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY)
-    );
-    
-    if (!bringLiquidityAdapter) {
-      throw new Error(`${this.getTag()}::getBringLiquidityCall: bring liquidity adapter not found`);
-    }
-    
-    // Get proofs
-    const tree = this.getMerkleTree();
-    const proofGroups: string[][] = [];
-    for (const [i, v] of tree.entries()) {
-      if (v.readableId === UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY ||
-          v.readableId === UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY) {
-        proofGroups.push(tree.getProof(i));
-      }
-    }
-    
-    // Construct calls
-    logger.verbose("approve adapter amount", params.amount);
-    const approveCalls = await approveAdapter().callConstructor({ amount: params.amount });
-    const bringLiquidityCalls = await bringLiquidityAdapter().callConstructor({ amount: params.amount });
-    
-    // Combine into final call
-    return this.getManageCall(proofGroups, [...approveCalls, ...bringLiquidityCalls]);
-  }
-
-  /**
-   * Gets all leaves from all leaf adapters.
-   * Note: This function is common for any SVK strategy.
-   */
-  getAllLeaves(): LeafData[] {
-    const leaves = this.metadata.additionalInfo.leafAdapters.map(adapter => adapter());
-    const _leaves: LeafData[] = [];
-    leaves.forEach((_l) => {
-      _leaves.push(..._l.leaves);
-    });
-    return _leaves;
-  }
-
-  /**
-   * Builds and caches the merkle tree from all leaf adapters.
-   * Note: This function is common for any SVK strategy.
-   */
-  getMerkleTree(): StandardMerkleTree {
-    if (this.merkleTree) return this.merkleTree;
-    const _leaves = this.getAllLeaves();
-    const standardTree = StandardMerkleTree.of(_leaves);
-    this.merkleTree = standardTree;
-    return standardTree;
-  }
-
-  /**
-   * Gets the merkle root of the tree.
-   * Note: This function is common for any SVK strategy.
-   */
-  getMerkleRoot(): string {
-    return this.getMerkleTree().root;
-  }
-
-  /**
-   * Combines proofs and manage calls into a single Starknet call.
-   * Note: This function is common for any SVK strategy.
-   */
-  getManageCall(proofGroups: string[][], manageCalls: ManageCall[]): Call {
-    assert(
-      proofGroups.length == manageCalls.length, 
-      `Proof IDs and Manage Calls length mismatch: ${proofGroups.length} != ${manageCalls.length}`
-    );
-    
-    return this.managerContract.populate('manage_vault_with_merkle_verification', {
-      proofs: proofGroups.map(group => group),
-      decoder_and_sanitizers: manageCalls.map(call => call.sanitizer.address),
-      targets: manageCalls.map(call => call.call.contractAddress.address),
-      selectors: manageCalls.map(call => call.call.selector),
-      calldatas: manageCalls.map(call => call.call.calldata),
-    });
-  }
-
-  /**
-   * Creates a call to set the merkle root on the manager contract.
-   * Note: This function is common for any SVK strategy.
-   */
-  getSetManagerCall(strategist: ContractAddr, root = this.getMerkleRoot()): Call {
-    return this.managerContract.populate('set_manage_root', [
-      strategist.address, 
-      num.getHexString(root)
-    ]);
-  }
-
-  /**
-   * Returns a tag for logging purposes.
-   * Should be overridden by subclasses to provide strategy-specific tags.
-   */
-  abstract getTag(): string;
-
-
-  /**
-   * Returns the positions in the vault.
-   * @returns An array of VaultPosition objects representing the positions in the vault.
-   */
-  async getVaultPositions(): Promise<VaultPosition[]> {
-    const positions = await Promise.all(
-      this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.getPositions())
-    )
-    return positions.flat().map((position) => ({
-      amount: position.amount,
-      usdValue: position.usdValue,
-      remarks: position.remarks ?? '',
-      token: position.tokenInfo,
-      protocol: position.protocol
-    }))
-  }
-
-  async getHealthFactors(): Promise<number[]> {
-    return Promise.all(this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.getHealthFactor()));
-  }
-
-  // todo undo this
-  async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
-    const allPositions: PositionInfo[] = [];
-    for (let adapter of this.metadata.additionalInfo.adapters) {
-      const positions = await adapter.adapter.getPositions();
-      allPositions.push(...positions);
-    }
-
-    const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0);
-    let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0);
-    const netAPY = weightedAPYs / totalHoldingsUSDValue;
-    return {
-      net: netAPY,
-      splits: allPositions.map(p => ({apy: p.apy.apy, id: p.remarks ?? ''}))
-    };
-  }
-
-  async getPrevAUM() {
-    const currentAUM: bigint = await this.contract.call('aum', []) as bigint;
-    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
-    logger.verbose(`${this.getTag()} Prev AUM: ${prevAum}`);
-    return prevAum;
-  }
-
-  async maxDepositables() {
-    const maxDepositables = await Promise.all(this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.maxDeposit()));
-    return maxDepositables;
-  }
-
-  async maxWithdrawables() {
-    const maxWithdrawables = await Promise.all(this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter.maxWithdraw()));
-    return maxWithdrawables;
-  }
-
-}
-

package/src/strategies/universal-adapters/adapter-optimizer.ts

@@ -1,65 +0,0 @@
-import { logger } from "@/utils";
-import { BaseAdapter, DepositParams, WithdrawParams } from "./baseAdapter";
-import { Web3Number } from "@/dataTypes";
-
-export class AdapterOptimizer {
-
-  // write a export function to compute the adapter to use 
-  // for a given withdraw/deposit action. It can be one or more adapters.
-  // Key decision factors:
-  // 1. The netAPY of the adapter is low compared to others (exhaust this first before using others)
-  // 2. Prefer one adapter over multiple adapters
-  static async getAdapterToUse(adapters: BaseAdapter<DepositParams, WithdrawParams>[], isDeposit: boolean, amount: Web3Number): Promise<BaseAdapter<DepositParams, WithdrawParams>[]> {
-    logger.verbose(`${this.name}::getAdapterToUse: adapters: ${JSON.stringify(adapters)}, isDeposit: ${isDeposit}, amount: ${amount.toFixed(9)}`);
-    const netAPYs = await Promise.all(adapters.map(a => a.getNetAPY()));
-    const indexAndNetAPYsArr = netAPYs.map((apy, index) => [index, apy]);
-    logger.verbose(`${this.name}::getAdapterToUse: netAPYs: ${JSON.stringify(netAPYs)}`);
-    // if is deposit
-    if (isDeposit) {
-      // sort apys by descending
-      const sortedNetAPYs = indexAndNetAPYsArr.sort((a, b) => (b[1] || 0) - (a[1] || 0));
-      logger.verbose(`${this.name}::getAdapterToUse: sortedNetAPYs: ${JSON.stringify(sortedNetAPYs)}`);
-
-      // get max depositables 
-      const adaptersToUse: BaseAdapter<DepositParams, WithdrawParams>[] = [];
-      let remainingAmount = amount;
-      for (const [index, _] of sortedNetAPYs) {
-        const adapter = adapters[index];
-        const maxDepositable = await adapter.maxDeposit(amount);
-        if (maxDepositable.amount.gt(0)) {
-          adaptersToUse.push(adapter);
-          remainingAmount = remainingAmount.minus(maxDepositable.amount).minimum(0);
-        }
-
-        if (remainingAmount.lte(0)) {
-          break;
-        }
-      }
-
-      return adaptersToUse;
-    } else {
-      // sort apys by ascending
-      const sortedNetAPYs = indexAndNetAPYsArr.sort((a, b) => (a[1] || 0) - (b[1] || 0));
-      logger.verbose(`${this.name}::getAdapterToUse: sortedNetAPYs: ${JSON.stringify(sortedNetAPYs)}`);
-
-      // get max withdrawables
-      const adaptersToUse: BaseAdapter<DepositParams, WithdrawParams>[] = [];
-      let remainingAmount = amount.abs();
-      for (const [index, _] of sortedNetAPYs) {
-        const adapter = adapters[index];
-        const maxWithdrawable = await adapter.maxWithdraw();
-        logger.verbose(`${this.name}::getAdapterToUse: maxWithdrawable: ${JSON.stringify(maxWithdrawable)}, adapter: ${adapter.name}, remainingAmount: ${remainingAmount}`);
-        if (maxWithdrawable.amount.gt(0)) {
-          adaptersToUse.push(adapter);
-          remainingAmount = remainingAmount.minus(maxWithdrawable.amount).minimum(0);
-        }
-
-        if (remainingAmount.lte(0)) {
-          break;
-        }
-      }
-
-      return adaptersToUse;
-    }
-  }
-}