@strkfarm/sdk 1.1.38 → 1.1.40

package/dist/index.mjs

@@ -315,6 +315,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 {
@@ -2208,16 +2227,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: []
     };
   }
@@ -4018,21 +4037,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;
   }
 };
@@ -15299,6 +15317,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 {
@@ -16421,62 +16524,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,
           {
@@ -16485,34 +16719,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();
@@ -19044,7 +19268,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 {
@@ -19062,6 +19337,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
@@ -26664,7 +27027,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);
@@ -26697,16 +27073,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;
@@ -26714,10 +27091,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) {
@@ -26726,11 +27103,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;
@@ -26742,7 +27119,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}`);
@@ -26762,11 +27140,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;
@@ -26778,7 +27156,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 = [{
@@ -26815,9 +27193,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) {
@@ -29479,11 +29857,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;
   }
@@ -29552,8 +29930,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();
@@ -30149,6 +30527,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) {
@@ -30163,15 +30577,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;
@@ -30219,20 +30632,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)}, 
@@ -30240,11 +30685,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();
@@ -30256,32 +30730,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
@@ -30297,7 +30773,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
@@ -30315,7 +30791,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,
@@ -30332,28 +30808,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 {
@@ -30386,7 +30875,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();
@@ -30443,21 +30932,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 
@@ -30481,7 +31001,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}`);
@@ -30498,8 +31018,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;
@@ -30602,7 +31122,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,
@@ -30668,6 +31188,7 @@ function VaultDescription(lstSymbol, underlyingSymbol) {
     /* @__PURE__ */ jsxs4("p", { style: { fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }, children: [
       "This vault uses Vesu for lending and borrowing. The oracle used by this pool is a ",
       highlightTextWithLinks("conversion rate oracle", [{ highlight: "conversion rate oracle", link: "https://docs.pragma.build/starknet/development#conversion-rate" }]),
+      " ",
       "which is resilient to liquidity issues and price volatility, hence reducing the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep."
     ] }),
     /* @__PURE__ */ jsx5("div", { style: { backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }, children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
@@ -30678,17 +31199,19 @@ function VaultDescription(lstSymbol, underlyingSymbol) {
     ] }) }),
     /* @__PURE__ */ jsx5("div", { style: { backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }, children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
       /* @__PURE__ */ jsx5("strong", { children: "Debt limits:" }),
-      " Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited LSTs remain in the vault, generating a shared net return for all depositors."
-    ] }) }),
-    /* @__PURE__ */ jsx5("div", { style: { backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }, children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
-      /* @__PURE__ */ jsx5("strong", { children: "APY assumptions:" }),
-      " APY shown is the max possible value given current LST and borrowing rates. True APY will be subject to the actual leverage, based on above point. More insights on exact APY will be added soon."
+      " Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited LSTs remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on LST APY, its only on added gain."
     ] }) })
   ] });
 }
 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);
@@ -30698,7 +31221,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,
@@ -30707,25 +31230,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));
@@ -30803,7 +31340,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"),
@@ -30815,7 +31353,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"),
@@ -30827,7 +31366,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"),
@@ -30839,7 +31379,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"),
@@ -30851,7 +31392,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 [
@@ -30883,7 +31425,7 @@ function getStrategySettings(lstSymbol, underlyingSymbol, addresses, isPreview =
     faqs: getFAQs2(lstSymbol, underlyingSymbol),
     investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
     isPreview,
-    apyMethodology: "Current annualized APY in terms of base asset of the LST"
+    apyMethodology: "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown."
   };
 }
 var HyperLSTStrategies = [
@@ -31553,6 +32095,7 @@ var Deployer = {
 };
 var deployer_default = Deployer;
 export {
+  APYType,
   AUMTypes,
   AVNU_EXCHANGE,
   AVNU_MIDDLEWARE,