@strkfarm/sdk 1.0.51 → 1.0.53

package/dist/index.browser.global.js

@@ -38124,14 +38124,16 @@ var strkfarm_risk_engine = (() => {
       };
       assert3(fromToken != toToken, "From and to tokens are the same");
       const quotes = await fetchQuotes(params);
-      if (quotes.length == 0) {
+      const filteredQuotes = quotes.filter((q) => q.sellAmount.toString() == amountWei);
+      if (filteredQuotes.length == 0) {
         if (retry < MAX_RETRY) {
           await new Promise((res) => setTimeout(res, 3e3));
           return await this.getQuotes(fromToken, toToken, amountWei, taker, retry + 1);
         }
         throw new Error("no quotes found");
       }
-      return quotes[0];
+      logger.verbose(`${_AvnuWrapper.name}: getQuotes => Found ${JSON.stringify(filteredQuotes[0])}`);
+      return filteredQuotes[0];
     }
     async getSwapInfo(quote, taker, integratorFeeBps, integratorFeeRecipient, minAmount) {
       const calldata = await fetchBuildExecuteTransaction(quote.quoteId);
@@ -38154,6 +38156,7 @@ var strkfarm_risk_engine = (() => {
         startIndex += 5 + swap_params_len;
       }
       const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
+      logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
       logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
       logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
       const swapInfo = {
@@ -51645,7 +51648,7 @@ var strkfarm_risk_engine = (() => {
           };
         }
       }
-      const ratioWeb3Number = sampleAmount0.multipliedBy(1e18).dividedBy(sampleAmount1.toString()).dividedBy(1e18);
+      const ratioWeb3Number = this.getRatio(sampleAmount0, sampleAmount1);
       const ratio = Number(ratioWeb3Number.toFixed(18));
       logger.verbose(
         `${_EkuboCLVault.name}: ${this.metadata.name} => ratio: ${ratio.toString()}`
@@ -51677,11 +51680,18 @@ var strkfarm_risk_engine = (() => {
         );
       }
     }
+    getRatio(token0Amt, token1Amount) {
+      const ratio = token0Amt.multipliedBy(1e18).dividedBy(token1Amount.toString()).dividedBy(1e18);
+      logger.verbose(
+        `${_EkuboCLVault.name}: getRatio => token0Amt: ${token0Amt.toString()}, token1Amount: ${token1Amount.toString()}, ratio: ${ratio.toString()}`
+      );
+      return ratio;
+    }
     _solveExpectedAmountsEq(availableAmount0, availableAmount1, ratio, price) {
       const y = ratio.multipliedBy(availableAmount1).minus(availableAmount0).dividedBy(ratio.plus(1 / price));
       const x = y.dividedBy(price);
       logger.verbose(
-        `${_EkuboCLVault.name}: _solveExpectedAmountsEq => x: ${x.toString()}, y: ${y.toString()}, amount0: ${availableAmount0.toString()}, amount1: ${availableAmount1.toString()}`
+        `${_EkuboCLVault.name}: _solveExpectedAmountsEq => ratio: ${ratio.toString()}, x: ${x.toString()}, y: ${y.toString()}, amount0: ${availableAmount0.toString()}, amount1: ${availableAmount1.toString()}`
       );
       if (ratio.eq(0)) {
         return {
@@ -51731,7 +51741,7 @@ var strkfarm_risk_engine = (() => {
         }
       };
     }
-    async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null) {
+    async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4) {
       const poolKey = await this.getPoolKey();
       const unusedBalances = await this.unusedBalances(poolKey);
       const { amount: token0Bal1, usdValue: token0PriceUsd } = unusedBalances.token0;
@@ -51764,14 +51774,59 @@ var strkfarm_risk_engine = (() => {
       logger.verbose(
         `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => newBounds: ${ekuboBounds.lowerTick}, ${ekuboBounds.upperTick}`
       );
+      this.assertValidBounds(ekuboBounds);
       return await this.getSwapInfoGivenAmounts(
         poolKey,
         token0Bal,
         token1Bal,
-        ekuboBounds
+        ekuboBounds,
+        maxIterations,
+        priceRatioPrecision
+      );
+    }
+    assertValidBounds(bounds) {
+      assert3(
+        bounds.lowerTick < bounds.upperTick,
+        `Invalid bounds: lowerTick (${bounds.lowerTick}) must be less than upperTick (${bounds.upperTick})`
       );
+      assert3(Number(bounds.lowerTick) % Number(this.poolKey?.tick_spacing) === 0, `Lower tick (${bounds.lowerTick}) must be a multiple of tick spacing (${this.poolKey?.tick_spacing})`);
+      assert3(Number(bounds.upperTick) % Number(this.poolKey?.tick_spacing) === 0, `Upper tick (${bounds.upperTick}) must be a multiple of tick spacing (${this.poolKey?.tick_spacing})`);
     }
-    async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds) {
+    // Helper to check for invalid states:
+    // Throws if both tokens are decreased or both are increased, which is not expected
+    assertValidAmounts(expectedAmounts, token0Bal, token1Bal) {
+      if (expectedAmounts.amount0.lessThan(token0Bal) && expectedAmounts.amount1.lessThan(token1Bal)) {
+        throw new Error("Both tokens are decreased, something is wrong");
+      }
+      if (expectedAmounts.amount0.greaterThan(token0Bal) && expectedAmounts.amount1.greaterThan(token1Bal)) {
+        throw new Error("Both tokens are increased, something is wrong");
+      }
+    }
+    // Helper to determine which token to sell, which to buy, and the amounts to use
+    getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal) {
+      const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal) ? poolKey.token0 : poolKey.token1;
+      const tokenToBuy = tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
+      const amountToSell = tokenToSell == poolKey.token0 ? token0Bal.minus(expectedAmounts.amount0) : token1Bal.minus(expectedAmounts.amount1);
+      if (amountToSell.eq(0)) {
+        throw new Error(
+          `No amount to sell for ${tokenToSell.address}`
+        );
+      }
+      const remainingSellAmount = tokenToSell == poolKey.token0 ? expectedAmounts.amount0 : expectedAmounts.amount1;
+      return { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount };
+    }
+    /**
+     * @description Calculates swap info based on given amounts of token0 and token1
+     * Use token0 and token1 balances to determine the expected amounts for new bounds
+     * @param poolKey 
+     * @param token0Bal 
+     * @param token1Bal 
+     * @param bounds // new bounds
+     * @param maxIterations 
+     * @returns {Promise<SwapInfo>}
+     * 
+     */
+    async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4) {
       logger.verbose(
         `${_EkuboCLVault.name}: getSwapInfoGivenAmounts::pre => token0Bal: ${token0Bal.toString()}, token1Bal: ${token1Bal.toString()}`
       );
@@ -51784,29 +51839,14 @@ var strkfarm_risk_engine = (() => {
         `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => expectedAmounts2: ${expectedAmounts.amount0.toString()}, ${expectedAmounts.amount1.toString()}`
       );
       let retry = 0;
-      const maxRetry = 10;
-      function assertValidAmounts(expectedAmounts2, token0Bal2, token1Bal2) {
-        if (expectedAmounts2.amount0.lessThan(token0Bal2) && expectedAmounts2.amount1.lessThan(token1Bal2)) {
-          throw new Error("Both tokens are decreased, something is wrong");
-        }
-        if (expectedAmounts2.amount0.greaterThan(token0Bal2) && expectedAmounts2.amount1.greaterThan(token1Bal2)) {
-          throw new Error("Both tokens are increased, something is wrong");
-        }
-      }
-      function getSwapParams(expectedAmounts2, poolKey2, token0Bal2, token1Bal2) {
-        const tokenToSell = expectedAmounts2.amount0.lessThan(token0Bal2) ? poolKey2.token0 : poolKey2.token1;
-        const tokenToBuy = tokenToSell == poolKey2.token0 ? poolKey2.token1 : poolKey2.token0;
-        const amountToSell = tokenToSell == poolKey2.token0 ? token0Bal2.minus(expectedAmounts2.amount0) : token1Bal2.minus(expectedAmounts2.amount1);
-        const remainingSellAmount = tokenToSell == poolKey2.token0 ? expectedAmounts2.amount0 : expectedAmounts2.amount1;
-        return { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount };
-      }
+      const maxRetry = maxIterations;
       while (retry < maxRetry) {
         retry++;
         logger.verbose(
           `getSwapInfoGivenAmounts::Retry attempt: ${retry}/${maxRetry}`
         );
-        assertValidAmounts(expectedAmounts, token0Bal, token1Bal);
-        const { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount } = getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal);
+        this.assertValidAmounts(expectedAmounts, token0Bal, token1Bal);
+        const { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount } = this.getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal);
         const tokenToBuyInfo = await Global.getTokenInfoFromAddr(tokenToBuy);
         const expectedRatio = expectedAmounts.ratio;
         logger.verbose(
@@ -51844,6 +51884,9 @@ var strkfarm_risk_engine = (() => {
           quote.buyAmount.toString(),
           tokenToBuyInfo.decimals
         );
+        logger.verbose(
+          `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => amountOut: ${amountOut.toString()}`
+        );
         const swapPrice = tokenToSell == poolKey.token0 ? amountOut.dividedBy(amountToSell) : amountToSell.dividedBy(amountOut);
         const newRatio = tokenToSell == poolKey.token0 ? remainingSellAmount.dividedBy(token1Bal.plus(amountOut)) : token0Bal.plus(amountOut).dividedBy(remainingSellAmount);
         logger.verbose(
@@ -51853,31 +51896,46 @@ var strkfarm_risk_engine = (() => {
             newRatio: newRatio.toString()
           })}`
         );
-        const expectedPrecision = Math.min(7, tokenToBuyInfo.decimals - 2);
-        if (Number(newRatio.toString()) > expectedRatio * (1 + 1 / 10 ** expectedPrecision) || Number(newRatio.toString()) < expectedRatio * (1 - 1 / 10 ** expectedPrecision)) {
-          expectedAmounts = await this._solveExpectedAmountsEq(
+        const expectedPrecision = Math.min(priceRatioPrecision);
+        const isWithInTolerance = Number(newRatio.toString()) <= expectedRatio * (1 + 1 / 10 ** expectedPrecision) && Number(newRatio.toString()) >= expectedRatio * (1 - 1 / 10 ** expectedPrecision);
+        const currentPrecision = (expectedRatio - Number(newRatio.toString())) / expectedRatio;
+        logger.verbose(
+          `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => isWithInTolerance: ${isWithInTolerance}, currentPrecision: ${currentPrecision.toString()}, expectedPrecision: ${expectedPrecision}`
+        );
+        if (!isWithInTolerance) {
+          const expectedAmountsNew = await this._solveExpectedAmountsEq(
             token0Bal,
             token1Bal,
             new Web3Number(Number(expectedRatio).toFixed(13), 18),
             Number(swapPrice.toString())
           );
           logger.verbose(
-            `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => expectedAmounts: ${expectedAmounts.amount0.toString()}, ${expectedAmounts.amount1.toString()}`
+            `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => expectedAmounts: ${expectedAmountsNew.amount0.toString()}, ${expectedAmountsNew.amount1.toString()}`
           );
+          if (expectedAmountsNew.amount0.eq(expectedAmounts.amount0.toString()) && expectedAmountsNew.amount1.eq(expectedAmounts.amount1.toString())) {
+            logger.error(
+              `getSwapInfoGivenAmounts: stuck in loop, expected amounts did not change`
+            );
+            throw new Error("Stuck in loop, expected amounts did not change");
+          }
+          expectedAmounts = expectedAmountsNew;
         } else {
           const minAmountOut = Web3Number.fromWei(
             quote.buyAmount.toString(),
             tokenToBuyInfo.decimals
           ).multipliedBy(0.9999);
-          return await this.avnu.getSwapInfo(
+          const output3 = await this.avnu.getSwapInfo(
             quote,
             this.address.address,
             0,
             this.address.address,
             minAmountOut.toWei()
           );
+          logger.verbose(
+            `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => swap info found: ${JSON.stringify(output3)}`
+          );
+          return output3;
         }
-        retry++;
       }
       throw new Error("Failed to get swap info");
     }
@@ -51894,8 +51952,7 @@ var strkfarm_risk_engine = (() => {
      * @returns Array of contract calls needed for rebalancing
      * @throws Error if max retries reached without successful rebalance
      */
-    async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n) {
-      const MAX_RETRIES = 40;
+    async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
       logger.verbose(
         `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
       );
@@ -52048,7 +52105,7 @@ var strkfarm_risk_engine = (() => {
         amount1
       };
     }
-    async harvest(acc) {
+    async harvest(acc, maxIterations = 20, priceRatioPrecision = 4) {
       const ekuboHarvests = new EkuboHarvests(this.config);
       const unClaimedRewards = await ekuboHarvests.getUnHarvestedRewards(
         this.address
@@ -52077,7 +52134,9 @@ var strkfarm_risk_engine = (() => {
           poolKey,
           token0Amt,
           token1Amt,
-          bounds
+          bounds,
+          maxIterations,
+          priceRatioPrecision
         );
         swapInfo.token_to_address = token0Info.address.address;
         logger.verbose(

package/dist/index.browser.mjs

@@ -1903,14 +1903,16 @@ var AvnuWrapper = class _AvnuWrapper {
     };
     assert(fromToken != toToken, "From and to tokens are the same");
     const quotes = await fetchQuotes(params);
-    if (quotes.length == 0) {
+    const filteredQuotes = quotes.filter((q) => q.sellAmount.toString() == amountWei);
+    if (filteredQuotes.length == 0) {
       if (retry < MAX_RETRY) {
         await new Promise((res) => setTimeout(res, 3e3));
         return await this.getQuotes(fromToken, toToken, amountWei, taker, retry + 1);
       }
       throw new Error("no quotes found");
     }
-    return quotes[0];
+    logger.verbose(`${_AvnuWrapper.name}: getQuotes => Found ${JSON.stringify(filteredQuotes[0])}`);
+    return filteredQuotes[0];
   }
   async getSwapInfo(quote, taker, integratorFeeBps, integratorFeeRecipient, minAmount) {
     const calldata = await fetchBuildExecuteTransaction(quote.quoteId);
@@ -1933,6 +1935,7 @@ var AvnuWrapper = class _AvnuWrapper {
       startIndex += 5 + swap_params_len;
     }
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
+    logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
     logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
     logger.verbose(`${_AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo = {
@@ -15438,7 +15441,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         };
       }
     }
-    const ratioWeb3Number = sampleAmount0.multipliedBy(1e18).dividedBy(sampleAmount1.toString()).dividedBy(1e18);
+    const ratioWeb3Number = this.getRatio(sampleAmount0, sampleAmount1);
     const ratio = Number(ratioWeb3Number.toFixed(18));
     logger.verbose(
       `${_EkuboCLVault.name}: ${this.metadata.name} => ratio: ${ratio.toString()}`
@@ -15470,11 +15473,18 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       );
     }
   }
+  getRatio(token0Amt, token1Amount) {
+    const ratio = token0Amt.multipliedBy(1e18).dividedBy(token1Amount.toString()).dividedBy(1e18);
+    logger.verbose(
+      `${_EkuboCLVault.name}: getRatio => token0Amt: ${token0Amt.toString()}, token1Amount: ${token1Amount.toString()}, ratio: ${ratio.toString()}`
+    );
+    return ratio;
+  }
   _solveExpectedAmountsEq(availableAmount0, availableAmount1, ratio, price) {
     const y = ratio.multipliedBy(availableAmount1).minus(availableAmount0).dividedBy(ratio.plus(1 / price));
     const x = y.dividedBy(price);
     logger.verbose(
-      `${_EkuboCLVault.name}: _solveExpectedAmountsEq => x: ${x.toString()}, y: ${y.toString()}, amount0: ${availableAmount0.toString()}, amount1: ${availableAmount1.toString()}`
+      `${_EkuboCLVault.name}: _solveExpectedAmountsEq => ratio: ${ratio.toString()}, x: ${x.toString()}, y: ${y.toString()}, amount0: ${availableAmount0.toString()}, amount1: ${availableAmount1.toString()}`
     );
     if (ratio.eq(0)) {
       return {
@@ -15524,7 +15534,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       }
     };
   }
-  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null) {
+  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4) {
     const poolKey = await this.getPoolKey();
     const unusedBalances = await this.unusedBalances(poolKey);
     const { amount: token0Bal1, usdValue: token0PriceUsd } = unusedBalances.token0;
@@ -15557,14 +15567,59 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
     logger.verbose(
       `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => newBounds: ${ekuboBounds.lowerTick}, ${ekuboBounds.upperTick}`
     );
+    this.assertValidBounds(ekuboBounds);
     return await this.getSwapInfoGivenAmounts(
       poolKey,
       token0Bal,
       token1Bal,
-      ekuboBounds
+      ekuboBounds,
+      maxIterations,
+      priceRatioPrecision
+    );
+  }
+  assertValidBounds(bounds) {
+    assert(
+      bounds.lowerTick < bounds.upperTick,
+      `Invalid bounds: lowerTick (${bounds.lowerTick}) must be less than upperTick (${bounds.upperTick})`
     );
+    assert(Number(bounds.lowerTick) % Number(this.poolKey?.tick_spacing) === 0, `Lower tick (${bounds.lowerTick}) must be a multiple of tick spacing (${this.poolKey?.tick_spacing})`);
+    assert(Number(bounds.upperTick) % Number(this.poolKey?.tick_spacing) === 0, `Upper tick (${bounds.upperTick}) must be a multiple of tick spacing (${this.poolKey?.tick_spacing})`);
+  }
+  // Helper to check for invalid states:
+  // Throws if both tokens are decreased or both are increased, which is not expected
+  assertValidAmounts(expectedAmounts, token0Bal, token1Bal) {
+    if (expectedAmounts.amount0.lessThan(token0Bal) && expectedAmounts.amount1.lessThan(token1Bal)) {
+      throw new Error("Both tokens are decreased, something is wrong");
+    }
+    if (expectedAmounts.amount0.greaterThan(token0Bal) && expectedAmounts.amount1.greaterThan(token1Bal)) {
+      throw new Error("Both tokens are increased, something is wrong");
+    }
   }
-  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds) {
+  // Helper to determine which token to sell, which to buy, and the amounts to use
+  getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal) {
+    const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal) ? poolKey.token0 : poolKey.token1;
+    const tokenToBuy = tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
+    const amountToSell = tokenToSell == poolKey.token0 ? token0Bal.minus(expectedAmounts.amount0) : token1Bal.minus(expectedAmounts.amount1);
+    if (amountToSell.eq(0)) {
+      throw new Error(
+        `No amount to sell for ${tokenToSell.address}`
+      );
+    }
+    const remainingSellAmount = tokenToSell == poolKey.token0 ? expectedAmounts.amount0 : expectedAmounts.amount1;
+    return { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount };
+  }
+  /**
+   * @description Calculates swap info based on given amounts of token0 and token1
+   * Use token0 and token1 balances to determine the expected amounts for new bounds
+   * @param poolKey 
+   * @param token0Bal 
+   * @param token1Bal 
+   * @param bounds // new bounds
+   * @param maxIterations 
+   * @returns {Promise<SwapInfo>}
+   * 
+   */
+  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4) {
     logger.verbose(
       `${_EkuboCLVault.name}: getSwapInfoGivenAmounts::pre => token0Bal: ${token0Bal.toString()}, token1Bal: ${token1Bal.toString()}`
     );
@@ -15577,29 +15632,14 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => expectedAmounts2: ${expectedAmounts.amount0.toString()}, ${expectedAmounts.amount1.toString()}`
     );
     let retry = 0;
-    const maxRetry = 10;
-    function assertValidAmounts(expectedAmounts2, token0Bal2, token1Bal2) {
-      if (expectedAmounts2.amount0.lessThan(token0Bal2) && expectedAmounts2.amount1.lessThan(token1Bal2)) {
-        throw new Error("Both tokens are decreased, something is wrong");
-      }
-      if (expectedAmounts2.amount0.greaterThan(token0Bal2) && expectedAmounts2.amount1.greaterThan(token1Bal2)) {
-        throw new Error("Both tokens are increased, something is wrong");
-      }
-    }
-    function getSwapParams(expectedAmounts2, poolKey2, token0Bal2, token1Bal2) {
-      const tokenToSell = expectedAmounts2.amount0.lessThan(token0Bal2) ? poolKey2.token0 : poolKey2.token1;
-      const tokenToBuy = tokenToSell == poolKey2.token0 ? poolKey2.token1 : poolKey2.token0;
-      const amountToSell = tokenToSell == poolKey2.token0 ? token0Bal2.minus(expectedAmounts2.amount0) : token1Bal2.minus(expectedAmounts2.amount1);
-      const remainingSellAmount = tokenToSell == poolKey2.token0 ? expectedAmounts2.amount0 : expectedAmounts2.amount1;
-      return { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount };
-    }
+    const maxRetry = maxIterations;
     while (retry < maxRetry) {
       retry++;
       logger.verbose(
         `getSwapInfoGivenAmounts::Retry attempt: ${retry}/${maxRetry}`
       );
-      assertValidAmounts(expectedAmounts, token0Bal, token1Bal);
-      const { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount } = getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal);
+      this.assertValidAmounts(expectedAmounts, token0Bal, token1Bal);
+      const { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount } = this.getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal);
       const tokenToBuyInfo = await Global.getTokenInfoFromAddr(tokenToBuy);
       const expectedRatio = expectedAmounts.ratio;
       logger.verbose(
@@ -15637,6 +15677,9 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         quote.buyAmount.toString(),
         tokenToBuyInfo.decimals
       );
+      logger.verbose(
+        `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => amountOut: ${amountOut.toString()}`
+      );
       const swapPrice = tokenToSell == poolKey.token0 ? amountOut.dividedBy(amountToSell) : amountToSell.dividedBy(amountOut);
       const newRatio = tokenToSell == poolKey.token0 ? remainingSellAmount.dividedBy(token1Bal.plus(amountOut)) : token0Bal.plus(amountOut).dividedBy(remainingSellAmount);
       logger.verbose(
@@ -15646,31 +15689,46 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           newRatio: newRatio.toString()
         })}`
       );
-      const expectedPrecision = Math.min(7, tokenToBuyInfo.decimals - 2);
-      if (Number(newRatio.toString()) > expectedRatio * (1 + 1 / 10 ** expectedPrecision) || Number(newRatio.toString()) < expectedRatio * (1 - 1 / 10 ** expectedPrecision)) {
-        expectedAmounts = await this._solveExpectedAmountsEq(
+      const expectedPrecision = Math.min(priceRatioPrecision);
+      const isWithInTolerance = Number(newRatio.toString()) <= expectedRatio * (1 + 1 / 10 ** expectedPrecision) && Number(newRatio.toString()) >= expectedRatio * (1 - 1 / 10 ** expectedPrecision);
+      const currentPrecision = (expectedRatio - Number(newRatio.toString())) / expectedRatio;
+      logger.verbose(
+        `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => isWithInTolerance: ${isWithInTolerance}, currentPrecision: ${currentPrecision.toString()}, expectedPrecision: ${expectedPrecision}`
+      );
+      if (!isWithInTolerance) {
+        const expectedAmountsNew = await this._solveExpectedAmountsEq(
           token0Bal,
           token1Bal,
           new Web3Number(Number(expectedRatio).toFixed(13), 18),
           Number(swapPrice.toString())
         );
         logger.verbose(
-          `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => expectedAmounts: ${expectedAmounts.amount0.toString()}, ${expectedAmounts.amount1.toString()}`
+          `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => expectedAmounts: ${expectedAmountsNew.amount0.toString()}, ${expectedAmountsNew.amount1.toString()}`
         );
+        if (expectedAmountsNew.amount0.eq(expectedAmounts.amount0.toString()) && expectedAmountsNew.amount1.eq(expectedAmounts.amount1.toString())) {
+          logger.error(
+            `getSwapInfoGivenAmounts: stuck in loop, expected amounts did not change`
+          );
+          throw new Error("Stuck in loop, expected amounts did not change");
+        }
+        expectedAmounts = expectedAmountsNew;
       } else {
         const minAmountOut = Web3Number.fromWei(
           quote.buyAmount.toString(),
           tokenToBuyInfo.decimals
         ).multipliedBy(0.9999);
-        return await this.avnu.getSwapInfo(
+        const output = await this.avnu.getSwapInfo(
           quote,
           this.address.address,
           0,
           this.address.address,
           minAmountOut.toWei()
         );
+        logger.verbose(
+          `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => swap info found: ${JSON.stringify(output)}`
+        );
+        return output;
       }
-      retry++;
     }
     throw new Error("Failed to get swap info");
   }
@@ -15687,8 +15745,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @returns Array of contract calls needed for rebalancing
    * @throws Error if max retries reached without successful rebalance
    */
-  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n) {
-    const MAX_RETRIES = 40;
+  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
     logger.verbose(
       `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
     );
@@ -15841,7 +15898,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       amount1
     };
   }
-  async harvest(acc) {
+  async harvest(acc, maxIterations = 20, priceRatioPrecision = 4) {
     const ekuboHarvests = new EkuboHarvests(this.config);
     const unClaimedRewards = await ekuboHarvests.getUnHarvestedRewards(
       this.address
@@ -15870,7 +15927,9 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         poolKey,
         token0Amt,
         token1Amt,
-        bounds
+        bounds,
+        maxIterations,
+        priceRatioPrecision
       );
       swapInfo.token_to_address = token0Info.address.address;
       logger.verbose(

package/dist/index.d.ts

@@ -699,6 +699,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @returns {amount0, amount1}
      */
     private _getExpectedAmountsForLiquidity;
+    getRatio(token0Amt: Web3Number, token1Amount: Web3Number): Web3Number;
     private _solveExpectedAmountsEq;
     unusedBalances(_poolKey?: EkuboPoolKey): Promise<{
         token0: {
@@ -712,8 +713,27 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
             usdValue: number;
         };
     }>;
-    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null): Promise<SwapInfo>;
-    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds): Promise<SwapInfo>;
+    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
+    assertValidBounds(bounds: EkuboBounds): void;
+    assertValidAmounts(expectedAmounts: any, token0Bal: Web3Number, token1Bal: Web3Number): void;
+    getSwapParams(expectedAmounts: any, poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number): {
+        tokenToSell: ContractAddr;
+        tokenToBuy: ContractAddr;
+        amountToSell: Web3Number;
+        remainingSellAmount: any;
+    };
+    /**
+     * @description Calculates swap info based on given amounts of token0 and token1
+     * Use token0 and token1 balances to determine the expected amounts for new bounds
+     * @param poolKey
+     * @param token0Bal
+     * @param token1Bal
+     * @param bounds // new bounds
+     * @param maxIterations
+     * @returns {Promise<SwapInfo>}
+     *
+     */
+    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
     /**
      * Attempts to rebalance the vault by iteratively adjusting swap amounts if initial attempt fails.
      * Uses binary search approach to find optimal swap amount.
@@ -727,7 +747,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @returns Array of contract calls needed for rebalancing
      * @throws Error if max retries reached without successful rebalance
      */
-    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint): Promise<Call[]>;
+    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number): Promise<Call[]>;
     static tickToi129(tick: number): {
         mag: number;
         sign: number;
@@ -746,7 +766,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
         amount0: Web3Number;
         amount1: Web3Number;
     }>;
-    harvest(acc: Account): Promise<Call[]>;
+    harvest(acc: Account, maxIterations?: number, priceRatioPrecision?: number): Promise<Call[]>;
     getInvestmentFlows(): Promise<IInvestmentFlow[]>;
 }
 /**