@stabbleorg/mclmm-sdk 0.3.1 → 0.3.3

package/lib/index.js

@@ -66,6 +66,7 @@ __export(index_exports, {
   PoolManager: () => PoolManager,
   PoolUtils: () => PoolUtils,
   PositionManager: () => PositionManager,
+  PositionUtils: () => PositionUtils,
   PriceApiClient: () => PriceApiClient,
   Q128: () => Q128,
   Q64: () => Q64,
@@ -5348,6 +5349,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
@@ -7471,6 +7488,268 @@ var PoolUtils = class {
   }
 };
 
+// src/utils/position.ts
+var import_bn5 = __toESM(require("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 import_bn5.default(feeGrowthGlobal0X64.toString());
+    const feeGrowthGlobal1 = new import_bn5.default(feeGrowthGlobal1X64.toString());
+    const tickLowerFeeGrowthOutside0 = new import_bn5.default(
+      tickLowerState.feeGrowthOutside0X64.toString()
+    );
+    const tickLowerFeeGrowthOutside1 = new import_bn5.default(
+      tickLowerState.feeGrowthOutside1X64.toString()
+    );
+    const tickUpperFeeGrowthOutside0 = new import_bn5.default(
+      tickUpperState.feeGrowthOutside0X64.toString()
+    );
+    const tickUpperFeeGrowthOutside1 = new import_bn5.default(
+      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 import_bn5.default(liquidity.toString());
+    const feeGrowthInside0Last = new import_bn5.default(feeGrowthInside0LastX64.toString());
+    const feeGrowthInside1Last = new import_bn5.default(feeGrowthInside1LastX64.toString());
+    const feesOwed0 = new import_bn5.default(tokenFeesOwed0.toString());
+    const feesOwed1 = new import_bn5.default(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 import_bn5.default(
+        rewardInfos[i].rewardGrowthGlobalX64.toString()
+      );
+      let rewardGrowthBelow;
+      if (tickLowerState.liquidityGross === 0n) {
+        rewardGrowthBelow = rewardGrowthGlobal;
+      } else if (tickCurrent < tickLower) {
+        rewardGrowthBelow = rewardGrowthGlobal.sub(
+          new import_bn5.default(tickLowerState.rewardGrowthsOutsideX64[i].toString())
+        );
+      } else {
+        rewardGrowthBelow = new import_bn5.default(
+          tickLowerState.rewardGrowthsOutsideX64[i].toString()
+        );
+      }
+      let rewardGrowthAbove;
+      if (tickUpperState.liquidityGross === 0n) {
+        rewardGrowthAbove = new import_bn5.default(0);
+      } else if (tickCurrent < tickUpper) {
+        rewardGrowthAbove = new import_bn5.default(
+          tickUpperState.rewardGrowthsOutsideX64[i].toString()
+        );
+      } else {
+        rewardGrowthAbove = rewardGrowthGlobal.sub(
+          new import_bn5.default(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 import_bn5.default(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 import_bn5.default(0));
+        continue;
+      }
+      const growthInsideLast = new import_bn5.default(
+        positionRewardInfo.growthInsideLastX64.toString()
+      );
+      const rewardAmountOwed = new import_bn5.default(
+        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
 var import_kit51 = require("@solana/kit");
 function validateAddress(address6, name = "address") {
@@ -7636,7 +7915,7 @@ var Clmm = class {
 // src/pool-manager.ts
 var import_kit52 = require("@solana/kit");
 var import_token2 = require("@solana-program/token");
-var import_bn5 = __toESM(require("bn.js"));
+var import_bn6 = __toESM(require("bn.js"));
 var import_decimal3 = __toESM(require("decimal.js"));
 
 // src/utils/token.ts
@@ -7675,8 +7954,8 @@ var PoolManager = class {
     } = params;
     const addressA = (0, import_kit52.address)(tokenMintA);
     const addressB = (0, import_kit52.address)(tokenMintB);
-    const isAFirst = new import_bn5.default(Buffer.from(addressB)).gt(
-      new import_bn5.default(Buffer.from(addressA))
+    const isAFirst = new import_bn6.default(Buffer.from(addressB)).gt(
+      new import_bn6.default(Buffer.from(addressA))
     );
     const [token0, token1, decimals0, decimals1, priceAdjusted] = isAFirst ? [tokenMintA, tokenMintB, mintADecimals, mintBDecimals, initialPrice] : [
       tokenMintB,
@@ -7858,7 +8137,7 @@ var PoolManager = class {
       getToken(this.config.rpc, poolState.tokenVault1)
     ]);
     const currentPrice = this.calculatePoolPrice(
-      new import_bn5.default(poolState.sqrtPriceX64.toString()),
+      new import_bn6.default(poolState.sqrtPriceX64.toString()),
       tokenA.decimals,
       tokenB.decimals
     );
@@ -7903,7 +8182,7 @@ var PoolManager = class {
 var import_kit53 = require("@solana/kit");
 var import_token4 = require("@solana-program/token");
 var import_token_20222 = require("@solana-program/token-2022");
-var import_bn6 = __toESM(require("bn.js"));
+var import_bn7 = __toESM(require("bn.js"));
 
 // ../node_modules/@solana/spl-token/lib/esm/constants.js
 var import_web3 = require("@solana/web3.js");
@@ -7940,16 +8219,6 @@ var PositionManager = class {
       (0, import_token4.getSyncNativeInstruction)({ account: ata })
     ];
   }
-  buildUnwrapSolInstruction(params) {
-    const { owner, destination, ata } = params;
-    return [
-      (0, import_token4.getCloseAccountInstruction)({
-        account: ata,
-        destination,
-        owner
-      })
-    ];
-  }
   /**
    * Build partial unwrap SOL instructions using a temp account:
    * 1. Create temp account
@@ -8387,27 +8656,17 @@ var PositionManager = class {
     ];
     if (isNative) {
       const destination = ownerInfo.wallet.address;
-      const isFullWithdrawal = liquidity === ownerPosition.liquidity;
       const isTokenANative = poolState.data.tokenMint0.toString() === NATIVE_MINT.toString();
       const wsolAta = isTokenANative ? ownerInfo.tokenAccountA : ownerInfo.tokenAccountB;
       const amount = isTokenANative ? amountMinA : amountMinB;
-      if (isFullWithdrawal) {
-        const unwrapIxs = this.buildUnwrapSolInstruction({
-          ata: wsolAta,
-          owner: ownerInfo.wallet.address,
-          destination
-        });
-        instructions.push(...unwrapIxs);
-      } else {
-        const { instructions: partialUnwrapIxs, signers: partialSigners } = await this.buildPartialUnwrapSolInstructions({
-          payer: ownerInfo.wallet,
-          sourceAta: wsolAta,
-          destination,
-          amount
-        });
-        instructions.push(...partialUnwrapIxs);
-        signers.push(...partialSigners);
-      }
+      const { instructions: unwrapIxs, signers: unwrapSigners } = await this.buildPartialUnwrapSolInstructions({
+        payer: ownerInfo.wallet,
+        sourceAta: wsolAta,
+        destination,
+        amount
+      });
+      instructions.push(...unwrapIxs);
+      signers.push(...unwrapSigners);
     }
     return {
       instructions,
@@ -8481,21 +8740,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 import_bn6.default(pool.sqrtPriceX64.toString());
+    const sqrtPriceCurrentX64 = new import_bn7.default(pool.sqrtPriceX64.toString());
     const { amountA, amountB } = LiquidityMath.getAmountsFromLiquidity(
       sqrtPriceCurrentX64,
       sqrtPriceLowerX64,
       sqrtPriceUpperX64,
-      new import_bn6.default(position.liquidity.toString()),
+      new import_bn7.default(position.liquidity.toString()),
       true
     );
     const [_amountA, _amountB] = [
@@ -8516,9 +8776,13 @@ var PositionManager = class {
     });
     const inRange = pool.tickCurrent >= position.tickLowerIndex && pool.tickCurrent < position.tickUpperIndex;
     const unclaimedFees = {
-      token0: new import_bn6.default(position.tokenFeesOwed0.toString()),
-      token1: new import_bn6.default(position.tokenFeesOwed1.toString())
+      token0: fees?.tokenFees0 ? fees?.tokenFees0 : new import_bn7.default(0),
+      token1: fees?.tokenFees1 ? fees?.tokenFees1 : new import_bn7.default(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,
@@ -8531,10 +8795,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
     };
   }
   /**
@@ -8574,7 +8836,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;
@@ -8589,6 +8860,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 import_bn7.default(0), tokenFees1: new import_bn7.default(0) },
+        rewards: { rewards: [new import_bn7.default(0), new import_bn7.default(0), new import_bn7.default(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 import_bn7.default(0), tokenFees1: new import_bn7.default(0) },
+        rewards: { rewards: [new import_bn7.default(0), new import_bn7.default(0), new import_bn7.default(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
@@ -9560,7 +9926,7 @@ var PriceApiClient = class _PriceApiClient {
 };
 
 // src/swap.ts
-var import_bn7 = __toESM(require("bn.js"));
+var import_bn8 = __toESM(require("bn.js"));
 var import_decimal6 = __toESM(require("decimal.js"));
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
@@ -9620,7 +9986,7 @@ var SwapMathEngine = class {
       slippageTolerance,
       poolAddress
     } = params;
-    if (amountIn.lte(new import_bn7.default(0))) {
+    if (amountIn.lte(new import_bn8.default(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero"
@@ -9632,8 +9998,8 @@ var SwapMathEngine = class {
         `Slippage tolerance must be between 0 and 1, got ${slippageTolerance}`
       );
     }
-    const liquidity = new import_bn7.default(pool.liquidity.toString());
-    const sqrtPriceCurrentX64 = new import_bn7.default(pool.sqrtPriceX64.toString());
+    const liquidity = new import_bn8.default(pool.liquidity.toString());
+    const sqrtPriceCurrentX64 = new import_bn8.default(pool.sqrtPriceX64.toString());
     const feeRate = ammConfig.tradeFeeRate;
     const sqrtPriceTargetX64 = this.calculateSqrtPriceLimit(
       sqrtPriceCurrentX64,
@@ -9661,9 +10027,9 @@ var SwapMathEngine = class {
       pool.mintDecimals1
     );
     const priceImpact = priceAfter.minus(priceBefore).div(priceBefore).abs().toNumber();
-    const slippageBN = new import_bn7.default(Math.floor(slippageTolerance * 1e4));
+    const slippageBN = new import_bn8.default(Math.floor(slippageTolerance * 1e4));
     const minAmountOut = step.amountOut.sub(
-      step.amountOut.mul(slippageBN).div(new import_bn7.default(1e4))
+      step.amountOut.mul(slippageBN).div(new import_bn8.default(1e4))
     );
     return {
       amountIn,
@@ -9710,17 +10076,17 @@ var SwapMathEngine = class {
       tickArrayCache
     } = params;
     const sqrtPriceLimitX64 = this.calculateSqrtPriceLimit(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       zeroForOne,
       slippageTolerance
     );
     const result = await SwapMath.swapCompute({
       poolState: {
-        sqrtPriceX64: new import_bn7.default(pool.sqrtPriceX64.toString()),
+        sqrtPriceX64: new import_bn8.default(pool.sqrtPriceX64.toString()),
         tickCurrent: pool.tickCurrent,
-        liquidity: new import_bn7.default(pool.liquidity.toString()),
-        feeGrowthGlobal0X64: new import_bn7.default(pool.feeGrowthGlobal0X64.toString()),
-        feeGrowthGlobal1X64: new import_bn7.default(pool.feeGrowthGlobal1X64.toString())
+        liquidity: new import_bn8.default(pool.liquidity.toString()),
+        feeGrowthGlobal0X64: new import_bn8.default(pool.feeGrowthGlobal0X64.toString()),
+        feeGrowthGlobal1X64: new import_bn8.default(pool.feeGrowthGlobal1X64.toString())
       },
       tickArrayCache,
       tickSpacing: pool.tickSpacing,
@@ -9737,7 +10103,7 @@ var SwapMathEngine = class {
       poolId: poolAddress
     });
     const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -9747,9 +10113,9 @@ var SwapMathEngine = class {
       pool.mintDecimals1
     );
     const priceImpact = priceAfter.minus(priceBefore).div(priceBefore).abs().toNumber();
-    const slippageBN = new import_bn7.default(Math.floor(slippageTolerance * 1e4));
+    const slippageBN = new import_bn8.default(Math.floor(slippageTolerance * 1e4));
     const minAmountOut = result.amountOut.sub(
-      result.amountOut.mul(slippageBN).div(new import_bn7.default(1e4))
+      result.amountOut.mul(slippageBN).div(new import_bn8.default(1e4))
     );
     const feeImpact = ammConfig.tradeFeeRate / FEE_RATE_DENOMINATOR_NUMBER;
     return {
@@ -9793,10 +10159,10 @@ var SwapMathEngine = class {
    */
   calculateSqrtPriceLimit(sqrtPriceX64, zeroForOne, slippageTolerance) {
     const bps = Math.floor(slippageTolerance * 1e4);
-    const base = new import_bn7.default(1e4);
-    const scaled = zeroForOne ? sqrtPriceX64.mul(base.sub(new import_bn7.default(bps))).div(base) : sqrtPriceX64.mul(base.add(new import_bn7.default(bps))).div(base);
-    const min2 = new import_bn7.default(MIN_SQRT_PRICE_X64);
-    const max = new import_bn7.default(MAX_SQRT_PRICE_X64);
+    const base = new import_bn8.default(1e4);
+    const scaled = zeroForOne ? sqrtPriceX64.mul(base.sub(new import_bn8.default(bps))).div(base) : sqrtPriceX64.mul(base.add(new import_bn8.default(bps))).div(base);
+    const min2 = new import_bn8.default(MIN_SQRT_PRICE_X64);
+    const max = new import_bn8.default(MAX_SQRT_PRICE_X64);
     if (scaled.lt(min2)) return min2;
     if (scaled.gt(max)) return max;
     return scaled;
@@ -10220,7 +10586,7 @@ var SwapManager = class {
         `Invalid slippage tolerance: ${slippageTolerance}. Must be between 0 and 1.`
       );
     }
-    if (amountIn.lte(new import_bn7.default(0))) {
+    if (amountIn.lte(new import_bn8.default(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero."
@@ -10322,7 +10688,7 @@ var SwapManager = class {
         `Invalid slippage tolerance: ${slippageTolerance}. Must be between 0 and 1.`
       );
     }
-    if (amountIn.lte(new import_bn7.default(0))) {
+    if (amountIn.lte(new import_bn8.default(0))) {
       throw new ClmmError(
         "SWAP_AMOUNT_CANNOT_BE_ZERO" /* SWAP_AMOUNT_CANNOT_BE_ZERO */,
         "Swap amount must be greater than zero."
@@ -10376,7 +10742,7 @@ var SwapManager = class {
         poolAddress
       });
       const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-        new import_bn7.default(pool.sqrtPriceX64.toString()),
+        new import_bn8.default(pool.sqrtPriceX64.toString()),
         pool.mintDecimals0,
         pool.mintDecimals1
       );
@@ -10486,21 +10852,21 @@ var SwapManager = class {
    * @returns Number of tick arrays to fetch (includes safety buffer)
    */
   estimateTickArrayCount(pool, amountIn) {
-    const liquidity = new import_bn7.default(pool.liquidity.toString());
-    if (liquidity.eq(new import_bn7.default(0)) || liquidity.lt(new import_bn7.default(1e3))) {
+    const liquidity = new import_bn8.default(pool.liquidity.toString());
+    if (liquidity.eq(new import_bn8.default(0)) || liquidity.lt(new import_bn8.default(1e3))) {
       return 10;
     }
-    const roughImpact = amountIn.mul(new import_bn7.default(1e3)).div(liquidity);
+    const roughImpact = amountIn.mul(new import_bn8.default(1e3)).div(liquidity);
     let baseArrays;
-    if (roughImpact.lte(new import_bn7.default(1))) {
+    if (roughImpact.lte(new import_bn8.default(1))) {
       baseArrays = 2;
-    } else if (roughImpact.lte(new import_bn7.default(10))) {
+    } else if (roughImpact.lte(new import_bn8.default(10))) {
       baseArrays = 4;
-    } else if (roughImpact.lte(new import_bn7.default(50))) {
+    } else if (roughImpact.lte(new import_bn8.default(50))) {
       baseArrays = 6;
-    } else if (roughImpact.lte(new import_bn7.default(100))) {
+    } else if (roughImpact.lte(new import_bn8.default(100))) {
       baseArrays = 8;
-    } else if (roughImpact.lte(new import_bn7.default(200))) {
+    } else if (roughImpact.lte(new import_bn8.default(200))) {
       baseArrays = 12;
     } else {
       baseArrays = 15;
@@ -10545,7 +10911,7 @@ var SwapManager = class {
     const decOut = zeroForOne ? pool.mintDecimals1 : pool.mintDecimals0;
     const promises = params.amounts.map(async (amountIn) => {
       try {
-        if (amountIn.lte(new import_bn7.default(0))) return;
+        if (amountIn.lte(new import_bn8.default(0))) return;
         const quote = await this.mathEngine.calculateSimpleSwap({
           pool,
           ammConfig,
@@ -10587,7 +10953,7 @@ var SwapManager = class {
       options
     );
     const priceBefore = SqrtPriceMath.sqrtPriceX64ToPrice(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -10710,13 +11076,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 import_bn7.default(10).pow(new import_bn7.default(outputDecimals));
+      const oneUnit = new import_bn8.default(10).pow(new import_bn8.default(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 import_bn7.default(0))) {
+      if (quote.amountOut.lte(new import_bn8.default(0))) {
         errors.push(
           "Swap would result in zero output. Amount may be too small."
         );
@@ -10737,11 +11103,11 @@ var SwapManager = class {
       return {
         quote: {
           amountIn: params.amountIn,
-          amountOut: new import_bn7.default(0),
-          minAmountOut: new import_bn7.default(0),
+          amountOut: new import_bn8.default(0),
+          minAmountOut: new import_bn8.default(0),
           priceImpact: 0,
           route: [],
-          fee: new import_bn7.default(0)
+          fee: new import_bn8.default(0)
         },
         willSucceed: false,
         errors,
@@ -10841,7 +11207,7 @@ var SwapManager = class {
       tokenProgram: import_token5.TOKEN_PROGRAM_ADDRESS
     });
     const sqrtPriceLimitX64 = params.sqrtPriceLimitX64 || this.mathEngine.calculateSqrtPriceLimit(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       zeroForOne,
       params.slippageTolerance || DEFAULT_SLIPPAGE_TOLERANCE
     );
@@ -10866,7 +11232,7 @@ var SwapManager = class {
   async getCurrentPrice(poolAddress, options) {
     const pool = await this.poolDataManager.getPoolState(poolAddress, options);
     return SqrtPriceMath.sqrtPriceX64ToPrice(
-      new import_bn7.default(pool.sqrtPriceX64.toString()),
+      new import_bn8.default(pool.sqrtPriceX64.toString()),
       pool.mintDecimals0,
       pool.mintDecimals1
     );
@@ -11079,6 +11445,7 @@ var DEFAULT_SDK_CONFIG = {
   PoolManager,
   PoolUtils,
   PositionManager,
+  PositionUtils,
   PriceApiClient,
   Q128,
   Q64,