@strkfarm/sdk 1.1.59 → 1.1.61

package/dist/index.browser.global.js

@@ -80220,7 +80220,7 @@ spurious results.`);
         }
       };
     }
-    async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4) {
+    async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
       const poolKey = await this.getPoolKey();
       const unusedBalances = await this.unusedBalances(poolKey);
       const { amount: token0Bal1, usdValue: token0PriceUsd } = unusedBalances.token0;
@@ -80260,7 +80260,8 @@ spurious results.`);
         token1Bal,
         ekuboBounds,
         maxIterations,
-        priceRatioPrecision
+        priceRatioPrecision,
+        getQuoteCallback
       );
     }
     assertValidBounds(bounds) {
@@ -80305,7 +80306,7 @@ spurious results.`);
      * @returns {Promise<SwapInfo>}
      * 
      */
-    async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4) {
+    async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
       logger2.verbose(
         `${_EkuboCLVault.name}: getSwapInfoGivenAmounts::pre => token0Bal: ${token0Bal.toString()}, token1Bal: ${token1Bal.toString()}`
       );
@@ -80340,12 +80341,7 @@ spurious results.`);
         if (amountToSell.eq(0)) {
           return AvnuWrapper.buildZeroSwap(tokenToSell, this.address.address);
         }
-        const quote = await this.avnu.getQuotes(
-          tokenToSell.address,
-          tokenToBuy.address,
-          amountToSell.toWei(),
-          this.address.address
-        );
+        const quote = await getQuoteCallback(tokenToSell.address, tokenToBuy.address, amountToSell.toWei(), this.address.address);
         if (remainingSellAmount.eq(0)) {
           const minAmountOut = Web3Number.fromWei(
             quote.buyAmount.toString(),
@@ -80428,13 +80424,20 @@ spurious results.`);
      * @param retry - Current retry attempt number (default 0)
      * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
      * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+     * @param MAX_RETRIES - Maximum number of retries (default 40)
+     * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+     * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
      * @returns Array of contract calls needed for rebalancing
-     * @throws Error if max retries reached without successful rebalance
+     * @throws Error if max retries reached without successful rebalance or max same errors reached
      */
-    async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+    async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
       logger2.verbose(
-        `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+        `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
       );
+      if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+        logger2.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+        throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      }
       const fromAmount = uint256_exports.uint256ToBN(swapInfo.token_from_amount);
       logger2.verbose(
         `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
@@ -80453,7 +80456,7 @@ spurious results.`);
         );
         const newSwapInfo = { ...swapInfo };
         const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-        logger2.verbose(`Current amount: ${currentAmount.toString()}`);
+        logger2.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
         if (err2.message.includes("invalid token0 balance") || err2.message.includes("invalid token0 amount")) {
           if (!isSellTokenToken0) {
             logger2.verbose("Reducing swap amount - excess token0");
@@ -80500,6 +80503,30 @@ spurious results.`);
             }
             newSwapInfo.token_from_amount = uint256_exports.bnToUint256(nextAmount);
           }
+        } else if (err2.message.includes("Residual tokens")) {
+          logger2.error("Residual tokens");
+          if (sameErrorCount.error == "Residual tokens") {
+            sameErrorCount.count++;
+          } else {
+            sameErrorCount.error = "Residual tokens";
+            sameErrorCount.count = 1;
+          }
+        } else if (err2.message.includes("Insufficient tokens received")) {
+          logger2.error("Insufficient tokens received");
+          if (sameErrorCount.error == "Insufficient tokens received") {
+            sameErrorCount.count++;
+          } else {
+            sameErrorCount.error = "Insufficient tokens received";
+            sameErrorCount.count = 1;
+          }
+        } else if (err2.message.includes("Could not reach the end of the program")) {
+          logger2.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+          if (sameErrorCount.error == "Could not reach the end of the program") {
+            sameErrorCount.count++;
+          } else {
+            sameErrorCount.error = "Could not reach the end of the program";
+            sameErrorCount.count = 1;
+          }
         } else {
           logger2.error("Unexpected error:", err2);
           throw err2;
@@ -80512,7 +80539,10 @@ spurious results.`);
           isSellTokenToken0,
           retry + 1,
           lowerLimit,
-          upperLimit
+          upperLimit,
+          MAX_RETRIES,
+          sameErrorCount,
+          MAX_SAME_ERROR_COUNT
         );
       }
     }

package/dist/index.browser.mjs

@@ -16297,7 +16297,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       }
     };
   }
-  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4) {
+  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
     const poolKey = await this.getPoolKey();
     const unusedBalances = await this.unusedBalances(poolKey);
     const { amount: token0Bal1, usdValue: token0PriceUsd } = unusedBalances.token0;
@@ -16337,7 +16337,8 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       token1Bal,
       ekuboBounds,
       maxIterations,
-      priceRatioPrecision
+      priceRatioPrecision,
+      getQuoteCallback
     );
   }
   assertValidBounds(bounds) {
@@ -16382,7 +16383,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @returns {Promise<SwapInfo>}
    * 
    */
-  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4) {
+  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
     logger.verbose(
       `${_EkuboCLVault.name}: getSwapInfoGivenAmounts::pre => token0Bal: ${token0Bal.toString()}, token1Bal: ${token1Bal.toString()}`
     );
@@ -16417,12 +16418,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       if (amountToSell.eq(0)) {
         return AvnuWrapper.buildZeroSwap(tokenToSell, this.address.address);
       }
-      const quote = await this.avnu.getQuotes(
-        tokenToSell.address,
-        tokenToBuy.address,
-        amountToSell.toWei(),
-        this.address.address
-      );
+      const quote = await getQuoteCallback(tokenToSell.address, tokenToBuy.address, amountToSell.toWei(), this.address.address);
       if (remainingSellAmount.eq(0)) {
         const minAmountOut = Web3Number.fromWei(
           quote.buyAmount.toString(),
@@ -16505,13 +16501,20 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
-  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
     logger.verbose(
-      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
     const fromAmount = uint2564.uint256ToBN(swapInfo.token_from_amount);
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
@@ -16530,7 +16533,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       );
       const newSwapInfo = { ...swapInfo };
       const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (err.message.includes("invalid token0 balance") || err.message.includes("invalid token0 amount")) {
         if (!isSellTokenToken0) {
           logger.verbose("Reducing swap amount - excess token0");
@@ -16577,6 +16580,30 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           }
           newSwapInfo.token_from_amount = uint2564.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
       } else {
         logger.error("Unexpected error:", err);
         throw err;
@@ -16589,7 +16616,10 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }

package/dist/index.d.ts

@@ -782,7 +782,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
             usdValue: number;
         };
     }>;
-    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
+    getSwapInfoToHandleUnused(considerRebalance?: boolean, newBounds?: EkuboBounds | null, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): Promise<SwapInfo>;
     assertValidBounds(bounds: EkuboBounds): void;
     assertValidAmounts(expectedAmounts: any, token0Bal: Web3Number, token1Bal: Web3Number): void;
     getSwapParams(expectedAmounts: any, poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number): {
@@ -802,7 +802,7 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @returns {Promise<SwapInfo>}
      *
      */
-    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number): Promise<SwapInfo>;
+    getSwapInfoGivenAmounts(poolKey: EkuboPoolKey, token0Bal: Web3Number, token1Bal: Web3Number, bounds: EkuboBounds, maxIterations?: number, priceRatioPrecision?: number, getQuoteCallback?: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote>): 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.
@@ -813,10 +813,16 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @param retry - Current retry attempt number (default 0)
      * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
      * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+     * @param MAX_RETRIES - Maximum number of retries (default 40)
+     * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+     * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
      * @returns Array of contract calls needed for rebalancing
-     * @throws Error if max retries reached without successful rebalance
+     * @throws Error if max retries reached without successful rebalance or max same errors reached
      */
-    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number): Promise<Call[]>;
+    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number, sameErrorCount?: {
+        count: number;
+        error: null | string;
+    }, MAX_SAME_ERROR_COUNT?: number): Promise<Call[]>;
     static tickToi129(tick: number): {
         mag: number;
         sign: number;

package/dist/index.js

@@ -16297,7 +16297,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       }
     };
   }
-  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4) {
+  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
     const poolKey = await this.getPoolKey();
     const unusedBalances = await this.unusedBalances(poolKey);
     const { amount: token0Bal1, usdValue: token0PriceUsd } = unusedBalances.token0;
@@ -16337,7 +16337,8 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       token1Bal,
       ekuboBounds,
       maxIterations,
-      priceRatioPrecision
+      priceRatioPrecision,
+      getQuoteCallback
     );
   }
   assertValidBounds(bounds) {
@@ -16382,7 +16383,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @returns {Promise<SwapInfo>}
    * 
    */
-  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4) {
+  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
     logger.verbose(
       `${_EkuboCLVault.name}: getSwapInfoGivenAmounts::pre => token0Bal: ${token0Bal.toString()}, token1Bal: ${token1Bal.toString()}`
     );
@@ -16417,12 +16418,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       if (amountToSell.eq(0)) {
         return AvnuWrapper.buildZeroSwap(tokenToSell, this.address.address);
       }
-      const quote = await this.avnu.getQuotes(
-        tokenToSell.address,
-        tokenToBuy.address,
-        amountToSell.toWei(),
-        this.address.address
-      );
+      const quote = await getQuoteCallback(tokenToSell.address, tokenToBuy.address, amountToSell.toWei(), this.address.address);
       if (remainingSellAmount.eq(0)) {
         const minAmountOut = Web3Number.fromWei(
           quote.buyAmount.toString(),
@@ -16505,13 +16501,20 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
-  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
     logger.verbose(
-      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
     const fromAmount = import_starknet11.uint256.uint256ToBN(swapInfo.token_from_amount);
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
@@ -16530,7 +16533,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       );
       const newSwapInfo = { ...swapInfo };
       const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (err.message.includes("invalid token0 balance") || err.message.includes("invalid token0 amount")) {
         if (!isSellTokenToken0) {
           logger.verbose("Reducing swap amount - excess token0");
@@ -16577,6 +16580,30 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           }
           newSwapInfo.token_from_amount = import_starknet11.uint256.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
       } else {
         logger.error("Unexpected error:", err);
         throw err;
@@ -16589,7 +16616,10 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }

package/dist/index.mjs

@@ -16195,7 +16195,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       }
     };
   }
-  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4) {
+  async getSwapInfoToHandleUnused(considerRebalance = true, newBounds = null, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
     const poolKey = await this.getPoolKey();
     const unusedBalances = await this.unusedBalances(poolKey);
     const { amount: token0Bal1, usdValue: token0PriceUsd } = unusedBalances.token0;
@@ -16235,7 +16235,8 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       token1Bal,
       ekuboBounds,
       maxIterations,
-      priceRatioPrecision
+      priceRatioPrecision,
+      getQuoteCallback
     );
   }
   assertValidBounds(bounds) {
@@ -16280,7 +16281,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @returns {Promise<SwapInfo>}
    * 
    */
-  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4) {
+  async getSwapInfoGivenAmounts(poolKey, token0Bal, token1Bal, bounds, maxIterations = 20, priceRatioPrecision = 4, getQuoteCallback = this.avnu.getQuotes) {
     logger.verbose(
       `${_EkuboCLVault.name}: getSwapInfoGivenAmounts::pre => token0Bal: ${token0Bal.toString()}, token1Bal: ${token1Bal.toString()}`
     );
@@ -16315,12 +16316,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       if (amountToSell.eq(0)) {
         return AvnuWrapper.buildZeroSwap(tokenToSell, this.address.address);
       }
-      const quote = await this.avnu.getQuotes(
-        tokenToSell.address,
-        tokenToBuy.address,
-        amountToSell.toWei(),
-        this.address.address
-      );
+      const quote = await getQuoteCallback(tokenToSell.address, tokenToBuy.address, amountToSell.toWei(), this.address.address);
       if (remainingSellAmount.eq(0)) {
         const minAmountOut = Web3Number.fromWei(
           quote.buyAmount.toString(),
@@ -16403,13 +16399,20 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
-  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
     logger.verbose(
-      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
     const fromAmount = uint2564.uint256ToBN(swapInfo.token_from_amount);
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
@@ -16428,7 +16431,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
       );
       const newSwapInfo = { ...swapInfo };
       const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (err.message.includes("invalid token0 balance") || err.message.includes("invalid token0 amount")) {
         if (!isSellTokenToken0) {
           logger.verbose("Reducing swap amount - excess token0");
@@ -16475,6 +16478,30 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           }
           newSwapInfo.token_from_amount = uint2564.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
       } else {
         logger.error("Unexpected error:", err);
         throw err;
@@ -16487,7 +16514,10 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.59",
+  "version": "1.1.61",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

package/src/strategies/ekubo-cl-vault.tsx

@@ -40,6 +40,7 @@ import { DepegRiskLevel, ImpermanentLossLevel, MarketRiskLevel, SmartContractRis
 import { gql } from "@apollo/client";
 import apolloClient from "@/modules/apollo-client";
 import { binarySearch } from "@/utils/math-utils";
+import { Quote } from "@avnu/avnu-sdk";
 
 export interface EkuboPoolKey {
   token0: ContractAddr;
@@ -1080,7 +1081,12 @@ export class EkuboCLVault extends BaseStrategy<
     };
   }
 
-  async getSwapInfoToHandleUnused(considerRebalance: boolean = true, newBounds: EkuboBounds | null = null, maxIterations = 20, priceRatioPrecision = 4): Promise<SwapInfo> {
+  async getSwapInfoToHandleUnused(
+    considerRebalance: boolean = true, 
+    newBounds: EkuboBounds | null = null, 
+    maxIterations = 20, priceRatioPrecision = 4, 
+    getQuoteCallback: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote> = this.avnu.getQuotes
+  ): Promise<SwapInfo> {
     const poolKey = await this.getPoolKey();
 
     // fetch current unused balances of vault
@@ -1145,7 +1151,8 @@ export class EkuboCLVault extends BaseStrategy<
       token1Bal,
       ekuboBounds,
       maxIterations,
-      priceRatioPrecision
+      priceRatioPrecision,
+      getQuoteCallback
     );
   }
 
@@ -1229,7 +1236,8 @@ export class EkuboCLVault extends BaseStrategy<
     token1Bal: Web3Number,
     bounds: EkuboBounds,
     maxIterations: number = 20,
-    priceRatioPrecision: number = 4
+    priceRatioPrecision: number = 4,
+    getQuoteCallback: (tokenToSell: string, tokenToBuy: string, amountWei: string, beneficiary: string) => Promise<Quote> = this.avnu.getQuotes
   ): Promise<SwapInfo> {
     logger.verbose(
       `${
@@ -1284,12 +1292,7 @@ export class EkuboCLVault extends BaseStrategy<
       }
 
       // Get a quote for swapping the calculated amount
-      const quote = await this.avnu.getQuotes(
-        tokenToSell.address,
-        tokenToBuy.address,
-        amountToSell.toWei(),
-        this.address.address
-      );
+      const quote = await getQuoteCallback(tokenToSell.address, tokenToBuy.address, amountToSell.toWei(), this.address.address);
 
       // If all of the token is to be swapped, return the swap info directly
       if (remainingSellAmount.eq(0)) {
@@ -1399,8 +1402,11 @@ export class EkuboCLVault extends BaseStrategy<
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
   async rebalanceIter(
     swapInfo: SwapInfo,
@@ -1410,14 +1416,21 @@ export class EkuboCLVault extends BaseStrategy<
     retry = 0,
     lowerLimit = 0n,
     upperLimit = 0n,
-    MAX_RETRIES = 40
+    MAX_RETRIES = 40,
+    sameErrorCount: { count: number, error: null | string } = { count: 0, error: null },
+    MAX_SAME_ERROR_COUNT = 10
   ): Promise<Call[]> {
 
     logger.verbose(
       `Rebalancing ${this.metadata.name}: ` +
-        `retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+        `retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
 
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
+
     const fromAmount = uint256.uint256ToBN(swapInfo.token_from_amount);
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
@@ -1439,7 +1452,7 @@ export class EkuboCLVault extends BaseStrategy<
 
       const newSwapInfo = { ...swapInfo };
       const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18); // 18 is ok, as its toWei eventually anyways
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (
         err.message.includes("invalid token0 balance") ||
         err.message.includes("invalid token0 amount")
@@ -1492,6 +1505,33 @@ export class EkuboCLVault extends BaseStrategy<
           }
           newSwapInfo.token_from_amount = uint256.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+        // dont do anything, just try again. 
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+        // dont do anything, just try again. 
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
+        // just try again. 
       } else {
         logger.error("Unexpected error:", err);
         throw err;
@@ -1504,7 +1544,10 @@ export class EkuboCLVault extends BaseStrategy<
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }