@stabbleorg/mclmm-sdk 0.3.2 → 0.3.3

package/lib/index.mjs

@@ -5898,6 +5898,22 @@ var TickUtils = class _TickUtils {
       );
     }
   }
+  static getTickOffsetInArray(tickIndex, tickSpacing) {
+    if (tickIndex % tickSpacing != 0) {
+      throw new Error("tickIndex % tickSpacing not equal 0");
+    }
+    const startTickIndex = _TickUtils.getTickArrayStartIndexByTick(
+      tickIndex,
+      tickSpacing
+    );
+    const offsetInArray = Math.floor(
+      (tickIndex - startTickIndex) / tickSpacing
+    );
+    if (offsetInArray < 0 || offsetInArray >= TICK_ARRAY_SIZE) {
+      throw new Error("tick offset in array overflow");
+    }
+    return offsetInArray;
+  }
   /**
    * Get the start index of the tick array containing a specific tick
    * @param tick - Target tick
@@ -8028,6 +8044,268 @@ var PoolUtils = class {
   }
 };
 
+// src/utils/position.ts
+import BN5 from "bn.js";
+var PositionUtils = class _PositionUtils {
+  /**
+   * Calculate fee growth inside a position's tick range.
+   *
+   * formula:
+   * ```
+   * feeGrowthInside = feeGrowthGlobal - feeGrowthBelow - feeGrowthAbove
+   * ```
+   *
+   * Where feeGrowthBelow and feeGrowthAbove depend on the current tick
+   * relative to the position's tick boundaries.
+   *
+   * @param params - Parameters for fee growth calculation
+   * @returns Fee growth inside for both tokens (X64 fixed-point)
+   */
+  static getFeeGrowthInside(params) {
+    const {
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64
+    } = params;
+    const feeGrowthGlobal0 = new BN5(feeGrowthGlobal0X64.toString());
+    const feeGrowthGlobal1 = new BN5(feeGrowthGlobal1X64.toString());
+    const tickLowerFeeGrowthOutside0 = new BN5(
+      tickLowerState.feeGrowthOutside0X64.toString()
+    );
+    const tickLowerFeeGrowthOutside1 = new BN5(
+      tickLowerState.feeGrowthOutside1X64.toString()
+    );
+    const tickUpperFeeGrowthOutside0 = new BN5(
+      tickUpperState.feeGrowthOutside0X64.toString()
+    );
+    const tickUpperFeeGrowthOutside1 = new BN5(
+      tickUpperState.feeGrowthOutside1X64.toString()
+    );
+    let feeGrowthBelow0X64;
+    let feeGrowthBelow1X64;
+    if (tickCurrent >= tickLower) {
+      feeGrowthBelow0X64 = tickLowerFeeGrowthOutside0;
+      feeGrowthBelow1X64 = tickLowerFeeGrowthOutside1;
+    } else {
+      feeGrowthBelow0X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal0,
+        tickLowerFeeGrowthOutside0
+      );
+      feeGrowthBelow1X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal1,
+        tickLowerFeeGrowthOutside1
+      );
+    }
+    let feeGrowthAbove0X64;
+    let feeGrowthAbove1X64;
+    if (tickCurrent < tickUpper) {
+      feeGrowthAbove0X64 = tickUpperFeeGrowthOutside0;
+      feeGrowthAbove1X64 = tickUpperFeeGrowthOutside1;
+    } else {
+      feeGrowthAbove0X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal0,
+        tickUpperFeeGrowthOutside0
+      );
+      feeGrowthAbove1X64 = MathUtils.wrappingSubU128(
+        feeGrowthGlobal1,
+        tickUpperFeeGrowthOutside1
+      );
+    }
+    const feeGrowthInside0X64 = MathUtils.wrappingSubU128(
+      MathUtils.wrappingSubU128(feeGrowthGlobal0, feeGrowthBelow0X64),
+      feeGrowthAbove0X64
+    );
+    const feeGrowthInside1X64 = MathUtils.wrappingSubU128(
+      MathUtils.wrappingSubU128(feeGrowthGlobal1, feeGrowthBelow1X64),
+      feeGrowthAbove1X64
+    );
+    return {
+      feeGrowthInside0X64,
+      feeGrowthInside1X64
+    };
+  }
+  /**
+   * Calculate pending fees for a position.
+   *
+   * Formula:
+   * ```
+   * feeDelta = (feeGrowthInside - feeGrowthInsideLast) × liquidity / 2^64
+   * totalFees = tokenFeesOwed + feeDelta
+   * ```
+   *
+   * @param params - Parameters for fee calculation
+   * @returns Pending fees for both tokens in native units
+   */
+  static getPositionFees(params) {
+    const {
+      liquidity,
+      tickLower,
+      tickUpper,
+      feeGrowthInside0LastX64,
+      feeGrowthInside1LastX64,
+      tokenFeesOwed0,
+      tokenFeesOwed1,
+      tickCurrent,
+      feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64,
+      tickLowerState,
+      tickUpperState
+    } = params;
+    const { feeGrowthInside0X64, feeGrowthInside1X64 } = _PositionUtils.getFeeGrowthInside({
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64
+    });
+    const liquidityBN = new BN5(liquidity.toString());
+    const feeGrowthInside0Last = new BN5(feeGrowthInside0LastX64.toString());
+    const feeGrowthInside1Last = new BN5(feeGrowthInside1LastX64.toString());
+    const feesOwed0 = new BN5(tokenFeesOwed0.toString());
+    const feesOwed1 = new BN5(tokenFeesOwed1.toString());
+    const feeGrowthDelta0 = MathUtils.wrappingSubU128(
+      feeGrowthInside0X64,
+      feeGrowthInside0Last
+    );
+    const feeGrowthDelta1 = MathUtils.wrappingSubU128(
+      feeGrowthInside1X64,
+      feeGrowthInside1Last
+    );
+    const feeAmount0 = MathUtils.mulDivFloor(feeGrowthDelta0, liquidityBN, Q64);
+    const feeAmount1 = MathUtils.mulDivFloor(feeGrowthDelta1, liquidityBN, Q64);
+    return {
+      tokenFees0: feesOwed0.add(feeAmount0),
+      tokenFees1: feesOwed1.add(feeAmount1)
+    };
+  }
+  /**
+   * Calculate reward growth inside a position's tick range for all reward tokens.
+   *
+   * Formula:
+   * ```
+   * rewardGrowthInside = rewardGrowthGlobal - rewardGrowthBelow - rewardGrowthAbove
+   * ```
+   *
+   * Special cases:
+   * - If tickLower has no liquidity (liquidityGross = 0), rewardGrowthBelow = rewardGrowthGlobal
+   * - If tickUpper has no liquidity (liquidityGross = 0), rewardGrowthAbove = 0
+   *
+   * @param params - Parameters for reward growth calculation
+   * @returns Reward growth inside for each reward token (X64 fixed-point)
+   */
+  static getRewardGrowthInside(params) {
+    const {
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      rewardInfos
+    } = params;
+    const rewardGrowthsInside = [];
+    for (let i = 0; i < rewardInfos.length; i++) {
+      const rewardGrowthGlobal = new BN5(
+        rewardInfos[i].rewardGrowthGlobalX64.toString()
+      );
+      let rewardGrowthBelow;
+      if (tickLowerState.liquidityGross === 0n) {
+        rewardGrowthBelow = rewardGrowthGlobal;
+      } else if (tickCurrent < tickLower) {
+        rewardGrowthBelow = rewardGrowthGlobal.sub(
+          new BN5(tickLowerState.rewardGrowthsOutsideX64[i].toString())
+        );
+      } else {
+        rewardGrowthBelow = new BN5(
+          tickLowerState.rewardGrowthsOutsideX64[i].toString()
+        );
+      }
+      let rewardGrowthAbove;
+      if (tickUpperState.liquidityGross === 0n) {
+        rewardGrowthAbove = new BN5(0);
+      } else if (tickCurrent < tickUpper) {
+        rewardGrowthAbove = new BN5(
+          tickUpperState.rewardGrowthsOutsideX64[i].toString()
+        );
+      } else {
+        rewardGrowthAbove = rewardGrowthGlobal.sub(
+          new BN5(tickUpperState.rewardGrowthsOutsideX64[i].toString())
+        );
+      }
+      const rewardGrowthInside = MathUtils.wrappingSubU128(
+        MathUtils.wrappingSubU128(rewardGrowthGlobal, rewardGrowthBelow),
+        rewardGrowthAbove
+      );
+      rewardGrowthsInside.push(rewardGrowthInside);
+    }
+    return rewardGrowthsInside;
+  }
+  /**
+   * Calculate pending rewards for a position.
+   *
+   * Formula:
+   * ```
+   * rewardDelta = (rewardGrowthInside - rewardGrowthInsideLast) × liquidity / 2^64
+   * totalReward = rewardAmountOwed + rewardDelta
+   * ```
+   *
+   * @param params - Parameters for reward calculation
+   * @returns Pending rewards for each reward token in native units
+   */
+  static getPositionRewards(params) {
+    const {
+      liquidity,
+      tickLower,
+      tickUpper,
+      positionRewardInfos,
+      tickCurrent,
+      rewardInfos,
+      tickLowerState,
+      tickUpperState
+    } = params;
+    const rewardGrowthsInside = _PositionUtils.getRewardGrowthInside({
+      tickCurrent,
+      tickLower,
+      tickUpper,
+      tickLowerState,
+      tickUpperState,
+      rewardInfos
+    });
+    const liquidityBN = new BN5(liquidity.toString());
+    const rewards = [];
+    for (let i = 0; i < rewardGrowthsInside.length; i++) {
+      const rewardGrowthInside = rewardGrowthsInside[i];
+      const positionRewardInfo = positionRewardInfos[i];
+      if (!positionRewardInfo) {
+        rewards.push(new BN5(0));
+        continue;
+      }
+      const growthInsideLast = new BN5(
+        positionRewardInfo.growthInsideLastX64.toString()
+      );
+      const rewardAmountOwed = new BN5(
+        positionRewardInfo.rewardAmountOwed.toString()
+      );
+      const rewardGrowthDelta = MathUtils.wrappingSubU128(
+        rewardGrowthInside,
+        growthInsideLast
+      );
+      const rewardAmountDelta = MathUtils.mulDivFloor(
+        rewardGrowthDelta,
+        liquidityBN,
+        Q64
+      );
+      rewards.push(rewardAmountOwed.add(rewardAmountDelta));
+    }
+    return { rewards };
+  }
+};
+
 // src/utils/index.ts
 import {
   getAddressEncoder as getAddressEncoder29
@@ -8197,7 +8475,7 @@ import {
   address as address3
 } from "@solana/kit";
 import { TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS2 } from "@solana-program/token";
-import BN5 from "bn.js";
+import BN6 from "bn.js";
 import Decimal3 from "decimal.js";
 
 // src/utils/token.ts
@@ -8239,8 +8517,8 @@ var PoolManager = class {
     } = params;
     const addressA = address3(tokenMintA);
     const addressB = address3(tokenMintB);
-    const isAFirst = new BN5(Buffer.from(addressB)).gt(
-      new BN5(Buffer.from(addressA))
+    const isAFirst = new BN6(Buffer.from(addressB)).gt(
+      new BN6(Buffer.from(addressA))
     );
     const [token0, token1, decimals0, decimals1, priceAdjusted] = isAFirst ? [tokenMintA, tokenMintB, mintADecimals, mintBDecimals, initialPrice] : [
       tokenMintB,
@@ -8422,7 +8700,7 @@ var PoolManager = class {
       getToken(this.config.rpc, poolState.tokenVault1)
     ]);
     const currentPrice = this.calculatePoolPrice(
-      new BN5(poolState.sqrtPriceX64.toString()),
+      new BN6(poolState.sqrtPriceX64.toString()),
       tokenA.decimals,
       tokenB.decimals
     );
@@ -8479,7 +8757,7 @@ import {
   getTransferCheckedInstruction
 } from "@solana-program/token";
 import { TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS2 } from "@solana-program/token-2022";
-import BN6 from "bn.js";
+import BN7 from "bn.js";
 
 // ../node_modules/@solana/spl-token/lib/esm/constants.js
 import { PublicKey } from "@solana/web3.js";
@@ -9040,21 +9318,22 @@ var PositionManager = class {
    * Enrich position state with computed fields from pool data
    * @param position - Raw position state from blockchain
    * @param pool - Pool state from blockchain
+   * @param fees - Position fees
    * @returns Enriched position info with calculated amounts and prices
    */
-  enrichPositionInfo(position, pool) {
+  enrichPositionInfo(position, pool, fees, rewards) {
     const sqrtPriceLowerX64 = SqrtPriceMath.getSqrtPriceX64FromTick(
       position.tickLowerIndex
     );
     const sqrtPriceUpperX64 = SqrtPriceMath.getSqrtPriceX64FromTick(
       position.tickUpperIndex
     );
-    const sqrtPriceCurrentX64 = new BN6(pool.sqrtPriceX64.toString());
+    const sqrtPriceCurrentX64 = new BN7(pool.sqrtPriceX64.toString());
     const { amountA, amountB } = LiquidityMath.getAmountsFromLiquidity(
       sqrtPriceCurrentX64,
       sqrtPriceLowerX64,
       sqrtPriceUpperX64,
-      new BN6(position.liquidity.toString()),
+      new BN7(position.liquidity.toString()),
       true
     );
     const [_amountA, _amountB] = [
@@ -9075,9 +9354,13 @@ var PositionManager = class {
     });
     const inRange = pool.tickCurrent >= position.tickLowerIndex && pool.tickCurrent < position.tickUpperIndex;
     const unclaimedFees = {
-      token0: new BN6(position.tokenFeesOwed0.toString()),
-      token1: new BN6(position.tokenFeesOwed1.toString())
+      token0: fees?.tokenFees0 ? fees?.tokenFees0 : new BN7(0),
+      token1: fees?.tokenFees1 ? fees?.tokenFees1 : new BN7(0)
     };
+    const unclaimedRewards = rewards?.rewards ? rewards.rewards.map((amount, i) => ({
+      mint: pool.rewardInfos[i]?.tokenMint,
+      amount
+    })).filter((r) => r.mint !== void 0) : void 0;
     const ageSeconds = 0;
     return {
       ...position,
@@ -9090,10 +9373,8 @@ var PositionManager = class {
       inRange,
       ageSeconds,
       unclaimedFees,
-      // valueUsd is optional and requires external price feeds
-      valueUsd: void 0,
-      // unclaimedRewards is optional
-      unclaimedRewards: void 0
+      unclaimedRewards,
+      valueUsd: void 0
     };
   }
   /**
@@ -9133,7 +9414,16 @@ var PositionManager = class {
               console.warn(`Pool ${position.poolId} not found for position`);
               return null;
             }
-            return this.enrichPositionInfo(position, poolAccount.data);
+            const { fees, rewards } = await this.getPositionFeeAndRewards(
+              position,
+              poolAccount.data
+            );
+            return this.enrichPositionInfo(
+              position,
+              poolAccount.data,
+              fees,
+              rewards
+            );
           } catch (error) {
             console.error(`Failed to enrich position: ${error}`);
             return null;
@@ -9148,6 +9438,101 @@ var PositionManager = class {
       );
     }
   }
+  /**
+   * Calculate pending fees and rewards for a position.
+   *
+   * @param position - Personal position state
+   * @param pool - Pool state
+   * @returns Pending fees for both tokens and rewards for each reward token (up to 3)
+   */
+  async getPositionFeeAndRewards(position, pool) {
+    const [tickArrayLower] = await PdaUtils.getTickArrayStatePda(
+      position.poolId,
+      PdaUtils.getTickArrayStartIndex(
+        position.tickLowerIndex,
+        pool.tickSpacing
+      )
+    );
+    const [tickArrayUpper] = await PdaUtils.getTickArrayStatePda(
+      position.poolId,
+      PdaUtils.getTickArrayStartIndex(
+        position.tickUpperIndex,
+        pool.tickSpacing
+      )
+    );
+    const tickArrayLowerAccount = await fetchMaybeTickArrayState(
+      this.config.rpc,
+      tickArrayLower
+    );
+    const tickArrayUpperAccount = await fetchMaybeTickArrayState(
+      this.config.rpc,
+      tickArrayUpper
+    );
+    if (!tickArrayLowerAccount.exists || !tickArrayUpperAccount.exists) {
+      console.log(
+        "[getPositionFeeAndRewards] tick array state accounts do not exist."
+      );
+      return {
+        fees: { tokenFees0: new BN7(0), tokenFees1: new BN7(0) },
+        rewards: { rewards: [new BN7(0), new BN7(0), new BN7(0)] }
+      };
+    }
+    const tickSpacing = pool.tickSpacing;
+    const tickArrayLowerIndex = TickUtils.getTickOffsetInArray(
+      position.tickLowerIndex,
+      tickSpacing
+    );
+    const tickArrayUpperIndex = TickUtils.getTickOffsetInArray(
+      position.tickUpperIndex,
+      tickSpacing
+    );
+    if (tickArrayLowerIndex < 0 || tickArrayUpperIndex < 0) {
+      console.log("[getPositionFeeAndRewards] tick array indexes < 0.");
+      return {
+        fees: { tokenFees0: new BN7(0), tokenFees1: new BN7(0) },
+        rewards: { rewards: [new BN7(0), new BN7(0), new BN7(0)] }
+      };
+    }
+    const lowerTickState = tickArrayLowerAccount.data.ticks[tickArrayLowerIndex];
+    const upperTickState = tickArrayUpperAccount.data.ticks[tickArrayUpperIndex];
+    const fees = PositionUtils.getPositionFees({
+      liquidity: position.liquidity,
+      tickLower: position.tickLowerIndex,
+      tickUpper: position.tickUpperIndex,
+      feeGrowthInside0LastX64: position.feeGrowthInside0LastX64,
+      feeGrowthInside1LastX64: position.feeGrowthInside1LastX64,
+      tokenFeesOwed0: position.tokenFeesOwed0,
+      tokenFeesOwed1: position.tokenFeesOwed1,
+      tickCurrent: pool.tickCurrent,
+      feeGrowthGlobal0X64: pool.feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64: pool.feeGrowthGlobal1X64,
+      tickLowerState: {
+        feeGrowthOutside0X64: lowerTickState.feeGrowthOutside0X64,
+        feeGrowthOutside1X64: lowerTickState.feeGrowthOutside1X64
+      },
+      tickUpperState: {
+        feeGrowthOutside0X64: upperTickState.feeGrowthOutside0X64,
+        feeGrowthOutside1X64: upperTickState.feeGrowthOutside1X64
+      }
+    });
+    const rewards = PositionUtils.getPositionRewards({
+      liquidity: position.liquidity,
+      tickLower: position.tickLowerIndex,
+      tickUpper: position.tickUpperIndex,
+      positionRewardInfos: position.rewardInfos,
+      tickCurrent: pool.tickCurrent,
+      rewardInfos: pool.rewardInfos,
+      tickLowerState: {
+        liquidityGross: lowerTickState.liquidityGross,
+        rewardGrowthsOutsideX64: lowerTickState.rewardGrowthsOutsideX64
+      },
+      tickUpperState: {
+        liquidityGross: upperTickState.liquidityGross,
+        rewardGrowthsOutsideX64: upperTickState.rewardGrowthsOutsideX64
+      }
+    });
+    return { fees, rewards };
+  }
 };
 
 // src/api/config.ts
@@ -10122,7 +10507,7 @@ var PriceApiClient = class _PriceApiClient {
 };
 
 // src/swap.ts
-import BN7 from "bn.js";
+import BN8 from "bn.js";
 import Decimal6 from "decimal.js";
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
@@ -10182,7 +10567,7 @@ var SwapMathEngine = class {
       slippageTolerance,
       poolAddress
     } = params;
-    if (amountIn.lte(new BN7(0))) {
+    if (amountIn.lte(new BN8(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero"
@@ -10194,8 +10579,8 @@ var SwapMathEngine = class {
         `Slippage tolerance must be between 0 and 1, got ${slippageTolerance}`
       );
     }
-    const liquidity = new BN7(pool.liquidity.toString());
-    const sqrtPriceCurrentX64 = new BN7(pool.sqrtPriceX64.toString());
+    const liquidity = new BN8(pool.liquidity.toString());
+    const sqrtPriceCurrentX64 = new BN8(pool.sqrtPriceX64.toString());
     const feeRate = ammConfig.tradeFeeRate;
     const sqrtPriceTargetX64 = this.calculateSqrtPriceLimit(
       sqrtPriceCurrentX64,
@@ -10223,9 +10608,9 @@ var SwapMathEngine = class {
       pool.mintDecimals1
     );
     const priceImpact = priceAfter.minus(priceBefore).div(priceBefore).abs().toNumber();
-    const slippageBN = new BN7(Math.floor(slippageTolerance * 1e4));
+    const slippageBN = new BN8(Math.floor(slippageTolerance * 1e4));
     const minAmountOut = step.amountOut.sub(
-      step.amountOut.mul(slippageBN).div(new BN7(1e4))
+      step.amountOut.mul(slippageBN).div(new BN8(1e4))
     );
     return {
       amountIn,
@@ -10272,17 +10657,17 @@ var SwapMathEngine = class {
       tickArrayCache
     } = params;
     const sqrtPriceLimitX64 = this.calculateSqrtPriceLimit(
-      new BN7(pool.sqrtPriceX64.toString()),
+      new BN8(pool.sqrtPriceX64.toString()),
       zeroForOne,
       slippageTolerance
     );
     const result = await SwapMath.swapCompute({
       poolState: {
-        sqrtPriceX64: new BN7(pool.sqrtPriceX64.toString()),
+        sqrtPriceX64: new BN8(pool.sqrtPriceX64.toString()),
         tickCurrent: pool.tickCurrent,
-        liquidity: new BN7(pool.liquidity.toString()),
-        feeGrowthGlobal0X64: new BN7(pool.feeGrowthGlobal0X64.toString()),
-        feeGrowthGlobal1X64: new BN7(pool.feeGrowthGlobal1X64.toString())
+        liquidity: new BN8(pool.liquidity.toString()),
+        feeGrowthGlobal0X64: new BN8(pool.feeGrowthGlobal0X64.toString()),
+        feeGrowthGlobal1X64: new BN8(pool.feeGrowthGlobal1X64.toString())
       },
       tickArrayCache,
       tickSpacing: pool.tickSpacing,
@@ -10299,7 +10684,7 @@ var SwapMathEngine = class {
       poolId: poolAddress
     });
     const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-      new BN7(pool.sqrtPriceX64.toString()),
+      new BN8(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -10309,9 +10694,9 @@ var SwapMathEngine = class {
       pool.mintDecimals1
     );
     const priceImpact = priceAfter.minus(priceBefore).div(priceBefore).abs().toNumber();
-    const slippageBN = new BN7(Math.floor(slippageTolerance * 1e4));
+    const slippageBN = new BN8(Math.floor(slippageTolerance * 1e4));
     const minAmountOut = result.amountOut.sub(
-      result.amountOut.mul(slippageBN).div(new BN7(1e4))
+      result.amountOut.mul(slippageBN).div(new BN8(1e4))
     );
     const feeImpact = ammConfig.tradeFeeRate / FEE_RATE_DENOMINATOR_NUMBER;
     return {
@@ -10355,10 +10740,10 @@ var SwapMathEngine = class {
    */
   calculateSqrtPriceLimit(sqrtPriceX64, zeroForOne, slippageTolerance) {
     const bps = Math.floor(slippageTolerance * 1e4);
-    const base = new BN7(1e4);
-    const scaled = zeroForOne ? sqrtPriceX64.mul(base.sub(new BN7(bps))).div(base) : sqrtPriceX64.mul(base.add(new BN7(bps))).div(base);
-    const min2 = new BN7(MIN_SQRT_PRICE_X64);
-    const max = new BN7(MAX_SQRT_PRICE_X64);
+    const base = new BN8(1e4);
+    const scaled = zeroForOne ? sqrtPriceX64.mul(base.sub(new BN8(bps))).div(base) : sqrtPriceX64.mul(base.add(new BN8(bps))).div(base);
+    const min2 = new BN8(MIN_SQRT_PRICE_X64);
+    const max = new BN8(MAX_SQRT_PRICE_X64);
     if (scaled.lt(min2)) return min2;
     if (scaled.gt(max)) return max;
     return scaled;
@@ -10782,7 +11167,7 @@ var SwapManager = class {
         `Invalid slippage tolerance: ${slippageTolerance}. Must be between 0 and 1.`
       );
     }
-    if (amountIn.lte(new BN7(0))) {
+    if (amountIn.lte(new BN8(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero."
@@ -10884,7 +11269,7 @@ var SwapManager = class {
         `Invalid slippage tolerance: ${slippageTolerance}. Must be between 0 and 1.`
       );
     }
-    if (amountIn.lte(new BN7(0))) {
+    if (amountIn.lte(new BN8(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero."
@@ -10938,7 +11323,7 @@ var SwapManager = class {
         poolAddress
       });
       const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-        new BN7(pool.sqrtPriceX64.toString()),
+        new BN8(pool.sqrtPriceX64.toString()),
         pool.mintDecimals0,
         pool.mintDecimals1
       );
@@ -11048,21 +11433,21 @@ var SwapManager = class {
    * @returns Number of tick arrays to fetch (includes safety buffer)
    */
   estimateTickArrayCount(pool, amountIn) {
-    const liquidity = new BN7(pool.liquidity.toString());
-    if (liquidity.eq(new BN7(0)) || liquidity.lt(new BN7(1e3))) {
+    const liquidity = new BN8(pool.liquidity.toString());
+    if (liquidity.eq(new BN8(0)) || liquidity.lt(new BN8(1e3))) {
       return 10;
     }
-    const roughImpact = amountIn.mul(new BN7(1e3)).div(liquidity);
+    const roughImpact = amountIn.mul(new BN8(1e3)).div(liquidity);
     let baseArrays;
-    if (roughImpact.lte(new BN7(1))) {
+    if (roughImpact.lte(new BN8(1))) {
       baseArrays = 2;
-    } else if (roughImpact.lte(new BN7(10))) {
+    } else if (roughImpact.lte(new BN8(10))) {
       baseArrays = 4;
-    } else if (roughImpact.lte(new BN7(50))) {
+    } else if (roughImpact.lte(new BN8(50))) {
       baseArrays = 6;
-    } else if (roughImpact.lte(new BN7(100))) {
+    } else if (roughImpact.lte(new BN8(100))) {
       baseArrays = 8;
-    } else if (roughImpact.lte(new BN7(200))) {
+    } else if (roughImpact.lte(new BN8(200))) {
       baseArrays = 12;
     } else {
       baseArrays = 15;
@@ -11107,7 +11492,7 @@ var SwapManager = class {
     const decOut = zeroForOne ? pool.mintDecimals1 : pool.mintDecimals0;
     const promises = params.amounts.map(async (amountIn) => {
       try {
-        if (amountIn.lte(new BN7(0))) return;
+        if (amountIn.lte(new BN8(0))) return;
         const quote = await this.mathEngine.calculateSimpleSwap({
           pool,
           ammConfig,
@@ -11149,7 +11534,7 @@ var SwapManager = class {
       options
     );
     const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-      new BN7(pool.sqrtPriceX64.toString()),
+      new BN8(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -11272,13 +11657,13 @@ var SwapManager = class {
           `Extremely high price impact: ${(quote.priceImpact * 100).toFixed(2)}%. Swap likely to fail or result in significant slippage.`
         );
       }
-      const oneUnit = new BN7(10).pow(new BN7(outputDecimals));
+      const oneUnit = new BN8(10).pow(new BN8(outputDecimals));
       if (quote.amountOut.lt(oneUnit)) {
         warnings.push(
           `Output amount is less than 1 unit of the output token. Consider increasing input amount or slippage tolerance.`
         );
       }
-      if (quote.amountOut.lte(new BN7(0))) {
+      if (quote.amountOut.lte(new BN8(0))) {
         errors.push(
           "Swap would result in zero output. Amount may be too small."
         );
@@ -11299,11 +11684,11 @@ var SwapManager = class {
       return {
         quote: {
           amountIn: params.amountIn,
-          amountOut: new BN7(0),
-          minAmountOut: new BN7(0),
+          amountOut: new BN8(0),
+          minAmountOut: new BN8(0),
           priceImpact: 0,
           route: [],
-          fee: new BN7(0)
+          fee: new BN8(0)
         },
         willSucceed: false,
         errors,
@@ -11403,7 +11788,7 @@ var SwapManager = class {
       tokenProgram: TOKEN_PROGRAM_ADDRESS4
     });
     const sqrtPriceLimitX64 = params.sqrtPriceLimitX64 || this.mathEngine.calculateSqrtPriceLimit(
-      new BN7(pool.sqrtPriceX64.toString()),
+      new BN8(pool.sqrtPriceX64.toString()),
       zeroForOne,
       params.slippageTolerance || DEFAULT_SLIPPAGE_TOLERANCE
     );
@@ -11428,7 +11813,7 @@ var SwapManager = class {
   async getCurrentPrice(poolAddress, options) {
     const pool = await this.poolDataManager.getPoolState(poolAddress, options);
     return SqrtPriceMath.sqrtPriceX64ToPrice(
-      new BN7(pool.sqrtPriceX64.toString()),
+      new BN8(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -11640,6 +12025,7 @@ export {
   PoolManager,
   PoolUtils,
   PositionManager,
+  PositionUtils,
   PriceApiClient,
   Q128,
   Q64,