@alephium/powfi-sdk 0.0.1-rc.1

package/src/clmm/liquidity.ts

@@ -0,0 +1,163 @@
+import type { TokenInfo } from '@alephium/token-list';
+import { TickUtils } from './tick';
+import { MathUtil } from '../common/math';
+import { Q96 } from 'clmm/artifacts/ts/constants';
+import type { GetPositionAmountsFromPriceProps, GetPositionAmountsFromPriceReturn } from './types';
+
+export class ClmmLiquidityUtils {
+  static getPositionAmountsFromPrice(
+    p: GetPositionAmountsFromPriceProps,
+  ): GetPositionAmountsFromPriceReturn {
+    if (p.amountBase === 0n || p.amountQuote === 0n) {
+      return { newAmountBase: 0n, newAmountQuote: 0n, liquidity: 0n };
+    }
+    const amounts = [p.amountBase, p.amountQuote];
+    const sqrts = [
+      TickUtils.getSqrtRatioAtTick(p.lowerTick),
+      TickUtils.getSqrtRatioAtTick(p.upperTick),
+    ];
+    const reverse1 = p.lowerTick > p.upperTick;
+    if (reverse1) {
+      sqrts.reverse();
+    }
+    const reverse2 = p.tokenBaseId > p.tokenQuoteId;
+    if (reverse2) {
+      amounts.reverse();
+    }
+    const [amount0, amount1, liquidity] = this.getAmountsAndLiquidityAtSqrtPrice(
+      p.sqrtRatioX96,
+      sqrts[0],
+      sqrts[1],
+      amounts[0],
+      amounts[1],
+    );
+    return reverse2
+      ? { newAmountBase: amount1, newAmountQuote: amount0, liquidity }
+      : { newAmountBase: amount0, newAmountQuote: amount1, liquidity };
+  }
+
+  static getAmountsAndLiquidityAtPrice(
+    currentPrice: number,
+    token0: TokenInfo,
+    token1: TokenInfo,
+    lowerTick: bigint,
+    upperTick: bigint,
+    amount0: bigint,
+    amount1: bigint,
+  ): [bigint, bigint, bigint] {
+    const sqrtRatioX96 = TickUtils.priceToSqrtPriceX96(
+      currentPrice,
+      token0.decimals,
+      token1.decimals,
+    );
+    const sqrtRatioAX96 = TickUtils.getSqrtRatioAtTick(lowerTick);
+    const sqrtRatioBX96 = TickUtils.getSqrtRatioAtTick(upperTick);
+    return this.getAmountsAndLiquidityAtSqrtPrice(
+      sqrtRatioX96,
+      sqrtRatioAX96,
+      sqrtRatioBX96,
+      amount0,
+      amount1,
+    );
+  }
+
+  static getAmountsAndLiquidityAtSqrtPrice(
+    sqrtRatioX96: bigint,
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    amount0: bigint,
+    amount1: bigint,
+  ): [bigint, bigint, bigint] {
+    const liquidity = this.getLiquidityFromAmounts(
+      sqrtRatioX96,
+      sqrtRatioAX96,
+      sqrtRatioBX96,
+      amount0,
+      amount1,
+    );
+    const [a0, a1] = this.getAmountsForLiquidity(
+      sqrtRatioX96,
+      sqrtRatioAX96,
+      sqrtRatioBX96,
+      -liquidity,
+    );
+    return [-a0, -a1, liquidity];
+  }
+
+  static getAmountsForLiquidity(
+    sqrtRatioX96: bigint,
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+  ): [bigint, bigint] {
+    if (sqrtRatioX96 <= sqrtRatioAX96) {
+      const amount0 = this.getToken0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity);
+      return [amount0, 0n];
+    } else if (sqrtRatioX96 < sqrtRatioBX96) {
+      const amount0 = this.getToken0Delta(sqrtRatioX96, sqrtRatioBX96, liquidity);
+      const amount1 = this.getToken1Delta(sqrtRatioAX96, sqrtRatioX96, liquidity);
+      return [amount0, amount1];
+    } else {
+      const amount1 = this.getToken1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity);
+      return [0n, amount1];
+    }
+  }
+
+  static getLiquidityFromAmounts(
+    sqrtRatioX96: bigint,
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    amount0: bigint,
+    amount1: bigint,
+  ): bigint {
+    if (sqrtRatioX96 < sqrtRatioAX96) {
+      return this.getLiquidityFromToken0(sqrtRatioAX96, sqrtRatioBX96, amount0);
+    } else if (sqrtRatioX96 < sqrtRatioBX96) {
+      const liquidity0 = this.getLiquidityFromToken0(sqrtRatioX96, sqrtRatioBX96, amount0);
+      const liquidity1 = this.getLiquidityFromToken1(sqrtRatioAX96, sqrtRatioX96, amount1);
+      return liquidity0 < liquidity1 ? liquidity0 : liquidity1;
+    } else {
+      return this.getLiquidityFromToken1(sqrtRatioAX96, sqrtRatioBX96, amount1);
+    }
+  }
+
+  static getLiquidityFromToken0(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    amount0: bigint,
+  ): bigint {
+    const intermediate = MathUtil.alphDiv(sqrtRatioAX96 * sqrtRatioBX96, Q96);
+    return MathUtil.alphDiv(amount0 * intermediate, sqrtRatioBX96 - sqrtRatioAX96);
+  }
+
+  static getLiquidityFromToken1(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    amount1: bigint,
+  ): bigint {
+    return MathUtil.alphDiv(amount1 * Q96, sqrtRatioBX96 - sqrtRatioAX96);
+  }
+
+  static getAmountDelta(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    if (zeroForOne) {
+      return this.getToken0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity);
+    } else {
+      return this.getToken1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity);
+    }
+  }
+
+  static getToken0Delta(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint {
+    const numerator1 = liquidity * Q96;
+    const numerator2 = sqrtRatioBX96 - sqrtRatioAX96;
+    return MathUtil.alphDiv(numerator1 * numerator2, sqrtRatioBX96 * sqrtRatioAX96);
+  }
+
+  static getToken1Delta(sqrtRatioAX96: bigint, sqrtRatioBX96: bigint, liquidity: bigint): bigint {
+    return MathUtil.alphDiv(liquidity * (sqrtRatioBX96 - sqrtRatioAX96), Q96);
+  }
+}

package/src/clmm/pool.ts

@@ -0,0 +1,154 @@
+import {
+  binToHex,
+  contractIdFromAddress,
+  encodePrimitiveValues,
+  groupOfAddress,
+  isGrouplessAddressWithoutGroupIndex,
+  subContractId,
+} from '@alephium/web3';
+import { Pool } from 'clmm/artifacts/ts/Pool';
+import { TickUtils } from './tick';
+import type { LiquidityDistribution } from './types';
+import { ClmmLiquidityUtils } from './liquidity';
+import { MathUtil } from '../common/math';
+
+function normalizeAddress(address: string, group: number): string {
+  return isGrouplessAddressWithoutGroupIndex(address) ? `${address}:${group}` : address;
+}
+
+export class PoolUtils {
+  static getPositionId(
+    poolAddress: string,
+    owner: string,
+    tickLower: bigint,
+    tickUpper: bigint,
+  ): string {
+    const group = groupOfAddress(poolAddress);
+    const poolId = binToHex(contractIdFromAddress(poolAddress));
+    const normalizedOwner = normalizeAddress(owner, group);
+    const path = encodePrimitiveValues([
+      { type: 'U256', value: Pool.consts.PathPrefixes.Position },
+      { type: 'Address', value: normalizedOwner },
+      { type: 'I256', value: tickLower },
+      { type: 'I256', value: tickUpper },
+    ]);
+    return subContractId(poolId, binToHex(path), group);
+  }
+
+  static computeSwapStep(
+    sqrtPriceX96: bigint,
+    sqrtPriceTargetX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    feePips: bigint,
+  ): [bigint, bigint, bigint, bigint] {
+    const zeroForOne = sqrtPriceX96 < sqrtPriceTargetX96;
+    const exactIn = amount > 0n;
+    let amountIn = 0n;
+    let amountOut = 0n;
+    let feeAmount = 0n;
+    let sqrtPriceNextX96 = 0n;
+    if (exactIn) {
+      amountIn = -ClmmLiquidityUtils.getAmountDelta(
+        sqrtPriceX96,
+        sqrtPriceTargetX96,
+        -liquidity,
+        zeroForOne,
+      );
+      const amountRemainingLessFee = MathUtil.divFloor(
+        amount * (Pool.consts.MAX_PIPS - feePips),
+        Pool.consts.MAX_PIPS,
+      );
+      const sqrtPriceRealTargetX96 = TickUtils.getNextSqrtPrice(
+        sqrtPriceX96,
+        liquidity,
+        amountRemainingLessFee,
+        zeroForOne,
+      );
+      sqrtPriceNextX96 =
+        amountRemainingLessFee >= amountIn ? sqrtPriceTargetX96 : sqrtPriceRealTargetX96;
+    } else {
+      amountOut = ClmmLiquidityUtils.getAmountDelta(
+        sqrtPriceTargetX96,
+        sqrtPriceX96,
+        liquidity,
+        zeroForOne,
+      );
+      const sqrtPriceRealTargetX96 = TickUtils.getNextSqrtPrice(
+        sqrtPriceX96,
+        liquidity,
+        amount,
+        zeroForOne,
+      );
+      sqrtPriceNextX96 = -amount >= amountOut ? sqrtPriceTargetX96 : sqrtPriceRealTargetX96;
+    }
+    const max = sqrtPriceTargetX96 == sqrtPriceNextX96;
+    if (zeroForOne) {
+      const amountIn2 = -ClmmLiquidityUtils.getAmountDelta(
+        sqrtPriceNextX96,
+        sqrtPriceX96,
+        -liquidity,
+        zeroForOne,
+      );
+      const amountOut2 = ClmmLiquidityUtils.getAmountDelta(
+        sqrtPriceNextX96,
+        sqrtPriceX96,
+        liquidity,
+        zeroForOne,
+      );
+      amountIn = max && exactIn ? amountIn : amountIn2;
+      amountOut = max && !exactIn ? amountOut : amountOut2;
+    } else {
+      const amountIn2 = -ClmmLiquidityUtils.getAmountDelta(
+        sqrtPriceX96,
+        sqrtPriceNextX96,
+        -liquidity,
+        zeroForOne,
+      );
+      const amountOut2 = ClmmLiquidityUtils.getAmountDelta(
+        sqrtPriceX96,
+        sqrtPriceNextX96,
+        liquidity,
+        zeroForOne,
+      );
+      amountIn = max && exactIn ? amountIn : amountIn2;
+      amountOut = max && !exactIn ? amountOut : amountOut2;
+    }
+    if (!exactIn && amount > -amountOut) amountOut = -amount;
+
+    if (exactIn && sqrtPriceNextX96 != sqrtPriceTargetX96) {
+      feeAmount = amount - amountIn;
+    } else {
+      feeAmount = MathUtil.divFloor(amountIn * feePips, Pool.consts.MAX_PIPS - feePips);
+    }
+
+    return [sqrtPriceNextX96, amountIn, amountOut, feeAmount];
+  }
+
+  static offlineSwap(
+    liqDist: LiquidityDistribution,
+    amountSpecified: bigint,
+    sqrtPriceX96: bigint,
+  ): bigint {
+    const exactIn = amountSpecified > 0n;
+    let amountCalculated = 0n;
+    for (const row of liqDist.rows) {
+      const [sqrtPriceNextX96, amountIn, amountOut, feeAmount] = this.computeSwapStep(
+        sqrtPriceX96,
+        row.sqrtPriceX96,
+        liqDist.liquidity,
+        amountSpecified,
+        liqDist.fee,
+      );
+      if (exactIn) {
+        amountSpecified -= amountIn + feeAmount;
+        amountCalculated -= amountOut;
+      } else {
+        amountSpecified += amountOut;
+        amountCalculated += amountIn + feeAmount;
+      }
+      sqrtPriceX96 = sqrtPriceNextX96;
+    }
+    return amountCalculated;
+  }
+}

package/src/clmm/tick.ts

@@ -0,0 +1,335 @@
+import {
+  MAX_SQRT_RATIO,
+  MAX_TICK,
+  MIN_SQRT_RATIO,
+  MIN_TICK,
+  Q128,
+  Q32,
+  Q64,
+  Q96,
+} from 'clmm/artifacts/ts/constants';
+import { U256_MAX } from './constants';
+import Decimal from 'decimal.js';
+import { MathUtil } from '../common/math';
+import { BPS } from '../common/constants';
+import type { TokenInfo } from '@alephium/token-list';
+
+export class TickUtils {
+  static getSqrtRatioAtTick(tick: bigint): bigint {
+    const absTick = tick < 0n ? -tick : tick;
+    if (absTick > MAX_TICK) {
+      throw new Error(`TickOutOfBounds: ${tick}`);
+    }
+
+    let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : Q128;
+
+    if ((absTick & 0x2n) !== 0n) ratio = (ratio * 0xfff97272373d413259a46990580e213an) >> 128n;
+    if ((absTick & 0x4n) !== 0n) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn) >> 128n;
+    if ((absTick & 0x8n) !== 0n) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n) >> 128n;
+    if ((absTick & 0x10n) !== 0n) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644n) >> 128n;
+    if ((absTick & 0x20n) !== 0n) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0n) >> 128n;
+    if ((absTick & 0x40n) !== 0n) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861n) >> 128n;
+    if ((absTick & 0x80n) !== 0n) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053n) >> 128n;
+    if ((absTick & 0x100n) !== 0n) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n) >> 128n;
+    if ((absTick & 0x200n) !== 0n) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54n) >> 128n;
+    if ((absTick & 0x400n) !== 0n) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3n) >> 128n;
+    if ((absTick & 0x800n) !== 0n) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n) >> 128n;
+    if ((absTick & 0x1000n) !== 0n) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n) >> 128n;
+    if ((absTick & 0x2000n) !== 0n) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n) >> 128n;
+    if ((absTick & 0x4000n) !== 0n) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7n) >> 128n;
+    if ((absTick & 0x8000n) !== 0n) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6n) >> 128n;
+    if ((absTick & 0x10000n) !== 0n) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n) >> 128n;
+    if ((absTick & 0x20000n) !== 0n) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604n) >> 128n;
+    if ((absTick & 0x40000n) !== 0n) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98n) >> 128n;
+    if ((absTick & 0x80000n) !== 0n) ratio = (ratio * 0x48a170391f7dc42444e8fa2n) >> 128n;
+
+    if (tick > 0n) {
+      ratio = U256_MAX / ratio;
+    }
+
+    return ratio >> 32n;
+  }
+
+  static getTickAtSqrtRatio(sqrtPriceX96: bigint): bigint {
+    if (sqrtPriceX96 < MIN_SQRT_RATIO || sqrtPriceX96 >= MAX_SQRT_RATIO) {
+      throw new Error('SqrtPriceX96OutOfBounds');
+    }
+
+    const ratio = sqrtPriceX96 << 32n;
+    let r = ratio;
+    let msb = 0n;
+
+    if (r > Q128 - 1n) {
+      msb |= 0x80n;
+      r >>= 0x80n;
+    }
+    if (r > Q64 - 1n) {
+      msb |= 0x40n;
+      r >>= 0x40n;
+    }
+    if (r > Q32 - 1n) {
+      msb |= 0x20n;
+      r >>= 0x20n;
+    }
+    if (r > 0xffffn) {
+      msb |= 0x10n;
+      r >>= 0x10n;
+    }
+    if (r > 0xffn) {
+      msb |= 0x8n;
+      r >>= 0x8n;
+    }
+    if (r > 0xfn) {
+      msb |= 0x4n;
+      r >>= 0x4n;
+    }
+    if (r > 0x3n) {
+      msb |= 0x2n;
+      r >>= 0x2n;
+    }
+    if (r > 0x1n) {
+      msb |= 0x1n;
+    }
+
+    if (msb >= 128n) {
+      r = ratio >> (msb - 127n);
+    } else {
+      r = ratio << (127n - msb);
+    }
+
+    let log_2 = (msb - 128n) << 64n;
+
+    for (let i = 63n; i >= 50n; i--) {
+      r = (r * r) >> 127n;
+      const f = r >> 128n;
+      log_2 |= f << i;
+      r >>= f;
+    }
+
+    const log_sqrt10001 = log_2 * 255738958999603826347141n;
+
+    const tickLow = (log_sqrt10001 - 3402992956809132418596140100660247210n) >> 128n;
+    const tickHi = (log_sqrt10001 + 291339464771989622907027621153398088495n) >> 128n;
+
+    if (tickLow === tickHi) {
+      return tickLow;
+    } else {
+      if (this.getSqrtRatioAtTick(tickHi) <= sqrtPriceX96) {
+        return tickHi;
+      } else {
+        return tickLow;
+      }
+    }
+  }
+
+  static priceToSqrtPriceX96(
+    price: Decimal.Value,
+    token0Decimal: number,
+    token1Decimal: number,
+  ): bigint {
+    const priceDecimal = new Decimal(price);
+    if (!priceDecimal.isFinite() || priceDecimal.lte(0)) {
+      throw new Error('Invalid price input');
+    }
+
+    const token0Unit = 10n ** BigInt(token0Decimal);
+    const token1Amount = BigInt(
+      priceDecimal
+        .mul(10n ** BigInt(token1Decimal))
+        .floor()
+        .toFixed(),
+    );
+    return this.priceSqrt(token1Amount, token0Unit);
+  }
+
+  static sqrtPriceX96ToPrice(
+    sqrtPriceX96: bigint,
+    token0Decimal: number,
+    token1Decimal: number,
+  ): number {
+    if (sqrtPriceX96 < 0n) {
+      throw new Error('Invalid sqrtPriceX96');
+    }
+
+    const sqrtPriceDecimal = new Decimal(sqrtPriceX96.toString());
+    const q96Decimal = new Decimal(Q96.toString());
+    let priceDecimal = sqrtPriceDecimal.div(q96Decimal).pow(2);
+
+    const exponentDiff = token0Decimal - token1Decimal;
+    if (exponentDiff !== 0) {
+      const factor = new Decimal(10).pow(Math.abs(exponentDiff));
+      priceDecimal = exponentDiff > 0 ? priceDecimal.mul(factor) : priceDecimal.div(factor);
+    }
+
+    if (!priceDecimal.isFinite()) {
+      throw new Error('Price overflow');
+    }
+
+    return priceDecimal.toNumber();
+  }
+
+  static getAlignedTick(
+    price: number,
+    token0Decimal: number,
+    token1Decimal: number,
+    tickSpacing: bigint,
+  ): bigint {
+    const sqrtPriceX96 = this.priceToSqrtPriceX96(price, token0Decimal, token1Decimal);
+    const tick0 = this.getTickAtSqrtRatio(sqrtPriceX96);
+
+    return MathUtil.alphCeil(tick0, tickSpacing) * tickSpacing;
+  }
+
+  static getNextTick(
+    tick: bigint,
+    tickSpacing: bigint,
+    tokenBase: TokenInfo,
+    tokenQuote: TokenInfo,
+    baseIn: boolean,
+    isAdd: boolean,
+  ): bigint {
+    const reverse = tokenBase.id > tokenQuote.id == baseIn;
+    const delta = isAdd == reverse ? tickSpacing : -tickSpacing;
+    return tick + delta;
+  }
+
+  static getAlignedPrice(
+    priceIn: number,
+    tokenBase: TokenInfo,
+    tokenQuote: TokenInfo,
+    tickSpacing: bigint,
+    baseIn: boolean,
+  ): { tick: bigint; price: number } {
+    const reverse = tokenBase.id > tokenQuote.id == baseIn;
+    const [token0, token1] = reverse ? [tokenQuote, tokenBase] : [tokenBase, tokenQuote];
+
+    const rawPrice = reverse ? 1 / priceIn : priceIn;
+    const tick = this.getAlignedTick(rawPrice, token0.decimals, token1.decimals, tickSpacing);
+    return this.getPriceFromTick(tick, tokenBase, tokenQuote, baseIn);
+  }
+
+  static getPriceFromTick(
+    tick: bigint,
+    tokenBase: TokenInfo,
+    tokenQuote: TokenInfo,
+    baseIn: boolean,
+  ): { tick: bigint; price: number } {
+    const reverse = tokenBase.id > tokenQuote.id == baseIn;
+    const [token0, token1] = reverse ? [tokenQuote, tokenBase] : [tokenBase, tokenQuote];
+
+    const sqrtPriceX96 = this.getSqrtRatioAtTick(tick);
+    const alignedPrice = this.sqrtPriceX96ToPrice(sqrtPriceX96, token0.decimals, token1.decimals);
+    const price = reverse ? 1 / alignedPrice : alignedPrice;
+    return { tick, price };
+  }
+
+  static getMinPriceFromTick(
+    tokenBase: TokenInfo,
+    tokenQuote: TokenInfo,
+    tickSpacing: bigint,
+    baseIn: boolean,
+  ): { tick: bigint; price: number } {
+    const reverse = tokenBase.id > tokenQuote.id == baseIn;
+    const rawTick = reverse ? MAX_TICK : MIN_TICK;
+    const tick = (rawTick / tickSpacing) * tickSpacing;
+    return this.getPriceFromTick(tick, tokenBase, tokenQuote, baseIn);
+  }
+
+  static getMaxPriceFromTick(
+    tokenBase: TokenInfo,
+    tokenQuote: TokenInfo,
+    tickSpacing: bigint,
+    baseIn: boolean,
+  ): { tick: bigint; price: number } {
+    const reverse = tokenBase.id > tokenQuote.id == baseIn;
+    const rawTick = reverse ? MIN_TICK : MAX_TICK;
+    const tick = (rawTick / tickSpacing) * tickSpacing;
+    return this.getPriceFromTick(tick, tokenBase, tokenQuote, baseIn);
+  }
+
+  static getNextSqrtPrice(
+    sqrtPriceX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    if (zeroForOne) {
+      return this.getNextSqrtPriceFromAmount0(sqrtPriceX96, liquidity, amount);
+    } else {
+      return this.getNextSqrtPriceFromAmount1(sqrtPriceX96, liquidity, amount);
+    }
+  }
+
+  static getNextSqrtPriceFromAmount0(
+    sqrtPriceX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+  ): bigint {
+    const numerator1 = liquidity * Q96;
+    const product = amount * sqrtPriceX96;
+    if (product >= numerator1) {
+      throw new Error('Amount0 exceeds available liquidity for the swap');
+    }
+    const denominator = numerator1 - product;
+    return MathUtil.alphDiv(numerator1 * sqrtPriceX96, denominator);
+  }
+
+  static getNextSqrtPriceFromAmount1(
+    sqrtPriceX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+  ): bigint {
+    const quotient = MathUtil.alphDiv(amount * Q96, liquidity);
+    return sqrtPriceX96 + quotient;
+  }
+
+  static getSqrtPriceLimitX96(sqrtPriceX96: bigint, slippage: bigint, zeroForOne: boolean): bigint {
+    if (slippage <= 0n || slippage >= BPS) {
+      throw new Error('slippageBps must be in (0, 10000)');
+    }
+
+    const [minBound, maxBound] = this.getSqrtPriceX96Bounds(sqrtPriceX96, slippage);
+    let limit = zeroForOne ? minBound : maxBound;
+
+    if (zeroForOne) {
+      if (limit >= sqrtPriceX96) limit = sqrtPriceX96 - 1n;
+      if (limit <= MIN_SQRT_RATIO) limit = MIN_SQRT_RATIO + 1n;
+    } else {
+      if (limit <= sqrtPriceX96) limit = sqrtPriceX96 + 1n;
+      if (limit >= MAX_SQRT_RATIO) limit = MAX_SQRT_RATIO - 1n;
+    }
+    return limit;
+  }
+
+  // Compute slippage bounds for a given sqrt price
+  // The slippage is in bps.
+  // Returns [minSqrtPriceX96, maxSqrtPriceX96], where:
+  //   min = floor(sqrtPriceX96 * sqrt(1 - slippage))
+  //   max = ceil(sqrtPriceX96 * sqrt(1 + slippage))
+  // `slippage` is bps: e.g., 100 for 1%, 30 for 0.3%
+  static getSqrtPriceX96Bounds(sqrtPriceX96: bigint, slippage: bigint): [bigint, bigint] {
+    if (slippage < 0n || slippage >= BPS) {
+      throw new Error('Invalid slippageBps; must be in [0, 10000)');
+    }
+    const numMinus = (BPS - slippage) * Q128;
+    const numPlus = (BPS + slippage) * Q128;
+    const den = BPS * Q128;
+    const factorMinusQ96 = MathUtil.mulDivFloor(
+      MathUtil.sqrt(numMinus) * Q96,
+      1n,
+      MathUtil.sqrt(den),
+    );
+    const factorPlusQ96 = MathUtil.mulDivFloor(
+      MathUtil.sqrt(numPlus) * Q96,
+      1n,
+      MathUtil.sqrt(den),
+    );
+    const minSqrtPriceX96 = MathUtil.mulDivFloor(sqrtPriceX96, factorMinusQ96, Q96);
+    const maxSqrtPriceX96 = (sqrtPriceX96 * factorPlusQ96 + Q96 - 1n) / Q96;
+    return [minSqrtPriceX96, maxSqrtPriceX96];
+  }
+
+  private static priceSqrt(r1: bigint, r0: bigint): bigint {
+    return MathUtil.sqrt(MathUtil.divFloor(r1 * Q96 * Q96, r0));
+  }
+}