@strkfarm/sdk 2.0.0-dev.4 → 2.0.0-dev.40

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

@@ -1,51 +1,74 @@
-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 { 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 { SVKStrategy } from "./svk-strategy";
-import { Call, uint256 } from "starknet";
+import { Call, Contract, uint256 } 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";
 
 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_${lstSymbol.toLowerCase()}_${getHyperLSTAdapterKey(debtSymbol, poolId)}`;
+}
+
+function getHyperLSTModifyAdapterId(
+  lstSymbol: string,
+  debtSymbol: string,
+  poolId: ContractAddr,
+): string {
+  return `vesu_modify_${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 +77,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,7 +117,7 @@ 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() {
+  getVesuMultiplyAdapters() {
     const vesuMultipleAdapters = this.metadata.additionalInfo.adapters
     .filter(adapter => adapter.adapter.name === VesuMultiplyAdapter.name)
     .map(adapter => adapter.adapter) as VesuMultiplyAdapter[]
@@ -83,6 +129,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 +254,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 +266,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 +324,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 +350,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 +375,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 +393,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 +405,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 +423,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 +449,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 +463,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 +477,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 +496,192 @@ 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 maxDeposits = await this.maxNewDeposits({ isAPYComputation: true });
+    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
+
+    if (maxDeposits * 1.5 < unusedBalance.amount.toNumber()) {
+      logger.verbose(
+        `${this.getTag()}::netAPY: unused balance is > max servicable from loan, lstAPY: ${lstAPY}`,
+      );
+      // TODO, need to add the unused balance APY
+      const output = await super.netAPY();
+      output.splits.push({ apy: lstAPY, id: "lst_apy" });
+      return output;
+    } else {
+      logger.verbose(
+        `${this.getTag()}::netAPY: we can take more deposits, use theoretical max APY`,
+      );
+      const output = await super.netAPY();
+      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 maxNewDeposits(
+    params: { isAPYComputation: boolean } = { isAPYComputation: false },
+  ) {
+    let numerator = 0;
+    for (let adapter of this.getVesuMultiplyAdapters()) {
+      const maxDepositInfo = await adapter.maxDeposit();
+      numerator += maxDepositInfo.amount.toNumber();
+    }
+    return numerator;
+  }
 
-  //   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};
-  //   } 
-  // }
+  protected async getUnusedBalanceAPY() {
+    const unusedBalance = await this.getUnusedBalance();
+    const underlying = this.getLSTUnderlyingTokenInfo();
+    const lstAPY = await this.getLSTAPR(underlying.address);
+    return {
+      apy: lstAPY,
+      weight: unusedBalance.usdValue,
+    };
+  }
 
-  // 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;
-  //   }
-  // }
+  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');
 
-  // 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();
-  // }
+    // dynamic computation of aum based on price type
+    const priceType = unrealizedAUM ? LSTPriceType.ENDUR_PRICE : LSTPriceType.AVNU_PRICE;
 
-  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);
+    // get dex rate
+    let tokenUnderlyingPrice: number;
+    const avnuRate = await this.getLSTAvnuRate();
+    if (avnuRate === 0) {
+      throw new Error(`${this.getTag()}::getAUM: tokenUnderlyingPrice (Avnu) is 0`);
     }
 
-    const assetPrice = await this.pricer.getPrice(this.asset().symbol);
-    let netAUM = new Web3Number(0, this.asset().decimals);
+    // 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},
       remarks: AUMTypes.DEFISPRING,
-      protocol: Protocols.NONE // just placeholder
+      protocol: Protocols.NONE
     };
 
     return {net: {
-      tokenInfo: this.asset(),
+      tokenInfo: underlying,
       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
-  // }): 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)];
-  // }
+  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(),
+    };
+  }
+
 }
 
 export default function VaultDescription(
@@ -689,7 +691,6 @@ export default function VaultDescription(
   const containerStyle = {
     maxWidth: "800px",
     margin: "0 auto",
-    backgroundColor: "#111",
     color: "#eee",
     fontFamily: "Arial, sans-serif",
     borderRadius: "12px",
@@ -716,7 +717,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 +734,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 +819,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;
 }
 
@@ -892,10 +902,6 @@ export const _riskFactor: RiskFactor[] = [
   {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 +912,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 +933,13 @@ 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,
+  }],
   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 +952,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 +974,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 +992,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 +1040,152 @@ 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 getMaxTVL(lstSymbol: string): Web3Number {
+  const lstMaxTVLs: Record<string, number> = {
+    xWBTC: 5,
+    xLBTC: 5,
+    xtBTC: 5,
+    xsBTC: 5,
+    xSTRK: 7000000,
+  };
+  const maxTVLValue = lstMaxTVLs[lstSymbol] || 0;
+  const token = Global.getDefaultTokens().find(
+    (token) => token.symbol === lstSymbol,
+  );
+  if (!token) {
+    return Web3Number.fromWei(0, 18);
+  }
+  return Web3Number.fromWei(maxTVLValue, token.decimals);
+}
+
+function createHyperLSTSettings(
+  lstSymbol: string,
+  underlyingSymbol: string,
+): StrategySettings {
+  const depositToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === lstSymbol,
+  )!;
   return {
+    maxTVL: getMaxTVL(lstSymbol),
+    isPaused: false,
+    liveStatus: StrategyLiveStatus.HOT,
+    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("0x0")],
+    timeLock: "2 Days",
+  },
+};
+
+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',
+    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 +1208,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),
   ]