@strkfarm/sdk 1.1.39 → 1.1.40

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

@@ -11,9 +11,12 @@ import { assert, logger } from "@/utils";
 import { SingleTokenInfo } from "./base-strategy";
 import { Call, Contract, uint256 } from "starknet";
 import ERC4626Abi from "@/data/erc4626.abi.json";
+import { HealthFactorMath } from "@/utils/health-factor-math";
+import { findMaxInputWithSlippage } from "@/utils/math-utils";
 
 export interface HyperLSTStrategySettings extends UniversalStrategySettings {
   borrowable_assets: TokenInfo[];
+  underlyingToken: TokenInfo;
 }
 
 export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTStrategySettings> {
@@ -34,8 +37,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   }
 
   asset() {
-    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
-    return vesuAdapter1.config.collateral;
+    return this.getVesuSameTokenAdapter().config.collateral;
   }
 
   getTag() {
@@ -44,7 +46,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
   // Vesu adapter with LST and base token match
   getVesuSameTokenAdapter() {
-    const baseAdapter = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
+    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;
@@ -102,18 +104,55 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     isDeposit: boolean,
     leg1DepositAmount: Web3Number
   }) {
+    assert(params.isDeposit, 'Only deposit is supported in getAvnuSwapMultiplyCall')
     // TODO use a varibale for 1.02
-    return this._getAvnuDepositSwapLegCall({
-      ...params,
-      minHF: 1.1 // undo
-    });
+    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`);
   }
 
-  private async _getAvnuDepositSwapLegCall(params: {
+  async _getAvnuDepositSwapLegCall(params: {
     isDeposit: boolean,
     leg1DepositAmount: Web3Number, 
-    minHF: number // e.g. 1.01
+    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
@@ -121,11 +160,11 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     // approve and swap strk
     // add collateral again
 
-    const [vesuAdapter1] = this.getVesuAdapters();
-    const legLTV = await vesuAdapter1.getLTVConfig(this.config);
+    
+    const legLTV = await vesuAdapter.getLTVConfig(this.config);
     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall legLTV: ${legLTV}`);
-    const existingPositions = await vesuAdapter1.getPositions(this.config);
-    const collateralisation = await vesuAdapter1.getCollateralization(this.config);
+    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)}, 
@@ -139,11 +178,44 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     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 = totalCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(debtPrice).dividedBy(params.minHF);
-    logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalDebtAmount: ${totalDebtAmount}`);
-    const debtAmount = totalDebtAmount.minus(existingDebtInfo.amount);
+    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. 
@@ -156,33 +228,35 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
       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: params.leg1DepositAmount
+      amount: newDepositAmount
     });
-    const STEP1 = UNIVERSAL_MANAGE_IDS.VESU_LEG1;
+    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: params.leg1DepositAmount,
+        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
-    // todo add non-zero check
     if (debtAmount.gt(0)) {
-      const STEP2 = LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT;
+      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 = vesuAdapter1.config.debt;
+      const debtTokenInfo = vesuAdapter.config.debt;
       const lstTokenInfo = this.asset();
       const avnuModule = new AvnuWrapper();
       const quote = await avnuModule.getQuotes(
@@ -202,7 +276,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
         minAmountWei
       );
       logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall swapInfo: ${JSON.stringify(swapInfo)}`);
-      const STEP3 = LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT;
+      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
@@ -226,7 +300,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
           amount: minAmount
         });
        
-        const STEP5 = UNIVERSAL_MANAGE_IDS.VESU_LEG1;
+        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,
@@ -245,18 +319,31 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
 
   // todo unwind or not deposit when the yield is bad. 
 
-  async getLSTMultiplierRebalanceCall(): Promise<{ shouldRebalance: boolean, manageCall: Call | undefined }> {
-    const positions = await this.getVaultPositions();
-    assert(positions.length == 3, 'Rebalance call is only supported for 3 positions');
+  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 = positions[2];
-    const [healthFactor] = await this.getVesuHealthFactors();
+    const unusedBalance = await this.getUnusedBalance();
+    const healthFactor = await vesuAdapter.getHealthFactor();
 
-    const [vesuAdapter1] = this.getVesuAdapters();
-    const legLTV = await vesuAdapter1.getLTVConfig(this.config);
-    const collateralisation = await vesuAdapter1.getCollateralization(this.config);
-    logger.debug(`${this.getTag()}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
+    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
@@ -265,15 +352,17 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     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) {
+    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. 
+        minHF: 1.02, // todo, shouldnt use this 1.02 HF, if there isn;t more looping left. 
+        vesuAdapter
       })
       return { shouldRebalance: true, manageCall };
     } else {
@@ -318,7 +407,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     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 minOutputAmount;
+    return new Web3Number(minOutputAmount.toString(), this.asset().decimals);
   }
 
   private async _getMinOutputAmountLSTSell(amountInLST: Web3Number) {
@@ -418,22 +507,58 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     return vesuAdapter1.config.debt;
   }
 
-  async getMaxBorrowableAmount() {
+  async getMaxBorrowableAmount(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
     const vesuAdapters = this.getVesuAdapters();
     let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
-    const maxBorrowables: {amount: Web3Number, borrowableAsset: TokenInfo}[] = [];
-    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
-    const maxInterestRate = lstAPY * 0.8;
+    const maxBorrowables: {amount: Web3Number, dexSwappableAmount: Web3Number, maxBorrowableAmount: Web3Number, borrowableAsset: TokenInfo}[] = [];
     for (const vesuAdapter of vesuAdapters) {
-      const maxBorrowableAmount = await vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxInterestRate);
-      const debtCap = await vesuAdapter.getDebtCap(this.config);
-      maxBorrowables.push({amount: maxBorrowableAmount.minimum(debtCap), borrowableAsset: vesuAdapter.config.debt});
+      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 
@@ -459,7 +584,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
   // todo undo this
   async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
     const unusedBalance = await this.getUnusedBalance();
-    const maxNewDeposits = await this.maxNewDeposits();
+    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
@@ -482,8 +607,8 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     }
   }
 
-  async maxNewDeposits() {
-    const maxBorrowableAmounts = await this.getMaxBorrowableAmount();
+  async maxNewDeposits(params: { isAPYComputation: boolean } = { isAPYComputation: false }) {
+    const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
     
     let ltv: number | undefined = undefined;
     for (let adapter of this.getVesuAdapters()) {
@@ -617,7 +742,7 @@ export class UniversalLstMultiplierStrategy extends UniversalStrategy<HyperLSTSt
     });
 
     // deposit and borrow or repay and withdraw
-    const STEP3_ID = LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU;
+    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,
@@ -710,15 +835,24 @@ function getDescription(tokenSymbol: string, underlyingSymbol: string) {
   return VaultDescription(tokenSymbol, underlyingSymbol);
 }
 
+
 enum LST_MULTIPLIER_MANAGE_IDS  {
   MULTIPLE_APPROVE = 'multiple_approve',
   MULTIPLY_VESU = 'multiply_vesu',
   SWITCH_DELEGATION_ON = 'switch_delegation_on',
   SWITCH_DELEGATION_OFF = 'switch_delegation_off',
-  AVNU_MULTIPLY_APPROVE_DEPOSIT = 'avnu_multiply_approve_deposit',
-  AVNU_MULTIPLY_SWAP_DEPOSIT = 'avnu_multiply_swap_deposit',
-  AVNU_MULTIPLY_APPROVE_WITHDRAW = 'avnu_multiply_approve_withdraw',
-  AVNU_MULTIPLY_SWAP_WITHDRAW = 'avnu_multiply_swap_withdraw',
+  AVNU_MULTIPLY_APPROVE_DEPOSIT = 'avnu_mul_approve_dep',
+  AVNU_MULTIPLY_SWAP_DEPOSIT = 'avnu_mul_swap_dep',
+  AVNU_MULTIPLY_APPROVE_WITHDRAW = 'avnu_mul_approve_withdr',
+  AVNU_MULTIPLY_SWAP_WITHDRAW = 'avnu_mul_swap_withdr',
+}
+
+function getAvnuManageIDs(baseID: LST_MULTIPLIER_MANAGE_IDS, debtTokenSymbol: string) {
+  return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
+}
+
+function getVesuLegId(baseID: string, debtTokenSymbol: string) {
+  return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
 }
 
 function getLooperSettings(
@@ -737,7 +871,7 @@ function getLooperSettings(
     collateral: lstToken,
     debt: underlyingToken,
     vaultAllocator: vaultSettings.vaultAllocator,
-    id: UNIVERSAL_MANAGE_IDS.VESU_LEG1
+    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol)
   })
 
   const commonAdapter = new CommonAdapter({
@@ -748,18 +882,10 @@ function getLooperSettings(
     vaultAllocator: vaultSettings.vaultAllocator,
   })
 
-  // vesu looping
-  const { isV2, addr:poolAddr } = getVesuSingletonAddress(pool1);
-  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.getMultiplyAdapter(LST_MULTIPLIER_MANAGE_IDS.MULTIPLY_VESU).bind(vesuAdapterLST));
-  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));
-
   // Useful for returning adapter class objects that can compute
   // certain things for us (e.g. positions, hfs)
   vaultSettings.adapters.push(...[{
-    id: UNIVERSAL_ADAPTERS.VESU_LEG1,
+    id: getVesuLegId(UNIVERSAL_MANAGE_IDS.VESU_LEG1, underlyingToken.symbol),
     adapter: vesuAdapterLST
   },{
     id: UNIVERSAL_ADAPTERS.COMMON,
@@ -767,14 +893,42 @@ function getLooperSettings(
   }])
 
   // avnu multiply
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(underlyingToken.address, AVNU_EXCHANGE, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_APPROVE_DEPOSIT).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(underlyingToken.address, lstToken.address, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_DEPOSIT, false).bind(commonAdapter));
+  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));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(lstToken.address, underlyingToken.address, LST_MULTIPLIER_MANAGE_IDS.AVNU_MULTIPLY_SWAP_WITHDRAW, false).bind(commonAdapter));
-  // approve LST to add collateral
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, poolAddr, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getModifyPosition.bind(vesuAdapterLST));
+  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));
@@ -865,6 +1019,7 @@ const hyperxSTRK: HyperLSTStrategySettings = {
   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 = {
@@ -878,6 +1033,7 @@ const hyperxWBTC: HyperLSTStrategySettings = {
   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 = {
@@ -891,6 +1047,7 @@ const hyperxtBTC: HyperLSTStrategySettings = {
   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')!,
 }
 
 const hyperxsBTC: HyperLSTStrategySettings = {
@@ -904,6 +1061,7 @@ const hyperxsBTC: HyperLSTStrategySettings = {
   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')!,
 }
 
 const hyperxLBTC: HyperLSTStrategySettings = {
@@ -917,6 +1075,7 @@ const hyperxLBTC: HyperLSTStrategySettings = {
   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')!,
 }
 
 function getInvestmentSteps(lstSymbol: string, underlyingSymbol: string) {

package/src/strategies/universal-strategy.tsx

@@ -2,7 +2,7 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
 import { PricerBase } from "@/modules/pricerBase";
 import { FAQ, getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, VaultPosition } from "@/interfaces";
-import { Call, CallData, Contract, num, uint256 } from "starknet";
+import { BlockIdentifier, Call, CallData, Contract, num, uint256 } from "starknet";
 import { VesuRebalanceSettings } from "./vesu-rebalance";
 import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
 import UniversalVaultAbi from '../data/universal-vault.abi.json';
@@ -452,11 +452,11 @@ export class UniversalStrategy<
     return [vesuAdapter1, vesuAdapter2];
   }
 
-  async getVesuPositions(): Promise<VaultPosition[]> {
+  async getVesuPositions(blockNumber: BlockIdentifier = 'latest'): Promise<VaultPosition[]> {
     const adapters = this.getVesuAdapters();
     const positions: VaultPosition[] = [];
     for (const adapter of adapters) {
-      positions.push(...await adapter.getPositions(this.config));
+      positions.push(...await adapter.getPositions(this.config, blockNumber));
     }
     return positions;
   }
@@ -540,8 +540,8 @@ export class UniversalStrategy<
     return 0;
   }
 
-  async getVesuHealthFactors() {
-    return await Promise.all(this.getVesuAdapters().map(v => v.getHealthFactor()));
+  async getVesuHealthFactors(blockNumber: BlockIdentifier = 'latest') {
+    return await Promise.all(this.getVesuAdapters().map(v => v.getHealthFactor(blockNumber)));
   }
 
   async computeRebalanceConditionAndReturnCalls(): Promise<Call[]> {

package/src/utils/health-factor-math.ts

@@ -0,0 +1,83 @@
+import { Web3Number } from "@/dataTypes";
+import { TokenInfo } from "@/interfaces";
+
+export class HealthFactorMath {
+  static getCollateralRequired(
+    debtAmount: Web3Number,
+    debtPrice: number,
+    targetHF: number,
+    maxLTV: number,
+    collateralPrice: number,
+    collateralTokenInfo: TokenInfo
+  ) {
+    const numerator = debtAmount.multipliedBy(debtPrice).multipliedBy(targetHF);
+    const denominator = collateralPrice * maxLTV;
+    const collateralAmount = numerator.dividedBy(denominator);
+    const netCollateral = new Web3Number(collateralAmount.toString(), collateralTokenInfo.decimals);
+    return netCollateral;
+  }
+
+  static getMinCollateralRequiredOnLooping(
+    debtAmount: Web3Number,
+    debtPrice: number,
+    targetHF: number,
+    maxLTV: number,
+    collateralPrice: number,
+    collateralTokenInfo: TokenInfo
+  ) {
+    const netCollateral = this.getCollateralRequired(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo);
+    const collateralFromDebt = new Web3Number(debtAmount.multipliedBy(debtPrice).dividedBy(collateralPrice).toString(), collateralTokenInfo.decimals);
+    return netCollateral.minus(collateralFromDebt);
+  }
+
+  static getHealthFactor(
+    collateralAmount: Web3Number,
+    collateralPrice: number,
+    maxLTV: number,
+    debtAmount: Web3Number,
+    debtPrice: number,
+  ) {
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    const denominator = debtAmount.multipliedBy(debtPrice);
+    const healthFactor = numerator.dividedBy(denominator);
+    return healthFactor.toNumber();
+  }
+
+  static getMaxDebtAmountOnLooping(
+    collateralAmount: Web3Number,
+    collateralPrice: number,
+    maxLTV: number,
+    targetHF: number,
+    debtPrice: number,
+    debtTokenInfo: TokenInfo
+  ) {
+    // lets say debt usd value is X
+    // HF = ((1 * cp) + X) * maxLTV / (X)
+    // => X * HF = ((1 * cp) + X) * maxLTV
+    // => X * (HF - maxLTV) = 1 * cp * maxLTV
+    // => X = 1 * cp * maxLTV / (HF - maxLTV)
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    const denominator = targetHF - maxLTV;
+    const debtAmount = numerator.dividedBy(denominator);
+    return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
+  }
+
+  static getMaxDebtAmount(
+    collateralAmount: Web3Number,
+    collateralPrice: number,
+    maxLTV: number,
+    targetHF: number,
+    debtPrice: number,
+    debtTokenInfo: TokenInfo
+  ) {
+    // lets say debt usd value is X
+    // HF = ((1 * cp) + X) * maxLTV / (X)
+    // => X * HF = ((1 * cp) + X) * maxLTV
+    // => X * (HF - maxLTV) = 1 * cp * maxLTV
+    // => X = 1 * cp * maxLTV / (HF - maxLTV)
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    const denominator = targetHF * debtPrice;
+    const debtAmount = numerator.dividedBy(denominator);
+    return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
+  }
+}