@strkfarm/sdk 1.1.39 → 1.1.41

package/dist/index.browser.global.js

@@ -20191,7 +20191,7 @@ ${r2}}` : "}", l2;
         toHexString: () => toHexString2,
         toStorageKey: () => toStorageKey2
       });
-      var import_utils63 = require_utils2();
+      var import_utils64 = require_utils2();
       function isHex3(hex) {
         return /^0x[0-9a-f]*$/i.test(hex);
       }
@@ -20264,7 +20264,7 @@ ${r2}}` : "}", l2;
         if (adaptedValue.length % 2 !== 0) {
           adaptedValue = `0${adaptedValue}`;
         }
-        return (0, import_utils63.hexToBytes)(adaptedValue);
+        return (0, import_utils64.hexToBytes)(adaptedValue);
       }
       function addPercent2(number2, percent) {
         const bigIntNum = BigInt(number2);
@@ -28640,6 +28640,7 @@ ${r2}}` : "}", l2;
   // src/index.browser.ts
   var index_browser_exports = {};
   __export(index_browser_exports, {
+    APYType: () => APYType,
     AUMTypes: () => AUMTypes,
     AVNU_EXCHANGE: () => AVNU_EXCHANGE,
     AVNU_MIDDLEWARE: () => AVNU_MIDDLEWARE,
@@ -49193,6 +49194,25 @@ ${JSON.stringify(data, null, 2)}`;
     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 {
@@ -53767,16 +53787,16 @@ ${JSON.stringify(data, null, 2)}`;
       };
       return swapInfo;
     }
-    static buildZeroSwap(tokenToSell, address) {
+    static buildZeroSwap(tokenToSell, beneficiary, tokenToBuy = tokenToSell) {
       return {
         token_from_address: tokenToSell.address,
         token_from_amount: uint256_exports.bnToUint256(0),
-        token_to_address: tokenToSell.address,
+        token_to_address: tokenToBuy.address,
         token_to_amount: uint256_exports.bnToUint256(0),
         token_to_min_amount: uint256_exports.bnToUint256(0),
-        beneficiary: address,
+        beneficiary,
         integrator_fee_amount_bps: 0,
-        integrator_fee_recipient: address,
+        integrator_fee_recipient: beneficiary,
         routes: []
       };
     }
@@ -55717,21 +55737,20 @@ ${JSON.stringify(data, null, 2)}`;
       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 Contract({ abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider });
-        const isClaimed = await contract.call("is_claimed", [reward.claim.id]);
-        logger2.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)) {
-          logger2.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 Contract({ abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider });
+      const isClaimed = await contract.call("is_claimed", [reward.claim.id]);
+      logger2.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)) {
+        logger2.verbose(`${_Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
+        return unClaimed;
+      }
+      unClaimed.unshift(reward);
       return unClaimed;
     }
   };
@@ -79321,6 +79340,91 @@ spurious results.`);
   });
   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 result2 = await callback(mid);
+      if (result2 === "found") {
+        return mid;
+      } else if (result2 == "retry") {
+      } else if (result2 === "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;
+      logger2.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
   var import_jsx_runtime3 = __toESM(require_jsx_runtime());
   var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
@@ -79607,7 +79711,6 @@ spurious results.`);
       for (let i = len - 1; i >= 0; --i) {
         let record = await this.contract.call("get_rewards_info", [i]);
         logger2.verbose(`${_EkuboCLVault.name}: getHarvestRewardShares: ${i}`);
-        console.log(record);
         const block2 = Number(record.block_number);
         if (block2 < fromBlock) {
           return shares;
@@ -79807,16 +79910,10 @@ spurious results.`);
       const sqrtRatio = _EkuboCLVault.div2Power128(
         BigInt(priceInfo.sqrt_ratio.toString())
       );
-      console.log(
-        `EkuboCLVault: getCurrentPrice: blockIdentifier: ${blockIdentifier}, sqrtRatio: ${sqrtRatio}, ${priceInfo.sqrt_ratio.toString()}`
-      );
       const token0Info = await Global.getTokenInfoFromAddr(poolKey.token0);
       const token1Info = await Global.getTokenInfoFromAddr(poolKey.token1);
       const price = sqrtRatio * sqrtRatio * 10 ** token0Info.decimals / 10 ** token1Info.decimals;
       const tick = priceInfo.tick;
-      console.log(
-        `EkuboCLVault: getCurrentPrice: blockIdentifier: ${blockIdentifier}, price: ${price}, tick: ${tick.mag}, ${tick.sign}`
-      );
       return {
         price,
         tick: Number(tick.mag) * (tick.sign ? -1 : 1),
@@ -80443,62 +80540,193 @@ spurious results.`);
         logger2.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);
+      logger2.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;
+      logger2.verbose(
+        `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+      );
+      logger2.verbose(
+        `${_EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
+      );
+      const harvestEstimateCall = async (swapInfo1) => {
+        const swap1Amount = Web3Number.fromWei(
+          uint256_exports.uint256ToBN(swapInfo1.token_from_amount).toString(),
+          18
+          // cause its always STRK?
+        ).minimum(
+          postFeeAmount.toFixed(18)
+          // cause always strk
+        );
+        swapInfo.token_from_amount = uint256_exports.bnToUint256(swap1Amount.toWei());
+        swapInfo.token_to_min_amount = uint256_exports.bnToUint256(
+          swap1Amount.multipliedBy(0).toWei()
+          // placeholder
+        );
         logger2.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);
+        logger2.verbose(
+          `${_EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
         );
-        swapInfo.token_to_address = token0Info.address.address;
+        const swapInfo2 = {
+          ...swapInfo,
+          token_from_amount: uint256_exports.bnToUint256(remainingAmount.toWei())
+        };
+        swapInfo2.token_to_address = token1Info.address.address;
         logger2.verbose(
-          `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+          `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
+            swapInfo
+          )}`
         );
         logger2.verbose(
-          `${_EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
+          `${_EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
+            swapInfo2
+          )}`
         );
-        const harvestEstimateCall = async (swapInfo1) => {
-          const swap1Amount = Web3Number.fromWei(
-            uint256_exports.uint256ToBN(swapInfo1.token_from_amount).toString(),
-            18
-            // cause its always STRK?
-          ).minimum(
-            postFeeAmount.toFixed(18)
-            // cause always strk
-          );
-          swapInfo.token_from_amount = uint256_exports.bnToUint256(swap1Amount.toWei());
-          swapInfo.token_to_min_amount = uint256_exports.bnToUint256(
-            swap1Amount.multipliedBy(0).toWei()
-            // placeholder
-          );
-          logger2.verbose(
-            `${_EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
-          );
-          const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
-          logger2.verbose(
-            `${_EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
-          );
-          const swapInfo2 = {
-            ...swapInfo,
-            token_from_amount: uint256_exports.bnToUint256(remainingAmount.toWei())
-          };
-          swapInfo2.token_to_address = token1Info.address.address;
-          logger2.verbose(
-            `${_EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
-              swapInfo
-            )}`
-          );
-          logger2.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) => num_exports.getDecimalString(p)),
+          swapInfo,
+          swapInfo2
+        ];
+        logger2.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
+      );
+      logger2.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,
             {
@@ -80507,34 +80735,23 @@ spurious results.`);
               claimee: claim.claim.claimee.address
             },
             claim.proof.map((p) => num_exports.getDecimalString(p)),
-            swapInfo,
+            swapInfo1,
             swapInfo2
           ];
-          logger2.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
-        );
-        logger2.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 (err2) {
+          if (err2.message.includes("invalid token0 amount")) {
+            return "go_low";
+          } else if (err2.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();
@@ -83060,7 +83277,58 @@ spurious results.`);
   }
 
   // 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 {
@@ -83078,6 +83346,94 @@ spurious results.`);
         ]
       };
     }
+    // /**
+    //  * 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
@@ -90676,7 +91032,20 @@ spurious results.`);
       }
       const output = await contract.call("pair_config", [this.config.collateral.address.address, this.config.debt.address.address]);
       logger2.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(config3);
+      logger2.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(config3) {
+      const { contract, isV2 } = await this.getVesuSingletonContract(config3, 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(config3, asset, maxBorrowAPY) {
       const { contract, isV2 } = await this.getVesuSingletonContract(config3, this.config.poolId);
@@ -90709,16 +91078,17 @@ spurious results.`);
       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);
       logger2.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);
+      logger2.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate currentDebt: ${currentDebt.toString()}, maxDebtToHave: ${maxDebtToHave.toString()}`);
       return maxDebtToHave.minus(currentDebt);
     }
-    async getLTVConfig(config3) {
-      const CACHE_KEY = "ltv_config";
+    async getLTVConfig(config3, blockNumber = "latest") {
+      const CACHE_KEY = `ltv_config_${blockNumber}`;
       const cacheData = this.getCache(CACHE_KEY);
       if (cacheData) {
         return cacheData;
@@ -90726,10 +91096,10 @@ spurious results.`);
       const { contract, isV2 } = await this.getVesuSingletonContract(config3, 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) {
@@ -90738,11 +91108,11 @@ spurious results.`);
       this.setCache(CACHE_KEY, ltv, 3e5);
       return this.getCache(CACHE_KEY);
     }
-    async getPositions(config3) {
+    async getPositions(config3, 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;
@@ -90754,7 +91124,8 @@ spurious results.`);
         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);
       logger2.verbose(`VesuAdapter::getPositions token1Price: ${token1Price.price}, token2Price: ${token2Price.price}`);
@@ -90774,11 +91145,11 @@ spurious results.`);
       this.setCache(CACHE_KEY, value, 6e4);
       return value;
     }
-    async getCollateralization(config3) {
+    async getCollateralization(config3, 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;
@@ -90790,7 +91161,7 @@ spurious results.`);
         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 = [{
@@ -90827,9 +91198,9 @@ spurious results.`);
         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) {
@@ -93488,11 +93859,11 @@ spurious results.`);
       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;
     }
@@ -93561,8 +93932,8 @@ spurious results.`);
     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();
@@ -94156,6 +94527,40 @@ spurious results.`);
     }
   ];
 
+  // 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
   var import_jsx_runtime5 = __toESM(require_jsx_runtime());
   var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy extends UniversalStrategy {
@@ -94171,15 +94576,14 @@ spurious results.`);
       }
     }
     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;
@@ -94227,20 +94631,52 @@ spurious results.`);
       return price;
     }
     async getAvnuSwapMultiplyCall(params) {
-      return this._getAvnuDepositSwapLegCall({
-        ...params,
-        minHF: 1.1
-        // undo
-      });
+      assert3(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);
+        logger2.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;
       logger2.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall params: ${JSON.stringify(params)}`);
       assert3(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);
       logger2.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];
       logger2.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
@@ -94248,11 +94684,40 @@ spurious results.`);
       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;
       logger2.debug(`${this.getTag()}::_getAvnuDepositSwapLegCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+      const debtTokenInfo = vesuAdapter.config.debt;
+      let newDepositAmount = params.leg1DepositAmount;
       const totalCollateral = existingCollateralInfo.amount.plus(params.leg1DepositAmount);
       logger2.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall totalCollateral: ${totalCollateral}`);
-      const totalDebtAmount = totalCollateral.multipliedBy(collateralPrice).multipliedBy(legLTV).dividedBy(debtPrice).dividedBy(params.minHF);
-      logger2.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);
+      logger2.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)) {
+        logger2.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) {
+          logger2.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall newDebtUSDValue is less than 100, skipping`);
+          return void 0;
+        }
+      }
       logger2.verbose(`${this.getTag()}::_getAvnuDepositSwapLegCall debtAmount: ${debtAmount}`);
       if (debtAmount.lt(0)) {
         const lstDEXPrice = await this.getLSTDexPrice();
@@ -94264,32 +94729,34 @@ spurious results.`);
         assert3(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
@@ -94305,7 +94772,7 @@ spurious results.`);
           minAmountWei
         );
         logger2.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
@@ -94323,7 +94790,7 @@ spurious results.`);
           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,
@@ -94340,28 +94807,41 @@ spurious results.`);
     }
     // todo unwind or not deposit when the yield is bad. 
     async getLSTMultiplierRebalanceCall() {
-      const positions = await this.getVaultPositions();
-      assert3(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);
+      assert3(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);
-      logger2.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);
+      logger2.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;
       logger2.debug(`${this.getTag()}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+      logger2.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 {
@@ -94394,7 +94874,7 @@ spurious results.`);
     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();
@@ -94451,21 +94931,52 @@ spurious results.`);
       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 (error2) {
+        logger2.warn(`${this.getTag()}: Failed to get max swappable: ${error2}`);
+        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 
@@ -94489,7 +95000,7 @@ spurious results.`);
     // 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()) {
         logger2.verbose(`${this.getTag()}::netAPY: unused balance is > max servicable from loan, lstAPY: ${lstAPY}`);
@@ -94506,8 +95017,8 @@ spurious results.`);
         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;
@@ -94610,7 +95121,7 @@ spurious results.`);
       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,
@@ -94694,6 +95205,12 @@ spurious results.`);
   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);
@@ -94703,7 +95220,7 @@ spurious results.`);
       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,
@@ -94712,25 +95229,39 @@ spurious results.`);
       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));
@@ -94808,7 +95339,8 @@ spurious results.`);
     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"),
@@ -94820,7 +95352,8 @@ spurious results.`);
     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"),
@@ -94832,7 +95365,8 @@ spurious results.`);
     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"),
@@ -94844,7 +95378,8 @@ spurious results.`);
     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"),
@@ -94856,7 +95391,8 @@ spurious results.`);
     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 [