@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

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

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