@strkfarm/sdk 1.0.52 → 1.0.54

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

@@ -745,10 +745,7 @@ export class EkuboCLVault extends BaseStrategy<
       }
     }
 
-    const ratioWeb3Number = sampleAmount0
-      .multipliedBy(1e18)
-      .dividedBy(sampleAmount1.toString())
-      .dividedBy(1e18);
+    const ratioWeb3Number = this.getRatio(sampleAmount0, sampleAmount1);
 
     const ratio: number = Number(ratioWeb3Number.toFixed(18));
     logger.verbose(
@@ -793,6 +790,17 @@ export class EkuboCLVault extends BaseStrategy<
     }
   }
 
+  getRatio(token0Amt: Web3Number, token1Amount: Web3Number) {
+    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;
+  }
+
   private _solveExpectedAmountsEq(
     availableAmount0: Web3Number,
     availableAmount1: Web3Number,
@@ -814,7 +822,7 @@ export class EkuboCLVault extends BaseStrategy<
     logger.verbose(
       `${
         EkuboCLVault.name
-      }: _solveExpectedAmountsEq => x: ${x.toString()}, y: ${y.toString()}, amount0: ${availableAmount0.toString()}, amount1: ${availableAmount1.toString()}`
+      }: _solveExpectedAmountsEq => ratio: ${ratio.toString()}, x: ${x.toString()}, y: ${y.toString()}, amount0: ${availableAmount0.toString()}, amount1: ${availableAmount1.toString()}`
     );
 
     if (ratio.eq(0)) {
@@ -872,7 +880,7 @@ export class EkuboCLVault extends BaseStrategy<
     };
   }
 
-  async getSwapInfoToHandleUnused(considerRebalance: boolean = true, newBounds: EkuboBounds | null = null, maxIterations = 20): Promise<SwapInfo> {
+  async getSwapInfoToHandleUnused(considerRebalance: boolean = true, newBounds: EkuboBounds | null = null, maxIterations = 20, priceRatioPrecision = 4): Promise<SwapInfo> {
     const poolKey = await this.getPoolKey();
 
     // fetch current unused balances of vault
@@ -928,21 +936,100 @@ export class EkuboCLVault extends BaseStrategy<
       `${EkuboCLVault.name}: getSwapInfoToHandleUnused => newBounds: ${ekuboBounds.lowerTick}, ${ekuboBounds.upperTick}`
     );
 
+    // assert bounds are valid
+    this.assertValidBounds(ekuboBounds);
+
     return await this.getSwapInfoGivenAmounts(
       poolKey,
       token0Bal,
       token1Bal,
       ekuboBounds,
-      maxIterations
+      maxIterations,
+      priceRatioPrecision
     );
   }
 
+  assertValidBounds(bounds: EkuboBounds) {
+    // Ensure bounds are valid
+    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: any,
+      token0Bal: Web3Number,
+      token1Bal: Web3Number
+    ) {
+    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: any,
+    poolKey: EkuboPoolKey,
+    token0Bal: Web3Number,
+    token1Bal: Web3Number
+  ) {
+    // Decide which token to sell based on which expected amount is less than the balance
+    const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal)
+      ? poolKey.token0
+      : poolKey.token1;
+    // The other token is the one to buy
+    const tokenToBuy =
+      tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
+    // Calculate how much to sell
+    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}`
+      );
+    }
+    // The remaining amount of the sold token after swap
+    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: EkuboPoolKey,
     token0Bal: Web3Number,
     token1Bal: Web3Number,
     bounds: EkuboBounds,
-    maxIterations: number = 20
+    maxIterations: number = 20,
+    priceRatioPrecision: number = 4
   ): Promise<SwapInfo> {
     logger.verbose(
       `${
@@ -965,54 +1052,6 @@ export class EkuboCLVault extends BaseStrategy<
     let retry = 0;
     const maxRetry = maxIterations;
 
-    // Helper to check for invalid states:
-    // Throws if both tokens are decreased or both are increased, which is not expected
-    function assertValidAmounts(
-      expectedAmounts: any,
-      token0Bal: Web3Number,
-      token1Bal: Web3Number
-    ) {
-      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
-    function getSwapParams(
-      expectedAmounts: any,
-      poolKey: EkuboPoolKey,
-      token0Bal: Web3Number,
-      token1Bal: Web3Number
-    ) {
-      // Decide which token to sell based on which expected amount is less than the balance
-      const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal)
-        ? poolKey.token0
-        : poolKey.token1;
-      // The other token is the one to buy
-      const tokenToBuy =
-        tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
-      // Calculate how much to sell
-      const amountToSell =
-        tokenToSell == poolKey.token0
-          ? token0Bal.minus(expectedAmounts.amount0)
-          : token1Bal.minus(expectedAmounts.amount1);
-      // The remaining amount of the sold token after swap
-      const remainingSellAmount =
-        tokenToSell == poolKey.token0
-          ? expectedAmounts.amount0
-          : expectedAmounts.amount1;
-      return { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount };
-    }
-
     // Main retry loop: attempts to find a swap that matches the expected ratio within tolerance
     while (retry < maxRetry) {
       retry++;
@@ -1021,11 +1060,11 @@ export class EkuboCLVault extends BaseStrategy<
       );
 
       // Ensure the expected amounts are valid for swap logic
-      assertValidAmounts(expectedAmounts, token0Bal, token1Bal);
+      this.assertValidAmounts(expectedAmounts, token0Bal, token1Bal);
 
       // Get swap parameters for this iteration
       const { tokenToSell, tokenToBuy, amountToSell, remainingSellAmount } =
-        getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal);
+        this.getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal);
 
       const tokenToBuyInfo = await Global.getTokenInfoFromAddr(tokenToBuy);
       const expectedRatio = expectedAmounts.ratio;
@@ -1067,12 +1106,16 @@ export class EkuboCLVault extends BaseStrategy<
         );
       }
 
-      // Calculate the actual output and price from the quote
+      // Raw amount out
       const amountOut = Web3Number.fromWei(
         quote.buyAmount.toString(),
         tokenToBuyInfo.decimals
       );
+      logger.verbose(
+        `${EkuboCLVault.name}: getSwapInfoToHandleUnused => amountOut: ${amountOut.toString()}`
+      );
       // Calculate the swap price depending on which token is being sold
+      // price is token1 / token0
       const swapPrice =
         tokenToSell == poolKey.token0
           ? amountOut.dividedBy(amountToSell)
@@ -1091,12 +1134,19 @@ export class EkuboCLVault extends BaseStrategy<
       );
 
       // If the new ratio is not within tolerance, adjust expected amounts and retry
-      const expectedPrecision = Math.min(7, tokenToBuyInfo.decimals - 2);
+      const expectedPrecision = Math.min(priceRatioPrecision); // e.g 7 for STRK, 4 for USDC
+      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 (
-        Number(newRatio.toString()) > expectedRatio * (1 + 1 / 10 ** expectedPrecision) ||
-        Number(newRatio.toString()) < expectedRatio * (1 - 1 / 10 ** expectedPrecision)
+        !isWithInTolerance
       ) {
-        expectedAmounts = await this._solveExpectedAmountsEq(
+        const expectedAmountsNew = await this._solveExpectedAmountsEq(
           token0Bal,
           token1Bal,
           new Web3Number(Number(expectedRatio).toFixed(13), 18),
@@ -1105,23 +1155,34 @@ export class EkuboCLVault extends BaseStrategy<
         logger.verbose(
           `${
             EkuboCLVault.name
-          }: getSwapInfoToHandleUnused => expectedAmounts: ${expectedAmounts.amount0.toString()}, ${expectedAmounts.amount1.toString()}`
+          }: getSwapInfoToHandleUnused => expectedAmounts: ${expectedAmountsNew.amount0.toString()}, ${expectedAmountsNew.amount1.toString()}`
         );
+        if (expectedAmountsNew.amount0.eq(expectedAmounts.amount0.toString()) && expectedAmountsNew.amount1.eq(expectedAmounts.amount1.toString())) {
+          // If the expected amounts did not change, we are stuck in a loop
+          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 {
         // Otherwise, return the swap info with a slippage buffer
         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++;
     }
 
     // If no suitable swap found after max retries, throw error
@@ -1336,7 +1397,7 @@ export class EkuboCLVault extends BaseStrategy<
     };
   }
 
-  async harvest(acc: Account, maxIterations = 20): Promise<Call[]> {
+  async harvest(acc: Account, maxIterations = 20, priceRatioPrecision = 4): Promise<Call[]> {
     const ekuboHarvests = new EkuboHarvests(this.config);
     const unClaimedRewards = await ekuboHarvests.getUnHarvestedRewards(
       this.address
@@ -1380,7 +1441,8 @@ export class EkuboCLVault extends BaseStrategy<
         token0Amt,
         token1Amt,
         bounds,
-        maxIterations
+        maxIterations,
+        priceRatioPrecision
       );
       swapInfo.token_to_address = token0Info.address.address;
       logger.verbose(
@@ -1394,11 +1456,19 @@ export class EkuboCLVault extends BaseStrategy<
         const swap1Amount = Web3Number.fromWei(
           uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
           18 // cause its always STRK?
-        );
+        ).minimum(
+          postFeeAmount.toFixed(18) // cause always strk
+        ); // ensure we don't swap more than we have
+        swapInfo.token_from_amount = uint256.bnToUint256(swap1Amount.toWei());
+        swapInfo.token_to_min_amount = uint256.bnToUint256(
+          swap1Amount.multipliedBy(0).toWei() // placeholder
+        ); // 0.01% slippage
+
         logger.verbose(
           `${EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
         );
-        const remainingAmount = postFeeAmount.minus(swap1Amount);
+
+        const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
         logger.verbose(
           `${EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
         );
@@ -1438,7 +1508,11 @@ export class EkuboCLVault extends BaseStrategy<
       const _callsFinal = await this.rebalanceIter(
         swapInfo,
         acc,
-        harvestEstimateCall
+        harvestEstimateCall,
+        claim.token.eq(poolKey.token0),
+        0,
+        0n,
+        BigInt(postFeeAmount.toWei()), // upper limit is the post fee amount
       );
       logger.verbose(
         `${EkuboCLVault.name}: harvest => _callsFinal: ${JSON.stringify(