@strkfarm/sdk 1.1.69 → 2.0.0-dev.1

package/src/strategies/universal-lst-muliplier-strategy.tsx

@@ -1,31 +1,36 @@
-import { FAQ, getNoRiskTags, highlightTextWithLinks, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, TokenInfo } from "@/interfaces";
-import { AUMTypes, getContractDetails, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalManageCall, UniversalStrategy, UniversalStrategySettings } from "./universal-strategy";
+import { FAQ, getMainnetConfig, getNoRiskTags, highlightTextWithLinks, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, TokenInfo, VaultPosition } from "@/interfaces";
+import { AUMTypes, getContractDetails, UNIVERSAL_MANAGE_IDS, UniversalManageCall, UniversalStrategySettings } from "./universal-strategy";
 import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { Global } from "@/global";
-import { ApproveCallParams, AvnuSwapCallParams, CommonAdapter, getVesuSingletonAddress, ManageCall, Swap, VesuAdapter, VesuModifyDelegationCallParams, VesuModifyPositionCallParams, VesuMultiplyCallParams, VesuPools } from "./universal-adapters";
+import { ApproveCallParams, APYType, AvnuSwapCallParams, BaseAdapterConfig, CommonAdapter, ManageCall, PositionInfo, UnusedBalanceAdapter, VesuMultiplyAdapter, VesuPools, VesuSupplyOnlyAdapter } from "./universal-adapters";
 import { AVNU_EXCHANGE } from "./universal-adapters/adapter-utils";
 import { DepegRiskLevel, LiquidationRiskLevel, SmartContractRiskLevel, TechnicalRiskLevel } from "@/interfaces/risks";
-import { AvnuWrapper, EkuboQuoter, ERC20, LSTAPRService, PricerLST } from "@/modules";
+import { AvnuWrapper, EkuboQuoter, ERC20, PricerFromApi, PricerLST } from "@/modules";
 import { assert, logger } from "@/utils";
-import { SingleTokenInfo } from "./base-strategy";
-import { Call, Contract, uint256 } from "starknet";
+import { SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { SVKStrategy } from "./svk-strategy";
+import { Call, uint256 } from "starknet";
 import ERC4626Abi from "@/data/erc4626.abi.json";
-import { HealthFactorMath } from "@/utils/health-factor-math";
-import { findMaxInputWithSlippage } from "@/utils/math-utils";
+import { AdapterOptimizer } from "./universal-adapters/adapter-optimizer";
+import { MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP } from "./vesu-extended-strategy/utils/constants";
+import { VesuExtendedStrategySettings } from "./vesu-extended-strategy/vesu-extended-strategy";
 
 export interface HyperLSTStrategySettings extends UniversalStrategySettings {
   borrowable_assets: TokenInfo[];
   underlyingToken: TokenInfo;
+  quoteAmountToFetchPrice: Web3Number;
+  targetHealthFactor: number;
+  minHealthFactor: number;
+  aumOracle: ContractAddr;
 }
 
-export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
-  
+export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings> extends SVKStrategy<S> {
+
   private quoteAmountToFetchPrice = new Web3Number(1, 18);
   
-  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>) {
+  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>) {
     super(config, pricer, metadata);
-
     const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
     const underlyingToken = this.getLSTUnderlyingTokenInfo();
     if (underlyingToken.address.eq(STRKToken.address)) {
@@ -34,10 +39,15 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
       // else this BTC
       this.quoteAmountToFetchPrice = new Web3Number(0.01, this.asset().decimals);
     }
-  }
 
-  asset() {
-    return this.getVesuSameTokenAdapter().config.collateral;
+    this.metadata.additionalInfo.adapters.forEach(adapter => {
+      adapter.adapter.config.networkConfig = this.config;
+      adapter.adapter.config.pricer = this.pricer;
+      if ((adapter.adapter as VesuMultiplyAdapter).vesuAdapter) {
+        (adapter.adapter as VesuMultiplyAdapter).vesuAdapter.networkConfig = this.config;
+        (adapter.adapter as VesuMultiplyAdapter).vesuAdapter.pricer = this.pricer;
+      }
+    });
   }
 
   getTag() {
@@ -46,376 +56,352 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
   // Vesu adapter with LST and base token match
   getVesuSameTokenAdapter() {
-    const baseAdapter = this.getAdapter(getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, this.metadata.additionalInfo.underlyingToken.symbol)) as VesuAdapter;
-    baseAdapter.networkConfig = this.config;
-    baseAdapter.pricer = this.pricer;
+    const vesuMultipleAdapters = this.getVesuAdapters();
+    console.log(vesuMultipleAdapters.map(adapter => adapter.config.debt.symbol));
+    const baseAdapter = vesuMultipleAdapters.find((adapter) => {
+      return adapter.config.debt.address.eq(this.metadata.additionalInfo.underlyingToken.address);
+    })
+    if (!baseAdapter) {
+      throw new Error(`${this.getTag()}::getVesuSameTokenAdapter: base adapter not found`);
+    }
+    baseAdapter.config.networkConfig = this.config;
+    baseAdapter.config.pricer = this.pricer;
     return baseAdapter;
   }
 
   // only one leg is used
   // todo support lending assets of underlying as well (like if xSTRK looping is not viable, simply supply STRK)
   getVesuAdapters() {
-    const adapters: VesuAdapter[] = [];
-    const baseAdapter = this.getVesuSameTokenAdapter();
-    for (const asset of this.metadata.additionalInfo.borrowable_assets) {
-      const vesuAdapter1 = new VesuAdapter({
-        poolId: baseAdapter.config.poolId,
-        collateral: this.asset(),
-        debt: asset,
-        vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
-        id: ''
-      })
-      vesuAdapter1.pricer = this.pricer;
-      vesuAdapter1.networkConfig = this.config;
-      adapters.push(vesuAdapter1);
-    }
-    return adapters;
-  }
+    const vesuMultipleAdapters = this.metadata.additionalInfo.adapters
+    .filter(adapter => adapter.adapter.name === VesuMultiplyAdapter.name)
+    .map(adapter => adapter.adapter) as VesuMultiplyAdapter[]
 
-  // not applicable for this strategy
-  // No rewards on collateral or borrowing of LST assets
-  protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
-    const lstToken = this.asset();
-    if (lstToken.symbol === 'xSTRK') {
-      return super.getRewardsAUM(prevAum);
+    for (const vesuAdapter of vesuMultipleAdapters) {
+      vesuAdapter.config.pricer = this.pricer;
+      vesuAdapter.config.networkConfig = this.config;
     }
-    return Web3Number.fromWei("0", lstToken.decimals);
-  }
-
-  async getLSTDexPrice() {
-    const ekuboQuoter = new EkuboQuoter(this.config);
-    const lstTokenInfo = this.asset();
-    const lstUnderlyingTokenInfo = this.getLSTUnderlyingTokenInfo();
-    const quote = await ekuboQuoter.getQuote(
-      lstTokenInfo.address.address,
-      lstUnderlyingTokenInfo.address.address,
-      this.quoteAmountToFetchPrice
-    );
-
-    // in Underlying
-    const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
-    const price = outputAmount.toNumber() / this.quoteAmountToFetchPrice.toNumber();
-    logger.verbose(`${this.getTag()}:: LST Dex Price: ${price}`);
-    return price;
+    return vesuMultipleAdapters;
   }
 
 
-  async getAvnuSwapMultiplyCall(params: {
-    isDeposit: boolean,
-    leg1DepositAmount: Web3Number
-  }) {
-    assert(params.isDeposit, 'Only deposit is supported in getAvnuSwapMultiplyCall')
-    // TODO use a varibale for 1.02
-    const maxBorrowableAmounts = await this.getMaxBorrowableAmount({ isAPYComputation: false });
-    const allVesuAdapters = this.getVesuAdapters();
-    let remainingAmount = params.leg1DepositAmount;
-    const lstExRate = await this.getLSTExchangeRate();
-    const baseAssetPrice = await this.pricer.getPrice(this.getLSTUnderlyingTokenInfo().symbol);
-    const lstPrice = baseAssetPrice.price * lstExRate;
-    for (let i = 0; i < maxBorrowableAmounts.maxBorrowables.length; i++) {
-      const maxBorrowable = maxBorrowableAmounts.maxBorrowables[i];
-      const vesuAdapter = allVesuAdapters.find(adapter => adapter.config.debt.address.eq(maxBorrowable.borrowableAsset.address));
-      if (!vesuAdapter) {
-        throw new Error(`${this.getTag()}::getAvnuSwapMultiplyCall: vesuAdapter not found for borrowable asset: ${maxBorrowable.borrowableAsset.symbol}`);
-      }
-      const maxLTV = await vesuAdapter.getLTVConfig(this.config);
-      const debtPrice = await this.pricer.getPrice(maxBorrowable.borrowableAsset.symbol);
-      const maxAmountToDeposit = HealthFactorMath.getMinCollateralRequiredOnLooping(
-        maxBorrowable.amount,
-        debtPrice.price,
-        this.metadata.additionalInfo.targetHealthFactor,
-        maxLTV,
-        lstPrice,
-        this.asset()
-      )
-      const amountToDeposit = remainingAmount.minimum(maxAmountToDeposit);
-      logger.verbose(`${this.getTag()}::getAvnuSwapMultiplyCall::${vesuAdapter.config.debt.symbol}:: remainingAmount: ${remainingAmount}, amountToDeposit: ${amountToDeposit}, depositAmount: ${amountToDeposit}, maxBorrowable: ${maxBorrowable.amount}`);
-      const call = await this._getAvnuDepositSwapLegCall({
-        isDeposit: params.isDeposit,
-        // adjust decimals of debt asset
-        leg1DepositAmount: amountToDeposit,
-        minHF: 1.1, // undo
-        vesuAdapter: vesuAdapter
-      });
-      remainingAmount = remainingAmount.minus(amountToDeposit);
-
-      // return the first possible call because computing all calls at a time
-      // is not efficinet for swaps
-      return {call, vesuAdapter};
-    }
-    throw new Error(`${this.getTag()}::getAvnuSwapMultiplyCall: no calls found`);
-  }
-
-  async _getAvnuDepositSwapLegCall(params: {
-    isDeposit: boolean,
-    leg1DepositAmount: Web3Number, 
-    minHF: number, // e.g. 1.01
-    vesuAdapter: VesuAdapter
-  }) {
-    const { vesuAdapter } = params;
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall params: ${JSON.stringify(params)}`);
-    assert(params.isDeposit, 'Only deposit is supported in _getAvnuDepositSwapLegCall')
-    // add collateral
-    // borrow STRK (e.g.)
-    // approve and swap strk
-    // add collateral again
+  // async getAvnuSwapMultiplyCall(params: {
+  //   isDeposit: boolean,
+  //   leg1DepositAmount: Web3Number
+  // }) {
+  //   assert(params.isDeposit, 'Only deposit is supported in getAvnuSwapMultiplyCall')
+  //   // TODO use a varibale for 1.02
+  //   const maxBorrowableAmounts = await this.getMaxBorrowableAmount({ isAPYComputation: false });
+  //   const allVesuAdapters = this.getVesuAdapters();
+  //   let remainingAmount = params.leg1DepositAmount;
+  //   const lstExRate = await this.getLSTExchangeRate();
+  //   const baseAssetPrice = await this.pricer.getPrice(this.getLSTUnderlyingTokenInfo().symbol);
+  //   const lstPrice = baseAssetPrice.price * lstExRate;
+  //   for (let i = 0; i < maxBorrowableAmounts.maxBorrowables.length; i++) {
+  //     const maxBorrowable = maxBorrowableAmounts.maxBorrowables[i];
+  //     const vesuAdapter = allVesuAdapters.find(adapter => adapter.config.debt.address.eq(maxBorrowable.borrowableAsset.address));
+  //     if (!vesuAdapter) {
+  //       throw new Error(`${this.getTag()}::getAvnuSwapMultiplyCall: vesuAdapter not found for borrowable asset: ${maxBorrowable.borrowableAsset.symbol}`);
+  //     }
+  //     const maxLTV = await vesuAdapter.getLTVConfig(this.config);
+  //     const debtPrice = await this.pricer.getPrice(maxBorrowable.borrowableAsset.symbol);
+  //     const maxAmountToDeposit = HealthFactorMath.getMinCollateralRequiredOnLooping(
+  //       maxBorrowable.amount,
+  //       debtPrice.price,
+  //       this.metadata.additionalInfo.targetHealthFactor,
+  //       maxLTV,
+  //       lstPrice,
+  //       this.asset()
+  //     )
+  //     const amountToDeposit = remainingAmount.minimum(maxAmountToDeposit);
+  //     logger.verbose(`${this.getTag()}::getAvnuSwapMultiplyCall::${vesuAdapter.config.debt.symbol}:: remainingAmount: ${remainingAmount}, amountToDeposit: ${amountToDeposit}, depositAmount: ${amountToDeposit}, maxBorrowable: ${maxBorrowable.amount}`);
+  //     const call = await this._getAvnuDepositSwapLegCall({
+  //       isDeposit: params.isDeposit,
+  //       // adjust decimals of debt asset
+  //       leg1DepositAmount: amountToDeposit,
+  //       minHF: 1.1, // undo
+  //       vesuAdapter: vesuAdapter
+  //     });
+  //     remainingAmount = remainingAmount.minus(amountToDeposit);
+
+  //     // return the first possible call because computing all calls at a time
+  //     // is not efficinet for swaps
+  //     return {call, vesuAdapter};
+  //   }
+  //   throw new Error(`${this.getTag()}::getAvnuSwapMultiplyCall: no calls found`);
+  // }
+
+  // async _getAvnuDepositSwapLegCall(params: {
+  //   isDeposit: boolean,
+  //   leg1DepositAmount: Web3Number, 
+  //   minHF: number, // e.g. 1.01
+  //   vesuAdapter: VesuAdapter
+  // }) {
+  //   const { vesuAdapter } = params;
+  //   logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall params: ${JSON.stringify(params)}`);
+  //   assert(params.isDeposit, 'Only deposit is supported in _getAvnuDepositSwapLegCall')
+  //   // add collateral
+  //   // borrow STRK (e.g.)
+  //   // approve and swap strk
+  //   // add collateral again
 
     
-    const legLTV = await vesuAdapter.getLTVConfig(this.config);
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall legLTV: ${legLTV}`);
-    const existingPositions = await vesuAdapter.getPositions(this.config);
-    const collateralisation = await vesuAdapter.getCollateralization(this.config);
-    const existingCollateralInfo = existingPositions[0];
-    const existingDebtInfo = existingPositions[1];
-    logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
-    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
-
-    // - Prices as seen by Vesu contracts, ideal for HF math
-    // Price 1 is ok as fallback bcz that would relatively price the 
-    // collateral and debt as equal.
-    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
-    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
-    logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
-
-
-    const debtTokenInfo = vesuAdapter.config.debt;
-    let newDepositAmount = params.leg1DepositAmount;
-    const totalCollateral = existingCollateralInfo.amount.plus(params.leg1DepositAmount);
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalCollateral: ${totalCollateral}`);
-    const totalDebtAmount = new Web3Number(
-      totalCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(debtPrice).dividedBy(params.minHF).toString(),
-      debtTokenInfo.decimals
-    );
-    let debtAmount = totalDebtAmount.minus(existingDebtInfo.amount);
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalDebtAmount: ${totalDebtAmount}, initial computed debt: ${debtAmount}`);
-    const maxBorrowable = await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, false);
-
-    // if the debt amount is greater than 0 and the max borrowable amount is 0, skip
-    if (debtAmount.gt(0) && maxBorrowable.amount.eq(0)) {
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall maxBorrowable is 0, skipping`);
-      return undefined;
-    } else if (debtAmount.gt(0) && maxBorrowable.amount.gt(0)) {
-      debtAmount = maxBorrowable.amount.minimum(debtAmount);
-      const newDebtUSDValue = debtAmount.multipliedBy(debtPrice);
-      const totalCollateralRequired = HealthFactorMath.getCollateralRequired(
-        debtAmount.plus(existingDebtInfo.amount),
-        debtPrice,
-        params.minHF,
-        legLTV,
-        collateralPrice,
-        this.asset()
-      );
-      newDepositAmount = totalCollateralRequired.minus(existingCollateralInfo.amount);
-      if (newDepositAmount.lt(0)) {
-        throw new Error(`${this.getTag()}::_getAvnuDepositSwapLegCall newDepositAmount is less than 0, newDepositAmount: ${newDepositAmount}, totalCollateralRequired: ${totalCollateralRequired}, existingCollateralInfo.amount: ${existingCollateralInfo.amount}`);
-      }
-      if (newDebtUSDValue.toNumber() < 100) {
-        // too less debt, skip
-        logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newDebtUSDValue is less than 100, skipping`);
-        return undefined;
-      }
-    }
-
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
-    if (debtAmount.lt(0)) {
-      // this is to unwind the position to optimal HF. 
-      const lstDEXPrice = await this.getLSTDexPrice();
-      const debtAmountInLST = debtAmount.abs().dividedBy(lstDEXPrice);
-      const calls = await this.getVesuMultiplyCall({
-        isDeposit: false,
-        leg1DepositAmount: debtAmountInLST
-      })
-      assert(calls.length == 1, `Expected 1 call for unwind, got ${calls.length}`);
-      return calls[0];
-    }
-    console.log(`debtAmount`, debtAmount.toWei(), params.leg1DepositAmount.toWei());
-    const STEP0 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
-    const manage0Info = this.getProofs<ApproveCallParams>(STEP0);
-    const manageCall0 = manage0Info.callConstructor({
-      amount: newDepositAmount
-    });
-    const STEP1 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol);
-    const manage1Info = this.getProofs<VesuModifyPositionCallParams>(STEP1);
-    const manageCall1 = manage1Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
-        collateralAmount: newDepositAmount,
-        isAddCollateral: params.isDeposit,
-        debtAmount: debtAmount,
-        isBorrow: params.isDeposit
-    }));
-
-    console.log(`manageCall1`, manageCall1.call, debtAmount.toWei(), newDepositAmount.toWei());
+  //   const legLTV = await vesuAdapter.getLTVConfig(this.config);
+  //   logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall legLTV: ${legLTV}`);
+  //   const existingPositions = await vesuAdapter.getPositions(this.config);
+  //   const collateralisation = await vesuAdapter.getCollateralization(this.config);
+  //   const existingCollateralInfo = existingPositions[0];
+  //   const existingDebtInfo = existingPositions[1];
+  //   logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+  //   existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+
+  //   // - Prices as seen by Vesu contracts, ideal for HF math
+  //   // Price 1 is ok as fallback bcz that would relatively price the 
+  //   // collateral and debt as equal.
+  //   const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
+  //   const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
+  //   logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+
+
+  //   const debtTokenInfo = vesuAdapter.config.debt;
+  //   let newDepositAmount = params.leg1DepositAmount;
+  //   const totalCollateral = existingCollateralInfo.amount.plus(params.leg1DepositAmount);
+  //   logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalCollateral: ${totalCollateral}`);
+  //   const totalDebtAmount = new Web3Number(
+  //     totalCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(debtPrice).dividedBy(params.minHF).toString(),
+  //     debtTokenInfo.decimals
+  //   );
+  //   let debtAmount = totalDebtAmount.minus(existingDebtInfo.amount);
+  //   logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalDebtAmount: ${totalDebtAmount}, initial computed debt: ${debtAmount}`);
+  //   const maxBorrowable = await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, false);
+
+  //   // if the debt amount is greater than 0 and the max borrowable amount is 0, skip
+  //   if (debtAmount.gt(0) && maxBorrowable.amount.eq(0)) {
+  //     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall maxBorrowable is 0, skipping`);
+  //     return undefined;
+  //   } else if (debtAmount.gt(0) && maxBorrowable.amount.gt(0)) {
+  //     debtAmount = maxBorrowable.amount.minimum(debtAmount);
+  //     const newDebtUSDValue = debtAmount.multipliedBy(debtPrice);
+  //     const totalCollateralRequired = HealthFactorMath.getCollateralRequired(
+  //       debtAmount.plus(existingDebtInfo.amount),
+  //       debtPrice,
+  //       params.minHF,
+  //       legLTV,
+  //       collateralPrice,
+  //       this.asset()
+  //     );
+  //     newDepositAmount = totalCollateralRequired.minus(existingCollateralInfo.amount);
+  //     if (newDepositAmount.lt(0)) {
+  //       throw new Error(`${this.getTag()}::_getAvnuDepositSwapLegCall newDepositAmount is less than 0, newDepositAmount: ${newDepositAmount}, totalCollateralRequired: ${totalCollateralRequired}, existingCollateralInfo.amount: ${existingCollateralInfo.amount}`);
+  //     }
+  //     if (newDebtUSDValue.toNumber() < 100) {
+  //       // too less debt, skip
+  //       logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newDebtUSDValue is less than 100, skipping`);
+  //       return undefined;
+  //     }
+  //   }
+
+  //   logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
+  //   if (debtAmount.lt(0)) {
+  //     // this is to unwind the position to optimal HF. 
+  //     const lstDEXPrice = await this.getLSTDexPrice();
+  //     const debtAmountInLST = debtAmount.abs().dividedBy(lstDEXPrice);
+  //     const calls = await this.getVesuMultiplyCall({
+  //       isDeposit: false,
+  //       leg1DepositAmount: debtAmountInLST
+  //     })
+  //     assert(calls.length == 1, `Expected 1 call for unwind, got ${calls.length}`);
+  //     return calls[0];
+  //   }
+  //   console.log(`debtAmount`, debtAmount.toWei(), params.leg1DepositAmount.toWei());
+  //   const STEP0 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
+  //   const manage0Info = this.getProofs<ApproveCallParams>(STEP0);
+  //   const manageCall0 = manage0Info.callConstructor({
+  //     amount: newDepositAmount
+  //   });
+  //   const STEP1 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol);
+  //   const manage1Info = this.getProofs<VesuModifyPositionCallParams>(STEP1);
+  //   const manageCall1 = manage1Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
+  //       collateralAmount: newDepositAmount,
+  //       isAddCollateral: params.isDeposit,
+  //       debtAmount: debtAmount,
+  //       isBorrow: params.isDeposit
+  //   }));
+
+  //   console.log(`manageCall1`, manageCall1.call, debtAmount.toWei(), newDepositAmount.toWei());
     
-    const proofIds: string[] = [STEP0, STEP1];
-    const manageCalls: ManageCall[] = [manageCall0, manageCall1];
-
-    // approve and swap to LST using avnu
-    if (debtAmount.gt(0)) {
-      const STEP2 = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT, vesuAdapter.config.debt.symbol);
-      const manage2Info = this.getProofs<ApproveCallParams>(STEP2);
-      const manageCall2 = manage2Info.callConstructor({
-        amount: debtAmount
-      });
-
-      const debtTokenInfo = vesuAdapter.config.debt;
-      const lstTokenInfo = this.asset();
-      const avnuModule = new AvnuWrapper();
-      const quote = await avnuModule.getQuotes(
-        debtTokenInfo.address.address,
-        lstTokenInfo.address.address,
-        debtAmount.toWei(),
-        this.metadata.additionalInfo.vaultAllocator.address
-      );
-      const minAmount = await this._getMinOutputAmountLSTBuy(debtAmount);
-      const minAmountWei = (minAmount).toWei();
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall minAmount: ${minAmount}`);
-      const swapInfo = await avnuModule.getSwapInfo(
-        quote, 
-        this.metadata.additionalInfo.vaultAllocator.address, 
-        0, 
-        this.address.address,
-        minAmountWei
-      );
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall swapInfo: ${JSON.stringify(swapInfo)}`);
-      const STEP3 = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT, vesuAdapter.config.debt.symbol);
-      const manage3Info = this.getProofs<AvnuSwapCallParams>(STEP3);
-      const manageCall3 = manage3Info.callConstructor({
-        props: swapInfo
-      });
-      proofIds.push(STEP2);
-      proofIds.push(STEP3);
-      manageCalls.push(manageCall2, manageCall3);
-
-
-      // if the created debt, when added is collateral will put the total HF above min, but below (target + 0.05),
-      // then lets close the looping cycle by adding this as collateral. 
-      const newCollateral = minAmount.plus(totalCollateral);
-      const newHF = newCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(totalDebtAmount).dividedBy(debtPrice).toNumber();
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF: ${newHF}`);
-      if (newHF > this.metadata.additionalInfo.minHealthFactor && newHF < this.metadata.additionalInfo.targetHealthFactor + 0.05) {
-        logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF is above min and below target + 0.05, adding collateral on vesu`);
-        // approve and add collateral on vesu (modify position)
-        const STEP4 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
-        const manage4Info = this.getProofs<ApproveCallParams>(STEP4);
-        const manageCall4 = manage4Info.callConstructor({
-          amount: minAmount
-        });
+  //   const proofIds: string[] = [STEP0, STEP1];
+  //   const manageCalls: ManageCall[] = [manageCall0, manageCall1];
+
+  //   // approve and swap to LST using avnu
+  //   if (debtAmount.gt(0)) {
+  //     const STEP2 = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT, vesuAdapter.config.debt.symbol);
+  //     const manage2Info = this.getProofs<ApproveCallParams>(STEP2);
+  //     const manageCall2 = manage2Info.callConstructor({
+  //       amount: debtAmount
+  //     });
+
+  //     const debtTokenInfo = vesuAdapter.config.debt;
+  //     const lstTokenInfo = this.asset();
+  //     const avnuModule = new AvnuWrapper();
+  //     const quote = await avnuModule.getQuotes(
+  //       debtTokenInfo.address.address,
+  //       lstTokenInfo.address.address,
+  //       debtAmount.toWei(),
+  //       this.metadata.additionalInfo.vaultAllocator.address
+  //     );
+  //     const minAmount = await this._getMinOutputAmountLSTBuy(debtAmount);
+  //     const minAmountWei = (minAmount).toWei();
+  //     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall minAmount: ${minAmount}`);
+  //     const swapInfo = await avnuModule.getSwapInfo(
+  //       quote, 
+  //       this.metadata.additionalInfo.vaultAllocator.address, 
+  //       0, 
+  //       this.address.address,
+  //       minAmountWei
+  //     );
+  //     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall swapInfo: ${JSON.stringify(swapInfo)}`);
+  //     const STEP3 = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT, vesuAdapter.config.debt.symbol);
+  //     const manage3Info = this.getProofs<AvnuSwapCallParams>(STEP3);
+  //     const manageCall3 = manage3Info.callConstructor({
+  //       props: swapInfo
+  //     });
+  //     proofIds.push(STEP2);
+  //     proofIds.push(STEP3);
+  //     manageCalls.push(manageCall2, manageCall3);
+
+
+  //     // if the created debt, when added is collateral will put the total HF above min, but below (target + 0.05),
+  //     // then lets close the looping cycle by adding this as collateral. 
+  //     const newCollateral = minAmount.plus(totalCollateral);
+  //     const newHF = newCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(totalDebtAmount).dividedBy(debtPrice).toNumber();
+  //     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF: ${newHF}`);
+  //     if (newHF > this.metadata.additionalInfo.minHealthFactor && newHF < this.metadata.additionalInfo.targetHealthFactor + 0.05) {
+  //       logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF is above min and below target + 0.05, adding collateral on vesu`);
+  //       // approve and add collateral on vesu (modify position)
+  //       const STEP4 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
+  //       const manage4Info = this.getProofs<ApproveCallParams>(STEP4);
+  //       const manageCall4 = manage4Info.callConstructor({
+  //         amount: minAmount
+  //       });
        
-        const STEP5 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol);
-        const manage5Info = this.getProofs<VesuModifyPositionCallParams>(STEP5);
-        const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
-          collateralAmount: minAmount,
-          isAddCollateral: true,
-          debtAmount: Web3Number.fromWei('0', this.asset().decimals),
-          isBorrow: params.isDeposit
-        }));
-        proofIds.push(STEP4, STEP5);
-        manageCalls.push(manageCall4, manageCall5);
-      }
-    }
-
-    const manageCall = this.getManageCall(proofIds, manageCalls);
-    return manageCall;
-  }
+  //       const STEP5 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol);
+  //       const manage5Info = this.getProofs<VesuModifyPositionCallParams>(STEP5);
+  //       const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
+  //         collateralAmount: minAmount,
+  //         isAddCollateral: true,
+  //         debtAmount: Web3Number.fromWei('0', this.asset().decimals),
+  //         isBorrow: params.isDeposit
+  //       }));
+  //       proofIds.push(STEP4, STEP5);
+  //       manageCalls.push(manageCall4, manageCall5);
+  //     }
+  //   }
+
+  //   const manageCall = this.getManageCall(proofIds, manageCalls);
+  //   return manageCall;
+  // }
 
   // todo unwind or not deposit when the yield is bad. 
 
-  async getLSTMultiplierRebalanceCall(): Promise<{ shouldRebalance: boolean, manageCalls: {vesuAdapter: VesuAdapter, manageCall: Call}[] }> {
-    let shouldRebalance = false;
-    const calls: {vesuAdapter: VesuAdapter, manageCall: Call}[] = [];
-    // todo undo
-    const allVesuAdapters = this.getVesuAdapters().filter(vesuAdapter => vesuAdapter.config.debt.symbol === 'LBTC');
-    for (const vesuAdapter of allVesuAdapters) {
-      const call = await this._getLSTMultiplierRebalanceCall(vesuAdapter);
-      if (call.shouldRebalance && call.manageCall) {
-        shouldRebalance = true;
-        calls.push({vesuAdapter, manageCall: call.manageCall});
-      }
-    }
-    return { shouldRebalance, manageCalls: calls };
-  }
-
-  async _getLSTMultiplierRebalanceCall(vesuAdapter: VesuAdapter): Promise<{ shouldRebalance: boolean, manageCall: Call | undefined }> {
-    const positions = await vesuAdapter.getPositions(this.config);
-    assert(positions.length == 2, 'Rebalance call is only supported for 2 positions');
-    const existingCollateralInfo = positions[0];
-    const existingDebtInfo = positions[1];
-    const unusedBalance = await this.getUnusedBalance();
-    const healthFactor = await vesuAdapter.getHealthFactor();
-
-    const collateralisation = await vesuAdapter.getCollateralization(this.config);
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall::${vesuAdapter.config.debt.symbol} existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
-    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
-
-    // - Prices as seen by Vesu contracts, ideal for HF math
-    // Price 1 is ok as fallback bcz that would relatively price the 
-    // collateral and debt as equal.
-    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
-    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall healthFactor: ${healthFactor}`);
-
-    const isHFTooLow = healthFactor < this.metadata.additionalInfo.minHealthFactor;
-    const isHFTooHigh = healthFactor > this.metadata.additionalInfo.targetHealthFactor + 0.05;
-    if (isHFTooLow || isHFTooHigh || 1) {
-      // use unused collateral to target more. 
-      const manageCall = await this._getAvnuDepositSwapLegCall({
-        isDeposit: true,
-        leg1DepositAmount: unusedBalance.amount,
-        minHF: 1.02, // todo, shouldnt use this 1.02 HF, if there isn;t more looping left. 
-        vesuAdapter
-      })
-      return { shouldRebalance: true, manageCall };
-    } else {
-      // do nothing
-      return { shouldRebalance: false, manageCall: undefined };
-    }
-  }
-
-  protected async getVesuAUM(adapter: VesuAdapter) {
-    const legAUM = await adapter.getPositions(this.config);
-    const underlying = this.asset();
-    // assert its an LST of Endur
-    assert(underlying.symbol.startsWith('x'), 'Underlying is not an LST of Endur');
-
-    let vesuAum = Web3Number.fromWei("0", underlying.decimals);
+  // async getLSTMultiplierRebalanceCall(): Promise<{ shouldRebalance: boolean, manageCalls: {vesuAdapter: VesuAdapter, manageCall: Call}[] }> {
+  //   let shouldRebalance = false;
+  //   const calls: {vesuAdapter: VesuAdapter, manageCall: Call}[] = [];
+  //   // todo undo
+  //   const allVesuAdapters = this.getVesuAdapters().filter(vesuAdapter => vesuAdapter.config.debt.symbol === 'LBTC');
+  //   for (const vesuAdapter of allVesuAdapters) {
+  //     const call = await this._getLSTMultiplierRebalanceCall(vesuAdapter);
+  //     if (call.shouldRebalance && call.manageCall) {
+  //       shouldRebalance = true;
+  //       calls.push({vesuAdapter, manageCall: call.manageCall});
+  //     }
+  //   }
+  //   return { shouldRebalance, manageCalls: calls };
+  // }
+
+  // async _getLSTMultiplierRebalanceCall(vesuAdapter: VesuAdapter): Promise<{ shouldRebalance: boolean, manageCall: Call | undefined }> {
+  //   const positions = await vesuAdapter.getPositions(this.config);
+  //   assert(positions.length == 2, 'Rebalance call is only supported for 2 positions');
+  //   const existingCollateralInfo = positions[0];
+  //   const existingDebtInfo = positions[1];
+  //   const unusedBalance = await this.getUnusedBalance();
+  //   const healthFactor = await vesuAdapter.getHealthFactor();
+
+  //   const collateralisation = await vesuAdapter.getCollateralization(this.config);
+  //   logger.debug(`${this.getTag()}::getVesuMultiplyCall::${vesuAdapter.config.debt.symbol} existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+  //   existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+
+  //   // - Prices as seen by Vesu contracts, ideal for HF math
+  //   // Price 1 is ok as fallback bcz that would relatively price the 
+  //   // collateral and debt as equal.
+  //   const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
+  //   const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
+  //   logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+  //   logger.debug(`${this.getTag()}::getVesuMultiplyCall healthFactor: ${healthFactor}`);
+
+  //   const isHFTooLow = healthFactor < this.metadata.additionalInfo.minHealthFactor;
+  //   const isHFTooHigh = healthFactor > this.metadata.additionalInfo.targetHealthFactor + 0.05;
+  //   if (isHFTooLow || isHFTooHigh || 1) {
+  //     // use unused collateral to target more. 
+  //     const manageCall = await this._getAvnuDepositSwapLegCall({
+  //       isDeposit: true,
+  //       leg1DepositAmount: unusedBalance.amount,
+  //       minHF: 1.02, // todo, shouldnt use this 1.02 HF, if there isn;t more looping left. 
+  //       vesuAdapter
+  //     })
+  //     return { shouldRebalance: true, manageCall };
+  //   } else {
+  //     // do nothing
+  //     return { shouldRebalance: false, manageCall: undefined };
+  //   }
+  // }
+
+  // protected async getVesuAUM(adapter: VesuAdapter) {
+  //   const legAUM = await adapter.getPositions(this.config);
+  //   const underlying = this.asset();
+  //   // assert its an LST of Endur
+  //   assert(underlying.symbol.startsWith('x'), 'Underlying is not an LST of Endur');
+
+  //   let vesuAum = Web3Number.fromWei("0", underlying.decimals);
     
-    let tokenUnderlyingPrice = await this.getLSTExchangeRate();
-    // to offset for usual DEX lag, we multiply by 0.998 (i.e. 0.2% loss)
-    tokenUnderlyingPrice = tokenUnderlyingPrice * 0.998;
-    logger.verbose(`${this.getTag()} tokenUnderlyingPrice: ${tokenUnderlyingPrice}`);
+  //   let tokenUnderlyingPrice = await this.getLSTExchangeRate();
+  //   // to offset for usual DEX lag, we multiply by 0.998 (i.e. 0.2% loss)
+  //   tokenUnderlyingPrice = tokenUnderlyingPrice * 0.998;
+  //   logger.verbose(`${this.getTag()} tokenUnderlyingPrice: ${tokenUnderlyingPrice}`);
     
-    // handle collateral
-    if (legAUM[0].token.address.eq(underlying.address)) {
-      vesuAum = vesuAum.plus(legAUM[0].amount);
-    } else {
-      vesuAum = vesuAum.plus(legAUM[0].amount.dividedBy(tokenUnderlyingPrice));
-    }
+  //   // handle collateral
+  //   if (legAUM[0].token.address.eq(underlying.address)) {
+  //     vesuAum = vesuAum.plus(legAUM[0].amount);
+  //   } else {
+  //     vesuAum = vesuAum.plus(legAUM[0].amount.dividedBy(tokenUnderlyingPrice));
+  //   }
+
+  //   // handle debt
+  //   if (legAUM[1].token.address.eq(underlying.address)) {
+  //     vesuAum = vesuAum.minus(legAUM[1].amount);
+  //   } else {
+  //     vesuAum = vesuAum.minus(legAUM[1].amount.dividedBy(tokenUnderlyingPrice));
+  //   };
+
+  //   logger.verbose(`${this.getTag()} Vesu AUM: ${vesuAum}, legCollateral: ${legAUM[0].amount.toNumber()}, legDebt: ${legAUM[1].amount.toNumber()}`);
+  //   return vesuAum;
+  // }
 
-    // handle debt
-    if (legAUM[1].token.address.eq(underlying.address)) {
-      vesuAum = vesuAum.minus(legAUM[1].amount);
-    } else {
-      vesuAum = vesuAum.minus(legAUM[1].amount.dividedBy(tokenUnderlyingPrice));
-    };
+  //
+  // private async _getMinOutputAmountLSTBuy(amountInUnderlying: Web3Number) {
+  //   const lstTruePrice = await this.getLSTExchangeRate();
+  //   // during buy, the purchase should always be <= true LST price. 
+  //   const minOutputAmount = amountInUnderlying.dividedBy(lstTruePrice).multipliedBy(0.99979); // minus 0.021% to account for avnu fees
+  //   return new Web3Number(minOutputAmount.toString(), this.asset().decimals);
+  // }
 
-    logger.verbose(`${this.getTag()} Vesu AUM: ${vesuAum}, legCollateral: ${legAUM[0].amount.toNumber()}, legDebt: ${legAUM[1].amount.toNumber()}`);
-    return vesuAum;
-  }
+  // private async _getMinOutputAmountLSTSell(amountInLST: Web3Number) {
+  //   const lstTruePrice = await this.getLSTExchangeRate();
+  //   // during sell, the purchase should always be > 0.995 * true LST price. 
+  //   const minOutputAmount = amountInLST.multipliedBy(lstTruePrice).multipliedBy(0.995);
+  //   return minOutputAmount;
+  // }
 
-  //
-  private async _getMinOutputAmountLSTBuy(amountInUnderlying: Web3Number) {
-    const lstTruePrice = await this.getLSTExchangeRate();
-    // during buy, the purchase should always be <= true LST price. 
-    const minOutputAmount = amountInUnderlying.dividedBy(lstTruePrice).multipliedBy(0.99979); // minus 0.021% to account for avnu fees
-    return new Web3Number(minOutputAmount.toString(), this.asset().decimals);
-  }
 
-  private async _getMinOutputAmountLSTSell(amountInLST: Web3Number) {
-    const lstTruePrice = await this.getLSTExchangeRate();
-    // during sell, the purchase should always be > 0.995 * true LST price. 
-    const minOutputAmount = amountInLST.multipliedBy(lstTruePrice).multipliedBy(0.995);
-    return minOutputAmount;
-  }
 
   // todo add a function to findout max borrowable amount without fucking yield
   // if the current net yield < LST yield, add a function to calculate how much to unwind. 
@@ -425,376 +411,275 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
    * Deposit amount is in LST
    * @param params 
    */
-  async getVesuMultiplyCall(params: {
+  async getFundManagementCall(params: {
     isDeposit: boolean,
-    leg1DepositAmount: Web3Number,
-    maxEkuboPriceImpact?: number
+    leg1DepositAmount: Web3Number
   }) {
-    const maxEkuboPriceImpact = params.maxEkuboPriceImpact || 0.01;
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
-    const legLTV = await vesuAdapter1.getLTVConfig(this.config);
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
-
+    logger.verbose(`${this.getTag()}::getFundManagementCall params: ${JSON.stringify(params)}`);
+    // const legLTV = await vesuAdapter1.getLTVConfig(this.config);
+    // logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
+    const allAdapters = this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter);
     if (!params.isDeposit) {
       // try using unused balance to unwind. 
       // no need to unwind. 
       const unusedBalance = await this.getUnusedBalance();
       logger.verbose(`${this.getTag()}::getVesuMultiplyCall unusedBalance: ${unusedBalance.amount.toString()}, required: ${params.leg1DepositAmount.toString()}`);
-      // undo
-      // if (unusedBalance.amount.gte(params.leg1DepositAmount)) {
-      //   return [];
-      // }
-      // throw new Error('Unused balance is less than the amount to unwind');
+      if (unusedBalance.amount.gte(params.leg1DepositAmount)) {
+        return null;
+      } else {
+        const adapters = await AdapterOptimizer.getAdapterToUse(allAdapters, false, params.leg1DepositAmount);
+        if (adapters.length > 0) {
+          const proofsInfo = adapters.map(adapter => adapter.getProofs(false, this.getMerkleTree()));
+          const calls: Call[] = [];
+          for (const info of proofsInfo) {
+            const proofGroups = info.proofs;
+            const call = this.getManageCall(proofGroups, await info.callConstructor({amount: params.leg1DepositAmount}));
+            calls.push(call);
+          }
+          return calls;
+        } else {
+          throw new Error(`${this.getTag()}::getVesuMultiplyCall: no adapters to use for unused balance: ${unusedBalance.amount.toString()}`);
+        }
+      }
     }
 
-    const existingPositions = await vesuAdapter1.getPositions(this.config);
-    const collateralisation = await vesuAdapter1.getCollateralization(this.config);
-    const existingCollateralInfo = existingPositions[0];
-    const existingDebtInfo = existingPositions[1];
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
-    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
-
-    // - Prices as seen by Vesu contracts, ideal for HF math
-    // Price 1 is ok as fallback bcz that would relatively price the 
-    // collateral and debt as equal.
-    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
-    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
-
-    // - Prices as seen by actual swap price
-    const dexPrice = await this.getLSTDexPrice();
-
-    // compute optimal amount of collateral and debt post addition/removal
-    // target hf = collateral * collateralPrice * ltv / debt * debtPrice
-    // assuming X to be the usd amount of debt borrowed or repaied (negative). 
-    // target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv / (debt * debtPrice + X)
-    // => X * target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv - (debt * debtPrice * target hf)
-    // => X * (target hf - ltv)= ((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)
-    // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
-    const addedCollateral = params.leg1DepositAmount
-      .multipliedBy(params.isDeposit ? 1 : -1)
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
-    const numeratorPart1 = (existingCollateralInfo.amount.plus((addedCollateral))).multipliedBy(collateralPrice).multipliedBy(legLTV);
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`);
-    const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.metadata.additionalInfo.targetHealthFactor);
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`);
-    const denominatorPart = this.metadata.additionalInfo.targetHealthFactor - (legLTV / dexPrice);
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`);
-    const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`);
-
-    // both in underlying
-    let debtAmount = x_debt_usd.dividedBy(debtPrice);
-    const marginAmount = addedCollateral;
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
-
-    if (marginAmount.lt(0) && debtAmount.gt(0)) {
-      // if we want to withdraw, but debt can go high, its conflicting between
-      // increasing and reducing lever. and in this case, the HF will go high, 
-      // which is ok. 
-      debtAmount = Web3Number.fromWei(0, this.asset().decimals);
+    const adapters = await AdapterOptimizer.getAdapterToUse(allAdapters, true, params.leg1DepositAmount);
+    if (adapters.length > 0) {
+      const proofsInfo = adapters.map(adapter => adapter.getProofs(true, this.getMerkleTree()));
+      const calls: Call[] = [];
+      for (const info of proofsInfo) {
+        const proofGroups = info.proofs;
+        const call = this.getManageCall(proofGroups, await info.callConstructor({amount: params.leg1DepositAmount}));
+        calls.push(call);
+      }
+      return calls;
+    } else {
+      throw new Error(`${this.getTag()}::getVesuMultiplyCall: no adapters to use for deposit: ${params.leg1DepositAmount.toString()}`);
     }
 
-    // Cases of lever increase (within the scopr of this function)
-    // 1. debtAmount > 0 and marginAmount > 0
-    // 2. debtAmount > 0 and marginAmount < 0
-
-    // Cases of lever decrease
-    // 3. debtAmount < 0 and marginAmount > 0
-    // 4. debtAmount < 0 and marginAmount < 0
-    return this.getModifyLeverCall({
-      marginAmount,
-      debtAmount,
-      lstDexPriceInUnderlying: dexPrice,
-      isIncrease: debtAmount.greaterThan(0),
-      maxEkuboPriceImpact
-    });
+    // const existingPositions = await vesuAdapter1.getPositions(this.config);
+    // const collateralisation = await vesuAdapter1.getCollateralization(this.config);
+    // const existingCollateralInfo = existingPositions[0];
+    // const existingDebtInfo = existingPositions[1];
+    // logger.debug(`${this.getTag()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+    // existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+
+    // // - Prices as seen by Vesu contracts, ideal for HF math
+    // // Price 1 is ok as fallback bcz that would relatively price the 
+    // // collateral and debt as equal.
+    // const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
+    // const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
+    // logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+
+    // // - Prices as seen by actual swap price
+    // const dexPrice = await this.getLSTDexPrice();
+
+    // // compute optimal amount of collateral and debt post addition/removal
+    // // target hf = collateral * collateralPrice * ltv / debt * debtPrice
+    // // assuming X to be the usd amount of debt borrowed or repaied (negative). 
+    // // target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv / (debt * debtPrice + X)
+    // // => X * target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv - (debt * debtPrice * target hf)
+    // // => X * (target hf - ltv)= ((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)
+    // // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
+    // const addedCollateral = params.leg1DepositAmount
+    //   .multipliedBy(params.isDeposit ? 1 : -1)
+    // logger.verbose(`${this.getTag()}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
+    // const numeratorPart1 = (existingCollateralInfo.amount.plus((addedCollateral))).multipliedBy(collateralPrice).multipliedBy(legLTV);
+    // logger.verbose(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`);
+    // const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.metadata.additionalInfo.targetHealthFactor);
+    // logger.verbose(`${this.getTag()}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`);
+    // const denominatorPart = this.metadata.additionalInfo.targetHealthFactor - (legLTV / dexPrice);
+    // logger.verbose(`${this.getTag()}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`);
+    // const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
+    // logger.verbose(`${this.getTag()}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
+    // logger.debug(`${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`);
+
+    // // both in underlying
+    // const debtAmount = x_debt_usd.dividedBy(debtPrice);
+    // const marginAmount = addedCollateral;
+    // logger.verbose(`${this.getTag()}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
+
+    // // Cases of lever increase (within the scopr of this function)
+    // // 1. debtAmount > 0 and marginAmount > 0
+    // // 2. debtAmount > 0 and marginAmount < 0
+
+    // // Cases of lever decrease
+    // // 3. debtAmount < 0 and marginAmount > 0
+    // // 4. debtAmount < 0 and marginAmount < 0
+    // return this.getModifyLeverCall({
+    //   marginAmount,
+    //   debtAmount,
+    //   lstDexPriceInUnderlying: dexPrice,
+    //   isIncrease: debtAmount.greaterThan(0)
+    // });
   }
 
+
   getLSTUnderlyingTokenInfo() {
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
-    return vesuAdapter1.config.debt;
+    return this.metadata.additionalInfo.underlyingToken;
   }
 
-  async getMaxBorrowableAmount(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
-    const vesuAdapters = this.getVesuAdapters();
-    let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
-    const maxBorrowables: {amount: Web3Number, dexSwappableAmount: Web3Number, maxBorrowableAmount: Web3Number, borrowableAsset: TokenInfo}[] = [];
-    for (const vesuAdapter of vesuAdapters) {
-      maxBorrowables.push(await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, params.isAPYComputation));
-    }
-    maxBorrowables.sort((a, b) => b.amount.toNumber() - a.amount.toNumber());
-    netMaxBorrowableAmount = maxBorrowables.reduce((acc, curr) => acc.plus(curr.amount), Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals));
-    return {netMaxBorrowableAmount, maxBorrowables};
-  }
+  // async getMaxBorrowableAmount(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
+  //   const vesuAdapters = this.getVesuAdapters();
+  //   let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
+  //   const maxBorrowables: {amount: Web3Number, dexSwappableAmount: Web3Number, maxBorrowableAmount: Web3Number, borrowableAsset: TokenInfo}[] = [];
+  //   for (const vesuAdapter of vesuAdapters) {
+  //     maxBorrowables.push(await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, params.isAPYComputation));
+  //   }
+  //   maxBorrowables.sort((a, b) => b.amount.toNumber() - a.amount.toNumber());
+  //   netMaxBorrowableAmount = maxBorrowables.reduce((acc, curr) => acc.plus(curr.amount), Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals));
+  //   return {netMaxBorrowableAmount, maxBorrowables};
+  // }
 
   // recursively, using binary search computes max swappable. 
   // @dev assumes 1 token of from == 1 token of to
-  async getMaxSwappableWithMaxSlippage(fromToken: TokenInfo, toToken: TokenInfo, maxSlippage: number, maxAmount: Web3Number) {
-    const output = await findMaxInputWithSlippage({
-      apiGetOutput: async (inputAmount: number): Promise<number> => {
-        const ekuboQuoter = new EkuboQuoter(this.config);
-        await new Promise(resolve => setTimeout(resolve, 1000)); // artificial delay, to avoid rate limit
-        const quote = await ekuboQuoter.getQuote(fromToken.address.address, toToken.address.address, new Web3Number(inputAmount.toFixed(9), fromToken.decimals));
-        return Web3Number.fromWei(quote.total_calculated.toString(), toToken.decimals).toNumber();
-      },
-      maxInput: maxAmount.toNumber(),
-      maxSlippagePercent: maxSlippage,
-      tolerance: 0.001,
-      referenceRate: 1,
-    });
-    return new Web3Number(output.optimalInput, fromToken.decimals);
-  }
-
-  async getMaxBorrowableAmountByVesuAdapter(vesuAdapter: VesuAdapter, isAPYComputation: boolean) {
-    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
-    const maxInterestRate = lstAPY * 0.8;
-    const maxBorrowableAmount = await vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxInterestRate);
-    const debtCap = await vesuAdapter.getDebtCap(this.config);
-
-    const maxBorrowable = maxBorrowableAmount.minimum(debtCap).multipliedBy(0.999);
-    // Dont compute precise max swappable for APY computation
-    if (vesuAdapter.config.debt.address.eq(this.getLSTUnderlyingTokenInfo().address) || isAPYComputation) {
-      return {amount: maxBorrowable, dexSwappableAmount: maxBorrowable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
-    }
-    // Want < 0.02% slippage
-    try {
-      const maxSwappable = await this.getMaxSwappableWithMaxSlippage(vesuAdapter.config.debt, this.getLSTUnderlyingTokenInfo(), 0.0002, maxBorrowable);
-      return {amount: maxBorrowable.minimum(maxSwappable), dexSwappableAmount: maxSwappable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
-    } catch (error) {
-      logger.warn(`${this.getTag()}: Failed to get max swappable: ${error}`);
-      const maxSwappable = Web3Number.fromWei("0", vesuAdapter.config.debt.decimals);
-      return {amount: maxBorrowable.minimum(maxSwappable), dexSwappableAmount: maxSwappable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
-    } 
-  }
+  // async getMaxSwappableWithMaxSlippage(fromToken: TokenInfo, toToken: TokenInfo, maxSlippage: number, maxAmount: Web3Number) {
+  //   const output = await findMaxInputWithSlippage({
+  //     apiGetOutput: async (inputAmount: number): Promise<number> => {
+  //       const ekuboQuoter = new EkuboQuoter(this.config);
+  //       await new Promise(resolve => setTimeout(resolve, 1000)); // artificial delay, to avoid rate limit
+  //       const quote = await ekuboQuoter.getQuote(fromToken.address.address, toToken.address.address, new Web3Number(inputAmount.toFixed(9), fromToken.decimals));
+  //       return Web3Number.fromWei(quote.total_calculated.toString(), toToken.decimals).toNumber();
+  //     },
+  //     maxInput: maxAmount.toNumber(),
+  //     maxSlippagePercent: maxSlippage,
+  //     tolerance: 0.001,
+  //     referenceRate: 1,
+  //   });
+  //   return new Web3Number(output.optimalInput, fromToken.decimals);
+  // }
+
+  // async getMaxBorrowableAmountByVesuAdapter(vesuAdapter: VesuAdapter, isAPYComputation: boolean) {
+  //   const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
+  //   const maxInterestRate = lstAPY * 0.8;
+  //   const maxBorrowableAmount = await vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxInterestRate);
+  //   const debtCap = await vesuAdapter.getDebtCap(this.config);
+
+  //   const maxBorrowable = maxBorrowableAmount.minimum(debtCap).multipliedBy(0.999);
+  //   // Dont compute precise max swappable for APY computation
+  //   if (vesuAdapter.config.debt.address.eq(this.getLSTUnderlyingTokenInfo().address) || isAPYComputation) {
+  //     return {amount: maxBorrowable, dexSwappableAmount: maxBorrowable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
+  //   }
+  //   // Want < 0.02% slippage
+  //   try {
+  //     const maxSwappable = await this.getMaxSwappableWithMaxSlippage(vesuAdapter.config.debt, this.getLSTUnderlyingTokenInfo(), 0.0002, maxBorrowable);
+  //     return {amount: maxBorrowable.minimum(maxSwappable), dexSwappableAmount: maxSwappable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
+  //   } catch (error) {
+  //     logger.warn(`${this.getTag()}: Failed to get max swappable: ${error}`);
+  //     const maxSwappable = Web3Number.fromWei("0", vesuAdapter.config.debt.decimals);
+  //     return {amount: maxBorrowable.minimum(maxSwappable), dexSwappableAmount: maxSwappable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
+  //   } 
+  // }
 
   // todo how much to unwind to get back healthy APY zone again
   // if net APY < LST APR + 0.5%, we need to unwind to get back to LST APR + 1% atleast or 0 vesu position
   // For xSTRK, simply deposit in Vesu if looping is not viable 
   
-  /**
-   * Gets LST APR for the strategy's underlying asset from Endur API
-   * @returns Promise<number> The LST APR (not divided by 1e18)
-   */
-  async getLSTAPR(_address: ContractAddr): Promise<number> {
-    try {
-      const vesuAdapter1 = this.getVesuSameTokenAdapter();
-      const apr = await LSTAPRService.getLSTAPR(vesuAdapter1.config.debt.address);
-      if (!apr) {
-        throw new Error('Failed to get LST APR');
-      }
-      return apr;
-    } catch (error) {
-      logger.warn(`${this.getTag()}: Failed to get LST APR: ${error}`);
-      return 0;
-    }
-  }
-
-  // todo undo this
-  async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
-    const unusedBalance = await this.getUnusedBalance();
-    const maxNewDeposits = await this.maxNewDeposits({ isAPYComputation: true });
-    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
-
-    // if unused balance is > max servicable from loan, we are limited by the max borrowing we can do
-    // we also allow accepting little higher deposits (1.5x) to have room for future looping when theres more liquidity or debt cap rises
-    if (maxNewDeposits * 1.5 < unusedBalance.amount.toNumber()) {
-      // we have excess, just use real APY
-      logger.verbose(`${this.getTag()}::netAPY: unused balance is > max servicable from loan, lstAPY: ${lstAPY}`);
-      const output = await super.netAPY();
-      output.splits.push({apy: lstAPY, id: 'lst_apy'});
-      return output;
-    } else {
-      // we have little bit room to accept more deposits, we use theoretical max APY
-      logger.verbose(`${this.getTag()}::netAPY: we can take more deposits, use theoretical max APY`);
-      const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
-      const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
-      const aum = weights.reduce((acc, curr) => acc + curr, 0);
-      const output = await this.returnNetAPY(baseAPYs, rewardAPYs, weights, new Web3Number(aum.toFixed(9), this.getLSTUnderlyingTokenInfo().decimals));
-      output.splits.push({apy: lstAPY, id: 'lst_apy'});
-      return output;
+  // /**
+  //  * Gets LST APR for the strategy's underlying asset from Endur API
+  //  * @returns Promise<number> The LST APR (not divided by 1e18)
+  //  */
+  // async getLSTAPR(_address: ContractAddr): Promise<number> {
+  //   try {
+  //     const vesuAdapter1 = this.getVesuSameTokenAdapter();
+  //     const apr = await LSTAPRService.getLSTAPR(vesuAdapter1.config.debt.address);
+  //     if (!apr) {
+  //       throw new Error('Failed to get LST APR');
+  //     }
+  //     return apr;
+  //   } catch (error) {
+  //     logger.warn(`${this.getTag()}: Failed to get LST APR: ${error}`);
+  //     return 0;
+  //   }
+  // }
+
+  // async maxNewDeposits(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
+  //   const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
+    
+  //   let ltv: number | undefined = undefined;
+  //   for (let adapter of this.getVesuAdapters()) {
+  //     const maxBorrowableAmount = maxBorrowableAmounts.maxBorrowables.find(b => b.borrowableAsset.address.eq(adapter.config.debt.address))?.amount;
+  //     if (!maxBorrowableAmount) {
+  //       throw new Error(`Max borrowable amount not found for adapter: ${adapter.config.debt.symbol}`);
+  //     }
+  //     const maxLTV = await adapter.getLTVConfig(this.config);
+  //     if (!ltv) {
+  //       ltv = maxLTV;
+  //     } else if (ltv != maxLTV) {
+  //       throw new Error(`LTV mismatch for adapter: ${adapter.config.debt.symbol}`);
+  //     }
+  //   }
+  //   if (!ltv) {
+  //     throw new Error('LTV not found');
+  //   }
+  //   // for simplicity, we assume 1 underlying = 1 LST
+  //   const numerator = this.metadata.additionalInfo.targetHealthFactor * maxBorrowableAmounts.netMaxBorrowableAmount.toNumber() / (ltv) 
+  //   return  numerator - maxBorrowableAmounts.netMaxBorrowableAmount.toNumber();
+  // }
+
+  async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[]}> {
+    const allPositions: PositionInfo[] = [];
+    for (let adapter of this.metadata.additionalInfo.adapters) {
+      const positions = await adapter.adapter.getPositions();
+      allPositions.push(...positions);
     }
-  }
 
-  async maxNewDeposits(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
-    const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
-    
-    let ltv: number | undefined = undefined;
-    for (let adapter of this.getVesuAdapters()) {
-      const maxBorrowableAmount = maxBorrowableAmounts.maxBorrowables.find(b => b.borrowableAsset.address.eq(adapter.config.debt.address))?.amount;
-      if (!maxBorrowableAmount) {
-        throw new Error(`Max borrowable amount not found for adapter: ${adapter.config.debt.symbol}`);
+    const assetPrice = await this.pricer.getPrice(this.asset().symbol);
+    let netAUM = new Web3Number(0, this.asset().decimals);
+    for (let position of allPositions) {
+      if (position.tokenInfo.address.eq(this.asset().address)) {
+        netAUM = netAUM.plus(position.amount);
+      } else {
+        netAUM = netAUM.plus(position.usdValue / assetPrice.price);
       }
-      const maxLTV = await adapter.getLTVConfig(this.config);
-      if (!ltv) {
-        ltv = maxLTV;
-      } else if (ltv != maxLTV) {
-        throw new Error(`LTV mismatch for adapter: ${adapter.config.debt.symbol}`);
-      }
-    }
-    if (!ltv) {
-      throw new Error('LTV not found');
     }
-    // for simplicity, we assume 1 underlying = 1 LST
-    const numerator = this.metadata.additionalInfo.targetHealthFactor * maxBorrowableAmounts.netMaxBorrowableAmount.toNumber() / (ltv) 
-    return  numerator - maxBorrowableAmounts.netMaxBorrowableAmount.toNumber();
-  }
 
-  // todo revisit cases where 0th adapters is used
-  protected async getUnusedBalanceAPY() {
-    const unusedBalance = await this.getUnusedBalance();
-    const vesuAdapter = this.getVesuSameTokenAdapter();
-    const underlying = vesuAdapter.config.debt;
-    const lstAPY = await this.getLSTAPR(underlying.address);
-    return {
-      apy: lstAPY, weight: unusedBalance.usdValue
-    }
-  }
+    const prevAum = await this.getPrevAUM();
+    const realAUM: PositionInfo = {
+      tokenInfo: this.asset(),
+      amount: netAUM,
+      usdValue: netAUM.toNumber() * assetPrice.price,
+      apy: {apy: netAUM.toNumber() * assetPrice.price, type: APYType.BASE},
+      remarks: AUMTypes.FINALISED,
+      protocol: Protocols.NONE // just placeholder
+    };
 
-  async getLSTExchangeRate() {
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
-    const lstTokenInfo = vesuAdapter1.config.collateral;
-    const lstABI = new Contract({
-      abi: ERC4626Abi,
-      address: lstTokenInfo.address.address,
-      providerOrAccount: this.config.provider
-    });
+    const estimatedAUMDelta: PositionInfo = {
+      tokenInfo: this.asset(),
+      amount: Web3Number.fromWei('0', this.asset().decimals),
+      usdValue: 0,
+      apy: {apy: 0, type: APYType.BASE},
+      remarks: AUMTypes.DEFISPRING,
+      protocol: Protocols.NONE // just placeholder
+    };
 
-    const price: any = await lstABI.call('convert_to_assets', [uint256.bnToUint256((new Web3Number(1, lstTokenInfo.decimals)).toWei())]);
-    const exchangeRate = Number(uint256.uint256ToBN(price).toString()) / Math.pow(10, lstTokenInfo.decimals);
-    logger.verbose(`${this.getTag()}:: LST Exchange Rate: ${exchangeRate}`);
-    return exchangeRate;
-   }
+    return {net: {
+      tokenInfo: this.asset(),
+      amount: netAUM,
+      usdValue: netAUM.toNumber() * assetPrice.price
+    }, prevAum: prevAum, splits: [realAUM, estimatedAUMDelta]};
+  }
 
   /**
    * 
    * @param params marginAmount is in LST, debtAmount is in underlying
    */
-  async getModifyLeverCall(params: {
-    marginAmount: Web3Number, // >0 during deposit
-    debtAmount: Web3Number,
-    lstDexPriceInUnderlying: number,
-    isIncrease: boolean,
-    maxEkuboPriceImpact: number
-  }): Promise<Call[]> {
-    logger.verbose(`${this.getTag()}::getModifyLeverCall marginAmount: ${params.marginAmount}, debtAmount: ${params.debtAmount}, lstDexPriceInUnderlying: ${params.lstDexPriceInUnderlying}, isIncrease: ${params.isIncrease}`);
-    assert(!params.marginAmount.isZero() || !params.debtAmount.isZero(), 'Deposit/debt must be non-0');
-
-    const vesuAdapter1 = this.getVesuSameTokenAdapter();
-    const lstTokenInfo = this.asset();
-    const lstUnderlyingTokenInfo = vesuAdapter1.config.debt;
-
-    // todo make it more general
-    // 500k STRK (~75k$) or 0.5 BTC (~60k$)
-    const maxAmounts = lstTokenInfo.symbol == 'xSTRK' ? 500000 : 0.5;
-    if (params.marginAmount.greaterThan(maxAmounts)) {
-      throw new Error(`Margin amount is greater than max amount: ${params.marginAmount.toNumber()} > ${maxAmounts}`);
-    }
-
-    const proofsIDs: string[] = [];
-    const manageCalls: ManageCall[] = [];
-
-    // approve token
-    if (params.marginAmount.greaterThan(0)) {
-      const STEP1_ID = LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE;
-      const manage1Info = this.getProofs<ApproveCallParams>(STEP1_ID);
-      const depositAmount = params.marginAmount;
-      const manageCall1 = manage1Info.callConstructor({
-          amount: depositAmount
-      })
-      proofsIDs.push(STEP1_ID);
-      manageCalls.push(manageCall1);
-    }
-
-    const lstDexPriceInUnderlying = params.lstDexPriceInUnderlying;
-    const lstTrueExchangeRate = await this.getLSTExchangeRate();
-    const ekuboQuoter = new EkuboQuoter(this.config);
-
-    // compute quotes for lever swap
-    const MAX_SLIPPAGE = 0.002;
-    // when increasing, debt is swapped to collateral (LST)
-    // when decreasing, collateral is swapped to debt (underlying)
-    // but both cases, we denominate amount in underlying. negative for decrease (exact amount out)
-    const fromToken = params.isIncrease ? lstUnderlyingTokenInfo : lstTokenInfo;
-    const toToken = params.isIncrease ? lstTokenInfo : lstUnderlyingTokenInfo;
-    const leverSwapQuote = await ekuboQuoter.getQuote(
-      fromToken.address.address, 
-      toToken.address.address, 
-      params.debtAmount // negative for exact amount out
-    );
-    logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwapQuote: ${JSON.stringify(leverSwapQuote)}`);
-    // Ekubo's price impact can randomly show high numbers sometimes. 
-    assert(leverSwapQuote.price_impact <= params.maxEkuboPriceImpact, 'getIncreaseLeverCall: Price impact is too high [Debt swap]');
-    const leverSwap = ekuboQuoter.getVesuMultiplyQuote(leverSwapQuote, fromToken, toToken);
-    logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwap: ${JSON.stringify(leverSwap)}`);
-
-    // todo double check this logic
-    // is Deposit
-    let minLSTReceived = params.debtAmount.dividedBy(lstDexPriceInUnderlying).multipliedBy(1 - MAX_SLIPPAGE); // used for increase
-    const minLSTReceivedAsPerTruePrice = params.debtAmount.dividedBy(lstTrueExchangeRate); // execution output to be <= True LST price
-    // if (minLSTReceived < minLSTReceivedAsPerTruePrice) {
-    //   minLSTReceived = minLSTReceivedAsPerTruePrice; // the execution shouldn't be bad than True price logi
-    // }
-    minLSTReceived = minLSTReceivedAsPerTruePrice; // in any case, we are ok with this, bcz the BTC LST spread shouldnt be high
-    logger.verbose(`${this.getTag()}::getModifyLeverCall minLSTReceivedAsPerTruePrice: ${minLSTReceivedAsPerTruePrice}, minLSTReceived: ${minLSTReceived}`);
-
-    // is withdraw
-    let maxUsedCollateral = params.debtAmount.abs().dividedBy(lstDexPriceInUnderlying).multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
-    const maxUsedCollateralInLST = params.debtAmount.abs().dividedBy(lstTrueExchangeRate).multipliedBy(1.005); // 0.5% slippage, worst case based on true price
-    logger.verbose(`${this.getTag()}::getModifyLeverCall maxUsedCollateralInLST: ${maxUsedCollateralInLST}, maxUsedCollateral: ${maxUsedCollateral}`);
-    // if (maxUsedCollateralInLST > maxUsedCollateral) {
-    //   maxUsedCollateral = maxUsedCollateralInLST;
-    // }
-    maxUsedCollateral = maxUsedCollateralInLST; // in any case, we are ok with this, bcz the BTC LST spread shouldnt be high
-
-    const STEP2_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON;
-    const manage2Info = this.getProofs<VesuModifyDelegationCallParams>(STEP2_ID);
-    const manageCall2 = manage2Info.callConstructor({
-      delegation: true
-    });
-
-    // deposit and borrow or repay and withdraw
-    const STEP3_ID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, vesuAdapter1.config.debt.symbol);
-    const manage3Info = this.getProofs<VesuMultiplyCallParams>(STEP3_ID);
-    const multiplyParams: VesuMultiplyCallParams = params.isIncrease ? {
-      isIncrease: true,
-      increaseParams: {
-        add_margin: params.marginAmount,
-        margin_swap: [],
-        margin_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
-        lever_swap: leverSwap,
-        lever_swap_limit_amount: minLSTReceived
-      }
-    } : {
-      isIncrease: false,
-      decreaseParams: {
-        sub_margin: params.marginAmount.multipliedBy(-1),
-        lever_swap: leverSwap,
-        lever_swap_limit_amount: maxUsedCollateral,
-        // only required for close position
-        lever_swap_weights: [],
-        // no need to swap collateral to anything, and any residuals return our contract anyways. 
-        withdraw_swap: [],
-        withdraw_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
-        withdraw_swap_weights: [],
-        close_position: false
-      }
-    }
-    const manageCall3 = manage3Info.callConstructor(multiplyParams);
-
-    // switch delegation off
-    const STEP4_ID = LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF;
-    const manage4Info = this.getProofs<VesuModifyDelegationCallParams>(STEP4_ID);
-    const manageCall4 = manage4Info.callConstructor({
-      delegation: false
-    });
-
-    proofsIDs.push(STEP2_ID, STEP3_ID, STEP4_ID);
-    manageCalls.push(manageCall2, manageCall3, manageCall4);
-
-    return [this.getManageCall(proofsIDs, manageCalls)];
-  }
+  // async getModifyLeverCall(params: {
+  //   marginAmount: Web3Number, // >0 during deposit
+  //   debtAmount: Web3Number,
+  //   lstDexPriceInUnderlying: number,
+  //   isIncrease: boolean
+  // }): Promise<Call[]> {
+  //   logger.verbose(`${this.getTag()}::getModifyLeverCall marginAmount: ${params.marginAmount}, debtAmount: ${params.debtAmount}, lstDexPriceInUnderlying: ${params.lstDexPriceInUnderlying}, isIncrease: ${params.isIncrease}`);
+    
+  //   const vesuAdapter = this.getVesuSameTokenAdapter();
+  //   const manage0Info = vesuAdapter.
+  //   const manageCall0 = manage0Info.callConstructor({
+  //     amount: newDepositAmount
+  //   });
+  //   const manageCalls = await vesu
+  //   return [this.getManageCall(proofsIDs, manageCalls)];
+  // }
 }
 
 export default function VaultDescription(
@@ -831,7 +716,7 @@ export default function VaultDescription(
       </div>
       <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
         <p style={{ fontSize: "13px", color: "#ccc" }}>
-          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited LSTs remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on LST APY, its only on added gain. 
+          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited Tokens remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on Yield token's APY, its only on added gain. 
         </p>
       </div>
       {/* <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
@@ -879,86 +764,72 @@ function getLooperSettings(
   const lstToken = Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!;
   const underlyingToken = Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!;
 
-  const vesuAdapterLST = new VesuAdapter({
-    poolId: pool1,
-    collateral: lstToken,
-    debt: underlyingToken,
+  const baseAdapterConfig: BaseAdapterConfig = {
+    baseToken: lstToken,
+    supportedPositions: [{asset: lstToken, isDebt: false}],
+    networkConfig: getMainnetConfig(),
+    pricer: new PricerFromApi(getMainnetConfig(), Global.getDefaultTokens()),
     vaultAllocator: vaultSettings.vaultAllocator,
-    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol)
+    vaultAddress: vaultSettings.vaultAddress
+  }
+  const vesuAdapterLST = new VesuSupplyOnlyAdapter({
+    // xWBTC vToken on re7 xBTC pool
+    vTokenContract: ContractAddr.from('0x062a162d0827db6f43ebb850cbef3c99fc7969e3070b83a2236c9f3713c89fd8'),
+    ...baseAdapterConfig,
   })
 
+  const vesuMultiplyAdapters = borrowableAssets.map(position => new VesuMultiplyAdapter({
+    poolId: pool1,
+    collateral: lstToken,
+    debt: Global.getDefaultTokens().find(token => token.symbol === position)!,
+    targetHealthFactor: vaultSettings.targetHealthFactor,
+    minHealthFactor: vaultSettings.minHealthFactor,
+    quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
+    ...baseAdapterConfig,
+    supportedPositions: [{asset: lstToken, isDebt: false}, {asset: Global.getDefaultTokens().find(token => token.symbol === position)!, isDebt: true}]
+  }));
+
+  const unusedBalanceAdapter = new UnusedBalanceAdapter({
+    ...baseAdapterConfig,
+  });
+
+  vaultSettings.adapters.push({id: `${vesuAdapterLST.name}_${lstToken.symbol}_${underlyingToken.symbol}`, adapter: vesuAdapterLST});
+  vesuMultiplyAdapters.map(adapter => vaultSettings.adapters.push({id: `${adapter.name}_${lstToken.symbol}_${underlyingToken.symbol}`, adapter: adapter}));
+  vaultSettings.adapters.push({id: `${unusedBalanceAdapter.name}_${lstToken.symbol}`, adapter: unusedBalanceAdapter});
+
   const commonAdapter = new CommonAdapter({
-    manager: vaultSettings.manager,
-    asset: lstToken.address,
-    id: '',
+    id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN,
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator,
+    manager: vaultSettings.manager,
+    asset: lstToken.address
   })
 
-  // Useful for returning adapter class objects that can compute
-  // certain things for us (e.g. positions, hfs)
-  vaultSettings.adapters.push(...[{
-    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol),
-    adapter: vesuAdapterLST
-  },{
-    id: UNIVERSAL_ADAPTERS.COMMON,
-    adapter: commonAdapter
-  }])
-
-  // avnu multiply
-  const { isV2, addr:poolAddr } = getVesuSingletonAddress(pool1);
-  // vesu multiply looping
-  const VESU_MULTIPLY = isV2 ? vesuAdapterLST.VESU_MULTIPLY : vesuAdapterLST.VESU_MULTIPLY_V1;
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, VESU_MULTIPLY, LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON).bind(vesuAdapterLST));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF).bind(vesuAdapterLST));
-
-  // approve lst once to avnu
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, AVNU_EXCHANGE, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_WITHDRAW).bind(commonAdapter));
-  for (let borrowableAsset of vaultSettings.borrowable_assets) {
-    // in-efficient avnu swap looping (but good with endur integration)
-    const debtAsset = borrowableAsset;
-    const approve_debt_token_id = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT, debtAsset.symbol);
-    const swap_debt_token_id = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT, debtAsset.symbol);
-    const swap_lst_token_id = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_WITHDRAW, debtAsset.symbol);
-    vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(debtAsset.address, AVNU_EXCHANGE, approve_debt_token_id).bind(commonAdapter));
-    vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(debtAsset.address, lstToken.address, swap_debt_token_id, false).bind(commonAdapter));
-    vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(lstToken.address, debtAsset.address, swap_lst_token_id, false).bind(commonAdapter));
-
-    // approve LST to add collateral
-    const vesuAdapter = new VesuAdapter({
-      poolId: pool1,
-      collateral: lstToken,
-      debt: debtAsset,
-      vaultAllocator: vaultSettings.vaultAllocator,
-      id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, debtAsset.symbol)
-    });
-    vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, poolAddr, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
-    vaultSettings.leafAdapters.push(vesuAdapter.getModifyPosition.bind(vesuAdapter));
-
-    // Vesu multiply
-    const multiplID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, debtAsset.symbol);
-    vaultSettings.leafAdapters.push(vesuAdapter.getMultiplyAdapter(multiplID).bind(vesuAdapter));
-  }
+  // push vesu adapter to leaf adapters
+  vaultSettings.leafAdapters.push(() => vesuAdapterLST.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => vesuAdapterLST.getWithdrawLeaf());
 
+  // push vesu multiply adapter to leaf adapters
+  vesuMultiplyAdapters.map(adapter => vaultSettings.leafAdapters.push(() => adapter.getDepositLeaf()));
+  vesuMultiplyAdapters.map(adapter => vaultSettings.leafAdapters.push(() => adapter.getWithdrawLeaf()));
   
   // to bridge liquidity back to vault (used by bring_liquidity)
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, vaultSettings.vaultAddress, UNIVERSAL_MANAGE_IDS.APPROVE_BRING_LIQUIDITY).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter(UNIVERSAL_MANAGE_IDS.BRING_LIQUIDITY).bind(commonAdapter));
   
   // claim rewards
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getDefispringRewardsAdapter(UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS).bind(vesuAdapterLST));
+  // vaultSettings.leafAdapters.push(vesuAdapterLST.getDefispringRewardsAdapter(UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS).bind(vesuAdapterLST));
 
-  // avnu swap for claims rewards
-  const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_EXCHANGE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, lstToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS, false).bind(commonAdapter));
+  // // avnu swap for claims rewards
+  // const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
+  // vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_EXCHANGE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
+  // vabaseAdapterConfigultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, lstToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS, false).bind(commonAdapter));
   return vaultSettings;
 }
 
-const AUDIT_URL = 'https://docs.troves.fi/p/security#starknet-vault-kit'
+export const AUDIT_URL = 'https://docs.troves.fi/p/security#starknet-vault-kit'
 
-function getFAQs(lstSymbol: string, underlyingSymbol: string): FAQ[] {
+export function getFAQs(lstSymbol: string, underlyingSymbol: string, isLST: boolean): FAQ[] {
   return [
     {
       question: `What is the Hyper ${lstSymbol} Vault?`,
@@ -972,10 +843,14 @@ function getFAQs(lstSymbol: string, underlyingSymbol: string): FAQ[] {
     },
     {
       question: "Which protocols/dApp are used??",
-      answer: (
+      answer: isLST ? (
         <span>
           Currently, the LST is from <strong>Endur</strong> while <strong>Vesu</strong> is used to collateralize the looped position.
         </span>
+      ) : (
+        <span>
+          Currently, the Yield Token is from <strong>Re7 Labs (Midas)</strong> while <strong>Vesu</strong> is used to collateralize the looped position.
+        </span>
       ),
     },
     {
@@ -993,14 +868,14 @@ function getFAQs(lstSymbol: string, underlyingSymbol: string): FAQ[] {
         "Withdrawals may take up to 1-2 hours to process, as the vault unwinds and settles liquidity routing across integrated protocols. In case of large withdrawals, to avoid slippage, we may slowly unwind the position, which could make the withdrawals longer.",
     },
     {
-      question: "Is the Hyper xSTRK Vault non-custodial?",
+      question: `Is the Hyper ${lstSymbol} Vault non-custodial?`,
       answer:
-        "Yes. The Hyper xSTRK Vault operates entirely on-chain. Users always maintain control of their vault tokens, and the strategy is fully transparent.",
+        `Yes. The Hyper ${lstSymbol} Vault operates entirely on-chain. Users always maintain control of their vault tokens, and the strategy is fully transparent.`,
     },
     {
       question: "Is the Vault audited?",
       answer:
-        "Yes. The Hyper xSTRK Vault is audited by Zellic. Look for safety icon beside the strategy name for more details.",
+        `Yes. The Hyper ${lstSymbol} Vault is audited by Zellic. Look for safety icon beside the strategy name for more details.`,
     },
     {
       question: "Are there any fees?",
@@ -1010,7 +885,7 @@ function getFAQs(lstSymbol: string, underlyingSymbol: string): FAQ[] {
   ];
 }
 
-const _riskFactor: RiskFactor[] = [
+export const _riskFactor: RiskFactor[] = [
   { type: RiskType.SMART_CONTRACT_RISK, value: SmartContractRiskLevel.WELL_AUDITED, weight: 25, reason: "Audited by Zellic" },
   { type: RiskType.LIQUIDATION_RISK, value: LiquidationRiskLevel.VERY_LOW_PROBABILITY, weight: 25, reason: "The collateral and debt are highly correlated" },
   { type: RiskType.TECHNICAL_RISK, value: TechnicalRiskLevel.STABLE_INFRASTRUCTURE, weight: 25, reason: "Liquidation can only happen if vault is left un-monitored for weeks, which is highly unlikely. We actively monitor all services on a daily basis." },
@@ -1033,6 +908,7 @@ const hyperxSTRK: HyperLSTStrategySettings = {
   minHealthFactor: 1.05,
   borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'STRK'),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'STRK')!,
+  quoteAmountToFetchPrice: new Web3Number('100', Global.getDefaultTokens().find(token => token.symbol === 'STRK')!.decimals),
 }
 
 const hyperxWBTC: HyperLSTStrategySettings = {
@@ -1047,6 +923,7 @@ const hyperxWBTC: HyperLSTStrategySettings = {
   minHealthFactor: 1.05,
   borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+  quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!.decimals),
 }
 
 const hyperxtBTC: HyperLSTStrategySettings = {
@@ -1059,8 +936,9 @@ const hyperxtBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'tBTC' || token.symbol === 'WBTC'),
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'tBTC')!,
+  quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'tBTC')!.decimals),
 }
 
 const hyperxsBTC: HyperLSTStrategySettings = {
@@ -1073,8 +951,9 @@ const hyperxsBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'solvBTC'),
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!,
+  quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!.decimals),
 }
 
 const hyperxLBTC: HyperLSTStrategySettings = {
@@ -1087,21 +966,56 @@ const hyperxLBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'LBTC'),
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!,
+  quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!.decimals),
 }
 
-function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
+const hypermRe7BTC: HyperLSTStrategySettings = {
+  vaultAddress: ContractAddr.from('0x6c89b75d09de82477edb86b2c2918cfc1a5dc0177cfbdea46278386b6499645'),
+  manager: ContractAddr.from('0x7bc2d0535e13352d3ab78ea047616a3162068294297304943d2302122a150a1'),
+  vaultAllocator: ContractAddr.from('0x760f9cebca9d2ee624f4224591da6da8b3ea5fd2410590735709551bd4e7570'),
+  redeemRequestNFT: ContractAddr.from('0x5e045ae0160f7650f8a4dd7c826f25630a89fe62434db4441e7e0075608180f'),
+  aumOracle: ContractAddr.from('0x3958df341b838813c24efb9183c23bddd1c57d44b1b86c0dd57f67887b89fba'),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05,
+  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+  quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'mRe7BTC')!.decimals),
+}
+// Contract deployed: Vault, addr: 0x42797ab4eb1f72787442e91a73d63a39e3a141c1106470a946ecc328db6896c
+// Contract deployed: RedeemRequest, addr: 0x4bbb25c2568af07967342833f7db1aece1be1be2330798dab4ee585aa6c2c72
+// Contract deployed: VaultAllocator, addr: 0x456c4c6afca90512aeb5c735d84405fea6e51ab06d1851ac8cdb0a235e14f15
+// Contract deployed: Manager, addr: 0x435b45d40fbb406cf69ac84bb471e7b7a4ea2295d0893c05dd2db565295e77f
+
+const hypermRe7YIELD: HyperLSTStrategySettings = {
+  vaultAddress: ContractAddr.from('0x42797ab4eb1f72787442e91a73d63a39e3a141c1106470a946ecc328db6896c'),
+  manager: ContractAddr.from('0x435b45d40fbb406cf69ac84bb471e7b7a4ea2295d0893c05dd2db565295e77f'),
+  vaultAllocator: ContractAddr.from('0x456c4c6afca90512aeb5c735d84405fea6e51ab06d1851ac8cdb0a235e14f15'),
+  redeemRequestNFT: ContractAddr.from('0x4bbb25c2568af07967342833f7db1aece1be1be2330798dab4ee585aa6c2c72'),
+  aumOracle: ContractAddr.from('0x3e1f2825158cafccc9b42a8165d17ceb6b8e966474d9c63587d338746888382'),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.1,
+  minHealthFactor: 1.05,
+  borrowable_assets: [Global.getDefaultTokens().find(token => token.symbol === 'USDC')!],
+  underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'USDC')!,
+  quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'mRe7BTC')!.decimals),
+}
+
+export function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
   return [
     `Deposit ${lstSymbol} into the vault`,
     `The vault manager loops the ${underlyingSymbol} to buy ${lstSymbol}`,
     `The vault manager collateralizes the ${lstSymbol} on Vesu`,
     `The vault manager borrows more ${underlyingSymbol} to loop further`,
-    `If required, adjust leverage or re-allocate assets within LST pool on Vesu to optimize yield`
+    `If required, adjust leverage or re-allocate assets within pool on Vesu to optimize yield`
   ]
 }
 
-function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: HyperLSTStrategySettings, isPreview: boolean = false): IStrategyMetadata<HyperLSTStrategySettings> {
+function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: HyperLSTStrategySettings, isPreview: boolean = false, isLST: boolean): IStrategyMetadata<HyperLSTStrategySettings> {
   return {
     name: `Hyper ${lstSymbol}`,
     description: getDescription(lstSymbol, underlyingSymbol),
@@ -1121,18 +1035,37 @@ function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addres
     protocols: [Protocols.ENDUR, Protocols.VESU],
     maxTVL: Web3Number.fromWei(0, 18),
     contractDetails: getContractDetails(addresses),
-    faqs: getFAQs(lstSymbol, underlyingSymbol),
+    faqs: getFAQs(lstSymbol, underlyingSymbol, isLST),
     investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
     isPreview: isPreview,
-    apyMethodology: 'Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.'
+    apyMethodology: isLST ? 'Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.' : 'Current annualized APY in terms of base asset of the Yield Token. There is no additional fee taken by Troves on yield token APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.'
   }
 }
 
+
+
+// const hyperxWBTCTest: HyperLSTStrategySettings = {
+//   vaultAddress: ContractAddr.from('0x5535e01a0d0438a888267ba6cd6519a40e653cdfb5dce4af475221d9cf11e63'),
+//   manager: ContractAddr.from('0x3caa816a9d9b55a6621a47c1a7e6773141dd05fb3ca4ec4b774656f360b32a1'),
+//   vaultAllocator: ContractAddr.from('0x3d4f82f8bfa8e5b2f0242c4d8ed87287c9ad5427be8b982a31a0393cf3075d1'),
+//   redeemRequestNFT: ContractAddr.from('0x6190460d0f1fd5d142bd5378d7b3270e70253bdd652d6826175f6c0b1ad4f32'),
+//   aumOracle: ContractAddr.from('0x43f5aa7c67b29b5e69ad03ab427f7613e43350d6ddede481e42e8184f49cb2f'),
+//   leafAdapters: [],
+//   adapters: [],
+//   targetHealthFactor: 1.1,
+//   minHealthFactor: 1.05,
+//   borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+//   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+//   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!.decimals),
+// }
+
 export const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[] =
   [
-    getStrategySettings('xSTRK', 'STRK', hyperxSTRK, false),
-    getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, false),
-    getStrategySettings('xtBTC', 'tBTC', hyperxtBTC, false),
-    getStrategySettings('xsBTC', 'solvBTC', hyperxsBTC, false),
-    getStrategySettings('xLBTC', 'LBTC', hyperxLBTC, false),
+    getStrategySettings('xSTRK', 'STRK', hyperxSTRK, false, true),
+    getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, false, false),
+    getStrategySettings('xtBTC', 'tBTC', hyperxtBTC, false, false),
+    getStrategySettings('xsBTC', 'solvBTC', hyperxsBTC, false, false),
+    getStrategySettings('xLBTC', 'LBTC', hyperxLBTC, false, false),
+    getStrategySettings('mRe7BTC', 'mRe7BTC', hypermRe7BTC, false, false),
+    getStrategySettings('mRe7YIELD', 'mRe7YIELD', hypermRe7YIELD, false, false),
   ]