@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.50

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

@@ -1,51 +1,79 @@
-import { FAQ, getMainnetConfig, getNoRiskTags, highlightTextWithLinks, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, TokenInfo, VaultPosition } from "@/interfaces";
+import { FAQ, getMainnetConfig, getNoRiskTags, highlightTextWithLinks, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, TokenInfo, VaultPosition, StrategyTag, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, StrategySettings, VaultType, RedemptionInfo } 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, APYType, AvnuSwapCallParams, BaseAdapterConfig, CommonAdapter, ManageCall, PositionInfo, UnusedBalanceAdapter, VesuMultiplyAdapter, VesuPools, VesuSupplyOnlyAdapter } from "./universal-adapters";
+import { ApproveCallParams, APYType, AvnuSwapCallParams, BaseAdapterConfig, CommonAdapter, ManageCall, PositionInfo, TokenTransferAdapter, VesuModifyPositionAdapter, VesuMultiplyAdapter, VesuPools, VesuSupplyOnlyAdapter } from "./universal-adapters";
+import { VesuAdapter } from "./universal-adapters/vesu-adapter";
 import { AVNU_EXCHANGE } from "./universal-adapters/adapter-utils";
 import { DepegRiskLevel, LiquidationRiskLevel, SmartContractRiskLevel, TechnicalRiskLevel } from "@/interfaces/risks";
-import { AvnuWrapper, EkuboQuoter, ERC20, PricerFromApi, PricerLST } from "@/modules";
+import { AvnuWrapper, EkuboQuoter, ERC20, LSTAPRService, PricerFromApi, PricerLST } from "@/modules";
 import { assert, logger } from "@/utils";
-import { SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { findMaxInputWithSlippage } from "@/utils/math-utils";
+import { SingleActionAmount, SingleTokenInfo, UserPositionCard, UserPositionCardsInput } from "./base-strategy";
 import { SVKStrategy } from "./svk-strategy";
-import { Call, uint256 } from "starknet";
+import { Call, Contract, num, uint256, BlockIdentifier } from "starknet";
 import ERC4626Abi from "@/data/erc4626.abi.json";
 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";
+import { LSTPriceType } from "./types";
+
+const VESU_MULTIPLY_ADAPTER_ID_PREFIX = "vesu_multiply_";
+const VESU_MODIFY_ADAPTER_ID_PREFIX = "vesu_modify_";
 
 export interface HyperLSTStrategySettings extends UniversalStrategySettings {
-  borrowable_assets: TokenInfo[];
+  borrowable_assets: { tokenInfo: TokenInfo, poolId: ContractAddr }[];
   underlyingToken: TokenInfo;
   quoteAmountToFetchPrice: Web3Number;
   targetHealthFactor: number;
   minHealthFactor: number;
   aumOracle: ContractAddr;
+  adapterIds?: {
+    /** VesuMultiplyAdapter for underlying-matched debt (first matching borrowable pool) */
+    primaryMultiply: string;
+    multiply: Record<string, string>;
+    modify: Record<string, string>;
+  };
+}
+
+function getHyperLSTAdapterKey(debtSymbol: string, poolId: ContractAddr): string {
+  return `${debtSymbol.toLowerCase()}_${poolId.shortString()}`;
+}
+
+function getHyperLSTMultiplyAdapterId(
+  lstSymbol: string,
+  debtSymbol: string,
+  poolId: ContractAddr,
+): string {
+  return `${VESU_MULTIPLY_ADAPTER_ID_PREFIX}${lstSymbol.toLowerCase()}_${getHyperLSTAdapterKey(debtSymbol, poolId)}`;
+}
+
+function getHyperLSTModifyAdapterId(
+  lstSymbol: string,
+  debtSymbol: string,
+  poolId: ContractAddr,
+): string {
+  return `${VESU_MODIFY_ADAPTER_ID_PREFIX}${lstSymbol.toLowerCase()}_${getHyperLSTAdapterKey(debtSymbol, poolId)}`;
 }
 
 export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings> extends SVKStrategy<S> {
 
   private quoteAmountToFetchPrice = new Web3Number(1, 18);
-  
+
   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)) {
-      this.quoteAmountToFetchPrice = new Web3Number(100, 18);
-    } else {
-      // else this BTC
-      this.quoteAmountToFetchPrice = new Web3Number(0.01, this.asset().decimals);
+    if (metadata.additionalInfo.quoteAmountToFetchPrice.isZero()) {
+      throw new Error(`${this.getTag()}::quoteAmountToFetchPrice is zero`);
     }
+    this.quoteAmountToFetchPrice = metadata.additionalInfo.quoteAmountToFetchPrice;
 
     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;
+      if ((adapter.adapter as any)._vesuAdapter) {
+        (adapter.adapter as any)._vesuAdapter.networkConfig = this.config;
+        (adapter.adapter as any)._vesuAdapter.pricer = this.pricer;
       }
     });
   }
@@ -54,13 +82,36 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     return `${UniversalLstMultiplierStrategy.name}:${this.metadata.name}`;
   }
 
-  // Vesu adapter with LST and base token match
-  getVesuSameTokenAdapter() {
-    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);
-    })
+  private getAdapterById<T>(id: string): T {
+    const entry = this.metadata.additionalInfo.adapters.find((a) => a.id === id);
+    if (!entry) {
+      throw new Error(`${this.getTag()}::getAdapterById: adapter not found for id "${id}"`);
+    }
+    return entry.adapter as T;
+  }
+
+  getVesuMultiplyAdapterByKey(key: string): VesuMultiplyAdapter {
+    const id = this.metadata.additionalInfo.adapterIds?.multiply[key];
+    if (!id) {
+      throw new Error(`${this.getTag()}::getVesuMultiplyAdapterByKey: unknown key "${key}"`);
+    }
+    return this.getAdapterById<VesuMultiplyAdapter>(id);
+  }
+
+  // Vesu multiply adapter whose debt matches the LST underlying (e.g. STRK for xSTRK)
+  getVesuSameTokenAdapter(): VesuMultiplyAdapter {
+    const primaryId = this.metadata.additionalInfo.adapterIds?.primaryMultiply;
+    if (primaryId) {
+      const adapter = this.getAdapterById<VesuMultiplyAdapter>(primaryId);
+      adapter.config.networkConfig = this.config;
+      adapter.config.pricer = this.pricer;
+      adapter._vesuAdapter.networkConfig = this.config;
+      adapter._vesuAdapter.pricer = this.pricer;
+      return adapter;
+    }
+    const baseAdapter = this.getVesuMultiplyAdapters().find((adapter) =>
+      adapter.config.debt.address.eq(this.metadata.additionalInfo.underlyingToken.address),
+    );
     if (!baseAdapter) {
       throw new Error(`${this.getTag()}::getVesuSameTokenAdapter: base adapter not found`);
     }
@@ -71,11 +122,15 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
 
   // 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 vesuMultipleAdapters = this.metadata.additionalInfo.adapters
-    .filter(adapter => adapter.adapter.name === VesuMultiplyAdapter.name)
-    .map(adapter => adapter.adapter) as VesuMultiplyAdapter[]
-
+  getVesuMultiplyAdapters() {
+    const multiplyAdapterIds = new Set(Object.values(this.metadata.additionalInfo.adapterIds?.multiply ?? {}));
+    const vesuMultipleAdapterEntries = this.metadata.additionalInfo.adapters
+      .filter((entry) =>
+        multiplyAdapterIds.size > 0
+          ? multiplyAdapterIds.has(entry.id)
+          : entry.id.startsWith(VESU_MULTIPLY_ADAPTER_ID_PREFIX),
+      );
+    const vesuMultipleAdapters = vesuMultipleAdapterEntries.map((entry) => entry.adapter) as VesuMultiplyAdapter[];
     for (const vesuAdapter of vesuMultipleAdapters) {
       vesuAdapter.config.pricer = this.pricer;
       vesuAdapter.config.networkConfig = this.config;
@@ -83,6 +138,82 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     return vesuMultipleAdapters;
   }
 
+  async getRewardsAUM(_prevAum: Web3Number) {
+    const lstToken = this.asset();
+    // Defi spring rewards handling; currently returns 0 as SVKStrategy has no built-in rewards logic
+    return Web3Number.fromWei("0", lstToken.decimals);
+  }
+
+  async getLSTAvnuRate() {
+    const vesuAdapter1 = this.getVesuSameTokenAdapter();
+    const lstTokenInfo = vesuAdapter1._vesuAdapter.config.collateral;
+    const underlyingTokenInfo = vesuAdapter1._vesuAdapter.config.debt;
+
+    const avnuModule = new AvnuWrapper();
+
+    const sellAmount = (lstTokenInfo as any).priceCheckAmount
+      ? new Web3Number(
+        (lstTokenInfo as any).priceCheckAmount,
+        underlyingTokenInfo.decimals,
+      )
+      : new Web3Number(1, underlyingTokenInfo.decimals);
+
+    const quote = await avnuModule.getQuotes(
+      underlyingTokenInfo.address.address,
+      lstTokenInfo.address.address,
+      sellAmount.toWei(),
+      this.metadata.additionalInfo.vaultAllocator.address,
+    );
+
+    const underlyingAmountNumber = sellAmount.toNumber();
+    const lstAmountNumber = Web3Number.fromWei(
+      quote.buyAmount.toString(),
+      lstTokenInfo.decimals,
+    ).toNumber();
+
+    assert(lstAmountNumber > 0, "Avnu LST amount is zero");
+
+    const exchangeRate = underlyingAmountNumber / lstAmountNumber;
+    logger.verbose(
+      `${this.getTag()}:: LST Avnu Exchange Rate: ${exchangeRate}`,
+    );
+    return exchangeRate;
+  }
+
+  async getLSTExchangeRate() {
+    const vesuAdapter1 = this.getVesuSameTokenAdapter();
+    const lstTokenInfo = vesuAdapter1._vesuAdapter.config.collateral;
+    const lstABI = new Contract({
+      abi: ERC4626Abi,
+      address: lstTokenInfo.address.address,
+      providerOrAccount: this.config.provider,
+    });
+
+    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;
+  }
+
+  private async _getMinOutputAmountLSTBuy(amountInUnderlying: Web3Number) {
+    const lstTruePrice = await this.getLSTExchangeRate();
+    const minOutputAmount = amountInUnderlying
+      .dividedBy(lstTruePrice)
+      .multipliedBy(0.99979);
+    return new Web3Number(minOutputAmount.toString(), this.asset().decimals);
+  }
+
+  private async _getMinOutputAmountLSTSell(amountInLST: Web3Number) {
+    const lstTruePrice = await this.getLSTExchangeRate();
+    const minOutputAmount = amountInLST
+      .multipliedBy(lstTruePrice)
+      .multipliedBy(0.995);
+    return minOutputAmount;
+  }
 
   // async getAvnuSwapMultiplyCall(params: {
   //   isDeposit: boolean,
@@ -132,7 +263,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
 
   // async _getAvnuDepositSwapLegCall(params: {
   //   isDeposit: boolean,
-  //   leg1DepositAmount: Web3Number, 
+  //   leg1DepositAmount: Web3Number,
   //   minHF: number, // e.g. 1.01
   //   vesuAdapter: VesuAdapter
   // }) {
@@ -144,18 +275,18 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //   // 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)}, 
+  //   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 
+  //   // 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;
@@ -202,7 +333,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
 
   //   logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
   //   if (debtAmount.lt(0)) {
-  //     // this is to unwind the position to optimal HF. 
+  //     // 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({
@@ -228,7 +359,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //   }));
 
   //   console.log(`manageCall1`, manageCall1.call, debtAmount.toWei(), newDepositAmount.toWei());
-    
+
   //   const proofIds: string[] = [STEP0, STEP1];
   //   const manageCalls: ManageCall[] = [manageCall0, manageCall1];
 
@@ -253,9 +384,9 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //     const minAmountWei = (minAmount).toWei();
   //     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall minAmount: ${minAmount}`);
   //     const swapInfo = await avnuModule.getSwapInfo(
-  //       quote, 
-  //       this.metadata.additionalInfo.vaultAllocator.address, 
-  //       0, 
+  //       quote,
+  //       this.metadata.additionalInfo.vaultAllocator.address,
+  //       0,
   //       this.address.address,
   //       minAmountWei
   //     );
@@ -271,7 +402,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
 
 
   //     // 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. 
+  //     // 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}`);
@@ -283,7 +414,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //       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({
@@ -301,7 +432,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //   return manageCall;
   // }
 
-  // todo unwind or not deposit when the yield is bad. 
+  // todo unwind or not deposit when the yield is bad.
 
   // async getLSTMultiplierRebalanceCall(): Promise<{ shouldRebalance: boolean, manageCalls: {vesuAdapter: VesuAdapter, manageCall: Call}[] }> {
   //   let shouldRebalance = false;
@@ -327,11 +458,11 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //   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)}, 
+  //   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 
+  //   // 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;
@@ -341,11 +472,11 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //   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. 
+  //     // 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. 
+  //       minHF: 1.02, // todo, shouldnt use this 1.02 HF, if there isn;t more looping left.
   //       vesuAdapter
   //     })
   //     return { shouldRebalance: true, manageCall };
@@ -355,61 +486,17 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //   }
   // }
 
-  // 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}`);
-    
-  //   // 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;
-  // }
-
-  //
-  // 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. 
+  // if the current net yield < LST yield, add a function to calculate how much to unwind.
 
   /**
    * Uses vesu's multiple call to create leverage on LST
    * Deposit amount is in LST
-   * @param params 
+   * @param params
    */
   async getFundManagementCall(params: {
     isDeposit: boolean,
@@ -418,268 +505,528 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     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);
+    const multiplyAdapters = this.getVesuMultiplyAdapters();
     if (!params.isDeposit) {
-      // try using unused balance to unwind. 
-      // no need to unwind. 
+      // 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()}`);
       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 adapters = await AdapterOptimizer.getAdapterToUse(allAdapters, true, params.leg1DepositAmount);
+    const adapters = await AdapterOptimizer.getAdapterToUse(multiplyAdapters, params.isDeposit, params.leg1DepositAmount);
     if (adapters.length > 0) {
-      const proofsInfo = adapters.map(adapter => adapter.getProofs(true, this.getMerkleTree()));
+      const proofsInfo = adapters.map(adapter => adapter.getProofs(params.isDeposit, 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}));
+        const manageCalls = await info.callConstructor({ amount: params.leg1DepositAmount });
+        const call = this.getManageCall(this.getProofGroupsForManageCalls(manageCalls), manageCalls);
         calls.push(call);
       }
       return calls;
     } else {
       throw new Error(`${this.getTag()}::getVesuMultiplyCall: no adapters to use for deposit: ${params.leg1DepositAmount.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
-    // 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() {
     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 getLSTAPR(_address: ContractAddr): Promise<number> {
+    try {
+      const apr = await LSTAPRService.getLSTAPR(this.getLSTUnderlyingTokenInfo().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;
+    }
+  }
 
-  // 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 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 { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
+      const unusedBalanceAPY = await this.getUnusedBalanceAPY();
+      baseAPYs.push(...[unusedBalanceAPY.apy]);
+      rewardAPYs.push(0);
+
+      const weights = positions.map((p: VaultPosition, index: number) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+      weights.push(unusedBalanceAPY.weight);
+
+      const prevAUM = await this.getPrevAUM();
+      const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+      const prevAUMUSD = prevAUM.multipliedBy(price.price);
+      const output = await this.returnNetAPY(baseAPYs, rewardAPYs, weights, prevAUMUSD);
+      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: VaultPosition, index: number) => p.usdValue * (index % 2 == 0 ? 1 : -1),
+      );
+      const aum = weights.reduce((acc: number, curr: number) => 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;
+    }
+  }
 
-  // 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);
+  async getVesuAPYs() {
+    const vesuAdapters = this.getVesuAdapters();
+    const allVesuPools = await VesuAdapter.getVesuPools();
+    const pools = vesuAdapters.map((vesuAdapter) => {
+      return allVesuPools.pools.find(p => vesuAdapter.config.poolId.eqString(num.getHexString(p.id)));
+    });
+    logger.verbose(`${this.metadata.name}::netAPY: vesu-pools: ${JSON.stringify(pools)}`);
+    if (pools.some(p => !p)) {
+      throw new Error('Pool not found');
+    }
+    const positions = await this.getVesuPositions();
+    logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
+    const baseAPYs: number[] = [];
+    const rewardAPYs: number[] = [];
+
+    for (const [index, pool] of pools.entries()) {
+      const vesuAdapter = vesuAdapters[index];
+      const collateralAsset = pool.assets.find((a: any) => a.symbol.toLowerCase() === vesuAdapter.config.collateral.symbol.toLowerCase())?.stats!;
+      const debtAsset = pool.assets.find((a: any) => a.symbol.toLowerCase() === vesuAdapter.config.debt.symbol.toLowerCase())?.stats!;
+      const supplyApy = Number(collateralAsset.supplyApy.value || 0) / 1e18;
+
+      const lstAPY = await this.getLSTAPR(vesuAdapter.config.collateral.address);
+      logger.verbose(`${this.metadata.name}::netAPY: ${vesuAdapter.config.collateral.symbol} LST APR from Endur: ${lstAPY}`);
+
+      baseAPYs.push(...[supplyApy + lstAPY, Number(debtAsset.borrowApr.value) / 1e18]);
+      rewardAPYs.push(...[Number(collateralAsset.defiSpringSupplyApr?.value || "0") / 1e18, 0]);
+    }
+    logger.verbose(`${this.metadata.name}::netAPY: baseAPYs: ${JSON.stringify(baseAPYs)}`);
+    logger.verbose(`${this.metadata.name}::netAPY: rewardAPYs: ${JSON.stringify(rewardAPYs)}`);
 
-  //   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};
-  //   } 
-  // }
+    assert(baseAPYs.length == positions.length, 'APYs and positions length mismatch');
 
-  // 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;
-  //   }
-  // }
+    return {
+      baseAPYs,
+      rewardAPYs,
+      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 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();
-  // }
+  protected async returnNetAPY(baseAPYs: number[], rewardAPYs: number[], weights: number[], prevAUMUSD: Web3Number) {
+    if (weights.every(p => p == 0)) {
+      return {
+        net: 0, splits: [{
+          apy: 0, id: 'base'
+        }, {
+          apy: 0, id: 'defispring'
+        }]
+      };
+    }
+
+    const baseAPY = this.computeAPY(baseAPYs, weights, prevAUMUSD);
+    const rewardAPY = this.computeAPY(rewardAPYs, weights, prevAUMUSD);
+    const netAPY = baseAPY + rewardAPY;
+    logger.verbose(`${this.metadata.name}::netAPY: net: ${netAPY}, baseAPY: ${baseAPY}, rewardAPY: ${rewardAPY}`);
+    return {
+      net: netAPY, splits: [{
+        apy: baseAPY, id: 'base'
+      }, {
+        apy: rewardAPY, id: 'defispring'
+      }]
+    };
+  }
+
+  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
+    };
+  }
+
+  private computeAPY(apys: number[], weights: number[], currentAUM: Web3Number) {
+    assert(apys.length === weights.length, "APYs and weights length mismatch");
+    const weightedSum = apys.reduce((acc, apy, i) => acc + apy * weights[i], 0);
+    logger.verbose(`${this.getTag()} computeAPY: apys: ${JSON.stringify(apys)}, weights: ${JSON.stringify(weights)}, weightedSum: ${weightedSum}, currentAUM: ${currentAUM}`);
+    return weightedSum / currentAUM.toNumber();
+  }
+
+  getVesuAdapters(): VesuAdapter[] {
+    const multiply = this.getVesuMultiplyAdapters();
+    return multiply.map(m => m._vesuAdapter);
+  }
+
+  async getVesuPositions(blockNumber: BlockIdentifier = 'latest'): Promise<VaultPosition[]> {
+    const adapters = this.getVesuAdapters();
+    const positions: VaultPosition[] = [];
+    for (const adapter of adapters) {
+      positions.push(...await adapter.getPositions(this.config, blockNumber));
+    }
+    return positions;
+  }
+
+  async getUnusedBalance(): Promise<SingleTokenInfo> {
+    const balance = await (new ERC20(this.config)).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(balance.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount: balance,
+      usdValue
+    };
+  }
+
+  async maxNewDeposits(
+    params: { isAPYComputation: boolean } = { isAPYComputation: false },
+  ) {
+    const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
+    let numerator = 0;
+
+    for (let adapter of this.getVesuAdapters()) {
+      const maxBorrowableAmountInfo = maxBorrowableAmounts.maxBorrowables.find(
+        (b) => b.borrowableAsset.address.eq(adapter.config.debt.address),
+      );
+      if (!maxBorrowableAmountInfo || !maxBorrowableAmountInfo?.amount) {
+        throw new Error(
+          `Max borrowable amount not found for adapter: ${adapter.config.debt.symbol}`,
+        );
+      }
+
+      numerator +=
+        (this.metadata.additionalInfo.targetHealthFactor *
+          maxBorrowableAmountInfo.amount.toNumber()) /
+        maxBorrowableAmountInfo.ltv;
+    }
+
+    return numerator - maxBorrowableAmounts.netMaxBorrowableAmount.toNumber();
+  }
+
+  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, ltv: number, poolId: ContractAddr }[] = [];
+    for (const vesuAdapter of vesuAdapters) {
+      const output = await this.getMaxBorrowableAmountByVesuAdapter(
+        vesuAdapter,
+        params.isAPYComputation,
+      );
+      const ltv = await vesuAdapter.getLTVConfig(this.config);
+      maxBorrowables.push({ ...output, ltv, poolId: vesuAdapter.config.poolId });
+    }
+    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 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, this.pricer);
+        await new Promise((resolve) => setTimeout(resolve, 1000)); // artificial delay, to avoid rate limit
+        const quote = await ekuboQuoter.getQuoteExactInput(
+          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 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 getMaxBorrowableAmountByVesuAdapter(
+    vesuAdapter: VesuAdapter,
+    isAPYComputation: boolean,
+  ) {
+    const lstAPY = await this.getLSTAPR(
+      this.getLSTUnderlyingTokenInfo().address,
+    );
+    const maxInterestRate = lstAPY * 0.8;
+    const { maxDebtToHave: maxBorrowableAmount, currentDebt } =
+      await vesuAdapter.getMaxBorrowableByInterestRate(
+        this.config,
+        vesuAdapter.config.debt,
+        maxInterestRate,
+      );
+    const debtCap = await vesuAdapter.getDebtCap(this.config);
+
+    if (currentDebt.gte(debtCap)) {
+      return {
+        amount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals),
+        dexSwappableAmount: Web3Number.fromWei(
+          "0",
+          vesuAdapter.config.debt.decimals,
+        ),
+        maxBorrowableAmount: Web3Number.fromWei(
+          "0",
+          vesuAdapter.config.debt.decimals,
+        ),
+        borrowableAsset: vesuAdapter.config.debt,
+      };
     }
 
-    const assetPrice = await this.pricer.getPrice(this.asset().symbol);
-    let netAUM = new Web3Number(0, this.asset().decimals);
+    const availableToBorrow = debtCap.minus(currentDebt);
+
+    const maxBorrowable = maxBorrowableAmount
+      .minimum(availableToBorrow)
+      .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 getAUM(unrealizedAUM: boolean = false): Promise<{ net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[] }> {
+    const underlying = this.asset();
+    assert(underlying.symbol.startsWith('x'), 'Underlying is not an LST of Endur');
+
+    // dynamic computation of aum based on price type
+    const priceType = unrealizedAUM ? LSTPriceType.ENDUR_PRICE : LSTPriceType.AVNU_PRICE;
+
+    // get dex rate
+    let tokenUnderlyingPrice: number;
+    const avnuRate = await this.getLSTAvnuRate();
+    if (avnuRate === 0) {
+      throw new Error(`${this.getTag()}::getAUM: tokenUnderlyingPrice (Avnu) is 0`);
+    }
+
+    // get token underlying price
+    if (priceType === LSTPriceType.ENDUR_PRICE) {
+      tokenUnderlyingPrice = await this.getLSTExchangeRate();
+      if (tokenUnderlyingPrice === 0) {
+        throw new Error(`${this.getTag()}::getAUM: tokenUnderlyingPrice (Endur) is 0`);
+      }
+    } else {
+      tokenUnderlyingPrice = avnuRate;
+    }
+
+    // check if endur and avnu prices differ by more than 2%
+    const diff = Math.abs(tokenUnderlyingPrice - avnuRate) / tokenUnderlyingPrice;
+    if (diff > 0.02) {
+      throw new Error(
+        `${this.getTag()}::getAUM: Endur and Avnu prices differ by more than 2% (Endur: ${tokenUnderlyingPrice}, Avnu: ${avnuRate})`,
+      );
+    }
+
+    // get all positions
+    const allPositions = await this.getVaultPositions();
+
+    // compute net aum
+    let netAUM = new Web3Number(0, underlying.decimals);
     for (let position of allPositions) {
-      if (position.tokenInfo.address.eq(this.asset().address)) {
+      if (position.token.address.eq(underlying.address)) {
         netAUM = netAUM.plus(position.amount);
+      } else if (position.token.address.eq(this.getLSTUnderlyingTokenInfo().address)) {
+        netAUM = netAUM.plus(position.amount.dividedBy(tokenUnderlyingPrice));
       } else {
-        netAUM = netAUM.plus(position.usdValue / assetPrice.price);
+        throw new Error(`${this.getTag()}::getAUM: unknown token: ${position.token.symbol}`);
       }
     }
 
+    const assetPrice = await this.pricer.getPrice(underlying.symbol);
     const prevAum = await this.getPrevAUM();
+    const priceTypeLabel = priceType === LSTPriceType.ENDUR_PRICE ? "Endur Price" : "Avnu Price";
+    logger.verbose(`${this.getTag()} AUM (${priceTypeLabel}): ${netAUM}`);
+
     const realAUM: PositionInfo = {
-      tokenInfo: this.asset(),
+      tokenInfo: underlying,
       amount: netAUM,
       usdValue: netAUM.toNumber() * assetPrice.price,
-      apy: {apy: netAUM.toNumber() * assetPrice.price, type: APYType.BASE},
+      apy: { apy: 0, type: APYType.BASE }, // VT: Dont remember why this field exists here. FOr now, set it to 0.
       remarks: AUMTypes.FINALISED,
-      protocol: Protocols.NONE // just placeholder
+      protocol: Protocols.NONE
     };
 
     const estimatedAUMDelta: PositionInfo = {
-      tokenInfo: this.asset(),
-      amount: Web3Number.fromWei('0', this.asset().decimals),
+      tokenInfo: underlying,
+      amount: Web3Number.fromWei('0', underlying.decimals),
       usdValue: 0,
-      apy: {apy: 0, type: APYType.BASE},
+      apy: { apy: 0, type: APYType.BASE },
       remarks: AUMTypes.DEFISPRING,
-      protocol: Protocols.NONE // just placeholder
+      protocol: Protocols.NONE
     };
 
-    return {net: {
+    return {
+      net: {
+        tokenInfo: underlying,
+        amount: netAUM,
+        usdValue: netAUM.toNumber() * assetPrice.price
+      }, prevAum: prevAum, splits: [realAUM, estimatedAUMDelta]
+    };
+  }
+
+  async getTVLUnrealized() {
+    return await this.getAUM(true);
+  }
+
+  async getUserUnrealizedGains(user: ContractAddr) {
+    const tvl = await this.getTVL();
+    const unrealizedTVL = await this.getTVLUnrealized();
+    const unrealizedDiff = unrealizedTVL.net.amount.minus(tvl.amount);
+    const userTVL = await this.getUserTVL(user);
+    const userShare = userTVL.amount.dividedBy(tvl.amount);
+    const unrealizedGains = unrealizedDiff.multipliedBy(userShare);
+
+    return {
+      unrealizedGains,
+      userShare: userShare.toNumber(),
       tokenInfo: this.asset(),
-      amount: netAUM,
-      usdValue: netAUM.toNumber() * assetPrice.price
-    }, prevAum: prevAum, splits: [realAUM, estimatedAUMDelta]};
+    };
+  }
+
+  async getUserPositionCards(input: UserPositionCardsInput): Promise<UserPositionCard[]> {
+    const cards = await super.getUserPositionCards(input);
+
+    try {
+      const [unrealizedResult, userTVL, realizedApyRaw] = await Promise.all([
+        this.getUserUnrealizedGains(input.user),
+        this.getUserTVL(input.user),
+        this.getUserRealizedAPY().catch(() => null),
+      ]);
+      const amount = unrealizedResult.unrealizedGains;
+      let usdValue = 0;
+      const userAmount = userTVL.amount.toNumber();
+      if (Number.isFinite(userAmount) && userAmount > 0) {
+        usdValue = (userTVL.usdValue / userAmount) * amount.toNumber();
+      }
+
+      cards.push({
+        title: "Unrealized Gains",
+        tooltip: "Unrealized gains based on current market prices vs Endur prices. If you withdraw now, you will forgo these gains.",
+        value: this.formatTokenAmountForCard(amount, unrealizedResult.tokenInfo),
+        subValue: `≈ ${this.formatUSDForCard(usdValue)}`,
+        subValueColor: this.getSubValueColorFromSignedNumber(usdValue),
+      });
+
+      const realizedApy = typeof realizedApyRaw === "number"
+        ? this.formatPercentForCard(realizedApyRaw)
+        : "N/A";
+      cards.push({
+        title: "Realized APY",
+        tooltip: this.metadata.realizedApyMethodology || "Realized APY is based on past 14 days performance",
+        value: realizedApy,
+      });
+    } catch (error) {
+      logger.warn(`${this.getTag()}::getUserPositionCards unrealized gains fallback`, error);
+      cards.push({
+        title: "Unrealized Gains",
+        tooltip: "Unrealized gains based on current market prices vs Endur prices. If you withdraw now, you will forgo these gains.",
+        value: this.formatTokenAmountForCard(
+          Web3Number.fromWei("0", this.asset().decimals),
+          this.asset()
+        ),
+        subValue: `≈ ${this.formatUSDForCard(0)}`,
+        subValueColor: "default",
+      });
+      cards.push({
+        title: "Realized APY",
+        tooltip: this.metadata.realizedApyMethodology || "Realized APY is based on past 14 days performance",
+        value: "N/A",
+      });
+    }
+
+    if (this.asset().symbol === "xSTRK") {
+      const index = cards.findIndex((card) => card.title === "Lifetime Earnings");
+      if (index >= 0) {
+        cards[index] = {
+          ...cards[index],
+          tooltip: "Lifetime earnings of the vault. Due to migration of xSTRK Sensei to this vault, any migrated funds are also seen as lifetime earnings. Team is working to fix this soon.",
+        };
+      }
+    }
+
+    return cards;
   }
 
-  /**
-   * 
-   * @param params marginAmount is in LST, debtAmount is in underlying
-   */
-  // 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(
@@ -689,7 +1036,6 @@ export default function VaultDescription(
   const containerStyle = {
     maxWidth: "800px",
     margin: "0 auto",
-    backgroundColor: "#111",
     color: "#eee",
     fontFamily: "Arial, sans-serif",
     borderRadius: "12px",
@@ -705,7 +1051,7 @@ export default function VaultDescription(
       </p>
 
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
-        This vault uses Vesu for lending and borrowing. The oracle used by this pool is a {highlightTextWithLinks("conversion rate oracle", [{highlight: "conversion rate oracle", link: "https://docs.pragma.build/starknet/development#conversion-rate"}])}
+        This vault uses Vesu for lending and borrowing. The oracle used by this pool is a {highlightTextWithLinks("conversion rate oracle", [{ highlight: "conversion rate oracle", link: "https://docs.pragma.build/starknet/development#conversion-rate" }])}
         {" "}which is resilient to liquidity issues and price volatility, hence reducing the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep.
       </p>
 
@@ -716,7 +1062,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 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. 
+          <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.
         </p>
       </div>
       {/* <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
@@ -733,69 +1079,82 @@ function getDescription(tokenSymbol: string, underlyingSymbol: string) {
   return VaultDescription(tokenSymbol, underlyingSymbol);
 }
 
-
-enum LST_MULTIPLIER_MANAGE_IDS  {
-  MULTIPLE_APPROVE = 'multiple_approve',
-  MULTIPLY_VESU = 'multiply_vesu',
-  SWITCH_DELEGATION_ON = 'switch_delegation_on',
-  SWITCH_DELEGATION_OFF = 'switch_delegation_off',
-  AVNU_MULTIPLY_APPROVE_DEPOSIT = 'avnu_mul_approve_dep',
-  AVNU_MULTIPLY_SWAP_DEPOSIT = 'avnu_mul_swap_dep',
-  AVNU_MULTIPLY_APPROVE_WITHDRAW = 'avnu_mul_approve_withdr',
-  AVNU_MULTIPLY_SWAP_WITHDRAW = 'avnu_mul_swap_withdr',
-}
-
-function getAvnuManageIDs(baseID: LST_MULTIPLIER_MANAGE_IDS, debtTokenSymbol: string) {
-  return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
-}
-
-function getVesuLegId(baseID: string, debtTokenSymbol: string) {
-  return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
-}
-
 function getLooperSettings(
   lstSymbol: string,
   underlyingSymbol: string,
   vaultSettings: HyperLSTStrategySettings,
-  pool1: ContractAddr,
 ) {
   vaultSettings.leafAdapters = [];
+  vaultSettings.adapters = [];
 
   const lstToken = Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!;
   const underlyingToken = Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!;
 
   const baseAdapterConfig: BaseAdapterConfig = {
     baseToken: lstToken,
-    supportedPositions: [{asset: lstToken, isDebt: false}],
+    supportedPositions: [{ asset: lstToken, isDebt: false }, { asset: underlyingToken, isDebt: true }],
     networkConfig: getMainnetConfig(),
     pricer: new PricerFromApi(getMainnetConfig(), Global.getDefaultTokens()),
     vaultAllocator: vaultSettings.vaultAllocator,
     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,
+  const adapterIds: NonNullable<HyperLSTStrategySettings["adapterIds"]> = {
+    primaryMultiply: "",
+    multiply: {},
+    modify: {},
+  };
+
+  const vesuMultiplyAdapters = vaultSettings.borrowable_assets.map((position) => {
+    const key = getHyperLSTAdapterKey(position.tokenInfo.symbol, position.poolId);
+    const id = getHyperLSTMultiplyAdapterId(lstSymbol, position.tokenInfo.symbol, position.poolId);
+    adapterIds.multiply[key] = id;
+    return {
+      id,
+      adapter: new VesuMultiplyAdapter({
+        poolId: position.poolId,
+        collateral: lstToken,
+        debt: position.tokenInfo,
+        marginToken: lstToken,
+        targetHealthFactor: vaultSettings.targetHealthFactor,
+        minHealthFactor: vaultSettings.minHealthFactor,
+        quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
+        ...baseAdapterConfig,
+        minimumVesuMovementAmount: 0,
+      }),
+    };
+  });
+
+  const vesuModifyPositionAdapters = vaultSettings.borrowable_assets.map((position) => {
+    const key = getHyperLSTAdapterKey(position.tokenInfo.symbol, position.poolId);
+    const id = getHyperLSTModifyAdapterId(lstSymbol, position.tokenInfo.symbol, position.poolId);
+    adapterIds.modify[key] = id;
+    return {
+      id,
+      adapter: new VesuModifyPositionAdapter({
+        poolId: position.poolId,
+        collateral: lstToken,
+        debt: position.tokenInfo,
+        targetLtv: 0.8,
+        maxLtv: 0.9,
+        ...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});
+  if (!adapterIds.primaryMultiply && vesuMultiplyAdapters.length > 0) {
+    adapterIds.primaryMultiply = vesuMultiplyAdapters[0].id;
+  } else {
+    throw new Error(`${lstSymbol}::getLooperSettings: primaryMultiply adapter not found`);
+  }
+  vaultSettings.adapterIds = adapterIds;
+
+  for (const entry of vesuMultiplyAdapters) {
+    vaultSettings.adapters.push(entry);
+  }
+  for (const entry of vesuModifyPositionAdapters) {
+    vaultSettings.adapters.push(entry);
+  }
 
   const commonAdapter = new CommonAdapter({
     id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN,
@@ -805,25 +1164,21 @@ function getLooperSettings(
     asset: lstToken.address
   })
 
-  // push vesu adapter to leaf adapters
-  vaultSettings.leafAdapters.push(() => vesuAdapterLST.getDepositLeaf());
-  vaultSettings.leafAdapters.push(() => vesuAdapterLST.getWithdrawLeaf());
+  for (const entry of vesuMultiplyAdapters) {
+    const adapter = entry.adapter;
+    vaultSettings.leafAdapters.push(() => adapter.getDepositLeaf());
+    vaultSettings.leafAdapters.push(() => adapter.getWithdrawLeaf());
+  }
+  for (const entry of vesuModifyPositionAdapters) {
+    const adapter = entry.adapter;
+    vaultSettings.leafAdapters.push(() => adapter.getDepositLeaf());
+    vaultSettings.leafAdapters.push(() => adapter.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));
-
-  // // 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;
 }
 
@@ -889,13 +1244,9 @@ 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." },
-  {type: RiskType.DEPEG_RISK, value: DepegRiskLevel.GENERALLY_STABLE, weight: 25, reason: "Generally stable pegged assets" },
+  { type: RiskType.DEPEG_RISK, value: DepegRiskLevel.GENERALLY_STABLE, weight: 25, reason: "Generally stable pegged assets" },
 ];
 
-const borrowableAssets = [
-  'WBTC', 'tBTC', 'LBTC', 'solvBTC'
-]
-
 const hyperxSTRK: HyperLSTStrategySettings = {
   vaultAddress: ContractAddr.from('0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960'),
   manager: ContractAddr.from('0x5d499cd333757f461a0bedaca3dfc4d77320c773037e0aa299f22a6dbfdc03a'),
@@ -906,9 +1257,15 @@ const hyperxSTRK: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'STRK'),
+  borrowable_assets: [{
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'STRK')!,
+    poolId: VesuPools.Re7STRK,
+  }, {
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'STRK')!,
+    poolId: VesuPools.Prime,
+  }],
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'STRK')!,
-  quoteAmountToFetchPrice: new Web3Number('100', Global.getDefaultTokens().find(token => token.symbol === 'STRK')!.decimals),
+  quoteAmountToFetchPrice: new Web3Number('1000', Global.getDefaultTokens().find(token => token.symbol === 'STRK')!.decimals),
 }
 
 const hyperxWBTC: HyperLSTStrategySettings = {
@@ -921,9 +1278,16 @@ const hyperxWBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: [{
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+    poolId: VesuPools.Re7xBTC,
+  }, {
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+    poolId: VesuPools.Prime,
+  }],
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!.decimals),
+  redemptionRouter: ContractAddr.from('0x6ea649f402898f69baf775c1afdd08522c071c640b9c4460192070ec2b96417'),
 }
 
 const hyperxtBTC: HyperLSTStrategySettings = {
@@ -936,9 +1300,16 @@ const hyperxtBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: [{
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'tBTC')!,
+    poolId: VesuPools.Re7xBTC,
+  }, {
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+    poolId: VesuPools.Re7xBTC,
+  }],
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'tBTC')!,
   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'tBTC')!.decimals),
+  redemptionRouter: ContractAddr.from('0x3de9c409d1e357e25778fb7a3e2e2393666956846a5c2caa607296fa8e76b5d'),
 }
 
 const hyperxsBTC: HyperLSTStrategySettings = {
@@ -951,7 +1322,10 @@ const hyperxsBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: [{
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!,
+    poolId: VesuPools.Re7xBTC,
+  }],
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!,
   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!.decimals),
 }
@@ -966,44 +1340,47 @@ const hyperxLBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: [{
+    tokenInfo: Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!,
+    poolId: VesuPools.Re7xBTC,
+  }],
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!,
   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!.decimals),
 }
 
-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),
-}
+// 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: .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),
-}
+// 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 [
@@ -1011,35 +1388,137 @@ export function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string)
     `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 pool on Vesu to optimize yield`
+    `If required, adjust leverage or re-allocate assets within LST pool on Vesu to optimize yield`
   ]
 }
 
-function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addresses: HyperLSTStrategySettings, isPreview: boolean = false, isLST: boolean): IStrategyMetadata<HyperLSTStrategySettings> {
+function createHyperLSTSettings(
+  lstSymbol: string,
+  underlyingSymbol: string,
+): StrategySettings {
+  const depositToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === lstSymbol,
+  )!;
   return {
+    isPaused: false,
+    liveStatus: lstSymbol === 'xSTRK' ? StrategyLiveStatus.HOT : ((lstSymbol == 'xWBTC' || lstSymbol == 'xtBTC') ? StrategyLiveStatus.ACTIVE : StrategyLiveStatus.DEPRECATED),
+    isAudited: true,
+    isInstantWithdrawal: false,
+    hideHarvestInfo: true,
+    quoteToken: depositToken,
+    showWithdrawalWarningModal: false,
+    alerts: [
+      {
+        tab: "withdraw" as const,
+        text: "On withdrawal, you will receive an NFT representing your withdrawal request. The funds will be automatically sent to your wallet (NFT owner) in 24 hours (In this initial phase of Launch). You can monitor the status in transactions tab.",
+        type: "info" as const,
+      },
+      {
+        tab: "deposit" as const,
+        text: (
+          <>
+            To acquire the LST, please visit{" "}
+            <a href="https://app.endur.fi" target="_blank" rel="noopener noreferrer">endur.fi</a>
+          </>
+        ),
+        type: "info" as const,
+      },
+      {
+        tab: "deposit" as const,
+        text: "It may take up to one week for your deposit to appreciate in value. This delay occurs because the LST price is sourced from DEXes and liquidity is usually rebased once a week.",
+        type: "info" as const,
+      },
+    ],
+  };
+}
+
+const HYPER_LST_SECURITY = {
+  auditStatus: AuditStatus.AUDITED,
+  sourceCode: {
+    type: SourceCodeType.CLOSED_SOURCE,
+    contractLink: "https://github.com/trovesfi/troves-contracts",
+  },
+  accessControl: {
+    type: AccessControlType.STANDARD_ACCOUNT,
+    addresses: [ContractAddr.from("0x03495dd1e4838aa06666aac236036d86e81a6553e222fc02e70c2cbc0062e8d0")],
+  },
+};
+
+const HYPER_LST_REDEMPTION_INFO: RedemptionInfo = {
+  instantWithdrawalVault: InstantWithdrawalVault.NO,
+  redemptionsInfo: [
+    {
+      title: "Typical Duration",
+      description: "1-2 hours",
+    },
+  ],
+  alerts: [
+    {
+      type: "info",
+      text: "In cases of low liquidity, high slippages, the redemptions can take longer time. Redemption times are estimates and may vary based on network conditions and liquidity requirements.",
+      tab: "withdraw",
+    },
+  ],
+};
+
+function getStrategySettings(
+  lstSymbol: string,
+  underlyingSymbol: string,
+  settings: HyperLSTStrategySettings,
+  isPreview: boolean = false,
+  isLST: boolean,
+): IStrategyMetadata<HyperLSTStrategySettings> {
+  return {
+    id: `hyper_${lstSymbol.toLowerCase()}`,
     name: `Hyper ${lstSymbol}`,
     description: getDescription(lstSymbol, underlyingSymbol),
-    address: addresses.vaultAddress,
+    address: settings.vaultAddress,
     launchBlock: 0,
     type: 'Other',
+    vaultType: {
+      type: VaultType.LOOPING,
+      description: `Creates leveraged looping position on ${lstSymbol} by borrowing ${underlyingSymbol} to increase yield`,
+    },
     depositTokens: [Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!],
-    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, lstSymbol === 'xSTRK' ? VesuPools.Re7xSTRK : VesuPools.Re7xBTC),
+    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, settings),
     risk: {
       riskFactor: _riskFactor,
       netRisk:
         _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
         _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
-      notARisks: getNoRiskTags(_riskFactor)
+      notARisks: getNoRiskTags(_riskFactor),
     },
     auditUrl: AUDIT_URL,
     protocols: [Protocols.ENDUR, Protocols.VESU],
-    maxTVL: Web3Number.fromWei(0, 18),
-    contractDetails: getContractDetails(addresses),
+    curator: {
+      name: "Unwrap Labs",
+      logo: "https://assets.troves.fi/integrations/unwraplabs/white.png",
+    },
+    settings: createHyperLSTSettings(lstSymbol, underlyingSymbol),
+    contractDetails: getContractDetails(settings),
     faqs: getFAQs(lstSymbol, underlyingSymbol, isLST),
     investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
     isPreview: isPreview,
-    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.'
-  }
+    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.",
+    realizedApyMethodology:
+      "The realizedAPY is based on past 14 days performance by the vault",
+    feeBps: {
+      performanceFeeBps: 1000,
+    },
+    tags: lstSymbol.includes("BTC")
+      ? [StrategyTag.BTC, StrategyTag.LEVERED]
+      : [StrategyTag.LEVERED],
+    security: HYPER_LST_SECURITY,
+    redemptionInfo: HYPER_LST_REDEMPTION_INFO,
+    usualTimeToEarnings: '2 weeks',
+    usualTimeToEarningsDescription: 'Strategy returns depend on LST price on DEXes. Even though the true price of LST on Endur increases continuously, the DEX price may lag sometimes, and historically is seen to rebase at least once every 2 hours. This is when you realise your earnings.',
+    points: lstSymbol === 'xSTRK' ? [{
+      multiplier: 4,
+      logo: "https://endur.fi/favicon.ico",
+      toolTip: "This strategy holds xSTRK. Earn 3-4x Endur points on your xSTRK due to the leverage. Points can be found on endur.fi.",
+    }] : undefined,
+  };
 }
 
 
@@ -1062,10 +1541,10 @@ function getStrategySettings(lstSymbol: string, underlyingSymbol: string, addres
 export const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[] =
   [
     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),
+    getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, false, true),
+    getStrategySettings('xtBTC', 'tBTC', hyperxtBTC, false, true),
+    getStrategySettings('xsBTC', 'solvBTC', hyperxsBTC, false, true),
+    getStrategySettings('xLBTC', 'LBTC', hyperxLBTC, false, true),
+    // getStrategySettings('mRe7BTC', 'mRe7BTC', hypermRe7BTC, false, false),
+    // getStrategySettings('mRe7YIELD', 'mRe7YIELD', hypermRe7YIELD, false, false),
   ]