@strkfarm/sdk 1.1.39 → 1.1.40

package/dist/index.browser.mjs

@@ -274,6 +274,25 @@ var defaultTokens = [{
   priceProxySymbol: "WBTC",
   priceCheckAmount: 1e-4
   // 112000 * 0.0001 = $11.2
+}, {
+  name: "mRe7BTC",
+  symbol: "mRe7BTC",
+  logo: "https://imagedelivery.net/0xPAQaDtnQhBs8IzYRIlNg/3a62ecee-1e58-45d3-9862-3ce90dff1900/logo",
+  address: ContractAddr.from("0x4e4fb1a9ca7e84bae609b9dc0078ad7719e49187ae7e425bb47d131710eddac"),
+  decimals: 18,
+  coingeckId: void 0,
+  displayDecimals: 6,
+  priceCheckAmount: 1e-4
+  // 112000 * 0.0001 = $11.2
+}, {
+  name: "mRe7YIELD",
+  symbol: "mRe7YIELD",
+  logo: "https://midas.app/assets/mre7-BcOOHm7i.svg",
+  address: ContractAddr.from("0x4be8945e61dc3e19ebadd1579a6bd53b262f51ba89e6f8b0c4bc9a7e3c633fc"),
+  decimals: 18,
+  coingeckId: void 0,
+  displayDecimals: 2,
+  priceCheckAmount: 100
 }];
 var tokens = defaultTokens;
 var _Global = class _Global {
@@ -2159,16 +2178,16 @@ var AvnuWrapper = class _AvnuWrapper {
     };
     return swapInfo;
   }
-  static buildZeroSwap(tokenToSell, address) {
+  static buildZeroSwap(tokenToSell, beneficiary, tokenToBuy = tokenToSell) {
     return {
       token_from_address: tokenToSell.address,
       token_from_amount: uint256.bnToUint256(0),
-      token_to_address: tokenToSell.address,
+      token_to_address: tokenToBuy.address,
       token_to_amount: uint256.bnToUint256(0),
       token_to_min_amount: uint256.bnToUint256(0),
-      beneficiary: address,
+      beneficiary,
       integrator_fee_amount_bps: 0,
-      integrator_fee_recipient: address,
+      integrator_fee_recipient: beneficiary,
       routes: []
     };
   }
@@ -4120,21 +4139,20 @@ var Harvests = class _Harvests {
     const rewards = await this.getHarvests(addr);
     if (rewards.length == 0) return [];
     const unClaimed = [];
-    const cls = await this.config.provider.getClassAt(rewards[0].rewardsContract.address);
-    for (let reward of rewards) {
-      const contract = new Contract4({ abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider });
-      const isClaimed = await contract.call("is_claimed", [reward.claim.id]);
-      logger.verbose(`${_Harvests.name}: isClaimed: ${isClaimed}`);
-      if (isClaimed) {
-        return unClaimed;
-      }
-      const bal = await new ERC20(this.config).balanceOf(reward.token, reward.rewardsContract.address, 18);
-      if (bal.lessThan(reward.claim.amount)) {
-        logger.verbose(`${_Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
-        continue;
-      }
-      unClaimed.unshift(reward);
+    const reward = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime())[0];
+    const cls = await this.config.provider.getClassAt(reward.rewardsContract.address);
+    const contract = new Contract4({ abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider });
+    const isClaimed = await contract.call("is_claimed", [reward.claim.id]);
+    logger.verbose(`${_Harvests.name}: isClaimed: ${isClaimed}`);
+    if (isClaimed) {
+      return unClaimed;
     }
+    const bal = await new ERC20(this.config).balanceOf(reward.token, reward.rewardsContract.address, 18);
+    if (bal.lessThan(reward.claim.amount)) {
+      logger.verbose(`${_Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
+      return unClaimed;
+    }
+    unClaimed.unshift(reward);
     return unClaimed;
   }
 };
@@ -15401,6 +15419,91 @@ var apolloClient = new ApolloClient({
 });
 var apollo_client_default = apolloClient;
 
+// src/utils/math-utils.ts
+async function binarySearch(lowWei, highWei, callback) {
+  while (lowWei <= highWei) {
+    const diff = highWei - lowWei;
+    const mid = lowWei + diff / 2n;
+    const result = await callback(mid);
+    if (result === "found") {
+      return mid;
+    } else if (result == "retry") {
+    } else if (result === "go_low") {
+      highWei = mid - BigInt(1);
+    } else {
+      lowWei = mid + BigInt(1);
+    }
+  }
+  return null;
+}
+async function findMaxInputWithSlippage(options) {
+  const {
+    apiGetOutput,
+    maxInput,
+    maxSlippagePercent,
+    tolerance,
+    minInput = 0,
+    referenceAmountMultiplier = 1e-3,
+    referenceRate = 0
+  } = options;
+  let apiCalls = 0;
+  if (!referenceRate && !referenceAmountMultiplier) {
+    throw new Error("One of referenceRate or referenceAmountMultiplier must be provided");
+  }
+  let _referenceRate = referenceRate;
+  if (!_referenceRate) {
+    const smallAmount = maxInput * referenceAmountMultiplier;
+    const referenceOutput = await apiGetOutput(smallAmount);
+    apiCalls++;
+    _referenceRate = referenceOutput / smallAmount;
+  }
+  async function checkSlippage(inputAmount) {
+    const actualOutput = await apiGetOutput(inputAmount);
+    apiCalls++;
+    const expectedOutput = inputAmount * referenceRate;
+    const slippage = (expectedOutput - actualOutput) / expectedOutput;
+    logger.verbose(`findMaxInputWithSlippage::checkSlippage inputAmount: ${inputAmount}, actualOutput: ${actualOutput}, slippage: ${slippage}, maxSlippagePercent: ${maxSlippagePercent}`);
+    return {
+      acceptable: slippage <= maxSlippagePercent,
+      slippage,
+      output: actualOutput
+    };
+  }
+  const maxCheck = await checkSlippage(maxInput);
+  if (maxCheck.acceptable) {
+    return {
+      optimalInput: maxInput,
+      actualOutput: maxCheck.output,
+      actualSlippage: maxCheck.slippage,
+      apiCallsUsed: apiCalls
+    };
+  }
+  let left = minInput;
+  let right = maxInput;
+  let bestInput = minInput;
+  let bestOutput = 0;
+  let bestSlippage = 0;
+  const convergenceThreshold = tolerance * maxInput;
+  while (right - left > convergenceThreshold) {
+    const mid = (left + right) / 2;
+    const midCheck = await checkSlippage(mid);
+    if (midCheck.acceptable) {
+      bestInput = mid;
+      bestOutput = midCheck.output;
+      bestSlippage = midCheck.slippage;
+      left = mid;
+    } else {
+      right = mid;
+    }
+  }
+  return {
+    optimalInput: bestInput,
+    actualOutput: bestOutput,
+    actualSlippage: bestSlippage,
+    apiCallsUsed: apiCalls
+  };
+}
+
 // src/strategies/ekubo-cl-vault.tsx
 import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
@@ -16523,62 +16626,193 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       logger.verbose(
         `${_EkuboCLVault.name}: harvest => Processing claim, isToken1: ${isToken1} amount: ${postFeeAmount.toWei()}`
       );
-      const token0Amt = isToken1 ? new Web3Number(0, token0Info.decimals) : postFeeAmount;
-      const token1Amt = isToken1 ? postFeeAmount : new Web3Number(0, token0Info.decimals);
+      const isRewardTokenMatch = claim.token.eq(poolKey.token0) || claim.token.eq(poolKey.token1);
+      if (isRewardTokenMatch) {
+        const _callsFinal = await this._handleRewardAndVaultTokenMatchHarvest({
+          acc,
+          claim,
+          isToken1,
+          token0Info,
+          token1Info,
+          postFeeAmount,
+          poolKey,
+          bounds,
+          maxIterations,
+          priceRatioPrecision
+        });
+        calls.push(..._callsFinal);
+      } else {
+        const _callsFinal = await this._handleRewardAndVaultTokenMismatchHarvest({
+          claim,
+          token0Info,
+          token1Info,
+          postFeeAmount,
+          poolKey,
+          bounds,
+          maxIterations,
+          priceRatioPrecision,
+          acc
+        });
+        calls.push(..._callsFinal);
+      }
+    }
+    return calls;
+  }
+  /**
+   * @description This funciton requires atleast one of the pool tokens to be reward token
+   * i.e. STRK. 
+   * @param params 
+   */
+  async _handleRewardAndVaultTokenMatchHarvest(params) {
+    const { acc, claim, isToken1, token0Info, token1Info, postFeeAmount, poolKey, bounds, maxIterations, priceRatioPrecision } = params;
+    const token0Amt = isToken1 ? new Web3Number(0, token0Info.decimals) : postFeeAmount;
+    const token1Amt = isToken1 ? postFeeAmount : new Web3Number(0, token0Info.decimals);
+    logger.verbose(
+      `${_EkuboCLVault.name}: harvest => token0Amt: ${token0Amt.toString()}, token1Amt: ${token1Amt.toString()}`
+    );
+    const swapInfo = await this.getSwapInfoGivenAmounts(
+      poolKey,
+      token0Amt,
+      token1Amt,
+      bounds,
+      maxIterations,
+      priceRatioPrecision
+    );
+    swapInfo.token_to_address = token0Info.address.address;
+    logger.verbose(
+      `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+    );
+    logger.verbose(
+      `${_EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
+    );
+    const harvestEstimateCall = async (swapInfo1) => {
+      const swap1Amount = Web3Number.fromWei(
+        uint2564.uint256ToBN(swapInfo1.token_from_amount).toString(),
+        18
+        // cause its always STRK?
+      ).minimum(
+        postFeeAmount.toFixed(18)
+        // cause always strk
+      );
+      swapInfo.token_from_amount = uint2564.bnToUint256(swap1Amount.toWei());
+      swapInfo.token_to_min_amount = uint2564.bnToUint256(
+        swap1Amount.multipliedBy(0).toWei()
+        // placeholder
+      );
       logger.verbose(
-        `${_EkuboCLVault.name}: harvest => token0Amt: ${token0Amt.toString()}, token1Amt: ${token1Amt.toString()}`
+        `${_EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
       );
-      const swapInfo = await this.getSwapInfoGivenAmounts(
-        poolKey,
-        token0Amt,
-        token1Amt,
-        bounds,
-        maxIterations,
-        priceRatioPrecision
+      const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
+      logger.verbose(
+        `${_EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
       );
-      swapInfo.token_to_address = token0Info.address.address;
+      const swapInfo2 = {
+        ...swapInfo,
+        token_from_amount: uint2564.bnToUint256(remainingAmount.toWei())
+      };
+      swapInfo2.token_to_address = token1Info.address.address;
       logger.verbose(
-        `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+        `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
+          swapInfo
+        )}`
       );
       logger.verbose(
-        `${_EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
+        `${_EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
+          swapInfo2
+        )}`
       );
-      const harvestEstimateCall = async (swapInfo1) => {
-        const swap1Amount = Web3Number.fromWei(
-          uint2564.uint256ToBN(swapInfo1.token_from_amount).toString(),
-          18
-          // cause its always STRK?
-        ).minimum(
-          postFeeAmount.toFixed(18)
-          // cause always strk
-        );
-        swapInfo.token_from_amount = uint2564.bnToUint256(swap1Amount.toWei());
-        swapInfo.token_to_min_amount = uint2564.bnToUint256(
-          swap1Amount.multipliedBy(0).toWei()
-          // placeholder
-        );
-        logger.verbose(
-          `${_EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
-        );
-        const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
-        logger.verbose(
-          `${_EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
-        );
-        const swapInfo2 = {
-          ...swapInfo,
-          token_from_amount: uint2564.bnToUint256(remainingAmount.toWei())
-        };
-        swapInfo2.token_to_address = token1Info.address.address;
-        logger.verbose(
-          `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
-            swapInfo
-          )}`
-        );
-        logger.verbose(
-          `${_EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
-            swapInfo2
-          )}`
-        );
+      const calldata = [
+        claim.rewardsContract.address,
+        {
+          id: claim.claim.id,
+          amount: claim.claim.amount.toWei(),
+          claimee: claim.claim.claimee.address
+        },
+        claim.proof.map((p) => num5.getDecimalString(p)),
+        swapInfo,
+        swapInfo2
+      ];
+      logger.verbose(
+        `${_EkuboCLVault.name}: harvest => calldata: ${JSON.stringify(
+          calldata
+        )}`
+      );
+      return [this.contract.populate("harvest", calldata)];
+    };
+    const _callsFinal = await this.rebalanceIter(
+      swapInfo,
+      acc,
+      harvestEstimateCall,
+      claim.token.eq(poolKey.token0),
+      0,
+      0n,
+      BigInt(postFeeAmount.toWei())
+      // upper limit is the post fee amount
+    );
+    logger.verbose(
+      `${_EkuboCLVault.name}: harvest => _callsFinal: ${JSON.stringify(
+        _callsFinal
+      )}`
+    );
+    return _callsFinal;
+  }
+  /**
+   * @description This function handles harvesting of reward token that is not the same as any of the vault token
+   * i.e. STRK is not part of vault tokens like BTC/ETH 
+   * @param params 
+   * @returns 
+   */
+  async _handleRewardAndVaultTokenMismatchHarvest(params) {
+    const { acc, claim, token0Info, token1Info, postFeeAmount, poolKey, bounds, maxIterations, priceRatioPrecision } = params;
+    let token0Amt = postFeeAmount;
+    const beneficiary = this.address.address;
+    let harvestCall = null;
+    harvestCall = await this.harvestMismatchEstimateCallFn({
+      postFeeAmount,
+      claim,
+      token0Info,
+      token1Info,
+      acc
+    });
+    if (!harvestCall) {
+      throw new Error("Harvest call not found");
+    }
+    return [harvestCall];
+  }
+  // given an amount (i.e. portion of reward to use to swap to token0), returns info on increasing or decreasing 
+  // amount for binary search
+  async harvestMismatchEstimateCallFn(params) {
+    const { postFeeAmount, claim, token0Info, token1Info, acc } = params;
+    let harvestCall = null;
+    const binarySearchCallbackFn = async (mid) => {
+      const rewardPart2 = BigInt(postFeeAmount.toWei()) - mid;
+      const avnuWrapper = new AvnuWrapper();
+      const beneficiary = this.address.address;
+      const quote1 = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token0Info.address.address,
+        mid.toString(),
+        beneficiary
+      );
+      const swapInfo1 = await avnuWrapper.getSwapInfo(
+        quote1,
+        beneficiary,
+        0,
+        beneficiary
+      );
+      const quote2 = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        rewardPart2.toString(),
+        beneficiary
+      );
+      const swapInfo2 = await avnuWrapper.getSwapInfo(
+        quote2,
+        beneficiary,
+        0,
+        beneficiary
+      );
+      try {
         const calldata = [
           claim.rewardsContract.address,
           {
@@ -16587,34 +16821,24 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
             claimee: claim.claim.claimee.address
           },
           claim.proof.map((p) => num5.getDecimalString(p)),
-          swapInfo,
+          swapInfo1,
           swapInfo2
         ];
-        logger.verbose(
-          `${_EkuboCLVault.name}: harvest => calldata: ${JSON.stringify(
-            calldata
-          )}`
-        );
-        return [this.contract.populate("harvest", calldata)];
-      };
-      const _callsFinal = await this.rebalanceIter(
-        swapInfo,
-        acc,
-        harvestEstimateCall,
-        claim.token.eq(poolKey.token0),
-        0,
-        0n,
-        BigInt(postFeeAmount.toWei())
-        // upper limit is the post fee amount
-      );
-      logger.verbose(
-        `${_EkuboCLVault.name}: harvest => _callsFinal: ${JSON.stringify(
-          _callsFinal
-        )}`
-      );
-      calls.push(..._callsFinal);
-    }
-    return calls;
+        harvestCall = this.contract.populate("harvest", calldata);
+        const gas = await acc.estimateInvokeFee(harvestCall);
+        return "found";
+      } catch (err) {
+        console.error(err);
+        if (err.message.includes("invalid token0 amount")) {
+          return "go_low";
+        } else if (err.message.includes("invalid token1 amount")) {
+          return "go_high";
+        }
+        return "retry";
+      }
+    };
+    await binarySearch(0n, BigInt(postFeeAmount.toWei()), binarySearchCallbackFn);
+    return harvestCall;
   }
   async getInvestmentFlows() {
     const netYield = await this.netAPY();
@@ -19146,7 +19370,58 @@ function toBigInt(value) {
 }
 
 // src/strategies/universal-adapters/baseAdapter.ts
+var APYType = /* @__PURE__ */ ((APYType2) => {
+  APYType2["BASE"] = "base";
+  APYType2["REWARD"] = "reward";
+  APYType2["LST"] = "lst";
+  return APYType2;
+})(APYType || {});
 var BaseAdapter = class extends CacheClass {
+  // readonly config: BaseAdapterConfig;
+  // constructor(config: BaseAdapterConfig) {
+  //   super();
+  //   this.config = config;
+  // }
+  constructor() {
+    super();
+  }
+  // /**
+  //  * Loop through all supported positions and return amount, usd value, remarks and apy for each
+  //  */
+  // async getPositions(): Promise<PositionInfo[]> {
+  //   const results: PositionInfo[] = [];
+  //   for (const supported of this.config.supportedPositions) {
+  //     const amount = await this.getPosition(supported);
+  //     const usdValue = await this.getUSDValue(supported.asset, amount);
+  //     const apy = await this.getAPY(supported);
+  //     results.push({ amount, usdValue, apy });
+  //   }
+  //   return results;
+  // }
+  // /**
+  //  * Implemented by child adapters to compute APY for a given supported position
+  //  */
+  // protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+  // /**
+  //  * Implemented by child adapters to fetch amount for a given supported position
+  //  */
+  // protected abstract getPosition(supportedPosition: SupportedPosition): Promise<Web3Number>;
+  // /**
+  //  * Implemented by child adapters to calculate maximum deposit positions
+  //  * @param amount Optional amount in baseToken to deposit
+  //  */
+  // protected abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo[]>;
+  // /**
+  //  * Implemented by child adapters to calculate maximum withdraw positions
+  //  */
+  // protected abstract maxWithdraw(): Promise<PositionInfo[]>;
+  // /**
+  //  * Uses pricer to convert an amount of an asset to USD value
+  //  */
+  // protected async getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number> {
+  //   const priceInfo = await this.config.pricer.getPrice(asset.symbol);
+  //   return amount.toNumber() * priceInfo.price;
+  // }
   constructSimpleLeafData(params, sanitizer = SIMPLE_SANITIZER) {
     const { id, target, method, packedArguments } = params;
     return {
@@ -19164,6 +19439,94 @@ var BaseAdapter = class extends CacheClass {
       ]
     };
   }
+  // /**
+  //  * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+  //  */
+  // protected abstract _getDepositLeaf(): {
+  //   target: ContractAddr,
+  //   method: string,
+  //   packedArguments: bigint[],
+  //   sanitizer: ContractAddr,
+  //   id: string
+  // }[];
+  // /**
+  //  * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
+  //  */
+  // protected abstract _getWithdrawLeaf(): {
+  //   target: ContractAddr,
+  //   method: string,
+  //   packedArguments: bigint[],
+  //   sanitizer: ContractAddr,
+  //   id: string
+  // }[];
+  // /**
+  //  * Returns deposit leaf adapter using configured proof id
+  //  */
+  // getDepositLeaf(): AdapterLeafType<T1> {
+  //   const leafConfigs = this._getDepositLeaf();
+  //   const leaves = leafConfigs.map(config => {
+  //     const { target, method, packedArguments, sanitizer, id } = config;
+  //     const leaf = this.constructSimpleLeafData({
+  //       id: id,
+  //       target,
+  //       method,
+  //       packedArguments
+  //     }, sanitizer);
+  //     return leaf;
+  //   });
+  //   return { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<T1> };
+  // }
+  // /**
+  //  * Returns withdraw leaf adapter using configured proof id
+  //  */
+  // getWithdrawLeaf(): AdapterLeafType<T2> {
+  //   const leafConfigs = this._getWithdrawLeaf();
+  //   const leaves = leafConfigs.map(config => {
+  //     const { target, method, packedArguments, sanitizer, id } = config;
+  //     const leaf = this.constructSimpleLeafData({
+  //       id: id,
+  //       target,
+  //       method,
+  //       packedArguments
+  //     }, sanitizer ?? SIMPLE_SANITIZER);
+  //     return leaf;
+  //   });
+  //   return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<T2> };
+  // }
+  // /**
+  //  * Default deposit callConstructor: expects params as calldata (bigint[])
+  //  */
+  // protected getDepositCall<T1 = bigint[]>(params: T1): ManageCall[] {
+  //   const leafConfigs = this._getDepositLeaf();
+  //   return leafConfigs.map(config => {
+  //     const { target, method, sanitizer } = config;
+  //     return {
+  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
+  //       call: {
+  //         contractAddress: target,
+  //         selector: hash.getSelectorFromName(method),
+  //         calldata: params as unknown as bigint[]
+  //       }
+  //     };
+  //   });
+  // }
+  // /**
+  //  * Default withdraw callConstructor: expects params as calldata (bigint[])
+  //  */
+  // protected getWithdrawCall<T2 = bigint[]>(params: T2): ManageCall[] {
+  //   const leafConfigs = this._getWithdrawLeaf();
+  //   return leafConfigs.map(config => {
+  //     const { target, method, sanitizer } = config;
+  //     return {
+  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
+  //       call: {
+  //         contractAddress: target,
+  //         selector: hash.getSelectorFromName(method),
+  //         calldata: params as unknown as bigint[]
+  //       }
+  //     };
+  //   });
+  // }
 };
 
 // src/strategies/universal-adapters/common-adapter.ts
@@ -26766,7 +27129,20 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     }
     const output = await contract.call("pair_config", [this.config.collateral.address.address, this.config.debt.address.address]);
     logger.verbose(`${this.config.debt.symbol}::VesuAdapter::getDebtCap debt_cap: ${output.debt_cap.toString()}`);
-    return Web3Number.fromWei(output.debt_cap.toString(), this.config.debt.decimals);
+    if (!isV2) {
+      throw new Error("getDebtCap is not supported for v1");
+    }
+    const currentDebt = await this.getCurrentDebtUtilisationAmount(config);
+    logger.verbose(`${this.config.debt.symbol}::VesuAdapter::getDebtCap currentDebt: ${currentDebt.toString()}`);
+    return Web3Number.fromWei(output.debt_cap.toString(), this.config.debt.decimals).minus(currentDebt);
+  }
+  async getCurrentDebtUtilisationAmount(config) {
+    const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
+    if (!isV2) {
+      throw new Error("getCurrentDebtUtilisationAmount is not supported for v1");
+    }
+    const output = await contract.call("pairs", [this.config.collateral.address.address, this.config.debt.address.address]);
+    return new Web3Number((Number(output.total_nominal_debt) / 1e18).toFixed(9), this.config.debt.decimals);
   }
   async getMaxBorrowableByInterestRate(config, asset, maxBorrowAPY) {
     const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
@@ -26799,16 +27175,17 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     const assetConfig = isV2 ? _assetConfig : _assetConfig["0"];
     const timeDelta = assetConfig.last_updated;
     const lastFullUtilizationRate = assetConfig.last_full_utilization_rate;
-    const totalSupply = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals).plus(Web3Number.fromWei(assetConfig.reserve, asset.decimals));
+    const currentDebt = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals);
+    const totalSupply = currentDebt.plus(Web3Number.fromWei(assetConfig.reserve, asset.decimals));
     const ratePerSecond = BigInt(Math.round(maxBorrowAPY / 365 / 24 / 60 / 60 * Number(SCALE)));
     const maxUtilisation = this.getMaxUtilizationGivenRatePerSecond(interestRateConfig, ratePerSecond, timeDelta, lastFullUtilizationRate);
     logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate maxUtilisation: ${Number(maxUtilisation) / 1e18}, totalSupply: ${totalSupply.toString()}`);
     const maxDebtToHave = totalSupply.multipliedBy(Number(maxUtilisation) / 1e18);
-    const currentDebt = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals);
+    logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate currentDebt: ${currentDebt.toString()}, maxDebtToHave: ${maxDebtToHave.toString()}`);
     return maxDebtToHave.minus(currentDebt);
   }
-  async getLTVConfig(config) {
-    const CACHE_KEY = "ltv_config";
+  async getLTVConfig(config, blockNumber = "latest") {
+    const CACHE_KEY = `ltv_config_${blockNumber}`;
     const cacheData = this.getCache(CACHE_KEY);
     if (cacheData) {
       return cacheData;
@@ -26816,10 +27193,10 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
     let ltv = 0;
     if (isV2) {
-      const output = await contract.call("pair_config", [this.config.collateral.address.address, this.config.debt.address.address]);
+      const output = await contract.call("pair_config", [this.config.collateral.address.address, this.config.debt.address.address], { blockIdentifier: blockNumber });
       ltv = Number(output.max_ltv) / 1e18;
     } else {
-      const output = await contract.call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
+      const output = await contract.call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address], { blockIdentifier: blockNumber });
       ltv = Number(output.max_ltv) / 1e18;
     }
     if (ltv == 0) {
@@ -26828,11 +27205,11 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     this.setCache(CACHE_KEY, ltv, 3e5);
     return this.getCache(CACHE_KEY);
   }
-  async getPositions(config) {
+  async getPositions(config, blockNumber = "latest") {
     if (!this.pricer) {
       throw new Error("Pricer is not initialized");
     }
-    const CACHE_KEY = "positions";
+    const CACHE_KEY = `positions_${blockNumber}`;
     const cacheData = this.getCache(CACHE_KEY);
     if (cacheData) {
       return cacheData;
@@ -26844,7 +27221,8 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
       this.config.collateral.address.address,
       this.config.debt.address.address,
       this.config.vaultAllocator.address
-    ]);
+    ], { blockIdentifier: blockNumber });
+    console.log(output);
     const token1Price = await this.pricer.getPrice(this.config.collateral.symbol);
     const token2Price = await this.pricer.getPrice(this.config.debt.symbol);
     logger.verbose(`VesuAdapter::getPositions token1Price: ${token1Price.price}, token2Price: ${token2Price.price}`);
@@ -26864,11 +27242,11 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     this.setCache(CACHE_KEY, value, 6e4);
     return value;
   }
-  async getCollateralization(config) {
+  async getCollateralization(config, blockNumber = "latest") {
     if (!this.pricer) {
       throw new Error("Pricer is not initialized");
     }
-    const CACHE_KEY = "collateralization";
+    const CACHE_KEY = `collateralization_${blockNumber}`;
     const cacheData = this.getCache(CACHE_KEY);
     if (cacheData) {
       return cacheData;
@@ -26880,7 +27258,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
       this.config.collateral.address.address,
       this.config.debt.address.address,
       this.config.vaultAllocator.address
-    ]);
+    ], { blockIdentifier: blockNumber });
     const collateralAmount = Web3Number.fromWei(output["1"].toString(), 18);
     const debtAmount = Web3Number.fromWei(output["2"].toString(), 18);
     const value = [{
@@ -26917,9 +27295,9 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
       ltv
     };
   }
-  async getHealthFactor() {
-    const ltv = await this.getLTVConfig(this.networkConfig);
-    const collateralisation = await this.getCollateralization(this.networkConfig);
+  async getHealthFactor(blockNumber = "latest") {
+    const ltv = await this.getLTVConfig(this.networkConfig, blockNumber);
+    const collateralisation = await this.getCollateralization(this.networkConfig, blockNumber);
     return collateralisation[0].usdValue * ltv / collateralisation[1].usdValue;
   }
   static async getVesuPools(retry = 0) {
@@ -29581,11 +29959,11 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     vesuAdapter2.networkConfig = this.config;
     return [vesuAdapter1, vesuAdapter2];
   }
-  async getVesuPositions() {
+  async getVesuPositions(blockNumber = "latest") {
     const adapters = this.getVesuAdapters();
     const positions = [];
     for (const adapter of adapters) {
-      positions.push(...await adapter.getPositions(this.config));
+      positions.push(...await adapter.getPositions(this.config, blockNumber));
     }
     return positions;
   }
@@ -29654,8 +30032,8 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   async getLSTAPR(address) {
     return 0;
   }
-  async getVesuHealthFactors() {
-    return await Promise.all(this.getVesuAdapters().map((v) => v.getHealthFactor()));
+  async getVesuHealthFactors(blockNumber = "latest") {
+    return await Promise.all(this.getVesuAdapters().map((v) => v.getHealthFactor(blockNumber)));
   }
   async computeRebalanceConditionAndReturnCalls() {
     const vesuAdapters = this.getVesuAdapters();
@@ -30251,6 +30629,42 @@ var UniversalStrategies = [
 
 // src/strategies/universal-lst-muliplier-strategy.tsx
 import { Contract as Contract10, uint256 as uint2569 } from "starknet";
+
+// src/utils/health-factor-math.ts
+var HealthFactorMath = class {
+  static getCollateralRequired(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo) {
+    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, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo) {
+    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, collateralPrice, maxLTV, debtAmount, debtPrice) {
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    const denominator = debtAmount.multipliedBy(debtPrice);
+    const healthFactor = numerator.dividedBy(denominator);
+    return healthFactor.toNumber();
+  }
+  static getMaxDebtAmountOnLooping(collateralAmount, collateralPrice, maxLTV, targetHF, debtPrice, debtTokenInfo) {
+    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, collateralPrice, maxLTV, targetHF, debtPrice, debtTokenInfo) {
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    const denominator = targetHF * debtPrice;
+    const debtAmount = numerator.dividedBy(denominator);
+    return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
+  }
+};
+
+// src/strategies/universal-lst-muliplier-strategy.tsx
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy extends UniversalStrategy {
   constructor(config, pricer, metadata) {
@@ -30265,15 +30679,14 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
     }
   }
   asset() {
-    const vesuAdapter1 = this.getAdapter("vesu_leg1_adapter" /* VESU_LEG1 */);
-    return vesuAdapter1.config.collateral;
+    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("vesu_leg1_adapter" /* VESU_LEG1 */);
+    const baseAdapter = this.getAdapter(getVesuLegId("vesu_leg1" /* VESU_LEG1 */, this.metadata.additionalInfo.underlyingToken.symbol));
     baseAdapter.networkConfig = this.config;
     baseAdapter.pricer = this.pricer;
     return baseAdapter;
@@ -30321,20 +30734,52 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
     return price;
   }
   async getAvnuSwapMultiplyCall(params) {
-    return this._getAvnuDepositSwapLegCall({
-      ...params,
-      minHF: 1.1
-      // undo
-    });
+    assert(params.isDeposit, "Only deposit is supported in getAvnuSwapMultiplyCall");
+    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
+      });
+      remainingAmount = remainingAmount.minus(amountToDeposit);
+      return { call, vesuAdapter };
+    }
+    throw new Error(`${this.getTag()}::getAvnuSwapMultiplyCall: no calls found`);
   }
   async _getAvnuDepositSwapLegCall(params) {
+    const { vesuAdapter } = params;
     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall params: ${JSON.stringify(params)}`);
     assert(params.isDeposit, "Only deposit is supported in _getAvnuDepositSwapLegCall");
-    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)}, 
@@ -30342,11 +30787,40 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
     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 = 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 (debtAmount.gt(0) && maxBorrowable.amount.eq(0)) {
+      logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall maxBorrowable is 0, skipping`);
+      return void 0;
+    } 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) {
+        logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newDebtUSDValue is less than 100, skipping`);
+        return void 0;
+      }
+    }
     logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
     if (debtAmount.lt(0)) {
       const lstDEXPrice = await this.getLSTDexPrice();
@@ -30358,32 +30832,34 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
       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 = "approve_token1" /* APPROVE_TOKEN1 */;
     const manage0Info = this.getProofs(STEP0);
     const manageCall0 = manage0Info.callConstructor({
-      amount: params.leg1DepositAmount
+      amount: newDepositAmount
     });
-    const STEP1 = "vesu_leg1" /* VESU_LEG1 */;
+    const STEP1 = getVesuLegId("vesu_leg1" /* VESU_LEG1 */, vesuAdapter.config.debt.symbol);
     const manage1Info = this.getProofs(STEP1);
     const manageCall1 = manage1Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
-      collateralAmount: params.leg1DepositAmount,
+      collateralAmount: newDepositAmount,
       isAddCollateral: params.isDeposit,
       debtAmount,
       isBorrow: params.isDeposit
     }));
+    console.log(`manageCall1`, manageCall1.call, debtAmount.toWei(), newDepositAmount.toWei());
     const proofIds = [STEP0, STEP1];
     const manageCalls = [manageCall0, manageCall1];
     if (debtAmount.gt(0)) {
-      const STEP2 = "avnu_multiply_approve_deposit" /* AVNU_MULTIPLY_APPROVE_DEPOSIT */;
+      const STEP2 = getAvnuManageIDs("avnu_mul_approve_dep" /* AVNU_MULTIPLY_APPROVE_DEPOSIT */, vesuAdapter.config.debt.symbol);
       const manage2Info = this.getProofs(STEP2);
       const manageCall2 = manage2Info.callConstructor({
         amount: debtAmount
       });
-      const debtTokenInfo = vesuAdapter1.config.debt;
+      const debtTokenInfo2 = vesuAdapter.config.debt;
       const lstTokenInfo = this.asset();
       const avnuModule = new AvnuWrapper();
       const quote = await avnuModule.getQuotes(
-        debtTokenInfo.address.address,
+        debtTokenInfo2.address.address,
         lstTokenInfo.address.address,
         debtAmount.toWei(),
         this.metadata.additionalInfo.vaultAllocator.address
@@ -30399,7 +30875,7 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
         minAmountWei
       );
       logger.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall swapInfo: ${JSON.stringify(swapInfo)}`);
-      const STEP3 = "avnu_multiply_swap_deposit" /* AVNU_MULTIPLY_SWAP_DEPOSIT */;
+      const STEP3 = getAvnuManageIDs("avnu_mul_swap_dep" /* AVNU_MULTIPLY_SWAP_DEPOSIT */, vesuAdapter.config.debt.symbol);
       const manage3Info = this.getProofs(STEP3);
       const manageCall3 = manage3Info.callConstructor({
         props: swapInfo
@@ -30417,7 +30893,7 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
         const manageCall4 = manage4Info.callConstructor({
           amount: minAmount
         });
-        const STEP5 = "vesu_leg1" /* VESU_LEG1 */;
+        const STEP5 = getVesuLegId("vesu_leg1" /* VESU_LEG1 */, vesuAdapter.config.debt.symbol);
         const manage5Info = this.getProofs(STEP5);
         const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
           collateralAmount: minAmount,
@@ -30434,28 +30910,41 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
   }
   // todo unwind or not deposit when the yield is bad. 
   async getLSTMultiplierRebalanceCall() {
-    const positions = await this.getVaultPositions();
-    assert(positions.length == 3, "Rebalance call is only supported for 3 positions");
+    let shouldRebalance = false;
+    const calls = [];
+    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) {
+    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 [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 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)}`);
     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) {
       const manageCall = await this._getAvnuDepositSwapLegCall({
         isDeposit: true,
         leg1DepositAmount: unusedBalance.amount,
-        minHF: 1.02
+        minHF: 1.02,
         // todo, shouldnt use this 1.02 HF, if there isn;t more looping left. 
+        vesuAdapter
       });
       return { shouldRebalance: true, manageCall };
     } else {
@@ -30488,7 +30977,7 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
   async _getMinOutputAmountLSTBuy(amountInUnderlying) {
     const lstTruePrice = await this.getLSTExchangeRate();
     const minOutputAmount = amountInUnderlying.dividedBy(lstTruePrice).multipliedBy(0.99979);
-    return minOutputAmount;
+    return new Web3Number(minOutputAmount.toString(), this.asset().decimals);
   }
   async _getMinOutputAmountLSTSell(amountInLST) {
     const lstTruePrice = await this.getLSTExchangeRate();
@@ -30545,21 +31034,52 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
     const vesuAdapter1 = this.getVesuSameTokenAdapter();
     return vesuAdapter1.config.debt;
   }
-  async getMaxBorrowableAmount() {
+  async getMaxBorrowableAmount(params = { isAPYComputation: false }) {
     const vesuAdapters = this.getVesuAdapters();
     let netMaxBorrowableAmount = Web3Number.fromWei("0", this.getLSTUnderlyingTokenInfo().decimals);
     const maxBorrowables = [];
-    const lstAPY = await this.getLSTAPR(this.getLSTUnderlyingTokenInfo().address);
-    const maxInterestRate = lstAPY * 0.8;
     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, toToken, maxSlippage, maxAmount) {
+    const output = await findMaxInputWithSlippage({
+      apiGetOutput: async (inputAmount) => {
+        const ekuboQuoter = new EkuboQuoter(this.config);
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        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: 1e-3,
+      referenceRate: 1
+    });
+    return new Web3Number(output.optimalInput, fromToken.decimals);
+  }
+  async getMaxBorrowableAmountByVesuAdapter(vesuAdapter, isAPYComputation) {
+    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);
+    if (vesuAdapter.config.debt.address.eq(this.getLSTUnderlyingTokenInfo().address) || isAPYComputation) {
+      return { amount: maxBorrowable, dexSwappableAmount: maxBorrowable, maxBorrowableAmount: maxBorrowable, borrowableAsset: vesuAdapter.config.debt };
+    }
+    try {
+      const maxSwappable = await this.getMaxSwappableWithMaxSlippage(vesuAdapter.config.debt, this.getLSTUnderlyingTokenInfo(), 2e-4, 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 
@@ -30583,7 +31103,7 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
   // todo undo this
   async netAPY() {
     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 (maxNewDeposits * 1.5 < unusedBalance.amount.toNumber()) {
       logger.verbose(`${this.getTag()}::netAPY: unused balance is > max servicable from loan, lstAPY: ${lstAPY}`);
@@ -30600,8 +31120,8 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
       return output;
     }
   }
-  async maxNewDeposits() {
-    const maxBorrowableAmounts = await this.getMaxBorrowableAmount();
+  async maxNewDeposits(params = { isAPYComputation: false }) {
+    const maxBorrowableAmounts = await this.getMaxBorrowableAmount(params);
     let ltv = void 0;
     for (let adapter of this.getVesuAdapters()) {
       const maxBorrowableAmount = maxBorrowableAmounts.maxBorrowables.find((b) => b.borrowableAsset.address.eq(adapter.config.debt.address))?.amount;
@@ -30704,7 +31224,7 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
     const manageCall2 = manage2Info.callConstructor({
       delegation: true
     });
-    const STEP3_ID = "multiply_vesu" /* MULTIPLY_VESU */;
+    const STEP3_ID = getVesuLegId("multiply_vesu" /* MULTIPLY_VESU */, vesuAdapter1.config.debt.symbol);
     const manage3Info = this.getProofs(STEP3_ID);
     const multiplyParams = params.isIncrease ? {
       isIncrease: true,
@@ -30788,6 +31308,12 @@ function VaultDescription(lstSymbol, underlyingSymbol) {
 function getDescription2(tokenSymbol, underlyingSymbol) {
   return VaultDescription(tokenSymbol, underlyingSymbol);
 }
+function getAvnuManageIDs(baseID, debtTokenSymbol) {
+  return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
+}
+function getVesuLegId(baseID, debtTokenSymbol) {
+  return `${baseID}_${debtTokenSymbol.toLowerCase()}`;
+}
 function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1) {
   vaultSettings.leafAdapters = [];
   const lstToken = Global.getDefaultTokens().find((token) => token.symbol === lstSymbol);
@@ -30797,7 +31323,7 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1) {
     collateral: lstToken,
     debt: underlyingToken,
     vaultAllocator: vaultSettings.vaultAllocator,
-    id: "vesu_leg1" /* VESU_LEG1 */
+    id: getVesuLegId("vesu_leg1" /* VESU_LEG1 */, underlyingToken.symbol)
   });
   const commonAdapter = new CommonAdapter({
     manager: vaultSettings.manager,
@@ -30806,25 +31332,39 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1) {
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator
   });
-  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, "multiple_approve" /* MULTIPLE_APPROVE */).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getMultiplyAdapter("multiply_vesu" /* MULTIPLY_VESU */).bind(vesuAdapterLST));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter("switch_delegation_on" /* SWITCH_DELEGATION_ON */).bind(vesuAdapterLST));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter("switch_delegation_off" /* SWITCH_DELEGATION_OFF */).bind(vesuAdapterLST));
   vaultSettings.adapters.push(...[{
-    id: "vesu_leg1_adapter" /* VESU_LEG1 */,
+    id: getVesuLegId("vesu_leg1" /* VESU_LEG1 */, underlyingToken.symbol),
     adapter: vesuAdapterLST
   }, {
     id: "common_adapter" /* COMMON */,
     adapter: commonAdapter
   }]);
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(underlyingToken.address, AVNU_EXCHANGE, "avnu_multiply_approve_deposit" /* AVNU_MULTIPLY_APPROVE_DEPOSIT */).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(underlyingToken.address, lstToken.address, "avnu_multiply_swap_deposit" /* AVNU_MULTIPLY_SWAP_DEPOSIT */, false).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, AVNU_EXCHANGE, "avnu_multiply_approve_withdraw" /* AVNU_MULTIPLY_APPROVE_WITHDRAW */).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(lstToken.address, underlyingToken.address, "avnu_multiply_swap_withdraw" /* AVNU_MULTIPLY_SWAP_WITHDRAW */, false).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, poolAddr, "approve_token1" /* APPROVE_TOKEN1 */).bind(commonAdapter));
-  vaultSettings.leafAdapters.push(vesuAdapterLST.getModifyPosition.bind(vesuAdapterLST));
+  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, "multiple_approve" /* MULTIPLE_APPROVE */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter("switch_delegation_on" /* SWITCH_DELEGATION_ON */).bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(vesuAdapterLST.getVesuModifyDelegationAdapter("switch_delegation_off" /* SWITCH_DELEGATION_OFF */).bind(vesuAdapterLST));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, AVNU_EXCHANGE, "avnu_mul_approve_withdr" /* AVNU_MULTIPLY_APPROVE_WITHDRAW */).bind(commonAdapter));
+  for (let borrowableAsset of vaultSettings.borrowable_assets) {
+    const debtAsset = borrowableAsset;
+    const approve_debt_token_id = getAvnuManageIDs("avnu_mul_approve_dep" /* AVNU_MULTIPLY_APPROVE_DEPOSIT */, debtAsset.symbol);
+    const swap_debt_token_id = getAvnuManageIDs("avnu_mul_swap_dep" /* AVNU_MULTIPLY_SWAP_DEPOSIT */, debtAsset.symbol);
+    const swap_lst_token_id = getAvnuManageIDs("avnu_mul_swap_withdr" /* AVNU_MULTIPLY_SWAP_WITHDRAW */, debtAsset.symbol);
+    vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(debtAsset.address, AVNU_EXCHANGE, approve_debt_token_id).bind(commonAdapter));
+    vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(debtAsset.address, lstToken.address, swap_debt_token_id, false).bind(commonAdapter));
+    vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(lstToken.address, debtAsset.address, swap_lst_token_id, false).bind(commonAdapter));
+    const vesuAdapter = new VesuAdapter({
+      poolId: pool1,
+      collateral: lstToken,
+      debt: debtAsset,
+      vaultAllocator: vaultSettings.vaultAllocator,
+      id: getVesuLegId("vesu_leg1" /* VESU_LEG1 */, debtAsset.symbol)
+    });
+    vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, poolAddr, "approve_token1" /* APPROVE_TOKEN1 */).bind(commonAdapter));
+    vaultSettings.leafAdapters.push(vesuAdapter.getModifyPosition.bind(vesuAdapter));
+    const multiplID = getVesuLegId("multiply_vesu" /* MULTIPLY_VESU */, debtAsset.symbol);
+    vaultSettings.leafAdapters.push(vesuAdapter.getMultiplyAdapter(multiplID).bind(vesuAdapter));
+  }
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(lstToken.address, vaultSettings.vaultAddress, "approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter("bring_liquidity" /* BRING_LIQUIDITY */).bind(commonAdapter));
   vaultSettings.leafAdapters.push(vesuAdapterLST.getDefispringRewardsAdapter("defispring_rewards" /* DEFISPRING_REWARDS */).bind(vesuAdapterLST));
@@ -30902,7 +31442,8 @@ var hyperxSTRK = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: Global.getDefaultTokens().filter((token) => token.symbol === "STRK")
+  borrowable_assets: Global.getDefaultTokens().filter((token) => token.symbol === "STRK"),
+  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "STRK")
 };
 var hyperxWBTC = {
   vaultAddress: ContractAddr.from("0x2da9d0f96a46b453f55604313785dc866424240b1c6811d13bef594343db818"),
@@ -30914,7 +31455,8 @@ var hyperxWBTC = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset))
+  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset)),
+  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "WBTC")
 };
 var hyperxtBTC = {
   vaultAddress: ContractAddr.from("0x47d5f68477e5637ce0e56436c6b5eee5a354e6828995dae106b11a48679328"),
@@ -30926,7 +31468,8 @@ var hyperxtBTC = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset))
+  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset)),
+  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "tBTC")
 };
 var hyperxsBTC = {
   vaultAddress: ContractAddr.from("0x437ef1e7d0f100b2e070b7a65cafec0b2be31b0290776da8b4112f5473d8d9"),
@@ -30938,7 +31481,8 @@ var hyperxsBTC = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset))
+  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset)),
+  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "solvBTC")
 };
 var hyperxLBTC = {
   vaultAddress: ContractAddr.from("0x64cf24d4883fe569926419a0569ab34497c6956a1a308fa883257f7486d7030"),
@@ -30950,7 +31494,8 @@ var hyperxLBTC = {
   adapters: [],
   targetHealthFactor: 1.1,
   minHealthFactor: 1.05,
-  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset))
+  borrowable_assets: borrowableAssets.map((asset) => Global.getDefaultTokens().find((token) => token.symbol === asset)),
+  underlyingToken: Global.getDefaultTokens().find((token) => token.symbol === "LBTC")
 };
 function getInvestmentSteps(lstSymbol, underlyingSymbol) {
   return [
@@ -30993,6 +31538,7 @@ var HyperLSTStrategies = [
   getStrategySettings("xLBTC", "LBTC", hyperxLBTC, false)
 ];
 export {
+  APYType,
   AUMTypes,
   AVNU_EXCHANGE,
   AVNU_MIDDLEWARE,