@pancakeswap/sdk 3.1.4 → 3.1.5

package/dist/index.js

@@ -18,7 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -104,13 +111,48 @@ var INIT_CODE_HASH_MAP = {
   [97 /* BSC_TESTNET */]: "0xd0d4c4cd0848c93cb4fd1f498d7013ee6bfb25783ea21593d5834f5d250ece66"
 };
 var WETH9 = {
-  [1 /* ETHEREUM */]: new ERC20Token(1 /* ETHEREUM */, "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", 18, "WETH", "Wrapped Ether", "https://weth.io"),
-  [5 /* GOERLI */]: new ERC20Token(5 /* GOERLI */, "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6", 18, "WETH", "Wrapped Ether", "https://weth.io")
+  [1 /* ETHEREUM */]: new ERC20Token(
+    1 /* ETHEREUM */,
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    18,
+    "WETH",
+    "Wrapped Ether",
+    "https://weth.io"
+  ),
+  [5 /* GOERLI */]: new ERC20Token(
+    5 /* GOERLI */,
+    "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6",
+    18,
+    "WETH",
+    "Wrapped Ether",
+    "https://weth.io"
+  )
 };
 var WBNB = {
-  [1 /* ETHEREUM */]: new ERC20Token(1 /* ETHEREUM */, "0x418D75f65a02b3D53B2418FB8E1fe493759c7605", 18, "WBNB", "Wrapped BNB", "https://www.binance.org"),
-  [56 /* BSC */]: new ERC20Token(56 /* BSC */, "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", 18, "WBNB", "Wrapped BNB", "https://www.binance.org"),
-  [97 /* BSC_TESTNET */]: new ERC20Token(97 /* BSC_TESTNET */, "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd", 18, "WBNB", "Wrapped BNB", "https://www.binance.org")
+  [1 /* ETHEREUM */]: new ERC20Token(
+    1 /* ETHEREUM */,
+    "0x418D75f65a02b3D53B2418FB8E1fe493759c7605",
+    18,
+    "WBNB",
+    "Wrapped BNB",
+    "https://www.binance.org"
+  ),
+  [56 /* BSC */]: new ERC20Token(
+    56 /* BSC */,
+    "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+    18,
+    "WBNB",
+    "Wrapped BNB",
+    "https://www.binance.org"
+  ),
+  [97 /* BSC_TESTNET */]: new ERC20Token(
+    97 /* BSC_TESTNET */,
+    "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd",
+    18,
+    "WBNB",
+    "Wrapped BNB",
+    "https://www.binance.org"
+  )
 };
 var WNATIVE = {
   [1 /* ETHEREUM */]: WETH9[1 /* ETHEREUM */],
@@ -168,7 +210,11 @@ var computePairAddress = ({
   if ((PAIR_ADDRESS_CACHE == null ? void 0 : PAIR_ADDRESS_CACHE[key]) === void 0) {
     PAIR_ADDRESS_CACHE = {
       ...PAIR_ADDRESS_CACHE,
-      [key]: (0, import_address2.getCreate2Address)(factoryAddress, (0, import_solidity.keccak256)(["bytes"], [(0, import_solidity.pack)(["address", "address"], [token0.address, token1.address])]), INIT_CODE_HASH_MAP[token0.chainId])
+      [key]: (0, import_address2.getCreate2Address)(
+        factoryAddress,
+        (0, import_solidity.keccak256)(["bytes"], [(0, import_solidity.pack)(["address", "address"], [token0.address, token1.address])]),
+        INIT_CODE_HASH_MAP[token0.chainId]
+      )
     };
   }
   return PAIR_ADDRESS_CACHE[key];
@@ -179,24 +225,47 @@ var Pair = class {
   }
   constructor(currencyAmountA, tokenAmountB) {
     const tokenAmounts = currencyAmountA.currency.sortsBefore(tokenAmountB.currency) ? [currencyAmountA, tokenAmountB] : [tokenAmountB, currencyAmountA];
-    this.liquidityToken = new ERC20Token(tokenAmounts[0].currency.chainId, Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency), 18, "Cake-LP", "Pancake LPs");
+    this.liquidityToken = new ERC20Token(
+      tokenAmounts[0].currency.chainId,
+      Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency),
+      18,
+      "Cake-LP",
+      "Pancake LPs"
+    );
     this.tokenAmounts = tokenAmounts;
   }
+  /**
+   * Returns true if the token is either token0 or token1
+   * @param token to check
+   */
   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
+   */
   get token0Price() {
     const result = this.tokenAmounts[1].divide(this.tokenAmounts[0]);
     return new import_swap_sdk_core3.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
+   */
   get token1Price() {
     const result = this.tokenAmounts[0].divide(this.tokenAmounts[1]);
     return new import_swap_sdk_core3.Price(this.token1, this.token0, result.denominator, result.numerator);
   }
+  /**
+   * Return the price of the given token in terms of the other token in the pair.
+   * @param token token to return price of
+   */
   priceOf(token) {
     (0, import_tiny_invariant2.default)(this.involvesToken(token), "TOKEN");
     return token.equals(this.token0) ? this.token0Price : this.token1Price;
   }
+  /**
+   * Returns the chain ID of the tokens in the pair.
+   */
   get chainId() {
     return this.token0.chainId;
   }
@@ -226,7 +295,10 @@ var Pair = class {
     const inputAmountWithFee = import_jsbi.default.multiply(inputAmount.quotient, import_swap_sdk_core3._9975);
     const numerator = import_jsbi.default.multiply(inputAmountWithFee, outputReserve.quotient);
     const denominator = import_jsbi.default.add(import_jsbi.default.multiply(inputReserve.quotient, import_swap_sdk_core3._10000), inputAmountWithFee);
-    const outputAmount = import_swap_sdk_core3.CurrencyAmount.fromRawAmount(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0, import_jsbi.default.divide(numerator, denominator));
+    const outputAmount = import_swap_sdk_core3.CurrencyAmount.fromRawAmount(
+      inputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
+      import_jsbi.default.divide(numerator, denominator)
+    );
     if (import_jsbi.default.equal(outputAmount.quotient, import_swap_sdk_core3.ZERO)) {
       throw new import_swap_sdk_core3.InsufficientInputAmountError();
     }
@@ -241,7 +313,10 @@ var Pair = class {
     const inputReserve = this.reserveOf(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0);
     const numerator = import_jsbi.default.multiply(import_jsbi.default.multiply(inputReserve.quotient, outputAmount.quotient), import_swap_sdk_core3._10000);
     const denominator = import_jsbi.default.multiply(import_jsbi.default.subtract(outputReserve.quotient, outputAmount.quotient), import_swap_sdk_core3._9975);
-    const inputAmount = import_swap_sdk_core3.CurrencyAmount.fromRawAmount(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0, import_jsbi.default.add(import_jsbi.default.divide(numerator, denominator), import_swap_sdk_core3.ONE));
+    const inputAmount = import_swap_sdk_core3.CurrencyAmount.fromRawAmount(
+      outputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
+      import_jsbi.default.add(import_jsbi.default.divide(numerator, denominator), import_swap_sdk_core3.ONE)
+    );
     return [inputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
   }
   getLiquidityMinted(totalSupply, tokenAmountA, tokenAmountB) {
@@ -250,7 +325,10 @@ var Pair = class {
     (0, import_tiny_invariant2.default)(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
     let liquidity;
     if (import_jsbi.default.equal(totalSupply.quotient, import_swap_sdk_core3.ZERO)) {
-      liquidity = import_jsbi.default.subtract((0, import_swap_sdk_core3.sqrt)(import_jsbi.default.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)), import_swap_sdk_core3.MINIMUM_LIQUIDITY);
+      liquidity = import_jsbi.default.subtract(
+        (0, import_swap_sdk_core3.sqrt)(import_jsbi.default.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)),
+        import_swap_sdk_core3.MINIMUM_LIQUIDITY
+      );
     } else {
       const amount0 = import_jsbi.default.divide(import_jsbi.default.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient);
       const amount1 = import_jsbi.default.divide(import_jsbi.default.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient);
@@ -287,7 +365,10 @@ var Pair = class {
         totalSupplyAdjusted = totalSupply;
       }
     }
-    return import_swap_sdk_core3.CurrencyAmount.fromRawAmount(token, import_jsbi.default.divide(import_jsbi.default.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient));
+    return import_swap_sdk_core3.CurrencyAmount.fromRawAmount(
+      token,
+      import_jsbi.default.divide(import_jsbi.default.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)
+    );
   }
 };
 
@@ -299,7 +380,10 @@ var Route = class {
     this._midPrice = null;
     (0, import_tiny_invariant3.default)(pairs.length > 0, "PAIRS");
     const chainId = pairs[0].chainId;
-    (0, import_tiny_invariant3.default)(pairs.every((pair) => pair.chainId === chainId), "CHAIN_IDS");
+    (0, import_tiny_invariant3.default)(
+      pairs.every((pair) => pair.chainId === chainId),
+      "CHAIN_IDS"
+    );
     const wrappedInput = input.wrapped;
     (0, import_tiny_invariant3.default)(pairs[0].involvesToken(wrappedInput), "INPUT");
     (0, import_tiny_invariant3.default)(typeof output === "undefined" || pairs[pairs.length - 1].involvesToken(output.wrapped), "OUTPUT");
@@ -320,7 +404,9 @@ var Route = class {
       return this._midPrice;
     const prices = [];
     for (const [i, pair] of this.pairs.entries()) {
-      prices.push(this.path[i].equals(pair.token0) ? new import_swap_sdk_core4.Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new import_swap_sdk_core4.Price(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient));
+      prices.push(
+        this.path[i].equals(pair.token0) ? new import_swap_sdk_core4.Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new import_swap_sdk_core4.Price(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient)
+      );
     }
     const reduced = prices.slice(1).reduce((accumulator, currentValue) => accumulator.multiply(currentValue), prices[0]);
     return this._midPrice = new import_swap_sdk_core4.Price(this.input, this.output, reduced.denominator, reduced.numerator);
@@ -364,9 +450,19 @@ function tradeComparator(a, b) {
   return a.route.path.length - b.route.path.length;
 }
 var Trade = class {
+  /**
+   * 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
+   */
   static exactIn(route, amountIn) {
     return new Trade(route, amountIn, import_swap_sdk_core5.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
+   */
   static exactOut(route, amountOut) {
     return new Trade(route, amountOut, import_swap_sdk_core5.TradeType.EXACT_OUTPUT);
   }
@@ -383,7 +479,11 @@ var Trade = class {
         tokenAmounts[i + 1] = outputAmount;
       }
       this.inputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
-      this.outputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.output, tokenAmounts[tokenAmounts.length - 1].numerator, tokenAmounts[tokenAmounts.length - 1].denominator);
+      this.outputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(
+        route.output,
+        tokenAmounts[tokenAmounts.length - 1].numerator,
+        tokenAmounts[tokenAmounts.length - 1].denominator
+      );
     } else {
       (0, import_tiny_invariant4.default)(amount.currency.equals(route.output), "OUTPUT");
       tokenAmounts[tokenAmounts.length - 1] = amount.wrapped;
@@ -392,12 +492,25 @@ var Trade = class {
         const [inputAmount] = pair.getInputAmount(tokenAmounts[i]);
         tokenAmounts[i - 1] = inputAmount;
       }
-      this.inputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.input, tokenAmounts[0].numerator, tokenAmounts[0].denominator);
+      this.inputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(
+        route.input,
+        tokenAmounts[0].numerator,
+        tokenAmounts[0].denominator
+      );
       this.outputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
     }
-    this.executionPrice = new import_swap_sdk_core5.Price(this.inputAmount.currency, this.outputAmount.currency, this.inputAmount.quotient, this.outputAmount.quotient);
+    this.executionPrice = new import_swap_sdk_core5.Price(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.inputAmount.quotient,
+      this.outputAmount.quotient
+    );
     this.priceImpact = (0, import_swap_sdk_core5.computePriceImpact)(route.midPrice, this.inputAmount, this.outputAmount);
   }
+  /**
+   * 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
+   */
   minimumAmountOut(slippageTolerance) {
     (0, import_tiny_invariant4.default)(!slippageTolerance.lessThan(import_swap_sdk_core5.ZERO), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === import_swap_sdk_core5.TradeType.EXACT_OUTPUT) {
@@ -406,6 +519,10 @@ var Trade = class {
     const slippageAdjustedAmountOut = new import_swap_sdk_core5.Fraction(import_swap_sdk_core5.ONE).add(slippageTolerance).invert().multiply(this.outputAmount.quotient).quotient;
     return import_swap_sdk_core5.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
+   */
   maximumAmountIn(slippageTolerance) {
     (0, import_tiny_invariant4.default)(!slippageTolerance.lessThan(import_swap_sdk_core5.ZERO), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === import_swap_sdk_core5.TradeType.EXACT_INPUT) {
@@ -414,6 +531,20 @@ var Trade = class {
     const slippageAdjustedAmountIn = new import_swap_sdk_core5.Fraction(import_swap_sdk_core5.ONE).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
     return import_swap_sdk_core5.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
+   */
   static bestTradeExactIn(pairs, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
     (0, import_tiny_invariant4.default)(pairs.length > 0, "PAIRS");
     (0, import_tiny_invariant4.default)(maxHops > 0, "MAX_HOPS");
@@ -437,20 +568,61 @@ var Trade = class {
         throw error;
       }
       if (amountOut.currency.equals(tokenOut)) {
-        (0, import_swap_sdk_core5.sortedInsert)(bestTrades, new Trade(new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut), currencyAmountIn, import_swap_sdk_core5.TradeType.EXACT_INPUT), maxNumResults, tradeComparator);
+        (0, import_swap_sdk_core5.sortedInsert)(
+          bestTrades,
+          new Trade(
+            new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut),
+            currencyAmountIn,
+            import_swap_sdk_core5.TradeType.EXACT_INPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
       } else if (maxHops > 1 && pairs.length > 1) {
         const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
-        Trade.bestTradeExactIn(pairsExcludingThisPair, currencyAmountIn, currencyOut, {
-          maxNumResults,
-          maxHops: maxHops - 1
-        }, [...currentPairs, pair], amountOut, bestTrades);
+        Trade.bestTradeExactIn(
+          pairsExcludingThisPair,
+          currencyAmountIn,
+          currencyOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [...currentPairs, pair],
+          amountOut,
+          bestTrades
+        );
       }
     }
     return bestTrades;
   }
+  /**
+   * Return the execution price after accounting for slippage tolerance
+   * @param slippageTolerance the allowed tolerated slippage
+   */
   worstExecutionPrice(slippageTolerance) {
-    return new import_swap_sdk_core5.Price(this.inputAmount.currency, this.outputAmount.currency, this.maximumAmountIn(slippageTolerance).quotient, this.minimumAmountOut(slippageTolerance).quotient);
-  }
+    return new import_swap_sdk_core5.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
+   */
   static bestTradeExactOut(pairs, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
     (0, import_tiny_invariant4.default)(pairs.length > 0, "PAIRS");
     (0, import_tiny_invariant4.default)(maxHops > 0, "MAX_HOPS");
@@ -474,13 +646,30 @@ var Trade = class {
         throw error;
       }
       if (amountIn.currency.equals(tokenIn)) {
-        (0, import_swap_sdk_core5.sortedInsert)(bestTrades, new Trade(new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency), currencyAmountOut, import_swap_sdk_core5.TradeType.EXACT_OUTPUT), maxNumResults, tradeComparator);
+        (0, import_swap_sdk_core5.sortedInsert)(
+          bestTrades,
+          new Trade(
+            new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency),
+            currencyAmountOut,
+            import_swap_sdk_core5.TradeType.EXACT_OUTPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
       } else if (maxHops > 1 && pairs.length > 1) {
         const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
-        Trade.bestTradeExactOut(pairsExcludingThisPair, currencyIn, currencyAmountOut, {
-          maxNumResults,
-          maxHops: maxHops - 1
-        }, [pair, ...currentPairs], amountIn, bestTrades);
+        Trade.bestTradeExactOut(
+          pairsExcludingThisPair,
+          currencyIn,
+          currencyAmountOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [pair, ...currentPairs],
+          amountIn,
+          bestTrades
+        );
       }
     }
     return bestTrades;
@@ -527,8 +716,16 @@ function toHex(currencyAmount) {
 }
 var ZERO_HEX = "0x0";
 var Router = class {
+  /**
+   * Cannot be constructed.
+   */
   constructor() {
   }
+  /**
+   * 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
+   */
   static swapCallParameters(trade, options) {
     const etherIn = trade.inputAmount.currency.isNative;
     const etherOut = trade.outputAmount.currency.isNative;
@@ -538,7 +735,7 @@ var Router = class {
     const amountIn = toHex(trade.maximumAmountIn(options.allowedSlippage));
     const amountOut = toHex(trade.minimumAmountOut(options.allowedSlippage));
     const path = trade.route.path.map((token) => token.address);
-    const deadline = "ttl" in options ? `0x${(Math.floor(new Date().getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
+    const deadline = "ttl" in options ? `0x${(Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
     const useFeeOnTransfer = Boolean(options.feeOnTransfer);
     let methodName;
     let args;

package/dist/index.mjs

@@ -55,13 +55,48 @@ var INIT_CODE_HASH_MAP = {
   [97 /* BSC_TESTNET */]: "0xd0d4c4cd0848c93cb4fd1f498d7013ee6bfb25783ea21593d5834f5d250ece66"
 };
 var WETH9 = {
-  [1 /* ETHEREUM */]: new ERC20Token(1 /* ETHEREUM */, "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", 18, "WETH", "Wrapped Ether", "https://weth.io"),
-  [5 /* GOERLI */]: new ERC20Token(5 /* GOERLI */, "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6", 18, "WETH", "Wrapped Ether", "https://weth.io")
+  [1 /* ETHEREUM */]: new ERC20Token(
+    1 /* ETHEREUM */,
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    18,
+    "WETH",
+    "Wrapped Ether",
+    "https://weth.io"
+  ),
+  [5 /* GOERLI */]: new ERC20Token(
+    5 /* GOERLI */,
+    "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6",
+    18,
+    "WETH",
+    "Wrapped Ether",
+    "https://weth.io"
+  )
 };
 var WBNB = {
-  [1 /* ETHEREUM */]: new ERC20Token(1 /* ETHEREUM */, "0x418D75f65a02b3D53B2418FB8E1fe493759c7605", 18, "WBNB", "Wrapped BNB", "https://www.binance.org"),
-  [56 /* BSC */]: new ERC20Token(56 /* BSC */, "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", 18, "WBNB", "Wrapped BNB", "https://www.binance.org"),
-  [97 /* BSC_TESTNET */]: new ERC20Token(97 /* BSC_TESTNET */, "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd", 18, "WBNB", "Wrapped BNB", "https://www.binance.org")
+  [1 /* ETHEREUM */]: new ERC20Token(
+    1 /* ETHEREUM */,
+    "0x418D75f65a02b3D53B2418FB8E1fe493759c7605",
+    18,
+    "WBNB",
+    "Wrapped BNB",
+    "https://www.binance.org"
+  ),
+  [56 /* BSC */]: new ERC20Token(
+    56 /* BSC */,
+    "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+    18,
+    "WBNB",
+    "Wrapped BNB",
+    "https://www.binance.org"
+  ),
+  [97 /* BSC_TESTNET */]: new ERC20Token(
+    97 /* BSC_TESTNET */,
+    "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd",
+    18,
+    "WBNB",
+    "Wrapped BNB",
+    "https://www.binance.org"
+  )
 };
 var WNATIVE = {
   [1 /* ETHEREUM */]: WETH9[1 /* ETHEREUM */],
@@ -131,7 +166,11 @@ var computePairAddress = ({
   if ((PAIR_ADDRESS_CACHE == null ? void 0 : PAIR_ADDRESS_CACHE[key]) === void 0) {
     PAIR_ADDRESS_CACHE = {
       ...PAIR_ADDRESS_CACHE,
-      [key]: getCreate2Address(factoryAddress, keccak256(["bytes"], [pack(["address", "address"], [token0.address, token1.address])]), INIT_CODE_HASH_MAP[token0.chainId])
+      [key]: getCreate2Address(
+        factoryAddress,
+        keccak256(["bytes"], [pack(["address", "address"], [token0.address, token1.address])]),
+        INIT_CODE_HASH_MAP[token0.chainId]
+      )
     };
   }
   return PAIR_ADDRESS_CACHE[key];
@@ -142,24 +181,47 @@ var Pair = class {
   }
   constructor(currencyAmountA, tokenAmountB) {
     const tokenAmounts = currencyAmountA.currency.sortsBefore(tokenAmountB.currency) ? [currencyAmountA, tokenAmountB] : [tokenAmountB, currencyAmountA];
-    this.liquidityToken = new ERC20Token(tokenAmounts[0].currency.chainId, Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency), 18, "Cake-LP", "Pancake LPs");
+    this.liquidityToken = new ERC20Token(
+      tokenAmounts[0].currency.chainId,
+      Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency),
+      18,
+      "Cake-LP",
+      "Pancake LPs"
+    );
     this.tokenAmounts = tokenAmounts;
   }
+  /**
+   * Returns true if the token is either token0 or token1
+   * @param token to check
+   */
   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
+   */
   get token0Price() {
     const 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
+   */
   get token1Price() {
     const result = this.tokenAmounts[0].divide(this.tokenAmounts[1]);
     return new Price(this.token1, this.token0, result.denominator, result.numerator);
   }
+  /**
+   * Return the price of the given token in terms of the other token in the pair.
+   * @param token token to return price of
+   */
   priceOf(token) {
     invariant2(this.involvesToken(token), "TOKEN");
     return token.equals(this.token0) ? this.token0Price : this.token1Price;
   }
+  /**
+   * Returns the chain ID of the tokens in the pair.
+   */
   get chainId() {
     return this.token0.chainId;
   }
@@ -189,7 +251,10 @@ var Pair = class {
     const inputAmountWithFee = JSBI.multiply(inputAmount.quotient, _9975);
     const numerator = JSBI.multiply(inputAmountWithFee, outputReserve.quotient);
     const denominator = JSBI.add(JSBI.multiply(inputReserve.quotient, _10000), inputAmountWithFee);
-    const outputAmount = CurrencyAmount.fromRawAmount(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0, JSBI.divide(numerator, denominator));
+    const outputAmount = CurrencyAmount.fromRawAmount(
+      inputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
+      JSBI.divide(numerator, denominator)
+    );
     if (JSBI.equal(outputAmount.quotient, ZERO)) {
       throw new InsufficientInputAmountError();
     }
@@ -204,7 +269,10 @@ var Pair = class {
     const inputReserve = this.reserveOf(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0);
     const numerator = JSBI.multiply(JSBI.multiply(inputReserve.quotient, outputAmount.quotient), _10000);
     const denominator = JSBI.multiply(JSBI.subtract(outputReserve.quotient, outputAmount.quotient), _9975);
-    const inputAmount = CurrencyAmount.fromRawAmount(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0, JSBI.add(JSBI.divide(numerator, denominator), ONE));
+    const inputAmount = CurrencyAmount.fromRawAmount(
+      outputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
+      JSBI.add(JSBI.divide(numerator, denominator), ONE)
+    );
     return [inputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
   }
   getLiquidityMinted(totalSupply, tokenAmountA, tokenAmountB) {
@@ -213,7 +281,10 @@ var Pair = class {
     invariant2(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
     let liquidity;
     if (JSBI.equal(totalSupply.quotient, ZERO)) {
-      liquidity = JSBI.subtract(sqrt(JSBI.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)), MINIMUM_LIQUIDITY);
+      liquidity = JSBI.subtract(
+        sqrt(JSBI.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)),
+        MINIMUM_LIQUIDITY
+      );
     } else {
       const amount0 = JSBI.divide(JSBI.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient);
       const amount1 = JSBI.divide(JSBI.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient);
@@ -250,7 +321,10 @@ var Pair = class {
         totalSupplyAdjusted = totalSupply;
       }
     }
-    return CurrencyAmount.fromRawAmount(token, JSBI.divide(JSBI.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient));
+    return CurrencyAmount.fromRawAmount(
+      token,
+      JSBI.divide(JSBI.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)
+    );
   }
 };
 
@@ -262,7 +336,10 @@ var Route = class {
     this._midPrice = null;
     invariant3(pairs.length > 0, "PAIRS");
     const chainId = pairs[0].chainId;
-    invariant3(pairs.every((pair) => pair.chainId === chainId), "CHAIN_IDS");
+    invariant3(
+      pairs.every((pair) => pair.chainId === chainId),
+      "CHAIN_IDS"
+    );
     const wrappedInput = input.wrapped;
     invariant3(pairs[0].involvesToken(wrappedInput), "INPUT");
     invariant3(typeof output === "undefined" || pairs[pairs.length - 1].involvesToken(output.wrapped), "OUTPUT");
@@ -283,7 +360,9 @@ var Route = class {
       return this._midPrice;
     const prices = [];
     for (const [i, pair] of this.pairs.entries()) {
-      prices.push(this.path[i].equals(pair.token0) ? new Price2(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new Price2(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient));
+      prices.push(
+        this.path[i].equals(pair.token0) ? new Price2(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new Price2(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient)
+      );
     }
     const reduced = prices.slice(1).reduce((accumulator, currentValue) => accumulator.multiply(currentValue), prices[0]);
     return this._midPrice = new Price2(this.input, this.output, reduced.denominator, reduced.numerator);
@@ -336,9 +415,19 @@ function tradeComparator(a, b) {
   return a.route.path.length - b.route.path.length;
 }
 var Trade = class {
+  /**
+   * 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
+   */
   static 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
+   */
   static exactOut(route, amountOut) {
     return new Trade(route, amountOut, TradeType.EXACT_OUTPUT);
   }
@@ -355,7 +444,11 @@ var Trade = class {
         tokenAmounts[i + 1] = outputAmount;
       }
       this.inputAmount = CurrencyAmount2.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
-      this.outputAmount = CurrencyAmount2.fromFractionalAmount(route.output, tokenAmounts[tokenAmounts.length - 1].numerator, tokenAmounts[tokenAmounts.length - 1].denominator);
+      this.outputAmount = CurrencyAmount2.fromFractionalAmount(
+        route.output,
+        tokenAmounts[tokenAmounts.length - 1].numerator,
+        tokenAmounts[tokenAmounts.length - 1].denominator
+      );
     } else {
       invariant4(amount.currency.equals(route.output), "OUTPUT");
       tokenAmounts[tokenAmounts.length - 1] = amount.wrapped;
@@ -364,12 +457,25 @@ var Trade = class {
         const [inputAmount] = pair.getInputAmount(tokenAmounts[i]);
         tokenAmounts[i - 1] = inputAmount;
       }
-      this.inputAmount = CurrencyAmount2.fromFractionalAmount(route.input, tokenAmounts[0].numerator, tokenAmounts[0].denominator);
+      this.inputAmount = CurrencyAmount2.fromFractionalAmount(
+        route.input,
+        tokenAmounts[0].numerator,
+        tokenAmounts[0].denominator
+      );
       this.outputAmount = CurrencyAmount2.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
     }
-    this.executionPrice = new Price3(this.inputAmount.currency, this.outputAmount.currency, this.inputAmount.quotient, this.outputAmount.quotient);
+    this.executionPrice = new Price3(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.inputAmount.quotient,
+      this.outputAmount.quotient
+    );
     this.priceImpact = computePriceImpact(route.midPrice, this.inputAmount, this.outputAmount);
   }
+  /**
+   * 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
+   */
   minimumAmountOut(slippageTolerance) {
     invariant4(!slippageTolerance.lessThan(ZERO2), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === TradeType.EXACT_OUTPUT) {
@@ -378,6 +484,10 @@ var Trade = class {
     const slippageAdjustedAmountOut = new Fraction(ONE2).add(slippageTolerance).invert().multiply(this.outputAmount.quotient).quotient;
     return CurrencyAmount2.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
+   */
   maximumAmountIn(slippageTolerance) {
     invariant4(!slippageTolerance.lessThan(ZERO2), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === TradeType.EXACT_INPUT) {
@@ -386,6 +496,20 @@ var Trade = class {
     const slippageAdjustedAmountIn = new Fraction(ONE2).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
     return CurrencyAmount2.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
+   */
   static bestTradeExactIn(pairs, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
     invariant4(pairs.length > 0, "PAIRS");
     invariant4(maxHops > 0, "MAX_HOPS");
@@ -409,20 +533,61 @@ var Trade = class {
         throw error;
       }
       if (amountOut.currency.equals(tokenOut)) {
-        sortedInsert(bestTrades, new Trade(new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut), currencyAmountIn, TradeType.EXACT_INPUT), maxNumResults, tradeComparator);
+        sortedInsert(
+          bestTrades,
+          new Trade(
+            new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut),
+            currencyAmountIn,
+            TradeType.EXACT_INPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
       } else if (maxHops > 1 && pairs.length > 1) {
         const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
-        Trade.bestTradeExactIn(pairsExcludingThisPair, currencyAmountIn, currencyOut, {
-          maxNumResults,
-          maxHops: maxHops - 1
-        }, [...currentPairs, pair], amountOut, bestTrades);
+        Trade.bestTradeExactIn(
+          pairsExcludingThisPair,
+          currencyAmountIn,
+          currencyOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [...currentPairs, pair],
+          amountOut,
+          bestTrades
+        );
       }
     }
     return bestTrades;
   }
+  /**
+   * Return the execution price after accounting for slippage tolerance
+   * @param slippageTolerance the allowed tolerated slippage
+   */
   worstExecutionPrice(slippageTolerance) {
-    return new Price3(this.inputAmount.currency, this.outputAmount.currency, this.maximumAmountIn(slippageTolerance).quotient, this.minimumAmountOut(slippageTolerance).quotient);
-  }
+    return new Price3(
+      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
+   */
   static bestTradeExactOut(pairs, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
     invariant4(pairs.length > 0, "PAIRS");
     invariant4(maxHops > 0, "MAX_HOPS");
@@ -446,13 +611,30 @@ var Trade = class {
         throw error;
       }
       if (amountIn.currency.equals(tokenIn)) {
-        sortedInsert(bestTrades, new Trade(new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency), currencyAmountOut, TradeType.EXACT_OUTPUT), maxNumResults, tradeComparator);
+        sortedInsert(
+          bestTrades,
+          new Trade(
+            new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency),
+            currencyAmountOut,
+            TradeType.EXACT_OUTPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
       } else if (maxHops > 1 && pairs.length > 1) {
         const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
-        Trade.bestTradeExactOut(pairsExcludingThisPair, currencyIn, currencyAmountOut, {
-          maxNumResults,
-          maxHops: maxHops - 1
-        }, [pair, ...currentPairs], amountIn, bestTrades);
+        Trade.bestTradeExactOut(
+          pairsExcludingThisPair,
+          currencyIn,
+          currencyAmountOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [pair, ...currentPairs],
+          amountIn,
+          bestTrades
+        );
       }
     }
     return bestTrades;
@@ -499,8 +681,16 @@ function toHex(currencyAmount) {
 }
 var ZERO_HEX = "0x0";
 var Router = class {
+  /**
+   * Cannot be constructed.
+   */
   constructor() {
   }
+  /**
+   * 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
+   */
   static swapCallParameters(trade, options) {
     const etherIn = trade.inputAmount.currency.isNative;
     const etherOut = trade.outputAmount.currency.isNative;
@@ -510,7 +700,7 @@ var Router = class {
     const amountIn = toHex(trade.maximumAmountIn(options.allowedSlippage));
     const amountOut = toHex(trade.minimumAmountOut(options.allowedSlippage));
     const path = trade.route.path.map((token) => token.address);
-    const deadline = "ttl" in options ? `0x${(Math.floor(new Date().getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
+    const deadline = "ttl" in options ? `0x${(Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
     const useFeeOnTransfer = Boolean(options.feeOnTransfer);
     let methodName;
     let args;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pancakeswap/sdk",
   "license": "MIT",
-  "version": "3.1.4",
+  "version": "3.1.5",
   "description": "🛠 An SDK for building applications on top of Pancakeswap.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -52,7 +52,7 @@
     "@types/big.js": "^4.0.5",
     "@types/jest": "^24.0.25",
     "babel-plugin-transform-jsbi-to-bigint": "^1.3.1",
-    "tsup": "^5.10.1"
+    "tsup": "^6.6.3"
   },
   "engines": {
     "node": ">=10"