@pancakeswap/v3-sdk 2.0.0 → 3.0.0

package/dist/index.js

@@ -1,15 +1,13 @@
 'use strict';
 
 var sdk = require('@pancakeswap/sdk');
-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 invariant11__default = /*#__PURE__*/_interopDefault(invariant11);
+var invariant9__default = /*#__PURE__*/_interopDefault(invariant9);
 
 // src/entities/pool.ts
 var FACTORY_ADDRESS = "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865";
@@ -44,6 +42,13 @@ var MAX_FEE = 10n ** 6n;
 var ONE_HUNDRED_PERCENT = new swapSdkCore.Percent("1");
 var ZERO_PERCENT = new swapSdkCore.Percent("0");
 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,
@@ -52,11 +57,10 @@ 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 ?? POOL_INIT_CODE_HASH
   );
@@ -95,11 +99,11 @@ var FullMath = class {
 var MaxUint160 = 2n ** 160n - ONE;
 function multiplyIn256(x, y) {
   const product = x * y;
-  return product & sdk.MaxUint256;
+  return product & swapSdkCore.MaxUint256;
 }
 function addIn256(x, y) {
   const sum = x + y;
-  return sum & sdk.MaxUint256;
+  return sum & swapSdkCore.MaxUint256;
 }
 var SqrtPriceMath = class {
   /**
@@ -124,13 +128,13 @@ var SqrtPriceMath = class {
     return roundUp ? FullMath.mulDivRoundingUp(liquidity, sqrtRatioBX96 - sqrtRatioAX96, Q96) : liquidity * (sqrtRatioBX96 - sqrtRatioAX96) / Q96;
   }
   static getNextSqrtPriceFromInput(sqrtPX96, liquidity, amountIn, zeroForOne) {
-    invariant11__default.default(sqrtPX96 > ZERO);
-    invariant11__default.default(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(sqrtPX96 > ZERO);
-    invariant11__default.default(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) {
@@ -148,8 +152,8 @@ var SqrtPriceMath = class {
       return FullMath.mulDivRoundingUp(numerator1, ONE, numerator1 / sqrtPX96 + amount);
     }
     const product = multiplyIn256(amount, sqrtPX96);
-    invariant11__default.default(product / amount === sqrtPX96);
-    invariant11__default.default(numerator1 > product);
+    invariant9__default.default(product / amount === sqrtPX96);
+    invariant9__default.default(numerator1 > product);
     const denominator = numerator1 - product;
     return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator);
   }
@@ -159,7 +163,7 @@ var SqrtPriceMath = class {
       return sqrtPX96 + quotient2;
     }
     const quotient = FullMath.mulDivRoundingUp(amount, Q96, liquidity);
-    invariant11__default.default(sqrtPX96 > quotient);
+    invariant9__default.default(sqrtPX96 > quotient);
     return sqrtPX96 - quotient;
   }
 };
@@ -227,8 +231,8 @@ var SwapMath = class {
 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(x > ZERO, "ZERO");
-  invariant11__default.default(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 (x >= min) {
@@ -255,7 +259,7 @@ 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 ? BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : BigInt("0x100000000000000000000000000000000");
     if ((absTick & 2) != 0)
@@ -297,7 +301,7 @@ var _TickMath = class {
     if ((absTick & 524288) != 0)
       ratio = mulShift(ratio, "0x48a170391f7dc42444e8fa2");
     if (tick > 0)
-      ratio = sdk.MaxUint256 / ratio;
+      ratio = swapSdkCore.MaxUint256 / ratio;
     return ratio % Q32 > ZERO ? ratio / Q32 + ONE : ratio / Q32;
   }
   /**
@@ -306,7 +310,7 @@ var _TickMath = class {
    * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
    */
   static getTickAtSqrtRatio(sqrtRatioX96) {
-    invariant11__default.default(sqrtRatioX96 >= _TickMath.MIN_SQRT_RATIO && sqrtRatioX96 < _TickMath.MAX_SQRT_RATIO, "SQRT_RATIO");
+    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;
@@ -380,25 +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(ticks.reduce((accumulator, { liquidityNet }) => 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;
   }
   /**
@@ -408,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;
@@ -426,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];
     }
@@ -470,44 +474,219 @@ var TickList = class {
     return Math.abs(beforeIndex - afterIndex);
   }
 };
+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);
+  }
+};
 
-// src/utils/calldata.ts
-function toHex(bigintIsh) {
-  const bigInt = BigInt(bigintIsh);
-  let hex = bigInt.toString(16);
-  if (hex.length % 2 !== 0) {
-    hex = `0${hex}`;
+// src/entities/tickListDataProvider.ts
+var TickListDataProvider = class {
+  constructor(ticks) {
+    const ticksMapped = ticks.map((t) => t instanceof Tick ? t : new Tick(t));
+    this.ticks = ticksMapped;
   }
-  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]
-        };
+  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 = BigInt(amount1) << 192n;
-  const denominator = BigInt(amount0);
-  const ratioX192 = 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) {
@@ -550,36 +729,18 @@ function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX9
   }
   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);
 }
 
-// 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/priceTickConversions.ts
 function tickToPrice(baseToken, quoteToken, tick) {
   const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
   const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
-  return baseToken.sortsBefore(quoteToken) ? new sdk.Price(baseToken, quoteToken, Q192, ratioX192) : new sdk.Price(baseToken, quoteToken, ratioX192, Q192);
+  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);
@@ -596,47 +757,6 @@ function priceToClosestTick(price) {
   return tick;
 }
 
-// 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)
-    ];
-  }
-};
-
 // src/utils/positionMath.ts
 function getToken0Amount(tickCurrent, tickLower, tickUpper, sqrtRatioX96, liquidity) {
   if (tickCurrent < tickLower) {
@@ -670,903 +790,503 @@ var PositionMath = {
   getToken0Amount,
   getToken1Amount
 };
-function parseNumberToFraction(num, precision = 6) {
-  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: sdk.CurrencyAmount.fromRawAmount(currency, sdk.MaxUint256)
-  });
-}
-function getEstimatedLPFee({ amount, currency, ...rest }) {
-  return getEstimatedLPFeeByAmounts({
-    ...rest,
-    amountA: amount,
-    amountB: sdk.CurrencyAmount.fromRawAmount(currency, sdk.MaxUint256)
-  });
-}
-function getEstimatedLPFeeByAmountsWithProtocolFee(options) {
-  try {
-    return tryGetEstimatedLPFeeByAmounts(options);
-  } catch (e) {
-    console.error(e);
-    return new sdk.Fraction(sdk.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 sdk.Fraction(sdk.ZERO);
+// src/entities/position.ts
+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;
+    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);
   }
-}
-function tryGetEstimatedLPFeeByAmounts({
-  amountA,
-  amountB,
-  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);
+  /**
+   * Returns the price of token0 at the lower tick
+   */
+  get token0PriceLower() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower);
   }
-  const liquidity = FeeCalculator.getLiquidityByAmountsAndPrice({
-    amountA,
-    amountB,
-    tickUpper,
-    tickLower,
-    sqrtRatioX96
-  });
-  return insidePercentage.multiply(parseNumberToFraction(volume24H).multiply(BigInt(fee)).multiply(liquidity)).divide(MAX_FEE * (liquidity + mostActiveLiquidity)).asFraction;
-}
-function getDependentAmount(options) {
-  const { currency, amount, sqrtRatioX96, tickLower, tickUpper } = options;
-  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);
+  /**
+   * Returns the price of token0 at the upper tick
+   */
+  get token0PriceUpper() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper);
   }
-  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) => 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;
+  /**
+   * 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) {
+      this._token0Amount = sdk.CurrencyAmount.fromRawAmount(
+        this.pool.token0,
+        PositionMath.getToken0Amount(
+          this.pool.tickCurrent,
+          this.tickLower,
+          this.tickUpper,
+          this.pool.sqrtRatioX96,
+          this.liquidity
+        )
+      );
     }
-    currentTick = TickList.nextInitializedTick(ticks, currentTick.index, false);
-  }
-  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 = sdk.ZERO;
-  if (!ticks?.length)
-    return liquidity;
-  if (tick < ticks[0].index || tick > ticks[ticks.length - 1].index) {
-    return liquidity;
+    return this._token0Amount;
   }
-  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;
+  /**
+   * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+   */
+  get amount1() {
+    if (this._token1Amount === null) {
+      this._token1Amount = sdk.CurrencyAmount.fromRawAmount(
+        this.pool.token1,
+        PositionMath.getToken1Amount(
+          this.pool.tickCurrent,
+          this.tickLower,
+          this.tickUpper,
+          this.pool.sqrtRatioX96,
+          this.liquidity
+        )
+      );
     }
-  }
-  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 sdk.Percent(token0ProtocolFee, FEE_BASE), new sdk.Percent(token1ProtocolFee, FEE_BASE)];
-}
-function sqrtRatioX96ToPrice(sqrtRatioX96, currencyA, currencyB) {
-  const ratioX192 = sqrtRatioX96 * sqrtRatioX96;
-  return currencyA.wrapped.sortsBefore(currencyB.wrapped) ? new swapSdkCore.Price(currencyA.wrapped, currencyB.wrapped, Q192, ratioX192) : new swapSdkCore.Price(currencyA.wrapped, currencyB.wrapped, ratioX192, Q192);
-}
-
-// src/entities/tick.ts
-var Tick = class {
-  constructor({ index, liquidityGross, liquidityNet }) {
-    invariant11__default.default(index >= TickMath.MIN_TICK && index <= TickMath.MAX_TICK, "TICK");
-    this.index = index;
-    this.liquidityGross = BigInt(liquidityGross);
-    this.liquidityNet = 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 ?? DEPLOYER_ADDRESSES[tokenA.chainId],
-      fee,
-      tokenA,
-      tokenB,
-      initCodeHashManualOverride
-    });
+    return this._token1Amount;
   }
   /**
-   * 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
+   * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+   * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+   * @returns The sqrt ratios after slippage
    */
-  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 = BigInt(sqrtRatioX96);
-    this.liquidity = BigInt(liquidity);
-    this.tickCurrent = tickCurrent;
-    this.tickDataProvider = Array.isArray(ticks) ? new TickListDataProvider(ticks) : ticks;
+  ratiosAfterSlippage(slippageTolerance) {
+    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 (sqrtRatioX96Lower <= TickMath.MIN_SQRT_RATIO) {
+      sqrtRatioX96Lower = TickMath.MIN_SQRT_RATIO + 1n;
+    }
+    let sqrtRatioX96Upper = encodeSqrtRatioX96(priceUpper.numerator, priceUpper.denominator);
+    if (sqrtRatioX96Upper >= TickMath.MAX_SQRT_RATIO) {
+      sqrtRatioX96Upper = TickMath.MAX_SQRT_RATIO - 1n;
+    }
+    return {
+      sqrtRatioX96Lower,
+      sqrtRatioX96Upper
+    };
   }
   /**
-   * Returns true if the token is either token0 or token1
-   * @param token The token to check
-   * @returns True if token is either token0 or token
+   * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
+   * with the given slippage tolerance
+   * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+   * @returns The amounts, with slippage
    */
-  involvesToken(token) {
-    return token.equals(this.token0) || token.equals(this.token1);
+  mintAmountsWithSlippage(slippageTolerance) {
+    const { sqrtRatioX96Upper, sqrtRatioX96Lower } = this.ratiosAfterSlippage(slippageTolerance);
+    const poolLower = new Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Lower,
+      0,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower)
+    );
+    const poolUpper = new Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Upper,
+      0,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper)
+    );
+    const positionThatWillBeCreated = Position.fromAmounts({
+      pool: this.pool,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper,
+      ...this.mintAmounts,
+      // the mint amounts are what will be passed as calldata
+      useFullPrecision: false
+    });
+    const { amount0 } = new Position({
+      pool: poolUpper,
+      liquidity: positionThatWillBeCreated.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    }).mintAmounts;
+    const { amount1 } = new Position({
+      pool: poolLower,
+      liquidity: positionThatWillBeCreated.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    }).mintAmounts;
+    return { amount0, amount1 };
   }
   /**
-   * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+   * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+   * position with the given slippage tolerance
+   * @param slippageTolerance tolerance of unfavorable slippage from the current price
+   * @returns The amounts, with slippage
    */
-  get token0Price() {
-    return this._token0Price ?? (this._token0Price = new sdk.Price(this.token0, this.token1, Q192, this.sqrtRatioX96 * this.sqrtRatioX96));
+  burnAmountsWithSlippage(slippageTolerance) {
+    const { sqrtRatioX96Upper, sqrtRatioX96Lower } = this.ratiosAfterSlippage(slippageTolerance);
+    const poolLower = new Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Lower,
+      0,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower)
+    );
+    const poolUpper = new Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Upper,
+      0,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper)
+    );
+    const { amount0 } = new Position({
+      pool: poolUpper,
+      liquidity: this.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    });
+    const { amount1 } = new Position({
+      pool: poolLower,
+      liquidity: this.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    });
+    return { amount0: amount0.quotient, amount1: amount1.quotient };
   }
   /**
-   * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+   * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+   * the current price for the pool
    */
-  get token1Price() {
-    return this._token1Price ?? (this._token1Price = new sdk.Price(this.token1, this.token0, this.sqrtRatioX96 * this.sqrtRatioX96, Q192));
+  get mintAmounts() {
+    if (this._mintAmounts === null) {
+      if (this.pool.tickCurrent < this.tickLower) {
+        return {
+          amount0: SqrtPriceMath.getAmount0Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true
+          ),
+          amount1: ZERO
+        };
+      }
+      if (this.pool.tickCurrent < this.tickUpper) {
+        return {
+          amount0: SqrtPriceMath.getAmount0Delta(
+            this.pool.sqrtRatioX96,
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true
+          ),
+          amount1: SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            this.pool.sqrtRatioX96,
+            this.liquidity,
+            true
+          )
+        };
+      }
+      return {
+        amount0: ZERO,
+        amount1: SqrtPriceMath.getAmount1Delta(
+          TickMath.getSqrtRatioAtTick(this.tickLower),
+          TickMath.getSqrtRatioAtTick(this.tickUpper),
+          this.liquidity,
+          true
+        )
+      };
+    }
+    return this._mintAmounts;
   }
   /**
-   * 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.
+   * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+   * and the prices at the tick boundaries.
+   * @param pool The pool for which the position should be created
+   * @param tickLower The lower tick of the position
+   * @param tickUpper The upper tick of the position
+   * @param amount0 token0 amount
+   * @param amount1 token1 amount
+   * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
+   * not what core can theoretically support
+   * @returns The amount of liquidity for the position
    */
-  priceOf(token) {
-    invariant11__default.default(this.involvesToken(token), "TOKEN");
-    return token.equals(this.token0) ? this.token0Price : this.token1Price;
+  static fromAmounts({
+    pool,
+    tickLower,
+    tickUpper,
+    amount0,
+    amount1,
+    useFullPrecision
+  }) {
+    const sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
+    const sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
+    return new Position({
+      pool,
+      tickLower,
+      tickUpper,
+      liquidity: maxLiquidityForAmounts(
+        pool.sqrtRatioX96,
+        sqrtRatioAX96,
+        sqrtRatioBX96,
+        amount0,
+        amount1,
+        useFullPrecision
+      )
+    });
   }
   /**
-   * Returns the chain ID of the tokens in the pool.
+   * Computes a position with the maximum amount of liquidity received for a given amount of token0, assuming an unlimited amount of token1
+   * @param pool The pool for which the position is created
+   * @param tickLower The lower tick
+   * @param tickUpper The upper tick
+   * @param amount0 The desired amount of token0
+   * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+   * not what core can theoretically support
+   * @returns The position
    */
-  get chainId() {
-    return this.token0.chainId;
+  static fromAmount0({
+    pool,
+    tickLower,
+    tickUpper,
+    amount0,
+    useFullPrecision
+  }) {
+    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0, amount1: sdk.MaxUint256, useFullPrecision });
   }
   /**
-   * 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
+   * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
+   * @param pool The pool for which the position is created
+   * @param tickLower The lower tick
+   * @param tickUpper The upper tick
+   * @param amount1 The desired amount of token1
+   * @returns The position
    */
-  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, outputAmount * NEGATIVE_ONE),
-      new Pool(this.token0, this.token1, this.fee, sqrtRatioX96, liquidity, tickCurrent, this.tickDataProvider)
-    ];
+  static fromAmount1({
+    pool,
+    tickLower,
+    tickUpper,
+    amount1
+  }) {
+    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0: sdk.MaxUint256, amount1, useFullPrecision: true });
   }
+};
+var Route = class {
   /**
-   * 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
+   * Creates an instance of route.
+   * @param pools An array of `Pool` objects, ordered by the route the swap will take
+   * @param input The input token
+   * @param output The output token
    */
-  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, outputAmount.quotient * NEGATIVE_ONE, sqrtPriceLimitX96);
-    invariant11__default.default(amountSpecifiedRemaining === ZERO, "INSUFICIENT_LIQUIDITY");
-    const inputToken = zeroForOne ? this.token0 : this.token1;
-    return [
-      sdk.CurrencyAmount.fromRawAmount(inputToken, inputAmount),
-      new Pool(this.token0, this.token1, this.fee, sqrtRatioX96, liquidity, tickCurrent, this.tickDataProvider)
-    ];
+  constructor(pools, input, output) {
+    this._midPrice = null;
+    invariant9__default.default(pools.length > 0, "POOLS");
+    const { chainId } = pools[0];
+    const allOnSameChain = pools.every((pool) => pool.chainId === chainId);
+    invariant9__default.default(allOnSameChain, "CHAIN_IDS");
+    const wrappedInput = input.wrapped;
+    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];
+      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 ?? tokenPath[tokenPath.length - 1];
+  }
+  get chainId() {
+    return this.pools[0].chainId;
   }
   /**
-   * 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
+   * Returns the mid price of the route
    */
-  async swap(zeroForOne, amountSpecified, sqrtPriceLimitX96) {
-    if (!sqrtPriceLimitX96)
-      sqrtPriceLimitX96 = zeroForOne ? TickMath.MIN_SQRT_RATIO + ONE : TickMath.MAX_SQRT_RATIO - ONE;
-    if (zeroForOne) {
-      invariant11__default.default(sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO, "RATIO_MIN");
-      invariant11__default.default(sqrtPriceLimitX96 < this.sqrtRatioX96, "RATIO_CURRENT");
-    } else {
-      invariant11__default.default(sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO, "RATIO_MAX");
-      invariant11__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;
-      }
-      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);
+  get midPrice() {
+    if (this._midPrice !== null)
+      return this._midPrice;
+    const { price } = this.pools.slice(1).reduce(
+      ({ nextInput, price: price2 }, pool) => {
+        return nextInput.equals(pool.token0) ? {
+          nextInput: pool.token1,
+          price: price2.multiply(pool.token0Price)
+        } : {
+          nextInput: pool.token0,
+          price: price2.multiply(pool.token1Price)
+        };
+      },
+      this.pools[0].token0.equals(this.input.wrapped) ? {
+        nextInput: this.pools[0].token1,
+        price: this.pools[0].token0Price
+      } : {
+        nextInput: this.pools[0].token0,
+        price: this.pools[0].token1Price
       }
-    }
-    return {
-      amountSpecifiedRemaining: state.amountSpecifiedRemaining,
-      amountCalculated: state.amountCalculated,
-      sqrtRatioX96: state.sqrtPriceX96,
-      liquidity: state.liquidity,
-      tickCurrent: state.tick
-    };
-  }
-  get tickSpacing() {
-    return TICK_SPACINGS[this.fee];
+    );
+    return this._midPrice = new swapSdkCore.Price(this.input, this.output, price.denominator, price.numerator);
   }
 };
-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 = BigInt(liquidity);
+function tradeComparator(a, b) {
+  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);
+      const bHops = b.swaps.reduce((total, cur) => total + cur.route.tokenPath.length, 0);
+      return aHops - bHops;
+    }
+    if (a.inputAmount.lessThan(b.inputAmount)) {
+      return -1;
+    }
+    return 1;
+  }
+  if (a.outputAmount.lessThan(b.outputAmount)) {
+    return 1;
   }
+  return -1;
+}
+var Trade = class {
   /**
-   * Returns the price of token0 at the lower tick
+   * @deprecated Deprecated in favor of 'swaps' property. If the trade consists of multiple routes
+   * this will return an error.
+   *
+   * When the trade consists of just a single route, this returns the route of the trade,
+   * i.e. which pools the trade goes through.
    */
-  get token0PriceLower() {
-    return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower);
+  get route() {
+    invariant9__default.default(this.swaps.length == 1, "MULTIPLE_ROUTES");
+    return this.swaps[0].route;
   }
   /**
-   * Returns the price of token0 at the upper tick
+   * The input amount for the trade assuming no slippage.
    */
-  get token0PriceUpper() {
-    return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper);
+  get inputAmount() {
+    if (this._inputAmount) {
+      return this._inputAmount;
+    }
+    const inputCurrency = this.swaps[0].inputAmount.currency;
+    const totalInputFromRoutes = this.swaps.map(({ inputAmount }) => inputAmount).reduce((total, cur) => total.add(cur), sdk.CurrencyAmount.fromRawAmount(inputCurrency, 0));
+    this._inputAmount = totalInputFromRoutes;
+    return this._inputAmount;
   }
   /**
-   * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+   * The output amount for the trade assuming no slippage.
    */
-  get amount0() {
-    if (this._token0Amount === null) {
-      this._token0Amount = sdk.CurrencyAmount.fromRawAmount(
-        this.pool.token0,
-        PositionMath.getToken0Amount(
-          this.pool.tickCurrent,
-          this.tickLower,
-          this.tickUpper,
-          this.pool.sqrtRatioX96,
-          this.liquidity
-        )
-      );
+  get outputAmount() {
+    if (this._outputAmount) {
+      return this._outputAmount;
     }
-    return this._token0Amount;
+    const outputCurrency = this.swaps[0].outputAmount.currency;
+    const totalOutputFromRoutes = this.swaps.map(({ outputAmount }) => outputAmount).reduce((total, cur) => total.add(cur), sdk.CurrencyAmount.fromRawAmount(outputCurrency, 0));
+    this._outputAmount = totalOutputFromRoutes;
+    return this._outputAmount;
   }
   /**
-   * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+   * The price expressed in terms of output amount/input amount.
    */
-  get amount1() {
-    if (this._token1Amount === null) {
-      this._token1Amount = sdk.CurrencyAmount.fromRawAmount(
-        this.pool.token1,
-        PositionMath.getToken1Amount(
-          this.pool.tickCurrent,
-          this.tickLower,
-          this.tickUpper,
-          this.pool.sqrtRatioX96,
-          this.liquidity
-        )
-      );
-    }
-    return this._token1Amount;
+  get executionPrice() {
+    return this._executionPrice ?? (this._executionPrice = new sdk.Price(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.inputAmount.quotient,
+      this.outputAmount.quotient
+    ));
   }
   /**
-   * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
-   * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
-   * @returns The sqrt ratios after slippage
+   * Returns the percent difference between the route's mid price and the price impact
    */
-  ratiosAfterSlippage(slippageTolerance) {
-    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 (sqrtRatioX96Lower <= TickMath.MIN_SQRT_RATIO) {
-      sqrtRatioX96Lower = TickMath.MIN_SQRT_RATIO + 1n;
+  get priceImpact() {
+    if (this._priceImpact) {
+      return this._priceImpact;
     }
-    let sqrtRatioX96Upper = encodeSqrtRatioX96(priceUpper.numerator, priceUpper.denominator);
-    if (sqrtRatioX96Upper >= TickMath.MAX_SQRT_RATIO) {
-      sqrtRatioX96Upper = TickMath.MAX_SQRT_RATIO - 1n;
+    let spotOutputAmount = sdk.CurrencyAmount.fromRawAmount(this.outputAmount.currency, 0);
+    for (const { route, inputAmount } of this.swaps) {
+      const { midPrice } = route;
+      spotOutputAmount = spotOutputAmount.add(midPrice.quote(inputAmount));
     }
-    return {
-      sqrtRatioX96Lower,
-      sqrtRatioX96Upper
-    };
+    const priceImpact = spotOutputAmount.subtract(this.outputAmount).divide(spotOutputAmount);
+    this._priceImpact = new sdk.Percent(priceImpact.numerator, priceImpact.denominator);
+    return this._priceImpact;
   }
   /**
-   * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
-   * with the given slippage tolerance
-   * @param slippageTolerance Tolerance of unfavorable slippage from the current price
-   * @returns The amounts, with slippage
+   * Constructs an exact in trade with the given amount in and route
+   * @template TInput The input token, either Ether or an ERC-20
+   * @template TOutput The output token, either Ether or an ERC-20
+   * @param route The route of the exact in trade
+   * @param amountIn The amount being passed in
+   * @returns The exact in trade
    */
-  mintAmountsWithSlippage(slippageTolerance) {
-    const { sqrtRatioX96Upper, sqrtRatioX96Lower } = this.ratiosAfterSlippage(slippageTolerance);
-    const poolLower = new Pool(
-      this.pool.token0,
-      this.pool.token1,
-      this.pool.fee,
-      sqrtRatioX96Lower,
-      0,
-      TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower)
-    );
-    const poolUpper = new Pool(
-      this.pool.token0,
-      this.pool.token1,
-      this.pool.fee,
-      sqrtRatioX96Upper,
-      0,
-      TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper)
-    );
-    const positionThatWillBeCreated = Position.fromAmounts({
-      pool: this.pool,
-      tickLower: this.tickLower,
-      tickUpper: this.tickUpper,
-      ...this.mintAmounts,
-      // the mint amounts are what will be passed as calldata
-      useFullPrecision: false
-    });
-    const { amount0 } = new Position({
-      pool: poolUpper,
-      liquidity: positionThatWillBeCreated.liquidity,
-      tickLower: this.tickLower,
-      tickUpper: this.tickUpper
-    }).mintAmounts;
-    const { amount1 } = new Position({
-      pool: poolLower,
-      liquidity: positionThatWillBeCreated.liquidity,
-      tickLower: this.tickLower,
-      tickUpper: this.tickUpper
-    }).mintAmounts;
-    return { amount0, amount1 };
+  static async exactIn(route, amountIn) {
+    return Trade.fromRoute(route, amountIn, sdk.TradeType.EXACT_INPUT);
   }
   /**
-   * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
-   * position with the given slippage tolerance
-   * @param slippageTolerance tolerance of unfavorable slippage from the current price
-   * @returns The amounts, with slippage
+   * Constructs an exact out trade with the given amount out and route
+   * @template TInput The input token, either Ether or an ERC-20
+   * @template TOutput The output token, either Ether or an ERC-20
+   * @param route The route of the exact out trade
+   * @param amountOut The amount returned by the trade
+   * @returns The exact out trade
    */
-  burnAmountsWithSlippage(slippageTolerance) {
-    const { sqrtRatioX96Upper, sqrtRatioX96Lower } = this.ratiosAfterSlippage(slippageTolerance);
-    const poolLower = new Pool(
-      this.pool.token0,
-      this.pool.token1,
-      this.pool.fee,
-      sqrtRatioX96Lower,
-      0,
-      TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower)
-    );
-    const poolUpper = new Pool(
-      this.pool.token0,
-      this.pool.token1,
-      this.pool.fee,
-      sqrtRatioX96Upper,
-      0,
-      TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper)
-    );
-    const { amount0 } = new Position({
-      pool: poolUpper,
-      liquidity: this.liquidity,
-      tickLower: this.tickLower,
-      tickUpper: this.tickUpper
-    });
-    const { amount1 } = new Position({
-      pool: poolLower,
-      liquidity: this.liquidity,
-      tickLower: this.tickLower,
-      tickUpper: this.tickUpper
-    });
-    return { amount0: amount0.quotient, amount1: amount1.quotient };
+  static async exactOut(route, amountOut) {
+    return Trade.fromRoute(route, amountOut, sdk.TradeType.EXACT_OUTPUT);
   }
   /**
-   * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
-   * the current price for the pool
+   * Constructs a trade by simulating swaps through the given route
+   * @template TInput The input token, either Ether or an ERC-20.
+   * @template TOutput The output token, either Ether or an ERC-20.
+   * @template TTradeType The type of the trade, either exact in or exact out.
+   * @param route route to swap through
+   * @param amount the amount specified, either input or output, depending on tradeType
+   * @param tradeType whether the trade is an exact input or exact output swap
+   * @returns The route
    */
-  get mintAmounts() {
-    if (this._mintAmounts === null) {
-      if (this.pool.tickCurrent < this.tickLower) {
-        return {
-          amount0: SqrtPriceMath.getAmount0Delta(
-            TickMath.getSqrtRatioAtTick(this.tickLower),
-            TickMath.getSqrtRatioAtTick(this.tickUpper),
-            this.liquidity,
-            true
-          ),
-          amount1: ZERO
-        };
+  static async fromRoute(route, amount, tradeType) {
+    const amounts = new Array(route.tokenPath.length);
+    let inputAmount;
+    let outputAmount;
+    if (tradeType === sdk.TradeType.EXACT_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];
+        const [outputAmount2] = await pool.getOutputAmount(amounts[i]);
+        amounts[i + 1] = outputAmount2;
       }
-      if (this.pool.tickCurrent < this.tickUpper) {
-        return {
-          amount0: SqrtPriceMath.getAmount0Delta(
-            this.pool.sqrtRatioX96,
-            TickMath.getSqrtRatioAtTick(this.tickUpper),
-            this.liquidity,
-            true
-          ),
-          amount1: SqrtPriceMath.getAmount1Delta(
-            TickMath.getSqrtRatioAtTick(this.tickLower),
-            this.pool.sqrtRatioX96,
-            this.liquidity,
-            true
-          )
-        };
+      inputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+      outputAmount = sdk.CurrencyAmount.fromFractionalAmount(
+        route.output,
+        amounts[amounts.length - 1].numerator,
+        amounts[amounts.length - 1].denominator
+      );
+    } else {
+      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];
+        const [inputAmount2] = await pool.getInputAmount(amounts[i]);
+        amounts[i - 1] = inputAmount2;
       }
-      return {
-        amount0: ZERO,
-        amount1: SqrtPriceMath.getAmount1Delta(
-          TickMath.getSqrtRatioAtTick(this.tickLower),
-          TickMath.getSqrtRatioAtTick(this.tickUpper),
-          this.liquidity,
-          true
-        )
-      };
+      inputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
+      outputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
     }
-    return this._mintAmounts;
-  }
-  /**
-   * Computes the maximum amount of liquidity received for a given amount of token0, token1,
-   * and the prices at the tick boundaries.
-   * @param pool The pool for which the position should be created
-   * @param tickLower The lower tick of the position
-   * @param tickUpper The upper tick of the position
-   * @param amount0 token0 amount
-   * @param amount1 token1 amount
-   * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
-   * not what core can theoretically support
-   * @returns The amount of liquidity for the position
-   */
-  static fromAmounts({
-    pool,
-    tickLower,
-    tickUpper,
-    amount0,
-    amount1,
-    useFullPrecision
-  }) {
-    const sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
-    const sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
-    return new Position({
-      pool,
-      tickLower,
-      tickUpper,
-      liquidity: maxLiquidityForAmounts(
-        pool.sqrtRatioX96,
-        sqrtRatioAX96,
-        sqrtRatioBX96,
-        amount0,
-        amount1,
-        useFullPrecision
-      )
-    });
-  }
-  /**
-   * Computes a position with the maximum amount of liquidity received for a given amount of token0, assuming an unlimited amount of token1
-   * @param pool The pool for which the position is created
-   * @param tickLower The lower tick
-   * @param tickUpper The upper tick
-   * @param amount0 The desired amount of token0
-   * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
-   * not what core can theoretically support
-   * @returns The position
-   */
-  static fromAmount0({
-    pool,
-    tickLower,
-    tickUpper,
-    amount0,
-    useFullPrecision
-  }) {
-    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0, amount1: sdk.MaxUint256, useFullPrecision });
-  }
-  /**
-   * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
-   * @param pool The pool for which the position is created
-   * @param tickLower The lower tick
-   * @param tickUpper The upper tick
-   * @param amount1 The desired amount of token1
-   * @returns The position
-   */
-  static fromAmount1({
-    pool,
-    tickLower,
-    tickUpper,
-    amount1
-  }) {
-    return Position.fromAmounts({ pool, tickLower, tickUpper, amount0: sdk.MaxUint256, amount1, useFullPrecision: true });
-  }
-};
-var Route = class {
-  /**
-   * Creates an instance of route.
-   * @param pools An array of `Pool` objects, ordered by the route the swap will take
-   * @param input The input token
-   * @param output The output token
-   */
-  constructor(pools, input, output) {
-    this._midPrice = null;
-    invariant11__default.default(pools.length > 0, "POOLS");
-    const { chainId } = pools[0];
-    const allOnSameChain = pools.every((pool) => pool.chainId === chainId);
-    invariant11__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");
-    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");
-      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 ?? tokenPath[tokenPath.length - 1];
-  }
-  get chainId() {
-    return this.pools[0].chainId;
-  }
-  /**
-   * Returns the mid price of the route
-   */
-  get midPrice() {
-    if (this._midPrice !== null)
-      return this._midPrice;
-    const { price } = this.pools.slice(1).reduce(
-      ({ nextInput, price: price2 }, pool) => {
-        return nextInput.equals(pool.token0) ? {
-          nextInput: pool.token1,
-          price: price2.multiply(pool.token0Price)
-        } : {
-          nextInput: pool.token0,
-          price: price2.multiply(pool.token1Price)
-        };
-      },
-      this.pools[0].token0.equals(this.input.wrapped) ? {
-        nextInput: this.pools[0].token1,
-        price: this.pools[0].token0Price
-      } : {
-        nextInput: this.pools[0].token0,
-        price: this.pools[0].token1Price
-      }
-    );
-    return this._midPrice = new swapSdkCore.Price(this.input, this.output, price.denominator, price.numerator);
-  }
-};
-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");
-  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);
-      const bHops = b.swaps.reduce((total, cur) => total + cur.route.tokenPath.length, 0);
-      return aHops - bHops;
-    }
-    if (a.inputAmount.lessThan(b.inputAmount)) {
-      return -1;
-    }
-    return 1;
-  }
-  if (a.outputAmount.lessThan(b.outputAmount)) {
-    return 1;
-  }
-  return -1;
-}
-var Trade = class {
-  /**
-   * @deprecated Deprecated in favor of 'swaps' property. If the trade consists of multiple routes
-   * this will return an error.
-   *
-   * When the trade consists of just a single route, this returns the route of the trade,
-   * i.e. which pools the trade goes through.
-   */
-  get route() {
-    invariant11__default.default(this.swaps.length == 1, "MULTIPLE_ROUTES");
-    return this.swaps[0].route;
-  }
-  /**
-   * The input amount for the trade assuming no slippage.
-   */
-  get inputAmount() {
-    if (this._inputAmount) {
-      return this._inputAmount;
-    }
-    const inputCurrency = this.swaps[0].inputAmount.currency;
-    const totalInputFromRoutes = this.swaps.map(({ inputAmount }) => inputAmount).reduce((total, cur) => total.add(cur), sdk.CurrencyAmount.fromRawAmount(inputCurrency, 0));
-    this._inputAmount = totalInputFromRoutes;
-    return this._inputAmount;
-  }
-  /**
-   * The output amount for the trade assuming no slippage.
-   */
-  get outputAmount() {
-    if (this._outputAmount) {
-      return this._outputAmount;
-    }
-    const outputCurrency = this.swaps[0].outputAmount.currency;
-    const totalOutputFromRoutes = this.swaps.map(({ outputAmount }) => outputAmount).reduce((total, cur) => total.add(cur), sdk.CurrencyAmount.fromRawAmount(outputCurrency, 0));
-    this._outputAmount = totalOutputFromRoutes;
-    return this._outputAmount;
-  }
-  /**
-   * The price expressed in terms of output amount/input amount.
-   */
-  get executionPrice() {
-    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
-   */
-  get priceImpact() {
-    if (this._priceImpact) {
-      return this._priceImpact;
-    }
-    let spotOutputAmount = sdk.CurrencyAmount.fromRawAmount(this.outputAmount.currency, 0);
-    for (const { route, inputAmount } of this.swaps) {
-      const { midPrice } = route;
-      spotOutputAmount = spotOutputAmount.add(midPrice.quote(inputAmount));
-    }
-    const priceImpact = spotOutputAmount.subtract(this.outputAmount).divide(spotOutputAmount);
-    this._priceImpact = new sdk.Percent(priceImpact.numerator, priceImpact.denominator);
-    return this._priceImpact;
-  }
-  /**
-   * Constructs an exact in trade with the given amount in and route
-   * @template TInput The input token, either Ether or an ERC-20
-   * @template TOutput The output token, either Ether or an ERC-20
-   * @param route The route of the exact in trade
-   * @param amountIn The amount being passed in
-   * @returns The exact in trade
-   */
-  static async exactIn(route, amountIn) {
-    return Trade.fromRoute(route, amountIn, sdk.TradeType.EXACT_INPUT);
-  }
-  /**
-   * Constructs an exact out trade with the given amount out and route
-   * @template TInput The input token, either Ether or an ERC-20
-   * @template TOutput The output token, either Ether or an ERC-20
-   * @param route The route of the exact out trade
-   * @param amountOut The amount returned by the trade
-   * @returns The exact out trade
-   */
-  static async exactOut(route, amountOut) {
-    return Trade.fromRoute(route, amountOut, sdk.TradeType.EXACT_OUTPUT);
-  }
-  /**
-   * Constructs a trade by simulating swaps through the given route
-   * @template TInput The input token, either Ether or an ERC-20.
-   * @template TOutput The output token, either Ether or an ERC-20.
-   * @template TTradeType The type of the trade, either exact in or exact out.
-   * @param route route to swap through
-   * @param amount the amount specified, either input or output, depending on tradeType
-   * @param tradeType whether the trade is an exact input or exact output swap
-   * @returns The route
-   */
-  static async fromRoute(route, amount, tradeType) {
-    const amounts = new Array(route.tokenPath.length);
-    let inputAmount;
-    let outputAmount;
-    if (tradeType === sdk.TradeType.EXACT_INPUT) {
-      invariant11__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];
-        const [outputAmount2] = await pool.getOutputAmount(amounts[i]);
-        amounts[i + 1] = outputAmount2;
-      }
-      inputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
-      outputAmount = sdk.CurrencyAmount.fromFractionalAmount(
-        route.output,
-        amounts[amounts.length - 1].numerator,
-        amounts[amounts.length - 1].denominator
-      );
-    } else {
-      invariant11__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];
-        const [inputAmount2] = await pool.getInputAmount(amounts[i]);
-        amounts[i - 1] = inputAmount2;
-      }
-      inputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
-      outputAmount = sdk.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
-    }
-    return new Trade({
-      routes: [{ inputAmount, outputAmount, route }],
-      tradeType
+    return new Trade({
+      routes: [{ inputAmount, outputAmount, route }],
+      tradeType
     });
   }
   /**
@@ -1586,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++) {
@@ -1600,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,
@@ -1665,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"
     );
@@ -1680,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;
   }
@@ -1690,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: [
@@ -1884,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" },
@@ -2397,8 +2407,8 @@ var NonfungiblePositionManager_default = [
   { stateMutability: "payable", type: "receive" }
 ];
 
-// src/abi/SelfPermit.json
-var SelfPermit_default = [
+// src/abi/SelfPermit.ts
+var selfPermitABI = [
   {
     inputs: [
       {
@@ -2564,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",
@@ -2705,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(2n ** 128n - 1n);
+var MaxUint128 = 2n ** 128n - 1n;
 function isMint(options) {
   return Object.keys(options).some((k) => k === "recipient");
 }
@@ -2756,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 {
@@ -2770,13 +2774,13 @@ var _NonfungiblePositionManager = class {
     };
   }
   static addCallParameters(position, options) {
-    invariant11__default.default(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));
     }
@@ -2789,40 +2793,48 @@ 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 (wrappedValue > ZERO) {
         calldatas.push(Payments.encodeRefundETH());
@@ -2836,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;
@@ -2873,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(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(
@@ -2924,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),
@@ -2939,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,
@@ -2957,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: [
       {
@@ -3172,8 +3199,8 @@ var Quoter_default = [
   }
 ];
 
-// src/abi/QuoterV2.json
-var QuoterV2_default = [
+// src/abi/QuoterV2.ts
+var quoterV2ABI = [
   {
     inputs: [
       {
@@ -3474,19 +3501,19 @@ var SwapQuoter = class {
    */
   static quoteCallParameters(route, amount, tradeType, options = {}) {
     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(options?.sqrtPriceLimitX96 ?? 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,
@@ -3495,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?.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,
@@ -3512,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: [
       {
@@ -4236,15 +4278,20 @@ var _Staker = class {
   static encodeClaim(incentiveKey, options) {
     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 = 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;
   }
@@ -4264,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 {
@@ -4295,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),
@@ -4320,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;
@@ -4337,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: [
       {
@@ -4951,11 +5001,11 @@ var _SwapRouter = class {
     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"
     );
@@ -4972,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) {
@@ -4992,9 +5042,15 @@ var _SwapRouter = class {
               deadline,
               amountIn,
               amountOutMinimum: amountOut,
-              sqrtPriceLimitX96: toHex(options.sqrtPriceLimitX96 ?? 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,
@@ -5004,12 +5060,18 @@ var _SwapRouter = class {
               deadline,
               amountOut,
               amountInMaximum: amountIn,
-              sqrtPriceLimitX96: toHex(options.sqrtPriceLimitX96 ?? 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 = {
@@ -5019,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,
@@ -5028,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] })
+            );
           }
         }
       }
@@ -5061,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" },
@@ -5752,14 +5819,14 @@ var _MasterChefV3 = class {
   // Copy from NonfungiblePositionManager
   // Only support increaseLiquidity
   static addCallParameters(position, options) {
-    invariant11__default.default(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));
     }
@@ -5767,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);
     }
@@ -5793,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;
@@ -5824,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(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(
@@ -5876,26 +5946,28 @@ var _MasterChefV3 = class {
     if (rest?.recipient) {
       if (options.liquidityPercentage.equalTo(sdk.ONE)) {
         calldatas.push(
-          _MasterChefV3.INTERFACE.encodeFunctionData("withdraw", [
-            tokenId.toString(),
-            sdk.validateAndParseAddress(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?.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),
@@ -5921,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;
   }
@@ -5929,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),
@@ -5938,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;
@@ -5990,13 +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;