@pancakeswap/v3-sdk 1.0.0 → 3.0.0

package/dist/index.mjs

@@ -1,10 +1,7 @@
-import { ChainId, JSBI as JSBI$1, MaxUint256, sqrt, Price, Fraction, ZERO as ZERO$1, CurrencyAmount, Percent as Percent$1, TradeType, sortedInsert, validateAndParseAddress, ONE as ONE$1 } from '@pancakeswap/sdk';
-import JSBI4 from 'jsbi';
-import invariant11 from 'tiny-invariant';
-import { JSBI, Percent, Price as Price$1, Fraction as Fraction$1 } from '@pancakeswap/swap-sdk-core';
-import { Interface, defaultAbiCoder } from '@ethersproject/abi';
-import { getCreate2Address } from '@ethersproject/address';
-import { keccak256, pack } from '@ethersproject/solidity';
+import { ChainId, Price, CurrencyAmount, Percent as Percent$1, MaxUint256 as MaxUint256$1, TradeType, Fraction, sortedInsert, validateAndParseAddress, ZERO as ZERO$2, ONE as ONE$1 } from '@pancakeswap/sdk';
+import invariant9 from 'tiny-invariant';
+import { Percent, MaxUint256, sqrt, Price as Price$1, CurrencyAmount as CurrencyAmount$1, Fraction as Fraction$1, ZERO as ZERO$1, TradeType as TradeType$1 } from '@pancakeswap/swap-sdk-core';
+import { keccak256, encodeAbiParameters, parseAbiParameters, encodePacked, encodeFunctionData, toBytes, getAddress, pad, isBytes, slice, concat } from 'viem';
 
 // src/entities/pool.ts
 var FACTORY_ADDRESS = "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865";
@@ -30,15 +27,22 @@ var TICK_SPACINGS = {
   [2500 /* MEDIUM */]: 50,
   [1e4 /* HIGH */]: 200
 };
-var NEGATIVE_ONE = JSBI.BigInt(-1);
-var ZERO = JSBI.BigInt(0);
-var ONE = JSBI.BigInt(1);
-var Q96 = JSBI.exponentiate(JSBI.BigInt(2), JSBI.BigInt(96));
-var Q192 = JSBI.exponentiate(Q96, JSBI.BigInt(2));
-var MAX_FEE = JSBI.exponentiate(JSBI.BigInt(10), 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 Percent("1");
 var ZERO_PERCENT = new Percent("0");
-var Q128 = JSBI.exponentiate(JSBI.BigInt(2), JSBI.BigInt(128));
+var Q128 = 2n ** 128n;
+function getCreate2Address(from_, salt_, initCodeHash) {
+  const from = toBytes(getAddress(from_));
+  const salt = pad(isBytes(salt_) ? salt_ : toBytes(salt_), {
+    size: 32
+  });
+  return getAddress(slice(keccak256(concat([toBytes("0xff"), from, salt, toBytes(initCodeHash)])), 12));
+}
 function computePoolAddress({
   deployerAddress,
   tokenA,
@@ -50,12 +54,13 @@ function computePoolAddress({
   return getCreate2Address(
     deployerAddress,
     keccak256(
-      ["bytes"],
-      [defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]
+      encodeAbiParameters(parseAbiParameters(["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.
@@ -63,12 +68,14 @@ var LiquidityMath = class {
   constructor() {
   }
   static addDelta(x, y) {
-    if (JSBI4.lessThan(y, ZERO)) {
-      return JSBI4.subtract(x, JSBI4.multiply(y, NEGATIVE_ONE));
+    if (y < ZERO) {
+      return x - y * NEGATIVE_ONE;
     }
-    return JSBI4.add(x, y);
+    return x + y;
   }
 };
+
+// src/utils/fullMath.ts
 var FullMath = class {
   /**
    * Cannot be constructed.
@@ -76,21 +83,21 @@ var FullMath = class {
   constructor() {
   }
   static mulDivRoundingUp(a, b, denominator) {
-    const product = JSBI4.multiply(a, b);
-    let result = JSBI4.divide(product, denominator);
-    if (JSBI4.notEqual(JSBI4.remainder(product, denominator), ZERO))
-      result = JSBI4.add(result, ONE);
+    const product = a * b;
+    let result = product / denominator;
+    if (product % denominator !== ZERO)
+      result = result + ONE;
     return result;
   }
 };
-var MaxUint160 = JSBI4.subtract(JSBI4.exponentiate(JSBI4.BigInt(2), JSBI4.BigInt(160)), ONE);
+var MaxUint160 = 2n ** 160n - ONE;
 function multiplyIn256(x, y) {
-  const product = JSBI4.multiply(x, y);
-  return JSBI4.bitwiseAnd(product, MaxUint256);
+  const product = x * y;
+  return product & MaxUint256;
 }
 function addIn256(x, y) {
-  const sum = JSBI4.add(x, y);
-  return JSBI4.bitwiseAnd(sum, MaxUint256);
+  const sum = x + y;
+  return sum & MaxUint256;
 }
 var SqrtPriceMath = class {
   /**
@@ -99,59 +106,59 @@ var SqrtPriceMath = class {
   constructor() {
   }
   static getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
-    if (JSBI4.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
       sqrtRatioAX96 = sqrtRatioBX96;
       sqrtRatioBX96 = sqrtRatioAX96;
     }
-    const numerator1 = JSBI4.leftShift(liquidity, JSBI4.BigInt(96));
-    const numerator2 = JSBI4.subtract(sqrtRatioBX96, sqrtRatioAX96);
-    return roundUp ? FullMath.mulDivRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96), ONE, sqrtRatioAX96) : JSBI4.divide(JSBI4.divide(JSBI4.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.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
       sqrtRatioAX96 = sqrtRatioBX96;
       sqrtRatioBX96 = sqrtRatioAX96;
     }
-    return roundUp ? FullMath.mulDivRoundingUp(liquidity, JSBI4.subtract(sqrtRatioBX96, sqrtRatioAX96), Q96) : JSBI4.divide(JSBI4.multiply(liquidity, JSBI4.subtract(sqrtRatioBX96, sqrtRatioAX96)), Q96);
+    return roundUp ? FullMath.mulDivRoundingUp(liquidity, sqrtRatioBX96 - sqrtRatioAX96, Q96) : liquidity * (sqrtRatioBX96 - sqrtRatioAX96) / Q96;
   }
   static getNextSqrtPriceFromInput(sqrtPX96, liquidity, amountIn, zeroForOne) {
-    invariant11(JSBI4.greaterThan(sqrtPX96, ZERO));
-    invariant11(JSBI4.greaterThan(liquidity, ZERO));
+    invariant9(sqrtPX96 > ZERO);
+    invariant9(liquidity > ZERO);
     return zeroForOne ? this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true) : this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountIn, true);
   }
   static getNextSqrtPriceFromOutput(sqrtPX96, liquidity, amountOut, zeroForOne) {
-    invariant11(JSBI4.greaterThan(sqrtPX96, ZERO));
-    invariant11(JSBI4.greaterThan(liquidity, ZERO));
+    invariant9(sqrtPX96 > ZERO);
+    invariant9(liquidity > ZERO);
     return zeroForOne ? this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountOut, false) : this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountOut, false);
   }
   static getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amount, add) {
-    if (JSBI4.equal(amount, ZERO))
+    if (amount === ZERO)
       return sqrtPX96;
-    const numerator1 = JSBI4.leftShift(liquidity, JSBI4.BigInt(96));
+    const numerator1 = liquidity << 96n;
     if (add) {
       const product2 = multiplyIn256(amount, sqrtPX96);
-      if (JSBI4.equal(JSBI4.divide(product2, amount), sqrtPX96)) {
+      if (product2 / amount === sqrtPX96) {
         const denominator2 = addIn256(numerator1, product2);
-        if (JSBI4.greaterThanOrEqual(denominator2, numerator1)) {
+        if (denominator2 >= numerator1) {
           return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator2);
         }
       }
-      return FullMath.mulDivRoundingUp(numerator1, ONE, JSBI4.add(JSBI4.divide(numerator1, sqrtPX96), amount));
+      return FullMath.mulDivRoundingUp(numerator1, ONE, numerator1 / sqrtPX96 + amount);
     }
     const product = multiplyIn256(amount, sqrtPX96);
-    invariant11(JSBI4.equal(JSBI4.divide(product, amount), sqrtPX96));
-    invariant11(JSBI4.greaterThan(numerator1, product));
-    const denominator = JSBI4.subtract(numerator1, product);
+    invariant9(product / amount === sqrtPX96);
+    invariant9(numerator1 > product);
+    const denominator = numerator1 - product;
     return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator);
   }
   static getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amount, add) {
     if (add) {
-      const quotient2 = JSBI4.lessThanOrEqual(amount, MaxUint160) ? JSBI4.divide(JSBI4.leftShift(amount, JSBI4.BigInt(96)), liquidity) : JSBI4.divide(JSBI4.multiply(amount, Q96), liquidity);
-      return JSBI4.add(sqrtPX96, quotient2);
+      const quotient2 = amount <= MaxUint160 ? (amount << 96n) / liquidity : amount * Q96 / liquidity;
+      return sqrtPX96 + quotient2;
     }
     const quotient = FullMath.mulDivRoundingUp(amount, Q96, liquidity);
-    invariant11(JSBI4.greaterThan(sqrtPX96, quotient));
-    return JSBI4.subtract(sqrtPX96, quotient);
+    invariant9(sqrtPX96 > quotient);
+    return sqrtPX96 - quotient;
   }
 };
 
@@ -164,15 +171,12 @@ var SwapMath = class {
   }
   static computeSwapStep(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, amountRemaining, feePips) {
     const returnValues = {};
-    const zeroForOne = JSBI4.greaterThanOrEqual(sqrtRatioCurrentX96, sqrtRatioTargetX96);
-    const exactIn = JSBI4.greaterThanOrEqual(amountRemaining, ZERO);
+    const zeroForOne = sqrtRatioCurrentX96 >= sqrtRatioTargetX96;
+    const exactIn = amountRemaining >= ZERO;
     if (exactIn) {
-      const amountRemainingLessFee = JSBI4.divide(
-        JSBI4.multiply(amountRemaining, JSBI4.subtract(MAX_FEE, JSBI4.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.greaterThanOrEqual(amountRemainingLessFee, returnValues.amountIn)) {
+      if (amountRemainingLessFee >= returnValues.amountIn) {
         returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
       } else {
         returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
@@ -184,18 +188,18 @@ var SwapMath = class {
       }
     } else {
       returnValues.amountOut = zeroForOne ? SqrtPriceMath.getAmount1Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, false) : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, false);
-      if (JSBI4.greaterThanOrEqual(JSBI4.multiply(amountRemaining, NEGATIVE_ONE), returnValues.amountOut)) {
+      if (amountRemaining * NEGATIVE_ONE >= returnValues.amountOut) {
         returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
       } else {
         returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
           sqrtRatioCurrentX96,
           liquidity,
-          JSBI4.multiply(amountRemaining, NEGATIVE_ONE),
+          amountRemaining * NEGATIVE_ONE,
           zeroForOne
         );
       }
     }
-    const max = JSBI4.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);
@@ -203,33 +207,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.greaterThan(returnValues.amountOut, JSBI4.multiply(amountRemaining, NEGATIVE_ONE))) {
-      returnValues.amountOut = JSBI4.multiply(amountRemaining, NEGATIVE_ONE);
+    if (!exactIn && returnValues.amountOut > amountRemaining * NEGATIVE_ONE) {
+      returnValues.amountOut = amountRemaining * NEGATIVE_ONE;
     }
-    if (exactIn && JSBI4.notEqual(returnValues.sqrtRatioNextX96, sqrtRatioTargetX96)) {
-      returnValues.feeAmount = JSBI4.subtract(amountRemaining, returnValues.amountIn);
+    if (exactIn && returnValues.sqrtRatioNextX96 !== sqrtRatioTargetX96) {
+      returnValues.feeAmount = amountRemaining - returnValues.amountIn;
     } else {
       returnValues.feeAmount = FullMath.mulDivRoundingUp(
         returnValues.amountIn,
-        JSBI4.BigInt(feePips),
-        JSBI4.subtract(MAX_FEE, JSBI4.BigInt(feePips))
+        BigInt(feePips),
+        MAX_FEE - BigInt(feePips)
       );
     }
     return [returnValues.sqrtRatioNextX96, returnValues.amountIn, returnValues.amountOut, returnValues.feeAmount];
   }
 };
-var TWO = JSBI4.BigInt(2);
-var POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow) => [
-  pow,
-  JSBI4.exponentiate(TWO, JSBI4.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(JSBI4.greaterThan(x, ZERO), "ZERO");
-  invariant11(JSBI4.lessThanOrEqual(x, MaxUint256), "MAX");
+  invariant9(x > ZERO, "ZERO");
+  invariant9(x <= MaxUint256, "MAX");
   let msb = 0;
   for (const [power, min] of POWERS_OF_2) {
-    if (JSBI4.greaterThanOrEqual(x, min)) {
-      x = JSBI4.signedRightShift(x, JSBI4.BigInt(power));
+    if (x >= min) {
+      x = x >> BigInt(power);
       msb += power;
     }
   }
@@ -238,9 +239,9 @@ function mostSignificantBit(x) {
 
 // src/utils/tickMath.ts
 function mulShift(val, mulBy) {
-  return JSBI$1.signedRightShift(JSBI$1.multiply(val, JSBI$1.BigInt(mulBy)), JSBI$1.BigInt(128));
+  return val * BigInt(mulBy) >> 128n;
 }
-var Q32 = JSBI$1.exponentiate(JSBI$1.BigInt(2), JSBI$1.BigInt(32));
+var Q32 = 2n ** 32n;
 var _TickMath = class {
   /**
    * Cannot be constructed.
@@ -252,9 +253,9 @@ var _TickMath = class {
    * @param tick the tick for which to compute the sqrt ratio
    */
   static getSqrtRatioAtTick(tick) {
-    invariant11(tick >= _TickMath.MIN_TICK && tick <= _TickMath.MAX_TICK && Number.isInteger(tick), "TICK");
+    invariant9(tick >= _TickMath.MIN_TICK && tick <= _TickMath.MAX_TICK && Number.isInteger(tick), "TICK");
     const absTick = tick < 0 ? tick * -1 : tick;
-    let ratio = (absTick & 1) != 0 ? JSBI$1.BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : JSBI$1.BigInt("0x100000000000000000000000000000000");
+    let ratio = (absTick & 1) != 0 ? BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : BigInt("0x100000000000000000000000000000000");
     if ((absTick & 2) != 0)
       ratio = mulShift(ratio, "0xfff97272373d413259a46990580e213a");
     if ((absTick & 4) != 0)
@@ -294,8 +295,8 @@ var _TickMath = class {
     if ((absTick & 524288) != 0)
       ratio = mulShift(ratio, "0x48a170391f7dc42444e8fa2");
     if (tick > 0)
-      ratio = JSBI$1.divide(MaxUint256, ratio);
-    return JSBI$1.greaterThan(JSBI$1.remainder(ratio, Q32), ZERO) ? JSBI$1.add(JSBI$1.divide(ratio, Q32), ONE) : JSBI$1.divide(ratio, Q32);
+      ratio = 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
@@ -303,39 +304,26 @@ var _TickMath = class {
    * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
    */
   static getTickAtSqrtRatio(sqrtRatioX96) {
-    invariant11(
-      JSBI$1.greaterThanOrEqual(sqrtRatioX96, _TickMath.MIN_SQRT_RATIO) && JSBI$1.lessThan(sqrtRatioX96, _TickMath.MAX_SQRT_RATIO),
-      "SQRT_RATIO"
-    );
-    const sqrtRatioX128 = JSBI$1.leftShift(sqrtRatioX96, JSBI$1.BigInt(32));
+    invariant9(sqrtRatioX96 >= _TickMath.MIN_SQRT_RATIO && sqrtRatioX96 < _TickMath.MAX_SQRT_RATIO, "SQRT_RATIO");
+    const sqrtRatioX128 = sqrtRatioX96 << 32n;
     const msb = mostSignificantBit(sqrtRatioX128);
     let r;
-    if (JSBI$1.greaterThanOrEqual(JSBI$1.BigInt(msb), JSBI$1.BigInt(128))) {
-      r = JSBI$1.signedRightShift(sqrtRatioX128, JSBI$1.BigInt(msb - 127));
+    if (BigInt(msb) >= 128n) {
+      r = sqrtRatioX128 >> BigInt(msb - 127);
     } else {
-      r = JSBI$1.leftShift(sqrtRatioX128, JSBI$1.BigInt(127 - msb));
+      r = sqrtRatioX128 << BigInt(127 - msb);
     }
-    let log_2 = JSBI$1.leftShift(JSBI$1.subtract(JSBI$1.BigInt(msb), JSBI$1.BigInt(128)), JSBI$1.BigInt(64));
+    let log_2 = BigInt(msb) - 128n << 64n;
     for (let i = 0; i < 14; i++) {
-      r = JSBI$1.signedRightShift(JSBI$1.multiply(r, r), JSBI$1.BigInt(127));
-      const f = JSBI$1.signedRightShift(r, JSBI$1.BigInt(128));
-      log_2 = JSBI$1.bitwiseOr(log_2, JSBI$1.leftShift(f, JSBI$1.BigInt(63 - i)));
-      r = JSBI$1.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 = JSBI$1.multiply(log_2, JSBI$1.BigInt("255738958999603826347141"));
-    const tickLow = JSBI$1.toNumber(
-      JSBI$1.signedRightShift(
-        JSBI$1.subtract(log_sqrt10001, JSBI$1.BigInt("3402992956809132418596140100660247210")),
-        JSBI$1.BigInt(128)
-      )
-    );
-    const tickHigh = JSBI$1.toNumber(
-      JSBI$1.signedRightShift(
-        JSBI$1.add(log_sqrt10001, JSBI$1.BigInt("291339464771989622907027621153398088495")),
-        JSBI$1.BigInt(128)
-      )
-    );
-    return tickLow === tickHigh ? tickLow : JSBI$1.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;
@@ -351,11 +339,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 = JSBI$1.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 = JSBI$1.BigInt("1461446703485210103287273052203988822378723970342");
+TickMath.MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
 
 // src/entities/tickDataProvider.ts
 var _NoTickDataProvider = class {
@@ -390,31 +378,25 @@ var TickList = class {
   constructor() {
   }
   static validateList(ticks, tickSpacing) {
-    invariant11(tickSpacing > 0, "TICK_SPACING_NONZERO");
-    invariant11(
+    invariant9(tickSpacing > 0, "TICK_SPACING_NONZERO");
+    invariant9(
       ticks.every(({ index }) => index % tickSpacing === 0),
       "TICK_SPACING"
     );
-    invariant11(
-      JSBI4.equal(
-        ticks.reduce((accumulator, { liquidityNet }) => JSBI4.add(accumulator, liquidityNet), ZERO),
-        ZERO
-      ),
-      "ZERO_NET"
-    );
-    invariant11(isSorted(ticks, tickComparator), "SORTED");
+    invariant9(ticks.reduce((accumulator, { liquidityNet }) => accumulator + liquidityNet, ZERO) === ZERO, "ZERO_NET");
+    invariant9(isSorted(ticks, tickComparator), "SORTED");
   }
   static isBelowSmallest(ticks, tick) {
-    invariant11(ticks.length > 0, "LENGTH");
+    invariant9(ticks.length > 0, "LENGTH");
     return tick < ticks[0].index;
   }
   static isAtOrAboveLargest(ticks, tick) {
-    invariant11(ticks.length > 0, "LENGTH");
+    invariant9(ticks.length > 0, "LENGTH");
     return tick >= ticks[ticks.length - 1].index;
   }
   static getTick(ticks, index) {
     const tick = ticks[this.binarySearch(ticks, index)];
-    invariant11(tick.index === index, "NOT_CONTAINED");
+    invariant9(tick.index === index, "NOT_CONTAINED");
     return tick;
   }
   /**
@@ -424,7 +406,7 @@ var TickList = class {
    * @private
    */
   static binarySearch(ticks, tick) {
-    invariant11(!this.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+    invariant9(!this.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
     let l = 0;
     let r = ticks.length - 1;
     let i;
@@ -442,14 +424,14 @@ var TickList = class {
   }
   static nextInitializedTick(ticks, tick, lte) {
     if (lte) {
-      invariant11(!TickList.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+      invariant9(!TickList.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
       if (TickList.isAtOrAboveLargest(ticks, tick)) {
         return ticks[ticks.length - 1];
       }
       const index2 = this.binarySearch(ticks, tick);
       return ticks[index2];
     }
-    invariant11(!this.isAtOrAboveLargest(ticks, tick), "AT_OR_ABOVE_LARGEST");
+    invariant9(!this.isAtOrAboveLargest(ticks, tick), "AT_OR_ABOVE_LARGEST");
     if (this.isBelowSmallest(ticks, tick)) {
       return ticks[0];
     }
@@ -486,116 +468,273 @@ var TickList = class {
     return Math.abs(beforeIndex - afterIndex);
   }
 };
-function toHex(bigintIsh) {
-  const bigInt = JSBI4.BigInt(bigintIsh);
-  let hex = bigInt.toString(16);
-  if (hex.length % 2 !== 0) {
-    hex = `0${hex}`;
+var Tick = class {
+  constructor({ index, liquidityGross, liquidityNet }) {
+    invariant9(index >= TickMath.MIN_TICK && index <= TickMath.MAX_TICK, "TICK");
+    this.index = index;
+    this.liquidityGross = BigInt(liquidityGross);
+    this.liquidityNet = BigInt(liquidityNet);
   }
-  return `0x${hex}`;
-}
-function encodeRouteToPath(route, exactOutput) {
-  const firstInputToken = route.input.wrapped;
-  const { path, types } = route.pools.reduce(
-    ({ inputToken, path: path2, types: types2 }, pool, index) => {
-      const outputToken = pool.token0.equals(inputToken) ? pool.token1 : pool.token0;
-      if (index === 0) {
-        return {
-          inputToken: outputToken,
-          types: ["address", "uint24", "address"],
-          path: [inputToken.address, pool.fee, outputToken.address]
-        };
+};
+
+// src/entities/tickListDataProvider.ts
+var TickListDataProvider = class {
+  constructor(ticks) {
+    const ticksMapped = ticks.map((t) => t instanceof Tick ? t : new Tick(t));
+    this.ticks = ticksMapped;
+  }
+  async getTick(tick) {
+    return TickList.getTick(this.ticks, tick);
+  }
+  async nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
+    return TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
+  }
+};
+
+// src/entities/pool.ts
+var NO_TICK_DATA_PROVIDER_DEFAULT = new NoTickDataProvider();
+var Pool = class {
+  static getAddress(tokenA, tokenB, fee, initCodeHashManualOverride, deployerAddressOverride) {
+    return computePoolAddress({
+      deployerAddress: deployerAddressOverride ?? DEPLOYER_ADDRESSES[tokenA.chainId],
+      fee,
+      tokenA,
+      tokenB,
+      initCodeHashManualOverride
+    });
+  }
+  /**
+   * Construct a pool
+   * @param tokenA One of the tokens in the pool
+   * @param tokenB The other token in the pool
+   * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+   * @param sqrtRatioX96 The sqrt of the current ratio of amounts of token1 to token0
+   * @param liquidity The current value of in range liquidity
+   * @param tickCurrent The current tick of the pool
+   * @param ticks The current state of the pool ticks or a data provider that can return tick data
+   */
+  constructor(tokenA, tokenB, fee, sqrtRatioX96, liquidity, tickCurrent, ticks = NO_TICK_DATA_PROVIDER_DEFAULT) {
+    invariant9(Number.isInteger(fee) && fee < 1e6, "FEE");
+    [this.token0, this.token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
+    this.fee = fee;
+    this.sqrtRatioX96 = BigInt(sqrtRatioX96);
+    this.liquidity = BigInt(liquidity);
+    this.tickCurrent = tickCurrent;
+    this.tickDataProvider = Array.isArray(ticks) ? new TickListDataProvider(ticks) : ticks;
+  }
+  /**
+   * Returns true if the token is either token0 or token1
+   * @param token The token to check
+   * @returns True if token is either token0 or token
+   */
+  involvesToken(token) {
+    return token.equals(this.token0) || token.equals(this.token1);
+  }
+  /**
+   * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+   */
+  get token0Price() {
+    return this._token0Price ?? (this._token0Price = new 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() {
+    return this._token1Price ?? (this._token1Price = new 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.
+   * @param token The token to return price of
+   * @returns The price of the given token, in terms of the other.
+   */
+  priceOf(token) {
+    invariant9(this.involvesToken(token), "TOKEN");
+    return token.equals(this.token0) ? this.token0Price : this.token1Price;
+  }
+  /**
+   * Returns the chain ID of the tokens in the pool.
+   */
+  get chainId() {
+    return this.token0.chainId;
+  }
+  /**
+   * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+   * @param inputAmount The input amount for which to quote the output amount
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit
+   * @returns The output amount and the pool with updated state
+   */
+  async getOutputAmount(inputAmount, sqrtPriceLimitX96) {
+    invariant9(this.involvesToken(inputAmount.currency), "TOKEN");
+    const zeroForOne = inputAmount.currency.equals(this.token0);
+    const {
+      amountCalculated: outputAmount,
+      sqrtRatioX96,
+      liquidity,
+      tickCurrent
+    } = await this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX96);
+    const outputToken = zeroForOne ? this.token1 : this.token0;
+    return [
+      CurrencyAmount.fromRawAmount(outputToken, outputAmount * NEGATIVE_ONE),
+      new Pool(this.token0, this.token1, this.fee, sqrtRatioX96, liquidity, tickCurrent, this.tickDataProvider)
+    ];
+  }
+  /**
+   * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+   * @param outputAmount the output amount for which to quote the input amount
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+   * @returns The input amount and the pool with updated state
+   */
+  async getInputAmount(outputAmount, sqrtPriceLimitX96) {
+    invariant9(outputAmount.currency.isToken && this.involvesToken(outputAmount.currency), "TOKEN");
+    const zeroForOne = outputAmount.currency.equals(this.token1);
+    const {
+      amountSpecifiedRemaining,
+      amountCalculated: inputAmount,
+      sqrtRatioX96,
+      liquidity,
+      tickCurrent
+    } = await this.swap(zeroForOne, outputAmount.quotient * NEGATIVE_ONE, sqrtPriceLimitX96);
+    invariant9(amountSpecifiedRemaining === ZERO, "INSUFICIENT_LIQUIDITY");
+    const inputToken = zeroForOne ? this.token0 : this.token1;
+    return [
+      CurrencyAmount.fromRawAmount(inputToken, inputAmount),
+      new Pool(this.token0, this.token1, this.fee, sqrtRatioX96, liquidity, tickCurrent, this.tickDataProvider)
+    ];
+  }
+  /**
+   * Executes a swap
+   * @param zeroForOne Whether the amount in is token0 or token1
+   * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+   * @returns amountCalculated
+   * @returns sqrtRatioX96
+   * @returns liquidity
+   * @returns tickCurrent
+   */
+  async swap(zeroForOne, amountSpecified, sqrtPriceLimitX96) {
+    if (!sqrtPriceLimitX96)
+      sqrtPriceLimitX96 = zeroForOne ? TickMath.MIN_SQRT_RATIO + ONE : TickMath.MAX_SQRT_RATIO - ONE;
+    if (zeroForOne) {
+      invariant9(sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO, "RATIO_MIN");
+      invariant9(sqrtPriceLimitX96 < this.sqrtRatioX96, "RATIO_CURRENT");
+    } else {
+      invariant9(sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO, "RATIO_MAX");
+      invariant9(sqrtPriceLimitX96 > this.sqrtRatioX96, "RATIO_CURRENT");
+    }
+    const exactInput = amountSpecified >= ZERO;
+    const state = {
+      amountSpecifiedRemaining: amountSpecified,
+      amountCalculated: ZERO,
+      sqrtPriceX96: this.sqrtRatioX96,
+      tick: this.tickCurrent,
+      liquidity: this.liquidity
+    };
+    while (state.amountSpecifiedRemaining !== ZERO && state.sqrtPriceX96 != sqrtPriceLimitX96) {
+      const step = {};
+      step.sqrtPriceStartX96 = state.sqrtPriceX96;
+      [step.tickNext, step.initialized] = await this.tickDataProvider.nextInitializedTickWithinOneWord(
+        state.tick,
+        zeroForOne,
+        this.tickSpacing
+      );
+      if (step.tickNext < TickMath.MIN_TICK) {
+        step.tickNext = TickMath.MIN_TICK;
+      } else if (step.tickNext > TickMath.MAX_TICK) {
+        step.tickNext = TickMath.MAX_TICK;
       }
-      return {
-        inputToken: outputToken,
-        types: [...types2, "uint24", "address"],
-        path: [...path2, pool.fee, outputToken.address]
-      };
-    },
-    { inputToken: firstInputToken, path: [], types: [] }
-  );
-  return exactOutput ? pack(types.reverse(), path.reverse()) : pack(types, path);
-}
-function encodeSqrtRatioX96(amount1, amount0) {
-  const numerator = JSBI4.leftShift(JSBI4.BigInt(amount1), JSBI4.BigInt(192));
-  const denominator = JSBI4.BigInt(amount0);
-  const ratioX192 = JSBI4.divide(numerator, denominator);
-  return sqrt(ratioX192);
-}
+      step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
+      [state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount] = SwapMath.computeSwapStep(
+        state.sqrtPriceX96,
+        (zeroForOne ? step.sqrtPriceNextX96 < sqrtPriceLimitX96 : step.sqrtPriceNextX96 > sqrtPriceLimitX96) ? sqrtPriceLimitX96 : step.sqrtPriceNextX96,
+        state.liquidity,
+        state.amountSpecifiedRemaining,
+        this.fee
+      );
+      if (exactInput) {
+        state.amountSpecifiedRemaining = state.amountSpecifiedRemaining - (step.amountIn + step.feeAmount);
+        state.amountCalculated = state.amountCalculated - step.amountOut;
+      } else {
+        state.amountSpecifiedRemaining = state.amountSpecifiedRemaining + step.amountOut;
+        state.amountCalculated = state.amountCalculated + (step.amountIn + step.feeAmount);
+      }
+      if (state.sqrtPriceX96 === step.sqrtPriceNextX96) {
+        if (step.initialized) {
+          let liquidityNet = BigInt((await this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
+          if (zeroForOne)
+            liquidityNet = liquidityNet * NEGATIVE_ONE;
+          state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
+        }
+        state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
+      } else if (state.sqrtPriceX96 !== step.sqrtPriceStartX96) {
+        state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
+      }
+    }
+    return {
+      amountSpecifiedRemaining: state.amountSpecifiedRemaining,
+      amountCalculated: state.amountCalculated,
+      sqrtRatioX96: state.sqrtPriceX96,
+      liquidity: state.liquidity,
+      tickCurrent: state.tick
+    };
+  }
+  get tickSpacing() {
+    return TICK_SPACINGS[this.fee];
+  }
+};
+
+// src/utils/maxLiquidityForAmounts.ts
 function maxLiquidityForAmount0Imprecise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
-  if (JSBI4.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  const intermediate = JSBI4.divide(JSBI4.multiply(sqrtRatioAX96, sqrtRatioBX96), Q96);
-  return JSBI4.divide(JSBI4.multiply(JSBI4.BigInt(amount0), intermediate), JSBI4.subtract(sqrtRatioBX96, sqrtRatioAX96));
+  const intermediate = sqrtRatioAX96 * sqrtRatioBX96 / Q96;
+  return BigInt(amount0) * intermediate / (sqrtRatioBX96 - sqrtRatioAX96);
 }
 function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
-  if (JSBI4.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  const numerator = JSBI4.multiply(JSBI4.multiply(JSBI4.BigInt(amount0), sqrtRatioAX96), sqrtRatioBX96);
-  const denominator = JSBI4.multiply(Q96, JSBI4.subtract(sqrtRatioBX96, sqrtRatioAX96));
-  return JSBI4.divide(numerator, denominator);
+  const numerator = BigInt(amount0) * sqrtRatioAX96 * sqrtRatioBX96;
+  const denominator = Q96 * (sqrtRatioBX96 - sqrtRatioAX96);
+  return numerator / denominator;
 }
 function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
-  if (JSBI4.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  return JSBI4.divide(JSBI4.multiply(JSBI4.BigInt(amount1), Q96), JSBI4.subtract(sqrtRatioBX96, sqrtRatioAX96));
+  return BigInt(amount1) * Q96 / (sqrtRatioBX96 - sqrtRatioAX96);
 }
 function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX96, amount0, amount1, useFullPrecision) {
-  if (JSBI4.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
   const maxLiquidityForAmount0 = useFullPrecision ? maxLiquidityForAmount0Precise : maxLiquidityForAmount0Imprecise;
-  if (JSBI4.lessThanOrEqual(sqrtRatioCurrentX96, sqrtRatioAX96)) {
+  if (sqrtRatioCurrentX96 <= sqrtRatioAX96) {
     return maxLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
   }
-  if (JSBI4.lessThan(sqrtRatioCurrentX96, sqrtRatioBX96)) {
+  if (sqrtRatioCurrentX96 < sqrtRatioBX96) {
     const liquidity0 = maxLiquidityForAmount0(sqrtRatioCurrentX96, sqrtRatioBX96, amount0);
     const liquidity1 = maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioCurrentX96, amount1);
-    return JSBI4.lessThan(liquidity0, liquidity1) ? liquidity0 : liquidity1;
+    return liquidity0 < liquidity1 ? liquidity0 : liquidity1;
   }
   return maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
 }
-function nearestUsableTick(tick, tickSpacing) {
-  invariant11(Number.isInteger(tick) && Number.isInteger(tickSpacing), "INTEGERS");
-  invariant11(tickSpacing > 0, "TICK_SPACING");
-  invariant11(tick >= TickMath.MIN_TICK && tick <= TickMath.MAX_TICK, "TICK_BOUND");
-  const rounded = Math.round(tick / tickSpacing) * tickSpacing;
-  if (rounded < TickMath.MIN_TICK)
-    return rounded + tickSpacing;
-  if (rounded > TickMath.MAX_TICK)
-    return rounded - tickSpacing;
-  return rounded;
+function encodeSqrtRatioX96(amount1, amount0) {
+  const numerator = BigInt(amount1) << 192n;
+  const denominator = BigInt(amount0);
+  const ratioX192 = numerator / denominator;
+  return sqrt(ratioX192);
 }
-var PositionLibrary = class {
-  /**
-   * Cannot be constructed.
-   */
-  constructor() {
-  }
-  // replicates the portions of Position#update required to compute unaccounted fees
-  static getTokensOwed(feeGrowthInside0LastX128, feeGrowthInside1LastX128, liquidity, feeGrowthInside0X128, feeGrowthInside1X128) {
-    const tokensOwed0 = JSBI$1.divide(
-      JSBI$1.multiply(subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128), liquidity),
-      Q128
-    );
-    const tokensOwed1 = JSBI$1.divide(
-      JSBI$1.multiply(subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128), liquidity),
-      Q128
-    );
-    return [tokensOwed0, tokensOwed1];
-  }
-};
+
+// src/utils/priceTickConversions.ts
 function tickToPrice(baseToken, quoteToken, tick) {
   const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
-  const ratioX192 = JSBI4.multiply(sqrtRatioX96, sqrtRatioX96);
-  return baseToken.sortsBefore(quoteToken) ? new Price(baseToken, quoteToken, Q192, ratioX192) : new Price(baseToken, quoteToken, ratioX192, Q192);
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
+  return baseToken.sortsBefore(quoteToken) ? new Price$1(baseToken, quoteToken, Q192, ratioX192) : new Price$1(baseToken, quoteToken, ratioX192, Q192);
 }
 function priceToClosestTick(price) {
   const sorted = price.baseCurrency.sortsBefore(price.quoteCurrency);
@@ -611,55 +750,16 @@ function priceToClosestTick(price) {
   }
   return tick;
 }
-var Q256 = JSBI4.exponentiate(JSBI4.BigInt(2), JSBI4.BigInt(256));
-function subIn256(x, y) {
-  const difference = JSBI4.subtract(x, y);
-  if (JSBI4.lessThan(difference, ZERO)) {
-    return JSBI4.add(Q256, difference);
-  }
-  return difference;
-}
-var TickLibrary = class {
-  /**
-   * Cannot be constructed.
-   */
-  constructor() {
-  }
-  static getFeeGrowthInside(feeGrowthOutsideLower, feeGrowthOutsideUpper, tickLower, tickUpper, tickCurrent, feeGrowthGlobal0X128, feeGrowthGlobal1X128) {
-    let feeGrowthBelow0X128;
-    let feeGrowthBelow1X128;
-    if (tickCurrent >= tickLower) {
-      feeGrowthBelow0X128 = feeGrowthOutsideLower.feeGrowthOutside0X128;
-      feeGrowthBelow1X128 = feeGrowthOutsideLower.feeGrowthOutside1X128;
-    } else {
-      feeGrowthBelow0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideLower.feeGrowthOutside0X128);
-      feeGrowthBelow1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideLower.feeGrowthOutside1X128);
-    }
-    let feeGrowthAbove0X128;
-    let feeGrowthAbove1X128;
-    if (tickCurrent < tickUpper) {
-      feeGrowthAbove0X128 = feeGrowthOutsideUpper.feeGrowthOutside0X128;
-      feeGrowthAbove1X128 = feeGrowthOutsideUpper.feeGrowthOutside1X128;
-    } else {
-      feeGrowthAbove0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideUpper.feeGrowthOutside0X128);
-      feeGrowthAbove1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideUpper.feeGrowthOutside1X128);
-    }
-    return [
-      subIn256(subIn256(feeGrowthGlobal0X128, feeGrowthBelow0X128), feeGrowthAbove0X128),
-      subIn256(subIn256(feeGrowthGlobal1X128, feeGrowthBelow1X128), feeGrowthAbove1X128)
-    ];
-  }
-};
-
-// src/utils/positionMath.ts
-function getToken0Amount(tickCurrent, tickLower, tickUpper, sqrtRatioX96, liquidity) {
-  if (tickCurrent < tickLower) {
-    return SqrtPriceMath.getAmount0Delta(
-      TickMath.getSqrtRatioAtTick(tickLower),
-      TickMath.getSqrtRatioAtTick(tickUpper),
-      liquidity,
-      false
-    );
+
+// src/utils/positionMath.ts
+function getToken0Amount(tickCurrent, tickLower, tickUpper, sqrtRatioX96, liquidity) {
+  if (tickCurrent < tickLower) {
+    return SqrtPriceMath.getAmount0Delta(
+      TickMath.getSqrtRatioAtTick(tickLower),
+      TickMath.getSqrtRatioAtTick(tickUpper),
+      liquidity,
+      false
+    );
   }
   if (tickCurrent < tickUpper) {
     return SqrtPriceMath.getAmount0Delta(sqrtRatioX96, TickMath.getSqrtRatioAtTick(tickUpper), liquidity, false);
@@ -684,434 +784,43 @@ var PositionMath = {
   getToken0Amount,
   getToken1Amount
 };
-function parseNumberToFraction(num, precision = 6) {
-  const scalar = 10 ** precision;
-  return new Fraction$1(JSBI.BigInt(Math.floor(num * scalar)), JSBI.BigInt(scalar));
-}
-
-// src/utils/feeCalculator.ts
-var FeeCalculator = {
-  getEstimatedLPFee,
-  getLiquidityFromTick,
-  getLiquidityFromSqrtRatioX96,
-  getAverageLiquidity,
-  getLiquidityBySingleAmount,
-  getDependentAmount,
-  getLiquidityByAmountsAndPrice,
-  getAmountsByLiquidityAndPrice,
-  getAmountsAtNewPrice
-};
-function getEstimatedLPFeeWithProtocolFee(options) {
-  try {
-    return tryGetEstimatedLPFee(options);
-  } catch (e) {
-    console.error(e);
-    return new Fraction(ZERO$1);
-  }
-}
-function getEstimatedLPFee({ protocolFee = ZERO_PERCENT, ...rest }) {
-  try {
-    const fee = tryGetEstimatedLPFee(rest);
-    return ONE_HUNDRED_PERCENT.subtract(protocolFee).multiply(fee).asFraction;
-  } catch (e) {
-    console.error(e);
-    return new Fraction(ZERO$1);
-  }
-}
-function tryGetEstimatedLPFee({
-  amount,
-  currency,
-  volume24H,
-  sqrtRatioX96,
-  tickLower,
-  tickUpper,
-  mostActiveLiquidity,
-  fee,
-  insidePercentage = ONE_HUNDRED_PERCENT
-}) {
-  invariant11(!Number.isNaN(fee) && fee >= 0, "INVALID_FEE");
-  const tickCurrent = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  if (tickCurrent < tickLower || tickCurrent > tickUpper) {
-    return new Fraction(ZERO$1);
-  }
-  const liquidity = FeeCalculator.getLiquidityBySingleAmount({ amount, currency, tickUpper, tickLower, sqrtRatioX96 });
-  return insidePercentage.multiply(parseNumberToFraction(volume24H).multiply(JSBI$1.BigInt(fee)).multiply(liquidity)).divide(JSBI$1.multiply(MAX_FEE, JSBI$1.add(liquidity, mostActiveLiquidity))).asFraction;
-}
-function getDependentAmount(options) {
-  const { currency, amount, sqrtRatioX96, tickLower, tickUpper } = options;
-  const currentTick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  const liquidity = FeeCalculator.getLiquidityBySingleAmount(options);
-  const isToken0 = currency.wrapped.sortsBefore(amount.currency.wrapped);
-  const getTokenAmount = isToken0 ? PositionMath.getToken0Amount : PositionMath.getToken1Amount;
-  return CurrencyAmount.fromRawAmount(
-    currency,
-    getTokenAmount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity)
-  );
-}
-function getLiquidityBySingleAmount({ amount, currency, ...rest }) {
-  return getLiquidityByAmountsAndPrice({
-    amountA: amount,
-    amountB: CurrencyAmount.fromRawAmount(currency, MaxUint256),
-    ...rest
-  });
-}
-function getLiquidityByAmountsAndPrice({
-  amountA,
-  amountB,
-  tickUpper,
-  tickLower,
-  sqrtRatioX96
-}) {
-  const isToken0 = amountA.currency.wrapped.sortsBefore(amountB.currency.wrapped);
-  const [inputAmount0, inputAmount1] = isToken0 ? [amountA.quotient, amountB.quotient] : [amountB.quotient, amountA.quotient];
-  const sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
-  const sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
-  return maxLiquidityForAmounts(sqrtRatioX96, sqrtRatioAX96, sqrtRatioBX96, inputAmount0, inputAmount1, true);
-}
-function getAmountsByLiquidityAndPrice(options) {
-  const { currencyA, currencyB, liquidity, sqrtRatioX96, tickLower, tickUpper } = options;
-  const currentTick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  const isToken0 = currencyA.wrapped.sortsBefore(currencyB.wrapped);
-  const adjustedAmount0 = PositionMath.getToken0Amount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity);
-  const adjustedAmount1 = PositionMath.getToken1Amount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity);
-  return [
-    CurrencyAmount.fromRawAmount(currencyA, isToken0 ? adjustedAmount0 : adjustedAmount1),
-    CurrencyAmount.fromRawAmount(currencyB, isToken0 ? adjustedAmount1 : adjustedAmount0)
-  ];
-}
-function getAmountsAtNewPrice({ newSqrtRatioX96, ...rest }) {
-  const { tickLower, tickUpper, amountA, amountB } = rest;
-  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice(rest);
-  return FeeCalculator.getAmountsByLiquidityAndPrice({
-    liquidity,
-    currencyA: amountA.currency,
-    currencyB: amountB.currency,
-    tickLower,
-    tickUpper,
-    sqrtRatioX96: newSqrtRatioX96
-  });
-}
-function getAverageLiquidity(ticks, tickSpacing, tickLower, tickUpper) {
-  invariant11(tickLower <= tickUpper, "INVALID_TICK_RANGE");
-  TickList.validateList(ticks, tickSpacing);
-  if (tickLower === tickUpper) {
-    return FeeCalculator.getLiquidityFromTick(ticks, tickLower);
-  }
-  const lowerOutOfBound = tickLower < ticks[0].index;
-  let lastTick = lowerOutOfBound ? new Tick({ index: TickMath.MIN_TICK, liquidityNet: ZERO$1, liquidityGross: ZERO$1 }) : TickList.nextInitializedTick(ticks, tickLower, true);
-  let currentTick = TickList.nextInitializedTick(ticks, tickLower, false);
-  let currentL = lowerOutOfBound ? ZERO$1 : FeeCalculator.getLiquidityFromTick(ticks, currentTick.index);
-  let weightedL = ZERO$1;
-  const getWeightedLFromLastTickTo = (toTick) => JSBI$1.multiply(currentL, JSBI$1.BigInt(toTick - Math.max(lastTick.index, tickLower)));
-  while (currentTick.index < tickUpper) {
-    weightedL = JSBI$1.add(weightedL, getWeightedLFromLastTickTo(currentTick.index));
-    currentL = JSBI$1.add(currentL, currentTick.liquidityNet);
-    lastTick = currentTick;
-    if (currentTick.index === ticks[ticks.length - 1].index) {
-      break;
-    }
-    currentTick = TickList.nextInitializedTick(ticks, currentTick.index, false);
-  }
-  weightedL = JSBI$1.add(weightedL, getWeightedLFromLastTickTo(tickUpper));
-  return JSBI$1.divide(weightedL, JSBI$1.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 = ZERO$1;
-  if (!(ticks == null ? void 0 : 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 = JSBI$1.add(liquidity, ticks[i].liquidityNet);
-    const lowerTick = ticks[i].index;
-    const upperTick = (_a = ticks[i + 1]) == null ? void 0 : _a.index;
-    if (lowerTick <= tick && tick <= upperTick) {
-      break;
-    }
-  }
-  return liquidity;
-}
-var FEE_BASE = JSBI$1.exponentiate(JSBI$1.BigInt(10), JSBI$1.BigInt(4));
-function parseProtocolFees(feeProtocol) {
-  const packed = Number(feeProtocol);
-  if (Number.isNaN(packed)) {
-    throw new Error(`Invalid fee protocol ${feeProtocol}`);
-  }
-  const token0ProtocolFee = packed % 2 ** 16;
-  const token1ProtocolFee = packed >> 16;
-  return [new Percent$1(token0ProtocolFee, FEE_BASE), new Percent$1(token1ProtocolFee, FEE_BASE)];
-}
-
-// src/entities/tick.ts
-var Tick = class {
-  constructor({ index, liquidityGross, liquidityNet }) {
-    invariant11(index >= TickMath.MIN_TICK && index <= TickMath.MAX_TICK, "TICK");
-    this.index = index;
-    this.liquidityGross = JSBI4.BigInt(liquidityGross);
-    this.liquidityNet = JSBI4.BigInt(liquidityNet);
-  }
-};
-
-// src/entities/tickListDataProvider.ts
-var TickListDataProvider = class {
-  constructor(ticks) {
-    const ticksMapped = ticks.map((t) => t instanceof Tick ? t : new Tick(t));
-    this.ticks = ticksMapped;
-  }
-  async getTick(tick) {
-    return TickList.getTick(this.ticks, tick);
-  }
-  async nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
-    return TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
-  }
-};
 
-// src/entities/pool.ts
-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],
-      fee,
-      tokenA,
-      tokenB,
-      initCodeHashManualOverride
-    });
-  }
+// src/entities/position.ts
+var Position = class {
   /**
-   * Construct a pool
-   * @param tokenA One of the tokens in the pool
-   * @param tokenB The other token in the pool
-   * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
-   * @param sqrtRatioX96 The sqrt of the current ratio of amounts of token1 to token0
-   * @param liquidity The current value of in range liquidity
-   * @param tickCurrent The current tick of the pool
-   * @param ticks The current state of the pool ticks or a data provider that can return tick data
+   * Constructs a position for a given pool with the given liquidity
+   * @param pool For which pool the liquidity is assigned
+   * @param liquidity The amount of liquidity that is in the position
+   * @param tickLower The lower tick of the position
+   * @param tickUpper The upper tick of the position
    */
-  constructor(tokenA, tokenB, fee, sqrtRatioX96, liquidity, tickCurrent, ticks = NO_TICK_DATA_PROVIDER_DEFAULT) {
-    invariant11(Number.isInteger(fee) && fee < 1e6, "FEE");
-    [this.token0, this.token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
-    this.fee = fee;
-    this.sqrtRatioX96 = JSBI4.BigInt(sqrtRatioX96);
-    this.liquidity = JSBI4.BigInt(liquidity);
-    this.tickCurrent = tickCurrent;
-    this.tickDataProvider = Array.isArray(ticks) ? new TickListDataProvider(ticks) : ticks;
+  constructor({ pool, liquidity, tickLower, tickUpper }) {
+    // cached resuts for the getters
+    this._token0Amount = null;
+    this._token1Amount = null;
+    this._mintAmounts = null;
+    invariant9(tickLower < tickUpper, "TICK_ORDER");
+    invariant9(tickLower >= TickMath.MIN_TICK && tickLower % pool.tickSpacing === 0, "TICK_LOWER");
+    invariant9(tickUpper <= TickMath.MAX_TICK && tickUpper % pool.tickSpacing === 0, "TICK_UPPER");
+    this.pool = pool;
+    this.tickLower = tickLower;
+    this.tickUpper = tickUpper;
+    this.liquidity = BigInt(liquidity);
   }
   /**
-   * Returns true if the token is either token0 or token1
-   * @param token The token to check
-   * @returns True if token is either token0 or token
+   * Returns the price of token0 at the lower tick
    */
-  involvesToken(token) {
-    return token.equals(this.token0) || token.equals(this.token1);
+  get token0PriceLower() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower);
   }
   /**
-   * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+   * Returns the price of token0 at the upper tick
    */
-  get token0Price() {
-    var _a;
-    return (_a = this._token0Price) != null ? _a : this._token0Price = new Price(
-      this.token0,
-      this.token1,
-      Q192,
-      JSBI4.multiply(this.sqrtRatioX96, this.sqrtRatioX96)
-    );
+  get token0PriceUpper() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper);
   }
   /**
-   * 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 Price(
-      this.token1,
-      this.token0,
-      JSBI4.multiply(this.sqrtRatioX96, this.sqrtRatioX96),
-      Q192
-    );
-  }
-  /**
-   * Return the price of the given token in terms of the other token in the pool.
-   * @param token The token to return price of
-   * @returns The price of the given token, in terms of the other.
-   */
-  priceOf(token) {
-    invariant11(this.involvesToken(token), "TOKEN");
-    return token.equals(this.token0) ? this.token0Price : this.token1Price;
-  }
-  /**
-   * Returns the chain ID of the tokens in the pool.
-   */
-  get chainId() {
-    return this.token0.chainId;
-  }
-  /**
-   * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
-   * @param inputAmount The input amount for which to quote the output amount
-   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit
-   * @returns The output amount and the pool with updated state
-   */
-  async getOutputAmount(inputAmount, sqrtPriceLimitX96) {
-    invariant11(this.involvesToken(inputAmount.currency), "TOKEN");
-    const zeroForOne = inputAmount.currency.equals(this.token0);
-    const {
-      amountCalculated: outputAmount,
-      sqrtRatioX96,
-      liquidity,
-      tickCurrent
-    } = await this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX96);
-    const outputToken = zeroForOne ? this.token1 : this.token0;
-    return [
-      CurrencyAmount.fromRawAmount(outputToken, JSBI4.multiply(outputAmount, NEGATIVE_ONE)),
-      new Pool(this.token0, this.token1, this.fee, sqrtRatioX96, liquidity, tickCurrent, this.tickDataProvider)
-    ];
-  }
-  /**
-   * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
-   * @param outputAmount the output amount for which to quote the input amount
-   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
-   * @returns The input amount and the pool with updated state
-   */
-  async getInputAmount(outputAmount, sqrtPriceLimitX96) {
-    invariant11(outputAmount.currency.isToken && this.involvesToken(outputAmount.currency), "TOKEN");
-    const zeroForOne = outputAmount.currency.equals(this.token1);
-    const {
-      amountSpecifiedRemaining,
-      amountCalculated: inputAmount,
-      sqrtRatioX96,
-      liquidity,
-      tickCurrent
-    } = await this.swap(zeroForOne, JSBI4.multiply(outputAmount.quotient, NEGATIVE_ONE), sqrtPriceLimitX96);
-    invariant11(JSBI4.equal(amountSpecifiedRemaining, ZERO), "INSUFICIENT_LIQUIDITY");
-    const inputToken = zeroForOne ? this.token0 : this.token1;
-    return [
-      CurrencyAmount.fromRawAmount(inputToken, inputAmount),
-      new Pool(this.token0, this.token1, this.fee, sqrtRatioX96, liquidity, tickCurrent, this.tickDataProvider)
-    ];
-  }
-  /**
-   * Executes a swap
-   * @param zeroForOne Whether the amount in is token0 or token1
-   * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
-   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
-   * @returns amountCalculated
-   * @returns sqrtRatioX96
-   * @returns liquidity
-   * @returns tickCurrent
-   */
-  async swap(zeroForOne, amountSpecified, sqrtPriceLimitX96) {
-    if (!sqrtPriceLimitX96)
-      sqrtPriceLimitX96 = zeroForOne ? JSBI4.add(TickMath.MIN_SQRT_RATIO, ONE) : JSBI4.subtract(TickMath.MAX_SQRT_RATIO, ONE);
-    if (zeroForOne) {
-      invariant11(JSBI4.greaterThan(sqrtPriceLimitX96, TickMath.MIN_SQRT_RATIO), "RATIO_MIN");
-      invariant11(JSBI4.lessThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
-    } else {
-      invariant11(JSBI4.lessThan(sqrtPriceLimitX96, TickMath.MAX_SQRT_RATIO), "RATIO_MAX");
-      invariant11(JSBI4.greaterThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
-    }
-    const exactInput = JSBI4.greaterThanOrEqual(amountSpecified, ZERO);
-    const state = {
-      amountSpecifiedRemaining: amountSpecified,
-      amountCalculated: ZERO,
-      sqrtPriceX96: this.sqrtRatioX96,
-      tick: this.tickCurrent,
-      liquidity: this.liquidity
-    };
-    while (JSBI4.notEqual(state.amountSpecifiedRemaining, ZERO) && state.sqrtPriceX96 != sqrtPriceLimitX96) {
-      const step = {};
-      step.sqrtPriceStartX96 = state.sqrtPriceX96;
-      [step.tickNext, step.initialized] = await this.tickDataProvider.nextInitializedTickWithinOneWord(
-        state.tick,
-        zeroForOne,
-        this.tickSpacing
-      );
-      if (step.tickNext < TickMath.MIN_TICK) {
-        step.tickNext = TickMath.MIN_TICK;
-      } else if (step.tickNext > TickMath.MAX_TICK) {
-        step.tickNext = TickMath.MAX_TICK;
-      }
-      step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
-      [state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount] = SwapMath.computeSwapStep(
-        state.sqrtPriceX96,
-        (zeroForOne ? JSBI4.lessThan(step.sqrtPriceNextX96, sqrtPriceLimitX96) : JSBI4.greaterThan(step.sqrtPriceNextX96, sqrtPriceLimitX96)) ? sqrtPriceLimitX96 : step.sqrtPriceNextX96,
-        state.liquidity,
-        state.amountSpecifiedRemaining,
-        this.fee
-      );
-      if (exactInput) {
-        state.amountSpecifiedRemaining = JSBI4.subtract(
-          state.amountSpecifiedRemaining,
-          JSBI4.add(step.amountIn, step.feeAmount)
-        );
-        state.amountCalculated = JSBI4.subtract(state.amountCalculated, step.amountOut);
-      } else {
-        state.amountSpecifiedRemaining = JSBI4.add(state.amountSpecifiedRemaining, step.amountOut);
-        state.amountCalculated = JSBI4.add(state.amountCalculated, JSBI4.add(step.amountIn, step.feeAmount));
-      }
-      if (JSBI4.equal(state.sqrtPriceX96, step.sqrtPriceNextX96)) {
-        if (step.initialized) {
-          let liquidityNet = JSBI4.BigInt((await this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
-          if (zeroForOne)
-            liquidityNet = JSBI4.multiply(liquidityNet, NEGATIVE_ONE);
-          state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
-        }
-        state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
-      } else if (JSBI4.notEqual(state.sqrtPriceX96, step.sqrtPriceStartX96)) {
-        state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
-      }
-    }
-    return {
-      amountSpecifiedRemaining: state.amountSpecifiedRemaining,
-      amountCalculated: state.amountCalculated,
-      sqrtRatioX96: state.sqrtPriceX96,
-      liquidity: state.liquidity,
-      tickCurrent: state.tick
-    };
-  }
-  get tickSpacing() {
-    return TICK_SPACINGS[this.fee];
-  }
-};
-var Position = class {
-  /**
-   * Constructs a position for a given pool with the given liquidity
-   * @param pool For which pool the liquidity is assigned
-   * @param liquidity The amount of liquidity that is in the position
-   * @param tickLower The lower tick of the position
-   * @param tickUpper The upper tick of the position
-   */
-  constructor({ pool, liquidity, tickLower, tickUpper }) {
-    // cached resuts for the getters
-    this._token0Amount = null;
-    this._token1Amount = null;
-    this._mintAmounts = null;
-    invariant11(tickLower < tickUpper, "TICK_ORDER");
-    invariant11(tickLower >= TickMath.MIN_TICK && tickLower % pool.tickSpacing === 0, "TICK_LOWER");
-    invariant11(tickUpper <= TickMath.MAX_TICK && tickUpper % pool.tickSpacing === 0, "TICK_UPPER");
-    this.pool = pool;
-    this.tickLower = tickLower;
-    this.tickUpper = tickUpper;
-    this.liquidity = JSBI4.BigInt(liquidity);
-  }
-  /**
-   * Returns the price of token0 at the lower tick
-   */
-  get token0PriceLower() {
-    return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower);
-  }
-  /**
-   * Returns the price of token0 at the upper tick
-   */
-  get token0PriceUpper() {
-    return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper);
-  }
-  /**
-   * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+   * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
    */
   get amount0() {
     if (this._token0Amount === null) {
@@ -1155,12 +864,12 @@ var Position = class {
     const priceLower = this.pool.token0Price.asFraction.multiply(new Percent$1(1).subtract(slippageTolerance));
     const priceUpper = this.pool.token0Price.asFraction.multiply(slippageTolerance.add(1));
     let sqrtRatioX96Lower = encodeSqrtRatioX96(priceLower.numerator, priceLower.denominator);
-    if (JSBI4.lessThanOrEqual(sqrtRatioX96Lower, TickMath.MIN_SQRT_RATIO)) {
-      sqrtRatioX96Lower = JSBI4.add(TickMath.MIN_SQRT_RATIO, JSBI4.BigInt(1));
+    if (sqrtRatioX96Lower <= TickMath.MIN_SQRT_RATIO) {
+      sqrtRatioX96Lower = TickMath.MIN_SQRT_RATIO + 1n;
     }
     let sqrtRatioX96Upper = encodeSqrtRatioX96(priceUpper.numerator, priceUpper.denominator);
-    if (JSBI4.greaterThanOrEqual(sqrtRatioX96Upper, TickMath.MAX_SQRT_RATIO)) {
-      sqrtRatioX96Upper = JSBI4.subtract(TickMath.MAX_SQRT_RATIO, JSBI4.BigInt(1));
+    if (sqrtRatioX96Upper >= TickMath.MAX_SQRT_RATIO) {
+      sqrtRatioX96Upper = TickMath.MAX_SQRT_RATIO - 1n;
     }
     return {
       sqrtRatioX96Lower,
@@ -1349,7 +1058,7 @@ var Position = class {
     amount0,
     useFullPrecision
   }) {
-    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0, amount1: MaxUint256, useFullPrecision });
+    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0, amount1: MaxUint256$1, useFullPrecision });
   }
   /**
    * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
@@ -1365,7 +1074,7 @@ var Position = class {
     tickUpper,
     amount1
   }) {
-    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0: MaxUint256, amount1, useFullPrecision: true });
+    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0: MaxUint256$1, amount1, useFullPrecision: true });
   }
 };
 var Route = class {
@@ -1377,24 +1086,24 @@ var Route = class {
    */
   constructor(pools, input, output) {
     this._midPrice = null;
-    invariant11(pools.length > 0, "POOLS");
+    invariant9(pools.length > 0, "POOLS");
     const { chainId } = pools[0];
     const allOnSameChain = pools.every((pool) => pool.chainId === chainId);
-    invariant11(allOnSameChain, "CHAIN_IDS");
+    invariant9(allOnSameChain, "CHAIN_IDS");
     const wrappedInput = input.wrapped;
-    invariant11(pools[0].involvesToken(wrappedInput), "INPUT");
-    invariant11(pools[pools.length - 1].involvesToken(output.wrapped), "OUTPUT");
+    invariant9(pools[0].involvesToken(wrappedInput), "INPUT");
+    invariant9(pools[pools.length - 1].involvesToken(output.wrapped), "OUTPUT");
     const tokenPath = [wrappedInput];
     for (const [i, pool] of pools.entries()) {
       const currentInputToken = tokenPath[i];
-      invariant11(currentInputToken.equals(pool.token0) || currentInputToken.equals(pool.token1), "PATH");
+      invariant9(currentInputToken.equals(pool.token0) || currentInputToken.equals(pool.token1), "PATH");
       const nextToken = currentInputToken.equals(pool.token0) ? pool.token1 : pool.token0;
       tokenPath.push(nextToken);
     }
     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;
@@ -1427,8 +1136,8 @@ var Route = class {
   }
 };
 function tradeComparator(a, b) {
-  invariant11(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
-  invariant11(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
+  invariant9(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
+  invariant9(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
   if (a.outputAmount.equalTo(b.outputAmount)) {
     if (a.inputAmount.equalTo(b.inputAmount)) {
       const aHops = a.swaps.reduce((total, cur) => total + cur.route.tokenPath.length, 0);
@@ -1454,7 +1163,7 @@ var Trade = class {
    * i.e. which pools the trade goes through.
    */
   get route() {
-    invariant11(this.swaps.length == 1, "MULTIPLE_ROUTES");
+    invariant9(this.swaps.length == 1, "MULTIPLE_ROUTES");
     return this.swaps[0].route;
   }
   /**
@@ -1485,13 +1194,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 Price(
+    return this._executionPrice ?? (this._executionPrice = new 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
@@ -1546,7 +1254,7 @@ var Trade = class {
     let inputAmount;
     let outputAmount;
     if (tradeType === TradeType.EXACT_INPUT) {
-      invariant11(amount.currency.equals(route.input), "INPUT");
+      invariant9(amount.currency.equals(route.input), "INPUT");
       amounts[0] = amount.wrapped;
       for (let i = 0; i < route.tokenPath.length - 1; i++) {
         const pool = route.pools[i];
@@ -1560,7 +1268,7 @@ var Trade = class {
         amounts[amounts.length - 1].denominator
       );
     } else {
-      invariant11(amount.currency.equals(route.output), "OUTPUT");
+      invariant9(amount.currency.equals(route.output), "OUTPUT");
       amounts[amounts.length - 1] = amount.wrapped;
       for (let i = route.tokenPath.length - 1; i > 0; i--) {
         const pool = route.pools[i - 1];
@@ -1592,7 +1300,7 @@ var Trade = class {
       let inputAmount;
       let outputAmount;
       if (tradeType === TradeType.EXACT_INPUT) {
-        invariant11(amount.currency.equals(route.input), "INPUT");
+        invariant9(amount.currency.equals(route.input), "INPUT");
         inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
         amounts[0] = CurrencyAmount.fromFractionalAmount(route.input.wrapped, amount.numerator, amount.denominator);
         for (let i = 0; i < route.tokenPath.length - 1; i++) {
@@ -1606,7 +1314,7 @@ var Trade = class {
           amounts[amounts.length - 1].denominator
         );
       } else {
-        invariant11(amount.currency.equals(route.output), "OUTPUT");
+        invariant9(amount.currency.equals(route.output), "OUTPUT");
         outputAmount = CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
         amounts[amounts.length - 1] = CurrencyAmount.fromFractionalAmount(
           route.output.wrapped,
@@ -1671,11 +1379,11 @@ var Trade = class {
   }) {
     const inputCurrency = routes[0].inputAmount.currency;
     const outputCurrency = routes[0].outputAmount.currency;
-    invariant11(
+    invariant9(
       routes.every(({ route }) => inputCurrency.wrapped.equals(route.input.wrapped)),
       "INPUT_CURRENCY_MATCH"
     );
-    invariant11(
+    invariant9(
       routes.every(({ route }) => outputCurrency.wrapped.equals(route.output.wrapped)),
       "OUTPUT_CURRENCY_MATCH"
     );
@@ -1686,7 +1394,7 @@ var Trade = class {
         poolAddressSet.add(Pool.getAddress(pool.token0, pool.token1, pool.fee));
       }
     }
-    invariant11(numPools == poolAddressSet.size, "POOLS_DUPLICATED");
+    invariant9(numPools == poolAddressSet.size, "POOLS_DUPLICATED");
     this.swaps = routes;
     this.tradeType = tradeType;
   }
@@ -1696,169 +1404,459 @@ var Trade = class {
    * @returns The amount out
    */
   minimumAmountOut(slippageTolerance, amountOut = this.outputAmount) {
-    invariant11(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    invariant9(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === TradeType.EXACT_OUTPUT) {
       return amountOut;
     }
     const slippageAdjustedAmountOut = new Fraction(ONE).add(slippageTolerance).invert().multiply(amountOut.quotient).quotient;
     return CurrencyAmount.fromRawAmount(amountOut.currency, slippageAdjustedAmountOut);
   }
-  /**
-   * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
-   * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
-   * @returns The amount in
-   */
-  maximumAmountIn(slippageTolerance, amountIn = this.inputAmount) {
-    invariant11(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
-    if (this.tradeType === TradeType.EXACT_INPUT) {
-      return amountIn;
+  /**
+   * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+   * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+   * @returns The amount in
+   */
+  maximumAmountIn(slippageTolerance, amountIn = this.inputAmount) {
+    invariant9(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === TradeType.EXACT_INPUT) {
+      return amountIn;
+    }
+    const slippageAdjustedAmountIn = new Fraction(ONE).add(slippageTolerance).multiply(amountIn.quotient).quotient;
+    return CurrencyAmount.fromRawAmount(amountIn.currency, slippageAdjustedAmountIn);
+  }
+  /**
+   * Return the execution price after accounting for slippage tolerance
+   * @param slippageTolerance the allowed tolerated slippage
+   * @returns The execution price
+   */
+  worstExecutionPrice(slippageTolerance) {
+    return new Price(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.maximumAmountIn(slippageTolerance).quotient,
+      this.minimumAmountOut(slippageTolerance).quotient
+    );
+  }
+  /**
+   * Given a list of pools, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
+   * amount to an output token, making at most `maxHops` hops.
+   * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
+   * the amount in among multiple routes.
+   * @param pools the pools to consider in finding the best trade
+   * @param nextAmountIn exact amount of input currency to spend
+   * @param currencyOut the desired currency out
+   * @param maxNumResults maximum number of results to return
+   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
+   * @param currentPools used in recursion; the current list of pools
+   * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
+   * @param bestTrades used in recursion; the current list of best trades
+   * @returns The exact in trade
+   */
+  static async bestTradeExactIn(pools, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPools = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
+    invariant9(pools.length > 0, "POOLS");
+    invariant9(maxHops > 0, "MAX_HOPS");
+    invariant9(currencyAmountIn === nextAmountIn || currentPools.length > 0, "INVALID_RECURSION");
+    const amountIn = nextAmountIn.wrapped;
+    const tokenOut = currencyOut.wrapped;
+    for (let i = 0; i < pools.length; i++) {
+      const pool = pools[i];
+      if (!pool.token0.equals(amountIn.currency) && !pool.token1.equals(amountIn.currency))
+        continue;
+      let amountOut;
+      try {
+        const [result] = await pool.getOutputAmount(amountIn);
+        amountOut = result;
+      } catch (error) {
+        if (error.isInsufficientInputAmountError) {
+          continue;
+        }
+        throw error;
+      }
+      if (amountOut.currency.isToken && amountOut.currency.equals(tokenOut)) {
+        sortedInsert(
+          bestTrades,
+          await Trade.fromRoute(
+            new Route([...currentPools, pool], currencyAmountIn.currency, currencyOut),
+            currencyAmountIn,
+            TradeType.EXACT_INPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
+      } else if (maxHops > 1 && pools.length > 1) {
+        const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
+        await Trade.bestTradeExactIn(
+          poolsExcludingThisPool,
+          currencyAmountIn,
+          currencyOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [...currentPools, pool],
+          amountOut,
+          bestTrades
+        );
+      }
+    }
+    return bestTrades;
+  }
+  /**
+   * similar to the above method but instead targets a fixed output amount
+   * given a list of pools, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
+   * to an output token amount, making at most `maxHops` hops
+   * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
+   * the amount in among multiple routes.
+   * @param pools the pools to consider in finding the best trade
+   * @param currencyIn the currency to spend
+   * @param currencyAmountOut the desired currency amount out
+   * @param nextAmountOut the exact amount of currency out
+   * @param maxNumResults maximum number of results to return
+   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
+   * @param currentPools used in recursion; the current list of pools
+   * @param bestTrades used in recursion; the current list of best trades
+   * @returns The exact out trade
+   */
+  static async bestTradeExactOut(pools, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPools = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
+    invariant9(pools.length > 0, "POOLS");
+    invariant9(maxHops > 0, "MAX_HOPS");
+    invariant9(currencyAmountOut === nextAmountOut || currentPools.length > 0, "INVALID_RECURSION");
+    const amountOut = nextAmountOut.wrapped;
+    const tokenIn = currencyIn.wrapped;
+    for (let i = 0; i < pools.length; i++) {
+      const pool = pools[i];
+      if (!pool.token0.equals(amountOut.currency) && !pool.token1.equals(amountOut.currency))
+        continue;
+      let amountIn;
+      try {
+        const [result] = await pool.getInputAmount(amountOut);
+        amountIn = result;
+      } catch (error) {
+        if (error.isInsufficientReservesError) {
+          continue;
+        }
+        throw error;
+      }
+      if (amountIn.currency.equals(tokenIn)) {
+        sortedInsert(
+          bestTrades,
+          await Trade.fromRoute(
+            new Route([pool, ...currentPools], currencyIn, currencyAmountOut.currency),
+            currencyAmountOut,
+            TradeType.EXACT_OUTPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
+      } else if (maxHops > 1 && pools.length > 1) {
+        const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
+        await Trade.bestTradeExactOut(
+          poolsExcludingThisPool,
+          currencyIn,
+          currencyAmountOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [pool, ...currentPools],
+          amountIn,
+          bestTrades
+        );
+      }
+    }
+    return bestTrades;
+  }
+};
+
+// src/utils/calldata.ts
+function toHex(bigintIsh) {
+  const bigInt = BigInt(bigintIsh);
+  let hex = bigInt.toString(16);
+  if (hex.length % 2 !== 0) {
+    hex = `0${hex}`;
+  }
+  return `0x${hex}`;
+}
+function encodeRouteToPath(route, exactOutput) {
+  const firstInputToken = route.input.wrapped;
+  const { path, types } = route.pools.reduce(
+    ({ inputToken, path: path2, types: types2 }, pool, index) => {
+      const outputToken = pool.token0.equals(inputToken) ? pool.token1 : pool.token0;
+      if (index === 0) {
+        return {
+          inputToken: outputToken,
+          types: ["address", "uint24", "address"],
+          path: [inputToken.address, pool.fee, outputToken.address]
+        };
+      }
+      return {
+        inputToken: outputToken,
+        types: [...types2, "uint24", "address"],
+        path: [...path2, pool.fee, outputToken.address]
+      };
+    },
+    { inputToken: firstInputToken, path: [], types: [] }
+  );
+  return exactOutput ? encodePacked(types.reverse(), path.reverse()) : encodePacked(types, path);
+}
+function nearestUsableTick(tick, tickSpacing) {
+  invariant9(Number.isInteger(tick) && Number.isInteger(tickSpacing), "INTEGERS");
+  invariant9(tickSpacing > 0, "TICK_SPACING");
+  invariant9(tick >= TickMath.MIN_TICK && tick <= TickMath.MAX_TICK, "TICK_BOUND");
+  const rounded = Math.round(tick / tickSpacing) * tickSpacing;
+  if (rounded < TickMath.MIN_TICK)
+    return rounded + tickSpacing;
+  if (rounded > TickMath.MAX_TICK)
+    return rounded - tickSpacing;
+  return rounded;
+}
+
+// src/utils/position.ts
+var PositionLibrary = class {
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  // replicates the portions of Position#update required to compute unaccounted fees
+  static getTokensOwed(feeGrowthInside0LastX128, feeGrowthInside1LastX128, liquidity, feeGrowthInside0X128, feeGrowthInside1X128) {
+    const tokensOwed0 = subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128) * liquidity / Q128;
+    const tokensOwed1 = subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128) * liquidity / Q128;
+    return [tokensOwed0, tokensOwed1];
+  }
+};
+
+// src/utils/tickLibrary.ts
+var Q256 = 2n ** 256n;
+function subIn256(x, y) {
+  const difference = x - y;
+  if (difference < ZERO) {
+    return Q256 + difference;
+  }
+  return difference;
+}
+var TickLibrary = class {
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static getFeeGrowthInside(feeGrowthOutsideLower, feeGrowthOutsideUpper, tickLower, tickUpper, tickCurrent, feeGrowthGlobal0X128, feeGrowthGlobal1X128) {
+    let feeGrowthBelow0X128;
+    let feeGrowthBelow1X128;
+    if (tickCurrent >= tickLower) {
+      feeGrowthBelow0X128 = feeGrowthOutsideLower.feeGrowthOutside0X128;
+      feeGrowthBelow1X128 = feeGrowthOutsideLower.feeGrowthOutside1X128;
+    } else {
+      feeGrowthBelow0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideLower.feeGrowthOutside0X128);
+      feeGrowthBelow1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideLower.feeGrowthOutside1X128);
+    }
+    let feeGrowthAbove0X128;
+    let feeGrowthAbove1X128;
+    if (tickCurrent < tickUpper) {
+      feeGrowthAbove0X128 = feeGrowthOutsideUpper.feeGrowthOutside0X128;
+      feeGrowthAbove1X128 = feeGrowthOutsideUpper.feeGrowthOutside1X128;
+    } else {
+      feeGrowthAbove0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideUpper.feeGrowthOutside0X128);
+      feeGrowthAbove1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideUpper.feeGrowthOutside1X128);
+    }
+    return [
+      subIn256(subIn256(feeGrowthGlobal0X128, feeGrowthBelow0X128), feeGrowthAbove0X128),
+      subIn256(subIn256(feeGrowthGlobal1X128, feeGrowthBelow1X128), feeGrowthAbove1X128)
+    ];
+  }
+};
+function parseNumberToFraction(num, precision = 6) {
+  if (Number.isNaN(num) || !Number.isFinite(num)) {
+    return void 0;
+  }
+  const scalar = 10 ** precision;
+  return new Fraction$1(BigInt(Math.floor(num * scalar)), BigInt(scalar));
+}
+
+// src/utils/feeCalculator.ts
+var FeeCalculator = {
+  getEstimatedLPFee,
+  getEstimatedLPFeeByAmounts,
+  getLiquidityFromTick,
+  getLiquidityFromSqrtRatioX96,
+  getAverageLiquidity,
+  getLiquidityBySingleAmount,
+  getDependentAmount,
+  getLiquidityByAmountsAndPrice,
+  getAmountsByLiquidityAndPrice,
+  getAmountsAtNewPrice
+};
+function getEstimatedLPFeeWithProtocolFee({ amount, currency, ...rest }) {
+  return getEstimatedLPFeeByAmountsWithProtocolFee({
+    ...rest,
+    amountA: amount,
+    amountB: CurrencyAmount$1.fromRawAmount(currency, MaxUint256)
+  });
+}
+function getEstimatedLPFee({ amount, currency, ...rest }) {
+  return getEstimatedLPFeeByAmounts({
+    ...rest,
+    amountA: amount,
+    amountB: CurrencyAmount$1.fromRawAmount(currency, MaxUint256)
+  });
+}
+function getEstimatedLPFeeByAmountsWithProtocolFee(options) {
+  try {
+    return tryGetEstimatedLPFeeByAmounts(options);
+  } catch (e) {
+    console.error(e);
+    return new Fraction$1(ZERO$1);
+  }
+}
+function getEstimatedLPFeeByAmounts({ protocolFee = ZERO_PERCENT, ...rest }) {
+  try {
+    const fee = tryGetEstimatedLPFeeByAmounts(rest);
+    return ONE_HUNDRED_PERCENT.subtract(protocolFee).multiply(fee).asFraction;
+  } catch (e) {
+    console.error(e);
+    return new Fraction$1(ZERO$1);
+  }
+}
+function tryGetEstimatedLPFeeByAmounts({
+  amountA,
+  amountB,
+  volume24H,
+  sqrtRatioX96,
+  tickLower,
+  tickUpper,
+  mostActiveLiquidity,
+  fee,
+  insidePercentage = ONE_HUNDRED_PERCENT
+}) {
+  invariant9(!Number.isNaN(fee) && fee >= 0, "INVALID_FEE");
+  const tickCurrent = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
+  if (tickCurrent < tickLower || tickCurrent > tickUpper) {
+    return new Fraction$1(ZERO$1);
+  }
+  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice({
+    amountA,
+    amountB,
+    tickUpper,
+    tickLower,
+    sqrtRatioX96
+  });
+  const volumeInFraction = parseNumberToFraction(volume24H) || new Fraction$1(ZERO$1);
+  return insidePercentage.multiply(volumeInFraction.multiply(BigInt(fee)).multiply(liquidity)).divide(MAX_FEE * (liquidity + mostActiveLiquidity)).asFraction;
+}
+function getDependentAmount(options) {
+  const { currency, amount, sqrtRatioX96, tickLower, tickUpper } = options;
+  const currentTick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
+  const liquidity = FeeCalculator.getLiquidityBySingleAmount(options);
+  const isToken0 = currency.wrapped.sortsBefore(amount.currency.wrapped);
+  const getTokenAmount = isToken0 ? PositionMath.getToken0Amount : PositionMath.getToken1Amount;
+  return CurrencyAmount$1.fromRawAmount(
+    currency,
+    getTokenAmount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity)
+  );
+}
+function getLiquidityBySingleAmount({ amount, currency, ...rest }) {
+  return getLiquidityByAmountsAndPrice({
+    amountA: amount,
+    amountB: CurrencyAmount$1.fromRawAmount(currency, MaxUint256),
+    ...rest
+  });
+}
+function getLiquidityByAmountsAndPrice({
+  amountA,
+  amountB,
+  tickUpper,
+  tickLower,
+  sqrtRatioX96
+}) {
+  const isToken0 = amountA.currency.wrapped.address !== amountB.currency.wrapped.address ? amountA.currency.wrapped.sortsBefore(amountB.currency.wrapped) : true;
+  const [inputAmount0, inputAmount1] = isToken0 ? [amountA.quotient, amountB.quotient] : [amountB.quotient, amountA.quotient];
+  const sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
+  const sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
+  return maxLiquidityForAmounts(sqrtRatioX96, sqrtRatioAX96, sqrtRatioBX96, inputAmount0, inputAmount1, true);
+}
+function getAmountsByLiquidityAndPrice(options) {
+  const { currencyA, currencyB, liquidity, sqrtRatioX96, tickLower, tickUpper } = options;
+  const currentTick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
+  const isToken0 = currencyA.wrapped.sortsBefore(currencyB.wrapped);
+  const adjustedAmount0 = PositionMath.getToken0Amount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity);
+  const adjustedAmount1 = PositionMath.getToken1Amount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity);
+  return [
+    CurrencyAmount$1.fromRawAmount(currencyA, isToken0 ? adjustedAmount0 : adjustedAmount1),
+    CurrencyAmount$1.fromRawAmount(currencyB, isToken0 ? adjustedAmount1 : adjustedAmount0)
+  ];
+}
+function getAmountsAtNewPrice({ newSqrtRatioX96, ...rest }) {
+  const { tickLower, tickUpper, amountA, amountB } = rest;
+  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice(rest);
+  return FeeCalculator.getAmountsByLiquidityAndPrice({
+    liquidity,
+    currencyA: amountA.currency,
+    currencyB: amountB.currency,
+    tickLower,
+    tickUpper,
+    sqrtRatioX96: newSqrtRatioX96
+  });
+}
+function getAverageLiquidity(ticks, tickSpacing, tickLower, tickUpper) {
+  invariant9(tickLower <= tickUpper, "INVALID_TICK_RANGE");
+  TickList.validateList(ticks, tickSpacing);
+  if (tickLower === tickUpper) {
+    return FeeCalculator.getLiquidityFromTick(ticks, tickLower);
+  }
+  const lowerOutOfBound = tickLower < ticks[0].index;
+  let lastTick = lowerOutOfBound ? new Tick({ index: TickMath.MIN_TICK, liquidityNet: ZERO$1, liquidityGross: ZERO$1 }) : TickList.nextInitializedTick(ticks, tickLower, true);
+  let currentTick = TickList.nextInitializedTick(ticks, tickLower, false);
+  let currentL = lowerOutOfBound ? ZERO$1 : FeeCalculator.getLiquidityFromTick(ticks, currentTick.index);
+  let weightedL = ZERO$1;
+  const getWeightedLFromLastTickTo = (toTick) => currentL * BigInt(toTick - Math.max(lastTick.index, tickLower));
+  while (currentTick.index < tickUpper) {
+    weightedL += getWeightedLFromLastTickTo(currentTick.index);
+    currentL += currentTick.liquidityNet;
+    lastTick = currentTick;
+    if (currentTick.index === ticks[ticks.length - 1].index) {
+      break;
     }
-    const slippageAdjustedAmountIn = new Fraction(ONE).add(slippageTolerance).multiply(amountIn.quotient).quotient;
-    return CurrencyAmount.fromRawAmount(amountIn.currency, slippageAdjustedAmountIn);
+    currentTick = TickList.nextInitializedTick(ticks, currentTick.index, false);
   }
-  /**
-   * Return the execution price after accounting for slippage tolerance
-   * @param slippageTolerance the allowed tolerated slippage
-   * @returns The execution price
-   */
-  worstExecutionPrice(slippageTolerance) {
-    return new Price(
-      this.inputAmount.currency,
-      this.outputAmount.currency,
-      this.maximumAmountIn(slippageTolerance).quotient,
-      this.minimumAmountOut(slippageTolerance).quotient
-    );
+  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) {
+  let liquidity = ZERO$1;
+  if (!ticks?.length)
+    return liquidity;
+  if (tick < ticks[0].index || tick > ticks[ticks.length - 1].index) {
+    return liquidity;
   }
-  /**
-   * Given a list of pools, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
-   * amount to an output token, making at most `maxHops` hops.
-   * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
-   * the amount in among multiple routes.
-   * @param pools the pools to consider in finding the best trade
-   * @param nextAmountIn exact amount of input currency to spend
-   * @param currencyOut the desired currency out
-   * @param maxNumResults maximum number of results to return
-   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
-   * @param currentPools used in recursion; the current list of pools
-   * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
-   * @param bestTrades used in recursion; the current list of best trades
-   * @returns The exact in trade
-   */
-  static async bestTradeExactIn(pools, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPools = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
-    invariant11(pools.length > 0, "POOLS");
-    invariant11(maxHops > 0, "MAX_HOPS");
-    invariant11(currencyAmountIn === nextAmountIn || currentPools.length > 0, "INVALID_RECURSION");
-    const amountIn = nextAmountIn.wrapped;
-    const tokenOut = currencyOut.wrapped;
-    for (let i = 0; i < pools.length; i++) {
-      const pool = pools[i];
-      if (!pool.token0.equals(amountIn.currency) && !pool.token1.equals(amountIn.currency))
-        continue;
-      let amountOut;
-      try {
-        const [result] = await pool.getOutputAmount(amountIn);
-        amountOut = result;
-      } catch (error) {
-        if (error.isInsufficientInputAmountError) {
-          continue;
-        }
-        throw error;
-      }
-      if (amountOut.currency.isToken && amountOut.currency.equals(tokenOut)) {
-        sortedInsert(
-          bestTrades,
-          await Trade.fromRoute(
-            new Route([...currentPools, pool], currencyAmountIn.currency, currencyOut),
-            currencyAmountIn,
-            TradeType.EXACT_INPUT
-          ),
-          maxNumResults,
-          tradeComparator
-        );
-      } else if (maxHops > 1 && pools.length > 1) {
-        const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
-        await Trade.bestTradeExactIn(
-          poolsExcludingThisPool,
-          currencyAmountIn,
-          currencyOut,
-          {
-            maxNumResults,
-            maxHops: maxHops - 1
-          },
-          [...currentPools, pool],
-          amountOut,
-          bestTrades
-        );
-      }
+  for (let i = 0; i < ticks.length - 1; ++i) {
+    liquidity += ticks[i].liquidityNet;
+    const lowerTick = ticks[i].index;
+    const upperTick = ticks[i + 1]?.index;
+    if (lowerTick <= tick && tick <= upperTick) {
+      break;
     }
-    return bestTrades;
   }
-  /**
-   * similar to the above method but instead targets a fixed output amount
-   * given a list of pools, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
-   * to an output token amount, making at most `maxHops` hops
-   * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
-   * the amount in among multiple routes.
-   * @param pools the pools to consider in finding the best trade
-   * @param currencyIn the currency to spend
-   * @param currencyAmountOut the desired currency amount out
-   * @param nextAmountOut the exact amount of currency out
-   * @param maxNumResults maximum number of results to return
-   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
-   * @param currentPools used in recursion; the current list of pools
-   * @param bestTrades used in recursion; the current list of best trades
-   * @returns The exact out trade
-   */
-  static async bestTradeExactOut(pools, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPools = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
-    invariant11(pools.length > 0, "POOLS");
-    invariant11(maxHops > 0, "MAX_HOPS");
-    invariant11(currencyAmountOut === nextAmountOut || currentPools.length > 0, "INVALID_RECURSION");
-    const amountOut = nextAmountOut.wrapped;
-    const tokenIn = currencyIn.wrapped;
-    for (let i = 0; i < pools.length; i++) {
-      const pool = pools[i];
-      if (!pool.token0.equals(amountOut.currency) && !pool.token1.equals(amountOut.currency))
-        continue;
-      let amountIn;
-      try {
-        const [result] = await pool.getInputAmount(amountOut);
-        amountIn = result;
-      } catch (error) {
-        if (error.isInsufficientReservesError) {
-          continue;
-        }
-        throw error;
-      }
-      if (amountIn.currency.equals(tokenIn)) {
-        sortedInsert(
-          bestTrades,
-          await Trade.fromRoute(
-            new Route([pool, ...currentPools], currencyIn, currencyAmountOut.currency),
-            currencyAmountOut,
-            TradeType.EXACT_OUTPUT
-          ),
-          maxNumResults,
-          tradeComparator
-        );
-      } else if (maxHops > 1 && pools.length > 1) {
-        const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
-        await Trade.bestTradeExactOut(
-          poolsExcludingThisPool,
-          currencyIn,
-          currencyAmountOut,
-          {
-            maxNumResults,
-            maxHops: maxHops - 1
-          },
-          [pool, ...currentPools],
-          amountIn,
-          bestTrades
-        );
-      }
-    }
-    return bestTrades;
+  return liquidity;
+}
+var FEE_BASE = 10n ** 4n;
+function parseProtocolFees(feeProtocol) {
+  const packed = Number(feeProtocol);
+  if (Number.isNaN(packed)) {
+    throw new Error(`Invalid fee protocol ${feeProtocol}`);
   }
-};
+  const token0ProtocolFee = packed % 2 ** 16;
+  const token1ProtocolFee = packed >> 16;
+  return [new Percent(token0ProtocolFee, FEE_BASE), new Percent(token1ProtocolFee, FEE_BASE)];
+}
+function sqrtRatioX96ToPrice(sqrtRatioX96, currencyA, currencyB) {
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
+  return currencyA.wrapped.sortsBefore(currencyB.wrapped) ? new Price$1(currencyA.wrapped, currencyB.wrapped, Q192, ratioX192) : new Price$1(currencyA.wrapped, currencyB.wrapped, ratioX192, Q192);
+}
 var IMulticall = [
   {
     inputs: [
@@ -1890,14 +1888,14 @@ var _Multicall = class {
     if (!Array.isArray(calldatas)) {
       calldatas = [calldatas];
     }
-    return calldatas.length === 1 ? calldatas[0] : _Multicall.INTERFACE.encodeFunctionData("multicall", [calldatas]);
+    return calldatas.length === 1 ? calldatas[0] : encodeFunctionData({ abi: _Multicall.ABI, functionName: "multicall", args: [calldatas] });
   }
 };
 var Multicall = _Multicall;
-Multicall.INTERFACE = new Interface(IMulticall);
+Multicall.ABI = IMulticall;
 
-// src/abi/NonfungiblePositionManager.json
-var NonfungiblePositionManager_default = [
+// src/abi/NonfungiblePositionManager.ts
+var nonfungiblePositionManagerABI = [
   {
     inputs: [
       { internalType: "address", name: "_deployer", type: "address" },
@@ -2403,8 +2401,8 @@ var NonfungiblePositionManager_default = [
   { stateMutability: "payable", type: "receive" }
 ];
 
-// src/abi/SelfPermit.json
-var SelfPermit_default = [
+// src/abi/SelfPermit.ts
+var selfPermitABI = [
   {
     inputs: [
       {
@@ -2570,28 +2568,22 @@ var _SelfPermit = class {
   constructor() {
   }
   static encodePermit(token, options) {
-    return isAllowedPermit(options) ? _SelfPermit.INTERFACE.encodeFunctionData("selfPermitAllowed", [
-      token.address,
-      toHex(options.nonce),
-      toHex(options.expiry),
-      options.v,
-      options.r,
-      options.s
-    ]) : _SelfPermit.INTERFACE.encodeFunctionData("selfPermit", [
-      token.address,
-      toHex(options.amount),
-      toHex(options.deadline),
-      options.v,
-      options.r,
-      options.s
-    ]);
+    return isAllowedPermit(options) ? encodeFunctionData({
+      abi: _SelfPermit.ABI,
+      functionName: "selfPermitAllowed",
+      args: [token.address, BigInt(options.nonce), BigInt(options.expiry), options.v, options.r, options.s]
+    }) : encodeFunctionData({
+      abi: _SelfPermit.ABI,
+      functionName: "selfPermit",
+      args: [token.address, BigInt(options.amount), BigInt(options.deadline), options.v, options.r, options.s]
+    });
   }
 };
 var SelfPermit = _SelfPermit;
-SelfPermit.INTERFACE = new Interface(SelfPermit_default);
+SelfPermit.ABI = selfPermitABI;
 
-// src/abi/IPeripheryPaymentsWithFee.json
-var IPeripheryPaymentsWithFee_default = [
+// src/abi/PeripheryPaymentsWithFee.ts
+var peripheryPaymentsWithFeeABI = [
   {
     inputs: [],
     name: "refundETH",
@@ -2711,46 +2703,47 @@ var _Payments = class {
   constructor() {
   }
   static encodeFeeBips(fee) {
-    return toHex(fee.multiply(1e4).quotient);
+    return fee.multiply(1e4).quotient;
   }
   static encodeUnwrapWETH9(amountMinimum, recipient, feeOptions) {
     recipient = validateAndParseAddress(recipient);
     if (feeOptions) {
       const feeBips = this.encodeFeeBips(feeOptions.fee);
       const feeRecipient = validateAndParseAddress(feeOptions.recipient);
-      return _Payments.INTERFACE.encodeFunctionData("unwrapWETH9WithFee", [
-        toHex(amountMinimum),
-        recipient,
-        feeBips,
-        feeRecipient
-      ]);
+      return encodeFunctionData({
+        abi: _Payments.ABI,
+        functionName: "unwrapWETH9WithFee",
+        args: [amountMinimum, recipient, feeBips, feeRecipient]
+      });
     }
-    return _Payments.INTERFACE.encodeFunctionData("unwrapWETH9", [toHex(amountMinimum), recipient]);
+    return encodeFunctionData({ abi: _Payments.ABI, functionName: "unwrapWETH9", args: [amountMinimum, recipient] });
   }
   static encodeSweepToken(token, amountMinimum, recipient, feeOptions) {
     recipient = validateAndParseAddress(recipient);
     if (feeOptions) {
       const feeBips = this.encodeFeeBips(feeOptions.fee);
       const feeRecipient = validateAndParseAddress(feeOptions.recipient);
-      return _Payments.INTERFACE.encodeFunctionData("sweepTokenWithFee", [
-        token.address,
-        toHex(amountMinimum),
-        recipient,
-        feeBips,
-        feeRecipient
-      ]);
+      return encodeFunctionData({
+        abi: _Payments.ABI,
+        functionName: "sweepTokenWithFee",
+        args: [token.address, amountMinimum, recipient, feeBips, feeRecipient]
+      });
     }
-    return _Payments.INTERFACE.encodeFunctionData("sweepToken", [token.address, toHex(amountMinimum), recipient]);
+    return encodeFunctionData({
+      abi: _Payments.ABI,
+      functionName: "sweepToken",
+      args: [token.address, amountMinimum, recipient]
+    });
   }
   static encodeRefundETH() {
-    return _Payments.INTERFACE.encodeFunctionData("refundETH");
+    return encodeFunctionData({ abi: _Payments.ABI, functionName: "refundETH" });
   }
 };
 var Payments = _Payments;
-Payments.INTERFACE = new Interface(IPeripheryPaymentsWithFee_default);
+Payments.ABI = peripheryPaymentsWithFeeABI;
 
 // src/nonfungiblePositionManager.ts
-var MaxUint128 = toHex(JSBI4.subtract(JSBI4.exponentiate(JSBI4.BigInt(2), JSBI4.BigInt(128)), JSBI4.BigInt(1)));
+var MaxUint128 = 2n ** 128n - 1n;
 function isMint(options) {
   return Object.keys(options).some((k) => k === "recipient");
 }
@@ -2762,12 +2755,11 @@ var _NonfungiblePositionManager = class {
   constructor() {
   }
   static encodeCreate(pool) {
-    return _NonfungiblePositionManager.INTERFACE.encodeFunctionData("createAndInitializePoolIfNecessary", [
-      pool.token0.address,
-      pool.token1.address,
-      pool.fee,
-      toHex(pool.sqrtRatioX96)
-    ]);
+    return encodeFunctionData({
+      abi: _NonfungiblePositionManager.ABI,
+      functionName: "createAndInitializePoolIfNecessary",
+      args: [pool.token0.address, pool.token1.address, pool.fee, pool.sqrtRatioX96]
+    });
   }
   static createCallParameters(pool) {
     return {
@@ -2776,13 +2768,13 @@ var _NonfungiblePositionManager = class {
     };
   }
   static addCallParameters(position, options) {
-    invariant11(JSBI4.greaterThan(position.liquidity, ZERO), "ZERO_LIQUIDITY");
+    invariant9(position.liquidity > ZERO, "ZERO_LIQUIDITY");
     const calldatas = [];
     const { amount0: amount0Desired, amount1: amount1Desired } = position.mintAmounts;
     const minimumAmounts = position.mintAmountsWithSlippage(options.slippageTolerance);
-    const amount0Min = toHex(minimumAmounts.amount0);
-    const amount1Min = toHex(minimumAmounts.amount1);
-    const deadline = toHex(options.deadline);
+    const amount0Min = minimumAmounts.amount0;
+    const amount1Min = minimumAmounts.amount1;
+    const deadline = BigInt(options.deadline);
     if (isMint(options) && options.createPool) {
       calldatas.push(this.encodeCreate(position.pool));
     }
@@ -2795,42 +2787,50 @@ var _NonfungiblePositionManager = class {
     if (isMint(options)) {
       const recipient = validateAndParseAddress(options.recipient);
       calldatas.push(
-        _NonfungiblePositionManager.INTERFACE.encodeFunctionData("mint", [
-          {
-            token0: position.pool.token0.address,
-            token1: position.pool.token1.address,
-            fee: position.pool.fee,
-            tickLower: position.tickLower,
-            tickUpper: position.tickUpper,
-            amount0Desired: toHex(amount0Desired),
-            amount1Desired: toHex(amount1Desired),
-            amount0Min,
-            amount1Min,
-            recipient,
-            deadline
-          }
-        ])
+        encodeFunctionData({
+          abi: _NonfungiblePositionManager.ABI,
+          functionName: "mint",
+          args: [
+            {
+              token0: position.pool.token0.address,
+              token1: position.pool.token1.address,
+              fee: position.pool.fee,
+              tickLower: position.tickLower,
+              tickUpper: position.tickUpper,
+              amount0Desired,
+              amount1Desired,
+              amount0Min,
+              amount1Min,
+              recipient,
+              deadline
+            }
+          ]
+        })
       );
     } else {
       calldatas.push(
-        _NonfungiblePositionManager.INTERFACE.encodeFunctionData("increaseLiquidity", [
-          {
-            tokenId: toHex(options.tokenId),
-            amount0Desired: toHex(amount0Desired),
-            amount1Desired: toHex(amount1Desired),
-            amount0Min,
-            amount1Min,
-            deadline
-          }
-        ])
+        encodeFunctionData({
+          abi: _NonfungiblePositionManager.ABI,
+          functionName: "increaseLiquidity",
+          args: [
+            {
+              tokenId: BigInt(options.tokenId),
+              amount0Desired,
+              amount1Desired,
+              amount0Min,
+              amount1Min,
+              deadline
+            }
+          ]
+        })
       );
     }
     let value = toHex(0);
     if (options.useNative) {
       const { wrapped } = options.useNative;
-      invariant11(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
+      invariant9(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
       const wrappedValue = position.pool.token0.equals(wrapped) ? amount0Desired : amount1Desired;
-      if (JSBI4.greaterThan(wrappedValue, ZERO)) {
+      if (wrappedValue > ZERO) {
         calldatas.push(Payments.encodeRefundETH());
       }
       value = toHex(wrappedValue);
@@ -2842,18 +2842,22 @@ var _NonfungiblePositionManager = class {
   }
   static encodeCollect(options) {
     const calldatas = [];
-    const tokenId = toHex(options.tokenId);
+    const tokenId = BigInt(options.tokenId);
     const involvesETH = options.expectedCurrencyOwed0.currency.isNative || options.expectedCurrencyOwed1.currency.isNative;
     const recipient = validateAndParseAddress(options.recipient);
     calldatas.push(
-      _NonfungiblePositionManager.INTERFACE.encodeFunctionData("collect", [
-        {
-          tokenId,
-          recipient: involvesETH ? ADDRESS_ZERO : recipient,
-          amount0Max: MaxUint128,
-          amount1Max: MaxUint128
-        }
-      ])
+      encodeFunctionData({
+        abi: _NonfungiblePositionManager.ABI,
+        functionName: "collect",
+        args: [
+          {
+            tokenId,
+            recipient: involvesETH ? ADDRESS_ZERO : recipient,
+            amount0Max: MaxUint128,
+            amount1Max: MaxUint128
+          }
+        ]
+      })
     );
     if (involvesETH) {
       const ethAmount = options.expectedCurrencyOwed0.currency.isNative ? options.expectedCurrencyOwed0.quotient : options.expectedCurrencyOwed1.quotient;
@@ -2879,40 +2883,48 @@ var _NonfungiblePositionManager = class {
    */
   static removeCallParameters(position, options) {
     const calldatas = [];
-    const deadline = toHex(options.deadline);
-    const tokenId = toHex(options.tokenId);
+    const deadline = BigInt(options.deadline);
+    const tokenId = BigInt(options.tokenId);
     const partialPosition = new Position({
       pool: position.pool,
       liquidity: options.liquidityPercentage.multiply(position.liquidity).quotient,
       tickLower: position.tickLower,
       tickUpper: position.tickUpper
     });
-    invariant11(JSBI4.greaterThan(partialPosition.liquidity, ZERO), "ZERO_LIQUIDITY");
+    invariant9(partialPosition.liquidity > ZERO, "ZERO_LIQUIDITY");
     const { amount0: amount0Min, amount1: amount1Min } = partialPosition.burnAmountsWithSlippage(
       options.slippageTolerance
     );
     if (options.permit) {
       calldatas.push(
-        _NonfungiblePositionManager.INTERFACE.encodeFunctionData("permit", [
-          validateAndParseAddress(options.permit.spender),
-          tokenId,
-          toHex(options.permit.deadline),
-          options.permit.v,
-          options.permit.r,
-          options.permit.s
-        ])
+        encodeFunctionData({
+          abi: _NonfungiblePositionManager.ABI,
+          functionName: "permit",
+          args: [
+            validateAndParseAddress(options.permit.spender),
+            tokenId,
+            BigInt(options.permit.deadline),
+            options.permit.v,
+            options.permit.r,
+            options.permit.s
+          ]
+        })
       );
     }
     calldatas.push(
-      _NonfungiblePositionManager.INTERFACE.encodeFunctionData("decreaseLiquidity", [
-        {
-          tokenId,
-          liquidity: toHex(partialPosition.liquidity),
-          amount0Min: toHex(amount0Min),
-          amount1Min: toHex(amount1Min),
-          deadline
-        }
-      ])
+      encodeFunctionData({
+        abi: _NonfungiblePositionManager.ABI,
+        functionName: "decreaseLiquidity",
+        args: [
+          {
+            tokenId,
+            liquidity: partialPosition.liquidity,
+            amount0Min,
+            amount1Min,
+            deadline
+          }
+        ]
+      })
     );
     const { expectedCurrencyOwed0, expectedCurrencyOwed1, ...rest } = options.collectOptions;
     calldatas.push(
@@ -2930,10 +2942,12 @@ var _NonfungiblePositionManager = class {
     );
     if (options.liquidityPercentage.equalTo(ONE)) {
       if (options.burnToken) {
-        calldatas.push(_NonfungiblePositionManager.INTERFACE.encodeFunctionData("burn", [tokenId]));
+        calldatas.push(
+          encodeFunctionData({ abi: _NonfungiblePositionManager.ABI, functionName: "burn", args: [tokenId] })
+        );
       }
     } else {
-      invariant11(options.burnToken !== true, "CANNOT_BURN");
+      invariant9(options.burnToken !== true, "CANNOT_BURN");
     }
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -2945,16 +2959,17 @@ var _NonfungiblePositionManager = class {
     const sender = validateAndParseAddress(options.sender);
     let calldata;
     if (options.data) {
-      calldata = _NonfungiblePositionManager.INTERFACE.encodeFunctionData(
-        "safeTransferFrom(address,address,uint256,bytes)",
-        [sender, recipient, toHex(options.tokenId), options.data]
-      );
+      calldata = encodeFunctionData({
+        abi: _NonfungiblePositionManager.ABI,
+        functionName: "safeTransferFrom",
+        args: [sender, recipient, BigInt(options.tokenId), options.data]
+      });
     } else {
-      calldata = _NonfungiblePositionManager.INTERFACE.encodeFunctionData("safeTransferFrom(address,address,uint256)", [
-        sender,
-        recipient,
-        toHex(options.tokenId)
-      ]);
+      calldata = encodeFunctionData({
+        abi: _NonfungiblePositionManager.ABI,
+        functionName: "safeTransferFrom",
+        args: [sender, recipient, BigInt(options.tokenId)]
+      });
     }
     return {
       calldata,
@@ -2963,10 +2978,10 @@ var _NonfungiblePositionManager = class {
   }
 };
 var NonfungiblePositionManager = _NonfungiblePositionManager;
-NonfungiblePositionManager.INTERFACE = new Interface(NonfungiblePositionManager_default);
+NonfungiblePositionManager.ABI = nonfungiblePositionManagerABI;
 
-// src/abi/Quoter.json
-var Quoter_default = [
+// src/abi/Quoter.ts
+var quoterABI = [
   {
     inputs: [
       {
@@ -3178,8 +3193,8 @@ var Quoter_default = [
   }
 ];
 
-// src/abi/QuoterV2.json
-var QuoterV2_default = [
+// src/abi/QuoterV2.ts
+var quoterV2ABI = [
   {
     inputs: [
       {
@@ -3479,21 +3494,20 @@ 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);
+    const quoteAmount = amount.quotient;
     let calldata;
-    const swapInterface = options.useQuoterV2 ? this.V2INTERFACE : this.V1INTERFACE;
+    const swapAbi = options.useQuoterV2 ? this.V2ABI : this.V1ABI;
     if (singleHop) {
       const baseQuoteParams = {
         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: BigInt(options?.sqrtPriceLimitX96 ?? 0)
       };
       const v2QuoteParams = {
         ...baseQuoteParams,
-        ...tradeType == TradeType.EXACT_INPUT ? { amountIn: quoteAmount } : { amount: quoteAmount }
+        ...tradeType === TradeType$1.EXACT_INPUT ? { amountIn: quoteAmount } : { amount: quoteAmount }
       };
       const v1QuoteParams = [
         baseQuoteParams.tokenIn,
@@ -3502,16 +3516,31 @@ var SwapQuoter = class {
         quoteAmount,
         baseQuoteParams.sqrtPriceLimitX96
       ];
-      const tradeTypeFunctionName = tradeType === TradeType.EXACT_INPUT ? "quoteExactInputSingle" : "quoteExactOutputSingle";
-      calldata = swapInterface.encodeFunctionData(
-        tradeTypeFunctionName,
-        options.useQuoterV2 ? [v2QuoteParams] : v1QuoteParams
-      );
+      const tradeTypeFunctionName = tradeType === TradeType$1.EXACT_INPUT ? "quoteExactInputSingle" : "quoteExactOutputSingle";
+      if (options.useQuoterV2) {
+        calldata = encodeFunctionData({
+          abi: this.V2ABI,
+          functionName: tradeTypeFunctionName,
+          // @ts-ignore // FIXME
+          args: [v2QuoteParams]
+        });
+      } else {
+        calldata = encodeFunctionData({
+          abi: this.V1ABI,
+          functionName: tradeTypeFunctionName,
+          args: v1QuoteParams
+        });
+      }
     } else {
-      invariant11((options == null ? void 0 : options.sqrtPriceLimitX96) === void 0, "MULTIHOP_PRICE_LIMIT");
-      const path = encodeRouteToPath(route, tradeType === TradeType.EXACT_OUTPUT);
-      const tradeTypeFunctionName = tradeType === TradeType.EXACT_INPUT ? "quoteExactInput" : "quoteExactOutput";
-      calldata = swapInterface.encodeFunctionData(tradeTypeFunctionName, [path, quoteAmount]);
+      invariant9(options?.sqrtPriceLimitX96 === void 0, "MULTIHOP_PRICE_LIMIT");
+      const path = encodeRouteToPath(route, tradeType === TradeType$1.EXACT_OUTPUT);
+      const tradeTypeFunctionName = tradeType === TradeType$1.EXACT_INPUT ? "quoteExactInput" : "quoteExactOutput";
+      calldata = encodeFunctionData({
+        // @ts-ignore
+        abi: swapAbi,
+        functionName: tradeTypeFunctionName,
+        args: [path, quoteAmount]
+      });
     }
     return {
       calldata,
@@ -3519,11 +3548,11 @@ var SwapQuoter = class {
     };
   }
 };
-SwapQuoter.V1INTERFACE = new Interface(Quoter_default);
-SwapQuoter.V2INTERFACE = new Interface(QuoterV2_default);
+SwapQuoter.V1ABI = quoterABI;
+SwapQuoter.V2ABI = quoterV2ABI;
 
-// src/abi/V3Staker.json
-var V3Staker_default = [
+// src/abi/V3Staker.ts
+var v3StakerABI = [
   {
     inputs: [
       {
@@ -4241,18 +4270,22 @@ var _Staker = class {
    * @returns The calldatas for 'unstakeToken' and 'claimReward'.
    */
   static encodeClaim(incentiveKey, options) {
-    var _a;
     const calldatas = [];
     calldatas.push(
-      _Staker.INTERFACE.encodeFunctionData("unstakeToken", [
-        this._encodeIncentiveKey(incentiveKey),
-        toHex(options.tokenId)
-      ])
+      encodeFunctionData({
+        abi: _Staker.ABI,
+        functionName: "unstakeToken",
+        args: [this._encodeIncentiveKey(incentiveKey), BigInt(options.tokenId)]
+      })
     );
     const recipient = 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)])
+      encodeFunctionData({
+        abi: _Staker.ABI,
+        functionName: "claimReward",
+        args: [incentiveKey.rewardToken.address, recipient, BigInt(amount)]
+      })
     );
     return calldatas;
   }
@@ -4272,10 +4305,11 @@ var _Staker = class {
       const incentiveKey = incentiveKeys[i];
       calldatas = calldatas.concat(this.encodeClaim(incentiveKey, options));
       calldatas.push(
-        _Staker.INTERFACE.encodeFunctionData("stakeToken", [
-          this._encodeIncentiveKey(incentiveKey),
-          toHex(options.tokenId)
-        ])
+        encodeFunctionData({
+          abi: _Staker.ABI,
+          functionName: "stakeToken",
+          args: [this._encodeIncentiveKey(incentiveKey), BigInt(options.tokenId)]
+        })
       );
     }
     return {
@@ -4303,11 +4337,11 @@ var _Staker = class {
     }
     const owner = validateAndParseAddress(withdrawOptions.owner);
     calldatas.push(
-      _Staker.INTERFACE.encodeFunctionData("withdrawToken", [
-        toHex(withdrawOptions.tokenId),
-        owner,
-        withdrawOptions.data ? withdrawOptions.data : toHex(0)
-      ])
+      encodeFunctionData({
+        abi: _Staker.ABI,
+        functionName: "withdrawToken",
+        args: [BigInt(withdrawOptions.tokenId), owner, toHex(0)]
+      })
     );
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -4328,16 +4362,18 @@ var _Staker = class {
         const incentiveKey = incentiveKeys[i];
         keys.push(this._encodeIncentiveKey(incentiveKey));
       }
-      data = defaultAbiCoder.encode([`${_Staker.INCENTIVE_KEY_ABI}[]`], [keys]);
+      data = encodeAbiParameters(parseAbiParameters([`${_Staker.INCENTIVE_KEY_ABI}[]`]), [keys]);
     } else {
-      data = defaultAbiCoder.encode([_Staker.INCENTIVE_KEY_ABI], [this._encodeIncentiveKey(incentiveKeys[0])]);
+      data = encodeAbiParameters(parseAbiParameters(_Staker.INCENTIVE_KEY_ABI), [
+        this._encodeIncentiveKey(incentiveKeys[0])
+      ]);
     }
     return data;
   }
   /**
    *
    * @param incentiveKey An `IncentiveKey` which represents a unique staking program.
-   * @returns An encoded IncentiveKey to be read by ethers
+   * @returns An encoded IncentiveKey to be read by viem
    */
   static _encodeIncentiveKey(incentiveKey) {
     const { token0, token1, fee } = incentiveKey.pool;
@@ -4345,18 +4381,18 @@ var _Staker = class {
     return {
       rewardToken: incentiveKey.rewardToken.address,
       pool: Pool.getAddress(token0, token1, fee),
-      startTime: toHex(incentiveKey.startTime),
-      endTime: toHex(incentiveKey.endTime),
+      startTime: BigInt(incentiveKey.startTime),
+      endTime: BigInt(incentiveKey.endTime),
       refundee
     };
   }
 };
 var Staker = _Staker;
-Staker.INTERFACE = new Interface(V3Staker_default);
+Staker.ABI = v3StakerABI;
 Staker.INCENTIVE_KEY_ABI = "tuple(address rewardToken, address pool, uint256 startTime, uint256 endTime, address refundee)";
 
-// src/abi/SwapRouter.json
-var SwapRouter_default = [
+// src/abi/SwapRouter.ts
+var swapRouterABI = [
   {
     inputs: [
       {
@@ -4953,18 +4989,17 @@ var _SwapRouter = class {
    * @param options options for the call parameters
    */
   static swapCallParameters(trades, options) {
-    var _a, _b;
     if (!Array.isArray(trades)) {
       trades = [trades];
     }
     const sampleTrade = trades[0];
     const tokenIn = sampleTrade.inputAmount.currency.wrapped;
     const tokenOut = sampleTrade.outputAmount.currency.wrapped;
-    invariant11(
+    invariant9(
       trades.every((trade) => trade.inputAmount.currency.wrapped.equals(tokenIn)),
       "TOKEN_IN_DIFF"
     );
-    invariant11(
+    invariant9(
       trades.every((trade) => trade.outputAmount.currency.wrapped.equals(tokenOut)),
       "TOKEN_OUT_DIFF"
     );
@@ -4981,15 +5016,15 @@ var _SwapRouter = class {
     const routerMustCustody = outputIsNative || !!options.fee;
     const totalValue = inputIsNative ? trades.reduce((sum, trade) => sum.add(trade.maximumAmountIn(options.slippageTolerance)), ZERO_IN) : ZERO_IN;
     if (options.inputTokenPermit) {
-      invariant11(sampleTrade.inputAmount.currency.isToken, "NON_TOKEN_PERMIT");
+      invariant9(sampleTrade.inputAmount.currency.isToken, "NON_TOKEN_PERMIT");
       calldatas.push(SelfPermit.encodePermit(sampleTrade.inputAmount.currency, options.inputTokenPermit));
     }
     const recipient = validateAndParseAddress(options.recipient);
-    const deadline = toHex(options.deadline);
+    const deadline = BigInt(options.deadline);
     for (const trade of trades) {
       for (const { route, inputAmount, outputAmount } of trade.swaps) {
-        const amountIn = toHex(trade.maximumAmountIn(options.slippageTolerance, inputAmount).quotient);
-        const amountOut = toHex(trade.minimumAmountOut(options.slippageTolerance, outputAmount).quotient);
+        const amountIn = BigInt(trade.maximumAmountIn(options.slippageTolerance, inputAmount).quotient);
+        const amountOut = BigInt(trade.minimumAmountOut(options.slippageTolerance, outputAmount).quotient);
         const singleHop = route.pools.length === 1;
         if (singleHop) {
           if (trade.tradeType === TradeType.EXACT_INPUT) {
@@ -5001,9 +5036,15 @@ var _SwapRouter = class {
               deadline,
               amountIn,
               amountOutMinimum: amountOut,
-              sqrtPriceLimitX96: toHex((_a = options.sqrtPriceLimitX96) != null ? _a : 0)
+              sqrtPriceLimitX96: BigInt(options.sqrtPriceLimitX96 ?? 0)
             };
-            calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactInputSingle", [exactInputSingleParams]));
+            calldatas.push(
+              encodeFunctionData({
+                abi: _SwapRouter.ABI,
+                functionName: "exactInputSingle",
+                args: [exactInputSingleParams]
+              })
+            );
           } else {
             const exactOutputSingleParams = {
               tokenIn: route.tokenPath[0].address,
@@ -5013,12 +5054,18 @@ var _SwapRouter = class {
               deadline,
               amountOut,
               amountInMaximum: amountIn,
-              sqrtPriceLimitX96: toHex((_b = options.sqrtPriceLimitX96) != null ? _b : 0)
+              sqrtPriceLimitX96: BigInt(options.sqrtPriceLimitX96 ?? 0)
             };
-            calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactOutputSingle", [exactOutputSingleParams]));
+            calldatas.push(
+              encodeFunctionData({
+                abi: _SwapRouter.ABI,
+                functionName: "exactOutputSingle",
+                args: [exactOutputSingleParams]
+              })
+            );
           }
         } else {
-          invariant11(options.sqrtPriceLimitX96 === void 0, "MULTIHOP_PRICE_LIMIT");
+          invariant9(options.sqrtPriceLimitX96 === void 0, "MULTIHOP_PRICE_LIMIT");
           const path = encodeRouteToPath(route, trade.tradeType === TradeType.EXACT_OUTPUT);
           if (trade.tradeType === TradeType.EXACT_INPUT) {
             const exactInputParams = {
@@ -5028,7 +5075,9 @@ var _SwapRouter = class {
               amountIn,
               amountOutMinimum: amountOut
             };
-            calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactInput", [exactInputParams]));
+            calldatas.push(
+              encodeFunctionData({ abi: _SwapRouter.ABI, functionName: "exactInput", args: [exactInputParams] })
+            );
           } else {
             const exactOutputParams = {
               path,
@@ -5037,7 +5086,9 @@ var _SwapRouter = class {
               amountOut,
               amountInMaximum: amountIn
             };
-            calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactOutput", [exactOutputParams]));
+            calldatas.push(
+              encodeFunctionData({ abi: _SwapRouter.ABI, functionName: "exactOutput", args: [exactOutputParams] })
+            );
           }
         }
       }
@@ -5070,10 +5121,11 @@ var _SwapRouter = class {
   }
 };
 var SwapRouter = _SwapRouter;
-SwapRouter.INTERFACE = new Interface(SwapRouter_default);
+// public static INTERFACE: Interface = new Interface(ISwapRouter)
+SwapRouter.ABI = swapRouterABI;
 
-// src/abi/MasterChefV3.json
-var MasterChefV3_default = [
+// src/abi/MasterChefV3.ts
+var masterChefV3ABI = [
   {
     inputs: [
       { internalType: "contract IERC20", name: "_CAKE", type: "address" },
@@ -5761,14 +5813,14 @@ var _MasterChefV3 = class {
   // Copy from NonfungiblePositionManager
   // Only support increaseLiquidity
   static addCallParameters(position, options) {
-    invariant11(JSBI4.greaterThan(position.liquidity, ZERO$1), "ZERO_LIQUIDITY");
+    invariant9(position.liquidity > ZERO$2, "ZERO_LIQUIDITY");
     const calldatas = [];
     const { amount0: amount0Desired, amount1: amount1Desired } = position.mintAmounts;
     const minimumAmounts = position.mintAmountsWithSlippage(options.slippageTolerance);
-    const amount0Min = toHex(minimumAmounts.amount0);
-    const amount1Min = toHex(minimumAmounts.amount1);
-    const deadline = toHex(options.deadline);
-    invariant11(!isMint(options), "NO_MINT_SUPPORT");
+    const amount0Min = BigInt(minimumAmounts.amount0);
+    const amount1Min = BigInt(minimumAmounts.amount1);
+    const deadline = BigInt(options.deadline);
+    invariant9(!isMint(options), "NO_MINT_SUPPORT");
     if (options.token0Permit) {
       calldatas.push(SelfPermit.encodePermit(position.pool.token0, options.token0Permit));
     }
@@ -5776,21 +5828,25 @@ var _MasterChefV3 = class {
       calldatas.push(SelfPermit.encodePermit(position.pool.token1, options.token1Permit));
     }
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("increaseLiquidity", [
-        {
-          tokenId: toHex(options.tokenId),
-          amount0Desired: toHex(amount0Desired),
-          amount1Desired: toHex(amount1Desired),
-          amount0Min,
-          amount1Min,
-          deadline
-        }
-      ])
+      encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "increaseLiquidity",
+        args: [
+          {
+            tokenId: BigInt(options.tokenId),
+            amount0Desired,
+            amount1Desired,
+            amount0Min,
+            amount1Min,
+            deadline
+          }
+        ]
+      })
     );
     let value = toHex(0);
     if (options.useNative) {
       const { wrapped } = options.useNative;
-      invariant11(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
+      invariant9(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
       const wrappedValue = position.pool.token0.equals(wrapped) ? amount0Desired : amount1Desired;
       value = toHex(wrappedValue);
     }
@@ -5802,18 +5858,22 @@ var _MasterChefV3 = class {
   // Copy from NonfungiblePositionManager
   static encodeCollect(options) {
     const calldatas = [];
-    const tokenId = toHex(options.tokenId);
+    const tokenId = BigInt(options.tokenId);
     const involvesETH = options.expectedCurrencyOwed0.currency.isNative || options.expectedCurrencyOwed1.currency.isNative;
     const recipient = validateAndParseAddress(options.recipient);
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("collect", [
-        {
-          tokenId,
-          recipient: involvesETH ? ADDRESS_ZERO : recipient,
-          amount0Max: MaxUint128,
-          amount1Max: MaxUint128
-        }
-      ])
+      encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "collect",
+        args: [
+          {
+            tokenId,
+            recipient: involvesETH ? ADDRESS_ZERO : recipient,
+            amount0Max: MaxUint128,
+            amount1Max: MaxUint128
+          }
+        ]
+      })
     );
     if (involvesETH) {
       const ethAmount = options.expectedCurrencyOwed0.currency.isNative ? options.expectedCurrencyOwed0.quotient : options.expectedCurrencyOwed1.quotient;
@@ -5833,40 +5893,35 @@ var _MasterChefV3 = class {
   }
   static removeCallParameters(position, options) {
     const calldatas = [];
-    const deadline = toHex(options.deadline);
-    const tokenId = toHex(options.tokenId);
+    const deadline = BigInt(options.deadline);
+    const tokenId = BigInt(options.tokenId);
     const partialPosition = new Position({
       pool: position.pool,
       liquidity: options.liquidityPercentage.multiply(position.liquidity).quotient,
       tickLower: position.tickLower,
       tickUpper: position.tickUpper
     });
-    invariant11(JSBI4.greaterThan(partialPosition.liquidity, ZERO$1), "ZERO_LIQUIDITY");
+    invariant9(partialPosition.liquidity > ZERO$2, "ZERO_LIQUIDITY");
     const { amount0: amount0Min, amount1: amount1Min } = partialPosition.burnAmountsWithSlippage(
       options.slippageTolerance
     );
     if (options.permit) {
-      calldatas.push(
-        _MasterChefV3.INTERFACE.encodeFunctionData("permit", [
-          validateAndParseAddress(options.permit.spender),
-          tokenId,
-          toHex(options.permit.deadline),
-          options.permit.v,
-          options.permit.r,
-          options.permit.s
-        ])
-      );
+      throw new Error("NOT_IMPLEMENTED");
     }
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("decreaseLiquidity", [
-        {
-          tokenId,
-          liquidity: toHex(partialPosition.liquidity),
-          amount0Min: toHex(amount0Min),
-          amount1Min: toHex(amount1Min),
-          deadline
-        }
-      ])
+      encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "decreaseLiquidity",
+        args: [
+          {
+            tokenId,
+            liquidity: partialPosition.liquidity,
+            amount0Min,
+            amount1Min,
+            deadline
+          }
+        ]
+      })
     );
     const { expectedCurrencyOwed0, expectedCurrencyOwed1, ...rest } = options.collectOptions;
     calldatas.push(
@@ -5882,29 +5937,31 @@ var _MasterChefV3 = class {
         ...rest
       })
     );
-    if (rest == null ? void 0 : rest.recipient) {
+    if (rest?.recipient) {
       if (options.liquidityPercentage.equalTo(ONE$1)) {
         calldatas.push(
-          _MasterChefV3.INTERFACE.encodeFunctionData("withdraw", [
-            tokenId.toString(),
-            validateAndParseAddress(rest == null ? void 0 : rest.recipient)
-          ])
+          encodeFunctionData({
+            abi: _MasterChefV3.ABI,
+            functionName: "withdraw",
+            args: [tokenId, validateAndParseAddress(rest?.recipient)]
+          })
         );
       } else {
         calldatas.push(
-          _MasterChefV3.INTERFACE.encodeFunctionData("harvest", [
-            tokenId.toString(),
-            validateAndParseAddress(rest == null ? void 0 : rest.recipient)
-          ])
+          encodeFunctionData({
+            abi: _MasterChefV3.ABI,
+            functionName: "harvest",
+            args: [tokenId, validateAndParseAddress(rest?.recipient)]
+          })
         );
       }
     }
     if (options.liquidityPercentage.equalTo(ONE$1)) {
       if (options.burnToken) {
-        calldatas.push(_MasterChefV3.INTERFACE.encodeFunctionData("burn", [tokenId]));
+        calldatas.push(encodeFunctionData({ abi: _MasterChefV3.ABI, functionName: "burn", args: [tokenId] }));
       }
     } else {
-      invariant11(options.burnToken !== true, "CANNOT_BURN");
+      invariant9(options.burnToken !== true, "CANNOT_BURN");
     }
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -5930,7 +5987,11 @@ var _MasterChefV3 = class {
     const { tokenId, to } = options;
     const calldatas = [];
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("harvest", [tokenId.toString(), validateAndParseAddress(to)])
+      encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "harvest",
+        args: [BigInt(tokenId), validateAndParseAddress(to)]
+      })
     );
     return calldatas;
   }
@@ -5938,7 +5999,11 @@ var _MasterChefV3 = class {
     const { tokenId, to } = options;
     const calldatas = [];
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("withdraw", [tokenId.toString(), validateAndParseAddress(to)])
+      encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "withdraw",
+        args: [BigInt(tokenId), validateAndParseAddress(to)]
+      })
     );
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -5947,6 +6012,6 @@ var _MasterChefV3 = class {
   }
 };
 var MasterChefV3 = _MasterChefV3;
-MasterChefV3.INTERFACE = new Interface(MasterChefV3_default);
+MasterChefV3.ABI = masterChefV3ABI;
 
-export { ADDRESS_ZERO, DEPLOYER_ADDRESS, DEPLOYER_ADDRESSES, FACTORY_ADDRESS, FeeAmount, FeeCalculator, FullMath, LiquidityMath, MasterChefV3, MaxUint128, Multicall, NoTickDataProvider, NonfungiblePositionManager, POOL_INIT_CODE_HASH, Payments, Pool, Position, PositionLibrary, PositionMath, Route, SelfPermit, SqrtPriceMath, Staker, SwapMath, SwapQuoter, SwapRouter, TICK_SPACINGS, Tick, TickLibrary, TickList, TickListDataProvider, TickMath, Trade, computePoolAddress, encodeRouteToPath, encodeSqrtRatioX96, getAmountsAtNewPrice, getAmountsByLiquidityAndPrice, getAverageLiquidity, getDependentAmount, getEstimatedLPFee, getEstimatedLPFeeWithProtocolFee, getLiquidityByAmountsAndPrice, getLiquidityBySingleAmount, getLiquidityFromSqrtRatioX96, getLiquidityFromTick, isMint, isSorted, maxLiquidityForAmounts, mostSignificantBit, nearestUsableTick, parseProtocolFees, priceToClosestTick, subIn256, tickToPrice, toHex, tradeComparator };
+export { ADDRESS_ZERO, DEPLOYER_ADDRESS, DEPLOYER_ADDRESSES, FACTORY_ADDRESS, FeeAmount, FeeCalculator, FullMath, LiquidityMath, MasterChefV3, MaxUint128, Multicall, NoTickDataProvider, NonfungiblePositionManager, POOL_INIT_CODE_HASH, Payments, Pool, Position, PositionLibrary, PositionMath, Route, SelfPermit, SqrtPriceMath, Staker, SwapMath, SwapQuoter, SwapRouter, TICK_SPACINGS, Tick, TickLibrary, TickList, TickListDataProvider, TickMath, Trade, computePoolAddress, encodeRouteToPath, encodeSqrtRatioX96, getAmountsAtNewPrice, getAmountsByLiquidityAndPrice, getAverageLiquidity, getDependentAmount, getEstimatedLPFee, getEstimatedLPFeeByAmounts, getEstimatedLPFeeByAmountsWithProtocolFee, getEstimatedLPFeeWithProtocolFee, getLiquidityByAmountsAndPrice, getLiquidityBySingleAmount, getLiquidityFromSqrtRatioX96, getLiquidityFromTick, isMint, isSorted, masterChefV3ABI, maxLiquidityForAmounts, mostSignificantBit, nearestUsableTick, nonfungiblePositionManagerABI, parseProtocolFees, peripheryPaymentsWithFeeABI, priceToClosestTick, quoterABI, quoterV2ABI, selfPermitABI, sqrtRatioX96ToPrice, subIn256, swapRouterABI, tickToPrice, toHex, tradeComparator, v3StakerABI };