@pancakeswap/v3-sdk 1.0.0 → 3.0.0

package/dist/index.js

@@ -1,17 +1,13 @@
 'use strict';
 
 var sdk = require('@pancakeswap/sdk');
-var JSBI4 = require('jsbi');
-var invariant11 = require('tiny-invariant');
+var invariant9 = require('tiny-invariant');
 var swapSdkCore = require('@pancakeswap/swap-sdk-core');
-var abi = require('@ethersproject/abi');
-var address = require('@ethersproject/address');
-var solidity = require('@ethersproject/solidity');
+var viem = require('viem');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var JSBI4__default = /*#__PURE__*/_interopDefault(JSBI4);
-var invariant11__default = /*#__PURE__*/_interopDefault(invariant11);
+var invariant9__default = /*#__PURE__*/_interopDefault(invariant9);
 
 // src/entities/pool.ts
 var FACTORY_ADDRESS = "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865";
@@ -37,15 +33,22 @@ var TICK_SPACINGS = {
   [2500 /* MEDIUM */]: 50,
   [1e4 /* HIGH */]: 200
 };
-var NEGATIVE_ONE = swapSdkCore.JSBI.BigInt(-1);
-var ZERO = swapSdkCore.JSBI.BigInt(0);
-var ONE = swapSdkCore.JSBI.BigInt(1);
-var Q96 = swapSdkCore.JSBI.exponentiate(swapSdkCore.JSBI.BigInt(2), swapSdkCore.JSBI.BigInt(96));
-var Q192 = swapSdkCore.JSBI.exponentiate(Q96, swapSdkCore.JSBI.BigInt(2));
-var MAX_FEE = swapSdkCore.JSBI.exponentiate(swapSdkCore.JSBI.BigInt(10), swapSdkCore.JSBI.BigInt(6));
+var NEGATIVE_ONE = BigInt(-1);
+var ZERO = 0n;
+var ONE = 1n;
+var Q96 = 2n ** 96n;
+var Q192 = Q96 ** 2n;
+var MAX_FEE = 10n ** 6n;
 var ONE_HUNDRED_PERCENT = new swapSdkCore.Percent("1");
 var ZERO_PERCENT = new swapSdkCore.Percent("0");
-var Q128 = swapSdkCore.JSBI.exponentiate(swapSdkCore.JSBI.BigInt(2), swapSdkCore.JSBI.BigInt(128));
+var Q128 = 2n ** 128n;
+function getCreate2Address(from_, salt_, initCodeHash) {
+  const from = viem.toBytes(viem.getAddress(from_));
+  const salt = viem.pad(viem.isBytes(salt_) ? salt_ : viem.toBytes(salt_), {
+    size: 32
+  });
+  return viem.getAddress(viem.slice(viem.keccak256(viem.concat([viem.toBytes("0xff"), from, salt, viem.toBytes(initCodeHash)])), 12));
+}
 function computePoolAddress({
   deployerAddress,
   tokenA,
@@ -54,15 +57,16 @@ function computePoolAddress({
   initCodeHashManualOverride
 }) {
   const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
-  return address.getCreate2Address(
+  return getCreate2Address(
     deployerAddress,
-    solidity.keccak256(
-      ["bytes"],
-      [abi.defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]
+    viem.keccak256(
+      viem.encodeAbiParameters(viem.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.
@@ -70,12 +74,14 @@ var LiquidityMath = class {
   constructor() {
   }
   static addDelta(x, y) {
-    if (JSBI4__default.default.lessThan(y, ZERO)) {
-      return JSBI4__default.default.subtract(x, JSBI4__default.default.multiply(y, NEGATIVE_ONE));
+    if (y < ZERO) {
+      return x - y * NEGATIVE_ONE;
     }
-    return JSBI4__default.default.add(x, y);
+    return x + y;
   }
 };
+
+// src/utils/fullMath.ts
 var FullMath = class {
   /**
    * Cannot be constructed.
@@ -83,21 +89,21 @@ var FullMath = class {
   constructor() {
   }
   static mulDivRoundingUp(a, b, denominator) {
-    const product = JSBI4__default.default.multiply(a, b);
-    let result = JSBI4__default.default.divide(product, denominator);
-    if (JSBI4__default.default.notEqual(JSBI4__default.default.remainder(product, denominator), ZERO))
-      result = JSBI4__default.default.add(result, ONE);
+    const product = a * b;
+    let result = product / denominator;
+    if (product % denominator !== ZERO)
+      result = result + ONE;
     return result;
   }
 };
-var MaxUint160 = JSBI4__default.default.subtract(JSBI4__default.default.exponentiate(JSBI4__default.default.BigInt(2), JSBI4__default.default.BigInt(160)), ONE);
+var MaxUint160 = 2n ** 160n - ONE;
 function multiplyIn256(x, y) {
-  const product = JSBI4__default.default.multiply(x, y);
-  return JSBI4__default.default.bitwiseAnd(product, sdk.MaxUint256);
+  const product = x * y;
+  return product & swapSdkCore.MaxUint256;
 }
 function addIn256(x, y) {
-  const sum = JSBI4__default.default.add(x, y);
-  return JSBI4__default.default.bitwiseAnd(sum, sdk.MaxUint256);
+  const sum = x + y;
+  return sum & swapSdkCore.MaxUint256;
 }
 var SqrtPriceMath = class {
   /**
@@ -106,59 +112,59 @@ var SqrtPriceMath = class {
   constructor() {
   }
   static getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
-    if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
       sqrtRatioAX96 = sqrtRatioBX96;
       sqrtRatioBX96 = sqrtRatioAX96;
     }
-    const numerator1 = JSBI4__default.default.leftShift(liquidity, JSBI4__default.default.BigInt(96));
-    const numerator2 = JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96);
-    return roundUp ? FullMath.mulDivRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96), ONE, sqrtRatioAX96) : JSBI4__default.default.divide(JSBI4__default.default.divide(JSBI4__default.default.multiply(numerator1, numerator2), sqrtRatioBX96), sqrtRatioAX96);
+    const numerator1 = liquidity << 96n;
+    const numerator2 = sqrtRatioBX96 - sqrtRatioAX96;
+    return roundUp ? FullMath.mulDivRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96), ONE, sqrtRatioAX96) : numerator1 * numerator2 / sqrtRatioBX96 / sqrtRatioAX96;
   }
   static getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
-    if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
       sqrtRatioAX96 = sqrtRatioBX96;
       sqrtRatioBX96 = sqrtRatioAX96;
     }
-    return roundUp ? FullMath.mulDivRoundingUp(liquidity, JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96), Q96) : JSBI4__default.default.divide(JSBI4__default.default.multiply(liquidity, JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96)), Q96);
+    return roundUp ? FullMath.mulDivRoundingUp(liquidity, sqrtRatioBX96 - sqrtRatioAX96, Q96) : liquidity * (sqrtRatioBX96 - sqrtRatioAX96) / Q96;
   }
   static getNextSqrtPriceFromInput(sqrtPX96, liquidity, amountIn, zeroForOne) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPX96, ZERO));
-    invariant11__default.default(JSBI4__default.default.greaterThan(liquidity, ZERO));
+    invariant9__default.default(sqrtPX96 > ZERO);
+    invariant9__default.default(liquidity > ZERO);
     return zeroForOne ? this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true) : this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountIn, true);
   }
   static getNextSqrtPriceFromOutput(sqrtPX96, liquidity, amountOut, zeroForOne) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPX96, ZERO));
-    invariant11__default.default(JSBI4__default.default.greaterThan(liquidity, ZERO));
+    invariant9__default.default(sqrtPX96 > ZERO);
+    invariant9__default.default(liquidity > ZERO);
     return zeroForOne ? this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountOut, false) : this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountOut, false);
   }
   static getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amount, add) {
-    if (JSBI4__default.default.equal(amount, ZERO))
+    if (amount === ZERO)
       return sqrtPX96;
-    const numerator1 = JSBI4__default.default.leftShift(liquidity, JSBI4__default.default.BigInt(96));
+    const numerator1 = liquidity << 96n;
     if (add) {
       const product2 = multiplyIn256(amount, sqrtPX96);
-      if (JSBI4__default.default.equal(JSBI4__default.default.divide(product2, amount), sqrtPX96)) {
+      if (product2 / amount === sqrtPX96) {
         const denominator2 = addIn256(numerator1, product2);
-        if (JSBI4__default.default.greaterThanOrEqual(denominator2, numerator1)) {
+        if (denominator2 >= numerator1) {
           return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator2);
         }
       }
-      return FullMath.mulDivRoundingUp(numerator1, ONE, JSBI4__default.default.add(JSBI4__default.default.divide(numerator1, sqrtPX96), amount));
+      return FullMath.mulDivRoundingUp(numerator1, ONE, numerator1 / sqrtPX96 + amount);
     }
     const product = multiplyIn256(amount, sqrtPX96);
-    invariant11__default.default(JSBI4__default.default.equal(JSBI4__default.default.divide(product, amount), sqrtPX96));
-    invariant11__default.default(JSBI4__default.default.greaterThan(numerator1, product));
-    const denominator = JSBI4__default.default.subtract(numerator1, product);
+    invariant9__default.default(product / amount === sqrtPX96);
+    invariant9__default.default(numerator1 > product);
+    const denominator = numerator1 - product;
     return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator);
   }
   static getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amount, add) {
     if (add) {
-      const quotient2 = JSBI4__default.default.lessThanOrEqual(amount, MaxUint160) ? JSBI4__default.default.divide(JSBI4__default.default.leftShift(amount, JSBI4__default.default.BigInt(96)), liquidity) : JSBI4__default.default.divide(JSBI4__default.default.multiply(amount, Q96), liquidity);
-      return JSBI4__default.default.add(sqrtPX96, quotient2);
+      const quotient2 = amount <= MaxUint160 ? (amount << 96n) / liquidity : amount * Q96 / liquidity;
+      return sqrtPX96 + quotient2;
     }
     const quotient = FullMath.mulDivRoundingUp(amount, Q96, liquidity);
-    invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPX96, quotient));
-    return JSBI4__default.default.subtract(sqrtPX96, quotient);
+    invariant9__default.default(sqrtPX96 > quotient);
+    return sqrtPX96 - quotient;
   }
 };
 
@@ -171,15 +177,12 @@ var SwapMath = class {
   }
   static computeSwapStep(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, amountRemaining, feePips) {
     const returnValues = {};
-    const zeroForOne = JSBI4__default.default.greaterThanOrEqual(sqrtRatioCurrentX96, sqrtRatioTargetX96);
-    const exactIn = JSBI4__default.default.greaterThanOrEqual(amountRemaining, ZERO);
+    const zeroForOne = sqrtRatioCurrentX96 >= sqrtRatioTargetX96;
+    const exactIn = amountRemaining >= ZERO;
     if (exactIn) {
-      const amountRemainingLessFee = JSBI4__default.default.divide(
-        JSBI4__default.default.multiply(amountRemaining, JSBI4__default.default.subtract(MAX_FEE, JSBI4__default.default.BigInt(feePips))),
-        MAX_FEE
-      );
+      const amountRemainingLessFee = amountRemaining * (MAX_FEE - BigInt(feePips)) / MAX_FEE;
       returnValues.amountIn = zeroForOne ? SqrtPriceMath.getAmount0Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, true) : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, true);
-      if (JSBI4__default.default.greaterThanOrEqual(amountRemainingLessFee, returnValues.amountIn)) {
+      if (amountRemainingLessFee >= returnValues.amountIn) {
         returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
       } else {
         returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
@@ -191,18 +194,18 @@ var SwapMath = class {
       }
     } else {
       returnValues.amountOut = zeroForOne ? SqrtPriceMath.getAmount1Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, false) : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, false);
-      if (JSBI4__default.default.greaterThanOrEqual(JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE), returnValues.amountOut)) {
+      if (amountRemaining * NEGATIVE_ONE >= returnValues.amountOut) {
         returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
       } else {
         returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
           sqrtRatioCurrentX96,
           liquidity,
-          JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE),
+          amountRemaining * NEGATIVE_ONE,
           zeroForOne
         );
       }
     }
-    const max = JSBI4__default.default.equal(sqrtRatioTargetX96, returnValues.sqrtRatioNextX96);
+    const max = sqrtRatioTargetX96 === returnValues.sqrtRatioNextX96;
     if (zeroForOne) {
       returnValues.amountIn = max && exactIn ? returnValues.amountIn : SqrtPriceMath.getAmount0Delta(returnValues.sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, true);
       returnValues.amountOut = max && !exactIn ? returnValues.amountOut : SqrtPriceMath.getAmount1Delta(returnValues.sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, false);
@@ -210,33 +213,30 @@ var SwapMath = class {
       returnValues.amountIn = max && exactIn ? returnValues.amountIn : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, returnValues.sqrtRatioNextX96, liquidity, true);
       returnValues.amountOut = max && !exactIn ? returnValues.amountOut : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, returnValues.sqrtRatioNextX96, liquidity, false);
     }
-    if (!exactIn && JSBI4__default.default.greaterThan(returnValues.amountOut, JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE))) {
-      returnValues.amountOut = JSBI4__default.default.multiply(amountRemaining, NEGATIVE_ONE);
+    if (!exactIn && returnValues.amountOut > amountRemaining * NEGATIVE_ONE) {
+      returnValues.amountOut = amountRemaining * NEGATIVE_ONE;
     }
-    if (exactIn && JSBI4__default.default.notEqual(returnValues.sqrtRatioNextX96, sqrtRatioTargetX96)) {
-      returnValues.feeAmount = JSBI4__default.default.subtract(amountRemaining, returnValues.amountIn);
+    if (exactIn && returnValues.sqrtRatioNextX96 !== sqrtRatioTargetX96) {
+      returnValues.feeAmount = amountRemaining - returnValues.amountIn;
     } else {
       returnValues.feeAmount = FullMath.mulDivRoundingUp(
         returnValues.amountIn,
-        JSBI4__default.default.BigInt(feePips),
-        JSBI4__default.default.subtract(MAX_FEE, JSBI4__default.default.BigInt(feePips))
+        BigInt(feePips),
+        MAX_FEE - BigInt(feePips)
       );
     }
     return [returnValues.sqrtRatioNextX96, returnValues.amountIn, returnValues.amountOut, returnValues.feeAmount];
   }
 };
-var TWO = JSBI4__default.default.BigInt(2);
-var POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow) => [
-  pow,
-  JSBI4__default.default.exponentiate(TWO, JSBI4__default.default.BigInt(pow))
-]);
+var TWO = 2n;
+var POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow) => [pow, TWO ** BigInt(pow)]);
 function mostSignificantBit(x) {
-  invariant11__default.default(JSBI4__default.default.greaterThan(x, ZERO), "ZERO");
-  invariant11__default.default(JSBI4__default.default.lessThanOrEqual(x, sdk.MaxUint256), "MAX");
+  invariant9__default.default(x > ZERO, "ZERO");
+  invariant9__default.default(x <= swapSdkCore.MaxUint256, "MAX");
   let msb = 0;
   for (const [power, min] of POWERS_OF_2) {
-    if (JSBI4__default.default.greaterThanOrEqual(x, min)) {
-      x = JSBI4__default.default.signedRightShift(x, JSBI4__default.default.BigInt(power));
+    if (x >= min) {
+      x = x >> BigInt(power);
       msb += power;
     }
   }
@@ -245,9 +245,9 @@ function mostSignificantBit(x) {
 
 // src/utils/tickMath.ts
 function mulShift(val, mulBy) {
-  return sdk.JSBI.signedRightShift(sdk.JSBI.multiply(val, sdk.JSBI.BigInt(mulBy)), sdk.JSBI.BigInt(128));
+  return val * BigInt(mulBy) >> 128n;
 }
-var Q32 = sdk.JSBI.exponentiate(sdk.JSBI.BigInt(2), sdk.JSBI.BigInt(32));
+var Q32 = 2n ** 32n;
 var _TickMath = class {
   /**
    * Cannot be constructed.
@@ -259,9 +259,9 @@ var _TickMath = class {
    * @param tick the tick for which to compute the sqrt ratio
    */
   static getSqrtRatioAtTick(tick) {
-    invariant11__default.default(tick >= _TickMath.MIN_TICK && tick <= _TickMath.MAX_TICK && Number.isInteger(tick), "TICK");
+    invariant9__default.default(tick >= _TickMath.MIN_TICK && tick <= _TickMath.MAX_TICK && Number.isInteger(tick), "TICK");
     const absTick = tick < 0 ? tick * -1 : tick;
-    let ratio = (absTick & 1) != 0 ? sdk.JSBI.BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : sdk.JSBI.BigInt("0x100000000000000000000000000000000");
+    let ratio = (absTick & 1) != 0 ? BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : BigInt("0x100000000000000000000000000000000");
     if ((absTick & 2) != 0)
       ratio = mulShift(ratio, "0xfff97272373d413259a46990580e213a");
     if ((absTick & 4) != 0)
@@ -301,8 +301,8 @@ var _TickMath = class {
     if ((absTick & 524288) != 0)
       ratio = mulShift(ratio, "0x48a170391f7dc42444e8fa2");
     if (tick > 0)
-      ratio = sdk.JSBI.divide(sdk.MaxUint256, ratio);
-    return sdk.JSBI.greaterThan(sdk.JSBI.remainder(ratio, Q32), ZERO) ? sdk.JSBI.add(sdk.JSBI.divide(ratio, Q32), ONE) : sdk.JSBI.divide(ratio, Q32);
+      ratio = swapSdkCore.MaxUint256 / ratio;
+    return ratio % Q32 > ZERO ? ratio / Q32 + ONE : ratio / Q32;
   }
   /**
    * Returns the tick corresponding to a given sqrt ratio, s.t. #getSqrtRatioAtTick(tick) <= sqrtRatioX96
@@ -310,39 +310,26 @@ var _TickMath = class {
    * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
    */
   static getTickAtSqrtRatio(sqrtRatioX96) {
-    invariant11__default.default(
-      sdk.JSBI.greaterThanOrEqual(sqrtRatioX96, _TickMath.MIN_SQRT_RATIO) && sdk.JSBI.lessThan(sqrtRatioX96, _TickMath.MAX_SQRT_RATIO),
-      "SQRT_RATIO"
-    );
-    const sqrtRatioX128 = sdk.JSBI.leftShift(sqrtRatioX96, sdk.JSBI.BigInt(32));
+    invariant9__default.default(sqrtRatioX96 >= _TickMath.MIN_SQRT_RATIO && sqrtRatioX96 < _TickMath.MAX_SQRT_RATIO, "SQRT_RATIO");
+    const sqrtRatioX128 = sqrtRatioX96 << 32n;
     const msb = mostSignificantBit(sqrtRatioX128);
     let r;
-    if (sdk.JSBI.greaterThanOrEqual(sdk.JSBI.BigInt(msb), sdk.JSBI.BigInt(128))) {
-      r = sdk.JSBI.signedRightShift(sqrtRatioX128, sdk.JSBI.BigInt(msb - 127));
+    if (BigInt(msb) >= 128n) {
+      r = sqrtRatioX128 >> BigInt(msb - 127);
     } else {
-      r = sdk.JSBI.leftShift(sqrtRatioX128, sdk.JSBI.BigInt(127 - msb));
+      r = sqrtRatioX128 << BigInt(127 - msb);
     }
-    let log_2 = sdk.JSBI.leftShift(sdk.JSBI.subtract(sdk.JSBI.BigInt(msb), sdk.JSBI.BigInt(128)), sdk.JSBI.BigInt(64));
+    let log_2 = BigInt(msb) - 128n << 64n;
     for (let i = 0; i < 14; i++) {
-      r = sdk.JSBI.signedRightShift(sdk.JSBI.multiply(r, r), sdk.JSBI.BigInt(127));
-      const f = sdk.JSBI.signedRightShift(r, sdk.JSBI.BigInt(128));
-      log_2 = sdk.JSBI.bitwiseOr(log_2, sdk.JSBI.leftShift(f, sdk.JSBI.BigInt(63 - i)));
-      r = sdk.JSBI.signedRightShift(r, f);
+      r = r * r >> 127n;
+      const f = r >> 128n;
+      log_2 = log_2 | f << BigInt(63 - i);
+      r = r >> f;
     }
-    const log_sqrt10001 = sdk.JSBI.multiply(log_2, sdk.JSBI.BigInt("255738958999603826347141"));
-    const tickLow = sdk.JSBI.toNumber(
-      sdk.JSBI.signedRightShift(
-        sdk.JSBI.subtract(log_sqrt10001, sdk.JSBI.BigInt("3402992956809132418596140100660247210")),
-        sdk.JSBI.BigInt(128)
-      )
-    );
-    const tickHigh = sdk.JSBI.toNumber(
-      sdk.JSBI.signedRightShift(
-        sdk.JSBI.add(log_sqrt10001, sdk.JSBI.BigInt("291339464771989622907027621153398088495")),
-        sdk.JSBI.BigInt(128)
-      )
-    );
-    return tickLow === tickHigh ? tickLow : sdk.JSBI.lessThanOrEqual(_TickMath.getSqrtRatioAtTick(tickHigh), sqrtRatioX96) ? tickHigh : tickLow;
+    const log_sqrt10001 = log_2 * 255738958999603826347141n;
+    const tickLow = Number(log_sqrt10001 - 3402992956809132418596140100660247210n >> 128n);
+    const tickHigh = Number(log_sqrt10001 + 291339464771989622907027621153398088495n >> 128n);
+    return tickLow === tickHigh ? tickLow : _TickMath.getSqrtRatioAtTick(tickHigh) <= sqrtRatioX96 ? tickHigh : tickLow;
   }
 };
 var TickMath = _TickMath;
@@ -358,11 +345,11 @@ TickMath.MAX_TICK = -_TickMath.MIN_TICK;
 /**
  * The sqrt ratio corresponding to the minimum tick that could be used on any pool.
  */
-TickMath.MIN_SQRT_RATIO = sdk.JSBI.BigInt("4295128739");
+TickMath.MIN_SQRT_RATIO = 4295128739n;
 /**
  * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
  */
-TickMath.MAX_SQRT_RATIO = sdk.JSBI.BigInt("1461446703485210103287273052203988822378723970342");
+TickMath.MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
 
 // src/entities/tickDataProvider.ts
 var _NoTickDataProvider = class {
@@ -397,31 +384,25 @@ var TickList = class {
   constructor() {
   }
   static validateList(ticks, tickSpacing) {
-    invariant11__default.default(tickSpacing > 0, "TICK_SPACING_NONZERO");
-    invariant11__default.default(
+    invariant9__default.default(tickSpacing > 0, "TICK_SPACING_NONZERO");
+    invariant9__default.default(
       ticks.every(({ index }) => index % tickSpacing === 0),
       "TICK_SPACING"
     );
-    invariant11__default.default(
-      JSBI4__default.default.equal(
-        ticks.reduce((accumulator, { liquidityNet }) => JSBI4__default.default.add(accumulator, liquidityNet), ZERO),
-        ZERO
-      ),
-      "ZERO_NET"
-    );
-    invariant11__default.default(isSorted(ticks, tickComparator), "SORTED");
+    invariant9__default.default(ticks.reduce((accumulator, { liquidityNet }) => accumulator + liquidityNet, ZERO) === ZERO, "ZERO_NET");
+    invariant9__default.default(isSorted(ticks, tickComparator), "SORTED");
   }
   static isBelowSmallest(ticks, tick) {
-    invariant11__default.default(ticks.length > 0, "LENGTH");
+    invariant9__default.default(ticks.length > 0, "LENGTH");
     return tick < ticks[0].index;
   }
   static isAtOrAboveLargest(ticks, tick) {
-    invariant11__default.default(ticks.length > 0, "LENGTH");
+    invariant9__default.default(ticks.length > 0, "LENGTH");
     return tick >= ticks[ticks.length - 1].index;
   }
   static getTick(ticks, index) {
     const tick = ticks[this.binarySearch(ticks, index)];
-    invariant11__default.default(tick.index === index, "NOT_CONTAINED");
+    invariant9__default.default(tick.index === index, "NOT_CONTAINED");
     return tick;
   }
   /**
@@ -431,7 +412,7 @@ var TickList = class {
    * @private
    */
   static binarySearch(ticks, tick) {
-    invariant11__default.default(!this.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+    invariant9__default.default(!this.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
     let l = 0;
     let r = ticks.length - 1;
     let i;
@@ -449,14 +430,14 @@ var TickList = class {
   }
   static nextInitializedTick(ticks, tick, lte) {
     if (lte) {
-      invariant11__default.default(!TickList.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+      invariant9__default.default(!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__default.default(!this.isAtOrAboveLargest(ticks, tick), "AT_OR_ABOVE_LARGEST");
+    invariant9__default.default(!this.isAtOrAboveLargest(ticks, tick), "AT_OR_ABOVE_LARGEST");
     if (this.isBelowSmallest(ticks, tick)) {
       return ticks[0];
     }
@@ -493,116 +474,273 @@ var TickList = class {
     return Math.abs(beforeIndex - afterIndex);
   }
 };
-function toHex(bigintIsh) {
-  const bigInt = JSBI4__default.default.BigInt(bigintIsh);
-  let hex = bigInt.toString(16);
-  if (hex.length % 2 !== 0) {
-    hex = `0${hex}`;
+var Tick = class {
+  constructor({ index, liquidityGross, liquidityNet }) {
+    invariant9__default.default(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__default.default(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 sdk.Price(this.token0, this.token1, Q192, this.sqrtRatioX96 * this.sqrtRatioX96));
+  }
+  /**
+   * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+   */
+  get token1Price() {
+    return this._token1Price ?? (this._token1Price = new sdk.Price(this.token1, this.token0, this.sqrtRatioX96 * this.sqrtRatioX96, Q192));
+  }
+  /**
+   * Return the price of the given token in terms of the other token in the pool.
+   * @param token The token to return price of
+   * @returns The price of the given token, in terms of the other.
+   */
+  priceOf(token) {
+    invariant9__default.default(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__default.default(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 [
+      sdk.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__default.default(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__default.default(amountSpecifiedRemaining === ZERO, "INSUFICIENT_LIQUIDITY");
+    const inputToken = zeroForOne ? this.token0 : this.token1;
+    return [
+      sdk.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__default.default(sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO, "RATIO_MIN");
+      invariant9__default.default(sqrtPriceLimitX96 < this.sqrtRatioX96, "RATIO_CURRENT");
+    } else {
+      invariant9__default.default(sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO, "RATIO_MAX");
+      invariant9__default.default(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 ? solidity.pack(types.reverse(), path.reverse()) : solidity.pack(types, path);
-}
-function encodeSqrtRatioX96(amount1, amount0) {
-  const numerator = JSBI4__default.default.leftShift(JSBI4__default.default.BigInt(amount1), JSBI4__default.default.BigInt(192));
-  const denominator = JSBI4__default.default.BigInt(amount0);
-  const ratioX192 = JSBI4__default.default.divide(numerator, denominator);
-  return sdk.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__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  const intermediate = JSBI4__default.default.divide(JSBI4__default.default.multiply(sqrtRatioAX96, sqrtRatioBX96), Q96);
-  return JSBI4__default.default.divide(JSBI4__default.default.multiply(JSBI4__default.default.BigInt(amount0), intermediate), JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96));
+  const intermediate = sqrtRatioAX96 * sqrtRatioBX96 / Q96;
+  return BigInt(amount0) * intermediate / (sqrtRatioBX96 - sqrtRatioAX96);
 }
 function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
-  if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  const numerator = JSBI4__default.default.multiply(JSBI4__default.default.multiply(JSBI4__default.default.BigInt(amount0), sqrtRatioAX96), sqrtRatioBX96);
-  const denominator = JSBI4__default.default.multiply(Q96, JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96));
-  return JSBI4__default.default.divide(numerator, denominator);
+  const numerator = BigInt(amount0) * sqrtRatioAX96 * sqrtRatioBX96;
+  const denominator = Q96 * (sqrtRatioBX96 - sqrtRatioAX96);
+  return numerator / denominator;
 }
 function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
-  if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
-  return JSBI4__default.default.divide(JSBI4__default.default.multiply(JSBI4__default.default.BigInt(amount1), Q96), JSBI4__default.default.subtract(sqrtRatioBX96, sqrtRatioAX96));
+  return BigInt(amount1) * Q96 / (sqrtRatioBX96 - sqrtRatioAX96);
 }
 function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX96, amount0, amount1, useFullPrecision) {
-  if (JSBI4__default.default.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
     sqrtRatioAX96 = sqrtRatioBX96;
     sqrtRatioBX96 = sqrtRatioAX96;
   }
   const maxLiquidityForAmount0 = useFullPrecision ? maxLiquidityForAmount0Precise : maxLiquidityForAmount0Imprecise;
-  if (JSBI4__default.default.lessThanOrEqual(sqrtRatioCurrentX96, sqrtRatioAX96)) {
+  if (sqrtRatioCurrentX96 <= sqrtRatioAX96) {
     return maxLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
   }
-  if (JSBI4__default.default.lessThan(sqrtRatioCurrentX96, sqrtRatioBX96)) {
+  if (sqrtRatioCurrentX96 < sqrtRatioBX96) {
     const liquidity0 = maxLiquidityForAmount0(sqrtRatioCurrentX96, sqrtRatioBX96, amount0);
     const liquidity1 = maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioCurrentX96, amount1);
-    return JSBI4__default.default.lessThan(liquidity0, liquidity1) ? liquidity0 : liquidity1;
+    return liquidity0 < liquidity1 ? liquidity0 : liquidity1;
   }
   return maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
 }
-function nearestUsableTick(tick, tickSpacing) {
-  invariant11__default.default(Number.isInteger(tick) && Number.isInteger(tickSpacing), "INTEGERS");
-  invariant11__default.default(tickSpacing > 0, "TICK_SPACING");
-  invariant11__default.default(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 swapSdkCore.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 = sdk.JSBI.divide(
-      sdk.JSBI.multiply(subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128), liquidity),
-      Q128
-    );
-    const tokensOwed1 = sdk.JSBI.divide(
-      sdk.JSBI.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__default.default.multiply(sqrtRatioX96, sqrtRatioX96);
-  return baseToken.sortsBefore(quoteToken) ? new sdk.Price(baseToken, quoteToken, Q192, ratioX192) : new sdk.Price(baseToken, quoteToken, ratioX192, Q192);
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
+  return baseToken.sortsBefore(quoteToken) ? new swapSdkCore.Price(baseToken, quoteToken, Q192, ratioX192) : new swapSdkCore.Price(baseToken, quoteToken, ratioX192, Q192);
 }
 function priceToClosestTick(price) {
   const sorted = price.baseCurrency.sortsBefore(price.quoteCurrency);
@@ -618,55 +756,16 @@ function priceToClosestTick(price) {
   }
   return tick;
 }
-var Q256 = JSBI4__default.default.exponentiate(JSBI4__default.default.BigInt(2), JSBI4__default.default.BigInt(256));
-function subIn256(x, y) {
-  const difference = JSBI4__default.default.subtract(x, y);
-  if (JSBI4__default.default.lessThan(difference, ZERO)) {
-    return JSBI4__default.default.add(Q256, difference);
-  }
-  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);
@@ -691,434 +790,43 @@ var PositionMath = {
   getToken0Amount,
   getToken1Amount
 };
-function parseNumberToFraction(num, precision = 6) {
-  const scalar = 10 ** precision;
-  return new swapSdkCore.Fraction(swapSdkCore.JSBI.BigInt(Math.floor(num * scalar)), swapSdkCore.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 sdk.Fraction(sdk.ZERO);
-  }
-}
-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 sdk.Fraction(sdk.ZERO);
-  }
-}
-function tryGetEstimatedLPFee({
-  amount,
-  currency,
-  volume24H,
-  sqrtRatioX96,
-  tickLower,
-  tickUpper,
-  mostActiveLiquidity,
-  fee,
-  insidePercentage = ONE_HUNDRED_PERCENT
-}) {
-  invariant11__default.default(!Number.isNaN(fee) && fee >= 0, "INVALID_FEE");
-  const tickCurrent = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  if (tickCurrent < tickLower || tickCurrent > tickUpper) {
-    return new sdk.Fraction(sdk.ZERO);
-  }
-  const liquidity = FeeCalculator.getLiquidityBySingleAmount({ amount, currency, tickUpper, tickLower, sqrtRatioX96 });
-  return insidePercentage.multiply(parseNumberToFraction(volume24H).multiply(sdk.JSBI.BigInt(fee)).multiply(liquidity)).divide(sdk.JSBI.multiply(MAX_FEE, sdk.JSBI.add(liquidity, mostActiveLiquidity))).asFraction;
-}
-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 sdk.CurrencyAmount.fromRawAmount(
-    currency,
-    getTokenAmount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity)
-  );
-}
-function getLiquidityBySingleAmount({ amount, currency, ...rest }) {
-  return getLiquidityByAmountsAndPrice({
-    amountA: amount,
-    amountB: sdk.CurrencyAmount.fromRawAmount(currency, sdk.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 [
-    sdk.CurrencyAmount.fromRawAmount(currencyA, isToken0 ? adjustedAmount0 : adjustedAmount1),
-    sdk.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__default.default(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: sdk.ZERO, liquidityGross: sdk.ZERO }) : TickList.nextInitializedTick(ticks, tickLower, true);
-  let currentTick = TickList.nextInitializedTick(ticks, tickLower, false);
-  let currentL = lowerOutOfBound ? sdk.ZERO : FeeCalculator.getLiquidityFromTick(ticks, currentTick.index);
-  let weightedL = sdk.ZERO;
-  const getWeightedLFromLastTickTo = (toTick) => sdk.JSBI.multiply(currentL, sdk.JSBI.BigInt(toTick - Math.max(lastTick.index, tickLower)));
-  while (currentTick.index < tickUpper) {
-    weightedL = sdk.JSBI.add(weightedL, getWeightedLFromLastTickTo(currentTick.index));
-    currentL = sdk.JSBI.add(currentL, currentTick.liquidityNet);
-    lastTick = currentTick;
-    if (currentTick.index === ticks[ticks.length - 1].index) {
-      break;
-    }
-    currentTick = TickList.nextInitializedTick(ticks, currentTick.index, false);
-  }
-  weightedL = sdk.JSBI.add(weightedL, getWeightedLFromLastTickTo(tickUpper));
-  return sdk.JSBI.divide(weightedL, sdk.JSBI.BigInt(tickUpper - tickLower));
-}
-function getLiquidityFromSqrtRatioX96(ticks, sqrtRatioX96) {
-  const tick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
-  return FeeCalculator.getLiquidityFromTick(ticks, tick);
-}
-function getLiquidityFromTick(ticks, tick) {
-  var _a;
-  let liquidity = sdk.ZERO;
-  if (!(ticks == null ? void 0 : ticks.length))
-    return liquidity;
-  if (tick < ticks[0].index || tick > ticks[ticks.length - 1].index) {
-    return liquidity;
-  }
-  for (let i = 0; i < ticks.length - 1; ++i) {
-    liquidity = sdk.JSBI.add(liquidity, ticks[i].liquidityNet);
-    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 = sdk.JSBI.exponentiate(sdk.JSBI.BigInt(10), sdk.JSBI.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 sdk.Percent(token0ProtocolFee, FEE_BASE), new sdk.Percent(token1ProtocolFee, FEE_BASE)];
-}
-
-// src/entities/tick.ts
-var Tick = class {
-  constructor({ index, liquidityGross, liquidityNet }) {
-    invariant11__default.default(index >= TickMath.MIN_TICK && index <= TickMath.MAX_TICK, "TICK");
-    this.index = index;
-    this.liquidityGross = JSBI4__default.default.BigInt(liquidityGross);
-    this.liquidityNet = JSBI4__default.default.BigInt(liquidityNet);
-  }
-};
-
-// 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
-    });
-  }
-  /**
-   * 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) {
-    invariant11__default.default(Number.isInteger(fee) && fee < 1e6, "FEE");
-    [this.token0, this.token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
-    this.fee = fee;
-    this.sqrtRatioX96 = JSBI4__default.default.BigInt(sqrtRatioX96);
-    this.liquidity = JSBI4__default.default.BigInt(liquidity);
-    this.tickCurrent = tickCurrent;
-    this.tickDataProvider = Array.isArray(ticks) ? new TickListDataProvider(ticks) : ticks;
-  }
+// src/entities/position.ts
+var Position = class {
   /**
-   * 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
+   * 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
    */
-  involvesToken(token) {
-    return token.equals(this.token0) || token.equals(this.token1);
+  constructor({ pool, liquidity, tickLower, tickUpper }) {
+    // cached resuts for the getters
+    this._token0Amount = null;
+    this._token1Amount = null;
+    this._mintAmounts = null;
+    invariant9__default.default(tickLower < tickUpper, "TICK_ORDER");
+    invariant9__default.default(tickLower >= TickMath.MIN_TICK && tickLower % pool.tickSpacing === 0, "TICK_LOWER");
+    invariant9__default.default(tickUpper <= TickMath.MAX_TICK && tickUpper % pool.tickSpacing === 0, "TICK_UPPER");
+    this.pool = pool;
+    this.tickLower = tickLower;
+    this.tickUpper = tickUpper;
+    this.liquidity = BigInt(liquidity);
   }
   /**
-   * 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 lower tick
    */
-  get token0Price() {
-    var _a;
-    return (_a = this._token0Price) != null ? _a : this._token0Price = new sdk.Price(
-      this.token0,
-      this.token1,
-      Q192,
-      JSBI4__default.default.multiply(this.sqrtRatioX96, this.sqrtRatioX96)
-    );
+  get token0PriceLower() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower);
   }
   /**
-   * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+   * Returns the price of token0 at the upper tick
    */
-  get token1Price() {
-    var _a;
-    return (_a = this._token1Price) != null ? _a : this._token1Price = new sdk.Price(
-      this.token1,
-      this.token0,
-      JSBI4__default.default.multiply(this.sqrtRatioX96, this.sqrtRatioX96),
-      Q192
-    );
+  get token0PriceUpper() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper);
   }
   /**
-   * 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__default.default(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__default.default(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 [
-      sdk.CurrencyAmount.fromRawAmount(outputToken, JSBI4__default.default.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__default.default(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__default.default.multiply(outputAmount.quotient, NEGATIVE_ONE), sqrtPriceLimitX96);
-    invariant11__default.default(JSBI4__default.default.equal(amountSpecifiedRemaining, ZERO), "INSUFICIENT_LIQUIDITY");
-    const inputToken = zeroForOne ? this.token0 : this.token1;
-    return [
-      sdk.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__default.default.add(TickMath.MIN_SQRT_RATIO, ONE) : JSBI4__default.default.subtract(TickMath.MAX_SQRT_RATIO, ONE);
-    if (zeroForOne) {
-      invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPriceLimitX96, TickMath.MIN_SQRT_RATIO), "RATIO_MIN");
-      invariant11__default.default(JSBI4__default.default.lessThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
-    } else {
-      invariant11__default.default(JSBI4__default.default.lessThan(sqrtPriceLimitX96, TickMath.MAX_SQRT_RATIO), "RATIO_MAX");
-      invariant11__default.default(JSBI4__default.default.greaterThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
-    }
-    const exactInput = JSBI4__default.default.greaterThanOrEqual(amountSpecified, ZERO);
-    const state = {
-      amountSpecifiedRemaining: amountSpecified,
-      amountCalculated: ZERO,
-      sqrtPriceX96: this.sqrtRatioX96,
-      tick: this.tickCurrent,
-      liquidity: this.liquidity
-    };
-    while (JSBI4__default.default.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__default.default.lessThan(step.sqrtPriceNextX96, sqrtPriceLimitX96) : JSBI4__default.default.greaterThan(step.sqrtPriceNextX96, sqrtPriceLimitX96)) ? sqrtPriceLimitX96 : step.sqrtPriceNextX96,
-        state.liquidity,
-        state.amountSpecifiedRemaining,
-        this.fee
-      );
-      if (exactInput) {
-        state.amountSpecifiedRemaining = JSBI4__default.default.subtract(
-          state.amountSpecifiedRemaining,
-          JSBI4__default.default.add(step.amountIn, step.feeAmount)
-        );
-        state.amountCalculated = JSBI4__default.default.subtract(state.amountCalculated, step.amountOut);
-      } else {
-        state.amountSpecifiedRemaining = JSBI4__default.default.add(state.amountSpecifiedRemaining, step.amountOut);
-        state.amountCalculated = JSBI4__default.default.add(state.amountCalculated, JSBI4__default.default.add(step.amountIn, step.feeAmount));
-      }
-      if (JSBI4__default.default.equal(state.sqrtPriceX96, step.sqrtPriceNextX96)) {
-        if (step.initialized) {
-          let liquidityNet = JSBI4__default.default.BigInt((await this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
-          if (zeroForOne)
-            liquidityNet = JSBI4__default.default.multiply(liquidityNet, NEGATIVE_ONE);
-          state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
-        }
-        state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
-      } else if (JSBI4__default.default.notEqual(state.sqrtPriceX96, step.sqrtPriceStartX96)) {
-        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__default.default(tickLower < tickUpper, "TICK_ORDER");
-    invariant11__default.default(tickLower >= TickMath.MIN_TICK && tickLower % pool.tickSpacing === 0, "TICK_LOWER");
-    invariant11__default.default(tickUpper <= TickMath.MAX_TICK && tickUpper % pool.tickSpacing === 0, "TICK_UPPER");
-    this.pool = pool;
-    this.tickLower = tickLower;
-    this.tickUpper = tickUpper;
-    this.liquidity = JSBI4__default.default.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) {
@@ -1162,12 +870,12 @@ var Position = class {
     const priceLower = this.pool.token0Price.asFraction.multiply(new sdk.Percent(1).subtract(slippageTolerance));
     const priceUpper = this.pool.token0Price.asFraction.multiply(slippageTolerance.add(1));
     let sqrtRatioX96Lower = encodeSqrtRatioX96(priceLower.numerator, priceLower.denominator);
-    if (JSBI4__default.default.lessThanOrEqual(sqrtRatioX96Lower, TickMath.MIN_SQRT_RATIO)) {
-      sqrtRatioX96Lower = JSBI4__default.default.add(TickMath.MIN_SQRT_RATIO, JSBI4__default.default.BigInt(1));
+    if (sqrtRatioX96Lower <= TickMath.MIN_SQRT_RATIO) {
+      sqrtRatioX96Lower = TickMath.MIN_SQRT_RATIO + 1n;
     }
     let sqrtRatioX96Upper = encodeSqrtRatioX96(priceUpper.numerator, priceUpper.denominator);
-    if (JSBI4__default.default.greaterThanOrEqual(sqrtRatioX96Upper, TickMath.MAX_SQRT_RATIO)) {
-      sqrtRatioX96Upper = JSBI4__default.default.subtract(TickMath.MAX_SQRT_RATIO, JSBI4__default.default.BigInt(1));
+    if (sqrtRatioX96Upper >= TickMath.MAX_SQRT_RATIO) {
+      sqrtRatioX96Upper = TickMath.MAX_SQRT_RATIO - 1n;
     }
     return {
       sqrtRatioX96Lower,
@@ -1384,24 +1092,24 @@ var Route = class {
    */
   constructor(pools, input, output) {
     this._midPrice = null;
-    invariant11__default.default(pools.length > 0, "POOLS");
+    invariant9__default.default(pools.length > 0, "POOLS");
     const { chainId } = pools[0];
     const allOnSameChain = pools.every((pool) => pool.chainId === chainId);
-    invariant11__default.default(allOnSameChain, "CHAIN_IDS");
+    invariant9__default.default(allOnSameChain, "CHAIN_IDS");
     const wrappedInput = input.wrapped;
-    invariant11__default.default(pools[0].involvesToken(wrappedInput), "INPUT");
-    invariant11__default.default(pools[pools.length - 1].involvesToken(output.wrapped), "OUTPUT");
+    invariant9__default.default(pools[0].involvesToken(wrappedInput), "INPUT");
+    invariant9__default.default(pools[pools.length - 1].involvesToken(output.wrapped), "OUTPUT");
     const tokenPath = [wrappedInput];
     for (const [i, pool] of pools.entries()) {
       const currentInputToken = tokenPath[i];
-      invariant11__default.default(currentInputToken.equals(pool.token0) || currentInputToken.equals(pool.token1), "PATH");
+      invariant9__default.default(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;
@@ -1434,8 +1142,8 @@ var Route = class {
   }
 };
 function tradeComparator(a, b) {
-  invariant11__default.default(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
-  invariant11__default.default(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
+  invariant9__default.default(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
+  invariant9__default.default(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);
@@ -1461,7 +1169,7 @@ var Trade = class {
    * i.e. which pools the trade goes through.
    */
   get route() {
-    invariant11__default.default(this.swaps.length == 1, "MULTIPLE_ROUTES");
+    invariant9__default.default(this.swaps.length == 1, "MULTIPLE_ROUTES");
     return this.swaps[0].route;
   }
   /**
@@ -1492,13 +1200,12 @@ var Trade = class {
    * The price expressed in terms of output amount/input amount.
    */
   get executionPrice() {
-    var _a;
-    return (_a = this._executionPrice) != null ? _a : this._executionPrice = new sdk.Price(
+    return this._executionPrice ?? (this._executionPrice = new sdk.Price(
       this.inputAmount.currency,
       this.outputAmount.currency,
       this.inputAmount.quotient,
       this.outputAmount.quotient
-    );
+    ));
   }
   /**
    * Returns the percent difference between the route's mid price and the price impact
@@ -1553,7 +1260,7 @@ var Trade = class {
     let inputAmount;
     let outputAmount;
     if (tradeType === sdk.TradeType.EXACT_INPUT) {
-      invariant11__default.default(amount.currency.equals(route.input), "INPUT");
+      invariant9__default.default(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];
@@ -1567,7 +1274,7 @@ var Trade = class {
         amounts[amounts.length - 1].denominator
       );
     } else {
-      invariant11__default.default(amount.currency.equals(route.output), "OUTPUT");
+      invariant9__default.default(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];
@@ -1599,7 +1306,7 @@ var Trade = class {
       let inputAmount;
       let outputAmount;
       if (tradeType === sdk.TradeType.EXACT_INPUT) {
-        invariant11__default.default(amount.currency.equals(route.input), "INPUT");
+        invariant9__default.default(amount.currency.equals(route.input), "INPUT");
         inputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
         amounts[0] = sdk.CurrencyAmount.fromFractionalAmount(route.input.wrapped, amount.numerator, amount.denominator);
         for (let i = 0; i < route.tokenPath.length - 1; i++) {
@@ -1613,7 +1320,7 @@ var Trade = class {
           amounts[amounts.length - 1].denominator
         );
       } else {
-        invariant11__default.default(amount.currency.equals(route.output), "OUTPUT");
+        invariant9__default.default(amount.currency.equals(route.output), "OUTPUT");
         outputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
         amounts[amounts.length - 1] = sdk.CurrencyAmount.fromFractionalAmount(
           route.output.wrapped,
@@ -1678,11 +1385,11 @@ var Trade = class {
   }) {
     const inputCurrency = routes[0].inputAmount.currency;
     const outputCurrency = routes[0].outputAmount.currency;
-    invariant11__default.default(
+    invariant9__default.default(
       routes.every(({ route }) => inputCurrency.wrapped.equals(route.input.wrapped)),
       "INPUT_CURRENCY_MATCH"
     );
-    invariant11__default.default(
+    invariant9__default.default(
       routes.every(({ route }) => outputCurrency.wrapped.equals(route.output.wrapped)),
       "OUTPUT_CURRENCY_MATCH"
     );
@@ -1693,7 +1400,7 @@ var Trade = class {
         poolAddressSet.add(Pool.getAddress(pool.token0, pool.token1, pool.fee));
       }
     }
-    invariant11__default.default(numPools == poolAddressSet.size, "POOLS_DUPLICATED");
+    invariant9__default.default(numPools == poolAddressSet.size, "POOLS_DUPLICATED");
     this.swaps = routes;
     this.tradeType = tradeType;
   }
@@ -1703,169 +1410,459 @@ var Trade = class {
    * @returns The amount out
    */
   minimumAmountOut(slippageTolerance, amountOut = this.outputAmount) {
-    invariant11__default.default(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    invariant9__default.default(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === sdk.TradeType.EXACT_OUTPUT) {
       return amountOut;
     }
     const slippageAdjustedAmountOut = new sdk.Fraction(ONE).add(slippageTolerance).invert().multiply(amountOut.quotient).quotient;
     return sdk.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__default.default(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
-    if (this.tradeType === sdk.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__default.default(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === sdk.TradeType.EXACT_INPUT) {
+      return amountIn;
+    }
+    const slippageAdjustedAmountIn = new sdk.Fraction(ONE).add(slippageTolerance).multiply(amountIn.quotient).quotient;
+    return sdk.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 sdk.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__default.default(pools.length > 0, "POOLS");
+    invariant9__default.default(maxHops > 0, "MAX_HOPS");
+    invariant9__default.default(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)) {
+        sdk.sortedInsert(
+          bestTrades,
+          await Trade.fromRoute(
+            new Route([...currentPools, pool], currencyAmountIn.currency, currencyOut),
+            currencyAmountIn,
+            sdk.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__default.default(pools.length > 0, "POOLS");
+    invariant9__default.default(maxHops > 0, "MAX_HOPS");
+    invariant9__default.default(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)) {
+        sdk.sortedInsert(
+          bestTrades,
+          await Trade.fromRoute(
+            new Route([pool, ...currentPools], currencyIn, currencyAmountOut.currency),
+            currencyAmountOut,
+            sdk.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 ? viem.encodePacked(types.reverse(), path.reverse()) : viem.encodePacked(types, path);
+}
+function nearestUsableTick(tick, tickSpacing) {
+  invariant9__default.default(Number.isInteger(tick) && Number.isInteger(tickSpacing), "INTEGERS");
+  invariant9__default.default(tickSpacing > 0, "TICK_SPACING");
+  invariant9__default.default(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 swapSdkCore.Fraction(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: swapSdkCore.CurrencyAmount.fromRawAmount(currency, swapSdkCore.MaxUint256)
+  });
+}
+function getEstimatedLPFee({ amount, currency, ...rest }) {
+  return getEstimatedLPFeeByAmounts({
+    ...rest,
+    amountA: amount,
+    amountB: swapSdkCore.CurrencyAmount.fromRawAmount(currency, swapSdkCore.MaxUint256)
+  });
+}
+function getEstimatedLPFeeByAmountsWithProtocolFee(options) {
+  try {
+    return tryGetEstimatedLPFeeByAmounts(options);
+  } catch (e) {
+    console.error(e);
+    return new swapSdkCore.Fraction(swapSdkCore.ZERO);
+  }
+}
+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 swapSdkCore.Fraction(swapSdkCore.ZERO);
+  }
+}
+function tryGetEstimatedLPFeeByAmounts({
+  amountA,
+  amountB,
+  volume24H,
+  sqrtRatioX96,
+  tickLower,
+  tickUpper,
+  mostActiveLiquidity,
+  fee,
+  insidePercentage = ONE_HUNDRED_PERCENT
+}) {
+  invariant9__default.default(!Number.isNaN(fee) && fee >= 0, "INVALID_FEE");
+  const tickCurrent = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
+  if (tickCurrent < tickLower || tickCurrent > tickUpper) {
+    return new swapSdkCore.Fraction(swapSdkCore.ZERO);
+  }
+  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice({
+    amountA,
+    amountB,
+    tickUpper,
+    tickLower,
+    sqrtRatioX96
+  });
+  const volumeInFraction = parseNumberToFraction(volume24H) || new swapSdkCore.Fraction(swapSdkCore.ZERO);
+  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 swapSdkCore.CurrencyAmount.fromRawAmount(
+    currency,
+    getTokenAmount(currentTick, tickLower, tickUpper, sqrtRatioX96, liquidity)
+  );
+}
+function getLiquidityBySingleAmount({ amount, currency, ...rest }) {
+  return getLiquidityByAmountsAndPrice({
+    amountA: amount,
+    amountB: swapSdkCore.CurrencyAmount.fromRawAmount(currency, swapSdkCore.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 [
+    swapSdkCore.CurrencyAmount.fromRawAmount(currencyA, isToken0 ? adjustedAmount0 : adjustedAmount1),
+    swapSdkCore.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) {
+  invariant9__default.default(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: swapSdkCore.ZERO, liquidityGross: swapSdkCore.ZERO }) : TickList.nextInitializedTick(ticks, tickLower, true);
+  let currentTick = TickList.nextInitializedTick(ticks, tickLower, false);
+  let currentL = lowerOutOfBound ? swapSdkCore.ZERO : FeeCalculator.getLiquidityFromTick(ticks, currentTick.index);
+  let weightedL = swapSdkCore.ZERO;
+  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 sdk.Fraction(ONE).add(slippageTolerance).multiply(amountIn.quotient).quotient;
-    return sdk.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 sdk.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 = swapSdkCore.ZERO;
+  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__default.default(pools.length > 0, "POOLS");
-    invariant11__default.default(maxHops > 0, "MAX_HOPS");
-    invariant11__default.default(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)) {
-        sdk.sortedInsert(
-          bestTrades,
-          await Trade.fromRoute(
-            new Route([...currentPools, pool], currencyAmountIn.currency, currencyOut),
-            currencyAmountIn,
-            sdk.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__default.default(pools.length > 0, "POOLS");
-    invariant11__default.default(maxHops > 0, "MAX_HOPS");
-    invariant11__default.default(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)) {
-        sdk.sortedInsert(
-          bestTrades,
-          await Trade.fromRoute(
-            new Route([pool, ...currentPools], currencyIn, currencyAmountOut.currency),
-            currencyAmountOut,
-            sdk.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 swapSdkCore.Percent(token0ProtocolFee, FEE_BASE), new swapSdkCore.Percent(token1ProtocolFee, FEE_BASE)];
+}
+function sqrtRatioX96ToPrice(sqrtRatioX96, currencyA, currencyB) {
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
+  return currencyA.wrapped.sortsBefore(currencyB.wrapped) ? new swapSdkCore.Price(currencyA.wrapped, currencyB.wrapped, Q192, ratioX192) : new swapSdkCore.Price(currencyA.wrapped, currencyB.wrapped, ratioX192, Q192);
+}
 var IMulticall = [
   {
     inputs: [
@@ -1897,14 +1894,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] : viem.encodeFunctionData({ abi: _Multicall.ABI, functionName: "multicall", args: [calldatas] });
   }
 };
 var Multicall = _Multicall;
-Multicall.INTERFACE = new abi.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" },
@@ -2410,8 +2407,8 @@ var NonfungiblePositionManager_default = [
   { stateMutability: "payable", type: "receive" }
 ];
 
-// src/abi/SelfPermit.json
-var SelfPermit_default = [
+// src/abi/SelfPermit.ts
+var selfPermitABI = [
   {
     inputs: [
       {
@@ -2577,28 +2574,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) ? viem.encodeFunctionData({
+      abi: _SelfPermit.ABI,
+      functionName: "selfPermitAllowed",
+      args: [token.address, BigInt(options.nonce), BigInt(options.expiry), options.v, options.r, options.s]
+    }) : viem.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 abi.Interface(SelfPermit_default);
+SelfPermit.ABI = selfPermitABI;
 
-// src/abi/IPeripheryPaymentsWithFee.json
-var IPeripheryPaymentsWithFee_default = [
+// src/abi/PeripheryPaymentsWithFee.ts
+var peripheryPaymentsWithFeeABI = [
   {
     inputs: [],
     name: "refundETH",
@@ -2718,46 +2709,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 = sdk.validateAndParseAddress(recipient);
     if (feeOptions) {
       const feeBips = this.encodeFeeBips(feeOptions.fee);
       const feeRecipient = sdk.validateAndParseAddress(feeOptions.recipient);
-      return _Payments.INTERFACE.encodeFunctionData("unwrapWETH9WithFee", [
-        toHex(amountMinimum),
-        recipient,
-        feeBips,
-        feeRecipient
-      ]);
+      return viem.encodeFunctionData({
+        abi: _Payments.ABI,
+        functionName: "unwrapWETH9WithFee",
+        args: [amountMinimum, recipient, feeBips, feeRecipient]
+      });
     }
-    return _Payments.INTERFACE.encodeFunctionData("unwrapWETH9", [toHex(amountMinimum), recipient]);
+    return viem.encodeFunctionData({ abi: _Payments.ABI, functionName: "unwrapWETH9", args: [amountMinimum, recipient] });
   }
   static encodeSweepToken(token, amountMinimum, recipient, feeOptions) {
     recipient = sdk.validateAndParseAddress(recipient);
     if (feeOptions) {
       const feeBips = this.encodeFeeBips(feeOptions.fee);
       const feeRecipient = sdk.validateAndParseAddress(feeOptions.recipient);
-      return _Payments.INTERFACE.encodeFunctionData("sweepTokenWithFee", [
-        token.address,
-        toHex(amountMinimum),
-        recipient,
-        feeBips,
-        feeRecipient
-      ]);
+      return viem.encodeFunctionData({
+        abi: _Payments.ABI,
+        functionName: "sweepTokenWithFee",
+        args: [token.address, amountMinimum, recipient, feeBips, feeRecipient]
+      });
     }
-    return _Payments.INTERFACE.encodeFunctionData("sweepToken", [token.address, toHex(amountMinimum), recipient]);
+    return viem.encodeFunctionData({
+      abi: _Payments.ABI,
+      functionName: "sweepToken",
+      args: [token.address, amountMinimum, recipient]
+    });
   }
   static encodeRefundETH() {
-    return _Payments.INTERFACE.encodeFunctionData("refundETH");
+    return viem.encodeFunctionData({ abi: _Payments.ABI, functionName: "refundETH" });
   }
 };
 var Payments = _Payments;
-Payments.INTERFACE = new abi.Interface(IPeripheryPaymentsWithFee_default);
+Payments.ABI = peripheryPaymentsWithFeeABI;
 
 // src/nonfungiblePositionManager.ts
-var MaxUint128 = toHex(JSBI4__default.default.subtract(JSBI4__default.default.exponentiate(JSBI4__default.default.BigInt(2), JSBI4__default.default.BigInt(128)), JSBI4__default.default.BigInt(1)));
+var MaxUint128 = 2n ** 128n - 1n;
 function isMint(options) {
   return Object.keys(options).some((k) => k === "recipient");
 }
@@ -2769,12 +2761,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 viem.encodeFunctionData({
+      abi: _NonfungiblePositionManager.ABI,
+      functionName: "createAndInitializePoolIfNecessary",
+      args: [pool.token0.address, pool.token1.address, pool.fee, pool.sqrtRatioX96]
+    });
   }
   static createCallParameters(pool) {
     return {
@@ -2783,13 +2774,13 @@ var _NonfungiblePositionManager = class {
     };
   }
   static addCallParameters(position, options) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(position.liquidity, ZERO), "ZERO_LIQUIDITY");
+    invariant9__default.default(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));
     }
@@ -2802,42 +2793,50 @@ var _NonfungiblePositionManager = class {
     if (isMint(options)) {
       const recipient = sdk.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
-          }
-        ])
+        viem.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
-          }
-        ])
+        viem.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__default.default(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
+      invariant9__default.default(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
       const wrappedValue = position.pool.token0.equals(wrapped) ? amount0Desired : amount1Desired;
-      if (JSBI4__default.default.greaterThan(wrappedValue, ZERO)) {
+      if (wrappedValue > ZERO) {
         calldatas.push(Payments.encodeRefundETH());
       }
       value = toHex(wrappedValue);
@@ -2849,18 +2848,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 = sdk.validateAndParseAddress(options.recipient);
     calldatas.push(
-      _NonfungiblePositionManager.INTERFACE.encodeFunctionData("collect", [
-        {
-          tokenId,
-          recipient: involvesETH ? ADDRESS_ZERO : recipient,
-          amount0Max: MaxUint128,
-          amount1Max: MaxUint128
-        }
-      ])
+      viem.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;
@@ -2886,40 +2889,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__default.default(JSBI4__default.default.greaterThan(partialPosition.liquidity, ZERO), "ZERO_LIQUIDITY");
+    invariant9__default.default(partialPosition.liquidity > ZERO, "ZERO_LIQUIDITY");
     const { amount0: amount0Min, amount1: amount1Min } = partialPosition.burnAmountsWithSlippage(
       options.slippageTolerance
     );
     if (options.permit) {
       calldatas.push(
-        _NonfungiblePositionManager.INTERFACE.encodeFunctionData("permit", [
-          sdk.validateAndParseAddress(options.permit.spender),
-          tokenId,
-          toHex(options.permit.deadline),
-          options.permit.v,
-          options.permit.r,
-          options.permit.s
-        ])
+        viem.encodeFunctionData({
+          abi: _NonfungiblePositionManager.ABI,
+          functionName: "permit",
+          args: [
+            sdk.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
-        }
-      ])
+      viem.encodeFunctionData({
+        abi: _NonfungiblePositionManager.ABI,
+        functionName: "decreaseLiquidity",
+        args: [
+          {
+            tokenId,
+            liquidity: partialPosition.liquidity,
+            amount0Min,
+            amount1Min,
+            deadline
+          }
+        ]
+      })
     );
     const { expectedCurrencyOwed0, expectedCurrencyOwed1, ...rest } = options.collectOptions;
     calldatas.push(
@@ -2937,10 +2948,12 @@ var _NonfungiblePositionManager = class {
     );
     if (options.liquidityPercentage.equalTo(ONE)) {
       if (options.burnToken) {
-        calldatas.push(_NonfungiblePositionManager.INTERFACE.encodeFunctionData("burn", [tokenId]));
+        calldatas.push(
+          viem.encodeFunctionData({ abi: _NonfungiblePositionManager.ABI, functionName: "burn", args: [tokenId] })
+        );
       }
     } else {
-      invariant11__default.default(options.burnToken !== true, "CANNOT_BURN");
+      invariant9__default.default(options.burnToken !== true, "CANNOT_BURN");
     }
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -2952,16 +2965,17 @@ var _NonfungiblePositionManager = class {
     const sender = sdk.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 = viem.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 = viem.encodeFunctionData({
+        abi: _NonfungiblePositionManager.ABI,
+        functionName: "safeTransferFrom",
+        args: [sender, recipient, BigInt(options.tokenId)]
+      });
     }
     return {
       calldata,
@@ -2970,10 +2984,10 @@ var _NonfungiblePositionManager = class {
   }
 };
 var NonfungiblePositionManager = _NonfungiblePositionManager;
-NonfungiblePositionManager.INTERFACE = new abi.Interface(NonfungiblePositionManager_default);
+NonfungiblePositionManager.ABI = nonfungiblePositionManagerABI;
 
-// src/abi/Quoter.json
-var Quoter_default = [
+// src/abi/Quoter.ts
+var quoterABI = [
   {
     inputs: [
       {
@@ -3185,8 +3199,8 @@ var Quoter_default = [
   }
 ];
 
-// src/abi/QuoterV2.json
-var QuoterV2_default = [
+// src/abi/QuoterV2.ts
+var quoterV2ABI = [
   {
     inputs: [
       {
@@ -3486,21 +3500,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 == sdk.TradeType.EXACT_INPUT ? { amountIn: quoteAmount } : { amount: quoteAmount }
+        ...tradeType === swapSdkCore.TradeType.EXACT_INPUT ? { amountIn: quoteAmount } : { amount: quoteAmount }
       };
       const v1QuoteParams = [
         baseQuoteParams.tokenIn,
@@ -3509,16 +3522,31 @@ var SwapQuoter = class {
         quoteAmount,
         baseQuoteParams.sqrtPriceLimitX96
       ];
-      const tradeTypeFunctionName = tradeType === sdk.TradeType.EXACT_INPUT ? "quoteExactInputSingle" : "quoteExactOutputSingle";
-      calldata = swapInterface.encodeFunctionData(
-        tradeTypeFunctionName,
-        options.useQuoterV2 ? [v2QuoteParams] : v1QuoteParams
-      );
+      const tradeTypeFunctionName = tradeType === swapSdkCore.TradeType.EXACT_INPUT ? "quoteExactInputSingle" : "quoteExactOutputSingle";
+      if (options.useQuoterV2) {
+        calldata = viem.encodeFunctionData({
+          abi: this.V2ABI,
+          functionName: tradeTypeFunctionName,
+          // @ts-ignore // FIXME
+          args: [v2QuoteParams]
+        });
+      } else {
+        calldata = viem.encodeFunctionData({
+          abi: this.V1ABI,
+          functionName: tradeTypeFunctionName,
+          args: v1QuoteParams
+        });
+      }
     } else {
-      invariant11__default.default((options == null ? void 0 : options.sqrtPriceLimitX96) === void 0, "MULTIHOP_PRICE_LIMIT");
-      const path = encodeRouteToPath(route, tradeType === sdk.TradeType.EXACT_OUTPUT);
-      const tradeTypeFunctionName = tradeType === sdk.TradeType.EXACT_INPUT ? "quoteExactInput" : "quoteExactOutput";
-      calldata = swapInterface.encodeFunctionData(tradeTypeFunctionName, [path, quoteAmount]);
+      invariant9__default.default(options?.sqrtPriceLimitX96 === void 0, "MULTIHOP_PRICE_LIMIT");
+      const path = encodeRouteToPath(route, tradeType === swapSdkCore.TradeType.EXACT_OUTPUT);
+      const tradeTypeFunctionName = tradeType === swapSdkCore.TradeType.EXACT_INPUT ? "quoteExactInput" : "quoteExactOutput";
+      calldata = viem.encodeFunctionData({
+        // @ts-ignore
+        abi: swapAbi,
+        functionName: tradeTypeFunctionName,
+        args: [path, quoteAmount]
+      });
     }
     return {
       calldata,
@@ -3526,11 +3554,11 @@ var SwapQuoter = class {
     };
   }
 };
-SwapQuoter.V1INTERFACE = new abi.Interface(Quoter_default);
-SwapQuoter.V2INTERFACE = new abi.Interface(QuoterV2_default);
+SwapQuoter.V1ABI = quoterABI;
+SwapQuoter.V2ABI = quoterV2ABI;
 
-// src/abi/V3Staker.json
-var V3Staker_default = [
+// src/abi/V3Staker.ts
+var v3StakerABI = [
   {
     inputs: [
       {
@@ -4248,18 +4276,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)
-      ])
+      viem.encodeFunctionData({
+        abi: _Staker.ABI,
+        functionName: "unstakeToken",
+        args: [this._encodeIncentiveKey(incentiveKey), BigInt(options.tokenId)]
+      })
     );
     const recipient = sdk.validateAndParseAddress(options.recipient);
-    const amount = (_a = options.amount) != null ? _a : 0;
+    const amount = options.amount ?? 0;
     calldatas.push(
-      _Staker.INTERFACE.encodeFunctionData("claimReward", [incentiveKey.rewardToken.address, recipient, toHex(amount)])
+      viem.encodeFunctionData({
+        abi: _Staker.ABI,
+        functionName: "claimReward",
+        args: [incentiveKey.rewardToken.address, recipient, BigInt(amount)]
+      })
     );
     return calldatas;
   }
@@ -4279,10 +4311,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)
-        ])
+        viem.encodeFunctionData({
+          abi: _Staker.ABI,
+          functionName: "stakeToken",
+          args: [this._encodeIncentiveKey(incentiveKey), BigInt(options.tokenId)]
+        })
       );
     }
     return {
@@ -4310,11 +4343,11 @@ var _Staker = class {
     }
     const owner = sdk.validateAndParseAddress(withdrawOptions.owner);
     calldatas.push(
-      _Staker.INTERFACE.encodeFunctionData("withdrawToken", [
-        toHex(withdrawOptions.tokenId),
-        owner,
-        withdrawOptions.data ? withdrawOptions.data : toHex(0)
-      ])
+      viem.encodeFunctionData({
+        abi: _Staker.ABI,
+        functionName: "withdrawToken",
+        args: [BigInt(withdrawOptions.tokenId), owner, toHex(0)]
+      })
     );
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -4335,16 +4368,18 @@ var _Staker = class {
         const incentiveKey = incentiveKeys[i];
         keys.push(this._encodeIncentiveKey(incentiveKey));
       }
-      data = abi.defaultAbiCoder.encode([`${_Staker.INCENTIVE_KEY_ABI}[]`], [keys]);
+      data = viem.encodeAbiParameters(viem.parseAbiParameters([`${_Staker.INCENTIVE_KEY_ABI}[]`]), [keys]);
     } else {
-      data = abi.defaultAbiCoder.encode([_Staker.INCENTIVE_KEY_ABI], [this._encodeIncentiveKey(incentiveKeys[0])]);
+      data = viem.encodeAbiParameters(viem.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;
@@ -4352,18 +4387,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 abi.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: [
       {
@@ -4960,18 +4995,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__default.default(
+    invariant9__default.default(
       trades.every((trade) => trade.inputAmount.currency.wrapped.equals(tokenIn)),
       "TOKEN_IN_DIFF"
     );
-    invariant11__default.default(
+    invariant9__default.default(
       trades.every((trade) => trade.outputAmount.currency.wrapped.equals(tokenOut)),
       "TOKEN_OUT_DIFF"
     );
@@ -4988,15 +5022,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__default.default(sampleTrade.inputAmount.currency.isToken, "NON_TOKEN_PERMIT");
+      invariant9__default.default(sampleTrade.inputAmount.currency.isToken, "NON_TOKEN_PERMIT");
       calldatas.push(SelfPermit.encodePermit(sampleTrade.inputAmount.currency, options.inputTokenPermit));
     }
     const recipient = sdk.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 === sdk.TradeType.EXACT_INPUT) {
@@ -5008,9 +5042,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(
+              viem.encodeFunctionData({
+                abi: _SwapRouter.ABI,
+                functionName: "exactInputSingle",
+                args: [exactInputSingleParams]
+              })
+            );
           } else {
             const exactOutputSingleParams = {
               tokenIn: route.tokenPath[0].address,
@@ -5020,12 +5060,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(
+              viem.encodeFunctionData({
+                abi: _SwapRouter.ABI,
+                functionName: "exactOutputSingle",
+                args: [exactOutputSingleParams]
+              })
+            );
           }
         } else {
-          invariant11__default.default(options.sqrtPriceLimitX96 === void 0, "MULTIHOP_PRICE_LIMIT");
+          invariant9__default.default(options.sqrtPriceLimitX96 === void 0, "MULTIHOP_PRICE_LIMIT");
           const path = encodeRouteToPath(route, trade.tradeType === sdk.TradeType.EXACT_OUTPUT);
           if (trade.tradeType === sdk.TradeType.EXACT_INPUT) {
             const exactInputParams = {
@@ -5035,7 +5081,9 @@ var _SwapRouter = class {
               amountIn,
               amountOutMinimum: amountOut
             };
-            calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactInput", [exactInputParams]));
+            calldatas.push(
+              viem.encodeFunctionData({ abi: _SwapRouter.ABI, functionName: "exactInput", args: [exactInputParams] })
+            );
           } else {
             const exactOutputParams = {
               path,
@@ -5044,7 +5092,9 @@ var _SwapRouter = class {
               amountOut,
               amountInMaximum: amountIn
             };
-            calldatas.push(_SwapRouter.INTERFACE.encodeFunctionData("exactOutput", [exactOutputParams]));
+            calldatas.push(
+              viem.encodeFunctionData({ abi: _SwapRouter.ABI, functionName: "exactOutput", args: [exactOutputParams] })
+            );
           }
         }
       }
@@ -5077,10 +5127,11 @@ var _SwapRouter = class {
   }
 };
 var SwapRouter = _SwapRouter;
-SwapRouter.INTERFACE = new abi.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" },
@@ -5768,14 +5819,14 @@ var _MasterChefV3 = class {
   // Copy from NonfungiblePositionManager
   // Only support increaseLiquidity
   static addCallParameters(position, options) {
-    invariant11__default.default(JSBI4__default.default.greaterThan(position.liquidity, sdk.ZERO), "ZERO_LIQUIDITY");
+    invariant9__default.default(position.liquidity > sdk.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);
-    invariant11__default.default(!isMint(options), "NO_MINT_SUPPORT");
+    const amount0Min = BigInt(minimumAmounts.amount0);
+    const amount1Min = BigInt(minimumAmounts.amount1);
+    const deadline = BigInt(options.deadline);
+    invariant9__default.default(!isMint(options), "NO_MINT_SUPPORT");
     if (options.token0Permit) {
       calldatas.push(SelfPermit.encodePermit(position.pool.token0, options.token0Permit));
     }
@@ -5783,21 +5834,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
-        }
-      ])
+      viem.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__default.default(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
+      invariant9__default.default(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
       const wrappedValue = position.pool.token0.equals(wrapped) ? amount0Desired : amount1Desired;
       value = toHex(wrappedValue);
     }
@@ -5809,18 +5864,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 = sdk.validateAndParseAddress(options.recipient);
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("collect", [
-        {
-          tokenId,
-          recipient: involvesETH ? ADDRESS_ZERO : recipient,
-          amount0Max: MaxUint128,
-          amount1Max: MaxUint128
-        }
-      ])
+      viem.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;
@@ -5840,40 +5899,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__default.default(JSBI4__default.default.greaterThan(partialPosition.liquidity, sdk.ZERO), "ZERO_LIQUIDITY");
+    invariant9__default.default(partialPosition.liquidity > sdk.ZERO, "ZERO_LIQUIDITY");
     const { amount0: amount0Min, amount1: amount1Min } = partialPosition.burnAmountsWithSlippage(
       options.slippageTolerance
     );
     if (options.permit) {
-      calldatas.push(
-        _MasterChefV3.INTERFACE.encodeFunctionData("permit", [
-          sdk.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
-        }
-      ])
+      viem.encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "decreaseLiquidity",
+        args: [
+          {
+            tokenId,
+            liquidity: partialPosition.liquidity,
+            amount0Min,
+            amount1Min,
+            deadline
+          }
+        ]
+      })
     );
     const { expectedCurrencyOwed0, expectedCurrencyOwed1, ...rest } = options.collectOptions;
     calldatas.push(
@@ -5889,29 +5943,31 @@ var _MasterChefV3 = class {
         ...rest
       })
     );
-    if (rest == null ? void 0 : rest.recipient) {
+    if (rest?.recipient) {
       if (options.liquidityPercentage.equalTo(sdk.ONE)) {
         calldatas.push(
-          _MasterChefV3.INTERFACE.encodeFunctionData("withdraw", [
-            tokenId.toString(),
-            sdk.validateAndParseAddress(rest == null ? void 0 : rest.recipient)
-          ])
+          viem.encodeFunctionData({
+            abi: _MasterChefV3.ABI,
+            functionName: "withdraw",
+            args: [tokenId, sdk.validateAndParseAddress(rest?.recipient)]
+          })
         );
       } else {
         calldatas.push(
-          _MasterChefV3.INTERFACE.encodeFunctionData("harvest", [
-            tokenId.toString(),
-            sdk.validateAndParseAddress(rest == null ? void 0 : rest.recipient)
-          ])
+          viem.encodeFunctionData({
+            abi: _MasterChefV3.ABI,
+            functionName: "harvest",
+            args: [tokenId, sdk.validateAndParseAddress(rest?.recipient)]
+          })
         );
       }
     }
     if (options.liquidityPercentage.equalTo(sdk.ONE)) {
       if (options.burnToken) {
-        calldatas.push(_MasterChefV3.INTERFACE.encodeFunctionData("burn", [tokenId]));
+        calldatas.push(viem.encodeFunctionData({ abi: _MasterChefV3.ABI, functionName: "burn", args: [tokenId] }));
       }
     } else {
-      invariant11__default.default(options.burnToken !== true, "CANNOT_BURN");
+      invariant9__default.default(options.burnToken !== true, "CANNOT_BURN");
     }
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -5937,7 +5993,11 @@ var _MasterChefV3 = class {
     const { tokenId, to } = options;
     const calldatas = [];
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("harvest", [tokenId.toString(), sdk.validateAndParseAddress(to)])
+      viem.encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "harvest",
+        args: [BigInt(tokenId), sdk.validateAndParseAddress(to)]
+      })
     );
     return calldatas;
   }
@@ -5945,7 +6005,11 @@ var _MasterChefV3 = class {
     const { tokenId, to } = options;
     const calldatas = [];
     calldatas.push(
-      _MasterChefV3.INTERFACE.encodeFunctionData("withdraw", [tokenId.toString(), sdk.validateAndParseAddress(to)])
+      viem.encodeFunctionData({
+        abi: _MasterChefV3.ABI,
+        functionName: "withdraw",
+        args: [BigInt(tokenId), sdk.validateAndParseAddress(to)]
+      })
     );
     return {
       calldata: Multicall.encodeMulticall(calldatas),
@@ -5954,7 +6018,7 @@ var _MasterChefV3 = class {
   }
 };
 var MasterChefV3 = _MasterChefV3;
-MasterChefV3.INTERFACE = new abi.Interface(MasterChefV3_default);
+MasterChefV3.ABI = masterChefV3ABI;
 
 exports.ADDRESS_ZERO = ADDRESS_ZERO;
 exports.DEPLOYER_ADDRESS = DEPLOYER_ADDRESS;
@@ -5997,6 +6061,8 @@ exports.getAmountsByLiquidityAndPrice = getAmountsByLiquidityAndPrice;
 exports.getAverageLiquidity = getAverageLiquidity;
 exports.getDependentAmount = getDependentAmount;
 exports.getEstimatedLPFee = getEstimatedLPFee;
+exports.getEstimatedLPFeeByAmounts = getEstimatedLPFeeByAmounts;
+exports.getEstimatedLPFeeByAmountsWithProtocolFee = getEstimatedLPFeeByAmountsWithProtocolFee;
 exports.getEstimatedLPFeeWithProtocolFee = getEstimatedLPFeeWithProtocolFee;
 exports.getLiquidityByAmountsAndPrice = getLiquidityByAmountsAndPrice;
 exports.getLiquidityBySingleAmount = getLiquidityBySingleAmount;
@@ -6004,12 +6070,21 @@ exports.getLiquidityFromSqrtRatioX96 = getLiquidityFromSqrtRatioX96;
 exports.getLiquidityFromTick = getLiquidityFromTick;
 exports.isMint = isMint;
 exports.isSorted = isSorted;
+exports.masterChefV3ABI = masterChefV3ABI;
 exports.maxLiquidityForAmounts = maxLiquidityForAmounts;
 exports.mostSignificantBit = mostSignificantBit;
 exports.nearestUsableTick = nearestUsableTick;
+exports.nonfungiblePositionManagerABI = nonfungiblePositionManagerABI;
 exports.parseProtocolFees = parseProtocolFees;
+exports.peripheryPaymentsWithFeeABI = peripheryPaymentsWithFeeABI;
 exports.priceToClosestTick = priceToClosestTick;
+exports.quoterABI = quoterABI;
+exports.quoterV2ABI = quoterV2ABI;
+exports.selfPermitABI = selfPermitABI;
+exports.sqrtRatioX96ToPrice = sqrtRatioX96ToPrice;
 exports.subIn256 = subIn256;
+exports.swapRouterABI = swapRouterABI;
 exports.tickToPrice = tickToPrice;
 exports.toHex = toHex;
 exports.tradeComparator = tradeComparator;
+exports.v3StakerABI = v3StakerABI;