@strkfarm/sdk 2.0.0-dev.27 → 2.0.0-dev.28

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

@@ -1,18 +1,19 @@
-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, 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 { LSTPriceType } from "./types";
 import { MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP } from "./vesu-extended-strategy/utils/constants";
 import { VesuExtendedStrategySettings } from "./vesu-extended-strategy/vesu-extended-strategy";
 
@@ -28,7 +29,7 @@ export interface HyperLSTStrategySettings extends UniversalStrategySettings {
 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')!;
@@ -43,9 +44,9 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     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;
       }
     });
   }
@@ -83,6 +84,102 @@ 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 getLSTDexPrice() {
+    const ekuboQuoter = new EkuboQuoter(this.config, this.pricer);
+    const lstTokenInfo = this.asset();
+    const lstUnderlyingTokenInfo = this.getLSTUnderlyingTokenInfo();
+    const quote = await ekuboQuoter.getQuoteExactInput(
+      lstTokenInfo.address.address,
+      lstUnderlyingTokenInfo.address.address,
+      this.quoteAmountToFetchPrice,
+    );
+
+    const outputAmount = Web3Number.fromWei(
+      quote.total_calculated,
+      lstUnderlyingTokenInfo.decimals,
+    );
+    const price =
+      outputAmount.toNumber() / this.quoteAmountToFetchPrice.toNumber();
+    logger.verbose(`${this.getTag()}:: LST Dex Price: ${price}`);
+    return price;
+  }
+
+  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 +229,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 +241,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 +299,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 +325,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 +350,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 +368,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 +380,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 +398,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 +424,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 +438,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 +452,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,
@@ -420,8 +473,8 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     // logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
     const allAdapters = this.metadata.additionalInfo.adapters.map(adapter => adapter.adapter);
     if (!params.isDeposit) {
-      // try using unused balance to unwind. 
-      // no need to unwind. 
+      // 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)) {
@@ -432,8 +485,8 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
           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}));
+            const manageCalls = await info.callConstructor({ amount: params.leg1DepositAmount });
+            const call = this.getManageCall(this.getProofGroupsForManageCalls(manageCalls), manageCalls);
             calls.push(call);
           }
           return calls;
@@ -448,8 +501,8 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
       const proofsInfo = adapters.map(adapter => adapter.getProofs(true, this.getMerkleTree()));
       const calls: Call[] = [];
       for (const info of proofsInfo) {
-        const proofGroups = info.proofs;
-        const call = this.getManageCall(proofGroups, await info.callConstructor({amount: params.leg1DepositAmount}));
+        const manageCalls = await info.callConstructor({ amount: params.leg1DepositAmount });
+        const call = this.getManageCall(this.getProofGroupsForManageCalls(manageCalls), manageCalls);
         calls.push(call);
       }
       return calls;
@@ -461,11 +514,11 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     // const collateralisation = await vesuAdapter1.getCollateralization(this.config);
     // const existingCollateralInfo = existingPositions[0];
     // const existingDebtInfo = existingPositions[1];
-    // logger.debug(`${this.getTag()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+    // 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 
+    // // 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;
@@ -476,7 +529,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
 
     // // 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). 
+    // // 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)
@@ -519,149 +572,166 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
     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 vesuAdapter1 = this.getVesuSameTokenAdapter();
+      const apr = await LSTAPRService.getLSTAPR(vesuAdapter1._vesuAdapter.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;
+    }
+  }
 
-  // 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}`,
+      );
+      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.getVesuAdapters()) {
+      const maxDepositInfo = await adapter.maxDeposit();
+      const ltv = await adapter._vesuAdapter.getLTVConfig(this.config);
+      numerator +=
+        (this.metadata.additionalInfo.targetHealthFactor *
+          maxDepositInfo.amount.toNumber()) / ltv;
+    }
+    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();
-  // }
+    const priceType = unrealizedAUM ? LSTPriceType.ENDUR_PRICE : LSTPriceType.AVNU_PRICE;
+
+    let tokenUnderlyingPrice: number;
+    if (priceType === LSTPriceType.ENDUR_PRICE) {
+      tokenUnderlyingPrice = await this.getLSTExchangeRate();
+      if (tokenUnderlyingPrice === 0) {
+        throw new Error(`${this.getTag()}::getAUM: tokenUnderlyingPrice (Endur) is 0`);
+      }
+      const avnuRate = await this.getLSTAvnuRate();
+      if (avnuRate === 0) {
+        throw new Error(`${this.getTag()}::getAUM: tokenUnderlyingPrice (Avnu) is 0`);
+      }
+      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})`,
+        );
+      }
+      logger.verbose(`${this.getTag()} tokenUnderlyingPrice (Endur): ${tokenUnderlyingPrice}, avnuRate: ${avnuRate}, diff: ${diff}`);
+    } else {
+      tokenUnderlyingPrice = await this.getLSTAvnuRate();
+      if (tokenUnderlyingPrice === 0) {
+        throw new Error(`${this.getTag()}::getAUM: tokenUnderlyingPrice (Avnu) is 0`);
+      }
+      logger.verbose(`${this.getTag()} tokenUnderlyingPrice (Avnu): ${tokenUnderlyingPrice}`);
+    }
 
-  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);
     }
 
-    const assetPrice = await this.pricer.getPrice(this.asset().symbol);
-    let netAUM = new Web3Number(0, this.asset().decimals);
+    let netAUM = new Web3Number(0, underlying.decimals);
     for (let position of allPositions) {
-      if (position.tokenInfo.address.eq(this.asset().address)) {
+      if (position.tokenInfo.address.eq(underlying.address)) {
         netAUM = netAUM.plus(position.amount);
       } else {
-        netAUM = netAUM.plus(position.usdValue / assetPrice.price);
+        netAUM = netAUM.plus(position.amount.dividedBy(tokenUnderlyingPrice));
       }
     }
 
+    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},
       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]};
   }
 
+  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(),
+    };
+  }
+
   /**
-   * 
+   *
    * @param params marginAmount is in LST, debtAmount is in underlying
    */
   // async getModifyLeverCall(params: {
@@ -671,7 +741,7 @@ export class UniversalLstMultiplierStrategy<S extends HyperLSTStrategySettings>
   //   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({
@@ -689,7 +759,6 @@ export default function VaultDescription(
   const containerStyle = {
     maxWidth: "800px",
     margin: "0 auto",
-    backgroundColor: "#111",
     color: "#eee",
     fontFamily: "Arial, sans-serif",
     borderRadius: "12px",
@@ -716,7 +785,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" }}>
@@ -782,21 +851,25 @@ function getLooperSettings(
     poolId: pool1,
     collateral: lstToken,
     debt: Global.getDefaultTokens().find(token => token.symbol === position)!,
+    marginToken: lstToken,
     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}],
-    minimumVesuMovementAmount: 0 
+    minimumVesuMovementAmount: 0
   }));
 
-  const unusedBalanceAdapter = new UnusedBalanceAdapter({
+  // Tracks LST balance in the vault allocator; fromAddress=vaultAllocator, toAddress=vaultAddress
+  const lstTransferAdapter = new TokenTransferAdapter({
     ...baseAdapterConfig,
+    fromAddress: vaultSettings.vaultAllocator,
+    toAddress: vaultSettings.vaultAddress,
   });
 
   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});
+  vaultSettings.adapters.push({id: `${lstTransferAdapter.name}_${lstToken.symbol}`, adapter: lstTransferAdapter});
 
   const commonAdapter = new CommonAdapter({
     id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN,
@@ -813,11 +886,11 @@ function getLooperSettings(
   // 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));
 
@@ -922,9 +995,10 @@ const hyperxWBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'WBTC'),
   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 = {
@@ -937,9 +1011,10 @@ const hyperxtBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'tBTC' || token.symbol === 'WBTC'),
   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 = {
@@ -952,7 +1027,7 @@ const hyperxsBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'solvBTC'),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!,
   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!.decimals),
 }
@@ -967,7 +1042,7 @@ const hyperxLBTC: HyperLSTStrategySettings = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!),
+  borrowable_assets: Global.getDefaultTokens().filter(token => token.symbol === 'LBTC'),
   underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!,
   quoteAmountToFetchPrice: new Web3Number('0.001', Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!.decimals),
 }
@@ -1012,35 +1087,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, lstSymbol === 'xSTRK' ? VesuPools.Re7xSTRK : VesuPools.Re7xBTC),
     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,
+  };
 }