@kayenfinance/v2-sdk 1.2.1 → 1.2.3

package/dist/v2-sdk.esm.js

@@ -6,8 +6,9 @@ import { keccak256, pack } from '@ethersproject/solidity';
 import invariant from 'tiny-invariant';
 
 var _FACTORY_ADDRESS_BY_C, _INIT_CODE_HASH_BY_CH;
-/**
- * @deprecated use FACTORY_ADDRESS_MAP instead
+
+/**
+ * @deprecated use FACTORY_ADDRESS_MAP instead
  */
 var FACTORY_ADDRESS = '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f';
 var FACTORY_ADDRESS_BY_CHAIN_ID = (_FACTORY_ADDRESS_BY_C = {}, _FACTORY_ADDRESS_BY_C[ChainId.CHILIZ] = '0xE2918AA38088878546c1A18F2F9b1BC83297fdD3', _FACTORY_ADDRESS_BY_C[ChainId.SPICY] = '0xfc1924E20d64AD4daA3A4947b4bAE6cDE77d2dBC', _FACTORY_ADDRESS_BY_C);
@@ -15,6 +16,7 @@ var FACTORY_ADDRESS_MAP = V2_FACTORY_ADDRESSES;
 var INIT_CODE_HASH = '0x4fb91ee014f2c198fe03fa69aa007f8e04f2fe96fe4444492a517fdec1063a17';
 var INIT_CODE_HASH_BY_CHAIN_ID = (_INIT_CODE_HASH_BY_CH = {}, _INIT_CODE_HASH_BY_CH[ChainId.CHILIZ] = '0x4fb91ee014f2c198fe03fa69aa007f8e04f2fe96fe4444492a517fdec1063a17', _INIT_CODE_HASH_BY_CH[ChainId.SPICY] = '0x4fb91ee014f2c198fe03fa69aa007f8e04f2fe96fe4444492a517fdec1063a17', _INIT_CODE_HASH_BY_CH);
 var MINIMUM_LIQUIDITY = /*#__PURE__*/JSBI.BigInt(1000);
+
 // exports for internal consumption
 var ZERO = /*#__PURE__*/JSBI.BigInt(0);
 var ONE = /*#__PURE__*/JSBI.BigInt(1);
@@ -139,9 +141,10 @@ function _wrapNativeSuper(t) {
 
 // see https://stackoverflow.com/a/41102306
 var CAN_SET_PROTOTYPE = 'setPrototypeOf' in Object;
-/**
- * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
- * obtained by sending any amount of input.
+
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
  */
 var InsufficientReservesError = /*#__PURE__*/function (_Error) {
   function InsufficientReservesError() {
@@ -155,9 +158,10 @@ var InsufficientReservesError = /*#__PURE__*/function (_Error) {
   _inheritsLoose(InsufficientReservesError, _Error);
   return InsufficientReservesError;
 }(/*#__PURE__*/_wrapNativeSuper(Error));
-/**
- * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
- * than the price of a single unit of output after fees.
+
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
  */
 var InsufficientInputAmountError = /*#__PURE__*/function (_Error2) {
   function InsufficientInputAmountError() {
@@ -183,11 +187,18 @@ var computePairAddress = function computePairAddress(_ref) {
 };
 var Pair = /*#__PURE__*/function () {
   function Pair(currencyAmountA, tokenAmountB) {
+    this.liquidityToken = void 0;
+    this.tokenAmounts = void 0;
     var tokenAmounts = currencyAmountA.currency.sortsBefore(tokenAmountB.currency) // does safety checks
     ? [currencyAmountA, tokenAmountB] : [tokenAmountB, currencyAmountA];
     this.liquidityToken = new Token(tokenAmounts[0].currency.chainId, Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency), 18, 'UNI-V2', 'Uniswap V2');
     this.tokenAmounts = tokenAmounts;
   }
+
+  /**
+   * Returns true if the token is either token0 or token1
+   * @param token to check
+   */
   Pair.getAddress = function getAddress(tokenA, tokenB) {
     var _FACTORY_ADDRESS_MAP$;
     var factoryAddress = (_FACTORY_ADDRESS_MAP$ = FACTORY_ADDRESS_MAP[tokenA.chainId]) != null ? _FACTORY_ADDRESS_MAP$ : FACTORY_ADDRESS;
@@ -196,92 +207,91 @@ var Pair = /*#__PURE__*/function () {
       tokenA: tokenA,
       tokenB: tokenB
     });
-  }
-  /**
-   * Returns true if the token is either token0 or token1
-   * @param token to check
-   */;
+  };
   var _proto = Pair.prototype;
   _proto.involvesToken = function involvesToken(token) {
     return token.equals(this.token0) || token.equals(this.token1);
   }
-  /**
-   * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0
+
+  /**
+   * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0
    */;
-  /**
-   * Return the price of the given token in terms of the other token in the pair.
-   * @param token token to return price of
+  /**
+   * Return the price of the given token in terms of the other token in the pair.
+   * @param token token to return price of
    */
   _proto.priceOf = function priceOf(token) {
     !this.involvesToken(token) ? process.env.NODE_ENV !== "production" ? invariant(false, 'TOKEN') : invariant(false) : void 0;
     return token.equals(this.token0) ? this.token0Price : this.token1Price;
   }
-  /**
-   * Returns the chain ID of the tokens in the pair.
+
+  /**
+   * Returns the chain ID of the tokens in the pair.
    */;
   _proto.reserveOf = function reserveOf(token) {
     !this.involvesToken(token) ? process.env.NODE_ENV !== "production" ? invariant(false, 'TOKEN') : invariant(false) : void 0;
     return token.equals(this.token0) ? this.reserve0 : this.reserve1;
   }
-  /**
-   * getAmountOut is the linear algebra of reserve ratio against amountIn:amountOut.
-   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000
-   * has the math deduction for the reserve calculation without fee-on-transfer fees.
-   *
-   * With fee-on-transfer tax, intuitively it's just:
-   * inputAmountWithFeeAndTax = 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
-   *                          = (1 - amountIn.sellFeesBips / 10000) * amountInWithFee
-   * where amountInWithFee is the amountIn after taking out the LP fees
-   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)
-   *
-   * But we are illustrating the math deduction below to ensure that's the case.
-   *
-   * before swap A * B = K where A = reserveIn B = reserveOut
-   *
-   * after swap A' * B' = K where only k is a constant value
-   *
-   * getAmountOut
-   *
-   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted
-   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)
-   * amountOut = (B - B') / (1 - amountOut.buyFeesBips / 10000) # where A' * B' still is k
-   *           = (B - K/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
-   *             /
-   *             (1 - amountOut.buyFeesBips / 10000)
-   *           = (B - AB/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
-   *             /
-   *             (1 - amountOut.buyFeesBips / 10000)
-   *           = ((BA + B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn - AB)/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
-   *             /
-   *             (1 - amountOut.buyFeesBips / 10000)
-   *           = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn / (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
-   *             /
-   *             (1 - amountOut.buyFeesBips / 10000)
-   * amountOut * (1 - amountOut.buyFeesBips / 10000) = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
-   *                                                    /
-   *                                                    (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
-   *
-   * outputAmountWithTax = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
-   *                       /
-   *                       (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
-   *                       = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn * 1000
-   *                       /
-   *                       ((A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn) * 1000)
-   *                     = (B * (1 - amountIn.sellFeesBips / 10000) 997 * * amountIn
-   *                       /
-   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * 997 * amountIn)
-   *                     = (B * (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)
-   *                       /
-   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)
-   *                     = (B * inputAmountWithFeeAndTax)
-   *                       /
-   *                       (1000 * A + inputAmountWithFeeAndTax)
-   *
-   * inputAmountWithFeeAndTax = (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee
-   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)
-   *
-   * @param inputAmount
-   * @param calculateFotFees
+
+  /**
+   * getAmountOut is the linear algebra of reserve ratio against amountIn:amountOut.
+   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000
+   * has the math deduction for the reserve calculation without fee-on-transfer fees.
+   *
+   * With fee-on-transfer tax, intuitively it's just:
+   * inputAmountWithFeeAndTax = 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
+   *                          = (1 - amountIn.sellFeesBips / 10000) * amountInWithFee
+   * where amountInWithFee is the amountIn after taking out the LP fees
+   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)
+   *
+   * But we are illustrating the math deduction below to ensure that's the case.
+   *
+   * before swap A * B = K where A = reserveIn B = reserveOut
+   *
+   * after swap A' * B' = K where only k is a constant value
+   *
+   * getAmountOut
+   *
+   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted
+   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)
+   * amountOut = (B - B') / (1 - amountOut.buyFeesBips / 10000) # where A' * B' still is k
+   *           = (B - K/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
+   *             /
+   *             (1 - amountOut.buyFeesBips / 10000)
+   *           = (B - AB/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
+   *             /
+   *             (1 - amountOut.buyFeesBips / 10000)
+   *           = ((BA + B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn - AB)/(A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn))
+   *             /
+   *             (1 - amountOut.buyFeesBips / 10000)
+   *           = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn / (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
+   *             /
+   *             (1 - amountOut.buyFeesBips / 10000)
+   * amountOut * (1 - amountOut.buyFeesBips / 10000) = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
+   *                                                    /
+   *                                                    (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
+   *
+   * outputAmountWithTax = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn
+   *                       /
+   *                       (A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn)
+   *                       = (B * 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn * 1000
+   *                       /
+   *                       ((A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn) * 1000)
+   *                     = (B * (1 - amountIn.sellFeesBips / 10000) 997 * * amountIn
+   *                       /
+   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * 997 * amountIn)
+   *                     = (B * (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)
+   *                       /
+   *                       (1000 * A + (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee)
+   *                     = (B * inputAmountWithFeeAndTax)
+   *                       /
+   *                       (1000 * A + inputAmountWithFeeAndTax)
+   *
+   * inputAmountWithFeeAndTax = (1 - amountIn.sellFeesBips / 10000) * inputAmountWithFee
+   * outputAmountWithTax = amountOut * (1 - amountOut.buyFeesBips / 10000)
+   *
+   * @param inputAmount
+   * @param calculateFotFees
    */;
   _proto.getOutputAmount = function getOutputAmount(inputAmount, calculateFotFees) {
     if (calculateFotFees === void 0) {
@@ -312,47 +322,48 @@ var Pair = /*#__PURE__*/function () {
     }
     return [outputAmountAfterTax, new Pair(inputReserve.add(inputAmountAfterTax), outputReserve.subtract(outputAmountAfterTax))];
   }
-  /**
-   * getAmountIn is the linear algebra of reserve ratio against amountIn:amountOut.
-   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000
-   * has the math deduction for the reserve calculation without fee-on-transfer fees.
-   *
-   * With fee-on-transfer fees, intuitively it's just:
-   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)
-   * inputAmountWithTax = amountIn / (1 - amountIn.sellFeesBips / 10000) / 0.997
-   *
-   * But we are illustrating the math deduction below to ensure that's the case.
-   *
-   * before swap A * B = K where A = reserveIn B = reserveOut
-   *
-   * after swap A' * B' = K where only k is a constant value
-   *
-   * getAmountIn
-   *
-   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)
-   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted
-   * amountIn = (A' - A) / (0.997 * (1 - amountIn.sellFeesBips / 10000))
-   *          = (K / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)
-   *            /
-   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
-   *          = (AB / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)
-   *            /
-   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
-   *          = ((AB - AB + A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
-   *            /
-   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
-   *          = ((A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
-   *            /
-   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
-   *          = ((A * 1000 * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
-   *            /
-   *            (997 * (1 - amountIn.sellFeesBips / 10000))
-   *
-   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)
-   * inputAmountWithTax = amountIn / (997 * (1 - amountIn.sellFeesBips / 10000))
-   *                    = (A * outputAmountWithTax * 1000) / ((B - outputAmountWithTax) * 997)
-   *
-   * @param outputAmount
+
+  /**
+   * getAmountIn is the linear algebra of reserve ratio against amountIn:amountOut.
+   * https://ethereum.stackexchange.com/questions/101629/what-is-math-for-uniswap-calculates-the-amountout-and-amountin-why-997-and-1000
+   * has the math deduction for the reserve calculation without fee-on-transfer fees.
+   *
+   * With fee-on-transfer fees, intuitively it's just:
+   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)
+   * inputAmountWithTax = amountIn / (1 - amountIn.sellFeesBips / 10000) / 0.997
+   *
+   * But we are illustrating the math deduction below to ensure that's the case.
+   *
+   * before swap A * B = K where A = reserveIn B = reserveOut
+   *
+   * after swap A' * B' = K where only k is a constant value
+   *
+   * getAmountIn
+   *
+   * B' = B - amountOut * (1 - amountOut.buyFeesBips / 10000)
+   * A' = A + 0.997 * (1 - amountIn.sellFeesBips / 10000) * amountIn # here 0.3% is deducted
+   * amountIn = (A' - A) / (0.997 * (1 - amountIn.sellFeesBips / 10000))
+   *          = (K / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)
+   *            /
+   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+   *          = (AB / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)) - A)
+   *            /
+   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+   *          = ((AB - AB + A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
+   *            /
+   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+   *          = ((A * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
+   *            /
+   *            (0.997 * (1 - amountIn.sellFeesBips / 10000))
+   *          = ((A * 1000 * amountOut / (1 - amountOut.buyFeesBips / 10000)) / (B - amountOut / (1 - amountOut.buyFeesBips / 10000)))
+   *            /
+   *            (997 * (1 - amountIn.sellFeesBips / 10000))
+   *
+   * outputAmountWithTax = amountOut / (1 - amountOut.buyFeesBips / 10000)
+   * inputAmountWithTax = amountIn / (997 * (1 - amountIn.sellFeesBips / 10000))
+   *                    = (A * outputAmountWithTax * 1000) / ((B - outputAmountWithTax) * 997)
+   *
+   * @param outputAmount
    */;
   _proto.getInputAmount = function getInputAmount(outputAmount, calculateFotFees) {
     if (calculateFotFees === void 0) {
@@ -447,8 +458,9 @@ var Pair = /*#__PURE__*/function () {
       var result = this.tokenAmounts[1].divide(this.tokenAmounts[0]);
       return new Price(this.token0, this.token1, result.denominator, result.numerator);
     }
-    /**
-     * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
+
+    /**
+     * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
      */
   }, {
     key: "token1Price",
@@ -486,6 +498,10 @@ var Pair = /*#__PURE__*/function () {
 
 var Route = /*#__PURE__*/function () {
   function Route(pairs, input, output) {
+    this.pairs = void 0;
+    this.path = void 0;
+    this.input = void 0;
+    this.output = void 0;
     this._midPrice = null;
     !(pairs.length > 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'PAIRS') : invariant(false) : void 0;
     var chainId = pairs[0].chainId;
@@ -534,6 +550,8 @@ var Route = /*#__PURE__*/function () {
   }]);
 }();
 
+// minimal interface so the input output comparator may be shared across types
+
 // comparator function that allows sorting trades by their output amounts, in decreasing order, and then input amounts
 // in increasing order. i.e. the best trades have the most outputs for the least inputs and are sorted first
 function inputOutputComparator(a, b) {
@@ -559,27 +577,54 @@ function inputOutputComparator(a, b) {
     }
   }
 }
+
 // extension of the input output comparator that also considers other dimensions of the trade in ranking them
 function tradeComparator(a, b) {
   var ioComp = inputOutputComparator(a, b);
   if (ioComp !== 0) {
     return ioComp;
   }
+
   // consider lowest slippage next, since these are less likely to fail
   if (a.priceImpact.lessThan(b.priceImpact)) {
     return -1;
   } else if (a.priceImpact.greaterThan(b.priceImpact)) {
     return 1;
   }
+
   // finally consider the number of hops since each hop costs gas
   return a.route.path.length - b.route.path.length;
 }
-/**
- * Represents a trade executed against a list of pairs.
- * Does not account for slippage, i.e. trades that front run this trade and move the price.
+/**
+ * Represents a trade executed against a list of pairs.
+ * Does not account for slippage, i.e. trades that front run this trade and move the price.
  */
 var Trade = /*#__PURE__*/function () {
   function Trade(route, amount, tradeType) {
+    /**
+     * The route of the trade, i.e. which pairs the trade goes through and the input/output currencies.
+     */
+    this.route = void 0;
+    /**
+     * The type of the trade, either exact in or exact out.
+     */
+    this.tradeType = void 0;
+    /**
+     * The input amount for the trade assuming no slippage.
+     */
+    this.inputAmount = void 0;
+    /**
+     * The output amount for the trade assuming no slippage.
+     */
+    this.outputAmount = void 0;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    this.executionPrice = void 0;
+    /**
+     * The percent difference between the mid price before the trade and the trade execution price.
+     */
+    this.priceImpact = void 0;
     this.route = route;
     this.tradeType = tradeType;
     var tokenAmounts = new Array(route.path.length);
@@ -609,26 +654,28 @@ var Trade = /*#__PURE__*/function () {
     this.executionPrice = new Price(this.inputAmount.currency, this.outputAmount.currency, this.inputAmount.quotient, this.outputAmount.quotient);
     this.priceImpact = computePriceImpact(route.midPrice, this.inputAmount, this.outputAmount);
   }
-  /**
-   * Constructs an exact in trade with the given amount in and route
-   * @param route route of the exact in trade
-   * @param amountIn the amount being passed in
+
+  /**
+   * Get the minimum amount that must be received from this trade for the given slippage tolerance
+   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
+   */
+  /**
+   * Constructs an exact in trade with the given amount in and route
+   * @param route route of the exact in trade
+   * @param amountIn the amount being passed in
    */
   Trade.exactIn = function exactIn(route, amountIn) {
     return new Trade(route, amountIn, TradeType.EXACT_INPUT);
   }
-  /**
-   * Constructs an exact out trade with the given amount out and route
-   * @param route route of the exact out trade
-   * @param amountOut the amount returned by the trade
+
+  /**
+   * Constructs an exact out trade with the given amount out and route
+   * @param route route of the exact out trade
+   * @param amountOut the amount returned by the trade
    */;
   Trade.exactOut = function exactOut(route, amountOut) {
     return new Trade(route, amountOut, TradeType.EXACT_OUTPUT);
-  }
-  /**
-   * Get the minimum amount that must be received from this trade for the given slippage tolerance
-   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
-   */;
+  };
   var _proto = Trade.prototype;
   _proto.minimumAmountOut = function minimumAmountOut(slippageTolerance) {
     !!slippageTolerance.lessThan(ZERO) ? process.env.NODE_ENV !== "production" ? invariant(false, 'SLIPPAGE_TOLERANCE') : invariant(false) : void 0;
@@ -639,9 +686,10 @@ var Trade = /*#__PURE__*/function () {
       return CurrencyAmount.fromRawAmount(this.outputAmount.currency, slippageAdjustedAmountOut);
     }
   }
-  /**
-   * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
-   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
+
+  /**
+   * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+   * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
    */;
   _proto.maximumAmountIn = function maximumAmountIn(slippageTolerance) {
     !!slippageTolerance.lessThan(ZERO) ? process.env.NODE_ENV !== "production" ? invariant(false, 'SLIPPAGE_TOLERANCE') : invariant(false) : void 0;
@@ -652,19 +700,20 @@ var Trade = /*#__PURE__*/function () {
       return CurrencyAmount.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn);
     }
   }
-  /**
-   * Given a list of pairs, 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 pairs the pairs 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 pair
-   * @param currentPairs used in recursion; the current list of pairs
-   * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
-   * @param bestTrades used in recursion; the current list of best trades
+
+  /**
+   * Given a list of pairs, 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 pairs the pairs 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 pair
+   * @param currentPairs used in recursion; the current list of pairs
+   * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
+   * @param bestTrades used in recursion; the current list of best trades
    */;
   Trade.bestTradeExactIn = function bestTradeExactIn(pairs, currencyAmountIn, currencyOut, _temp,
   // used in recursion.
@@ -710,6 +759,7 @@ var Trade = /*#__PURE__*/function () {
         sortedInsert(bestTrades, new Trade(new Route([].concat(currentPairs, [pair]), currencyAmountIn.currency, currencyOut), currencyAmountIn, TradeType.EXACT_INPUT), maxNumResults, tradeComparator);
       } else if (maxHops > 1 && pairs.length > 1) {
         var pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
+
         // otherwise, consider all the other paths that lead from this token as long as we have not exceeded maxHops
         Trade.bestTradeExactIn(pairsExcludingThisPair, currencyAmountIn, currencyOut, {
           maxNumResults: maxNumResults,
@@ -719,27 +769,29 @@ var Trade = /*#__PURE__*/function () {
     }
     return bestTrades;
   }
-  /**
-   * Return the execution price after accounting for slippage tolerance
-   * @param slippageTolerance the allowed tolerated slippage
+
+  /**
+   * Return the execution price after accounting for slippage tolerance
+   * @param slippageTolerance the allowed tolerated slippage
    */;
   _proto.worstExecutionPrice = function worstExecutionPrice(slippageTolerance) {
     return new Price(this.inputAmount.currency, this.outputAmount.currency, this.maximumAmountIn(slippageTolerance).quotient, this.minimumAmountOut(slippageTolerance).quotient);
   }
-  /**
-   * similar to the above method but instead targets a fixed output amount
-   * given a list of pairs, 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 pairs the pairs to consider in finding the best trade
-   * @param currencyIn the currency to spend
-   * @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 pair
-   * @param currentPairs used in recursion; the current list of pairs
-   * @param currencyAmountOut used in recursion; the original value of the currencyAmountOut parameter
-   * @param bestTrades used in recursion; the current list of best trades
+
+  /**
+   * similar to the above method but instead targets a fixed output amount
+   * given a list of pairs, 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 pairs the pairs to consider in finding the best trade
+   * @param currencyIn the currency to spend
+   * @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 pair
+   * @param currentPairs used in recursion; the current list of pairs
+   * @param currencyAmountOut used in recursion; the original value of the currencyAmountOut parameter
+   * @param bestTrades used in recursion; the current list of best trades
    */;
   Trade.bestTradeExactOut = function bestTradeExactOut(pairs, currencyIn, currencyAmountOut, _temp2,
   // used in recursion.
@@ -785,6 +837,7 @@ var Trade = /*#__PURE__*/function () {
         sortedInsert(bestTrades, new Trade(new Route([pair].concat(currentPairs), currencyIn, currencyAmountOut.currency), currencyAmountOut, TradeType.EXACT_OUTPUT), maxNumResults, tradeComparator);
       } else if (maxHops > 1 && pairs.length > 1) {
         var pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
+
         // otherwise, consider all the other paths that arrive at this token as long as we have not exceeded maxHops
         Trade.bestTradeExactOut(pairsExcludingThisPair, currencyIn, currencyAmountOut, {
           maxNumResults: maxNumResults,
@@ -797,22 +850,31 @@ var Trade = /*#__PURE__*/function () {
   return Trade;
 }();
 
+/**
+ * Options for producing the arguments to send call to the router.
+ */
+
+/**
+ * The parameters to use in the call to the Uniswap V2 Router to execute a trade.
+ */
+
 function toHex(currencyAmount) {
   return "0x" + currencyAmount.quotient.toString(16);
 }
 var ZERO_HEX = '0x0';
-/**
- * Represents the Uniswap V2 Router, and has static methods for helping execute trades.
+
+/**
+ * Represents the Uniswap V2 Router, and has static methods for helping execute trades.
  */
 var Router = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
+  /**
+   * Cannot be constructed.
    */
   function Router() {}
-  /**
-   * 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
    */
   Router.swapCallParameters = function swapCallParameters(trade, options) {
     var etherIn = trade.inputAmount.currency.isNative;