@ekubo/sdk 0.0.8-alpha.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./math";

package/dist/index.js

@@ -0,0 +1,849 @@
+// src/math/constants.ts
+var MAX_U256 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
+var MAX_U128 = 0xffffffffffffffffffffffffffffffffn;
+
+// src/math/delta.ts
+function amount0Delta(sqrtRatioA, sqrtRatioB, liquidity, roundUp) {
+  if (liquidity === 0n || sqrtRatioA === sqrtRatioB)
+    return 0n;
+  const [lower, upper] = sqrtRatioA < sqrtRatioB ? [sqrtRatioA, sqrtRatioB] : [sqrtRatioB, sqrtRatioA];
+  const numerator = (liquidity << 128n) * (upper - lower);
+  let result0 = numerator / upper;
+  if (roundUp && numerator % upper !== 0n) {
+    result0++;
+  }
+  if (result0 > MAX_U256) {
+    throw new Error("AMOUNT0_DELTA_OVERFLOW_U256");
+  }
+  let result = result0 / lower;
+  if (roundUp && result % lower !== 0n) {
+    result++;
+  }
+  if (result > MAX_U128) {
+    throw new Error("AMOUNT0_DELTA_OVERFLOW_U128");
+  }
+  return result;
+}
+var TWO_POW_128 = 0x100000000000000000000000000000000n;
+function amount1Delta(sqrtRatioA, sqrtRatioB, liquidity, roundUp) {
+  if (liquidity === 0n || sqrtRatioA === sqrtRatioB)
+    return 0n;
+  const [lower, upper] = sqrtRatioA < sqrtRatioB ? [sqrtRatioA, sqrtRatioB] : [sqrtRatioB, sqrtRatioA];
+  const result = liquidity * (upper - lower);
+  if (result > MAX_U256) {
+    throw new Error("AMOUNT1_DELTA_OVERFLOW_U256");
+  }
+  if (roundUp && result % TWO_POW_128 !== 0n) {
+    const delta = result / TWO_POW_128 + 1n;
+    if (delta > MAX_U128) {
+      throw new Error("AMOUNT1_DELTA_OVERFLOW_U128");
+    }
+    return delta;
+  } else {
+    return result >> 128n;
+  }
+}
+
+// src/math/msb.ts
+var MAX = 1n << 128n;
+function msb(x) {
+  if (x >= MAX) {
+    throw new Error("x too large");
+  }
+  if (x <= 0n) {
+    throw new Error("x must be positive");
+  }
+  let res = 0;
+  if (x >= 0x10000000000000000n) {
+    x = x >> 64n;
+    res += 64;
+  }
+  if (x >= 0x100000000n) {
+    x = x >> 32n;
+    res += 32;
+  }
+  if (x >= 0x10000n) {
+    x = x >> 16n;
+    res += 16;
+  }
+  if (x >= 0x100n) {
+    x = x >> 8n;
+    res += 8;
+  }
+  if (x >= 0x10n) {
+    x = x >> 4n;
+    res += 4;
+  }
+  if (x >= 0x04n) {
+    x = x >> 2n;
+    res += 2;
+  }
+  if (x >= 0x02n) {
+    res += 1;
+  }
+  return res;
+}
+
+// src/math/price.ts
+var toBig = (value, name) => {
+  if (typeof value === "bigint")
+    return value;
+  try {
+    return BigInt(value);
+  } catch (err) {
+    const printed = value === null || value === undefined ? String(value) : value.toString();
+    const ctor = value && typeof value === "object" && "constructor" in value ? value.constructor.name : undefined;
+    throw new TypeError(`${name} must be bigint-compatible, received ${printed} (type ${typeof value}${ctor ? `, ctor ${ctor}` : ""})`);
+  }
+};
+function nextSqrtRatioFromAmount0(sqrtRatio, liquidity, amount0) {
+  const sqrtRatioFixed = toBig(sqrtRatio, "sqrtRatio");
+  const liquidityFixed = toBig(liquidity, "liquidity");
+  const amount0Fixed = toBig(amount0, "amount0");
+  if (amount0Fixed === 0n)
+    return sqrtRatioFixed;
+  if (liquidityFixed === 0n)
+    throw new Error("NO_LIQUIDITY");
+  const numerator1 = liquidityFixed << 128n;
+  if (amount0Fixed < 0n) {
+    const product = amount0Fixed * -1n * sqrtRatioFixed;
+    if (product >= MAX_U256) {
+      return null;
+    }
+    const denominator = numerator1 - product;
+    if (denominator < 0n) {
+      return null;
+    }
+    const num = numerator1 * sqrtRatioFixed;
+    const result = num / denominator + (num % denominator === 0n ? 0n : 1n);
+    if (result > MAX_U256) {
+      return null;
+    }
+    return result;
+  } else {
+    const denomP1 = numerator1 / sqrtRatioFixed;
+    const denom = denomP1 + amount0Fixed;
+    const quotient = numerator1 / denom;
+    const remainder = numerator1 % denom;
+    if (remainder === 0n)
+      return quotient;
+    const sum = quotient + 1n;
+    if (sum > MAX_U256)
+      return null;
+    return sum;
+  }
+}
+function nextSqrtRatioFromAmount1(sqrtRatio, liquidity, amount1) {
+  const sqrtRatioFixed = toBig(sqrtRatio, "sqrtRatio");
+  const liquidityFixed = toBig(liquidity, "liquidity");
+  const amount1Fixed = toBig(amount1, "amount1");
+  if (amount1Fixed === 0n)
+    return sqrtRatioFixed;
+  if (liquidityFixed === 0n)
+    throw new Error("NO_LIQUIDITY");
+  const amountShifted = amount1Fixed << 128n;
+  const quotient = amountShifted / liquidityFixed;
+  const remainder = amountShifted % liquidityFixed;
+  if (amount1Fixed < 0n) {
+    const res = sqrtRatioFixed + quotient;
+    if (res < 0n) {
+      return null;
+    }
+    if (remainder === 0n) {
+      return res;
+    } else {
+      if (res != 0n) {
+        return res - 1n;
+      } else {
+        return null;
+      }
+    }
+  } else {
+    const res = sqrtRatioFixed + quotient;
+    if (res > MAX_U256) {
+      return null;
+    } else {
+      return res;
+    }
+  }
+}
+
+// src/math/swap.ts
+function isPriceIncreasing(amount, isToken1) {
+  return amount < 0n !== isToken1;
+}
+function noOp(sqrtRatioNext) {
+  return {
+    consumedAmount: 0n,
+    calculatedAmount: 0n,
+    sqrtRatioNext,
+    feeAmount: 0n
+  };
+}
+function amountBeforeFee(amount, fee) {
+  if (fee === 0n)
+    return amount;
+  const num = amount << 128n;
+  const denom = (1n << 128n) - fee;
+  const val = num / denom;
+  const result = val + (num % denom !== 0n ? 1n : 0n);
+  if (result > MAX_U128)
+    throw new Error("AMOUNT_BEFORE_FEE_OVERFLOW");
+  return result;
+}
+function computeFee(amount, fee) {
+  const num = amount * fee;
+  const denom = 2n ** 128n;
+  if (num % denom !== 0n) {
+    return num / denom + 1n;
+  } else {
+    return num / denom;
+  }
+}
+function computeStep({
+  sqrtRatio,
+  liquidity,
+  sqrtRatioLimit,
+  amount,
+  isToken1,
+  fee
+}) {
+  if (amount === 0n || sqrtRatio === sqrtRatioLimit) {
+    return noOp(sqrtRatio);
+  }
+  const increasing = isPriceIncreasing(amount, isToken1);
+  if (sqrtRatioLimit < sqrtRatio === increasing) {
+    throw new Error("computeStep: wrong direction");
+  }
+  if (liquidity === 0n) {
+    return noOp(sqrtRatioLimit);
+  }
+  let priceImpactAmount;
+  if (amount < 0n) {
+    priceImpactAmount = amount;
+  } else {
+    priceImpactAmount = amount - computeFee(amount, fee);
+  }
+  let sqrtRatioNextFromAmount;
+  if (isToken1) {
+    sqrtRatioNextFromAmount = nextSqrtRatioFromAmount1(sqrtRatio, liquidity, priceImpactAmount);
+  } else {
+    sqrtRatioNextFromAmount = nextSqrtRatioFromAmount0(sqrtRatio, liquidity, priceImpactAmount);
+  }
+  if (sqrtRatioNextFromAmount === null || sqrtRatioNextFromAmount > sqrtRatioLimit === increasing) {
+    const [specifiedAmountDelta, calculatedAmountDelta] = isToken1 ? [
+      amount1Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount >= 0n) * (amount < 0n ? -1n : 1n),
+      amount0Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount < 0n)
+    ] : [
+      amount0Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount >= 0n) * (amount < 0n ? -1n : 1n),
+      amount1Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount < 0n)
+    ];
+    if (amount < 0n) {
+      const beforeFee = amountBeforeFee(calculatedAmountDelta, fee);
+      return {
+        consumedAmount: specifiedAmountDelta,
+        calculatedAmount: beforeFee,
+        feeAmount: beforeFee - calculatedAmountDelta,
+        sqrtRatioNext: sqrtRatioLimit
+      };
+    } else {
+      const beforeFee = amountBeforeFee(specifiedAmountDelta, fee);
+      return {
+        consumedAmount: beforeFee,
+        calculatedAmount: calculatedAmountDelta,
+        feeAmount: beforeFee - specifiedAmountDelta,
+        sqrtRatioNext: sqrtRatioLimit
+      };
+    }
+  }
+  if (sqrtRatioNextFromAmount === sqrtRatio) {
+    return {
+      consumedAmount: amount,
+      calculatedAmount: 0n,
+      feeAmount: amount,
+      sqrtRatioNext: sqrtRatio
+    };
+  }
+  const calculatedAmountExcludingFee = isToken1 ? amount0Delta(sqrtRatioNextFromAmount, sqrtRatio, liquidity, amount < 0n) : amount1Delta(sqrtRatioNextFromAmount, sqrtRatio, liquidity, amount < 0n);
+  if (amount < 0n) {
+    const includingFee = amountBeforeFee(calculatedAmountExcludingFee, fee);
+    return {
+      consumedAmount: amount,
+      calculatedAmount: includingFee,
+      sqrtRatioNext: sqrtRatioNextFromAmount,
+      feeAmount: includingFee - calculatedAmountExcludingFee
+    };
+  } else {
+    return {
+      consumedAmount: amount,
+      calculatedAmount: calculatedAmountExcludingFee,
+      sqrtRatioNext: sqrtRatioNextFromAmount,
+      feeAmount: amount - priceImpactAmount
+    };
+  }
+}
+
+// src/math/tick.ts
+var EVM_MIN_TICK = -88722835;
+var EVM_MAX_TICK = 88722835;
+var EVM_MAX_TICK_SPACING = 698605;
+var EVM_MIN_SQRT_RATIO = 18447191164202170524n;
+var EVM_MAX_SQRT_RATIO = 6276949602062853172742588666607187473671941430179807625216n;
+var STARKNET_MIN_TICK = -88722883;
+var STARKNET_MAX_TICK = 88722883;
+var STARKNET_MAX_SQRT_RATIO = 6277100250585753475930931601400621808602321654880405518632n;
+var STARKNET_MIN_SQRT_RATIO = 18446748437148339061n;
+var STARKNET_MAX_TICK_SPACING = 354892;
+var CHAIN_PARAMS = {
+  evm: {
+    MIN_TICK: EVM_MIN_TICK,
+    MAX_TICK: EVM_MAX_TICK,
+    MIN_SQRT_RATIO: EVM_MIN_SQRT_RATIO,
+    MAX_SQRT_RATIO: EVM_MAX_SQRT_RATIO,
+    MAX_TICK_SPACING: EVM_MAX_TICK_SPACING
+  },
+  starknet: {
+    MIN_TICK: STARKNET_MIN_TICK,
+    MAX_TICK: STARKNET_MAX_TICK,
+    MIN_SQRT_RATIO: STARKNET_MIN_SQRT_RATIO,
+    MAX_SQRT_RATIO: STARKNET_MAX_SQRT_RATIO,
+    MAX_TICK_SPACING: STARKNET_MAX_TICK_SPACING
+  }
+};
+var SQRT_RATIO_FLOAT_BITMASK = 0xc00000000000000000000000n;
+var SQRT_RATIO_FLOAT_NOT_BITMASK = 0x3fffffffffffffffffffffffn;
+var SQRT_RATIO_FLOAT_EXPONENTS = [0n, 32n, 64n, 96n];
+var TWO_POW_160 = 1n << 160n;
+var TWO_POW_1282 = 1n << 128n;
+var TWO_POW_96 = 1n << 96n;
+function toSqrtRatio(tick, chain) {
+  const MIN_TICK = CHAIN_PARAMS[chain].MIN_TICK;
+  const MAX_TICK = CHAIN_PARAMS[chain].MAX_TICK;
+  if (tick < MIN_TICK || tick > MAX_TICK)
+    throw new Error(`Invalid tick: ${tick}`);
+  let sign = tick < 0;
+  tick = Math.abs(tick);
+  let ratio = 0x100000000000000000000000000000000n;
+  if ((tick & 1) != 0) {
+    ratio = 0xfffff79c8499329c7cbb2510d893283bn;
+  }
+  if ((tick & 2) != 0) {
+    ratio = ratio * 0xffffef390978c398134b4ff3764fe410n >> 128n;
+  }
+  if ((tick & 4) != 0) {
+    ratio = ratio * 0xffffde72140b00a354bd3dc828e976c9n >> 128n;
+  }
+  if ((tick & 8) != 0) {
+    ratio = ratio * 0xffffbce42c7be6c998ad6318193c0b18n >> 128n;
+  }
+  if ((tick & 16) != 0) {
+    ratio = ratio * 0xffff79c86a8f6150a32d9778eceef97cn >> 128n;
+  }
+  if ((tick & 32) != 0) {
+    ratio = ratio * 0xfffef3911b7cff24ba1b3dbb5f8f5974n >> 128n;
+  }
+  if ((tick & 64) != 0) {
+    ratio = ratio * 0xfffde72350725cc4ea8feece3b5f13c8n >> 128n;
+  }
+  if ((tick & 128) != 0) {
+    ratio = ratio * 0xfffbce4b06c196e9247ac87695d53c60n >> 128n;
+  }
+  if ((tick & 256) != 0) {
+    ratio = ratio * 0xfff79ca7a4d1bf1ee8556cea23cdbaa5n >> 128n;
+  }
+  if ((tick & 512) != 0) {
+    ratio = ratio * 0xffef3995a5b6a6267530f207142a5764n >> 128n;
+  }
+  if ((tick & 1024) != 0) {
+    ratio = ratio * 0xffde7444b28145508125d10077ba83b8n >> 128n;
+  }
+  if ((tick & 2048) != 0) {
+    ratio = ratio * 0xffbceceeb791747f10df216f2e53ec57n >> 128n;
+  }
+  if ((tick & 4096) != 0) {
+    ratio = ratio * 0xff79eb706b9a64c6431d76e63531e929n >> 128n;
+  }
+  if ((tick & 8192) != 0) {
+    ratio = ratio * 0xfef41d1a5f2ae3a20676bec6f7f9459an >> 128n;
+  }
+  if ((tick & 16384) != 0) {
+    ratio = ratio * 0xfde95287d26d81bea159c37073122c73n >> 128n;
+  }
+  if ((tick & 32768) != 0) {
+    ratio = ratio * 0xfbd701c7cbc4c8a6bb81efd232d1e4e7n >> 128n;
+  }
+  if ((tick & 65536) != 0) {
+    ratio = ratio * 0xf7bf5211c72f5185f372aeb1d48f937en >> 128n;
+  }
+  if ((tick & 131072) != 0) {
+    ratio = ratio * 0xefc2bf59df33ecc28125cf78ec4f167fn >> 128n;
+  }
+  if ((tick & 262144) != 0) {
+    ratio = ratio * 0xe08d35706200796273f0b3a981d90cfdn >> 128n;
+  }
+  if ((tick & 524288) != 0) {
+    ratio = ratio * 0xc4f76b68947482dc198a48a54348c4edn >> 128n;
+  }
+  if ((tick & 1048576) != 0) {
+    ratio = ratio * 0x978bcb9894317807e5fa4498eee7c0fan >> 128n;
+  }
+  if ((tick & 2097152) != 0) {
+    ratio = ratio * 0x59b63684b86e9f486ec54727371ba6can >> 128n;
+  }
+  if ((tick & 4194304) != 0) {
+    ratio = ratio * 0x1f703399d88f6aa83a28b22d4a1f56e3n >> 128n;
+  }
+  if ((tick & 8388608) != 0) {
+    ratio = ratio * 0x3dc5dac7376e20fc8679758d1bcdcfcn >> 128n;
+  }
+  if ((tick & 16777216) != 0) {
+    ratio = ratio * 0xee7e32d61fdb0a5e622b820f681d0n >> 128n;
+  }
+  if ((tick & 33554432) != 0) {
+    ratio = ratio * 0xde2ee4bc381afa7089aa84bb66n >> 128n;
+  }
+  if ((tick & 67108864) != 0) {
+    ratio = ratio * 0xc0d55d4d7152c25fb139n >> 128n;
+  }
+  if (tick > 0 && !sign) {
+    ratio = MAX_U256 / ratio;
+  }
+  ratio = chain === "evm" ? ratio >= TWO_POW_160 ? ratio >> 98n << 98n : ratio >= TWO_POW_1282 ? ratio >> 66n << 66n : ratio >= TWO_POW_96 ? ratio >> 34n << 34n : ratio >> 2n << 2n : ratio;
+  return ratio;
+}
+var logBase = Math.log(1.0000005);
+function floatSqrtRatioToFixed(sqrtRatioFloat) {
+  const exponent = (sqrtRatioFloat & SQRT_RATIO_FLOAT_BITMASK) >> 89n;
+  const mantissa = sqrtRatioFloat & SQRT_RATIO_FLOAT_NOT_BITMASK;
+  return mantissa << 2n + exponent;
+}
+function fixedSqrtRatioToFloat(sqrtRatio) {
+  if (sqrtRatio < 0n)
+    throw new Error("Sqrt ratio must be non-negative");
+  for (const exponent of SQRT_RATIO_FLOAT_EXPONENTS) {
+    const shift = 2n + exponent;
+    const mantissa = sqrtRatio >> shift;
+    if (mantissa <= SQRT_RATIO_FLOAT_NOT_BITMASK) {
+      return mantissa | exponent << 89n;
+    }
+  }
+  throw new Error("Sqrt ratio too large to encode as float");
+}
+
+// src/math/twamm.ts
+var EXPONENT_LIMIT = 1623313478486440542208n;
+function calculateNextSqrtRatio(sqrtRatio, liquidity, token0SaleRate, token1SaleRate, timeElapsed, fee) {
+  let sqrtSaleRatio = sqrt((token1SaleRate << 128n) / token0SaleRate) << 64n;
+  if (liquidity === 0n) {
+    return sqrtSaleRatio;
+  }
+  const sRate = sqrt(token1SaleRate * token0SaleRate) * ((1n << 128n) - fee) / (1n << 128n);
+  const roundUp = sqrtRatio > sqrtSaleRatio;
+  const exponent = div(0x200000000n * timeElapsed * sRate, liquidity, roundUp);
+  if (exponent > EXPONENT_LIMIT) {
+    return sqrtSaleRatio;
+  }
+  const e = exp(exponent);
+  const [num, sign] = roundUp ? [sqrtRatio - sqrtSaleRatio, true] : [sqrtSaleRatio - sqrtRatio, false];
+  const c = div(num << 128n, sqrtSaleRatio + sqrtRatio, roundUp);
+  const [term1, term2] = [e - c, e + c];
+  const scale = sign ? div(term2 << 128n, term1, roundUp) : div(term1 << 128n, term2, roundUp);
+  return sqrtSaleRatio * scale >> 128n;
+}
+function div(x, y, round) {
+  const quotient = x / y;
+  const remainder = x % y;
+  return quotient + (remainder !== 0n && round ? 1n : 0n);
+}
+function exp(x) {
+  if (x >= 36893488147419103000) {
+    let half = exp(x / 2n);
+    return half * half >> 128n;
+  } else {
+    return expInner(x);
+  }
+}
+function expInner(x) {
+  if (x >= 0x20000000000000000n) {
+    throw new Error("Invalid input");
+  }
+  let ratio = 0x100000000000000000000000000000000n;
+  if ((x & 0x1n) != 0n) {
+    ratio = 0xffffffffffffffff0000000000000000n;
+  }
+  if ((x & 0x2n) != 0n) {
+    ratio = ratio * 0xfffffffffffffffe0000000000000002n >> 128n;
+  }
+  if ((x & 0x4n) != 0n) {
+    ratio = ratio * 0xfffffffffffffffc0000000000000008n >> 128n;
+  }
+  if ((x & 0x8n) != 0n) {
+    ratio = ratio * 0xfffffffffffffff80000000000000020n >> 128n;
+  }
+  if ((x & 0x10n) != 0n) {
+    ratio = ratio * 0xfffffffffffffff00000000000000080n >> 128n;
+  }
+  if ((x & 0x20n) != 0n) {
+    ratio = ratio * 0xffffffffffffffe00000000000000200n >> 128n;
+  }
+  if ((x & 0x40n) != 0n) {
+    ratio = ratio * 0xffffffffffffffc00000000000000800n >> 128n;
+  }
+  if ((x & 0x80n) != 0n) {
+    ratio = ratio * 0xffffffffffffff800000000000002000n >> 128n;
+  }
+  if ((x & 0x100n) != 0n) {
+    ratio = ratio * 0xffffffffffffff000000000000008000n >> 128n;
+  }
+  if ((x & 0x200n) != 0n) {
+    ratio = ratio * 0xfffffffffffffe000000000000020000n >> 128n;
+  }
+  if ((x & 0x400n) != 0n) {
+    ratio = ratio * 0xfffffffffffffc000000000000080000n >> 128n;
+  }
+  if ((x & 0x800n) != 0n) {
+    ratio = ratio * 0xfffffffffffff8000000000000200000n >> 128n;
+  }
+  if ((x & 0x1000n) != 0n) {
+    ratio = ratio * 0xfffffffffffff0000000000000800000n >> 128n;
+  }
+  if ((x & 0x2000n) != 0n) {
+    ratio = ratio * 0xffffffffffffe0000000000002000000n >> 128n;
+  }
+  if ((x & 0x4000n) != 0n) {
+    ratio = ratio * 0xffffffffffffc0000000000008000000n >> 128n;
+  }
+  if ((x & 0x8000n) != 0n) {
+    ratio = ratio * 0xffffffffffff80000000000020000000n >> 128n;
+  }
+  if ((x & 0x10000n) != 0n) {
+    ratio = ratio * 0xffffffffffff00000000000080000000n >> 128n;
+  }
+  if ((x & 0x20000n) != 0n) {
+    ratio = ratio * 0xfffffffffffe00000000000200000000n >> 128n;
+  }
+  if ((x & 0x40000n) != 0n) {
+    ratio = ratio * 0xfffffffffffc00000000000800000000n >> 128n;
+  }
+  if ((x & 0x80000n) != 0n) {
+    ratio = ratio * 0xfffffffffff800000000002000000000n >> 128n;
+  }
+  if ((x & 0x100000n) != 0n) {
+    ratio = ratio * 0xfffffffffff000000000008000000000n >> 128n;
+  }
+  if ((x & 0x200000n) != 0n) {
+    ratio = ratio * 0xffffffffffe000000000020000000000n >> 128n;
+  }
+  if ((x & 0x400000n) != 0n) {
+    ratio = ratio * 0xffffffffffc00000000007ffffffffffn >> 128n;
+  }
+  if ((x & 0x800000n) != 0n) {
+    ratio = ratio * 0xffffffffff80000000001ffffffffffbn >> 128n;
+  }
+  if ((x & 0x1000000n) != 0n) {
+    ratio = ratio * 0xffffffffff00000000007fffffffffd5n >> 128n;
+  }
+  if ((x & 0x2000000n) != 0n) {
+    ratio = ratio * 0xfffffffffe0000000001fffffffffeabn >> 128n;
+  }
+  if ((x & 0x4000000n) != 0n) {
+    ratio = ratio * 0xfffffffffc0000000007fffffffff555n >> 128n;
+  }
+  if ((x & 0x8000000n) != 0n) {
+    ratio = ratio * 0xfffffffff8000000001fffffffffaaabn >> 128n;
+  }
+  if ((x & 0x10000000n) != 0n) {
+    ratio = ratio * 0xfffffffff0000000007ffffffffd5555n >> 128n;
+  }
+  if ((x & 0x20000000n) != 0n) {
+    ratio = ratio * 0xffffffffe000000001ffffffffeaaaabn >> 128n;
+  }
+  if ((x & 0x40000000n) != 0n) {
+    ratio = ratio * 0xffffffffc000000007ffffffff555555n >> 128n;
+  }
+  if ((x & 0x80000000n) != 0n) {
+    ratio = ratio * 0xffffffff800000001ffffffffaaaaaabn >> 128n;
+  }
+  if ((x & 0x100000000n) != 0n) {
+    ratio = ratio * 0xffffffff000000007fffffffd5555555n >> 128n;
+  }
+  if ((x & 0x200000000n) != 0n) {
+    ratio = ratio * 0xfffffffe00000001fffffffeaaaaaaabn >> 128n;
+  }
+  if ((x & 0x400000000n) != 0n) {
+    ratio = ratio * 0xfffffffc00000007fffffff555555560n >> 128n;
+  }
+  if ((x & 0x800000000n) != 0n) {
+    ratio = ratio * 0xfffffff80000001fffffffaaaaaaab55n >> 128n;
+  }
+  if ((x & 0x1000000000n) != 0n) {
+    ratio = ratio * 0xfffffff00000007ffffffd5555556000n >> 128n;
+  }
+  if ((x & 0x2000000000n) != 0n) {
+    ratio = ratio * 0xffffffe0000001ffffffeaaaaaab5555n >> 128n;
+  }
+  if ((x & 0x4000000000n) != 0n) {
+    ratio = ratio * 0xffffffc0000007ffffff555555600000n >> 128n;
+  }
+  if ((x & 0x8000000000n) != 0n) {
+    ratio = ratio * 0xffffff8000001ffffffaaaaaab555555n >> 128n;
+  }
+  if ((x & 0x10000000000n) != 0n) {
+    ratio = ratio * 0xffffff0000007fffffd555555ffffffen >> 128n;
+  }
+  if ((x & 0x20000000000n) != 0n) {
+    ratio = ratio * 0xfffffe000001fffffeaaaaab55555511n >> 128n;
+  }
+  if ((x & 0x40000000000n) != 0n) {
+    ratio = ratio * 0xfffffc000007fffff555555ffffff777n >> 128n;
+  }
+  if ((x & 0x80000000000n) != 0n) {
+    ratio = ratio * 0xfffff800001fffffaaaaab5555544444n >> 128n;
+  }
+  if ((x & 0x100000000000n) != 0n) {
+    ratio = ratio * 0xfffff000007ffffd55555fffffddddden >> 128n;
+  }
+  if ((x & 0x200000000000n) != 0n) {
+    ratio = ratio * 0xffffe00001ffffeaaaab555551111128n >> 128n;
+  }
+  if ((x & 0x400000000000n) != 0n) {
+    ratio = ratio * 0xffffc00007ffff55555fffff77777d28n >> 128n;
+  }
+  if ((x & 0x800000000000n) != 0n) {
+    ratio = ratio * 0xffff80001ffffaaaab5555444445b05bn >> 128n;
+  }
+  if ((x & 0x1000000000000n) != 0n) {
+    ratio = ratio * 0xffff00007fffd5555ffffdddde38e381n >> 128n;
+  }
+  if ((x & 0x2000000000000n) != 0n) {
+    ratio = ratio * 0xfffe0001fffeaaab5555111127d276a7n >> 128n;
+  }
+  if ((x & 0x4000000000000n) != 0n) {
+    ratio = ratio * 0xfffc0007fff5555ffff7777d27cf3cf5n >> 128n;
+  }
+  if ((x & 0x8000000000000n) != 0n) {
+    ratio = ratio * 0xfff8001fffaaab55544445b0596597f9n >> 128n;
+  }
+  if ((x & 0x10000000000000n) != 0n) {
+    ratio = ratio * 0xfff0007ffd555fffddde38e2be2d82d5n >> 128n;
+  }
+  if ((x & 0x20000000000000n) != 0n) {
+    ratio = ratio * 0xffe001ffeaab55511127d21522f2295cn >> 128n;
+  }
+  if ((x & 0x40000000000000n) != 0n) {
+    ratio = ratio * 0xffc007ff555fff777d279e7b87acece0n >> 128n;
+  }
+  if ((x & 0x80000000000000n) != 0n) {
+    ratio = ratio * 0xff801ffaab554445b04105b043e8f48dn >> 128n;
+  }
+  if ((x & 0x100000000000000n) != 0n) {
+    ratio = ratio * 0xff007fd55ffdde38d68f08c257e0ce3fn >> 128n;
+  }
+  if ((x & 0x200000000000000n) != 0n) {
+    ratio = ratio * 0xfe01feab551127cbfe5f89994c44216fn >> 128n;
+  }
+  if ((x & 0x400000000000000n) != 0n) {
+    ratio = ratio * 0xfc07f55ff77d2493e885eeaa756ad523n >> 128n;
+  }
+  if ((x & 0x800000000000000n) != 0n) {
+    ratio = ratio * 0xf81fab5445aebc8a58055fcbbb139ae9n >> 128n;
+  }
+  if ((x & 0x1000000000000000n) != 0n) {
+    ratio = ratio * 0xf07d5fde38151e72f18ff03049ac5d7fn >> 128n;
+  }
+  if ((x & 0x2000000000000000n) != 0n) {
+    ratio = ratio * 0xe1eb51276c110c3c3eb1269f2f5d4afbn >> 128n;
+  }
+  if ((x & 0x4000000000000000n) != 0n) {
+    ratio = ratio * 0xc75f7cf564105743415cbc9d6368f3b9n >> 128n;
+  }
+  if ((x & 0x8000000000000000n) != 0n) {
+    ratio = ratio * 0x9b4597e37cb04ff3d675a35530cdd768n >> 128n;
+  }
+  if ((x & 0x10000000000000000n) != 0n) {
+    ratio = ratio * 0x5e2d58d8b3bcdf1abadec7829054f90en >> 128n;
+  }
+  if (x != 0n) {
+    ratio = MAX_U256 / ratio;
+  }
+  return ratio;
+}
+function sqrt(x) {
+  if (x < 0n) {
+    throw new Error("Square root of negative numbers is not supported.");
+  }
+  if (x < 2n) {
+    return x;
+  }
+  let x0 = x / 2n;
+  let x1 = (x0 + x / x0) / 2n;
+  while (x0 > x1) {
+    x0 = x1;
+    x1 = (x0 + x / x0) / 2n;
+  }
+  return x0;
+}
+
+// src/math/liquidity.ts
+var Q128 = 1n << 128n;
+function orderBounds(a, b) {
+  return a < b ? [a, b] : [b, a];
+}
+function maxLiquidityForBaseToken({
+  sqrtPriceLower,
+  sqrtPriceUpper,
+  amount
+}) {
+  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);
+  if (amount === 0n || lower === upper)
+    return 0n;
+  return amount * lower * upper / (upper - lower) / Q128;
+}
+function maxLiquidityForQuoteToken({
+  sqrtPriceLower,
+  sqrtPriceUpper,
+  amount
+}) {
+  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);
+  if (amount === 0n || lower === upper)
+    return 0n;
+  return amount * Q128 / (upper - lower);
+}
+function maxLiquidityForTokenAmounts({
+  sqrtPrice,
+  sqrtPriceLower,
+  sqrtPriceUpper,
+  amountBase,
+  amountQuote
+}) {
+  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);
+  if (sqrtPrice <= lower) {
+    return maxLiquidityForBaseToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amountBase });
+  } else if (sqrtPrice < upper) {
+    const liquidityBase = maxLiquidityForBaseToken({
+      sqrtPriceLower: sqrtPrice,
+      sqrtPriceUpper: upper,
+      amount: amountBase
+    });
+    const liquidityQuote = maxLiquidityForQuoteToken({
+      sqrtPriceLower: lower,
+      sqrtPriceUpper: sqrtPrice,
+      amount: amountQuote
+    });
+    return liquidityBase < liquidityQuote ? liquidityBase : liquidityQuote;
+  } else {
+    return maxLiquidityForQuoteToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amountQuote });
+  }
+}
+function liquidityToAmountBase({
+  sqrtPriceLower,
+  sqrtPriceUpper,
+  liquidity
+}) {
+  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);
+  return amount0Delta(lower, upper, liquidity, false);
+}
+function liquidityToAmountQuote({
+  sqrtPriceLower,
+  sqrtPriceUpper,
+  liquidity
+}) {
+  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);
+  return amount1Delta(lower, upper, liquidity, false);
+}
+function maxLiquidityForSpecifiedAmount({
+  sqrtPrice,
+  sqrtPriceUpper,
+  sqrtPriceLower,
+  amount
+}) {
+  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);
+  if (sqrtPrice <= lower) {
+    return "base" in amount ? maxLiquidityForBaseToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amount.base }) : 0n;
+  } else if (sqrtPrice < upper) {
+    return "base" in amount ? maxLiquidityForBaseToken({ sqrtPriceLower: sqrtPrice, sqrtPriceUpper: upper, amount: amount.base }) : maxLiquidityForQuoteToken({ sqrtPriceLower: lower, sqrtPriceUpper: sqrtPrice, amount: amount.quote });
+  } else {
+    return "quote" in amount ? maxLiquidityForQuoteToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amount.quote }) : 0n;
+  }
+}
+function amountsFromSpecifiedAmount({
+  sqrtPrice,
+  sqrtPriceUpper,
+  sqrtPriceLower,
+  amount
+}) {
+  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);
+  const maxLiquidity = maxLiquidityForSpecifiedAmount({
+    sqrtPrice,
+    sqrtPriceLower: lower,
+    sqrtPriceUpper: upper,
+    amount
+  });
+  if ("base" in amount) {
+    if (sqrtPrice < lower) {
+      return {
+        maxLiquidity,
+        base: amount.base,
+        quote: liquidityToAmountQuote({ liquidity: maxLiquidity, sqrtPriceLower: lower, sqrtPriceUpper: upper })
+      };
+    } else if (sqrtPrice < upper) {
+      return {
+        maxLiquidity,
+        base: amount.base,
+        quote: liquidityToAmountQuote({ liquidity: maxLiquidity, sqrtPriceLower: sqrtPrice, sqrtPriceUpper: upper })
+      };
+    } else {
+      return { maxLiquidity, base: amount.base, quote: 0n };
+    }
+  } else {
+    if (sqrtPrice < lower) {
+      return { maxLiquidity, quote: amount.quote, base: 0n };
+    } else if (sqrtPrice < upper) {
+      return {
+        maxLiquidity,
+        quote: amount.quote,
+        base: liquidityToAmountBase({ liquidity: maxLiquidity, sqrtPriceLower: lower, sqrtPriceUpper: sqrtPrice })
+      };
+    } else {
+      return {
+        maxLiquidity,
+        quote: amount.quote,
+        base: liquidityToAmountBase({ liquidity: maxLiquidity, sqrtPriceLower: lower, sqrtPriceUpper: upper })
+      };
+    }
+  }
+}
+export {
+  toSqrtRatio,
+  nextSqrtRatioFromAmount1,
+  nextSqrtRatioFromAmount0,
+  msb,
+  maxLiquidityForTokenAmounts,
+  maxLiquidityForSpecifiedAmount,
+  maxLiquidityForQuoteToken,
+  maxLiquidityForBaseToken,
+  liquidityToAmountQuote,
+  liquidityToAmountBase,
+  floatSqrtRatioToFixed,
+  fixedSqrtRatioToFloat,
+  computeStep,
+  calculateNextSqrtRatio,
+  amountsFromSpecifiedAmount,
+  amount1Delta,
+  amount0Delta,
+  STARKNET_MIN_TICK,
+  STARKNET_MIN_SQRT_RATIO,
+  STARKNET_MAX_TICK_SPACING,
+  STARKNET_MAX_TICK,
+  STARKNET_MAX_SQRT_RATIO,
+  MAX_U256,
+  MAX_U128,
+  EVM_MIN_TICK,
+  EVM_MIN_SQRT_RATIO,
+  EVM_MAX_TICK_SPACING,
+  EVM_MAX_TICK,
+  EVM_MAX_SQRT_RATIO
+};
+
+//# debugId=638B62C2E6A8A81B64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,17 @@
+{
+  "version": 3,
+  "sources": ["../src/math/constants.ts", "../src/math/delta.ts", "../src/math/msb.ts", "../src/math/price.ts", "../src/math/swap.ts", "../src/math/tick.ts", "../src/math/twamm.ts", "../src/math/liquidity.ts"],
+  "sourcesContent": [
+    "export const MAX_U256 =\n  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;\nexport const MAX_U128 = 0xffffffffffffffffffffffffffffffffn;\n",
+    "import { MAX_U128, MAX_U256 } from \"./constants\";\n\nexport function amount0Delta(\n  sqrtRatioA: bigint,\n  sqrtRatioB: bigint,\n  liquidity: bigint,\n  roundUp: boolean,\n): bigint {\n  if (liquidity === 0n || sqrtRatioA === sqrtRatioB) return 0n;\n\n  const [lower, upper] =\n    sqrtRatioA < sqrtRatioB\n      ? [sqrtRatioA, sqrtRatioB]\n      : [sqrtRatioB, sqrtRatioA];\n\n  const numerator = (liquidity << 128n) * (upper - lower);\n\n  let result0 = numerator / upper;\n  if (roundUp && numerator % upper !== 0n) {\n    result0++;\n  }\n\n  if (result0 > MAX_U256) {\n    throw new Error(\"AMOUNT0_DELTA_OVERFLOW_U256\");\n  }\n  let result = result0 / lower;\n  if (roundUp && result % lower !== 0n) {\n    result++;\n  }\n\n  if (result > MAX_U128) {\n    throw new Error(\"AMOUNT0_DELTA_OVERFLOW_U128\");\n  }\n\n  return result;\n}\n\nconst TWO_POW_128 = 0x100000000000000000000000000000000n;\n\nexport function amount1Delta(\n  sqrtRatioA: bigint,\n  sqrtRatioB: bigint,\n  liquidity: bigint,\n  roundUp: boolean,\n): bigint {\n  if (liquidity === 0n || sqrtRatioA === sqrtRatioB) return 0n;\n\n  const [lower, upper] =\n    sqrtRatioA < sqrtRatioB\n      ? [sqrtRatioA, sqrtRatioB]\n      : [sqrtRatioB, sqrtRatioA];\n\n  const result = liquidity * (upper - lower);\n\n  if (result > MAX_U256) {\n    throw new Error(\"AMOUNT1_DELTA_OVERFLOW_U256\");\n  }\n\n  if (roundUp && result % TWO_POW_128 !== 0n) {\n    const delta = result / TWO_POW_128 + 1n;\n    if (delta > MAX_U128) {\n      throw new Error(\"AMOUNT1_DELTA_OVERFLOW_U128\");\n    }\n    return delta;\n  } else {\n    return result >> 128n;\n  }\n}\n",
+    "const MAX = 1n << 128n;\n\nexport default function msb(x: bigint): number {\n  if (x >= MAX) {\n    throw new Error(\"x too large\");\n  }\n  if (x <= 0n) {\n    throw new Error(\"x must be positive\");\n  }\n  let res = 0;\n  if (x >= 0x10000000000000000n) {\n    x = x >> 64n;\n    res += 64;\n  }\n  if (x >= 0x100000000n) {\n    x = x >> 32n;\n    res += 32;\n  }\n  if (x >= 0x10000n) {\n    x = x >> 16n;\n    res += 16;\n  }\n  if (x >= 0x100n) {\n    x = x >> 8n;\n    res += 8;\n  }\n  if (x >= 0x10n) {\n    x = x >> 4n;\n    res += 4;\n  }\n  if (x >= 0x04n) {\n    x = x >> 2n;\n    res += 2;\n  }\n  if (x >= 0x02n) {\n    res += 1;\n  }\n  return res;\n}\n",
+    "import { MAX_U256 } from \"./constants\";\n\nconst toBig = (value: unknown, name: string): bigint => {\n  if (typeof value === \"bigint\") return value;\n  try {\n    return BigInt(value as any);\n  } catch (err) {\n    const printed =\n      value === null || value === undefined ? String(value) : value.toString();\n    const ctor =\n      value && typeof value === \"object\" && \"constructor\" in value\n        ? (value as { constructor: { name: string } }).constructor.name\n        : undefined;\n    throw new TypeError(\n      `${name} must be bigint-compatible, received ${printed} (type ${typeof value}${\n        ctor ? `, ctor ${ctor}` : \"\"\n      })`,\n    );\n  }\n};\n\nexport function nextSqrtRatioFromAmount0(\n  sqrtRatio: bigint,\n  liquidity: bigint,\n  amount0: bigint,\n): bigint | null {\n  const sqrtRatioFixed = toBig(sqrtRatio, \"sqrtRatio\");\n  const liquidityFixed = toBig(liquidity, \"liquidity\");\n  const amount0Fixed = toBig(amount0, \"amount0\");\n\n  if (amount0Fixed === 0n) return sqrtRatioFixed;\n\n  if (liquidityFixed === 0n) throw new Error(\"NO_LIQUIDITY\");\n\n  const numerator1 = liquidityFixed << 128n;\n\n  // because quotient is rounded down, this price movement is also rounded towards sqrt_ratio\n  if (amount0Fixed < 0n) {\n    const product = amount0Fixed * -1n * sqrtRatioFixed;\n\n    if (product >= MAX_U256) {\n      return null;\n    }\n\n    const denominator = numerator1 - product;\n\n    if (denominator < 0n) {\n      return null;\n    }\n\n    const num = numerator1 * sqrtRatioFixed;\n\n    const result = num / denominator + (num % denominator === 0n ? 0n : 1n);\n\n    if (result > MAX_U256) {\n      return null;\n    }\n\n    return result;\n  } else {\n    const denomP1 = numerator1 / sqrtRatioFixed;\n\n    const denom = denomP1 + amount0Fixed;\n    const quotient = numerator1 / denom;\n    const remainder = numerator1 % denom;\n\n    if (remainder === 0n) return quotient;\n    const sum = quotient + 1n;\n    if (sum > MAX_U256) return null;\n    return sum;\n  }\n}\n\nexport function nextSqrtRatioFromAmount1(\n  sqrtRatio: bigint,\n  liquidity: bigint,\n  amount1: bigint,\n): bigint | null {\n  const sqrtRatioFixed = toBig(sqrtRatio, \"sqrtRatio\");\n  const liquidityFixed = toBig(liquidity, \"liquidity\");\n  const amount1Fixed = toBig(amount1, \"amount1\");\n\n  if (amount1Fixed === 0n) return sqrtRatioFixed;\n\n  if (liquidityFixed === 0n) throw new Error(\"NO_LIQUIDITY\");\n\n  const amountShifted = amount1Fixed << 128n;\n  const quotient = amountShifted / liquidityFixed;\n  const remainder = amountShifted % liquidityFixed;\n\n  // because quotient is rounded down, this price movement is also rounded towards sqrt_ratio\n  if (amount1Fixed < 0n) {\n    // adding amount1, taking out amount0\n    const res = sqrtRatioFixed + quotient;\n    if (res < 0n) {\n      return null;\n    }\n    if (remainder === 0n) {\n      return res;\n    } else {\n      if (res != 0n) {\n        return res - 1n;\n      } else {\n        return null;\n      }\n    }\n  } else {\n    // adding amount1, taking out amount0, price goes up\n    const res = sqrtRatioFixed + quotient;\n    if (res > MAX_U256) {\n      return null;\n    } else {\n      return res;\n    }\n  }\n}\n",
+    "import { nextSqrtRatioFromAmount0, nextSqrtRatioFromAmount1 } from \"./price\";\nimport { amount0Delta, amount1Delta } from \"./delta\";\nimport { MAX_U128 } from \"./constants\";\n\ninterface SwapResult {\n  consumedAmount: bigint;\n  calculatedAmount: bigint;\n  sqrtRatioNext: bigint;\n  feeAmount: bigint;\n}\n\nexport function isPriceIncreasing(amount: bigint, isToken1: boolean): boolean {\n  return amount < 0n !== isToken1;\n}\n\nfunction noOp(sqrtRatioNext: bigint): SwapResult {\n  return {\n    consumedAmount: 0n,\n    calculatedAmount: 0n,\n    sqrtRatioNext,\n    feeAmount: 0n,\n  };\n}\n\nexport function amountBeforeFee(amount: bigint, fee: bigint): bigint {\n  if (fee === 0n) return amount;\n  const num = amount << 128n;\n  const denom = (1n << 128n) - fee;\n  const val = num / denom;\n  const result = val + (num % denom !== 0n ? 1n : 0n);\n  if (result > MAX_U128) throw new Error(\"AMOUNT_BEFORE_FEE_OVERFLOW\");\n  return result;\n}\n\nexport function computeFee(amount: bigint, fee: bigint) {\n  const num = amount * fee;\n  const denom = 2n ** 128n;\n  if (num % denom !== 0n) {\n    return num / denom + 1n;\n  } else {\n    return num / denom;\n  }\n}\n\nexport function computeStep({\n  sqrtRatio,\n  liquidity,\n  sqrtRatioLimit,\n  amount,\n  isToken1,\n  fee,\n}: {\n  sqrtRatio: bigint;\n  liquidity: bigint;\n  sqrtRatioLimit: bigint;\n  amount: bigint;\n  isToken1: boolean;\n  fee: bigint;\n}): SwapResult {\n  if (amount === 0n || sqrtRatio === sqrtRatioLimit) {\n    return noOp(sqrtRatio);\n  }\n\n  const increasing = isPriceIncreasing(amount, isToken1);\n\n  if (sqrtRatioLimit < sqrtRatio === increasing) {\n    throw new Error(\"computeStep: wrong direction\");\n  }\n\n  if (liquidity === 0n) {\n    return noOp(sqrtRatioLimit);\n  }\n\n  let priceImpactAmount: bigint;\n  if (amount < 0n) {\n    priceImpactAmount = amount;\n  } else {\n    priceImpactAmount = amount - computeFee(amount, fee);\n  }\n\n  let sqrtRatioNextFromAmount: bigint | null;\n  if (isToken1) {\n    sqrtRatioNextFromAmount = nextSqrtRatioFromAmount1(\n      sqrtRatio,\n      liquidity,\n      priceImpactAmount,\n    );\n  } else {\n    sqrtRatioNextFromAmount = nextSqrtRatioFromAmount0(\n      sqrtRatio,\n      liquidity,\n      priceImpactAmount,\n    );\n  }\n\n  if (\n    sqrtRatioNextFromAmount === null ||\n    sqrtRatioNextFromAmount > sqrtRatioLimit === increasing\n  ) {\n    const [specifiedAmountDelta, calculatedAmountDelta]: [bigint, bigint] =\n      isToken1\n        ? [\n            amount1Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount >= 0n) *\n              (amount < 0n ? -1n : 1n),\n            amount0Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount < 0n),\n          ]\n        : [\n            amount0Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount >= 0n) *\n              (amount < 0n ? -1n : 1n),\n            amount1Delta(sqrtRatioLimit, sqrtRatio, liquidity, amount < 0n),\n          ];\n\n    if (amount < 0n) {\n      const beforeFee = amountBeforeFee(calculatedAmountDelta, fee);\n      return {\n        consumedAmount: specifiedAmountDelta,\n        calculatedAmount: beforeFee,\n        feeAmount: beforeFee - calculatedAmountDelta,\n        sqrtRatioNext: sqrtRatioLimit,\n      };\n    } else {\n      const beforeFee = amountBeforeFee(specifiedAmountDelta, fee);\n      return {\n        consumedAmount: beforeFee,\n        calculatedAmount: calculatedAmountDelta,\n        feeAmount: beforeFee - specifiedAmountDelta,\n        sqrtRatioNext: sqrtRatioLimit,\n      };\n    }\n  }\n\n  if (sqrtRatioNextFromAmount === sqrtRatio) {\n    return {\n      consumedAmount: amount,\n      calculatedAmount: 0n,\n      feeAmount: amount,\n      sqrtRatioNext: sqrtRatio,\n    };\n  }\n\n  const calculatedAmountExcludingFee = isToken1\n    ? amount0Delta(sqrtRatioNextFromAmount, sqrtRatio, liquidity, amount < 0n)\n    : amount1Delta(sqrtRatioNextFromAmount, sqrtRatio, liquidity, amount < 0n);\n\n  if (amount < 0n) {\n    const includingFee = amountBeforeFee(calculatedAmountExcludingFee, fee);\n    return {\n      consumedAmount: amount,\n      calculatedAmount: includingFee,\n      sqrtRatioNext: sqrtRatioNextFromAmount,\n      feeAmount: includingFee - calculatedAmountExcludingFee,\n    };\n  } else {\n    return {\n      consumedAmount: amount,\n      calculatedAmount: calculatedAmountExcludingFee,\n      sqrtRatioNext: sqrtRatioNextFromAmount,\n      feeAmount: amount - priceImpactAmount,\n    };\n  }\n}\n",
+    "import { Chain } from \"./chain\";\nimport { MAX_U256 } from \"./constants\";\n\nexport const EVM_MIN_TICK = -88722835 as const;\nexport const EVM_MAX_TICK = 88722835 as const;\nexport const EVM_MAX_TICK_SPACING = 698605 as const;\nexport const EVM_MIN_SQRT_RATIO: bigint = 18447191164202170524n as const;\nexport const EVM_MAX_SQRT_RATIO: bigint =\n  6276949602062853172742588666607187473671941430179807625216n as const;\n\nexport const STARKNET_MIN_TICK = -88722883 as const;\nexport const STARKNET_MAX_TICK = 88722883 as const;\nexport const STARKNET_MAX_SQRT_RATIO: bigint =\n  6277100250585753475930931601400621808602321654880405518632n as const;\nexport const STARKNET_MIN_SQRT_RATIO: bigint = 18446748437148339061n as const;\nexport const STARKNET_MAX_TICK_SPACING = 354892 as const;\n\nexport const CHAIN_PARAMS: Record<\n  Chain,\n  {\n    MIN_TICK: number;\n    MAX_TICK: number;\n    MIN_SQRT_RATIO: bigint;\n    MAX_SQRT_RATIO: bigint;\n    MAX_TICK_SPACING: number;\n  }\n> = {\n  evm: {\n    MIN_TICK: EVM_MIN_TICK,\n    MAX_TICK: EVM_MAX_TICK,\n    MIN_SQRT_RATIO: EVM_MIN_SQRT_RATIO,\n    MAX_SQRT_RATIO: EVM_MAX_SQRT_RATIO,\n    MAX_TICK_SPACING: EVM_MAX_TICK_SPACING,\n  },\n  starknet: {\n    MIN_TICK: STARKNET_MIN_TICK,\n    MAX_TICK: STARKNET_MAX_TICK,\n    MIN_SQRT_RATIO: STARKNET_MIN_SQRT_RATIO,\n    MAX_SQRT_RATIO: STARKNET_MAX_SQRT_RATIO,\n    MAX_TICK_SPACING: STARKNET_MAX_TICK_SPACING,\n  },\n};\n\n// sqrt ratio float encoding (96-bit custom float used on mainnet)\nconst SQRT_RATIO_FLOAT_BITMASK = 0xc00000000000000000000000n;\nconst SQRT_RATIO_FLOAT_NOT_BITMASK = 0x3fffffffffffffffffffffffn;\nconst SQRT_RATIO_FLOAT_EXPONENTS: readonly bigint[] = [0n, 32n, 64n, 96n];\n\nconst TWO_POW_160 = 1n << 160n;\nconst TWO_POW_128 = 1n << 128n;\nconst TWO_POW_96 = 1n << 96n;\n\nexport function toSqrtRatio(tick: number, chain: Chain): bigint {\n  const MIN_TICK = CHAIN_PARAMS[chain].MIN_TICK;\n  const MAX_TICK = CHAIN_PARAMS[chain].MAX_TICK;\n\n  if (tick < MIN_TICK || tick > MAX_TICK)\n    throw new Error(`Invalid tick: ${tick}`);\n  let sign = tick < 0;\n  tick = Math.abs(tick);\n  let ratio = 0x100000000000000000000000000000000n;\n  if ((tick & 0x1) != 0) {\n    ratio = 0xfffff79c8499329c7cbb2510d893283bn;\n  }\n  if ((tick & 0x2) != 0) {\n    ratio = (ratio * 0xffffef390978c398134b4ff3764fe410n) >> 128n;\n  }\n  if ((tick & 0x4) != 0) {\n    ratio = (ratio * 0xffffde72140b00a354bd3dc828e976c9n) >> 128n;\n  }\n  if ((tick & 0x8) != 0) {\n    ratio = (ratio * 0xffffbce42c7be6c998ad6318193c0b18n) >> 128n;\n  }\n  if ((tick & 0x10) != 0) {\n    ratio = (ratio * 0xffff79c86a8f6150a32d9778eceef97cn) >> 128n;\n  }\n  if ((tick & 0x20) != 0) {\n    ratio = (ratio * 0xfffef3911b7cff24ba1b3dbb5f8f5974n) >> 128n;\n  }\n  if ((tick & 0x40) != 0) {\n    ratio = (ratio * 0xfffde72350725cc4ea8feece3b5f13c8n) >> 128n;\n  }\n  if ((tick & 0x80) != 0) {\n    ratio = (ratio * 0xfffbce4b06c196e9247ac87695d53c60n) >> 128n;\n  }\n  if ((tick & 0x100) != 0) {\n    ratio = (ratio * 0xfff79ca7a4d1bf1ee8556cea23cdbaa5n) >> 128n;\n  }\n  if ((tick & 0x200) != 0) {\n    ratio = (ratio * 0xffef3995a5b6a6267530f207142a5764n) >> 128n;\n  }\n  if ((tick & 0x400) != 0) {\n    ratio = (ratio * 0xffde7444b28145508125d10077ba83b8n) >> 128n;\n  }\n  if ((tick & 0x800) != 0) {\n    ratio = (ratio * 0xffbceceeb791747f10df216f2e53ec57n) >> 128n;\n  }\n  if ((tick & 0x1000) != 0) {\n    ratio = (ratio * 0xff79eb706b9a64c6431d76e63531e929n) >> 128n;\n  }\n  if ((tick & 0x2000) != 0) {\n    ratio = (ratio * 0xfef41d1a5f2ae3a20676bec6f7f9459an) >> 128n;\n  }\n  if ((tick & 0x4000) != 0) {\n    ratio = (ratio * 0xfde95287d26d81bea159c37073122c73n) >> 128n;\n  }\n  if ((tick & 0x8000) != 0) {\n    ratio = (ratio * 0xfbd701c7cbc4c8a6bb81efd232d1e4e7n) >> 128n;\n  }\n  if ((tick & 0x10000) != 0) {\n    ratio = (ratio * 0xf7bf5211c72f5185f372aeb1d48f937en) >> 128n;\n  }\n  if ((tick & 0x20000) != 0) {\n    ratio = (ratio * 0xefc2bf59df33ecc28125cf78ec4f167fn) >> 128n;\n  }\n  if ((tick & 0x40000) != 0) {\n    ratio = (ratio * 0xe08d35706200796273f0b3a981d90cfdn) >> 128n;\n  }\n  if ((tick & 0x80000) != 0) {\n    ratio = (ratio * 0xc4f76b68947482dc198a48a54348c4edn) >> 128n;\n  }\n  if ((tick & 0x100000) != 0) {\n    ratio = (ratio * 0x978bcb9894317807e5fa4498eee7c0fan) >> 128n;\n  }\n  if ((tick & 0x200000) != 0) {\n    ratio = (ratio * 0x59b63684b86e9f486ec54727371ba6can) >> 128n;\n  }\n  if ((tick & 0x400000) != 0) {\n    ratio = (ratio * 0x1f703399d88f6aa83a28b22d4a1f56e3n) >> 128n;\n  }\n  if ((tick & 0x800000) != 0) {\n    ratio = (ratio * 0x3dc5dac7376e20fc8679758d1bcdcfcn) >> 128n;\n  }\n  if ((tick & 0x1000000) != 0) {\n    ratio = (ratio * 0xee7e32d61fdb0a5e622b820f681d0n) >> 128n;\n  }\n  if ((tick & 0x2000000) != 0) {\n    ratio = (ratio * 0xde2ee4bc381afa7089aa84bb66n) >> 128n;\n  }\n  if ((tick & 0x4000000) != 0) {\n    ratio = (ratio * 0xc0d55d4d7152c25fb139n) >> 128n;\n  }\n\n  if (tick > 0 && !sign) {\n    ratio = MAX_U256 / ratio;\n  }\n\n  ratio =\n    chain === \"evm\"\n      ? ratio >= TWO_POW_160\n        ? (ratio >> 98n) << 98n\n        : ratio >= TWO_POW_128\n          ? (ratio >> 66n) << 66n\n          : ratio >= TWO_POW_96\n            ? (ratio >> 34n) << 34n\n            : (ratio >> 2n) << 2n\n      : ratio;\n\n  return ratio;\n}\n\nconst logBase = Math.log(1.0000005);\n\nexport function approximateNumberOfTickSpacingsCrossed(\n  sqrtRatioStart: bigint,\n  sqrtRatioEnd: bigint,\n  tickSpacing: number,\n): number {\n  const logPriceDiff =\n    Math.log(Number(sqrtRatioEnd) / Number(sqrtRatioStart)) / logBase;\n\n  return Math.floor(Math.abs(logPriceDiff / (tickSpacing * 251)));\n}\n\n// Convert the on-chain float sqrt ratio to the fixed-point representation used in math.\nexport function floatSqrtRatioToFixed(sqrtRatioFloat: bigint): bigint {\n  const exponent = (sqrtRatioFloat & SQRT_RATIO_FLOAT_BITMASK) >> 89n;\n  const mantissa = sqrtRatioFloat & SQRT_RATIO_FLOAT_NOT_BITMASK;\n  return mantissa << (2n + exponent);\n}\n\n// Convert a fixed-point sqrt ratio to the compact float format expected on mainnet.\nexport function fixedSqrtRatioToFloat(sqrtRatio: bigint): bigint {\n  if (sqrtRatio < 0n) throw new Error(\"Sqrt ratio must be non-negative\");\n\n  for (const exponent of SQRT_RATIO_FLOAT_EXPONENTS) {\n    const shift = 2n + exponent;\n    const mantissa = sqrtRatio >> shift;\n    if (mantissa <= SQRT_RATIO_FLOAT_NOT_BITMASK) {\n      return mantissa | (exponent << 89n);\n    }\n  }\n\n  throw new Error(\"Sqrt ratio too large to encode as float\");\n}\n",
+    "import { MAX_U256 } from \"./constants\";\n\n// ~ ln(2**128) * 2**64\nexport const EXPONENT_LIMIT: bigint = 1623313478486440542208n;\n\nexport function calculateNextSqrtRatio(\n  sqrtRatio: bigint,\n  liquidity: bigint,\n  token0SaleRate: bigint,\n  token1SaleRate: bigint,\n  timeElapsed: bigint,\n  fee: bigint,\n): bigint {\n  let sqrtSaleRatio = sqrt((token1SaleRate << 128n) / token0SaleRate) << 64n;\n\n  if (liquidity === 0n) {\n    return sqrtSaleRatio;\n  }\n\n  const sRate =\n    (sqrt(token1SaleRate * token0SaleRate) * ((1n << 128n) - fee)) /\n    (1n << 128n);\n\n  const roundUp = sqrtRatio > sqrtSaleRatio;\n\n  const exponent = div(0x200000000n * timeElapsed * sRate, liquidity, roundUp);\n\n  if (exponent > EXPONENT_LIMIT) {\n    return sqrtSaleRatio;\n  }\n\n  const e = exp(exponent);\n\n  const [num, sign] = roundUp\n    ? [sqrtRatio - sqrtSaleRatio, true]\n    : [sqrtSaleRatio - sqrtRatio, false];\n\n  const c = div(num << 128n, sqrtSaleRatio + sqrtRatio, roundUp);\n\n  const [term1, term2] = [e - c, e + c];\n  const scale = sign\n    ? div(term2 << 128n, term1, roundUp)\n    : div(term1 << 128n, term2, roundUp);\n\n  return (sqrtSaleRatio * scale) >> 128n;\n}\n\nfunction div(x: bigint, y: bigint, round: boolean): bigint {\n  const quotient = x / y;\n  const remainder: bigint = x % y;\n  return quotient + (remainder !== 0n && round ? 1n : 0n);\n}\n\n// Computes e^x where x is a fixed point 64.64 number and the result is a fixed point 128.128 number\nexport function exp(x: bigint): bigint {\n  if (x >= 0x20000000000000000) {\n    let half = exp(x / 2n);\n    return (half * half) >> 128n;\n  } else {\n    return expInner(x);\n  }\n}\n\n// Computes e^x where x is a fixed point 64.64 number that is less than the real number 2\nfunction expInner(x: bigint): bigint {\n  if (x >= 0x20000000000000000n) {\n    throw new Error(\"Invalid input\");\n  }\n\n  let ratio = 0x100000000000000000000000000000000n;\n\n  if ((x & 0x1n) != 0n) {\n    ratio = 0xffffffffffffffff0000000000000000n;\n  }\n  if ((x & 0x2n) != 0n) {\n    ratio = (ratio * 0xfffffffffffffffe0000000000000002n) >> 128n;\n  }\n  if ((x & 0x4n) != 0n) {\n    ratio = (ratio * 0xfffffffffffffffc0000000000000008n) >> 128n;\n  }\n  if ((x & 0x8n) != 0n) {\n    ratio = (ratio * 0xfffffffffffffff80000000000000020n) >> 128n;\n  }\n  if ((x & 0x10n) != 0n) {\n    ratio = (ratio * 0xfffffffffffffff00000000000000080n) >> 128n;\n  }\n  if ((x & 0x20n) != 0n) {\n    ratio = (ratio * 0xffffffffffffffe00000000000000200n) >> 128n;\n  }\n  if ((x & 0x40n) != 0n) {\n    ratio = (ratio * 0xffffffffffffffc00000000000000800n) >> 128n;\n  }\n  if ((x & 0x80n) != 0n) {\n    ratio = (ratio * 0xffffffffffffff800000000000002000n) >> 128n;\n  }\n  if ((x & 0x100n) != 0n) {\n    ratio = (ratio * 0xffffffffffffff000000000000008000n) >> 128n;\n  }\n  if ((x & 0x200n) != 0n) {\n    ratio = (ratio * 0xfffffffffffffe000000000000020000n) >> 128n;\n  }\n  if ((x & 0x400n) != 0n) {\n    ratio = (ratio * 0xfffffffffffffc000000000000080000n) >> 128n;\n  }\n  if ((x & 0x800n) != 0n) {\n    ratio = (ratio * 0xfffffffffffff8000000000000200000n) >> 128n;\n  }\n  if ((x & 0x1000n) != 0n) {\n    ratio = (ratio * 0xfffffffffffff0000000000000800000n) >> 128n;\n  }\n  if ((x & 0x2000n) != 0n) {\n    ratio = (ratio * 0xffffffffffffe0000000000002000000n) >> 128n;\n  }\n  if ((x & 0x4000n) != 0n) {\n    ratio = (ratio * 0xffffffffffffc0000000000008000000n) >> 128n;\n  }\n  if ((x & 0x8000n) != 0n) {\n    ratio = (ratio * 0xffffffffffff80000000000020000000n) >> 128n;\n  }\n  if ((x & 0x10000n) != 0n) {\n    ratio = (ratio * 0xffffffffffff00000000000080000000n) >> 128n;\n  }\n  if ((x & 0x20000n) != 0n) {\n    ratio = (ratio * 0xfffffffffffe00000000000200000000n) >> 128n;\n  }\n  if ((x & 0x40000n) != 0n) {\n    ratio = (ratio * 0xfffffffffffc00000000000800000000n) >> 128n;\n  }\n  if ((x & 0x80000n) != 0n) {\n    ratio = (ratio * 0xfffffffffff800000000002000000000n) >> 128n;\n  }\n  if ((x & 0x100000n) != 0n) {\n    ratio = (ratio * 0xfffffffffff000000000008000000000n) >> 128n;\n  }\n  if ((x & 0x200000n) != 0n) {\n    ratio = (ratio * 0xffffffffffe000000000020000000000n) >> 128n;\n  }\n  if ((x & 0x400000n) != 0n) {\n    ratio = (ratio * 0xffffffffffc00000000007ffffffffffn) >> 128n;\n  }\n  if ((x & 0x800000n) != 0n) {\n    ratio = (ratio * 0xffffffffff80000000001ffffffffffbn) >> 128n;\n  }\n  if ((x & 0x1000000n) != 0n) {\n    ratio = (ratio * 0xffffffffff00000000007fffffffffd5n) >> 128n;\n  }\n  if ((x & 0x2000000n) != 0n) {\n    ratio = (ratio * 0xfffffffffe0000000001fffffffffeabn) >> 128n;\n  }\n  if ((x & 0x4000000n) != 0n) {\n    ratio = (ratio * 0xfffffffffc0000000007fffffffff555n) >> 128n;\n  }\n  if ((x & 0x8000000n) != 0n) {\n    ratio = (ratio * 0xfffffffff8000000001fffffffffaaabn) >> 128n;\n  }\n  if ((x & 0x10000000n) != 0n) {\n    ratio = (ratio * 0xfffffffff0000000007ffffffffd5555n) >> 128n;\n  }\n  if ((x & 0x20000000n) != 0n) {\n    ratio = (ratio * 0xffffffffe000000001ffffffffeaaaabn) >> 128n;\n  }\n  if ((x & 0x40000000n) != 0n) {\n    ratio = (ratio * 0xffffffffc000000007ffffffff555555n) >> 128n;\n  }\n  if ((x & 0x80000000n) != 0n) {\n    ratio = (ratio * 0xffffffff800000001ffffffffaaaaaabn) >> 128n;\n  }\n  if ((x & 0x100000000n) != 0n) {\n    ratio = (ratio * 0xffffffff000000007fffffffd5555555n) >> 128n;\n  }\n  if ((x & 0x200000000n) != 0n) {\n    ratio = (ratio * 0xfffffffe00000001fffffffeaaaaaaabn) >> 128n;\n  }\n  if ((x & 0x400000000n) != 0n) {\n    ratio = (ratio * 0xfffffffc00000007fffffff555555560n) >> 128n;\n  }\n  if ((x & 0x800000000n) != 0n) {\n    ratio = (ratio * 0xfffffff80000001fffffffaaaaaaab55n) >> 128n;\n  }\n  if ((x & 0x1000000000n) != 0n) {\n    ratio = (ratio * 0xfffffff00000007ffffffd5555556000n) >> 128n;\n  }\n  if ((x & 0x2000000000n) != 0n) {\n    ratio = (ratio * 0xffffffe0000001ffffffeaaaaaab5555n) >> 128n;\n  }\n  if ((x & 0x4000000000n) != 0n) {\n    ratio = (ratio * 0xffffffc0000007ffffff555555600000n) >> 128n;\n  }\n  if ((x & 0x8000000000n) != 0n) {\n    ratio = (ratio * 0xffffff8000001ffffffaaaaaab555555n) >> 128n;\n  }\n  if ((x & 0x10000000000n) != 0n) {\n    ratio = (ratio * 0xffffff0000007fffffd555555ffffffen) >> 128n;\n  }\n  if ((x & 0x20000000000n) != 0n) {\n    ratio = (ratio * 0xfffffe000001fffffeaaaaab55555511n) >> 128n;\n  }\n  if ((x & 0x40000000000n) != 0n) {\n    ratio = (ratio * 0xfffffc000007fffff555555ffffff777n) >> 128n;\n  }\n  if ((x & 0x80000000000n) != 0n) {\n    ratio = (ratio * 0xfffff800001fffffaaaaab5555544444n) >> 128n;\n  }\n  if ((x & 0x100000000000n) != 0n) {\n    ratio = (ratio * 0xfffff000007ffffd55555fffffddddden) >> 128n;\n  }\n  if ((x & 0x200000000000n) != 0n) {\n    ratio = (ratio * 0xffffe00001ffffeaaaab555551111128n) >> 128n;\n  }\n  if ((x & 0x400000000000n) != 0n) {\n    ratio = (ratio * 0xffffc00007ffff55555fffff77777d28n) >> 128n;\n  }\n  if ((x & 0x800000000000n) != 0n) {\n    ratio = (ratio * 0xffff80001ffffaaaab5555444445b05bn) >> 128n;\n  }\n  if ((x & 0x1000000000000n) != 0n) {\n    ratio = (ratio * 0xffff00007fffd5555ffffdddde38e381n) >> 128n;\n  }\n  if ((x & 0x2000000000000n) != 0n) {\n    ratio = (ratio * 0xfffe0001fffeaaab5555111127d276a7n) >> 128n;\n  }\n  if ((x & 0x4000000000000n) != 0n) {\n    ratio = (ratio * 0xfffc0007fff5555ffff7777d27cf3cf5n) >> 128n;\n  }\n  if ((x & 0x8000000000000n) != 0n) {\n    ratio = (ratio * 0xfff8001fffaaab55544445b0596597f9n) >> 128n;\n  }\n  if ((x & 0x10000000000000n) != 0n) {\n    ratio = (ratio * 0xfff0007ffd555fffddde38e2be2d82d5n) >> 128n;\n  }\n  if ((x & 0x20000000000000n) != 0n) {\n    ratio = (ratio * 0xffe001ffeaab55511127d21522f2295cn) >> 128n;\n  }\n  if ((x & 0x40000000000000n) != 0n) {\n    ratio = (ratio * 0xffc007ff555fff777d279e7b87acece0n) >> 128n;\n  }\n  if ((x & 0x80000000000000n) != 0n) {\n    ratio = (ratio * 0xff801ffaab554445b04105b043e8f48dn) >> 128n;\n  }\n  if ((x & 0x100000000000000n) != 0n) {\n    ratio = (ratio * 0xff007fd55ffdde38d68f08c257e0ce3fn) >> 128n;\n  }\n  if ((x & 0x200000000000000n) != 0n) {\n    ratio = (ratio * 0xfe01feab551127cbfe5f89994c44216fn) >> 128n;\n  }\n  if ((x & 0x400000000000000n) != 0n) {\n    ratio = (ratio * 0xfc07f55ff77d2493e885eeaa756ad523n) >> 128n;\n  }\n  if ((x & 0x800000000000000n) != 0n) {\n    ratio = (ratio * 0xf81fab5445aebc8a58055fcbbb139ae9n) >> 128n;\n  }\n  if ((x & 0x1000000000000000n) != 0n) {\n    ratio = (ratio * 0xf07d5fde38151e72f18ff03049ac5d7fn) >> 128n;\n  }\n  if ((x & 0x2000000000000000n) != 0n) {\n    ratio = (ratio * 0xe1eb51276c110c3c3eb1269f2f5d4afbn) >> 128n;\n  }\n  if ((x & 0x4000000000000000n) != 0n) {\n    ratio = (ratio * 0xc75f7cf564105743415cbc9d6368f3b9n) >> 128n;\n  }\n  if ((x & 0x8000000000000000n) != 0n) {\n    ratio = (ratio * 0x9b4597e37cb04ff3d675a35530cdd768n) >> 128n;\n  }\n  if ((x & 0x10000000000000000n) != 0n) {\n    ratio = (ratio * 0x5e2d58d8b3bcdf1abadec7829054f90en) >> 128n;\n  }\n\n  if (x != 0n) {\n    ratio = MAX_U256 / ratio;\n  }\n\n  return ratio;\n}\n\nexport function sqrt(x: bigint): bigint {\n  if (x < 0n) {\n    throw new Error(\"Square root of negative numbers is not supported.\");\n  }\n  if (x < 2n) {\n    return x;\n  }\n\n  let x0: bigint = x / 2n;\n  let x1: bigint = (x0 + x / x0) / 2n;\n\n  while (x0 > x1) {\n    x0 = x1;\n    x1 = (x0 + x / x0) / 2n;\n  }\n\n  return x0;\n}\n",
+    "import { amount0Delta, amount1Delta } from \"./delta\";\n\nconst Q128 = 1n << 128n;\n\nfunction orderBounds(a: bigint, b: bigint): [bigint, bigint] {\n  return a < b ? [a, b] : [b, a];\n}\n\nexport function maxLiquidityForBaseToken({\n  sqrtPriceLower,\n  sqrtPriceUpper,\n  amount,\n}: {\n  amount: bigint;\n  sqrtPriceLower: bigint;\n  sqrtPriceUpper: bigint;\n}): bigint {\n  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);\n  if (amount === 0n || lower === upper) return 0n;\n  return (amount * lower * upper) / (upper - lower) / Q128;\n}\n\nexport function maxLiquidityForQuoteToken({\n  sqrtPriceLower,\n  sqrtPriceUpper,\n  amount,\n}: {\n  amount: bigint;\n  sqrtPriceLower: bigint;\n  sqrtPriceUpper: bigint;\n}): bigint {\n  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);\n  if (amount === 0n || lower === upper) return 0n;\n  return (amount * Q128) / (upper - lower);\n}\n\nexport function maxLiquidityForTokenAmounts({\n  sqrtPrice,\n  sqrtPriceLower,\n  sqrtPriceUpper,\n  amountBase,\n  amountQuote,\n}: {\n  sqrtPrice: bigint;\n  sqrtPriceLower: bigint;\n  sqrtPriceUpper: bigint;\n  amountBase: bigint;\n  amountQuote: bigint;\n}): bigint {\n  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);\n\n  if (sqrtPrice <= lower) {\n    return maxLiquidityForBaseToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amountBase });\n  } else if (sqrtPrice < upper) {\n    const liquidityBase = maxLiquidityForBaseToken({\n      sqrtPriceLower: sqrtPrice,\n      sqrtPriceUpper: upper,\n      amount: amountBase,\n    });\n    const liquidityQuote = maxLiquidityForQuoteToken({\n      sqrtPriceLower: lower,\n      sqrtPriceUpper: sqrtPrice,\n      amount: amountQuote,\n    });\n    return liquidityBase < liquidityQuote ? liquidityBase : liquidityQuote;\n  } else {\n    return maxLiquidityForQuoteToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amountQuote });\n  }\n}\n\nexport function liquidityToAmountBase({\n  sqrtPriceLower,\n  sqrtPriceUpper,\n  liquidity,\n}: {\n  liquidity: bigint;\n  sqrtPriceLower: bigint;\n  sqrtPriceUpper: bigint;\n}): bigint {\n  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);\n  return amount0Delta(lower, upper, liquidity, false);\n}\n\nexport function liquidityToAmountQuote({\n  sqrtPriceLower,\n  sqrtPriceUpper,\n  liquidity,\n}: {\n  liquidity: bigint;\n  sqrtPriceLower: bigint;\n  sqrtPriceUpper: bigint;\n}): bigint {\n  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);\n  return amount1Delta(lower, upper, liquidity, false);\n}\n\nexport function maxLiquidityForSpecifiedAmount({\n  sqrtPrice,\n  sqrtPriceUpper,\n  sqrtPriceLower,\n  amount,\n}: {\n  amount: { base: bigint } | { quote: bigint };\n  sqrtPrice: bigint;\n  sqrtPriceLower: bigint;\n  sqrtPriceUpper: bigint;\n}): bigint {\n  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);\n\n  if (sqrtPrice <= lower) {\n    return \"base\" in amount\n      ? maxLiquidityForBaseToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amount.base })\n      : 0n;\n  } else if (sqrtPrice < upper) {\n    return \"base\" in amount\n      ? maxLiquidityForBaseToken({ sqrtPriceLower: sqrtPrice, sqrtPriceUpper: upper, amount: amount.base })\n      : maxLiquidityForQuoteToken({ sqrtPriceLower: lower, sqrtPriceUpper: sqrtPrice, amount: amount.quote });\n  } else {\n    return \"quote\" in amount\n      ? maxLiquidityForQuoteToken({ sqrtPriceLower: lower, sqrtPriceUpper: upper, amount: amount.quote })\n      : 0n;\n  }\n}\n\nexport function amountsFromSpecifiedAmount({\n  sqrtPrice,\n  sqrtPriceUpper,\n  sqrtPriceLower,\n  amount,\n}: {\n  amount: { base: bigint } | { quote: bigint };\n  sqrtPrice: bigint;\n  sqrtPriceLower: bigint;\n  sqrtPriceUpper: bigint;\n}): { base: bigint; quote: bigint; maxLiquidity: bigint } {\n  const [lower, upper] = orderBounds(sqrtPriceLower, sqrtPriceUpper);\n  const maxLiquidity = maxLiquidityForSpecifiedAmount({\n    sqrtPrice,\n    sqrtPriceLower: lower,\n    sqrtPriceUpper: upper,\n    amount,\n  });\n\n  if (\"base\" in amount) {\n    if (sqrtPrice < lower) {\n      return {\n        maxLiquidity,\n        base: amount.base,\n        quote: liquidityToAmountQuote({ liquidity: maxLiquidity, sqrtPriceLower: lower, sqrtPriceUpper: upper }),\n      };\n    } else if (sqrtPrice < upper) {\n      return {\n        maxLiquidity,\n        base: amount.base,\n        quote: liquidityToAmountQuote({ liquidity: maxLiquidity, sqrtPriceLower: sqrtPrice, sqrtPriceUpper: upper }),\n      };\n    } else {\n      return { maxLiquidity, base: amount.base, quote: 0n };\n    }\n  } else {\n    if (sqrtPrice < lower) {\n      return { maxLiquidity, quote: amount.quote, base: 0n };\n    } else if (sqrtPrice < upper) {\n      return {\n        maxLiquidity,\n        quote: amount.quote,\n        base: liquidityToAmountBase({ liquidity: maxLiquidity, sqrtPriceLower: lower, sqrtPriceUpper: sqrtPrice }),\n      };\n    } else {\n      return {\n        maxLiquidity,\n        quote: amount.quote,\n        base: liquidityToAmountBase({ liquidity: maxLiquidity, sqrtPriceLower: lower, sqrtPriceUpper: upper }),\n      };\n    }\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "638B62C2E6A8A81B64756E2164756E21",
+  "names": []
+}

package/dist/math/chain.d.ts

@@ -0,0 +1 @@
+export type Chain = "evm" | "starknet";

package/dist/math/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_U256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+export declare const MAX_U128 = 340282366920938463463374607431768211455n;

package/dist/math/delta.d.ts

@@ -0,0 +1,2 @@
+export declare function amount0Delta(sqrtRatioA: bigint, sqrtRatioB: bigint, liquidity: bigint, roundUp: boolean): bigint;
+export declare function amount1Delta(sqrtRatioA: bigint, sqrtRatioB: bigint, liquidity: bigint, roundUp: boolean): bigint;

package/dist/math/delta.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math/liquidity.d.ts

@@ -0,0 +1,51 @@
+export declare function maxLiquidityForBaseToken({ sqrtPriceLower, sqrtPriceUpper, amount, }: {
+    amount: bigint;
+    sqrtPriceLower: bigint;
+    sqrtPriceUpper: bigint;
+}): bigint;
+export declare function maxLiquidityForQuoteToken({ sqrtPriceLower, sqrtPriceUpper, amount, }: {
+    amount: bigint;
+    sqrtPriceLower: bigint;
+    sqrtPriceUpper: bigint;
+}): bigint;
+export declare function maxLiquidityForTokenAmounts({ sqrtPrice, sqrtPriceLower, sqrtPriceUpper, amountBase, amountQuote, }: {
+    sqrtPrice: bigint;
+    sqrtPriceLower: bigint;
+    sqrtPriceUpper: bigint;
+    amountBase: bigint;
+    amountQuote: bigint;
+}): bigint;
+export declare function liquidityToAmountBase({ sqrtPriceLower, sqrtPriceUpper, liquidity, }: {
+    liquidity: bigint;
+    sqrtPriceLower: bigint;
+    sqrtPriceUpper: bigint;
+}): bigint;
+export declare function liquidityToAmountQuote({ sqrtPriceLower, sqrtPriceUpper, liquidity, }: {
+    liquidity: bigint;
+    sqrtPriceLower: bigint;
+    sqrtPriceUpper: bigint;
+}): bigint;
+export declare function maxLiquidityForSpecifiedAmount({ sqrtPrice, sqrtPriceUpper, sqrtPriceLower, amount, }: {
+    amount: {
+        base: bigint;
+    } | {
+        quote: bigint;
+    };
+    sqrtPrice: bigint;
+    sqrtPriceLower: bigint;
+    sqrtPriceUpper: bigint;
+}): bigint;
+export declare function amountsFromSpecifiedAmount({ sqrtPrice, sqrtPriceUpper, sqrtPriceLower, amount, }: {
+    amount: {
+        base: bigint;
+    } | {
+        quote: bigint;
+    };
+    sqrtPrice: bigint;
+    sqrtPriceLower: bigint;
+    sqrtPriceUpper: bigint;
+}): {
+    base: bigint;
+    quote: bigint;
+    maxLiquidity: bigint;
+};

package/dist/math/liquidity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math/msb.d.ts

@@ -0,0 +1 @@
+export default function msb(x: bigint): number;

package/dist/math/msb.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math/price.d.ts

@@ -0,0 +1,2 @@
+export declare function nextSqrtRatioFromAmount0(sqrtRatio: bigint, liquidity: bigint, amount0: bigint): bigint | null;
+export declare function nextSqrtRatioFromAmount1(sqrtRatio: bigint, liquidity: bigint, amount1: bigint): bigint | null;

package/dist/math/price.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math/swap.d.ts

@@ -0,0 +1,18 @@
+interface SwapResult {
+    consumedAmount: bigint;
+    calculatedAmount: bigint;
+    sqrtRatioNext: bigint;
+    feeAmount: bigint;
+}
+export declare function isPriceIncreasing(amount: bigint, isToken1: boolean): boolean;
+export declare function amountBeforeFee(amount: bigint, fee: bigint): bigint;
+export declare function computeFee(amount: bigint, fee: bigint): bigint;
+export declare function computeStep({ sqrtRatio, liquidity, sqrtRatioLimit, amount, isToken1, fee, }: {
+    sqrtRatio: bigint;
+    liquidity: bigint;
+    sqrtRatioLimit: bigint;
+    amount: bigint;
+    isToken1: boolean;
+    fee: bigint;
+}): SwapResult;
+export {};

package/dist/math/swap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math/tick.d.ts

@@ -0,0 +1,22 @@
+import { Chain } from "./chain";
+export declare const EVM_MIN_TICK: -88722835;
+export declare const EVM_MAX_TICK: 88722835;
+export declare const EVM_MAX_TICK_SPACING: 698605;
+export declare const EVM_MIN_SQRT_RATIO: bigint;
+export declare const EVM_MAX_SQRT_RATIO: bigint;
+export declare const STARKNET_MIN_TICK: -88722883;
+export declare const STARKNET_MAX_TICK: 88722883;
+export declare const STARKNET_MAX_SQRT_RATIO: bigint;
+export declare const STARKNET_MIN_SQRT_RATIO: bigint;
+export declare const STARKNET_MAX_TICK_SPACING: 354892;
+export declare const CHAIN_PARAMS: Record<Chain, {
+    MIN_TICK: number;
+    MAX_TICK: number;
+    MIN_SQRT_RATIO: bigint;
+    MAX_SQRT_RATIO: bigint;
+    MAX_TICK_SPACING: number;
+}>;
+export declare function toSqrtRatio(tick: number, chain: Chain): bigint;
+export declare function approximateNumberOfTickSpacingsCrossed(sqrtRatioStart: bigint, sqrtRatioEnd: bigint, tickSpacing: number): number;
+export declare function floatSqrtRatioToFixed(sqrtRatioFloat: bigint): bigint;
+export declare function fixedSqrtRatioToFloat(sqrtRatio: bigint): bigint;

package/dist/math/tick.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math/twamm.d.ts

@@ -0,0 +1,4 @@
+export declare const EXPONENT_LIMIT: bigint;
+export declare function calculateNextSqrtRatio(sqrtRatio: bigint, liquidity: bigint, token0SaleRate: bigint, token1SaleRate: bigint, timeElapsed: bigint, fee: bigint): bigint;
+export declare function exp(x: bigint): bigint;
+export declare function sqrt(x: bigint): bigint;

package/dist/math/twamm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math.d.ts

@@ -0,0 +1,9 @@
+import { MAX_U128, MAX_U256 } from "./math/constants";
+import { amount0Delta, amount1Delta } from "./math/delta";
+import msb from "./math/msb";
+import { nextSqrtRatioFromAmount0, nextSqrtRatioFromAmount1 } from "./math/price";
+import { computeStep } from "./math/swap";
+import { EVM_MAX_SQRT_RATIO, EVM_MAX_TICK, EVM_MAX_TICK_SPACING, EVM_MIN_SQRT_RATIO, EVM_MIN_TICK, STARKNET_MAX_SQRT_RATIO, STARKNET_MAX_TICK, STARKNET_MAX_TICK_SPACING, STARKNET_MIN_SQRT_RATIO, STARKNET_MIN_TICK, toSqrtRatio, floatSqrtRatioToFixed, fixedSqrtRatioToFloat } from "./math/tick";
+import { calculateNextSqrtRatio } from "./math/twamm";
+import { maxLiquidityForBaseToken, maxLiquidityForQuoteToken, maxLiquidityForTokenAmounts, maxLiquidityForSpecifiedAmount, amountsFromSpecifiedAmount, liquidityToAmountBase, liquidityToAmountQuote } from "./math/liquidity";
+export { amount0Delta, amount1Delta, msb, nextSqrtRatioFromAmount0, nextSqrtRatioFromAmount1, computeStep, toSqrtRatio, calculateNextSqrtRatio, floatSqrtRatioToFixed, fixedSqrtRatioToFloat, maxLiquidityForBaseToken, maxLiquidityForQuoteToken, maxLiquidityForTokenAmounts, maxLiquidityForSpecifiedAmount, amountsFromSpecifiedAmount, liquidityToAmountBase, liquidityToAmountQuote, MAX_U128, MAX_U256, EVM_MIN_TICK, EVM_MAX_TICK, EVM_MIN_SQRT_RATIO, EVM_MAX_SQRT_RATIO, EVM_MAX_TICK_SPACING, STARKNET_MIN_TICK, STARKNET_MAX_TICK, STARKNET_MIN_SQRT_RATIO, STARKNET_MAX_SQRT_RATIO, STARKNET_MAX_TICK_SPACING, };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@ekubo/sdk",
+  "version": "0.0.8-alpha.0",
+  "private": false,
+  "description": "Shared math utilities for Ekubo (chain-agnostic)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "bun test",
+    "build": "bun build ./src/index.ts --outdir dist --format esm --sourcemap && tsc -p tsconfig.json",
+    "prepublishOnly": "rm -rf dist && bun run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "Moody Salem",
+  "license": "UNLICENSED",
+  "packageManager": "bun@1.3.3",
+  "devDependencies": {
+    "@types/bun": "^1.3.4",
+    "typescript": "^5.7.3"
+  }
+}