@pancakeswap/v3-sdk 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var sdk = require('@pancakeswap/sdk');
-var JSBI4 = require('jsbi');
 var invariant11 = require('tiny-invariant');
 var swapSdkCore = require('@pancakeswap/swap-sdk-core');
 var abi = require('@ethersproject/abi');
@@ -10,7 +9,6 @@ var solidity = require('@ethersproject/solidity');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var JSBI4__default = /*#__PURE__*/_interopDefault(JSBI4);
 var invariant11__default = /*#__PURE__*/_interopDefault(invariant11);
 
 // src/entities/pool.ts
@@ -37,15 +35,15 @@ var TICK_SPACINGS = {
   [2500 /* MEDIUM */]: 50,
   [1e4 /* HIGH */]: 200
 };
-var NEGATIVE_ONE = swapSdkCore.JSBI.BigInt(-1);
-var ZERO = swapSdkCore.JSBI.BigInt(0);
-var ONE = swapSdkCore.JSBI.BigInt(1);
-var Q96 = swapSdkCore.JSBI.exponentiate(swapSdkCore.JSBI.BigInt(2), swapSdkCore.JSBI.BigInt(96));
-var Q192 = swapSdkCore.JSBI.exponentiate(Q96, swapSdkCore.JSBI.BigInt(2));
-var MAX_FEE = swapSdkCore.JSBI.exponentiate(swapSdkCore.JSBI.BigInt(10), swapSdkCore.JSBI.BigInt(6));
+var NEGATIVE_ONE = BigInt(-1);
+var ZERO = 0n;
+var ONE = 1n;
+var Q96 = 2n ** 96n;
+var Q192 = Q96 ** 2n;
+var MAX_FEE = 10n ** 6n;
 var ONE_HUNDRED_PERCENT = new swapSdkCore.Percent("1");
 var ZERO_PERCENT = new swapSdkCore.Percent("0");
-var Q128 = swapSdkCore.JSBI.exponentiate(swapSdkCore.JSBI.BigInt(2), swapSdkCore.JSBI.BigInt(128));
+var Q128 = 2n ** 128n;
 function computePoolAddress({
   deployerAddress,
   tokenA,
@@ -60,9 +58,11 @@ function computePoolAddress({
       ["bytes"],
       [abi.defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]
     ),
-    initCodeHashManualOverride != null ? initCodeHashManualOverride : POOL_INIT_CODE_HASH
+    initCodeHashManualOverride ?? POOL_INIT_CODE_HASH
   );
 }
+
+// src/utils/liquidityMath.ts
 var LiquidityMath = class {
   /**
    * Cannot be constructed.
@@ -70,12 +70,14 @@ var LiquidityMath = class {
   constructor() {
   }
   static addDelta(x, y) {
-    if (JSBI4__default.default.lessThan(y, ZERO)) {
-      return JSBI4__default.default.subtract(x, JSBI4__default.default.multiply(y, NEGATIVE_ONE));
+    if (y < ZERO) {
+      return x - y * NEGATIVE_ONE;
     }
-    return JSBI4__default.default.add(x, y);
+    return x + y;
   }
 };
+
+// src/utils/fullMath.ts
 var FullMath = class {
   /**
    * Cannot be constructed.
@@ -83,21 +85,21 @@ var FullMath = class {
   constructor() {
   }
   static mulDivRoundingUp(a, b, denominator) {
-    const product = JSBI4__default.default.multiply(a, b);
-    let result = JSBI4__default.default.divide(product, denominator);
-    if (JSBI4__default.default.notEqual(JSBI4__default.default.remainder(product, denominator), ZERO))
-      result = JSBI4__default.default.add(result, ONE);
+    const product = a * b;
+    let result = product / denominator;
+    if (product % denominator !== ZERO)
+      result = result + ONE;
     return result;
   }
 };
-var MaxUint160 = JSBI4__default.default.subtract(JSBI4__default.default.exponentiate(JSBI4__default.default.BigInt(2), JSBI4__default.default.BigInt(160)), ONE);
+var MaxUint160 = 2n ** 160n - ONE;
 function multiplyIn256(x, y) {
-  const product = JSBI4__default.default.multiply(x, y);
-  return JSBI4__default.default.bitwiseAnd(product, sdk.MaxUint256);
+  const product = x * y;
+  return product & sdk.MaxUint256;
 }
 function addIn256(x, y) {
-  const sum = JSBI4__default.default.add(x, y);
-  return JSBI4__default.default.bitwiseAnd(sum, sdk.MaxUint256);
+  const sum = x + y;
+  return sum & sdk.MaxUint256;
 }
 var SqrtPriceMath = class {
   /**
@@ -106,59 +108,59 @@ var SqrtPriceMath = class {
   constructor() {
   }
   static getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
-    if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
       sqrtRatioAX96 = sqrtRatioBX96;
       sqrtRatioBX96 = sqrtRatioAX96;
     }
-    const numerator1 = JSBI4__default.default.leftShift(liquidity, JSBI4__default.default.BigInt(96));
-    const numerator2 = JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96);
-    return roundUp ? FullMath.mulDivRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96), ONE, sqrtRatioAX96) : JSBI4__default.default.divide(JSBI4__default.default.divide(JSBI4__default.default.multiply(numerator1, numerator2), sqrtRatioBX96), sqrtRatioAX96);
+    const numerator1 = liquidity << 96n;
+    const numerator2 = sqrtRatioBX96 - sqrtRatioAX96;
+    return roundUp ? FullMath.mulDivRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96), ONE, sqrtRatioAX96) : numerator1 * numerator2 / sqrtRatioBX96 / sqrtRatioAX96;
   }
   static getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
-    if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
       sqrtRatioAX96 = sqrtRatioBX96;
       sqrtRatioBX96 = sqrtRatioAX96;
     }
-    return roundUp ? FullMath.mulDivRoundingUp(liquidity, JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96), Q96) : JSBI4__default.default.divide(JSBI4__default.default.multiply(liquidity, JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96)), Q96);
+    return roundUp ? FullMath.mulDivRoundingUp(liquidity, sqrtRatioBX96 - sqrtRatioAX96, Q96) : liquidity * (sqrtRatioBX96 - sqrtRatioAX96) / Q96;
   }
   static getNextSqrtPriceFromInput(sqrtPX96, liquidity, amountIn, zeroForOne) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPX96, ZERO));
-    invariant11__default.default(JSBI4__default.default.greaterThan(liquidity, ZERO));
+    invariant11__default.default(sqrtPX96 > ZERO);
+    invariant11__default.default(liquidity > ZERO);
     return zeroForOne ? this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true) : this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountIn, true);
   }
   static getNextSqrtPriceFromOutput(sqrtPX96, liquidity, amountOut, zeroForOne) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPX96, ZERO));
-    invariant11__default.default(JSBI4__default.default.greaterThan(liquidity, ZERO));
+    invariant11__default.default(sqrtPX96 > ZERO);
+    invariant11__default.default(liquidity > ZERO);
     return zeroForOne ? this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountOut, false) : this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountOut, false);
   }
   static getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amount, add) {
-    if (JSBI4__default.default.equal(amount, ZERO))
+    if (amount === ZERO)
       return sqrtPX96;
-    const numerator1 = JSBI4__default.default.leftShift(liquidity, JSBI4__default.default.BigInt(96));
+    const numerator1 = liquidity << 96n;
     if (add) {
       const product2 = multiplyIn256(amount, sqrtPX96);
-      if (JSBI4__default.default.equal(JSBI4__default.default.divide(product2, amount), sqrtPX96)) {
+      if (product2 / amount === sqrtPX96) {
         const denominator2 = addIn256(numerator1, product2);
-        if (JSBI4__default.default.greaterThanOrEqual(denominator2, numerator1)) {
+        if (denominator2 >= numerator1) {
           return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator2);
         }
       }
-      return FullMath.mulDivRoundingUp(numerator1, ONE, JSBI4__default.default.add(JSBI4__default.default.divide(numerator1, sqrtPX96), amount));
+      return FullMath.mulDivRoundingUp(numerator1, ONE, numerator1 / sqrtPX96 + amount);
     }
     const product = multiplyIn256(amount, sqrtPX96);
-    invariant11__default.default(JSBI4__default.default.equal(JSBI4__default.default.divide(product, amount), sqrtPX96));
-    invariant11__default.default(JSBI4__default.default.greaterThan(numerator1, product));
-    const denominator = JSBI4__default.default.subtract(numerator1, product);
+    invariant11__default.default(product / amount === sqrtPX96);
+    invariant11__default.default(numerator1 > product);
+    const denominator = numerator1 - product;
     return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator);
   }
   static getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amount, add) {
     if (add) {
-      const quotient2 = JSBI4__default.default.lessThanOrEqual(amount, MaxUint160) ? JSBI4__default.default.divide(JSBI4__default.default.leftShift(amount, JSBI4__default.default.BigInt(96)), liquidity) : JSBI4__default.default.divide(JSBI4__default.default.multiply(amount, Q96), liquidity);
-      return JSBI4__default.default.add(sqrtPX96, quotient2);
+      const quotient2 = amount <= MaxUint160 ? (amount << 96n) / liquidity : amount * Q96 / liquidity;
+      return sqrtPX96 + quotient2;
     }
     const quotient = FullMath.mulDivRoundingUp(amount, Q96, liquidity);
-    invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPX96, quotient));
-    return JSBI4__default.default.subtract(sqrtPX96, quotient);
+    invariant11__default.default(sqrtPX96 > quotient);
+    return sqrtPX96 - quotient;
   }
 };
 
@@ -171,15 +173,12 @@ var SwapMath = class {
   }
   static computeSwapStep(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, amountRemaining, feePips) {
     const returnValues = {};
-    const zeroForOne = JSBI4__default.default.greaterThanOrEqual(sqrtRatioCurrentX96, sqrtRatioTargetX96);
-    const exactIn = JSBI4__default.default.greaterThanOrEqual(amountRemaining, ZERO);
+    const zeroForOne = sqrtRatioCurrentX96 >= sqrtRatioTargetX96;
+    const exactIn = amountRemaining >= ZERO;
     if (exactIn) {
-      const amountRemainingLessFee = JSBI4__default.default.divide(
-        JSBI4__default.default.multiply(amountRemaining, JSBI4__default.default.subtract(MAX_FEE, JSBI4__default.default.BigInt(feePips))),
-        MAX_FEE
-      );
+      const amountRemainingLessFee = amountRemaining * (MAX_FEE - BigInt(feePips)) / MAX_FEE;
       returnValues.amountIn = zeroForOne ? SqrtPriceMath.getAmount0Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, true) : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, true);
-      if (JSBI4__default.default.greaterThanOrEqual(amountRemainingLessFee, returnValues.amountIn)) {
+      if (amountRemainingLessFee >= returnValues.amountIn) {
         returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
       } else {
         returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
@@ -191,18 +190,18 @@ var SwapMath = class {
       }
     } else {
       returnValues.amountOut = zeroForOne ? SqrtPriceMath.getAmount1Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, false) : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, false);
-      if (JSBI4__default.default.greaterThanOrEqual(JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE), returnValues.amountOut)) {
+      if (amountRemaining * NEGATIVE_ONE >= returnValues.amountOut) {
         returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
       } else {
         returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
           sqrtRatioCurrentX96,
           liquidity,
-          JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE),
+          amountRemaining * NEGATIVE_ONE,
           zeroForOne
         );
       }
     }
-    const max = JSBI4__default.default.equal(sqrtRatioTargetX96, returnValues.sqrtRatioNextX96);
+    const max = sqrtRatioTargetX96 === returnValues.sqrtRatioNextX96;
     if (zeroForOne) {
       returnValues.amountIn = max && exactIn ? returnValues.amountIn : SqrtPriceMath.getAmount0Delta(returnValues.sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, true);
       returnValues.amountOut = max && !exactIn ? returnValues.amountOut : SqrtPriceMath.getAmount1Delta(returnValues.sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, false);
@@ -210,33 +209,30 @@ var SwapMath = class {
       returnValues.amountIn = max && exactIn ? returnValues.amountIn : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, returnValues.sqrtRatioNextX96, liquidity, true);
       returnValues.amountOut = max && !exactIn ? returnValues.amountOut : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, returnValues.sqrtRatioNextX96, liquidity, false);
     }
-    if (!exactIn && JSBI4__default.default.greaterThan(returnValues.amountOut, JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE))) {
-      returnValues.amountOut = JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE);
+    if (!exactIn && returnValues.amountOut > amountRemaining * NEGATIVE_ONE) {
+      returnValues.amountOut = amountRemaining * NEGATIVE_ONE;
     }
-    if (exactIn && JSBI4__default.default.notEqual(returnValues.sqrtRatioNextX96, sqrtRatioTargetX96)) {
-      returnValues.feeAmount = JSBI4__default.default.subtract(amountRemaining, returnValues.amountIn);
+    if (exactIn && returnValues.sqrtRatioNextX96 !== sqrtRatioTargetX96) {
+      returnValues.feeAmount = amountRemaining - returnValues.amountIn;
     } else {
       returnValues.feeAmount = FullMath.mulDivRoundingUp(
         returnValues.amountIn,
-        JSBI4__default.default.BigInt(feePips),
-        JSBI4__default.default.subtract(MAX_FEE, JSBI4__default.default.BigInt(feePips))
+        BigInt(feePips),
+        MAX_FEE - BigInt(feePips)
       );
     }
     return [returnValues.sqrtRatioNextX96, returnValues.amountIn, returnValues.amountOut, returnValues.feeAmount];
   }
 };
-var TWO = JSBI4__default.default.BigInt(2);
-var POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow) => [
-  pow,
-  JSBI4__default.default.exponentiate(TWO, JSBI4__default.default.BigInt(pow))
-]);
+var TWO = 2n;
+var POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow) => [pow, TWO ** BigInt(pow)]);
 function mostSignificantBit(x) {
-  invariant11__default.default(JSBI4__default.default.greaterThan(x, ZERO), "ZERO");
-  invariant11__default.default(JSBI4__default.default.lessThanOrEqual(x, sdk.MaxUint256), "MAX");
+  invariant11__default.default(x > ZERO, "ZERO");
+  invariant11__default.default(x <= sdk.MaxUint256, "MAX");
   let msb = 0;
   for (const [power, min] of POWERS_OF_2) {
-    if (JSBI4__default.default.greaterThanOrEqual(x, min)) {
-      x = JSBI4__default.default.signedRightShift(x, JSBI4__default.default.BigInt(power));
+    if (x >= min) {
+      x = x >> BigInt(power);
       msb += power;
     }
   }
@@ -245,9 +241,9 @@ function mostSignificantBit(x) {
 
 // src/utils/tickMath.ts
 function mulShift(val, mulBy) {
-  return sdk.JSBI.signedRightShift(sdk.JSBI.multiply(val, sdk.JSBI.BigInt(mulBy)), sdk.JSBI.BigInt(128));
+  return val * BigInt(mulBy) >> 128n;
 }
-var Q32 = sdk.JSBI.exponentiate(sdk.JSBI.BigInt(2), sdk.JSBI.BigInt(32));
+var Q32 = 2n ** 32n;
 var _TickMath = class {
   /**
    * Cannot be constructed.
@@ -261,7 +257,7 @@ var _TickMath = class {
   static getSqrtRatioAtTick(tick) {
     invariant11__default.default(tick >= _TickMath.MIN_TICK && tick <= _TickMath.MAX_TICK && Number.isInteger(tick), "TICK");
     const absTick = tick < 0 ? tick * -1 : tick;
-    let ratio = (absTick & 1) != 0 ? sdk.JSBI.BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : sdk.JSBI.BigInt("0x100000000000000000000000000000000");
+    let ratio = (absTick & 1) != 0 ? BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : BigInt("0x100000000000000000000000000000000");
     if ((absTick & 2) != 0)
       ratio = mulShift(ratio, "0xfff97272373d413259a46990580e213a");
     if ((absTick & 4) != 0)
@@ -301,8 +297,8 @@ var _TickMath = class {
     if ((absTick & 524288) != 0)
       ratio = mulShift(ratio, "0x48a170391f7dc42444e8fa2");
     if (tick > 0)
-      ratio = sdk.JSBI.divide(sdk.MaxUint256, ratio);
-    return sdk.JSBI.greaterThan(sdk.JSBI.remainder(ratio, Q32), ZERO) ? sdk.JSBI.add(sdk.JSBI.divide(ratio, Q32), ONE) : sdk.JSBI.divide(ratio, Q32);
+      ratio = sdk.MaxUint256 / ratio;
+    return ratio % Q32 > ZERO ? ratio / Q32 + ONE : ratio / Q32;
   }
   /**
    * Returns the tick corresponding to a given sqrt ratio, s.t. #getSqrtRatioAtTick(tick) <= sqrtRatioX96
@@ -310,39 +306,26 @@ var _TickMath = class {
    * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
    */
   static getTickAtSqrtRatio(sqrtRatioX96) {
-    invariant11__default.default(
-      sdk.JSBI.greaterThanOrEqual(sqrtRatioX96, _TickMath.MIN_SQRT_RATIO) && sdk.JSBI.lessThan(sqrtRatioX96, _TickMath.MAX_SQRT_RATIO),
-      "SQRT_RATIO"
-    );
-    const sqrtRatioX128 = sdk.JSBI.leftShift(sqrtRatioX96, sdk.JSBI.BigInt(32));
+    invariant11__default.default(sqrtRatioX96 >= _TickMath.MIN_SQRT_RATIO && sqrtRatioX96 < _TickMath.MAX_SQRT_RATIO, "SQRT_RATIO");
+    const sqrtRatioX128 = sqrtRatioX96 << 32n;
     const msb = mostSignificantBit(sqrtRatioX128);
     let r;
-    if (sdk.JSBI.greaterThanOrEqual(sdk.JSBI.BigInt(msb), sdk.JSBI.BigInt(128))) {
-      r = sdk.JSBI.signedRightShift(sqrtRatioX128, sdk.JSBI.BigInt(msb - 127));
+    if (BigInt(msb) >= 128n) {
+      r = sqrtRatioX128 >> BigInt(msb - 127);
     } else {
-      r = sdk.JSBI.leftShift(sqrtRatioX128, sdk.JSBI.BigInt(127 - msb));
+      r = sqrtRatioX128 << BigInt(127 - msb);
     }
-    let log_2 = sdk.JSBI.leftShift(sdk.JSBI.subtract(sdk.JSBI.BigInt(msb), sdk.JSBI.BigInt(128)), sdk.JSBI.BigInt(64));
+    let log_2 = BigInt(msb) - 128n << 64n;
     for (let i = 0; i < 14; i++) {
-      r = sdk.JSBI.signedRightShift(sdk.JSBI.multiply(r, r), sdk.JSBI.BigInt(127));
-      const f = sdk.JSBI.signedRightShift(r, sdk.JSBI.BigInt(128));
-      log_2 = sdk.JSBI.bitwiseOr(log_2, sdk.JSBI.leftShift(f, sdk.JSBI.BigInt(63 - i)));
-      r = sdk.JSBI.signedRightShift(r, f);
+      r = r * r >> 127n;
+      const f = r >> 128n;
+      log_2 = log_2 | f << BigInt(63 - i);
+      r = r >> f;
     }
-    const log_sqrt10001 = sdk.JSBI.multiply(log_2, sdk.JSBI.BigInt("255738958999603826347141"));
-    const tickLow = sdk.JSBI.toNumber(
-      sdk.JSBI.signedRightShift(
-        sdk.JSBI.subtract(log_sqrt10001, sdk.JSBI.BigInt("3402992956809132418596140100660247210")),
-        sdk.JSBI.BigInt(128)
-      )
-    );
-    const tickHigh = sdk.JSBI.toNumber(
-      sdk.JSBI.signedRightShift(
-        sdk.JSBI.add(log_sqrt10001, sdk.JSBI.BigInt("291339464771989622907027621153398088495")),
-        sdk.JSBI.BigInt(128)
-      )
-    );
-    return tickLow === tickHigh ? tickLow : sdk.JSBI.lessThanOrEqual(_TickMath.getSqrtRatioAtTick(tickHigh), sqrtRatioX96) ? tickHigh : tickLow;
+    const log_sqrt10001 = log_2 * 255738958999603826347141n;
+    const tickLow = Number(log_sqrt10001 - 3402992956809132418596140100660247210n >> 128n);
+    const tickHigh = Number(log_sqrt10001 + 291339464771989622907027621153398088495n >> 128n);
+    return tickLow === tickHigh ? tickLow : _TickMath.getSqrtRatioAtTick(tickHigh) <= sqrtRatioX96 ? tickHigh : tickLow;
   }
 };
 var TickMath = _TickMath;
@@ -358,11 +341,11 @@ TickMath.MAX_TICK = -_TickMath.MIN_TICK;
 /**
  * The sqrt ratio corresponding to the minimum tick that could be used on any pool.
  */
-TickMath.MIN_SQRT_RATIO = sdk.JSBI.BigInt("4295128739");
+TickMath.MIN_SQRT_RATIO = 4295128739n;
 /**
  * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
  */
-TickMath.MAX_SQRT_RATIO = sdk.JSBI.BigInt("1461446703485210103287273052203988822378723970342");
+TickMath.MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
 
 // src/entities/tickDataProvider.ts
 var _NoTickDataProvider = class {
@@ -402,13 +385,7 @@ var TickList = class {
       ticks.every(({ index }) => index % tickSpacing === 0),
       "TICK_SPACING"
     );
-    invariant11__default.default(
-      JSBI4__default.default.equal(
-        ticks.reduce((accumulator, { liquidityNet }) => JSBI4__default.default.add(accumulator, liquidityNet), ZERO),
-        ZERO
-      ),
-      "ZERO_NET"
-    );
+    invariant11__default.default(ticks.reduce((accumulator, { liquidityNet }) => accumulator + liquidityNet, ZERO) === ZERO, "ZERO_NET");
     invariant11__default.default(isSorted(ticks, tickComparator), "SORTED");
   }
   static isBelowSmallest(ticks, tick) {
@@ -493,8 +470,10 @@ var TickList = class {
     return Math.abs(beforeIndex - afterIndex);
   }
 };
+
+// src/utils/calldata.ts
 function toHex(bigintIsh) {
-  const bigInt = JSBI4__default.default.BigInt(bigintIsh);
+  const bigInt = BigInt(bigintIsh);
   let hex = bigInt.toString(16);
   if (hex.length % 2 !== 0) {
     hex = `0${hex}`;
@@ -524,48 +503,50 @@ function encodeRouteToPath(route, exactOutput) {
   return exactOutput ? solidity.pack(types.reverse(), path.reverse()) : solidity.pack(types, path);
 }
 function encodeSqrtRatioX96(amount1, amount0) {
-  const numerator = JSBI4__default.default.leftShift(JSBI4__default.default.BigInt(amount1), JSBI4__default.default.BigInt(192));
-  const denominator = JSBI4__default.default.BigInt(amount0);
-  const ratioX192 = JSBI4__default.default.divide(numerator, denominator);
+  const numerator = BigInt(amount1) << 192n;
+  const denominator = BigInt(amount0);
+  const ratioX192 = numerator / denominator;
   return sdk.sqrt(ratioX192);
 }
+
+// src/utils/maxLiquidityForAmounts.ts
 function maxLiquidityForAmount0Imprecise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
-  if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  const intermediate = JSBI4__default.default.divide(JSBI4__default.default.multiply(sqrtRatioAX96, sqrtRatioBX96), Q96);
-  return JSBI4__default.default.divide(JSBI4__default.default.multiply(JSBI4__default.default.BigInt(amount0), intermediate), JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96));
+  const intermediate = sqrtRatioAX96 * sqrtRatioBX96 / Q96;
+  return BigInt(amount0) * intermediate / (sqrtRatioBX96 - sqrtRatioAX96);
 }
 function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
-  if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  const numerator = JSBI4__default.default.multiply(JSBI4__default.default.multiply(JSBI4__default.default.BigInt(amount0), sqrtRatioAX96), sqrtRatioBX96);
-  const denominator = JSBI4__default.default.multiply(Q96, JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96));
-  return JSBI4__default.default.divide(numerator, denominator);
+  const numerator = BigInt(amount0) * sqrtRatioAX96 * sqrtRatioBX96;
+  const denominator = Q96 * (sqrtRatioBX96 - sqrtRatioAX96);
+  return numerator / denominator;
 }
 function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
-  if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  return JSBI4__default.default.divide(JSBI4__default.default.multiply(JSBI4__default.default.BigInt(amount1), Q96), JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96));
+  return BigInt(amount1) * Q96 / (sqrtRatioBX96 - sqrtRatioAX96);
 }
 function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX96, amount0, amount1, useFullPrecision) {
-  if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
   const maxLiquidityForAmount0 = useFullPrecision ? maxLiquidityForAmount0Precise : maxLiquidityForAmount0Imprecise;
-  if (JSBI4__default.default.lessThanOrEqual(sqrtRatioCurrentX96, sqrtRatioAX96)) {
+  if (sqrtRatioCurrentX96 <= sqrtRatioAX96) {
     return maxLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
   }
-  if (JSBI4__default.default.lessThan(sqrtRatioCurrentX96, sqrtRatioBX96)) {
+  if (sqrtRatioCurrentX96 < sqrtRatioBX96) {
     const liquidity0 = maxLiquidityForAmount0(sqrtRatioCurrentX96, sqrtRatioBX96, amount0);
     const liquidity1 = maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioCurrentX96, amount1);
-    return JSBI4__default.default.lessThan(liquidity0, liquidity1) ? liquidity0 : liquidity1;
+    return liquidity0 < liquidity1 ? liquidity0 : liquidity1;
   }
   return maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
 }
@@ -580,6 +561,8 @@ function nearestUsableTick(tick, tickSpacing) {
     return rounded - tickSpacing;
   return rounded;
 }
+
+// src/utils/position.ts
 var PositionLibrary = class {
   /**
    * Cannot be constructed.
@@ -588,20 +571,14 @@ var PositionLibrary = class {
   }
   // replicates the portions of Position#update required to compute unaccounted fees
   static getTokensOwed(feeGrowthInside0LastX128, feeGrowthInside1LastX128, liquidity, feeGrowthInside0X128, feeGrowthInside1X128) {
-    const tokensOwed0 = sdk.JSBI.divide(
-      sdk.JSBI.multiply(subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128), liquidity),
-      Q128
-    );
-    const tokensOwed1 = sdk.JSBI.divide(
-      sdk.JSBI.multiply(subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128), liquidity),
-      Q128
-    );
+    const tokensOwed0 = subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128) * liquidity / Q128;
+    const tokensOwed1 = subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128) * liquidity / Q128;
     return [tokensOwed0, tokensOwed1];
   }
 };
 function tickToPrice(baseToken, quoteToken, tick) {
   const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
-  const ratioX192 = JSBI4__default.default.multiply(sqrtRatioX96, sqrtRatioX96);
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
   return baseToken.sortsBefore(quoteToken) ? new sdk.Price(baseToken, quoteToken, Q192, ratioX192) : new sdk.Price(baseToken, quoteToken, ratioX192, Q192);
 }
 function priceToClosestTick(price) {
@@ -618,11 +595,13 @@ function priceToClosestTick(price) {
   }
   return tick;
 }
-var Q256 = JSBI4__default.default.exponentiate(JSBI4__default.default.BigInt(2), JSBI4__default.default.BigInt(256));
+
+// src/utils/tickLibrary.ts
+var Q256 = 2n ** 256n;
 function subIn256(x, y) {
-  const difference = JSBI4__default.default.subtract(x, y);
-  if (JSBI4__default.default.lessThan(difference, ZERO)) {
-    return JSBI4__default.default.add(Q256, difference);
+  const difference = x - y;
+  if (difference < ZERO) {
+    return Q256 + difference;
   }
   return difference;
 }
@@ -693,12 +672,13 @@ var PositionMath = {
 };
 function parseNumberToFraction(num, precision = 6) {
   const scalar = 10 ** precision;
-  return new swapSdkCore.Fraction(swapSdkCore.JSBI.BigInt(Math.floor(num * scalar)), swapSdkCore.JSBI.BigInt(scalar));
+  return new swapSdkCore.Fraction(BigInt(Math.floor(num * scalar)), BigInt(scalar));
 }
 
 // src/utils/feeCalculator.ts
 var FeeCalculator = {
   getEstimatedLPFee,
+  getEstimatedLPFeeByAmounts,
   getLiquidityFromTick,
   getLiquidityFromSqrtRatioX96,
   getAverageLiquidity,
@@ -708,26 +688,40 @@ var FeeCalculator = {
   getAmountsByLiquidityAndPrice,
   getAmountsAtNewPrice
 };
-function getEstimatedLPFeeWithProtocolFee(options) {
+function getEstimatedLPFeeWithProtocolFee({ amount, currency, ...rest }) {
+  return getEstimatedLPFeeByAmountsWithProtocolFee({
+    ...rest,
+    amountA: amount,
+    amountB: sdk.CurrencyAmount.fromRawAmount(currency, sdk.MaxUint256)
+  });
+}
+function getEstimatedLPFee({ amount, currency, ...rest }) {
+  return getEstimatedLPFeeByAmounts({
+    ...rest,
+    amountA: amount,
+    amountB: sdk.CurrencyAmount.fromRawAmount(currency, sdk.MaxUint256)
+  });
+}
+function getEstimatedLPFeeByAmountsWithProtocolFee(options) {
   try {
-    return tryGetEstimatedLPFee(options);
+    return tryGetEstimatedLPFeeByAmounts(options);
   } catch (e) {
     console.error(e);
     return new sdk.Fraction(sdk.ZERO);
   }
 }
-function getEstimatedLPFee({ protocolFee = ZERO_PERCENT, ...rest }) {
+function getEstimatedLPFeeByAmounts({ protocolFee = ZERO_PERCENT, ...rest }) {
   try {
-    const fee = tryGetEstimatedLPFee(rest);
+    const fee = tryGetEstimatedLPFeeByAmounts(rest);
     return ONE_HUNDRED_PERCENT.subtract(protocolFee).multiply(fee).asFraction;
   } catch (e) {
     console.error(e);
     return new sdk.Fraction(sdk.ZERO);
   }
 }
-function tryGetEstimatedLPFee({
-  amount,
-  currency,
+function tryGetEstimatedLPFeeByAmounts({
+  amountA,
+  amountB,
   volume24H,
   sqrtRatioX96,
   tickLower,
@@ -741,8 +735,14 @@ function tryGetEstimatedLPFee({
   if (tickCurrent < tickLower || tickCurrent > tickUpper) {
     return new sdk.Fraction(sdk.ZERO);
   }
-  const liquidity = FeeCalculator.getLiquidityBySingleAmount({ amount, currency, tickUpper, tickLower, sqrtRatioX96 });
-  return insidePercentage.multiply(parseNumberToFraction(volume24H).multiply(sdk.JSBI.BigInt(fee)).multiply(liquidity)).divide(sdk.JSBI.multiply(MAX_FEE, sdk.JSBI.add(liquidity, mostActiveLiquidity))).asFraction;
+  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice({
+    amountA,
+    amountB,
+    tickUpper,
+    tickLower,
+    sqrtRatioX96
+  });
+  return insidePercentage.multiply(parseNumberToFraction(volume24H).multiply(BigInt(fee)).multiply(liquidity)).divide(MAX_FEE * (liquidity + mostActiveLiquidity)).asFraction;
 }
 function getDependentAmount(options) {
   const { currency, amount, sqrtRatioX96, tickLower, tickUpper } = options;
@@ -809,42 +809,41 @@ function getAverageLiquidity(ticks, tickSpacing, tickLower, tickUpper) {
   let currentTick = TickList.nextInitializedTick(ticks, tickLower, false);
   let currentL = lowerOutOfBound ? sdk.ZERO : FeeCalculator.getLiquidityFromTick(ticks, currentTick.index);
   let weightedL = sdk.ZERO;
-  const getWeightedLFromLastTickTo = (toTick) => sdk.JSBI.multiply(currentL, sdk.JSBI.BigInt(toTick - Math.max(lastTick.index, tickLower)));
+  const getWeightedLFromLastTickTo = (toTick) => currentL * BigInt(toTick - Math.max(lastTick.index, tickLower));
   while (currentTick.index < tickUpper) {
-    weightedL = sdk.JSBI.add(weightedL, getWeightedLFromLastTickTo(currentTick.index));
-    currentL = sdk.JSBI.add(currentL, currentTick.liquidityNet);
+    weightedL += getWeightedLFromLastTickTo(currentTick.index);
+    currentL += currentTick.liquidityNet;
     lastTick = currentTick;
     if (currentTick.index === ticks[ticks.length - 1].index) {
       break;
     }
     currentTick = TickList.nextInitializedTick(ticks, currentTick.index, false);
   }
-  weightedL = sdk.JSBI.add(weightedL, getWeightedLFromLastTickTo(tickUpper));
-  return sdk.JSBI.divide(weightedL, sdk.JSBI.BigInt(tickUpper - tickLower));
+  weightedL += getWeightedLFromLastTickTo(tickUpper);
+  return weightedL / BigInt(tickUpper - tickLower);
 }
 function getLiquidityFromSqrtRatioX96(ticks, sqrtRatioX96) {
   const tick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
   return FeeCalculator.getLiquidityFromTick(ticks, tick);
 }
 function getLiquidityFromTick(ticks, tick) {
-  var _a;
   let liquidity = sdk.ZERO;
-  if (!(ticks == null ? void 0 : ticks.length))
+  if (!ticks?.length)
     return liquidity;
   if (tick < ticks[0].index || tick > ticks[ticks.length - 1].index) {
     return liquidity;
   }
   for (let i = 0; i < ticks.length - 1; ++i) {
-    liquidity = sdk.JSBI.add(liquidity, ticks[i].liquidityNet);
+    liquidity += ticks[i].liquidityNet;
     const lowerTick = ticks[i].index;
-    const upperTick = (_a = ticks[i + 1]) == null ? void 0 : _a.index;
+    const upperTick = ticks[i + 1]?.index;
     if (lowerTick <= tick && tick <= upperTick) {
       break;
     }
   }
   return liquidity;
 }
-var FEE_BASE = sdk.JSBI.exponentiate(sdk.JSBI.BigInt(10), sdk.JSBI.BigInt(4));
+var FEE_BASE = 10n ** 4n;
 function parseProtocolFees(feeProtocol) {
   const packed = Number(feeProtocol);
   if (Number.isNaN(packed)) {
@@ -854,14 +853,18 @@ function parseProtocolFees(feeProtocol) {
   const token1ProtocolFee = packed >> 16;
   return [new sdk.Percent(token0ProtocolFee, FEE_BASE), new sdk.Percent(token1ProtocolFee, FEE_BASE)];
 }
+function sqrtRatioX96ToPrice(sqrtRatioX96, currencyA, currencyB) {
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
+  return currencyA.wrapped.sortsBefore(currencyB.wrapped) ? new swapSdkCore.Price(currencyA.wrapped, currencyB.wrapped, Q192, ratioX192) : new swapSdkCore.Price(currencyA.wrapped, currencyB.wrapped, ratioX192, Q192);
+}
 
 // src/entities/tick.ts
 var Tick = class {
   constructor({ index, liquidityGross, liquidityNet }) {
     invariant11__default.default(index >= TickMath.MIN_TICK && index <= TickMath.MAX_TICK, "TICK");
     this.index = index;
-    this.liquidityGross = JSBI4__default.default.BigInt(liquidityGross);
-    this.liquidityNet = JSBI4__default.default.BigInt(liquidityNet);
+    this.liquidityGross = BigInt(liquidityGross);
+    this.liquidityNet = BigInt(liquidityNet);
   }
 };
 
@@ -884,7 +887,7 @@ var NO_TICK_DATA_PROVIDER_DEFAULT = new NoTickDataProvider();
 var Pool = class {
   static getAddress(tokenA, tokenB, fee, initCodeHashManualOverride, deployerAddressOverride) {
     return computePoolAddress({
-      deployerAddress: deployerAddressOverride != null ? deployerAddressOverride : DEPLOYER_ADDRESSES[tokenA.chainId],
+      deployerAddress: deployerAddressOverride ?? DEPLOYER_ADDRESSES[tokenA.chainId],
       fee,
       tokenA,
       tokenB,
@@ -905,8 +908,8 @@ var Pool = class {
     invariant11__default.default(Number.isInteger(fee) && fee < 1e6, "FEE");
     [this.token0, this.token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
     this.fee = fee;
-    this.sqrtRatioX96 = JSBI4__default.default.BigInt(sqrtRatioX96);
-    this.liquidity = JSBI4__default.default.BigInt(liquidity);
+    this.sqrtRatioX96 = BigInt(sqrtRatioX96);
+    this.liquidity = BigInt(liquidity);
     this.tickCurrent = tickCurrent;
     this.tickDataProvider = Array.isArray(ticks) ? new TickListDataProvider(ticks) : ticks;
   }
@@ -922,25 +925,13 @@ var Pool = class {
    * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
    */
   get token0Price() {
-    var _a;
-    return (_a = this._token0Price) != null ? _a : this._token0Price = new sdk.Price(
-      this.token0,
-      this.token1,
-      Q192,
-      JSBI4__default.default.multiply(this.sqrtRatioX96, this.sqrtRatioX96)
-    );
+    return this._token0Price ?? (this._token0Price = new sdk.Price(this.token0, this.token1, Q192, this.sqrtRatioX96 * this.sqrtRatioX96));
   }
   /**
    * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
    */
   get token1Price() {
-    var _a;
-    return (_a = this._token1Price) != null ? _a : this._token1Price = new sdk.Price(
-      this.token1,
-      this.token0,
-      JSBI4__default.default.multiply(this.sqrtRatioX96, this.sqrtRatioX96),
-      Q192
-    );
+    return this._token1Price ?? (this._token1Price = new sdk.Price(this.token1, this.token0, this.sqrtRatioX96 * this.sqrtRatioX96, Q192));
   }
   /**
    * Return the price of the given token in terms of the other token in the pool.
@@ -974,7 +965,7 @@ var Pool = class {
     } = await this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX96);
     const outputToken = zeroForOne ? this.token1 : this.token0;
     return [
-      sdk.CurrencyAmount.fromRawAmount(outputToken, JSBI4__default.default.multiply(outputAmount, NEGATIVE_ONE)),
+      sdk.CurrencyAmount.fromRawAmount(outputToken, outputAmount * NEGATIVE_ONE),
       new Pool(this.token0, this.token1, this.fee, sqrtRatioX96, liquidity, tickCurrent, this.tickDataProvider)
     ];
   }
@@ -993,8 +984,8 @@ var Pool = class {
       sqrtRatioX96,
       liquidity,
       tickCurrent
-    } = await this.swap(zeroForOne, JSBI4__default.default.multiply(outputAmount.quotient, NEGATIVE_ONE), sqrtPriceLimitX96);
-    invariant11__default.default(JSBI4__default.default.equal(amountSpecifiedRemaining, ZERO), "INSUFICIENT_LIQUIDITY");
+    } = await this.swap(zeroForOne, outputAmount.quotient * NEGATIVE_ONE, sqrtPriceLimitX96);
+    invariant11__default.default(amountSpecifiedRemaining === ZERO, "INSUFICIENT_LIQUIDITY");
     const inputToken = zeroForOne ? this.token0 : this.token1;
     return [
       sdk.CurrencyAmount.fromRawAmount(inputToken, inputAmount),
@@ -1013,15 +1004,15 @@ var Pool = class {
    */
   async swap(zeroForOne, amountSpecified, sqrtPriceLimitX96) {
     if (!sqrtPriceLimitX96)
-      sqrtPriceLimitX96 = zeroForOne ? JSBI4__default.default.add(TickMath.MIN_SQRT_RATIO, ONE) : JSBI4__default.default.subtract(TickMath.MAX_SQRT_RATIO, ONE);
+      sqrtPriceLimitX96 = zeroForOne ? TickMath.MIN_SQRT_RATIO + ONE : TickMath.MAX_SQRT_RATIO - ONE;
     if (zeroForOne) {
-      invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPriceLimitX96, TickMath.MIN_SQRT_RATIO), "RATIO_MIN");
-      invariant11__default.default(JSBI4__default.default.lessThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
+      invariant11__default.default(sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO, "RATIO_MIN");
+      invariant11__default.default(sqrtPriceLimitX96 < this.sqrtRatioX96, "RATIO_CURRENT");
     } else {
-      invariant11__default.default(JSBI4__default.default.lessThan(sqrtPriceLimitX96, TickMath.MAX_SQRT_RATIO), "RATIO_MAX");
-      invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
+      invariant11__default.default(sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO, "RATIO_MAX");
+      invariant11__default.default(sqrtPriceLimitX96 > this.sqrtRatioX96, "RATIO_CURRENT");
     }
-    const exactInput = JSBI4__default.default.greaterThanOrEqual(amountSpecified, ZERO);
+    const exactInput = amountSpecified >= ZERO;
     const state = {
       amountSpecifiedRemaining: amountSpecified,
       amountCalculated: ZERO,
@@ -1029,7 +1020,7 @@ var Pool = class {
       tick: this.tickCurrent,
       liquidity: this.liquidity
     };
-    while (JSBI4__default.default.notEqual(state.amountSpecifiedRemaining, ZERO) && state.sqrtPriceX96 != sqrtPriceLimitX96) {
+    while (state.amountSpecifiedRemaining !== ZERO && state.sqrtPriceX96 != sqrtPriceLimitX96) {
       const step = {};
       step.sqrtPriceStartX96 = state.sqrtPriceX96;
       [step.tickNext, step.initialized] = await this.tickDataProvider.nextInitializedTickWithinOneWord(
@@ -1045,30 +1036,27 @@ var Pool = class {
       step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
       [state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount] = SwapMath.computeSwapStep(
         state.sqrtPriceX96,
-        (zeroForOne ? JSBI4__default.default.lessThan(step.sqrtPriceNextX96, sqrtPriceLimitX96) : JSBI4__default.default.greaterThan(step.sqrtPriceNextX96, sqrtPriceLimitX96)) ? sqrtPriceLimitX96 : step.sqrtPriceNextX96,
+        (zeroForOne ? step.sqrtPriceNextX96 < sqrtPriceLimitX96 : step.sqrtPriceNextX96 > sqrtPriceLimitX96) ? sqrtPriceLimitX96 : step.sqrtPriceNextX96,
         state.liquidity,
         state.amountSpecifiedRemaining,
         this.fee
       );
       if (exactInput) {
-        state.amountSpecifiedRemaining = JSBI4__default.default.subtract(
-          state.amountSpecifiedRemaining,
-          JSBI4__default.default.add(step.amountIn, step.feeAmount)
-        );
-        state.amountCalculated = JSBI4__default.default.subtract(state.amountCalculated, step.amountOut);
+        state.amountSpecifiedRemaining = state.amountSpecifiedRemaining - (step.amountIn + step.feeAmount);
+        state.amountCalculated = state.amountCalculated - step.amountOut;
       } else {
-        state.amountSpecifiedRemaining = JSBI4__default.default.add(state.amountSpecifiedRemaining, step.amountOut);
-        state.amountCalculated = JSBI4__default.default.add(state.amountCalculated, JSBI4__default.default.add(step.amountIn, step.feeAmount));
+        state.amountSpecifiedRemaining = state.amountSpecifiedRemaining + step.amountOut;
+        state.amountCalculated = state.amountCalculated + (step.amountIn + step.feeAmount);
       }
-      if (JSBI4__default.default.equal(state.sqrtPriceX96, step.sqrtPriceNextX96)) {
+      if (state.sqrtPriceX96 === step.sqrtPriceNextX96) {
         if (step.initialized) {
-          let liquidityNet = JSBI4__default.default.BigInt((await this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
+          let liquidityNet = BigInt((await this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
           if (zeroForOne)
-            liquidityNet = JSBI4__default.default.multiply(liquidityNet, NEGATIVE_ONE);
+            liquidityNet = liquidityNet * NEGATIVE_ONE;
           state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
         }
         state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
-      } else if (JSBI4__default.default.notEqual(state.sqrtPriceX96, step.sqrtPriceStartX96)) {
+      } else if (state.sqrtPriceX96 !== step.sqrtPriceStartX96) {
         state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
       }
     }
@@ -1103,7 +1091,7 @@ var Position = class {
     this.pool = pool;
     this.tickLower = tickLower;
     this.tickUpper = tickUpper;
-    this.liquidity = JSBI4__default.default.BigInt(liquidity);
+    this.liquidity = BigInt(liquidity);
   }
   /**
    * Returns the price of token0 at the lower tick
@@ -1162,12 +1150,12 @@ var Position = class {
     const priceLower = this.pool.token0Price.asFraction.multiply(new sdk.Percent(1).subtract(slippageTolerance));
     const priceUpper = this.pool.token0Price.asFraction.multiply(slippageTolerance.add(1));
     let sqrtRatioX96Lower = encodeSqrtRatioX96(priceLower.numerator, priceLower.denominator);
-    if (JSBI4__default.default.lessThanOrEqual(sqrtRatioX96Lower, TickMath.MIN_SQRT_RATIO)) {
-      sqrtRatioX96Lower = JSBI4__default.default.add(TickMath.MIN_SQRT_RATIO, JSBI4__default.default.BigInt(1));
+    if (sqrtRatioX96Lower <= TickMath.MIN_SQRT_RATIO) {
+      sqrtRatioX96Lower = TickMath.MIN_SQRT_RATIO + 1n;
     }
     let sqrtRatioX96Upper = encodeSqrtRatioX96(priceUpper.numerator, priceUpper.denominator);
-    if (JSBI4__default.default.greaterThanOrEqual(sqrtRatioX96Upper, TickMath.MAX_SQRT_RATIO)) {
-      sqrtRatioX96Upper = JSBI4__default.default.subtract(TickMath.MAX_SQRT_RATIO, JSBI4__default.default.BigInt(1));
+    if (sqrtRatioX96Upper >= TickMath.MAX_SQRT_RATIO) {
+      sqrtRatioX96Upper = TickMath.MAX_SQRT_RATIO - 1n;
     }
     return {
       sqrtRatioX96Lower,
@@ -1401,7 +1389,7 @@ var Route = class {
     this.pools = pools;
     this.tokenPath = tokenPath;
     this.input = input;
-    this.output = output != null ? output : tokenPath[tokenPath.length - 1];
+    this.output = output ?? tokenPath[tokenPath.length - 1];
   }
   get chainId() {
     return this.pools[0].chainId;
@@ -1492,13 +1480,12 @@ var Trade = class {
    * The price expressed in terms of output amount/input amount.
    */
   get executionPrice() {
-    var _a;
-    return (_a = this._executionPrice) != null ? _a : this._executionPrice = new sdk.Price(
+    return this._executionPrice ?? (this._executionPrice = new sdk.Price(
       this.inputAmount.currency,
       this.outputAmount.currency,
       this.inputAmount.quotient,
       this.outputAmount.quotient
-    );
+    ));
   }
   /**
    * Returns the percent difference between the route's mid price and the price impact
@@ -2757,7 +2744,7 @@ var Payments = _Payments;
 Payments.INTERFACE = new abi.Interface(IPeripheryPaymentsWithFee_default);
 
 // src/nonfungiblePositionManager.ts
-var MaxUint128 = toHex(JSBI4__default.default.subtract(JSBI4__default.default.exponentiate(JSBI4__default.default.BigInt(2), JSBI4__default.default.BigInt(128)), JSBI4__default.default.BigInt(1)));
+var MaxUint128 = toHex(2n ** 128n - 1n);
 function isMint(options) {
   return Object.keys(options).some((k) => k === "recipient");
 }
@@ -2783,7 +2770,7 @@ var _NonfungiblePositionManager = class {
     };
   }
   static addCallParameters(position, options) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(position.liquidity, ZERO), "ZERO_LIQUIDITY");
+    invariant11__default.default(position.liquidity > ZERO, "ZERO_LIQUIDITY");
     const calldatas = [];
     const { amount0: amount0Desired, amount1: amount1Desired } = position.mintAmounts;
     const minimumAmounts = position.mintAmountsWithSlippage(options.slippageTolerance);
@@ -2837,7 +2824,7 @@ var _NonfungiblePositionManager = class {
       const { wrapped } = options.useNative;
       invariant11__default.default(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
       const wrappedValue = position.pool.token0.equals(wrapped) ? amount0Desired : amount1Desired;
-      if (JSBI4__default.default.greaterThan(wrappedValue, ZERO)) {
+      if (wrappedValue > ZERO) {
         calldatas.push(Payments.encodeRefundETH());
       }
       value = toHex(wrappedValue);
@@ -2894,7 +2881,7 @@ var _NonfungiblePositionManager = class {
       tickLower: position.tickLower,
       tickUpper: position.tickUpper
     });
-    invariant11__default.default(JSBI4__default.default.greaterThan(partialPosition.liquidity, ZERO), "ZERO_LIQUIDITY");
+    invariant11__default.default(partialPosition.liquidity > ZERO, "ZERO_LIQUIDITY");
     const { amount0: amount0Min, amount1: amount1Min } = partialPosition.burnAmountsWithSlippage(
       options.slippageTolerance
     );
@@ -3486,7 +3473,6 @@ var SwapQuoter = class {
    * @returns The formatted calldata
    */
   static quoteCallParameters(route, amount, tradeType, options = {}) {
-    var _a;
     const singleHop = route.pools.length === 1;
     const quoteAmount = toHex(amount.quotient);
     let calldata;
@@ -3496,7 +3482,7 @@ var SwapQuoter = class {
         tokenIn: route.tokenPath[0].address,
         tokenOut: route.tokenPath[1].address,
         fee: route.pools[0].fee,
-        sqrtPriceLimitX96: toHex((_a = options == null ? void 0 : options.sqrtPriceLimitX96) != null ? _a : 0)
+        sqrtPriceLimitX96: toHex(options?.sqrtPriceLimitX96 ?? 0)
       };
       const v2QuoteParams = {
         ...baseQuoteParams,
@@ -3515,7 +3501,7 @@ var SwapQuoter = class {
         options.useQuoterV2 ? [v2QuoteParams] : v1QuoteParams
       );
     } else {
-      invariant11__default.default((options == null ? void 0 : options.sqrtPriceLimitX96) === void 0, "MULTIHOP_PRICE_LIMIT");
+      invariant11__default.default(options?.sqrtPriceLimitX96 === void 0, "MULTIHOP_PRICE_LIMIT");
       const path = encodeRouteToPath(route, tradeType === sdk.TradeType.EXACT_OUTPUT);
       const tradeTypeFunctionName = tradeType === sdk.TradeType.EXACT_INPUT ? "quoteExactInput" : "quoteExactOutput";
       calldata = swapInterface.encodeFunctionData(tradeTypeFunctionName, [path, quoteAmount]);
@@ -4248,7 +4234,6 @@ var _Staker = class {
    * @returns The calldatas for 'unstakeToken' and 'claimReward'.
    */
   static encodeClaim(incentiveKey, options) {
-    var _a;
     const calldatas = [];
     calldatas.push(
       _Staker.INTERFACE.encodeFunctionData("unstakeToken", [
@@ -4257,7 +4242,7 @@ var _Staker = class {
       ])
     );
     const recipient = sdk.validateAndParseAddress(options.recipient);
-    const amount = (_a = options.amount) != null ? _a : 0;
+    const amount = options.amount ?? 0;
     calldatas.push(
       _Staker.INTERFACE.encodeFunctionData("claimReward", [incentiveKey.rewardToken.address, recipient, toHex(amount)])
     );
@@ -4960,7 +4945,6 @@ var _SwapRouter = class {
    * @param options options for the call parameters
    */
   static swapCallParameters(trades, options) {
-    var _a, _b;
     if (!Array.isArray(trades)) {
       trades = [trades];
     }
@@ -5008,7 +4992,7 @@ var _SwapRouter = class {
               deadline,
               amountIn,
               amountOutMinimum: amountOut,
-              sqrtPriceLimitX96: toHex((_a = options.sqrtPriceLimitX96) != null ? _a : 0)
+              sqrtPriceLimitX96: toHex(options.sqrtPriceLimitX96 ?? 0)
             };
             calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactInputSingle", [exactInputSingleParams]));
           } else {
@@ -5020,7 +5004,7 @@ var _SwapRouter = class {
               deadline,
               amountOut,
               amountInMaximum: amountIn,
-              sqrtPriceLimitX96: toHex((_b = options.sqrtPriceLimitX96) != null ? _b : 0)
+              sqrtPriceLimitX96: toHex(options.sqrtPriceLimitX96 ?? 0)
             };
             calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactOutputSingle", [exactOutputSingleParams]));
           }
@@ -5768,7 +5752,7 @@ var _MasterChefV3 = class {
   // Copy from NonfungiblePositionManager
   // Only support increaseLiquidity
   static addCallParameters(position, options) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(position.liquidity, sdk.ZERO), "ZERO_LIQUIDITY");
+    invariant11__default.default(position.liquidity > sdk.ZERO, "ZERO_LIQUIDITY");
     const calldatas = [];
     const { amount0: amount0Desired, amount1: amount1Desired } = position.mintAmounts;
     const minimumAmounts = position.mintAmountsWithSlippage(options.slippageTolerance);
@@ -5848,7 +5832,7 @@ var _MasterChefV3 = class {
       tickLower: position.tickLower,
       tickUpper: position.tickUpper
     });
-    invariant11__default.default(JSBI4__default.default.greaterThan(partialPosition.liquidity, sdk.ZERO), "ZERO_LIQUIDITY");
+    invariant11__default.default(partialPosition.liquidity > sdk.ZERO, "ZERO_LIQUIDITY");
     const { amount0: amount0Min, amount1: amount1Min } = partialPosition.burnAmountsWithSlippage(
       options.slippageTolerance
     );
@@ -5889,19 +5873,19 @@ var _MasterChefV3 = class {
         ...rest
       })
     );
-    if (rest == null ? void 0 : rest.recipient) {
+    if (rest?.recipient) {
       if (options.liquidityPercentage.equalTo(sdk.ONE)) {
         calldatas.push(
           _MasterChefV3.INTERFACE.encodeFunctionData("withdraw", [
             tokenId.toString(),
-            sdk.validateAndParseAddress(rest == null ? void 0 : rest.recipient)
+            sdk.validateAndParseAddress(rest?.recipient)
           ])
         );
       } else {
         calldatas.push(
           _MasterChefV3.INTERFACE.encodeFunctionData("harvest", [
             tokenId.toString(),
-            sdk.validateAndParseAddress(rest == null ? void 0 : rest.recipient)
+            sdk.validateAndParseAddress(rest?.recipient)
           ])
         );
       }
@@ -5997,6 +5981,8 @@ exports.getAmountsByLiquidityAndPrice = getAmountsByLiquidityAndPrice;
 exports.getAverageLiquidity = getAverageLiquidity;
 exports.getDependentAmount = getDependentAmount;
 exports.getEstimatedLPFee = getEstimatedLPFee;
+exports.getEstimatedLPFeeByAmounts = getEstimatedLPFeeByAmounts;
+exports.getEstimatedLPFeeByAmountsWithProtocolFee = getEstimatedLPFeeByAmountsWithProtocolFee;
 exports.getEstimatedLPFeeWithProtocolFee = getEstimatedLPFeeWithProtocolFee;
 exports.getLiquidityByAmountsAndPrice = getLiquidityByAmountsAndPrice;
 exports.getLiquidityBySingleAmount = getLiquidityBySingleAmount;
@@ -6009,6 +5995,7 @@ exports.mostSignificantBit = mostSignificantBit;
 exports.nearestUsableTick = nearestUsableTick;
 exports.parseProtocolFees = parseProtocolFees;
 exports.priceToClosestTick = priceToClosestTick;
+exports.sqrtRatioX96ToPrice = sqrtRatioX96ToPrice;
 exports.subIn256 = subIn256;
 exports.tickToPrice = tickToPrice;
 exports.toHex = toHex;