@strkfarm/sdk 2.0.0-staging.22 → 2.0.0-staging.25

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

@@ -1,44 +1,105 @@
-import { FAQ, getNoRiskTags, highlightTextWithLinks, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, StrategyTag, TokenInfo, AuditStatus, SourceCodeType, AccessControlType, InstantWithdrawalVault, StrategyLiveStatus, StrategySettings, VaultType, RedemptionInfo } from "@/interfaces";
-import { AUMTypes, getContractDetails, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalManageCall, UniversalStrategy, UniversalStrategySettings } from "./universal-strategy";
+import {
+  FAQ,
+  getNoRiskTags,
+  highlightTextWithLinks,
+  IConfig,
+  IStrategyMetadata,
+  Protocols,
+  RiskFactor,
+  RiskType,
+  StrategyTag,
+  TokenInfo,
+  AuditStatus,
+  SourceCodeType,
+  AccessControlType,
+  InstantWithdrawalVault,
+  StrategyLiveStatus,
+  StrategySettings,
+  VaultType,
+  RedemptionInfo,
+} from "@/interfaces";
+import {
+  AUMTypes,
+  getContractDetails,
+  UNIVERSAL_ADAPTERS,
+  UNIVERSAL_MANAGE_IDS,
+  UniversalManageCall,
+  UniversalStrategy,
+  UniversalStrategySettings,
+} from "./universal-strategy";
 import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { Global } from "@/global";
-import { ApproveCallParams, AvnuSwapCallParams, CommonAdapter, getVesuSingletonAddress, ManageCall, Swap, VesuAdapter, VesuModifyDelegationCallParams, VesuModifyPositionCallParams, VesuMultiplyCallParams, VesuPools } from "./universal-adapters";
+import {
+  ApproveCallParams,
+  AvnuSwapCallParams,
+  CommonAdapter,
+  getVesuSingletonAddress,
+  ManageCall,
+  Swap,
+  VesuAdapter,
+  VesuModifyDelegationCallParams,
+  VesuModifyPositionCallParams,
+  VesuMultiplyCallParams,
+  VesuPools,
+} from "./universal-adapters";
 import { AVNU_EXCHANGE } from "./universal-adapters/adapter-utils";
-import { DepegRiskLevel, LiquidationRiskLevel, SmartContractRiskLevel, TechnicalRiskLevel } from "@/interfaces/risks";
-import { AvnuWrapper, EkuboQuoter, ERC20, LSTAPRService, PricerLST } from "@/modules";
+import {
+  DepegRiskLevel,
+  LiquidationRiskLevel,
+  SmartContractRiskLevel,
+  TechnicalRiskLevel,
+} from "@/interfaces/risks";
+import {
+  AvnuWrapper,
+  EkuboQuoter,
+  ERC20,
+  LSTAPRService,
+  PricerLST,
+} from "@/modules";
 import { assert, logger } from "@/utils";
 import { SingleTokenInfo } from "./base-strategy";
 import { Call, Contract, uint256 } from "starknet";
 import ERC4626Abi from "@/data/erc4626.abi.json";
 import { HealthFactorMath } from "@/utils/health-factor-math";
 import { findMaxInputWithSlippage } from "@/utils/math-utils";
+import { LSTPriceType } from "./types";
 
 export interface HyperLSTStrategySettings extends UniversalStrategySettings {
-  borrowable_assets: { token: TokenInfo, poolId: ContractAddr }[];
+  borrowable_assets: { token: TokenInfo; poolId: ContractAddr }[];
   underlyingToken: TokenInfo;
   defaultPoolId: ContractAddr;
 }
 
 export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
-  
   private quoteAmountToFetchPrice = new Web3Number(1, 18);
-  
-  constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<HyperLSTStrategySettings>) {
+
+  constructor(
+    config: IConfig,
+    pricer: PricerBase,
+    metadata: IStrategyMetadata<HyperLSTStrategySettings>,
+  ) {
     super(config, pricer, metadata);
 
-    const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
+    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);
+      this.quoteAmountToFetchPrice = new Web3Number(
+        0.01,
+        this.asset().decimals,
+      );
     }
   }
 
   asset() {
-    return this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId).config.collateral;
+    return this.getVesuSameTokenAdapter(
+      this.metadata.additionalInfo.defaultPoolId,
+    ).config.collateral;
   }
 
   getTag() {
@@ -47,7 +108,13 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
   // Vesu adapter with LST and base token match
   getVesuSameTokenAdapter(poolId: ContractAddr) {
-    const baseAdapter = this.getAdapter(getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, this.metadata.additionalInfo.underlyingToken.symbol, poolId.toString())) as VesuAdapter;
+    const baseAdapter = this.getAdapter(
+      getVesuLegId(
+        UNIVERSAL_MANAGE_IDS.VESU_LEG1,
+        this.metadata.additionalInfo.underlyingToken.symbol,
+        poolId.toString(),
+      ),
+    ) as VesuAdapter;
     baseAdapter.networkConfig = this.config;
     baseAdapter.pricer = this.pricer;
     return baseAdapter;
@@ -57,7 +124,8 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   // todo support lending assets of underlying as well (like if xSTRK looping is not viable, simply supply STRK)
   getVesuAdapters() {
     const adapters: VesuAdapter[] = [];
-    for (const borrowableInfo of this.metadata.additionalInfo.borrowable_assets) {
+    for (const borrowableInfo of this.metadata.additionalInfo
+      .borrowable_assets) {
       // do not add adapter if the pool id does not match
       const asset = borrowableInfo.token;
       const poolId = borrowableInfo.poolId;
@@ -66,8 +134,8 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
         collateral: this.asset(),
         debt: asset,
         vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
-        id: ''
-      })
+        id: "",
+      });
       vesuAdapter1.pricer = this.pricer;
       vesuAdapter1.networkConfig = this.config;
       adapters.push(vesuAdapter1);
@@ -79,7 +147,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   // No rewards on collateral or borrowing of LST assets
   protected async getRewardsAUM(prevAum: Web3Number): Promise<Web3Number> {
     const lstToken = this.asset();
-    if (lstToken.symbol === 'xSTRK') {
+    if (lstToken.symbol === "xSTRK") {
       return super.getRewardsAUM(prevAum);
     }
     return Web3Number.fromWei("0", lstToken.decimals);
@@ -92,110 +160,163 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     const quote = await ekuboQuoter.getQuote(
       lstTokenInfo.address.address,
       lstUnderlyingTokenInfo.address.address,
-      this.quoteAmountToFetchPrice
+      this.quoteAmountToFetchPrice,
     );
 
     // in Underlying
-    const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
-    const price = outputAmount.toNumber() / this.quoteAmountToFetchPrice.toNumber();
+    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 getAvnuSwapMultiplyCall(params: {
-    isDeposit: boolean,
-    leg1DepositAmount: Web3Number
+    isDeposit: boolean;
+    leg1DepositAmount: Web3Number;
   }) {
-    assert(params.isDeposit, 'Only deposit is supported in getAvnuSwapMultiplyCall')
+    assert(
+      params.isDeposit,
+      "Only deposit is supported in getAvnuSwapMultiplyCall",
+    );
     // TODO use a varibale for 1.02
-    const maxBorrowableAmounts = await this.getMaxBorrowableAmount({ isAPYComputation: false });
+    const maxBorrowableAmounts = await this.getMaxBorrowableAmount({
+      isAPYComputation: false,
+    });
     const allVesuAdapters = this.getVesuAdapters();
     let remainingAmount = params.leg1DepositAmount;
     const lstExRate = await this.getLSTExchangeRate();
-    const baseAssetPrice = await this.pricer.getPrice(this.getLSTUnderlyingTokenInfo().symbol);
+    const baseAssetPrice = await this.pricer.getPrice(
+      this.getLSTUnderlyingTokenInfo().symbol,
+    );
     const lstPrice = baseAssetPrice.price * lstExRate;
     for (let i = 0; i < maxBorrowableAmounts.maxBorrowables.length; i++) {
       const maxBorrowable = maxBorrowableAmounts.maxBorrowables[i];
-      const vesuAdapter = allVesuAdapters.find(adapter => adapter.config.debt.address.eq(maxBorrowable.borrowableAsset.address));
+      const vesuAdapter = allVesuAdapters.find((adapter) =>
+        adapter.config.debt.address.eq(maxBorrowable.borrowableAsset.address),
+      );
       if (!vesuAdapter) {
-        throw new Error(`${this.getTag()}::getAvnuSwapMultiplyCall: vesuAdapter not found for borrowable asset: ${maxBorrowable.borrowableAsset.symbol}`);
+        throw new Error(
+          `${this.getTag()}::getAvnuSwapMultiplyCall: vesuAdapter not found for borrowable asset: ${maxBorrowable.borrowableAsset.symbol}`,
+        );
       }
       const maxLTV = await vesuAdapter.getLTVConfig(this.config);
-      const debtPrice = await this.pricer.getPrice(maxBorrowable.borrowableAsset.symbol);
-      const maxAmountToDeposit = HealthFactorMath.getMinCollateralRequiredOnLooping(
-        maxBorrowable.amount,
-        debtPrice.price,
-        this.metadata.additionalInfo.targetHealthFactor,
-        maxLTV,
-        lstPrice,
-        this.asset()
-      )
+      const debtPrice = await this.pricer.getPrice(
+        maxBorrowable.borrowableAsset.symbol,
+      );
+      const maxAmountToDeposit =
+        HealthFactorMath.getMinCollateralRequiredOnLooping(
+          maxBorrowable.amount,
+          debtPrice.price,
+          this.metadata.additionalInfo.targetHealthFactor,
+          maxLTV,
+          lstPrice,
+          this.asset(),
+        );
       const amountToDeposit = remainingAmount.minimum(maxAmountToDeposit);
-      logger.verbose(`${this.getTag()}::getAvnuSwapMultiplyCall::${vesuAdapter.config.debt.symbol}:: remainingAmount: ${remainingAmount}, amountToDeposit: ${amountToDeposit}, depositAmount: ${amountToDeposit}, maxBorrowable: ${maxBorrowable.amount}`);
+      logger.verbose(
+        `${this.getTag()}::getAvnuSwapMultiplyCall::${vesuAdapter.config.debt.symbol}:: remainingAmount: ${remainingAmount}, amountToDeposit: ${amountToDeposit}, depositAmount: ${amountToDeposit}, maxBorrowable: ${maxBorrowable.amount}`,
+      );
       const call = await this._getAvnuDepositSwapLegCall({
         isDeposit: params.isDeposit,
         // adjust decimals of debt asset
         leg1DepositAmount: amountToDeposit,
         minHF: 1.1, // undo
-        vesuAdapter: vesuAdapter
+        vesuAdapter: vesuAdapter,
       });
       remainingAmount = remainingAmount.minus(amountToDeposit);
 
       // return the first possible call because computing all calls at a time
       // is not efficinet for swaps
-      return {call, vesuAdapter};
+      return { call, vesuAdapter };
     }
-    throw new Error(`${this.getTag()}::getAvnuSwapMultiplyCall: no calls found`);
+    throw new Error(
+      `${this.getTag()}::getAvnuSwapMultiplyCall: no calls found`,
+    );
   }
 
   async _getAvnuDepositSwapLegCall(params: {
-    isDeposit: boolean,
-    leg1DepositAmount: Web3Number, 
-    minHF: number, // e.g. 1.01
-    vesuAdapter: VesuAdapter
+    isDeposit: boolean;
+    leg1DepositAmount: Web3Number;
+    minHF: number; // e.g. 1.01
+    vesuAdapter: VesuAdapter;
   }) {
     const { vesuAdapter } = params;
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall params: ${JSON.stringify(params)}`);
-    assert(params.isDeposit, 'Only deposit is supported in _getAvnuDepositSwapLegCall')
+    logger.verbose(
+      `${this.getTag()}::_getAvnuDepositSwapLegCall params: ${JSON.stringify(params)}`,
+    );
+    assert(
+      params.isDeposit,
+      "Only deposit is supported in _getAvnuDepositSwapLegCall",
+    );
     // add collateral
     // borrow STRK (e.g.)
     // approve and swap strk
     // add collateral again
 
-    
     const legLTV = await vesuAdapter.getLTVConfig(this.config);
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall legLTV: ${legLTV}`);
+    logger.verbose(
+      `${this.getTag()}::_getAvnuDepositSwapLegCall legLTV: ${legLTV}`,
+    );
     const existingPositions = await vesuAdapter.getPositions(this.config);
-    const collateralisation = await vesuAdapter.getCollateralization(this.config);
+    const collateralisation = await vesuAdapter.getCollateralization(
+      this.config,
+    );
     const existingCollateralInfo = existingPositions[0];
     const existingDebtInfo = existingPositions[1];
     logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
     existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
 
     // - Prices as seen by Vesu contracts, ideal for HF math
-    // Price 1 is ok as fallback bcz that would relatively price the 
+    // Price 1 is ok as fallback bcz that would relatively price the
     // collateral and debt as equal.
-    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
-    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
-    logger.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
-
+    const collateralPrice =
+      collateralisation[0].usdValue > 0
+        ? collateralisation[0].usdValue /
+          existingCollateralInfo.amount.toNumber()
+        : 1;
+    const debtPrice =
+      collateralisation[1].usdValue > 0
+        ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber()
+        : 1;
+    logger.debug(
+      `${this.getTag()}::_getAvnuDepositSwapLegCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`,
+    );
 
     const debtTokenInfo = vesuAdapter.config.debt;
     let newDepositAmount = params.leg1DepositAmount;
-    const totalCollateral = existingCollateralInfo.amount.plus(params.leg1DepositAmount);
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalCollateral: ${totalCollateral}`);
+    const totalCollateral = existingCollateralInfo.amount.plus(
+      params.leg1DepositAmount,
+    );
+    logger.verbose(
+      `${this.getTag()}::_getAvnuDepositSwapLegCall totalCollateral: ${totalCollateral}`,
+    );
     const totalDebtAmount = new Web3Number(
-      totalCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(debtPrice).dividedBy(params.minHF).toString(),
-      debtTokenInfo.decimals
+      totalCollateral
+        .multipliedBy(collateralPrice)
+        .multipliedBy(legLTV)
+        .dividedBy(debtPrice)
+        .dividedBy(params.minHF)
+        .toString(),
+      debtTokenInfo.decimals,
     );
     let debtAmount = totalDebtAmount.minus(existingDebtInfo.amount);
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalDebtAmount: ${totalDebtAmount}, initial computed debt: ${debtAmount}`);
-    const maxBorrowable = await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, false);
+    logger.verbose(
+      `${this.getTag()}::_getAvnuDepositSwapLegCall totalDebtAmount: ${totalDebtAmount}, initial computed debt: ${debtAmount}`,
+    );
+    const maxBorrowable = await this.getMaxBorrowableAmountByVesuAdapter(
+      vesuAdapter,
+      false,
+    );
 
     // if the debt amount is greater than 0 and the max borrowable amount is 0, skip
     if (debtAmount.gt(0) && maxBorrowable.amount.eq(0)) {
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall maxBorrowable is 0, skipping`);
+      logger.verbose(
+        `${this.getTag()}::_getAvnuDepositSwapLegCall maxBorrowable is 0, skipping`,
+      );
       return undefined;
     } else if (debtAmount.gt(0) && maxBorrowable.amount.gt(0)) {
       debtAmount = maxBorrowable.amount.minimum(debtAmount);
@@ -206,58 +327,78 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
         params.minHF,
         legLTV,
         collateralPrice,
-        this.asset()
+        this.asset(),
+      );
+      newDepositAmount = totalCollateralRequired.minus(
+        existingCollateralInfo.amount,
       );
-      newDepositAmount = totalCollateralRequired.minus(existingCollateralInfo.amount);
       if (newDepositAmount.lt(0)) {
-        throw new Error(`${this.getTag()}::_getAvnuDepositSwapLegCall newDepositAmount is less than 0, newDepositAmount: ${newDepositAmount}, totalCollateralRequired: ${totalCollateralRequired}, existingCollateralInfo.amount: ${existingCollateralInfo.amount}`);
+        throw new Error(
+          `${this.getTag()}::_getAvnuDepositSwapLegCall newDepositAmount is less than 0, newDepositAmount: ${newDepositAmount}, totalCollateralRequired: ${totalCollateralRequired}, existingCollateralInfo.amount: ${existingCollateralInfo.amount}`,
+        );
       }
       if (newDebtUSDValue.toNumber() < 100) {
         // too less debt, skip
-        logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newDebtUSDValue is less than 100, skipping`);
+        logger.verbose(
+          `${this.getTag()}::_getAvnuDepositSwapLegCall newDebtUSDValue is less than 100, skipping`,
+        );
         return undefined;
       }
     }
 
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
+    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({
         isDeposit: false,
         leg1DepositAmount: debtAmountInLST,
-        poolId: vesuAdapter.config.poolId
-      })
-      assert(calls.length == 1, `Expected 1 call for unwind, got ${calls.length}`);
+        poolId: vesuAdapter.config.poolId,
+      });
+      assert(
+        calls.length == 1,
+        `Expected 1 call for unwind, got ${calls.length}`,
+      );
       return calls[0];
     }
-    console.log(`debtAmount`, debtAmount.toWei(), params.leg1DepositAmount.toWei());
+    // console.log(`debtAmount`, debtAmount.toWei(), params.leg1DepositAmount.toWei());
     const STEP0 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
     const manage0Info = this.getProofs<ApproveCallParams>(STEP0);
     const manageCall0 = manage0Info.callConstructor({
-      amount: newDepositAmount
+      amount: newDepositAmount,
     });
-    const STEP1 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol, vesuAdapter.config.poolId.toString());
+    const STEP1 = getVesuLegId(
+      UNIVERSAL_MANAGE_IDS.VESU_LEG1,
+      vesuAdapter.config.debt.symbol,
+      vesuAdapter.config.poolId.toString(),
+    );
     const manage1Info = this.getProofs<VesuModifyPositionCallParams>(STEP1);
-    const manageCall1 = manage1Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
+    const manageCall1 = manage1Info.callConstructor(
+      VesuAdapter.getDefaultModifyPositionCallParams({
         collateralAmount: newDepositAmount,
         isAddCollateral: params.isDeposit,
         debtAmount: debtAmount,
-        isBorrow: params.isDeposit
-    }));
+        isBorrow: params.isDeposit,
+      }),
+    );
+
+    // console.log(`manageCall1`, manageCall1.call, debtAmount.toWei(), newDepositAmount.toWei());
 
-    console.log(`manageCall1`, manageCall1.call, debtAmount.toWei(), newDepositAmount.toWei());
-    
     const proofIds: string[] = [STEP0, STEP1];
     const manageCalls: ManageCall[] = [manageCall0, manageCall1];
 
     // approve and swap to LST using avnu
     if (debtAmount.gt(0)) {
-      const STEP2 = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT, vesuAdapter.config.debt.symbol);
+      const STEP2 = getAvnuManageIDs(
+        LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT,
+        vesuAdapter.config.debt.symbol,
+      );
       const manage2Info = this.getProofs<ApproveCallParams>(STEP2);
       const manageCall2 = manage2Info.callConstructor({
-        amount: debtAmount
+        amount: debtAmount,
       });
 
       const debtTokenInfo = vesuAdapter.config.debt;
@@ -267,51 +408,75 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
         debtTokenInfo.address.address,
         lstTokenInfo.address.address,
         debtAmount.toWei(),
-        this.metadata.additionalInfo.vaultAllocator.address
+        this.metadata.additionalInfo.vaultAllocator.address,
       );
       const minAmount = await this._getMinOutputAmountLSTBuy(debtAmount);
-      const minAmountWei = (minAmount).toWei();
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall minAmount: ${minAmount}`);
+      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
+        minAmountWei,
+      );
+      logger.verbose(
+        `${this.getTag()}::_getAvnuDepositSwapLegCall swapInfo: ${JSON.stringify(swapInfo)}`,
+      );
+      const STEP3 = getAvnuManageIDs(
+        LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT,
+        vesuAdapter.config.debt.symbol,
       );
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall swapInfo: ${JSON.stringify(swapInfo)}`);
-      const STEP3 = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT, vesuAdapter.config.debt.symbol);
       const manage3Info = this.getProofs<AvnuSwapCallParams>(STEP3);
       const manageCall3 = manage3Info.callConstructor({
-        props: swapInfo
+        props: swapInfo,
       });
       proofIds.push(STEP2);
       proofIds.push(STEP3);
       manageCalls.push(manageCall2, manageCall3);
 
-
       // if the created debt, when added is collateral will put the total HF above min, but below (target + 0.05),
-      // then lets close the looping cycle by adding this as collateral. 
+      // then lets close the looping cycle by adding this as collateral.
       const newCollateral = minAmount.plus(totalCollateral);
-      const newHF = newCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(totalDebtAmount).dividedBy(debtPrice).toNumber();
-      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF: ${newHF}`);
-      if (newHF > this.metadata.additionalInfo.minHealthFactor && newHF < this.metadata.additionalInfo.targetHealthFactor + 0.05) {
-        logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newHF is above min and below target + 0.05, adding collateral on vesu`);
+      const newHF = newCollateral
+        .multipliedBy(collateralPrice)
+        .multipliedBy(legLTV)
+        .dividedBy(totalDebtAmount)
+        .dividedBy(debtPrice)
+        .toNumber();
+      logger.verbose(
+        `${this.getTag()}::_getAvnuDepositSwapLegCall newHF: ${newHF}`,
+      );
+      if (
+        newHF > this.metadata.additionalInfo.minHealthFactor &&
+        newHF < this.metadata.additionalInfo.targetHealthFactor + 0.05
+      ) {
+        logger.verbose(
+          `${this.getTag()}::_getAvnuDepositSwapLegCall newHF is above min and below target + 0.05, adding collateral on vesu`,
+        );
         // approve and add collateral on vesu (modify position)
         const STEP4 = UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1;
         const manage4Info = this.getProofs<ApproveCallParams>(STEP4);
         const manageCall4 = manage4Info.callConstructor({
-          amount: minAmount
+          amount: minAmount,
         });
-       
-        const STEP5 = getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, vesuAdapter.config.debt.symbol, vesuAdapter.config.poolId.toString());
+
+        const STEP5 = getVesuLegId(
+          UNIVERSAL_MANAGE_IDS.VESU_LEG1,
+          vesuAdapter.config.debt.symbol,
+          vesuAdapter.config.poolId.toString(),
+        );
         const manage5Info = this.getProofs<VesuModifyPositionCallParams>(STEP5);
-        const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
-          collateralAmount: minAmount,
-          isAddCollateral: true,
-          debtAmount: Web3Number.fromWei('0', this.asset().decimals),
-          isBorrow: params.isDeposit
-        }));
+        const manageCall5 = manage5Info.callConstructor(
+          VesuAdapter.getDefaultModifyPositionCallParams({
+            collateralAmount: minAmount,
+            isAddCollateral: true,
+            debtAmount: Web3Number.fromWei("0", this.asset().decimals),
+            isBorrow: params.isDeposit,
+          }),
+        );
         proofIds.push(STEP4, STEP5);
         manageCalls.push(manageCall4, manageCall5);
       }
@@ -321,53 +486,78 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     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}[] }> {
+  async getLSTMultiplierRebalanceCall(): Promise<{
+    shouldRebalance: boolean;
+    manageCalls: { vesuAdapter: VesuAdapter; manageCall: Call }[];
+  }> {
     let shouldRebalance = false;
-    const calls: {vesuAdapter: VesuAdapter, manageCall: Call}[] = [];
+    const calls: { vesuAdapter: VesuAdapter; manageCall: Call }[] = [];
     // todo undo
-    const allVesuAdapters = this.getVesuAdapters().filter(vesuAdapter => vesuAdapter.config.debt.symbol === 'LBTC');
+    const allVesuAdapters = this.getVesuAdapters().filter(
+      (vesuAdapter) => vesuAdapter.config.debt.symbol === "LBTC",
+    );
     for (const vesuAdapter of allVesuAdapters) {
       const call = await this._getLSTMultiplierRebalanceCall(vesuAdapter);
       if (call.shouldRebalance && call.manageCall) {
         shouldRebalance = true;
-        calls.push({vesuAdapter, manageCall: call.manageCall});
+        calls.push({ vesuAdapter, manageCall: call.manageCall });
       }
     }
     return { shouldRebalance, manageCalls: calls };
   }
 
-  async _getLSTMultiplierRebalanceCall(vesuAdapter: VesuAdapter): Promise<{ shouldRebalance: boolean, manageCall: Call | undefined }> {
+  async _getLSTMultiplierRebalanceCall(
+    vesuAdapter: VesuAdapter,
+  ): Promise<{ shouldRebalance: boolean; manageCall: Call | undefined }> {
     const positions = await vesuAdapter.getPositions(this.config);
-    assert(positions.length == 2, 'Rebalance call is only supported for 2 positions');
+    assert(
+      positions.length == 2,
+      "Rebalance call is only supported for 2 positions",
+    );
     const existingCollateralInfo = positions[0];
     const existingDebtInfo = positions[1];
     const unusedBalance = await this.getUnusedBalance();
     const healthFactor = await vesuAdapter.getHealthFactor();
 
-    const collateralisation = await vesuAdapter.getCollateralization(this.config);
+    const collateralisation = await vesuAdapter.getCollateralization(
+      this.config,
+    );
     logger.debug(`${this.getTag()}::getVesuMultiplyCall::${vesuAdapter.config.debt.symbol} existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
     existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
 
     // - Prices as seen by Vesu contracts, ideal for HF math
-    // Price 1 is ok as fallback bcz that would relatively price the 
+    // Price 1 is ok as fallback bcz that would relatively price the
     // collateral and debt as equal.
-    const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : 1;
-    const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : 1;
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall healthFactor: ${healthFactor}`);
+    const collateralPrice =
+      collateralisation[0].usdValue > 0
+        ? collateralisation[0].usdValue /
+          existingCollateralInfo.amount.toNumber()
+        : 1;
+    const debtPrice =
+      collateralisation[1].usdValue > 0
+        ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber()
+        : 1;
+    logger.debug(
+      `${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`,
+    );
+    logger.debug(
+      `${this.getTag()}::getVesuMultiplyCall healthFactor: ${healthFactor}`,
+    );
 
-    const isHFTooLow = healthFactor < this.metadata.additionalInfo.minHealthFactor;
-    const isHFTooHigh = healthFactor > this.metadata.additionalInfo.targetHealthFactor + 0.05;
+    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. 
-        vesuAdapter
-      })
+        minHF: 1.02, // todo, shouldnt use this 1.02 HF, if there isn;t more looping left.
+        vesuAdapter,
+      });
       return { shouldRebalance: true, manageCall };
     } else {
       // do nothing
@@ -375,19 +565,61 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     }
   }
 
-  protected async getVesuAUM(adapter: VesuAdapter) {
+  protected async getVesuAUM(
+    adapter: VesuAdapter,
+    priceType: LSTPriceType = LSTPriceType.AVNU_PRICE,
+  ) {
     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');
+    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}`);
-    
+
+    // Get the price based on the price type
+    let tokenUnderlyingPrice: number;
+    if (priceType === LSTPriceType.ENDUR_PRICE) {
+      tokenUnderlyingPrice = await this.getLSTExchangeRate();
+      if (tokenUnderlyingPrice === 0) {
+        throw new Error(
+          `${this.getTag()}::getVesuAUM: tokenUnderlyingPrice (Endur) is 0`,
+        );
+      }
+
+      // For Endur price, also check against Avnu rate to ensure they're within 2%
+      const avnuRate = await this.getLSTAvnuRate();
+      if (avnuRate === 0) {
+        throw new Error(
+          `${this.getTag()}::getVesuAUM: tokenUnderlyingPrice (Avnu) is 0`,
+        );
+      }
+
+      const diff =
+        Math.abs(tokenUnderlyingPrice - avnuRate) / tokenUnderlyingPrice;
+      if (diff > 0.02) {
+        throw new Error(
+          `${this.getTag()}::getVesuAUM: 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()}::getVesuAUM: tokenUnderlyingPrice (Avnu) is 0`,
+        );
+      }
+      logger.verbose(
+        `${this.getTag()} tokenUnderlyingPrice (Avnu): ${tokenUnderlyingPrice}`,
+      );
+    }
+
     // handle collateral
     if (legAUM[0].token.address.eq(underlying.address)) {
       vesuAum = vesuAum.plus(legAUM[0].amount);
@@ -400,40 +632,82 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
       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()}`);
+    const priceTypeLabel =
+      priceType === LSTPriceType.ENDUR_PRICE ? "Endur Price" : "Avnu Price";
+    logger.verbose(
+      `${this.getTag()} Vesu AUM (${priceTypeLabel}): ${vesuAum}, legCollateral: ${legAUM[0].amount.toNumber()}, legDebt: ${legAUM[1].amount.toNumber()}`,
+    );
     return vesuAum;
   }
 
+  async getTVLUnrealized(): Promise<{
+    net: SingleTokenInfo;
+    prevAum: Web3Number;
+    splits: { id: string; aum: Web3Number }[];
+  }> {
+    return await this.getAUM(true);
+  }
+
+  async getUserUnrealizedGains(user: ContractAddr) {
+    // Get total TVL (realized)
+    const tvl = await this.getTVL();
+
+    // Get unrealized TVL (using Endur prices)
+    const unrealizedTVL = await this.getTVLUnrealized();
+
+    // Calculate the difference between unrealized and realized TVL
+    const unrealizedDiff = unrealizedTVL.net.amount.minus(tvl.amount);
+
+    // Get user's TVL
+    const userTVL = await this.getUserTVL(user);
+
+    // Calculate user's share of the total TVL
+    const userShare = userTVL.amount.dividedBy(tvl.amount);
+
+    // Calculate user's unrealized gains (in token amount)
+    const unrealizedGains = unrealizedDiff.multipliedBy(userShare);
+
+    return {
+      unrealizedGains,
+      userShare: userShare.toNumber(),
+      tokenInfo: this.asset(),
+    };
+  }
+
   //
   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
+    // 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);
+    // 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 getVesuMultiplyCall(params: {
-    isDeposit: boolean,
-    leg1DepositAmount: Web3Number,
-    maxEkuboPriceImpact?: number,
-    poolId: ContractAddr
+    isDeposit: boolean;
+    leg1DepositAmount: Web3Number;
+    maxEkuboPriceImpact?: number;
+    poolId: ContractAddr;
   }) {
     const maxEkuboPriceImpact = params.maxEkuboPriceImpact || 0.01;
     const vesuAdapter1 = this.getVesuSameTokenAdapter(params.poolId);
@@ -441,10 +715,12 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     logger.verbose(`${this.getTag()}::getVesuMultiplyCall legLTV: ${legLTV}`);
 
     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()}`);
+      logger.verbose(
+        `${this.getTag()}::getVesuMultiplyCall unusedBalance: ${unusedBalance.amount.toString()}, required: ${params.leg1DepositAmount.toString()}`,
+      );
       // undo
       // if (unusedBalance.amount.gte(params.leg1DepositAmount)) {
       //   return [];
@@ -453,51 +729,85 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     }
 
     const existingPositions = await vesuAdapter1.getPositions(this.config);
-    const collateralisation = await vesuAdapter1.getCollateralization(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 
+    // 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}`);
+    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). 
+    // 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}`);
+    const addedCollateral = params.leg1DepositAmount.multipliedBy(
+      params.isDeposit ? 1 : -1,
+    );
+    logger.verbose(
+      `${this.getTag()}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`,
+    );
+    const numeratorPart1 = existingCollateralInfo.amount
+      .plus(addedCollateral)
+      .multipliedBy(collateralPrice)
+      .multipliedBy(legLTV);
+    logger.verbose(
+      `${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`,
+    );
+    const numeratorPart2 = existingDebtInfo.amount
+      .multipliedBy(debtPrice)
+      .multipliedBy(this.metadata.additionalInfo.targetHealthFactor);
+    logger.verbose(
+      `${this.getTag()}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`,
+    );
+    const denominatorPart =
+      this.metadata.additionalInfo.targetHealthFactor - legLTV / dexPrice;
+    logger.verbose(
+      `${this.getTag()}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`,
+    );
+    const x_debt_usd = numeratorPart1
+      .minus(numeratorPart2)
+      .dividedBy(denominatorPart);
+    logger.verbose(
+      `${this.getTag()}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`,
+    );
+    logger.debug(
+      `${this.getTag()}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`,
+    );
 
     // both in underlying
     let debtAmount = x_debt_usd.dividedBy(debtPrice);
     const marginAmount = addedCollateral;
-    logger.verbose(`${this.getTag()}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
+    logger.verbose(
+      `${this.getTag()}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`,
+    );
 
     if (marginAmount.lt(0) && debtAmount.gt(0)) {
       // if we want to withdraw, but debt can go high, its conflicting between
-      // increasing and reducing lever. and in this case, the HF will go high, 
-      // which is ok. 
+      // increasing and reducing lever. and in this case, the HF will go high,
+      // which is ok.
       debtAmount = Web3Number.fromWei(0, this.asset().decimals);
     }
 
@@ -514,38 +824,69 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
       lstDexPriceInUnderlying: dexPrice,
       isIncrease: debtAmount.greaterThan(0),
       maxEkuboPriceImpact,
-      poolId: params.poolId
+      poolId: params.poolId,
     });
   }
 
   getLSTUnderlyingTokenInfo() {
-    const vesuAdapter1 = this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId);
+    const vesuAdapter1 = this.getVesuSameTokenAdapter(
+      this.metadata.additionalInfo.defaultPoolId,
+    );
     return vesuAdapter1.config.debt;
   }
 
-  async getMaxBorrowableAmount(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
+  async getMaxBorrowableAmount(
+    params: { isAPYComputation: boolean } = { isAPYComputation: false },
+  ) {
     const vesuAdapters = this.getVesuAdapters();
-    let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
-    const maxBorrowables: {amount: Web3Number, dexSwappableAmount: Web3Number, maxBorrowableAmount: Web3Number, borrowableAsset: TokenInfo, ltv: number}[] = [];
+    let netMaxBorrowableAmount = Web3Number.fromWei(
+      "0",
+      this.getLSTUnderlyingTokenInfo().decimals,
+    );
+    const maxBorrowables: {
+      amount: Web3Number;
+      dexSwappableAmount: Web3Number;
+      maxBorrowableAmount: Web3Number;
+      borrowableAsset: TokenInfo;
+      ltv: number;
+    }[] = [];
     for (const vesuAdapter of vesuAdapters) {
-      const output = await this.getMaxBorrowableAmountByVesuAdapter(vesuAdapter, params.isAPYComputation);
+      const output = await this.getMaxBorrowableAmountByVesuAdapter(
+        vesuAdapter,
+        params.isAPYComputation,
+      );
       const ltv = await vesuAdapter.getLTVConfig(this.config);
-      maxBorrowables.push({...output, ltv});
+      maxBorrowables.push({ ...output, ltv });
     }
     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};
+    netMaxBorrowableAmount = maxBorrowables.reduce(
+      (acc, curr) => acc.plus(curr.amount),
+      Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals),
+    );
+    return { netMaxBorrowableAmount, maxBorrowables };
   }
 
-  // recursively, using binary search computes max swappable. 
+  // 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) {
+  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();
+        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,
@@ -555,48 +896,103 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     return new Web3Number(output.optimalInput, fromToken.decimals);
   }
 
-  async getMaxBorrowableAmountByVesuAdapter(vesuAdapter: VesuAdapter, isAPYComputation: boolean) {
-    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
+  async getMaxBorrowableAmountByVesuAdapter(
+    vesuAdapter: VesuAdapter,
+    isAPYComputation: boolean,
+  ) {
+    const lstAPY = await this.getLSTAPR(
+      this.getLSTUnderlyingTokenInfo().address,
+    );
     const maxInterestRate = lstAPY * 0.8;
-    const {maxDebtToHave: maxBorrowableAmount, currentDebt} = await vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxInterestRate);
+    const { maxDebtToHave: maxBorrowableAmount, currentDebt } =
+      await vesuAdapter.getMaxBorrowableByInterestRate(
+        this.config,
+        vesuAdapter.config.debt,
+        maxInterestRate,
+      );
     const debtCap = await vesuAdapter.getDebtCap(this.config);
 
     if (currentDebt.gte(debtCap)) {
-      return {amount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals), dexSwappableAmount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals), maxBorrowableAmount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals), borrowableAsset: vesuAdapter.config.debt};
+      return {
+        amount: Web3Number.fromWei("0", vesuAdapter.config.debt.decimals),
+        dexSwappableAmount: Web3Number.fromWei(
+          "0",
+          vesuAdapter.config.debt.decimals,
+        ),
+        maxBorrowableAmount: Web3Number.fromWei(
+          "0",
+          vesuAdapter.config.debt.decimals,
+        ),
+        borrowableAsset: vesuAdapter.config.debt,
+      };
     }
 
     const availableToBorrow = debtCap.minus(currentDebt);
 
-    const maxBorrowable = maxBorrowableAmount.minimum(availableToBorrow).multipliedBy(0.999);
+    const maxBorrowable = maxBorrowableAmount
+      .minimum(availableToBorrow)
+      .multipliedBy(0.999);
     // Dont compute precise max swappable for APY computation
-    if (vesuAdapter.config.debt.address.eq(this.getLSTUnderlyingTokenInfo().address) || isAPYComputation) {
-      return {amount: maxBorrowable, dexSwappableAmount: maxBorrowable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt};
+    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};
+      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};
-    } 
+      const maxSwappable = Web3Number.fromWei(
+        "0",
+        vesuAdapter.config.debt.decimals,
+      );
+      return {
+        amount: maxBorrowable.minimum(maxSwappable),
+        dexSwappableAmount: maxSwappable,
+        maxBorrowableAmount: maxBorrowable,
+        borrowableAsset: vesuAdapter.config.debt,
+      };
+    }
   }
 
   // todo how much to unwind to get back healthy APY zone again
   // if net APY < LST APR + 0.5%, we need to unwind to get back to LST APR + 1% atleast or 0 vesu position
-  // For xSTRK, simply deposit in Vesu if looping is not viable 
-  
+  // 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(this.metadata.additionalInfo.defaultPoolId);
-      const apr = await LSTAPRService.getLSTAPR(vesuAdapter1.config.debt.address);
+      const vesuAdapter1 = this.getVesuSameTokenAdapter(
+        this.metadata.additionalInfo.defaultPoolId,
+      );
+      const apr = await LSTAPRService.getLSTAPR(
+        vesuAdapter1.config.debt.address,
+      );
       if (!apr) {
-        throw new Error('Failed to get LST APR');
+        throw new Error("Failed to get LST APR");
       }
       return apr;
     } catch (error) {
@@ -606,88 +1002,170 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   }
 
   // todo undo this
-  async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
+  async netAPY(): Promise<{
+    net: number;
+    splits: { apy: number; id: string }[];
+  }> {
     const unusedBalance = await this.getUnusedBalance();
-    const maxNewDeposits = await this.maxNewDeposits({ isAPYComputation: true });
-    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
+    const maxNewDeposits = await this.maxNewDeposits({
+      isAPYComputation: true,
+    });
+    const lstAPY = await this.getLSTAPR(
+      this.getLSTUnderlyingTokenInfo().address,
+    );
 
     // if unused balance is > max servicable from loan, we are limited by the max borrowing we can do
     // we also allow accepting little higher deposits (1.5x) to have room for future looping when theres more liquidity or debt cap rises
     if (maxNewDeposits * 1.5 < unusedBalance.amount.toNumber()) {
       // we have excess, just use real APY
-      logger.verbose(`${this.getTag()}::netAPY: unused balance is > max servicable from loan, lstAPY: ${lstAPY}`);
+      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'});
+      output.splits.push({ apy: lstAPY, id: "lst_apy" });
       return output;
     } else {
       // we have little bit room to accept more deposits, we use theoretical max APY
-      logger.verbose(`${this.getTag()}::netAPY: we can take more deposits, use theoretical max APY`);
+      logger.verbose(
+        `${this.getTag()}::netAPY: we can take more deposits, use theoretical max APY`,
+      );
       const { positions, baseAPYs, rewardAPYs } = await this.getVesuAPYs();
-      const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+      const weights = positions.map(
+        (p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1),
+      );
       const aum = weights.reduce((acc, curr) => acc + curr, 0);
-      const output = await this.returnNetAPY(baseAPYs, rewardAPYs, weights, new Web3Number(aum.toFixed(9), this.getLSTUnderlyingTokenInfo().decimals));
-      output.splits.push({apy: lstAPY, id: 'lst_apy'});
+      const output = await this.returnNetAPY(
+        baseAPYs,
+        rewardAPYs,
+        weights,
+        new Web3Number(
+          aum.toFixed(9),
+          this.getLSTUnderlyingTokenInfo().decimals,
+        ),
+      );
+      output.splits.push({ apy: lstAPY, id: "lst_apy" });
       return output;
     }
   }
 
-  async maxNewDeposits(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
+  async maxNewDeposits(
+    params: { isAPYComputation: boolean } = { isAPYComputation: false },
+  ) {
     const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
     let numerator = 0;
 
     let ltv: number | undefined = undefined;
     for (let adapter of this.getVesuAdapters()) {
-      const maxBorrowableAmountInfo = maxBorrowableAmounts.maxBorrowables.find(b => b.borrowableAsset.address.eq(adapter.config.debt.address));
+      const maxBorrowableAmountInfo = maxBorrowableAmounts.maxBorrowables.find(
+        (b) => b.borrowableAsset.address.eq(adapter.config.debt.address),
+      );
       if (!maxBorrowableAmountInfo || !maxBorrowableAmountInfo?.amount) {
-        throw new Error(`Max borrowable amount not found for adapter: ${adapter.config.debt.symbol}`);
+        throw new Error(
+          `Max borrowable amount not found for adapter: ${adapter.config.debt.symbol}`,
+        );
       }
 
-      numerator += this.metadata.additionalInfo.targetHealthFactor * maxBorrowableAmountInfo.amount.toNumber() / maxBorrowableAmountInfo.ltv;
+      numerator +=
+        (this.metadata.additionalInfo.targetHealthFactor *
+          maxBorrowableAmountInfo.amount.toNumber()) /
+        maxBorrowableAmountInfo.ltv;
     }
 
-    return  numerator - maxBorrowableAmounts.netMaxBorrowableAmount.toNumber();
+    return numerator - maxBorrowableAmounts.netMaxBorrowableAmount.toNumber();
   }
 
   // todo revisit cases where 0th adapters is used
   protected async getUnusedBalanceAPY() {
     const unusedBalance = await this.getUnusedBalance();
-    const vesuAdapter = this.getVesuSameTokenAdapter(this.metadata.additionalInfo.defaultPoolId);
+    const vesuAdapter = this.getVesuSameTokenAdapter(
+      this.metadata.additionalInfo.defaultPoolId,
+    );
     const underlying = vesuAdapter.config.debt;
     const lstAPY = await this.getLSTAPR(underlying.address);
     return {
-      apy: lstAPY, weight: unusedBalance.usdValue
-    }
+      apy: lstAPY,
+      weight: unusedBalance.usdValue,
+    };
+  }
+
+  async getLSTAvnuRate() {
+    const vesuAdapter1 = this.getVesuSameTokenAdapter(
+      this.metadata.additionalInfo.defaultPoolId,
+    );
+    const lstTokenInfo = vesuAdapter1.config.collateral;
+    const underlyingTokenInfo = vesuAdapter1.config.debt;
+
+    const avnuModule = new AvnuWrapper();
+
+    const sellAmount = lstTokenInfo.priceCheckAmount
+      ? new Web3Number(
+          lstTokenInfo.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(this.metadata.additionalInfo.defaultPoolId);
+    const vesuAdapter1 = this.getVesuSameTokenAdapter(
+      this.metadata.additionalInfo.defaultPoolId,
+    );
     const lstTokenInfo = vesuAdapter1.config.collateral;
     const lstABI = new Contract({
       abi: ERC4626Abi,
       address: lstTokenInfo.address.address,
-      providerOrAccount: this.config.provider
+      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);
+    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;
-   }
+  }
 
   /**
-   * 
+   *
    * @param params marginAmount is in LST, debtAmount is in underlying
    */
   async getModifyLeverCall(params: {
-    marginAmount: Web3Number, // >0 during deposit
-    debtAmount: Web3Number,
-    lstDexPriceInUnderlying: number,
-    isIncrease: boolean,
-    maxEkuboPriceImpact: number,
-    poolId: ContractAddr
+    marginAmount: Web3Number; // >0 during deposit
+    debtAmount: Web3Number;
+    lstDexPriceInUnderlying: number;
+    isIncrease: boolean;
+    maxEkuboPriceImpact: number;
+    poolId: ContractAddr;
   }): Promise<Call[]> {
-    logger.verbose(`${this.getTag()}::getModifyLeverCall marginAmount: ${params.marginAmount}, debtAmount: ${params.debtAmount}, lstDexPriceInUnderlying: ${params.lstDexPriceInUnderlying}, isIncrease: ${params.isIncrease}`);
-    assert(!params.marginAmount.isZero() || !params.debtAmount.isZero(), 'Deposit/debt must be non-0');
+    logger.verbose(
+      `${this.getTag()}::getModifyLeverCall marginAmount: ${params.marginAmount}, debtAmount: ${params.debtAmount}, lstDexPriceInUnderlying: ${params.lstDexPriceInUnderlying}, isIncrease: ${params.isIncrease}`,
+    );
+    assert(
+      !params.marginAmount.isZero() || !params.debtAmount.isZero(),
+      "Deposit/debt must be non-0",
+    );
 
     const vesuAdapter1 = this.getVesuSameTokenAdapter(params.poolId);
     const lstTokenInfo = this.asset();
@@ -695,9 +1173,11 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
     // todo make it more general
     // 500k STRK (~75k$) or 0.5 BTC (~60k$)
-    const maxAmounts = lstTokenInfo.symbol == 'xSTRK' ? 500000 : 0.5;
+    const maxAmounts = lstTokenInfo.symbol == "xSTRK" ? 500000 : 0.5;
     if (params.marginAmount.greaterThan(maxAmounts)) {
-      throw new Error(`Margin amount is greater than max amount: ${params.marginAmount.toNumber()} > ${maxAmounts}`);
+      throw new Error(
+        `Margin amount is greater than max amount: ${params.marginAmount.toNumber()} > ${maxAmounts}`,
+      );
     }
 
     const proofsIDs: string[] = [];
@@ -705,12 +1185,15 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
     // approve token
     if (params.marginAmount.greaterThan(0)) {
-      const STEP1_ID = getVesuGenericLegId(params.poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE);
+      const STEP1_ID = getVesuGenericLegId(
+        params.poolId.toString(),
+        LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE,
+      );
       const manage1Info = this.getProofs<ApproveCallParams>(STEP1_ID);
       const depositAmount = params.marginAmount;
       const manageCall1 = manage1Info.callConstructor({
-          amount: depositAmount
-      })
+        amount: depositAmount,
+      });
       proofsIDs.push(STEP1_ID);
       manageCalls.push(manageCall1);
     }
@@ -727,75 +1210,119 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     const fromToken = params.isIncrease ? lstUnderlyingTokenInfo : lstTokenInfo;
     const toToken = params.isIncrease ? lstTokenInfo : lstUnderlyingTokenInfo;
     const leverSwapQuote = await ekuboQuoter.getQuote(
-      fromToken.address.address, 
-      toToken.address.address, 
-      params.debtAmount // negative for exact amount out
+      fromToken.address.address,
+      toToken.address.address,
+      params.debtAmount, // negative for exact amount out
+    );
+    logger.verbose(
+      `${this.getTag()}::getModifyLeverCall leverSwapQuote: ${JSON.stringify(leverSwapQuote)}`,
+    );
+    // Ekubo's price impact can randomly show high numbers sometimes.
+    assert(
+      leverSwapQuote.price_impact <= params.maxEkuboPriceImpact,
+      "getIncreaseLeverCall: Price impact is too high [Debt swap]",
+    );
+    const leverSwap = ekuboQuoter.getVesuMultiplyQuote(
+      leverSwapQuote,
+      fromToken,
+      toToken,
+    );
+    logger.verbose(
+      `${this.getTag()}::getModifyLeverCall leverSwap: ${JSON.stringify(leverSwap)}`,
     );
-    logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwapQuote: ${JSON.stringify(leverSwapQuote)}`);
-    // Ekubo's price impact can randomly show high numbers sometimes. 
-    assert(leverSwapQuote.price_impact <= params.maxEkuboPriceImpact, 'getIncreaseLeverCall: Price impact is too high [Debt swap]');
-    const leverSwap = ekuboQuoter.getVesuMultiplyQuote(leverSwapQuote, fromToken, toToken);
-    logger.verbose(`${this.getTag()}::getModifyLeverCall leverSwap: ${JSON.stringify(leverSwap)}`);
 
     // todo double check this logic
     // is Deposit
-    let minLSTReceived = params.debtAmount.dividedBy(lstDexPriceInUnderlying).multipliedBy(1 - MAX_SLIPPAGE); // used for increase
-    const minLSTReceivedAsPerTruePrice = params.debtAmount.dividedBy(lstTrueExchangeRate); // execution output to be <= True LST price
+    let minLSTReceived = params.debtAmount
+      .dividedBy(lstDexPriceInUnderlying)
+      .multipliedBy(1 - MAX_SLIPPAGE); // used for increase
+    const minLSTReceivedAsPerTruePrice =
+      params.debtAmount.dividedBy(lstTrueExchangeRate); // execution output to be <= True LST price
     // if (minLSTReceived < minLSTReceivedAsPerTruePrice) {
     //   minLSTReceived = minLSTReceivedAsPerTruePrice; // the execution shouldn't be bad than True price logi
     // }
     minLSTReceived = minLSTReceivedAsPerTruePrice; // in any case, we are ok with this, bcz the BTC LST spread shouldnt be high
-    logger.verbose(`${this.getTag()}::getModifyLeverCall minLSTReceivedAsPerTruePrice: ${minLSTReceivedAsPerTruePrice}, minLSTReceived: ${minLSTReceived}`);
+    logger.verbose(
+      `${this.getTag()}::getModifyLeverCall minLSTReceivedAsPerTruePrice: ${minLSTReceivedAsPerTruePrice}, minLSTReceived: ${minLSTReceived}`,
+    );
 
     // is withdraw
-    let maxUsedCollateral = params.debtAmount.abs().dividedBy(lstDexPriceInUnderlying).multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
-    const maxUsedCollateralInLST = params.debtAmount.abs().dividedBy(lstTrueExchangeRate).multipliedBy(1.005); // 0.5% slippage, worst case based on true price
-    logger.verbose(`${this.getTag()}::getModifyLeverCall maxUsedCollateralInLST: ${maxUsedCollateralInLST}, maxUsedCollateral: ${maxUsedCollateral}`);
+    let maxUsedCollateral = params.debtAmount
+      .abs()
+      .dividedBy(lstDexPriceInUnderlying)
+      .multipliedBy(1 + MAX_SLIPPAGE); // +ve for exact amount out, used for decrease
+    const maxUsedCollateralInLST = params.debtAmount
+      .abs()
+      .dividedBy(lstTrueExchangeRate)
+      .multipliedBy(1.005); // 0.5% slippage, worst case based on true price
+    logger.verbose(
+      `${this.getTag()}::getModifyLeverCall maxUsedCollateralInLST: ${maxUsedCollateralInLST}, maxUsedCollateral: ${maxUsedCollateral}`,
+    );
     // if (maxUsedCollateralInLST > maxUsedCollateral) {
     //   maxUsedCollateral = maxUsedCollateralInLST;
     // }
     maxUsedCollateral = maxUsedCollateralInLST; // in any case, we are ok with this, bcz the BTC LST spread shouldnt be high
 
-    const STEP2_ID = getVesuGenericLegId(params.poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON);
-    const manage2Info = this.getProofs<VesuModifyDelegationCallParams>(STEP2_ID);
+    const STEP2_ID = getVesuGenericLegId(
+      params.poolId.toString(),
+      LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON,
+    );
+    const manage2Info =
+      this.getProofs<VesuModifyDelegationCallParams>(STEP2_ID);
     const manageCall2 = manage2Info.callConstructor({
       delegation: true,
     });
 
     // deposit and borrow or repay and withdraw
-    const STEP3_ID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, vesuAdapter1.config.debt.symbol, vesuAdapter1.config.poolId.toString());
+    const STEP3_ID = getVesuLegId(
+      LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU,
+      vesuAdapter1.config.debt.symbol,
+      vesuAdapter1.config.poolId.toString(),
+    );
     const manage3Info = this.getProofs<VesuMultiplyCallParams>(STEP3_ID);
-    const multiplyParams: VesuMultiplyCallParams = params.isIncrease ? {
-      isIncrease: true,
-      increaseParams: {
-        add_margin: params.marginAmount,
-        margin_swap: [],
-        margin_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
-        lever_swap: leverSwap,
-        lever_swap_limit_amount: minLSTReceived
-      }
-    } : {
-      isIncrease: false,
-      decreaseParams: {
-        sub_margin: params.marginAmount.multipliedBy(-1),
-        lever_swap: leverSwap,
-        lever_swap_limit_amount: maxUsedCollateral,
-        // only required for close position
-        lever_swap_weights: [],
-        // no need to swap collateral to anything, and any residuals return our contract anyways. 
-        withdraw_swap: [],
-        withdraw_swap_limit_amount: Web3Number.fromWei(0, this.asset().decimals),
-        withdraw_swap_weights: [],
-        close_position: false
-      }
-    }
+    const multiplyParams: VesuMultiplyCallParams = params.isIncrease
+      ? {
+          isIncrease: true,
+          increaseParams: {
+            add_margin: params.marginAmount,
+            margin_swap: [],
+            margin_swap_limit_amount: Web3Number.fromWei(
+              0,
+              this.asset().decimals,
+            ),
+            lever_swap: leverSwap,
+            lever_swap_limit_amount: minLSTReceived,
+          },
+        }
+      : {
+          isIncrease: false,
+          decreaseParams: {
+            sub_margin: params.marginAmount.multipliedBy(-1),
+            lever_swap: leverSwap,
+            lever_swap_limit_amount: maxUsedCollateral,
+            // only required for close position
+            lever_swap_weights: [],
+            // no need to swap collateral to anything, and any residuals return our contract anyways.
+            withdraw_swap: [],
+            withdraw_swap_limit_amount: Web3Number.fromWei(
+              0,
+              this.asset().decimals,
+            ),
+            withdraw_swap_weights: [],
+            close_position: false,
+          },
+        };
     const manageCall3 = manage3Info.callConstructor(multiplyParams);
 
     // switch delegation off
-    const STEP4_ID = getVesuGenericLegId(params.poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF);
-    const manage4Info = this.getProofs<VesuModifyDelegationCallParams>(STEP4_ID);
+    const STEP4_ID = getVesuGenericLegId(
+      params.poolId.toString(),
+      LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF,
+    );
+    const manage4Info =
+      this.getProofs<VesuModifyDelegationCallParams>(STEP4_ID);
     const manageCall4 = manage4Info.callConstructor({
-      delegation: false
+      delegation: false,
     });
 
     proofsIDs.push(STEP2_ID, STEP3_ID, STEP4_ID);
@@ -807,12 +1334,11 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
 export default function VaultDescription(
   lstSymbol: string,
-  underlyingSymbol: string
+  underlyingSymbol: string,
 ) {
   const containerStyle = {
     maxWidth: "800px",
     margin: "0 auto",
-    backgroundColor: "#111",
     color: "#eee",
     fontFamily: "Arial, sans-serif",
     borderRadius: "12px",
@@ -820,26 +1346,64 @@ export default function VaultDescription(
 
   return (
     <div style={containerStyle}>
-      <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>Liquidation risk managed leverged {lstSymbol} Vault</h1>
+      <h1 style={{ fontSize: "18px", marginBottom: "10px" }}>
+        Liquidation risk managed leverged {lstSymbol} Vault
+      </h1>
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
-        This Levered Endur {lstSymbol} vault is a tokenized leveraged Vault, auto-compounding strategy that takes upto 5x leverage on {lstSymbol} by borrow {underlyingSymbol}. Borrowed amount
-        is swapped to {lstSymbol} to create leverage. Depositors receive vault shares that
-        represent a proportional claim on the underlying assets and accrued yield.
+        This Levered Endur {lstSymbol} vault is a tokenized leveraged Vault,
+        auto-compounding strategy that takes upto 5x leverage on {lstSymbol} by
+        borrow {underlyingSymbol}. Borrowed amount is swapped to {lstSymbol} to
+        create leverage. Depositors receive vault shares that represent a
+        proportional claim on the underlying assets and accrued yield.
       </p>
 
       <p style={{ fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }}>
-        This vault uses Vesu for lending and borrowing. The oracle used by this pool is a {highlightTextWithLinks("conversion rate oracle", [{highlight: "conversion rate oracle", link: "https://docs.pragma.build/starknet/development#conversion-rate"}])}
-        {" "}which is resilient to liquidity issues and price volatility, hence reducing the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep.
+        This vault uses Vesu for lending and borrowing. The oracle used by this
+        pool is a{" "}
+        {highlightTextWithLinks("conversion rate oracle", [
+          {
+            highlight: "conversion rate oracle",
+            link: "https://docs.pragma.build/starknet/development#conversion-rate",
+          },
+        ])}{" "}
+        which is resilient to liquidity issues and price volatility, hence
+        reducing the risk of liquidation. However, overtime, if left
+        un-monitored, debt can increase enough to trigger a liquidation. But no
+        worries, our continuous monitoring systems look for situations with
+        reduced health factor and balance collateral/debt to bring it back to
+        safe levels. With Troves, you can have a peaceful sleep.
       </p>
 
-      <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+      <div
+        style={{
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444",
+        }}
+      >
         <p style={{ fontSize: "13px", color: "#ccc" }}>
-          <strong>Withdrawals:</strong> Requests can take up to <strong>1-2 hours</strong> to process as the vault unwinds and settles routing.
+          <strong>Withdrawals:</strong> Requests can take up to{" "}
+          <strong>1-2 hours</strong> to process as the vault unwinds and settles
+          routing.
         </p>
       </div>
-      <div style={{ backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }}>
+      <div
+        style={{
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444",
+        }}
+      >
         <p style={{ fontSize: "13px", color: "#ccc" }}>
-          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited LSTs remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on LST APY, its only on added gain. 
+          <strong>Debt limits:</strong> Pools on Vesu have debt caps that are
+          gradually increased over time. Until caps are raised, deposited 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" }}>
@@ -851,24 +1415,25 @@ export default function VaultDescription(
   );
 }
 
-
 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',
+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) {
+function getAvnuManageIDs(
+  baseID: LST_MULTIPLIER_MANAGE_IDS,
+  debtTokenSymbol: string,
+) {
   return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
 }
 
@@ -887,45 +1452,100 @@ function addVesuLeaves(
   vaultSettings: HyperLSTStrategySettings,
   commonAdapter: CommonAdapter,
 ) {
-  const lstToken = Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!;
-  const underlyingToken = Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!;
+  const lstToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === lstSymbol,
+  )!;
+  const underlyingToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === underlyingSymbol,
+  )!;
 
   const vesuAdapterLST = new VesuAdapter({
     poolId: poolId,
     collateral: lstToken,
     debt: underlyingToken,
     vaultAllocator: vaultSettings.vaultAllocator,
-    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol, poolId.toString())
+    id: getVesuLegId(
+      UNIVERSAL_MANAGE_IDS.VESU_LEG1,
+      underlyingToken.symbol,
+      poolId.toString(),
+    ),
   });
 
   // Useful for returning adapter class objects that can compute
   // certain things for us (e.g. positions, hfs)
-  vaultSettings.adapters.push(...[{
-    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol, poolId.toString()),
-    adapter: vesuAdapterLST
-  }]);
+  vaultSettings.adapters.push(
+    ...[
+      {
+        id: getVesuLegId(
+          UNIVERSAL_MANAGE_IDS.VESU_LEG1,
+          underlyingToken.symbol,
+          poolId.toString(),
+        ),
+        adapter: vesuAdapterLST,
+      },
+    ],
+  );
 
   // avnu multiply
   const { isV2, addr: poolAddr } = getVesuSingletonAddress(poolId);
 
   // vesu multiply looping
-  const VESU_MULTIPLY = isV2 ? vesuAdapterLST.VESU_MULTIPLY : vesuAdapterLST.VESU_MULTIPLY_V1;
-
-  const leafIdApprove = getVesuGenericLegId(poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE);
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, VESU_MULTIPLY, leafIdApprove).bind(commonAdapter));
-  
-  const leafIdDelegationOn = getVesuGenericLegId(poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON);
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(leafIdDelegationOn, VESU_MULTIPLY).bind(vesuAdapterLST));
-  
-  const leafIdDelegationOff = getVesuGenericLegId(poolId.toString(), LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF);
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter(leafIdDelegationOff, VESU_MULTIPLY).bind(vesuAdapterLST));
-
-  const multiplID = getVesuLegId(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU, underlyingToken.symbol, poolId.toString());
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getMultiplyAdapter(multiplID).bind(vesuAdapterLST));
- 
+  const VESU_MULTIPLY = isV2
+    ? vesuAdapterLST.VESU_MULTIPLY
+    : vesuAdapterLST.VESU_MULTIPLY_V1;
+
+  const leafIdApprove = getVesuGenericLegId(
+    poolId.toString(),
+    LST_MULTIPLIER_MANAGE_IDS.MULTIPLE_APPROVE,
+  );
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(lstToken.address, VESU_MULTIPLY, leafIdApprove)
+      .bind(commonAdapter),
+  );
+
+  const leafIdDelegationOn = getVesuGenericLegId(
+    poolId.toString(),
+    LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_ON,
+  );
+  vaultSettings.leafAdapters.push(
+    vesuAdapterLST
+      .getVesuModifyDelegationAdapter(leafIdDelegationOn, VESU_MULTIPLY)
+      .bind(vesuAdapterLST),
+  );
+
+  const leafIdDelegationOff = getVesuGenericLegId(
+    poolId.toString(),
+    LST_MULTIPLIER_MANAGE_IDS.SWITCH_DELEGATION_OFF,
+  );
+  vaultSettings.leafAdapters.push(
+    vesuAdapterLST
+      .getVesuModifyDelegationAdapter(leafIdDelegationOff, VESU_MULTIPLY)
+      .bind(vesuAdapterLST),
+  );
+
+  const multiplID = getVesuLegId(
+    LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU,
+    underlyingToken.symbol,
+    poolId.toString(),
+  );
+  vaultSettings.leafAdapters.push(
+    vesuAdapterLST.getMultiplyAdapter(multiplID).bind(vesuAdapterLST),
+  );
+
   // direct modify position stuff
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, poolAddr, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getModifyPosition.bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(
+        lstToken.address,
+        poolAddr,
+        UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1,
+      )
+      .bind(commonAdapter),
+  );
+  vaultSettings.leafAdapters.push(
+    vesuAdapterLST.getModifyPosition.bind(vesuAdapterLST),
+  );
 
   return vesuAdapterLST;
 }
@@ -934,7 +1554,7 @@ function getLooperSettings(
   lstSymbol: string,
   underlyingSymbol: string,
   vaultSettings: HyperLSTStrategySettings,
-  defaultPoolId: ContractAddr
+  defaultPoolId: ContractAddr,
 ) {
   vaultSettings.leafAdapters = [];
   const pool1 = vaultSettings.defaultPoolId;
@@ -942,82 +1562,179 @@ function getLooperSettings(
     throw new Error(`Dont include default pool id in supported pool ids`);
   }
 
-  const lstToken = Global.getDefaultTokens().find(token => token.symbol === lstSymbol)!;
-  const underlyingToken = Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!;
+  const lstToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === lstSymbol,
+  )!;
+  const underlyingToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === underlyingSymbol,
+  )!;
 
   const commonAdapter = new CommonAdapter({
     manager: vaultSettings.manager,
     asset: lstToken.address,
-    id: '',
+    id: "",
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator,
   });
 
   // add common adapter to adapters
-  vaultSettings.adapters.push(...[{
-    id: UNIVERSAL_ADAPTERS.COMMON,
-    adapter: commonAdapter
-  }]);
+  vaultSettings.adapters.push(
+    ...[
+      {
+        id: UNIVERSAL_ADAPTERS.COMMON,
+        adapter: commonAdapter,
+      },
+    ],
+  );
 
   // add vesu leaves for all supported pool ids
-  vaultSettings.borrowable_assets.map(borrowableAsset => addVesuLeaves(borrowableAsset.poolId, lstSymbol, underlyingSymbol, vaultSettings, commonAdapter));
-  
+  vaultSettings.borrowable_assets.map((borrowableAsset) =>
+    addVesuLeaves(
+      borrowableAsset.poolId,
+      lstSymbol,
+      underlyingSymbol,
+      vaultSettings,
+      commonAdapter,
+    ),
+  );
+
   // approve lst once to avnu
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, AVNU_EXCHANGE, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_WITHDRAW).bind(commonAdapter));
- 
-  const uniqueBorrowableAssets = [...new Set(vaultSettings.borrowable_assets.map(borrowableAsset => borrowableAsset.token.symbol))];
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(
+        lstToken.address,
+        AVNU_EXCHANGE,
+        LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_WITHDRAW,
+      )
+      .bind(commonAdapter),
+  );
+
+  const uniqueBorrowableAssets = [
+    ...new Set(
+      vaultSettings.borrowable_assets.map(
+        (borrowableAsset) => borrowableAsset.token.symbol,
+      ),
+    ),
+  ];
   for (let borrowableAssetSymbol of uniqueBorrowableAssets) {
-    const borrowableAsset = Global.getDefaultTokens().find(token => token.symbol === borrowableAssetSymbol)!;
+    const borrowableAsset = Global.getDefaultTokens().find(
+      (token) => token.symbol === borrowableAssetSymbol,
+    )!;
     // in-efficient avnu swap looping (but good with endur integration)
     const debtAsset = borrowableAsset;
-    const approve_debt_token_id = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT, debtAsset.symbol);
-    const swap_debt_token_id = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT, debtAsset.symbol);
-    const swap_lst_token_id = getAvnuManageIDs(LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_WITHDRAW, debtAsset.symbol);
-    vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(debtAsset.address, AVNU_EXCHANGE, approve_debt_token_id).bind(commonAdapter));
-    vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(debtAsset.address, lstToken.address, swap_debt_token_id, false).bind(commonAdapter));
-    vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(lstToken.address, debtAsset.address, swap_lst_token_id, false).bind(commonAdapter));
+    const approve_debt_token_id = getAvnuManageIDs(
+      LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT,
+      debtAsset.symbol,
+    );
+    const swap_debt_token_id = getAvnuManageIDs(
+      LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT,
+      debtAsset.symbol,
+    );
+    const swap_lst_token_id = getAvnuManageIDs(
+      LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_WITHDRAW,
+      debtAsset.symbol,
+    );
+    vaultSettings.leafAdapters.push(
+      commonAdapter
+        .getApproveAdapter(
+          debtAsset.address,
+          AVNU_EXCHANGE,
+          approve_debt_token_id,
+        )
+        .bind(commonAdapter),
+    );
+    vaultSettings.leafAdapters.push(
+      commonAdapter
+        .getAvnuAdapter(
+          debtAsset.address,
+          lstToken.address,
+          swap_debt_token_id,
+          false,
+        )
+        .bind(commonAdapter),
+    );
+    vaultSettings.leafAdapters.push(
+      commonAdapter
+        .getAvnuAdapter(
+          lstToken.address,
+          debtAsset.address,
+          swap_lst_token_id,
+          false,
+        )
+        .bind(commonAdapter),
+    );
   }
 
-  
   // 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));
-  
+  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 (defi spring ended)
   // vaultSettings.leafAdapters.push(vesuAdapterLST.getDefispringRewardsAdapter(UNIVERSAL_MANAGE_IDS.DEFISPRING_REWARDS).bind(vesuAdapterLST));
 
   // avnu swap for claims rewards
-  const STRKToken = Global.getDefaultTokens().find(token => token.symbol === 'STRK')!;
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_EXCHANGE, UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, lstToken.address, UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS, false).bind(commonAdapter));
+  const STRKToken = Global.getDefaultTokens().find(
+    (token) => token.symbol === "STRK",
+  )!;
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getApproveAdapter(
+        STRKToken.address,
+        AVNU_EXCHANGE,
+        UNIVERSAL_MANAGE_IDS.APPROVE_SWAP_TOKEN1,
+      )
+      .bind(commonAdapter),
+  );
+  vaultSettings.leafAdapters.push(
+    commonAdapter
+      .getAvnuAdapter(
+        STRKToken.address,
+        lstToken.address,
+        UNIVERSAL_MANAGE_IDS.AVNU_SWAP_REWARDS,
+        false,
+      )
+      .bind(commonAdapter),
+  );
   return vaultSettings;
 }
 
-const AUDIT_URL = 'https://docs.troves.fi/p/security#starknet-vault-kit'
+const AUDIT_URL = "https://docs.troves.fi/p/security#starknet-vault-kit";
 
 function getFAQs(lstSymbol: string, underlyingSymbol: string): FAQ[] {
   return [
     {
       question: `What is the Hyper ${lstSymbol} Vault?`,
-      answer:
-        `The Hyper ${lstSymbol} Vault is a tokenized strategy that automatically loops your ${lstSymbol} to create up to 5x leverage to hence yield in a very low risk manner.`,
+      answer: `The Hyper ${lstSymbol} Vault is a tokenized strategy that automatically loops your ${lstSymbol} to create up to 5x leverage to hence yield in a very low risk manner.`,
     },
     {
       question: "How does yield allocation work?",
-      answer:
-        `The strategy uses deposited ${lstSymbol} to collateralize it on Vesu, borrow more ${underlyingSymbol} to loop further. Instead of manually doing this, using flash loan, this leverage is created in a single gas efficient step. Our continuous monitoring systems gauge current yield and available liquidity in real time to make sure yield is optimal. For instance, if the looping becomes in-efficient in future, the strategy will rebalance to reduce leverage or simply hold ${lstSymbol} to continue earning yield.`,
+      answer: `The strategy uses deposited ${lstSymbol} to collateralize it on Vesu, borrow more ${underlyingSymbol} to loop further. Instead of manually doing this, using flash loan, this leverage is created in a single gas efficient step. Our continuous monitoring systems gauge current yield and available liquidity in real time to make sure yield is optimal. For instance, if the looping becomes in-efficient in future, the strategy will rebalance to reduce leverage or simply hold ${lstSymbol} to continue earning yield.`,
     },
     {
       question: "Which protocols/dApp are used??",
       answer: (
         <span>
-          Currently, the LST is from <strong>Endur</strong> while <strong>Vesu</strong> is used to collateralize the looped position.
+          Currently, the LST is from <strong>Endur</strong> while{" "}
+          <strong>Vesu</strong> is used to collateralize the looped position.
         </span>
       ),
     },
     {
       question: "Can I get liquidated?",
-      answer: "The strategy uses highly correlated assets which drastically reduces the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep.",
+      answer:
+        "The strategy uses highly correlated assets which drastically reduces the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep.",
     },
     {
       question: "What do I receive when I deposit?",
@@ -1048,107 +1765,209 @@ function getFAQs(lstSymbol: string, underlyingSymbol: string): FAQ[] {
 }
 
 const _riskFactor: RiskFactor[] = [
-  { type: RiskType.SMART_CONTRACT_RISK, value: SmartContractRiskLevel.WELL_AUDITED, weight: 25, reason: "Audited by Zellic" },
-  { type: RiskType.LIQUIDATION_RISK, value: LiquidationRiskLevel.VERY_LOW_PROBABILITY, weight: 25, reason: "The collateral and debt are highly correlated" },
-  { type: RiskType.TECHNICAL_RISK, value: TechnicalRiskLevel.STABLE_INFRASTRUCTURE, weight: 25, reason: "Liquidation can only happen if vault is left un-monitored for weeks, which is highly unlikely. We actively monitor all services on a daily basis." },
-  {type: RiskType.DEPEG_RISK, value: DepegRiskLevel.GENERALLY_STABLE, weight: 25, reason: "Generally stable pegged assets" },
+  {
+    type: RiskType.SMART_CONTRACT_RISK,
+    value: SmartContractRiskLevel.WELL_AUDITED,
+    weight: 25,
+    reason: "Audited by Zellic",
+  },
+  {
+    type: RiskType.LIQUIDATION_RISK,
+    value: LiquidationRiskLevel.VERY_LOW_PROBABILITY,
+    weight: 25,
+    reason: "The collateral and debt are highly correlated",
+  },
+  {
+    type: RiskType.TECHNICAL_RISK,
+    value: TechnicalRiskLevel.STABLE_INFRASTRUCTURE,
+    weight: 25,
+    reason:
+      "Liquidation can only happen if vault is left un-monitored for weeks, which is highly unlikely. We actively monitor all services on a daily basis.",
+  },
+  {
+    type: RiskType.DEPEG_RISK,
+    value: DepegRiskLevel.GENERALLY_STABLE,
+    weight: 25,
+    reason: "Generally stable pegged assets",
+  },
 ];
 
-const btcBorrowableAssets = [
-  'WBTC', 'tBTC', 'LBTC', 'solvBTC'
-]
+const btcBorrowableAssets = ["WBTC", "tBTC", "LBTC", "solvBTC"];
 
 const hyperxSTRK: HyperLSTStrategySettings = {
-  vaultAddress: ContractAddr.from('0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960'),
-  manager: ContractAddr.from('0x5d499cd333757f461a0bedaca3dfc4d77320c773037e0aa299f22a6dbfdc03a'),
-  vaultAllocator: ContractAddr.from('0x511d07953a09bc7c505970891507c5a2486d2ea22752601a14db092186d7caa'),
-  redeemRequestNFT: ContractAddr.from('0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095'),
-  aumOracle: ContractAddr.from('0x48cf709870a1a0d453d37de108e0c41b8b89819ef54f95abc0e2e1f98bbe937'),
+  vaultAddress: ContractAddr.from(
+    "0x46c7a54c82b1fe374353859f554a40b8bd31d3e30f742901579e7b57b1b5960",
+  ),
+  manager: ContractAddr.from(
+    "0x5d499cd333757f461a0bedaca3dfc4d77320c773037e0aa299f22a6dbfdc03a",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x511d07953a09bc7c505970891507c5a2486d2ea22752601a14db092186d7caa",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x51e40b839dc0c2feca923f863072673b94abfa2483345be3b30b457a90d095",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x48cf709870a1a0d453d37de108e0c41b8b89819ef54f95abc0e2e1f98bbe937",
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
   borrowable_assets: [
-    ...Global.getDefaultTokens().filter(token => token.symbol === 'STRK').map(token => ({ token, poolId: VesuPools.Re7xSTRK })),
-    ...Global.getDefaultTokens().filter(token => token.symbol === 'STRK').map(token => ({ token, poolId: VesuPools.Prime })),
-    ...Global.getDefaultTokens().filter(token => token.symbol === 'STRK').map(token => ({ token, poolId: VesuPools.Re7STRK })), // v2, new alt for Re7xSTRK
+    ...Global.getDefaultTokens()
+      .filter((token) => token.symbol === "STRK")
+      .map((token) => ({ token, poolId: VesuPools.Re7xSTRK })),
+    ...Global.getDefaultTokens()
+      .filter((token) => token.symbol === "STRK")
+      .map((token) => ({ token, poolId: VesuPools.Prime })),
+    ...Global.getDefaultTokens()
+      .filter((token) => token.symbol === "STRK")
+      .map((token) => ({ token, poolId: VesuPools.Re7STRK })), // v2, new alt for Re7xSTRK
   ],
-  underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'STRK')!,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "STRK",
+  )!,
   defaultPoolId: VesuPools.Re7xSTRK,
-}
+};
 
 const hyperxWBTC: HyperLSTStrategySettings = {
-  vaultAddress: ContractAddr.from('0x2da9d0f96a46b453f55604313785dc866424240b1c6811d13bef594343db818'),
-  manager: ContractAddr.from('0x75866db44c81e6986f06035206ee9c7d15833ddb22d6a22c016cfb5c866a491'),
-  vaultAllocator: ContractAddr.from('0x57b5c1bb457b5e840a2714ae53ada87d77be2f3fd33a59b4fe709ef20c020c1'),
-  redeemRequestNFT: ContractAddr.from('0x7a5dc288325456f05e70e9616e16bc02ffbe448f4b89f80b47c0970b989c7c'),
-  aumOracle: ContractAddr.from('0x258f8a0ca0d21f542e48ad89d00e92dc4d9db4999084f50ef9c22dfb1e83023'),
+  vaultAddress: ContractAddr.from(
+    "0x2da9d0f96a46b453f55604313785dc866424240b1c6811d13bef594343db818",
+  ),
+  manager: ContractAddr.from(
+    "0x75866db44c81e6986f06035206ee9c7d15833ddb22d6a22c016cfb5c866a491",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x57b5c1bb457b5e840a2714ae53ada87d77be2f3fd33a59b4fe709ef20c020c1",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x7a5dc288325456f05e70e9616e16bc02ffbe448f4b89f80b47c0970b989c7c",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x258f8a0ca0d21f542e48ad89d00e92dc4d9db4999084f50ef9c22dfb1e83023",
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
   borrowable_assets: [
     // allow all BTC flavours borrowing on Re7xBTC pool
-    ...btcBorrowableAssets.map(asset => Global.getDefaultTokens().find(token => token.symbol === asset)!).map(token => ({ token, poolId: VesuPools.Re7xBTC })),
+    ...btcBorrowableAssets
+      .map(
+        (asset) =>
+          Global.getDefaultTokens().find((token) => token.symbol === asset)!,
+      )
+      .map((token) => ({ token, poolId: VesuPools.Re7xBTC })),
     // allow only WBTC borrowing on Prime pool
-    ...Global.getDefaultTokens().filter(token => token.symbol === 'WBTC').map(token => ({ token, poolId: VesuPools.Prime })),
+    ...Global.getDefaultTokens()
+      .filter((token) => token.symbol === "WBTC")
+      .map((token) => ({ token, poolId: VesuPools.Prime })),
   ],
-  underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "WBTC",
+  )!,
   defaultPoolId: VesuPools.Re7xBTC,
-  redemptionRouter: ContractAddr.from('0x6ea649f402898f69baf775c1afdd08522c071c640b9c4460192070ec2b96417')
-}
+  redemptionRouter: ContractAddr.from(
+    "0x6ea649f402898f69baf775c1afdd08522c071c640b9c4460192070ec2b96417",
+  ),
+};
 
 const hyperxtBTC: HyperLSTStrategySettings = {
-  vaultAddress: ContractAddr.from('0x47d5f68477e5637ce0e56436c6b5eee5a354e6828995dae106b11a48679328'),
-  manager: ContractAddr.from('0xc4cc3e08029a0ae076f5fdfca70575abb78d23c5cd1c49a957f7e697885401'),
-  vaultAllocator: ContractAddr.from('0x50bbd4fe69f841ecb13b2619fe50ebfa4e8944671b5d0ebf7868fd80c61b31e'),
-  redeemRequestNFT: ContractAddr.from('0xeac9032f02057779816e38a6cb9185d12d86b3aacc9949b96b36de359c1e3'),
-  aumOracle: ContractAddr.from('0x7e0d05cb7ba3f7db77a36c21c21583b5a524c2e685c08c24b3554911fb4a039'),
+  vaultAddress: ContractAddr.from(
+    "0x47d5f68477e5637ce0e56436c6b5eee5a354e6828995dae106b11a48679328",
+  ),
+  manager: ContractAddr.from(
+    "0xc4cc3e08029a0ae076f5fdfca70575abb78d23c5cd1c49a957f7e697885401",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x50bbd4fe69f841ecb13b2619fe50ebfa4e8944671b5d0ebf7868fd80c61b31e",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0xeac9032f02057779816e38a6cb9185d12d86b3aacc9949b96b36de359c1e3",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x7e0d05cb7ba3f7db77a36c21c21583b5a524c2e685c08c24b3554911fb4a039",
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
   borrowable_assets: [
-    ...Global.getDefaultTokens().filter(token => token.symbol === 'tBTC' || token.symbol === 'WBTC').map(token => ({ token, poolId: VesuPools.Re7xBTC })),
+    ...Global.getDefaultTokens()
+      .filter((token) => token.symbol === "tBTC" || token.symbol === "WBTC")
+      .map((token) => ({ token, poolId: VesuPools.Re7xBTC })),
   ],
-  underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'tBTC')!,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "tBTC",
+  )!,
   defaultPoolId: VesuPools.Re7xBTC,
-  redemptionRouter: ContractAddr.from('0x3de9c409d1e357e25778fb7a3e2e2393666956846a5c2caa607296fa8e76b5d')
-}
+  redemptionRouter: ContractAddr.from(
+    "0x3de9c409d1e357e25778fb7a3e2e2393666956846a5c2caa607296fa8e76b5d",
+  ),
+};
 
 const hyperxsBTC: HyperLSTStrategySettings = {
-  vaultAddress: ContractAddr.from('0x437ef1e7d0f100b2e070b7a65cafec0b2be31b0290776da8b4112f5473d8d9'),
-  manager: ContractAddr.from('0xc9ac023090625b0be3f6532ca353f086746f9c09f939dbc1b2613f09e5f821'),
-  vaultAllocator: ContractAddr.from('0x60c2d856936b975459a5b4eb28b8672d91f757bd76cebb6241f8d670185dc01'),
-  redeemRequestNFT: ContractAddr.from('0x429e8ee8bc7ecd1ade72630d350a2e0f10f9a2507c45f188ba17fe8f2ab4cf3'),
-  aumOracle: ContractAddr.from('0x149298ade3e79ec6cbdac6cfad289c57504eaf54e590939136ed1ceca60c345'),
+  vaultAddress: ContractAddr.from(
+    "0x437ef1e7d0f100b2e070b7a65cafec0b2be31b0290776da8b4112f5473d8d9",
+  ),
+  manager: ContractAddr.from(
+    "0xc9ac023090625b0be3f6532ca353f086746f9c09f939dbc1b2613f09e5f821",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x60c2d856936b975459a5b4eb28b8672d91f757bd76cebb6241f8d670185dc01",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x429e8ee8bc7ecd1ade72630d350a2e0f10f9a2507c45f188ba17fe8f2ab4cf3",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x149298ade3e79ec6cbdac6cfad289c57504eaf54e590939136ed1ceca60c345",
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
   borrowable_assets: [
-    ...Global.getDefaultTokens().filter(token => token.symbol === 'solvBTC').map(token => ({ token, poolId: VesuPools.Re7xBTC })),
+    ...Global.getDefaultTokens()
+      .filter((token) => token.symbol === "solvBTC")
+      .map((token) => ({ token, poolId: VesuPools.Re7xBTC })),
   ],
-  underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'solvBTC')!,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "solvBTC",
+  )!,
   defaultPoolId: VesuPools.Re7xBTC,
-}
+};
 
 const hyperxLBTC: HyperLSTStrategySettings = {
-  vaultAddress: ContractAddr.from('0x64cf24d4883fe569926419a0569ab34497c6956a1a308fa883257f7486d7030'),
-  manager: ContractAddr.from('0x203530a4022a99b8f4b406aaf33b0849d43ad7422c1d5cc14ff8c667abec6c0'),
-  vaultAllocator: ContractAddr.from('0x7dbc8ccd4eabce6ea6c19e0e5c9ccca3a93bd510303b9e071cbe25fc508546e'),
-  redeemRequestNFT: ContractAddr.from('0x5ee66a39af9aef3d0d48982b4a63e8bd2a5bad021916bd87fb0eae3a26800b8'),
-  aumOracle: ContractAddr.from('0x23d69e4391fa72d10e625e7575d8bddbb4aff96f04503f83fdde23123bf41d0'),
+  vaultAddress: ContractAddr.from(
+    "0x64cf24d4883fe569926419a0569ab34497c6956a1a308fa883257f7486d7030",
+  ),
+  manager: ContractAddr.from(
+    "0x203530a4022a99b8f4b406aaf33b0849d43ad7422c1d5cc14ff8c667abec6c0",
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x7dbc8ccd4eabce6ea6c19e0e5c9ccca3a93bd510303b9e071cbe25fc508546e",
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x5ee66a39af9aef3d0d48982b4a63e8bd2a5bad021916bd87fb0eae3a26800b8",
+  ),
+  aumOracle: ContractAddr.from(
+    "0x23d69e4391fa72d10e625e7575d8bddbb4aff96f04503f83fdde23123bf41d0",
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
   borrowable_assets: [
-    ...Global.getDefaultTokens().filter(token => token.symbol === 'LBTC').map(token => ({ token, poolId: VesuPools.Re7xBTC })),
+    ...Global.getDefaultTokens()
+      .filter((token) => token.symbol === "LBTC")
+      .map((token) => ({ token, poolId: VesuPools.Re7xBTC })),
   ],
-  underlyingToken: Global.getDefaultTokens().find(token => token.symbol === 'LBTC')!,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "LBTC",
+  )!,
   defaultPoolId: VesuPools.Re7xBTC,
-}
+};
 
 function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {
   return [
@@ -1156,172 +1975,180 @@ 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 LST pool on Vesu to optimize yield`
-  ]
+    `If required, adjust leverage or re-allocate assets within LST pool on Vesu to optimize yield`,
+  ];
 }
 
 // Helper to get maxTVL based on LST symbol (matching client values)
 function getMaxTVL(lstSymbol: string): Web3Number {
-    const lstMaxTVLs: Record<string, number> = {
-        xWBTC: 5,
-        xLBTC: 5,
-        xtBTC: 5,
-        xsBTC: 5,
-        xSTRK: 550000
-    };
+  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);
+  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);
 }
 
 // Helper to create Hyper LST strategy settings
 function createHyperLSTSettings(
-    lstSymbol: string,
-    underlyingSymbol: string
+  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 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"
-    }
+  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'
-    }]
+  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
+  lstSymbol: string,
+  underlyingSymbol: string,
+  settings: HyperLSTStrategySettings,
+  isPreview: boolean = false,
 ): IStrategyMetadata<HyperLSTStrategySettings> {
-    return {
-        id: `hyper_${lstSymbol.toLowerCase()}`,
-        name: `Hyper ${lstSymbol}`,
-        description: getDescription(lstSymbol, underlyingSymbol),
-        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,
-            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)
-        },
-        auditUrl: AUDIT_URL,
-        protocols: [Protocols.ENDUR, Protocols.VESU],
-        curator: {
-            name: "Unwrap Labs",
-            logo: "https://assets.troves.fi/integrations/unwraplabs/white.png"
-        },
-        settings: createHyperLSTSettings(lstSymbol, underlyingSymbol),
-        contractDetails: getContractDetails(settings),
-        faqs: getFAQs(lstSymbol, underlyingSymbol),
-        investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
-        isPreview: isPreview,
-        apyMethodology:
-            "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.",
-        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: [{
-          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.",
-        }]
-    };
+  return {
+    id: `hyper_${lstSymbol.toLowerCase()}`,
+    name: `Hyper ${lstSymbol}`,
+    description: getDescription(lstSymbol, underlyingSymbol),
+    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,
+      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),
+    },
+    auditUrl: AUDIT_URL,
+    protocols: [Protocols.ENDUR, Protocols.VESU],
+    curator: {
+      name: "Unwrap Labs",
+      logo: "https://assets.troves.fi/integrations/unwraplabs/white.png",
+    },
+    settings: createHyperLSTSettings(lstSymbol, underlyingSymbol),
+    contractDetails: getContractDetails(settings),
+    faqs: getFAQs(lstSymbol, underlyingSymbol),
+    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
+    isPreview: isPreview,
+    apyMethodology:
+      "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.",
+    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: [
+      {
+        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.",
+      },
+    ],
+  };
 }
 
 export const HyperLSTStrategies: IStrategyMetadata<HyperLSTStrategySettings>[] =
   [
-    getStrategySettings('xSTRK', 'STRK', hyperxSTRK, false),
-    getStrategySettings('xWBTC', 'WBTC', hyperxWBTC, false),
-    getStrategySettings('xtBTC', 'tBTC', hyperxtBTC, false),
-    getStrategySettings('xsBTC', 'solvBTC', hyperxsBTC, false),
-    getStrategySettings('xLBTC', 'LBTC', hyperxLBTC, false),
-  ]
+    getStrategySettings("xSTRK", "STRK", hyperxSTRK, false),
+    getStrategySettings("xWBTC", "WBTC", hyperxWBTC, false),
+    getStrategySettings("xtBTC", "tBTC", hyperxtBTC, false),
+    getStrategySettings("xsBTC", "solvBTC", hyperxsBTC, false),
+    getStrategySettings("xLBTC", "LBTC", hyperxLBTC, false),
+  ];