@kayenfinance/v3-sdk 1.3.1 → 1.3.3

package/dist/v3-sdk.cjs.development.js

@@ -229,6 +229,7 @@ var _FACTORY_ADDRESS_BY_C, _POOL_INIT_CODE_HASH_, _TICK_SPACINGS;
 var FACTORY_ADDRESS = '0x4bC8BDF50843Cc503E196Be4A9560134d358bb3C';
 var FACTORY_ADDRESS_BY_CHAIN_ID = (_FACTORY_ADDRESS_BY_C = {}, _FACTORY_ADDRESS_BY_C[sdkCore.ChainId.CHILIZ] = '0x4bC8BDF50843Cc503E196Be4A9560134d358bb3C', _FACTORY_ADDRESS_BY_C[sdkCore.ChainId.SPICY] = '0x9Fc08909577539c635F04ef924f65c56560c8BD3', _FACTORY_ADDRESS_BY_C);
 var ADDRESS_ZERO = '0x0000000000000000000000000000000000000000';
+
 // @deprecated please use poolInitCodeHash(chainId: ChainId)
 var POOL_INIT_CODE_HASH = '0xcb96d536c98123b475b91f2f81bd6d5877fb48561b42d7892f4725df4c8cce7e';
 var POOL_INIT_CODE_HASH_BY_CHAIN_ID = (_POOL_INIT_CODE_HASH_ = {}, _POOL_INIT_CODE_HASH_[sdkCore.ChainId.CHILIZ] = '0xcb96d536c98123b475b91f2f81bd6d5877fb48561b42d7892f4725df4c8cce7e', _POOL_INIT_CODE_HASH_[sdkCore.ChainId.SPICY] = '0xcb96d536c98123b475b91f2f81bd6d5877fb48561b42d7892f4725df4c8cce7e', _POOL_INIT_CODE_HASH_);
@@ -241,7 +242,11 @@ function poolInitCodeHash(chainId) {
       return (_POOL_INIT_CODE_HASH_2 = POOL_INIT_CODE_HASH_BY_CHAIN_ID[chainId]) != null ? _POOL_INIT_CODE_HASH_2 : POOL_INIT_CODE_HASH;
   }
 }
-(function (FeeAmount) {
+
+/**
+ * The default factory enabled fee amounts, denominated in hundredths of bips.
+ */
+var FeeAmount = /*#__PURE__*/function (FeeAmount) {
   FeeAmount[FeeAmount["LOWEST"] = 100] = "LOWEST";
   FeeAmount[FeeAmount["LOW_200"] = 200] = "LOW_200";
   FeeAmount[FeeAmount["LOW_300"] = 300] = "LOW_300";
@@ -249,29 +254,32 @@ function poolInitCodeHash(chainId) {
   FeeAmount[FeeAmount["LOW"] = 500] = "LOW";
   FeeAmount[FeeAmount["MEDIUM"] = 3000] = "MEDIUM";
   FeeAmount[FeeAmount["HIGH"] = 10000] = "HIGH";
-})(exports.FeeAmount || (exports.FeeAmount = {}));
-/**
- * The default factory tick spacings by fee amount.
+  return FeeAmount;
+}({});
+
+/**
+ * The default factory tick spacings by fee amount.
  */
-var TICK_SPACINGS = (_TICK_SPACINGS = {}, _TICK_SPACINGS[exports.FeeAmount.LOWEST] = 1, _TICK_SPACINGS[exports.FeeAmount.LOW_200] = 4, _TICK_SPACINGS[exports.FeeAmount.LOW_300] = 6, _TICK_SPACINGS[exports.FeeAmount.LOW_400] = 8, _TICK_SPACINGS[exports.FeeAmount.LOW] = 10, _TICK_SPACINGS[exports.FeeAmount.MEDIUM] = 60, _TICK_SPACINGS[exports.FeeAmount.HIGH] = 200, _TICK_SPACINGS);
+var TICK_SPACINGS = (_TICK_SPACINGS = {}, _TICK_SPACINGS[FeeAmount.LOWEST] = 1, _TICK_SPACINGS[FeeAmount.LOW_200] = 4, _TICK_SPACINGS[FeeAmount.LOW_300] = 6, _TICK_SPACINGS[FeeAmount.LOW_400] = 8, _TICK_SPACINGS[FeeAmount.LOW] = 10, _TICK_SPACINGS[FeeAmount.MEDIUM] = 60, _TICK_SPACINGS[FeeAmount.HIGH] = 200, _TICK_SPACINGS);
 
 // constants used internally but not expected to be used externally
 var NEGATIVE_ONE = /*#__PURE__*/JSBI.BigInt(-1);
 var ZERO = /*#__PURE__*/JSBI.BigInt(0);
 var ONE = /*#__PURE__*/JSBI.BigInt(1);
+
 // used in liquidity amount math
 var Q96 = /*#__PURE__*/JSBI.exponentiate(/*#__PURE__*/JSBI.BigInt(2), /*#__PURE__*/JSBI.BigInt(96));
 var Q192 = /*#__PURE__*/JSBI.exponentiate(Q96, /*#__PURE__*/JSBI.BigInt(2));
 
-/**
- * Computes a pool address
- * @param factoryAddress The Uniswap V3 factory address
- * @param tokenA The first token of the pair, irrespective of sort order
- * @param tokenB The second token of the pair, irrespective of sort order
- * @param fee The fee tier of the pool
- * @param initCodeHashManualOverride Override the init code hash used to compute the pool address if necessary
- * @param chainId
- * @returns The pool address
+/**
+ * Computes a pool address
+ * @param factoryAddress The Uniswap V3 factory address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param fee The fee tier of the pool
+ * @param initCodeHashManualOverride Override the init code hash used to compute the pool address if necessary
+ * @param chainId
+ * @returns The pool address
  */
 function computePoolAddress(_ref) {
   var factoryAddress = _ref.factoryAddress,
@@ -285,6 +293,7 @@ function computePoolAddress(_ref) {
     token1 = _ref2[1]; // does safety checks
   var salt = solidity.keccak256(['bytes'], [abi.defaultAbiCoder.encode(['address', 'address', 'uint24'], [token0.address, token1.address, fee])]);
   var initCodeHash = initCodeHashManualOverride != null ? initCodeHashManualOverride : poolInitCodeHash(chainId);
+
   // ZKSync uses a different create2 address computation
   // Most likely all ZKEVM chains will use the different computation from standard create2
   switch (chainId) {
@@ -296,8 +305,8 @@ function computePoolAddress(_ref) {
 }
 
 var FullMath = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function FullMath() {}
   FullMath.mulDivRoundingUp = function mulDivRoundingUp(a, b, denominator) {
@@ -319,8 +328,8 @@ function addIn256(x, y) {
   return JSBI.bitwiseAnd(sum, sdkCore.MaxUint256);
 }
 var SqrtPriceMath = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function SqrtPriceMath() {}
   SqrtPriceMath.getAmount0Delta = function getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
@@ -386,8 +395,8 @@ var SqrtPriceMath = /*#__PURE__*/function () {
 
 var MAX_FEE = /*#__PURE__*/JSBI.exponentiate(/*#__PURE__*/JSBI.BigInt(10), /*#__PURE__*/JSBI.BigInt(6));
 var SwapMath = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function SwapMath() {}
   SwapMath.computeSwapStep = function computeSwapStep(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, amountRemaining, feePips) {
@@ -434,8 +443,8 @@ var SwapMath = /*#__PURE__*/function () {
 }();
 
 var LiquidityMath = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function LiquidityMath() {}
   LiquidityMath.addDelta = function addDelta(x, y) {
@@ -468,18 +477,23 @@ function mostSignificantBit(x) {
   return msb;
 }
 
+var _TickMath;
 function mulShift(val, mulBy) {
   return JSBI.signedRightShift(JSBI.multiply(val, JSBI.BigInt(mulBy)), JSBI.BigInt(128));
 }
 var Q32 = /*#__PURE__*/JSBI.exponentiate(/*#__PURE__*/JSBI.BigInt(2), /*#__PURE__*/JSBI.BigInt(32));
 var TickMath = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function TickMath() {}
-  /**
-   * Returns the sqrt ratio as a Q64.96 for the given tick. The sqrt ratio is computed as sqrt(1.0001)^tick
-   * @param tick the tick for which to compute the sqrt ratio
+
+  /**
+   * The minimum tick that can be used on any pool.
+   */
+  /**
+   * Returns the sqrt ratio as a Q64.96 for the given tick. The sqrt ratio is computed as sqrt(1.0001)^tick
+   * @param tick the tick for which to compute the sqrt ratio
    */
   TickMath.getSqrtRatioAtTick = function getSqrtRatioAtTick(tick) {
     !(tick >= TickMath.MIN_TICK && tick <= TickMath.MAX_TICK && Number.isInteger(tick)) ?  invariant(false, 'TICK')  : void 0;
@@ -505,13 +519,15 @@ var TickMath = /*#__PURE__*/function () {
     if ((absTick & 0x40000) !== 0) ratio = mulShift(ratio, '0x2216e584f5fa1ea926041bedfe98');
     if ((absTick & 0x80000) !== 0) ratio = mulShift(ratio, '0x48a170391f7dc42444e8fa2');
     if (tick > 0) ratio = JSBI.divide(sdkCore.MaxUint256, ratio);
+
     // back to Q96
     return JSBI.greaterThan(JSBI.remainder(ratio, Q32), ZERO) ? JSBI.add(JSBI.divide(ratio, Q32), ONE) : JSBI.divide(ratio, Q32);
   }
-  /**
-   * Returns the tick corresponding to a given sqrt ratio, s.t. #getSqrtRatioAtTick(tick) <= sqrtRatioX96
-   * and #getSqrtRatioAtTick(tick + 1) > sqrtRatioX96
-   * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
+
+  /**
+   * Returns the tick corresponding to a given sqrt ratio, s.t. #getSqrtRatioAtTick(tick) <= sqrtRatioX96
+   * and #getSqrtRatioAtTick(tick + 1) > sqrtRatioX96
+   * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
    */;
   TickMath.getTickAtSqrtRatio = function getTickAtSqrtRatio(sqrtRatioX96) {
     !(JSBI.greaterThanOrEqual(sqrtRatioX96, TickMath.MIN_SQRT_RATIO) && JSBI.lessThan(sqrtRatioX96, TickMath.MAX_SQRT_RATIO)) ?  invariant(false, 'SQRT_RATIO')  : void 0;
@@ -537,20 +553,18 @@ var TickMath = /*#__PURE__*/function () {
   };
   return TickMath;
 }();
-/**
- * The minimum tick that can be used on any pool.
- */
+_TickMath = TickMath;
 TickMath.MIN_TICK = -887272;
-/**
- * The maximum tick that can be used on any pool.
+/**
+ * The maximum tick that can be used on any pool.
  */
-TickMath.MAX_TICK = -TickMath.MIN_TICK;
-/**
- * The sqrt ratio corresponding to the minimum tick that could be used on any pool.
+TickMath.MAX_TICK = -_TickMath.MIN_TICK;
+/**
+ * The sqrt ratio corresponding to the minimum tick that could be used on any pool.
  */
 TickMath.MIN_SQRT_RATIO = /*#__PURE__*/JSBI.BigInt('4295128739');
-/**
- * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
+/**
+ * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
  */
 TickMath.MAX_SQRT_RATIO = /*#__PURE__*/JSBI.BigInt('1461446703485210103287273052203988822378723970342');
 
@@ -585,7 +599,12 @@ function _v3Swap() {
             break;
           }
           step = {};
-          step.sqrtPriceStartX96 = state.sqrtPriceX96;
+          step.sqrtPriceStartX96 = state.sqrtPriceX96
+
+          // because each iteration of the while loop rounds, we can't optimize this code (relative to the smart contract)
+          // by simply traversing to the next available tick, we instead need to exactly replicate
+          // tickBitmap.nextInitializedTickWithinOneWord
+;
           _context.n = 2;
           return tickDataProvider.nextInitializedTickWithinOneWord(state.tick, zeroForOne, tickSpacing);
         case 2:
@@ -610,6 +629,7 @@ function _v3Swap() {
             state.amountSpecifiedRemaining = JSBI.add(state.amountSpecifiedRemaining, step.amountOut);
             state.amountCalculated = JSBI.add(state.amountCalculated, JSBI.add(step.amountIn, step.feeAmount));
           }
+
           // TODO
           if (!JSBI.equal(state.sqrtPriceX96, step.sqrtPriceNextX96)) {
             _context.n = 5;
@@ -654,9 +674,13 @@ function _v3Swap() {
   return _v3Swap.apply(this, arguments);
 }
 
-/**
- * This tick data provider does not know how to fetch any tick data. It throws whenever it is required. Useful if you
- * do not need to load tick data for your use case.
+/**
+ * Provides information about ticks
+ */
+
+/**
+ * This tick data provider does not know how to fetch any tick data. It throws whenever it is required. Useful if you
+ * do not need to load tick data for your use case.
  */
 var NoTickDataProvider = /*#__PURE__*/function () {
   function NoTickDataProvider() {}
@@ -697,11 +721,11 @@ var NoTickDataProvider = /*#__PURE__*/function () {
 }();
 NoTickDataProvider.ERROR_MESSAGE = 'No tick data provider was given';
 
-/**
- * Determines if a tick list is sorted
- * @param list The tick list
- * @param comparator The comparator
- * @returns true if sorted
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
  */
 function isSorted(list, comparator) {
   for (var i = 0; i < list.length - 1; i++) {
@@ -715,12 +739,13 @@ function isSorted(list, comparator) {
 function tickComparator(a, b) {
   return a.index - b.index;
 }
-/**
- * Utility methods for interacting with sorted lists of ticks
+
+/**
+ * Utility methods for interacting with sorted lists of ticks
  */
 var TickList = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed
+  /**
+   * Cannot be constructed
    */
   function TickList() {}
   TickList.validateList = function validateList(ticks, tickSpacing) {
@@ -730,6 +755,7 @@ var TickList = /*#__PURE__*/function () {
       var index = _ref.index;
       return index % tickSpacing === 0;
     }) ?  invariant(false, 'TICK_SPACING')  : void 0;
+
     // ensure tick liquidity deltas sum to 0
     !JSBI.equal(ticks.reduce(function (accumulator, _ref2) {
       var liquidityNet = _ref2.liquidityNet;
@@ -750,11 +776,12 @@ var TickList = /*#__PURE__*/function () {
     !(tick.index === index) ?  invariant(false, 'NOT_CONTAINED')  : void 0;
     return tick;
   }
-  /**
-   * Finds the largest tick in the list of ticks that is less than or equal to tick
-   * @param ticks list of ticks
-   * @param tick tick to find the largest tick that is less than or equal to tick
-   * @private
+
+  /**
+   * Finds the largest tick in the list of ticks that is less than or equal to tick
+   * @param ticks list of ticks
+   * @param tick tick to find the largest tick that is less than or equal to tick
+   * @private
    */;
   TickList.binarySearch = function binarySearch(ticks, tick) {
     !!this.isBelowSmallest(ticks, tick) ?  invariant(false, 'BELOW_SMALLEST')  : void 0;
@@ -792,6 +819,7 @@ var TickList = /*#__PURE__*/function () {
   };
   TickList.nextInitializedTickWithinOneWord = function nextInitializedTickWithinOneWord(ticks, tick, lte, tickSpacing) {
     var compressed = Math.floor(tick / tickSpacing); // matches rounding in the code
+
     if (lte) {
       var wordPos = compressed >> 8;
       var minimum = (wordPos << 8) * tickSpacing;
@@ -815,10 +843,14 @@ var TickList = /*#__PURE__*/function () {
   return TickList;
 }();
 
-/**
- * Converts a big int to a hex string
- * @param bigintIsh
- * @returns The hex encoded calldata
+/**
+ * Generated method parameters for executing a call.
+ */
+
+/**
+ * Converts a big int to a hex string
+ * @param bigintIsh
+ * @returns The hex encoded calldata
  */
 function toHex(bigintIsh) {
   var bigInt = JSBI.BigInt(bigintIsh);
@@ -829,10 +861,10 @@ function toHex(bigintIsh) {
   return "0x" + hex;
 }
 
-/**
- * Converts a route to a hex encoded path
- * @param route the v3 path to convert to an encoded path
- * @param exactOutput whether the route should be encoded in reverse, for making exact output swaps
+/**
+ * Converts a route to a hex encoded path
+ * @param route the v3 path to convert to an encoded path
+ * @param exactOutput whether the route should be encoded in reverse, for making exact output swaps
  */
 function encodeRouteToPath(route, exactOutput) {
   var firstInputToken = route.input.wrapped;
@@ -864,12 +896,13 @@ function encodeRouteToPath(route, exactOutput) {
   return exactOutput ? solidity.pack(types.reverse(), path.reverse()) : solidity.pack(types, path);
 }
 
-/**
- * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
- * @param amount1 The numerator amount i.e., the amount of token1
- * @param amount0 The denominator amount i.e., the amount of token0
- * @returns The sqrt ratio
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
+ * @param amount1 The numerator amount i.e., the amount of token1
+ * @param amount0 The denominator amount i.e., the amount of token0
+ * @returns The sqrt ratio
  */
+
 function encodeSqrtRatioX96(amount1, amount0) {
   var numerator = JSBI.leftShift(JSBI.BigInt(amount1), JSBI.BigInt(192));
   var denominator = JSBI.BigInt(amount0);
@@ -877,16 +910,16 @@ function encodeSqrtRatioX96(amount1, amount0) {
   return sdkCore.sqrt(ratioX192);
 }
 
-/**
- * Returns an imprecise maximum amount of liquidity received for a given amount of token 0.
- * This function is available to accommodate LiquidityAmounts#getLiquidityForAmount0 in the v3 periphery,
- * which could be more precise by at least 32 bits by dividing by Q64 instead of Q96 in the intermediate step,
- * and shifting the subtracted ratio left by 32 bits. This imprecise calculation will likely be replaced in a future
- * v3 router contract.
- * @param sqrtRatioAX96 The price at the lower boundary
- * @param sqrtRatioBX96 The price at the upper boundary
- * @param amount0 The token0 amount
- * @returns liquidity for amount0, imprecise
+/**
+ * Returns an imprecise maximum amount of liquidity received for a given amount of token 0.
+ * This function is available to accommodate LiquidityAmounts#getLiquidityForAmount0 in the v3 periphery,
+ * which could be more precise by at least 32 bits by dividing by Q64 instead of Q96 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits. This imprecise calculation will likely be replaced in a future
+ * v3 router contract.
+ * @param sqrtRatioAX96 The price at the lower boundary
+ * @param sqrtRatioBX96 The price at the upper boundary
+ * @param amount0 The token0 amount
+ * @returns liquidity for amount0, imprecise
  */
 function maxLiquidityForAmount0Imprecise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
   if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
@@ -897,13 +930,14 @@ function maxLiquidityForAmount0Imprecise(sqrtRatioAX96, sqrtRatioBX96, amount0)
   var intermediate = JSBI.divide(JSBI.multiply(sqrtRatioAX96, sqrtRatioBX96), Q96);
   return JSBI.divide(JSBI.multiply(JSBI.BigInt(amount0), intermediate), JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96));
 }
-/**
- * Returns a precise maximum amount of liquidity received for a given amount of token 0 by dividing by Q64 instead of Q96 in the intermediate step,
- * and shifting the subtracted ratio left by 32 bits.
- * @param sqrtRatioAX96 The price at the lower boundary
- * @param sqrtRatioBX96 The price at the upper boundary
- * @param amount0 The token0 amount
- * @returns liquidity for amount0, precise
+
+/**
+ * Returns a precise maximum amount of liquidity received for a given amount of token 0 by dividing by Q64 instead of Q96 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits.
+ * @param sqrtRatioAX96 The price at the lower boundary
+ * @param sqrtRatioBX96 The price at the upper boundary
+ * @param amount0 The token0 amount
+ * @returns liquidity for amount0, precise
  */
 function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
   if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
@@ -915,12 +949,13 @@ function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
   var denominator = JSBI.multiply(Q96, JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96));
   return JSBI.divide(numerator, denominator);
 }
-/**
- * Computes the maximum amount of liquidity received for a given amount of token1
- * @param sqrtRatioAX96 The price at the lower tick boundary
- * @param sqrtRatioBX96 The price at the upper tick boundary
- * @param amount1 The token1 amount
- * @returns liquidity for amount1
+
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token1
+ * @param sqrtRatioAX96 The price at the lower tick boundary
+ * @param sqrtRatioBX96 The price at the upper tick boundary
+ * @param amount1 The token1 amount
+ * @returns liquidity for amount1
  */
 function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
   if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
@@ -930,16 +965,17 @@ function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
   }
   return JSBI.divide(JSBI.multiply(JSBI.BigInt(amount1), Q96), JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96));
 }
-/**
- * Computes the maximum amount of liquidity received for a given amount of token0, token1,
- * and the prices at the tick boundaries.
- * @param sqrtRatioCurrentX96 the current price
- * @param sqrtRatioAX96 price at lower boundary
- * @param sqrtRatioBX96 price at upper boundary
- * @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
+
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX96 the current price
+ * @param sqrtRatioAX96 price at lower boundary
+ * @param sqrtRatioBX96 price at upper boundary
+ * @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
  */
 function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX96, amount0, amount1, useFullPrecision) {
   if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
@@ -959,10 +995,10 @@ function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX9
   }
 }
 
-/**
- * Returns the closest tick that is nearest a given tick and usable for the given tick spacing
- * @param tick the target tick
- * @param tickSpacing the spacing of the pool
+/**
+ * Returns the closest tick that is nearest a given tick and usable for the given tick spacing
+ * @param tick the target tick
+ * @param tickSpacing the spacing of the pool
  */
 function nearestUsableTick(tick, tickSpacing) {
   !(Number.isInteger(tick) && Number.isInteger(tickSpacing)) ?  invariant(false, 'INTEGERS')  : void 0;
@@ -974,10 +1010,11 @@ function nearestUsableTick(tick, tickSpacing) {
 
 var Q128 = /*#__PURE__*/JSBI.exponentiate(/*#__PURE__*/JSBI.BigInt(2), /*#__PURE__*/JSBI.BigInt(128));
 var PositionLibrary = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function PositionLibrary() {}
+
   // replicates the portions of Position#update required to compute unaccounted fees
   PositionLibrary.getTokensOwed = function getTokensOwed(feeGrowthInside0LastX128, feeGrowthInside1LastX128, liquidity, feeGrowthInside0X128, feeGrowthInside1X128) {
     var tokensOwed0 = JSBI.divide(JSBI.multiply(subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128), liquidity), Q128);
@@ -987,22 +1024,23 @@ var PositionLibrary = /*#__PURE__*/function () {
   return PositionLibrary;
 }();
 
-/**
- * Returns a price object corresponding to the input tick and the base/quote token
- * Inputs must be tokens because the address order is used to interpret the price represented by the tick
- * @param baseToken the base token of the price
- * @param quoteToken the quote token of the price
- * @param tick the tick for which to return the price
+/**
+ * Returns a price object corresponding to the input tick and the base/quote token
+ * Inputs must be tokens because the address order is used to interpret the price represented by the tick
+ * @param baseToken the base token of the price
+ * @param quoteToken the quote token of the price
+ * @param tick the tick for which to return the price
  */
 function tickToPrice(baseToken, quoteToken, tick) {
   var sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
   var ratioX192 = JSBI.multiply(sqrtRatioX96, sqrtRatioX96);
   return baseToken.sortsBefore(quoteToken) ? new sdkCore.Price(baseToken, quoteToken, Q192, ratioX192) : new sdkCore.Price(baseToken, quoteToken, ratioX192, Q192);
 }
-/**
- * Returns the first tick for which the given price is greater than or equal to the tick price
- * @param price for which to return the closest tick that represents a price less than or equal to the input price,
- * i.e. the price of the returned tick is less than or equal to the input price
+
+/**
+ * Returns the first tick for which the given price is greater than or equal to the tick price
+ * @param price for which to return the closest tick that represents a price less than or equal to the input price,
+ * i.e. the price of the returned tick is less than or equal to the input price
  */
 function priceToClosestTick(price) {
   var sorted = price.baseCurrency.sortsBefore(price.quoteCurrency);
@@ -1031,8 +1069,8 @@ function subIn256(x, y) {
   }
 }
 var TickLibrary = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function TickLibrary() {}
   TickLibrary.getFeeGrowthInside = function getFeeGrowthInside(feeGrowthOutsideLower, feeGrowthOutsideUpper, tickLower, tickUpper, tickCurrent, feeGrowthGlobal0X128, feeGrowthGlobal1X128) {
@@ -1063,17 +1101,21 @@ var Tick = function Tick(_ref) {
   var index = _ref.index,
     liquidityGross = _ref.liquidityGross,
     liquidityNet = _ref.liquidityNet;
+  this.index = void 0;
+  this.liquidityGross = void 0;
+  this.liquidityNet = void 0;
   !(index >= TickMath.MIN_TICK && index <= TickMath.MAX_TICK) ?  invariant(false, 'TICK')  : void 0;
   this.index = index;
   this.liquidityGross = JSBI.BigInt(liquidityGross);
   this.liquidityNet = JSBI.BigInt(liquidityNet);
 };
 
-/**
- * A data provider for ticks that is backed by an in-memory array of ticks.
+/**
+ * A data provider for ticks that is backed by an in-memory array of ticks.
  */
 var TickListDataProvider = /*#__PURE__*/function () {
   function TickListDataProvider(ticks, tickSpacing) {
+    this.ticks = void 0;
     var ticksMapped = ticks.map(function (t) {
       return t instanceof Tick ? t : new Tick(t);
     });
@@ -1112,32 +1154,43 @@ var TickListDataProvider = /*#__PURE__*/function () {
   return TickListDataProvider;
 }();
 
-/**
- * By default, pools will not allow operations that require ticks.
+/**
+ * By default, pools will not allow operations that require ticks.
  */
 var NO_TICK_DATA_PROVIDER_DEFAULT = /*#__PURE__*/new NoTickDataProvider();
-/**
- * Represents a V3 pool
+
+/**
+ * Represents a V3 pool
  */
 var Pool = /*#__PURE__*/function () {
-  /**
-   * 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
+  /**
+   * 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
    */
   function Pool(tokenA, tokenB, fee, sqrtRatioX96, liquidity, tickCurrent, ticks) {
     if (ticks === void 0) {
       ticks = NO_TICK_DATA_PROVIDER_DEFAULT;
     }
+    this.token0 = void 0;
+    this.token1 = void 0;
+    this.fee = void 0;
+    this.sqrtRatioX96 = void 0;
+    this.liquidity = void 0;
+    this.tickCurrent = void 0;
+    this.tickDataProvider = void 0;
+    this._token0Price = void 0;
+    this._token1Price = void 0;
     !(Number.isInteger(fee) && fee < 1000000) ?  invariant(false, 'FEE')  : void 0;
     var tickCurrentSqrtRatioX96 = TickMath.getSqrtRatioAtTick(tickCurrent);
     var nextTickSqrtRatioX96 = TickMath.getSqrtRatioAtTick(tickCurrent + 1);
-    !(JSBI.greaterThanOrEqual(JSBI.BigInt(sqrtRatioX96), tickCurrentSqrtRatioX96) && JSBI.lessThanOrEqual(JSBI.BigInt(sqrtRatioX96), nextTickSqrtRatioX96)) ?  invariant(false, 'PRICE_BOUNDS')  : void 0;
+    !(JSBI.greaterThanOrEqual(JSBI.BigInt(sqrtRatioX96), tickCurrentSqrtRatioX96) && JSBI.lessThanOrEqual(JSBI.BigInt(sqrtRatioX96), nextTickSqrtRatioX96)) ?  invariant(false, 'PRICE_BOUNDS')  : void 0 // always create a copy of the list since we want the pool's tick list to be immutable
+;
     var _ref = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
     this.token0 = _ref[0];
     this.token1 = _ref[1];
@@ -1147,6 +1200,12 @@ var Pool = /*#__PURE__*/function () {
     this.tickCurrent = tickCurrent;
     this.tickDataProvider = Array.isArray(ticks) ? new TickListDataProvider(ticks, TICK_SPACINGS[fee]) : 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
+   */
   Pool.getAddress = function getAddress(tokenA, tokenB, fee, initCodeHashManualOverride, factoryAddressOverride) {
     return computePoolAddress({
       factoryAddress: factoryAddressOverride != null ? factoryAddressOverride : FACTORY_ADDRESS,
@@ -1155,36 +1214,33 @@ var Pool = /*#__PURE__*/function () {
       tokenB: tokenB,
       initCodeHashManualOverride: initCodeHashManualOverride
     });
-  }
-  /**
-   * 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
-   */;
+  };
   var _proto = Pool.prototype;
   _proto.involvesToken = function 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
+
+  /**
+   * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
    */;
-  /**
-   * 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.
+  /**
+   * 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.
    */
   _proto.priceOf = function priceOf(token) {
     !this.involvesToken(token) ?  invariant(false, 'TOKEN')  : void 0;
     return token.equals(this.token0) ? this.token0Price : this.token1Price;
   }
-  /**
-   * Returns the chain ID of the tokens in the pool.
+
+  /**
+   * Returns the chain ID of the tokens in the pool.
    */;
-  /**
-   * 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
+  /**
+   * 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
    */
   _proto.getOutputAmount =
   /*#__PURE__*/
@@ -1214,11 +1270,11 @@ var Pool = /*#__PURE__*/function () {
     }
     return getOutputAmount;
   }()
-  /**
-   * 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
+  /**
+   * 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
    */
 ;
   _proto.getInputAmount =
@@ -1249,15 +1305,15 @@ var Pool = /*#__PURE__*/function () {
     }
     return getInputAmount;
   }()
-  /**
-   * 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
+  /**
+   * 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
    */
 ;
   _proto.swap =
@@ -1282,8 +1338,9 @@ var Pool = /*#__PURE__*/function () {
       var _this$_token0Price;
       return (_this$_token0Price = this._token0Price) != null ? _this$_token0Price : this._token0Price = new sdkCore.Price(this.token0, this.token1, Q192, JSBI.multiply(this.sqrtRatioX96, this.sqrtRatioX96));
     }
-    /**
-     * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+
+    /**
+     * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
      */
   }, {
     key: "token1Price",
@@ -1304,22 +1361,26 @@ var Pool = /*#__PURE__*/function () {
   }]);
 }();
 
-/**
- * Represents a position on a Uniswap V3 Pool
+/**
+ * Represents a position on a Uniswap V3 Pool
  */
 var Position = /*#__PURE__*/function () {
-  /**
-   * 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
+  /**
+   * 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
    */
   function Position(_ref) {
     var pool = _ref.pool,
       liquidity = _ref.liquidity,
       tickLower = _ref.tickLower,
       tickUpper = _ref.tickUpper;
+    this.pool = void 0;
+    this.tickLower = void 0;
+    this.tickUpper = void 0;
+    this.liquidity = void 0;
     // cached resuts for the getters
     this._token0Amount = null;
     this._token1Amount = null;
@@ -1332,14 +1393,15 @@ var Position = /*#__PURE__*/function () {
     this.tickUpper = tickUpper;
     this.liquidity = JSBI.BigInt(liquidity);
   }
-  /**
-   * Returns the price of token0 at the lower tick
+
+  /**
+   * Returns the price of token0 at the lower tick
    */
   var _proto = Position.prototype;
-  /**
-   * 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 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
    */
   _proto.ratiosAfterSlippage = function ratiosAfterSlippage(slippageTolerance) {
     var priceLower = this.pool.token0Price.asFraction.multiply(new sdkCore.Percent(1).subtract(slippageTolerance));
@@ -1357,28 +1419,33 @@ var Position = /*#__PURE__*/function () {
       sqrtRatioX96Upper: sqrtRatioX96Upper
     };
   }
-  /**
-   * 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
+
+  /**
+   * 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
    */;
   _proto.mintAmountsWithSlippage = function mintAmountsWithSlippage(slippageTolerance) {
     // get lower/upper prices
     var _this$ratiosAfterSlip = this.ratiosAfterSlippage(slippageTolerance),
       sqrtRatioX96Upper = _this$ratiosAfterSlip.sqrtRatioX96Upper,
       sqrtRatioX96Lower = _this$ratiosAfterSlip.sqrtRatioX96Lower;
+
     // construct counterfactual pools
     var poolLower = new Pool(this.pool.token0, this.pool.token1, this.pool.fee, sqrtRatioX96Lower, 0 /* liquidity doesn't matter */, TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower));
     var poolUpper = new Pool(this.pool.token0, this.pool.token1, this.pool.fee, sqrtRatioX96Upper, 0 /* liquidity doesn't matter */, TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper));
+
     // because the router is imprecise, we need to calculate the position that will be created (assuming no slippage)
     var positionThatWillBeCreated = Position.fromAmounts(_extends({
       pool: this.pool,
       tickLower: this.tickLower,
       tickUpper: this.tickUpper
     }, this.mintAmounts, {
+      // the mint amounts are what will be passed as calldata
       useFullPrecision: false
     }));
+
     // we want the smaller amounts...
     // ...which occurs at the upper price for amount0...
     var amount0 = new Position({
@@ -1399,20 +1466,23 @@ var Position = /*#__PURE__*/function () {
       amount1: amount1
     };
   }
-  /**
-   * 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
+
+  /**
+   * 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
    */;
   _proto.burnAmountsWithSlippage = function burnAmountsWithSlippage(slippageTolerance) {
     // get lower/upper prices
     var _this$ratiosAfterSlip2 = this.ratiosAfterSlippage(slippageTolerance),
       sqrtRatioX96Upper = _this$ratiosAfterSlip2.sqrtRatioX96Upper,
       sqrtRatioX96Lower = _this$ratiosAfterSlip2.sqrtRatioX96Lower;
+
     // construct counterfactual pools
     var poolLower = new Pool(this.pool.token0, this.pool.token1, this.pool.fee, sqrtRatioX96Lower, 0 /* liquidity doesn't matter */, TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower));
     var poolUpper = new Pool(this.pool.token0, this.pool.token1, this.pool.fee, sqrtRatioX96Upper, 0 /* liquidity doesn't matter */, TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper));
+
     // we want the smaller amounts...
     // ...which occurs at the upper price for amount0...
     var amount0 = new Position({
@@ -1433,21 +1503,22 @@ var Position = /*#__PURE__*/function () {
       amount1: amount1.quotient
     };
   }
-  /**
-   * 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
+
+  /**
+   * 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
    */;
-  /**
-   * 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
+  /**
+   * 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
    */
   Position.fromAmounts = function fromAmounts(_ref2) {
     var pool = _ref2.pool,
@@ -1465,15 +1536,16 @@ var Position = /*#__PURE__*/function () {
       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
+
+  /**
+   * 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
    */;
   Position.fromAmount0 = function fromAmount0(_ref3) {
     var pool = _ref3.pool,
@@ -1490,13 +1562,14 @@ var Position = /*#__PURE__*/function () {
       useFullPrecision: 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
+
+  /**
+   * 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
    */;
   Position.fromAmount1 = function fromAmount1(_ref4) {
     var pool = _ref4.pool,
@@ -1518,16 +1591,18 @@ var Position = /*#__PURE__*/function () {
     get: function get() {
       return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower);
     }
-    /**
-     * Returns the price of token0 at the upper tick
+
+    /**
+     * Returns the price of token0 at the upper tick
      */
   }, {
     key: "token0PriceUpper",
     get: function get() {
       return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper);
     }
-    /**
-     * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+
+    /**
+     * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
      */
   }, {
     key: "amount0",
@@ -1543,8 +1618,9 @@ var Position = /*#__PURE__*/function () {
       }
       return this._token0Amount;
     }
-    /**
-     * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+
+    /**
+     * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
      */
   }, {
     key: "amount1",
@@ -1586,19 +1662,23 @@ var Position = /*#__PURE__*/function () {
   }]);
 }();
 
-/**
- * Represents a list of pools through which a swap can occur
- * @template TInput The input token
- * @template TOutput The output token
+/**
+ * Represents a list of pools through which a swap can occur
+ * @template TInput The input token
+ * @template TOutput The output token
  */
 var Route = /*#__PURE__*/function () {
-  /**
-   * 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
+  /**
+   * 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
    */
   function Route(pools, input, output) {
+    this.pools = void 0;
+    this.tokenPath = void 0;
+    this.input = void 0;
+    this.output = void 0;
     this._midPrice = null;
     !(pools.length > 0) ?  invariant(false, 'POOLS')  : void 0;
     var chainId = pools[0].chainId;
@@ -1609,8 +1689,9 @@ var Route = /*#__PURE__*/function () {
     var wrappedInput = input.wrapped;
     !pools[0].involvesToken(wrappedInput) ?  invariant(false, 'INPUT')  : void 0;
     !pools[pools.length - 1].involvesToken(output.wrapped) ?  invariant(false, 'OUTPUT')  : void 0;
-    /**
-     * Normalizes token0-token1 order and selects the next token/fee step to add to the path
+
+    /**
+     * Normalizes token0-token1 order and selects the next token/fee step to add to the path
      * */
     var tokenPath = [wrappedInput];
     for (var _iterator = _createForOfIteratorHelperLoose(pools.entries()), _step; !(_step = _iterator()).done;) {
@@ -1632,8 +1713,9 @@ var Route = /*#__PURE__*/function () {
     get: function get() {
       return this.pools[0].chainId;
     }
-    /**
-     * Returns the mid price of the route
+
+    /**
+     * Returns the mid price of the route
      */
   }, {
     key: "midPrice",
@@ -1661,14 +1743,14 @@ var Route = /*#__PURE__*/function () {
   }]);
 }();
 
-/**
- * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
- * @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 trade type, either exact input or exact output
- * @param a The first trade to compare
- * @param b The second trade to compare
- * @returns A sorted ordering for two neighboring elements in a trade array
+/**
+ * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
+ * @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 trade type, either exact input or exact output
+ * @param a The first trade to compare
+ * @param b The second trade to compare
+ * @returns A sorted ordering for two neighboring elements in a trade array
  */
 function tradeComparator(a, b) {
   // must have same input and output token for comparison
@@ -1700,27 +1782,56 @@ function tradeComparator(a, b) {
     }
   }
 }
-/**
- * Represents a trade executed against a set of routes where some percentage of the input is
- * split across each route.
- *
- * Each route has its own set of pools. Pools can not be re-used across routes.
- *
- * Does not account for slippage, i.e., changes in price environment that can occur between
- * the time the trade is submitted and when it is executed.
- * @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 trade type, either exact input or exact output
+/**
+ * Represents a trade executed against a set of routes where some percentage of the input is
+ * split across each route.
+ *
+ * Each route has its own set of pools. Pools can not be re-used across routes.
+ *
+ * Does not account for slippage, i.e., changes in price environment that can occur between
+ * the time the trade is submitted and when it is executed.
+ * @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 trade type, either exact input or exact output
  */
 var Trade = /*#__PURE__*/function () {
-  /**
-   * Construct a trade by passing in the pre-computed property values
-   * @param routes The routes through which the trade occurs
-   * @param tradeType The type of trade, exact input or exact output
+  /**
+   * Construct a trade by passing in the pre-computed property values
+   * @param routes The routes through which the trade occurs
+   * @param tradeType The type of trade, exact input or exact output
    */
   function Trade(_ref) {
     var routes = _ref.routes,
       tradeType = _ref.tradeType;
+    /**
+     * The swaps of the trade, i.e. which routes and how much is swapped in each that
+     * make up the trade.
+     */
+    this.swaps = void 0;
+    /**
+     * The type of the trade, either exact in or exact out.
+     */
+    this.tradeType = void 0;
+    /**
+     * The cached result of the input amount computation
+     * @private
+     */
+    this._inputAmount = void 0;
+    /**
+     * The cached result of the output amount computation
+     * @private
+     */
+    this._outputAmount = void 0;
+    /**
+     * The cached result of the computed execution price
+     * @private
+     */
+    this._executionPrice = void 0;
+    /**
+     * The cached result of the price impact computation
+     * @private
+     */
+    this._priceImpact = void 0;
     var inputCurrency = routes[0].inputAmount.currency;
     var outputCurrency = routes[0].outputAmount.currency;
     !routes.every(function (_ref2) {
@@ -1749,20 +1860,19 @@ var Trade = /*#__PURE__*/function () {
     this.swaps = routes;
     this.tradeType = tradeType;
   }
-  /**
-   * @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 the minimum amount that must be received from this trade for the given slippage tolerance
+   * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+   * @returns The amount out
    */
-  /**
-   * 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
+  /**
+   * 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
    */
   Trade.exactIn =
   /*#__PURE__*/
@@ -1780,13 +1890,13 @@ var Trade = /*#__PURE__*/function () {
     }
     return exactIn;
   }()
-  /**
-   * 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
+  /**
+   * 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
    */
 ;
   Trade.exactOut =
@@ -1805,15 +1915,15 @@ var Trade = /*#__PURE__*/function () {
     }
     return exactOut;
   }()
-  /**
-   * 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
+  /**
+   * 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
    */
 ;
   Trade.fromRoute =
@@ -1893,15 +2003,15 @@ var Trade = /*#__PURE__*/function () {
     }
     return fromRoute;
   }()
-  /**
-   * Constructs a trade from routes by simulating swaps
-   *
-   * @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 routes the routes to swap through and how much of the amount should be routed through each
-   * @param tradeType whether the trade is an exact input or exact output swap
-   * @returns The trade
+  /**
+   * Constructs a trade from routes by simulating swaps
+   *
+   * @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 routes the routes to swap through and how much of the amount should be routed through each
+   * @param tradeType whether the trade is an exact input or exact output swap
+   * @returns The trade
    */
 ;
   Trade.fromRoutes =
@@ -1996,14 +2106,14 @@ var Trade = /*#__PURE__*/function () {
     }
     return fromRoutes;
   }()
-  /**
-   * Creates a trade without computing the result of swapping through the route. Useful when you have simulated the trade
-   * elsewhere and do not have any tick data
-   * @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 constructorArguments The arguments passed to the trade constructor
-   * @returns The unchecked trade
+  /**
+   * Creates a trade without computing the result of swapping through the route. Useful when you have simulated the trade
+   * elsewhere and do not have any tick data
+   * @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 constructorArguments The arguments passed to the trade constructor
+   * @returns The unchecked trade
    */
 ;
   Trade.createUncheckedTrade = function createUncheckedTrade(constructorArguments) {
@@ -2015,23 +2125,19 @@ var Trade = /*#__PURE__*/function () {
       }]
     }));
   }
-  /**
-   * Creates a trade without computing the result of swapping through the routes. Useful when you have simulated the trade
-   * elsewhere and do not have any tick data
-   * @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 constructorArguments The arguments passed to the trade constructor
-   * @returns The unchecked trade
+
+  /**
+   * Creates a trade without computing the result of swapping through the routes. Useful when you have simulated the trade
+   * elsewhere and do not have any tick data
+   * @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 constructorArguments The arguments passed to the trade constructor
+   * @returns The unchecked trade
    */;
   Trade.createUncheckedTradeWithMultipleRoutes = function createUncheckedTradeWithMultipleRoutes(constructorArguments) {
     return new Trade(constructorArguments);
-  }
-  /**
-   * Get the minimum amount that must be received from this trade for the given slippage tolerance
-   * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
-   * @returns The amount out
-   */;
+  };
   var _proto = Trade.prototype;
   _proto.minimumAmountOut = function minimumAmountOut(slippageTolerance, amountOut) {
     if (amountOut === void 0) {
@@ -2045,10 +2151,11 @@ var Trade = /*#__PURE__*/function () {
       return sdkCore.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
+
+  /**
+   * 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
    */;
   _proto.maximumAmountIn = function maximumAmountIn(slippageTolerance, amountIn) {
     if (amountIn === void 0) {
@@ -2062,28 +2169,30 @@ var Trade = /*#__PURE__*/function () {
       return sdkCore.CurrencyAmount.fromRawAmount(amountIn.currency, slippageAdjustedAmountIn);
     }
   }
-  /**
-   * Return the execution price after accounting for slippage tolerance
-   * @param slippageTolerance the allowed tolerated slippage
-   * @returns The execution price
+
+  /**
+   * Return the execution price after accounting for slippage tolerance
+   * @param slippageTolerance the allowed tolerated slippage
+   * @returns The execution price
    */;
   _proto.worstExecutionPrice = function worstExecutionPrice(slippageTolerance) {
     return new sdkCore.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
+
+  /**
+   * 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
    */;
   Trade.bestTradeExactIn =
   /*#__PURE__*/
@@ -2180,21 +2289,21 @@ var Trade = /*#__PURE__*/function () {
     }
     return bestTradeExactIn;
   }()
-  /**
-   * 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
+  /**
+   * 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
    */
 ;
   Trade.bestTradeExactOut =
@@ -2294,16 +2403,25 @@ var Trade = /*#__PURE__*/function () {
   }();
   return _createClass(Trade, [{
     key: "route",
-    get: function get() {
+    get:
+    /**
+     * @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.
+     */
+    function get() {
       !(this.swaps.length === 1) ?  invariant(false, 'MULTIPLE_ROUTES')  : void 0;
       return this.swaps[0].route;
     }
-    /**
-     * The input amount for the trade assuming no slippage.
-     */
   }, {
     key: "inputAmount",
-    get: function get() {
+    get:
+    /**
+     * The input amount for the trade assuming no slippage.
+     */
+    function get() {
       if (this._inputAmount) {
         return this._inputAmount;
       }
@@ -2317,12 +2435,13 @@ var Trade = /*#__PURE__*/function () {
       this._inputAmount = totalInputFromRoutes;
       return this._inputAmount;
     }
-    /**
-     * The output amount for the trade assuming no slippage.
-     */
   }, {
     key: "outputAmount",
-    get: function get() {
+    get:
+    /**
+     * The output amount for the trade assuming no slippage.
+     */
+    function get() {
       if (this._outputAmount) {
         return this._outputAmount;
       }
@@ -2336,21 +2455,23 @@ var Trade = /*#__PURE__*/function () {
       this._outputAmount = totalOutputFromRoutes;
       return this._outputAmount;
     }
-    /**
-     * The price expressed in terms of output amount/input amount.
-     */
   }, {
     key: "executionPrice",
-    get: function get() {
+    get:
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    function get() {
       var _this$_executionPrice;
       return (_this$_executionPrice = this._executionPrice) != null ? _this$_executionPrice : this._executionPrice = new sdkCore.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
-     */
   }, {
     key: "priceImpact",
-    get: function get() {
+    get:
+    /**
+     * Returns the percent difference between the route's mid price and the price impact
+     */
+    function get() {
       if (this._priceImpact) {
         return this._priceImpact;
       }
@@ -2370,8 +2491,8 @@ var Trade = /*#__PURE__*/function () {
 }();
 
 var Multicall = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function Multicall() {}
   Multicall.encodeMulticall = function encodeMulticall(calldatas) {
@@ -2388,8 +2509,8 @@ function isAllowedPermit(permitOptions) {
   return 'nonce' in permitOptions;
 }
 var SelfPermit = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function SelfPermit() {}
   SelfPermit.encodePermit = function encodePermit(token, options) {
@@ -2400,8 +2521,8 @@ var SelfPermit = /*#__PURE__*/function () {
 SelfPermit.INTERFACE = /*#__PURE__*/new abi.Interface(ISelfPermit.abi);
 
 var Payments = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function Payments() {}
   Payments.encodeFeeBips = function encodeFeeBips(fee) {
@@ -2436,15 +2557,25 @@ Payments.INTERFACE = /*#__PURE__*/new abi.Interface(IPeripheryPaymentsWithFee.ab
 
 var _excluded = ["expectedCurrencyOwed0", "expectedCurrencyOwed1"];
 var MaxUint128 = /*#__PURE__*/toHex(/*#__PURE__*/JSBI.subtract(/*#__PURE__*/JSBI.exponentiate(/*#__PURE__*/JSBI.BigInt(2), /*#__PURE__*/JSBI.BigInt(128)), /*#__PURE__*/JSBI.BigInt(1)));
+
+/**
+ * Options for producing the calldata to add liquidity.
+ */
+
 // type guard
 function isMint(options) {
   return Object.keys(options).some(function (k) {
     return k === 'recipient';
   });
 }
+
+/**
+ * Options for producing the calldata to exit a position.
+ */
+
 var NonfungiblePositionManager = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function NonfungiblePositionManager() {}
   NonfungiblePositionManager.encodeCreate = function encodeCreate(pool) {
@@ -2459,19 +2590,23 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
   NonfungiblePositionManager.addCallParameters = function addCallParameters(position, options) {
     !JSBI.greaterThan(position.liquidity, ZERO) ?  invariant(false, 'ZERO_LIQUIDITY')  : void 0;
     var calldatas = [];
+
     // get amounts
     var _position$mintAmounts = position.mintAmounts,
       amount0Desired = _position$mintAmounts.amount0,
       amount1Desired = _position$mintAmounts.amount1;
+
     // adjust for slippage
     var minimumAmounts = position.mintAmountsWithSlippage(options.slippageTolerance);
     var amount0Min = toHex(minimumAmounts.amount0);
     var amount1Min = toHex(minimumAmounts.amount1);
     var deadline = toHex(options.deadline);
+
     // create pool if needed
     if (isMint(options) && options.createPool) {
       calldatas.push(this.encodeCreate(position.pool));
     }
+
     // permits if necessary
     if (options.token0Permit) {
       calldatas.push(SelfPermit.encodePermit(position.pool.token0, options.token0Permit));
@@ -2479,6 +2614,7 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
     if (options.token1Permit) {
       calldatas.push(SelfPermit.encodePermit(position.pool.token1, options.token1Permit));
     }
+
     // mint
     if (isMint(options)) {
       var recipient = sdkCore.validateAndParseAddress(options.recipient);
@@ -2511,6 +2647,7 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
       var wrapped = options.useNative.wrapped;
       !(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped)) ?  invariant(false, 'NO_WETH')  : void 0;
       var wrappedValue = position.pool.token0.equals(wrapped) ? amount0Desired : amount1Desired;
+
       // we only need to refund if we're actually sending ETH
       if (JSBI.greaterThan(wrappedValue, ZERO)) {
         calldatas.push(Payments.encodeRefundETH());
@@ -2527,6 +2664,7 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
     var tokenId = toHex(options.tokenId);
     var involvesETH = options.expectedCurrencyOwed0.currency.isNative || options.expectedCurrencyOwed1.currency.isNative;
     var recipient = sdkCore.validateAndParseAddress(options.recipient);
+
     // collect
     calldatas.push(NonfungiblePositionManager.INTERFACE.encodeFunctionData('collect', [{
       tokenId: tokenId,
@@ -2550,16 +2688,18 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
       value: toHex(0)
     };
   }
-  /**
-   * Produces the calldata for completely or partially exiting a position
-   * @param position The position to exit
-   * @param options Additional information necessary for generating the calldata
-   * @returns The call parameters
+
+  /**
+   * Produces the calldata for completely or partially exiting a position
+   * @param position The position to exit
+   * @param options Additional information necessary for generating the calldata
+   * @returns The call parameters
    */;
   NonfungiblePositionManager.removeCallParameters = function removeCallParameters(position, options) {
     var calldatas = [];
     var deadline = toHex(options.deadline);
     var tokenId = toHex(options.tokenId);
+
     // construct a partial position with a percentage of liquidity
     var partialPosition = new Position({
       pool: position.pool,
@@ -2568,6 +2708,7 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
       tickUpper: position.tickUpper
     });
     !JSBI.greaterThan(partialPosition.liquidity, ZERO) ?  invariant(false, 'ZERO_LIQUIDITY')  : void 0;
+
     // slippage-adjusted underlying amounts
     var _partialPosition$burn = partialPosition.burnAmountsWithSlippage(options.slippageTolerance),
       amount0Min = _partialPosition$burn.amount0,
@@ -2575,6 +2716,7 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
     if (options.permit) {
       calldatas.push(NonfungiblePositionManager.INTERFACE.encodeFunctionData('permit', [sdkCore.validateAndParseAddress(options.permit.spender), tokenId, toHex(options.permit.deadline), options.permit.v, options.permit.r, options.permit.s]));
     }
+
     // remove liquidity
     calldatas.push(NonfungiblePositionManager.INTERFACE.encodeFunctionData('decreaseLiquidity', [{
       tokenId: tokenId,
@@ -2623,22 +2765,26 @@ var NonfungiblePositionManager = /*#__PURE__*/function () {
 }();
 NonfungiblePositionManager.INTERFACE = /*#__PURE__*/new abi.Interface(INonfungiblePositionManager.abi);
 
-/**
- * Represents the Uniswap V3 QuoterV1 contract with a method for returning the formatted
- * calldata needed to call the quoter contract.
+/**
+ * Optional arguments to send to the quoter.
+ */
+
+/**
+ * Represents the Uniswap V3 QuoterV1 contract with a method for returning the formatted
+ * calldata needed to call the quoter contract.
  */
 var SwapQuoter = /*#__PURE__*/function () {
   function SwapQuoter() {}
-  /**
-   * Produces the on-chain method name of the appropriate function within QuoterV2,
-   * and the relevant hex encoded parameters.
-   * @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 swap route, a list of pools through which a swap can occur
-   * @param amount The amount of the quote, either an amount in, or an amount out
-   * @param tradeType The trade type, either exact input or exact output
-   * @param options The optional params including price limit and Quoter contract switch
-   * @returns The formatted calldata
+  /**
+   * Produces the on-chain method name of the appropriate function within QuoterV2,
+   * and the relevant hex encoded parameters.
+   * @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 swap route, a list of pools through which a swap can occur
+   * @param amount The amount of the quote, either an amount in, or an amount out
+   * @param tradeType The trade type, either exact input or exact output
+   * @param options The optional params including price limit and Quoter contract switch
+   * @returns The formatted calldata
    */
   SwapQuoter.quoteCallParameters = function quoteCallParameters(route, amount, tradeType, options) {
     if (options === void 0) {
@@ -2681,13 +2827,25 @@ var SwapQuoter = /*#__PURE__*/function () {
 SwapQuoter.V1INTERFACE = /*#__PURE__*/new abi.Interface(IQuoter.abi);
 SwapQuoter.V2INTERFACE = /*#__PURE__*/new abi.Interface(IQuoterV2.abi);
 
+/**
+ * Represents a unique staking program.
+ */
+
+/**
+ * Options to specify when claiming rewards.
+ */
+
+/**
+ * Options to specify when withdrawing a position.
+ */
+
 var Staker = /*#__PURE__*/function () {
   function Staker() {}
-  /**
-   *  To claim rewards, must unstake and then claim.
-   * @param incentiveKey The unique identifier of a staking program.
-   * @param options Options for producing the calldata to claim. Can't claim unless you unstake.
-   * @returns The calldatas for 'unstakeToken' and 'claimReward'.
+  /**
+   *  To claim rewards, must unstake and then claim.
+   * @param incentiveKey The unique identifier of a staking program.
+   * @param options Options for producing the calldata to claim. Can't claim unless you unstake.
+   * @returns The calldatas for 'unstakeToken' and 'claimReward'.
    */
   Staker.encodeClaim = function encodeClaim(incentiveKey, options) {
     var _options$amount;
@@ -2698,14 +2856,15 @@ var Staker = /*#__PURE__*/function () {
     calldatas.push(Staker.INTERFACE.encodeFunctionData('claimReward', [incentiveKey.rewardToken.address, recipient, toHex(amount)]));
     return calldatas;
   }
-  /**
-   *
-   * Note:  A `tokenId` can be staked in many programs but to claim rewards and continue the program you must unstake, claim, and then restake.
-   * @param incentiveKeys An IncentiveKey or array of IncentiveKeys that `tokenId` is staked in.
-   * Input an array of IncentiveKeys to claim rewards for each program.
-   * @param options ClaimOptions to specify tokenId, recipient, and amount wanting to collect.
-   * Note that you can only specify one amount and one recipient across the various programs if you are collecting from multiple programs at once.
-   * @returns
+
+  /**
+   *
+   * Note:  A `tokenId` can be staked in many programs but to claim rewards and continue the program you must unstake, claim, and then restake.
+   * @param incentiveKeys An IncentiveKey or array of IncentiveKeys that `tokenId` is staked in.
+   * Input an array of IncentiveKeys to claim rewards for each program.
+   * @param options ClaimOptions to specify tokenId, recipient, and amount wanting to collect.
+   * Note that you can only specify one amount and one recipient across the various programs if you are collecting from multiple programs at once.
+   * @returns
    */;
   Staker.collectRewards = function collectRewards(incentiveKeys, options) {
     incentiveKeys = Array.isArray(incentiveKeys) ? incentiveKeys : [incentiveKeys];
@@ -2723,11 +2882,12 @@ var Staker = /*#__PURE__*/function () {
       value: toHex(0)
     };
   }
-  /**
-   *
-   * @param incentiveKeys A list of incentiveKeys to unstake from. Should include all incentiveKeys (unique staking programs) that `options.tokenId` is staked in.
-   * @param withdrawOptions Options for producing claim calldata and withdraw calldata. Can't withdraw without unstaking all programs for `tokenId`.
-   * @returns Calldata for unstaking, claiming, and withdrawing.
+
+  /**
+   *
+   * @param incentiveKeys A list of incentiveKeys to unstake from. Should include all incentiveKeys (unique staking programs) that `options.tokenId` is staked in.
+   * @param withdrawOptions Options for producing claim calldata and withdraw calldata. Can't withdraw without unstaking all programs for `tokenId`.
+   * @returns Calldata for unstaking, claiming, and withdrawing.
    */;
   Staker.withdrawToken = function withdrawToken(incentiveKeys, withdrawOptions) {
     var calldatas = [];
@@ -2748,10 +2908,11 @@ var Staker = /*#__PURE__*/function () {
       value: toHex(0)
     };
   }
-  /**
-   *
-   * @param incentiveKeys A single IncentiveKey or array of IncentiveKeys to be encoded and used in the data parameter in `safeTransferFrom`
-   * @returns An IncentiveKey as a string
+
+  /**
+   *
+   * @param incentiveKeys A single IncentiveKey or array of IncentiveKeys to be encoded and used in the data parameter in `safeTransferFrom`
+   * @returns An IncentiveKey as a string
    */;
   Staker.encodeDeposit = function encodeDeposit(incentiveKeys) {
     incentiveKeys = Array.isArray(incentiveKeys) ? incentiveKeys : [incentiveKeys];
@@ -2768,10 +2929,10 @@ var Staker = /*#__PURE__*/function () {
     }
     return data;
   }
-  /**
-   *
-   * @param incentiveKey An `IncentiveKey` which represents a unique staking program.
-   * @returns An encoded IncentiveKey to be read by ethers
+  /**
+   *
+   * @param incentiveKey An `IncentiveKey` which represents a unique staking program.
+   * @returns An encoded IncentiveKey to be read by ethers
    */;
   Staker._encodeIncentiveKey = function _encodeIncentiveKey(incentiveKey) {
     var _incentiveKey$pool = incentiveKey.pool,
@@ -2792,18 +2953,23 @@ var Staker = /*#__PURE__*/function () {
 Staker.INTERFACE = /*#__PURE__*/new abi.Interface(IUniswapV3Staker.abi);
 Staker.INCENTIVE_KEY_ABI = 'tuple(address rewardToken, address pool, uint256 startTime, uint256 endTime, address refundee)';
 
-/**
- * Represents the Uniswap V3 SwapRouter, and has static methods for helping execute trades.
+/**
+ * Options for producing the arguments to send calls to the router.
+ */
+
+/**
+ * Represents the Uniswap V3 SwapRouter, and has static methods for helping execute trades.
  */
 var SwapRouter = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function SwapRouter() {}
-  /**
-   * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
-   * @param trade to produce call parameters for
-   * @param options options for the call parameters
+
+  /**
+   * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+   * @param trade to produce call parameters for
+   * @param options options for the call parameters
    */
   SwapRouter.swapCallParameters = function swapCallParameters(trades, options) {
     if (!Array.isArray(trades)) {
@@ -2812,6 +2978,7 @@ var SwapRouter = /*#__PURE__*/function () {
     var sampleTrade = trades[0];
     var tokenIn = sampleTrade.inputAmount.currency.wrapped;
     var tokenOut = sampleTrade.outputAmount.currency.wrapped;
+
     // All trades should have the same starting and ending token.
     !trades.every(function (trade) {
       return trade.inputAmount.currency.wrapped.equals(tokenIn);
@@ -2825,6 +2992,7 @@ var SwapRouter = /*#__PURE__*/function () {
     var totalAmountOut = trades.reduce(function (sum, trade) {
       return sum.add(trade.minimumAmountOut(options.slippageTolerance));
     }, ZERO_OUT);
+
     // flag for whether a refund needs to happen
     var mustRefund = sampleTrade.inputAmount.currency.isNative && sampleTrade.tradeType === sdkCore.TradeType.EXACT_OUTPUT;
     var inputIsNative = sampleTrade.inputAmount.currency.isNative;
@@ -2834,6 +3002,7 @@ var SwapRouter = /*#__PURE__*/function () {
     var totalValue = inputIsNative ? trades.reduce(function (sum, trade) {
       return sum.add(trade.maximumAmountIn(options.slippageTolerance));
     }, ZERO_IN) : ZERO_IN;
+
     // encode permit if necessary
     if (options.inputTokenPermit) {
       !sampleTrade.inputAmount.currency.isToken ?  invariant(false, 'NON_TOKEN_PERMIT')  : void 0;
@@ -2850,6 +3019,7 @@ var SwapRouter = /*#__PURE__*/function () {
           outputAmount = _step2$value.outputAmount;
         var amountIn = toHex(trade.maximumAmountIn(options.slippageTolerance, inputAmount).quotient);
         var amountOut = toHex(trade.minimumAmountOut(options.slippageTolerance, outputAmount).quotient);
+
         // flag for whether the trade is single hop or not
         var singleHop = route.pools.length === 1;
         if (singleHop) {
@@ -2905,6 +3075,7 @@ var SwapRouter = /*#__PURE__*/function () {
         }
       }
     }
+
     // unwrap
     if (routerMustCustody) {
       if (!!options.fee) {
@@ -2917,6 +3088,7 @@ var SwapRouter = /*#__PURE__*/function () {
         calldatas.push(Payments.encodeUnwrapWETH9(totalAmountOut.quotient, recipient));
       }
     }
+
     // refund
     if (mustRefund) {
       calldatas.push(Payments.encodeRefundETH());
@@ -2933,6 +3105,7 @@ SwapRouter.INTERFACE = /*#__PURE__*/new abi.Interface(ISwapRouter.abi);
 exports.ADDRESS_ZERO = ADDRESS_ZERO;
 exports.FACTORY_ADDRESS = FACTORY_ADDRESS;
 exports.FACTORY_ADDRESS_BY_CHAIN_ID = FACTORY_ADDRESS_BY_CHAIN_ID;
+exports.FeeAmount = FeeAmount;
 exports.FullMath = FullMath;
 exports.LiquidityMath = LiquidityMath;
 exports.Multicall = Multicall;