@pancakeswap/sdk 3.1.5 → 3.2.1

package/dist/index.js

@@ -1,99 +1,49 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  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(
-  // 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);
+'use strict';
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ChainId: () => ChainId,
-  ERC20Token: () => ERC20Token,
-  FACTORY_ADDRESS: () => FACTORY_ADDRESS,
-  FACTORY_ADDRESS_MAP: () => FACTORY_ADDRESS_MAP,
-  INIT_CODE_HASH: () => INIT_CODE_HASH,
-  INIT_CODE_HASH_MAP: () => INIT_CODE_HASH_MAP,
-  JSBI: () => import_jsbi2.default,
-  NATIVE: () => NATIVE,
-  Native: () => Native,
-  ONE_HUNDRED_PERCENT: () => ONE_HUNDRED_PERCENT,
-  Pair: () => Pair,
-  Route: () => Route,
-  Router: () => Router,
-  Trade: () => Trade,
-  WBNB: () => WBNB,
-  WETH9: () => WETH9,
-  WNATIVE: () => WNATIVE,
-  ZERO_PERCENT: () => ZERO_PERCENT,
-  computePairAddress: () => computePairAddress,
-  inputOutputComparator: () => inputOutputComparator,
-  isTradeBetter: () => isTradeBetter,
-  tradeComparator: () => tradeComparator
-});
-module.exports = __toCommonJS(src_exports);
-var import_jsbi2 = __toESM(require("jsbi"));
+var JSBI = require('jsbi');
+var swapSdkCore = require('@pancakeswap/swap-sdk-core');
+var address = require('@ethersproject/address');
+var invariant4 = require('tiny-invariant');
+var warning = require('tiny-warning');
+var solidity = require('@ethersproject/solidity');
+var contracts = require('@ethersproject/contracts');
+var networks = require('@ethersproject/networks');
+var providers = require('@ethersproject/providers');
 
-// src/constants.ts
-var import_swap_sdk_core2 = require("@pancakeswap/swap-sdk-core");
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/entities/token.ts
-var import_swap_sdk_core = require("@pancakeswap/swap-sdk-core");
+var JSBI__default = /*#__PURE__*/_interopDefault(JSBI);
+var invariant4__default = /*#__PURE__*/_interopDefault(invariant4);
+var warning__default = /*#__PURE__*/_interopDefault(warning);
 
-// src/utils.ts
-var import_address = require("@ethersproject/address");
-var import_tiny_invariant = __toESM(require("tiny-invariant"));
-var import_tiny_warning = __toESM(require("tiny-warning"));
-function validateAndParseAddress(address) {
+// src/index.ts
+function validateAndParseAddress(address$1) {
   try {
-    const checksummedAddress = (0, import_address.getAddress)(address);
-    (0, import_tiny_warning.default)(address === checksummedAddress, `${address} is not checksummed.`);
+    const checksummedAddress = address.getAddress(address$1);
+    warning__default.default(address$1 === checksummedAddress, `${address$1} is not checksummed.`);
     return checksummedAddress;
   } catch (error) {
-    (0, import_tiny_invariant.default)(false, `${address} is not a valid address.`);
+    invariant4__default.default(false, `${address$1} is not a valid address.`);
   }
 }
 
 // src/entities/token.ts
-var ERC20Token = class extends import_swap_sdk_core.Token {
+var ERC20Token = class extends swapSdkCore.Token {
   constructor(chainId, address, decimals, symbol, name, projectLink) {
     super(chainId, validateAndParseAddress(address), decimals, symbol, name, projectLink);
   }
 };
 
 // src/constants.ts
-var ChainId = /* @__PURE__ */ ((ChainId2) => {
-  ChainId2[ChainId2["ETHEREUM"] = 1] = "ETHEREUM";
-  ChainId2[ChainId2["GOERLI"] = 5] = "GOERLI";
-  ChainId2[ChainId2["BSC"] = 56] = "BSC";
-  ChainId2[ChainId2["BSC_TESTNET"] = 97] = "BSC_TESTNET";
-  return ChainId2;
+var ChainId = /* @__PURE__ */ ((ChainId3) => {
+  ChainId3[ChainId3["ETHEREUM"] = 1] = "ETHEREUM";
+  ChainId3[ChainId3["GOERLI"] = 5] = "GOERLI";
+  ChainId3[ChainId3["BSC"] = 56] = "BSC";
+  ChainId3[ChainId3["BSC_TESTNET"] = 97] = "BSC_TESTNET";
+  return ChainId3;
 })(ChainId || {});
-var ZERO_PERCENT = new import_swap_sdk_core2.Percent("0");
-var ONE_HUNDRED_PERCENT = new import_swap_sdk_core2.Percent("1");
+var ZERO_PERCENT = new swapSdkCore.Percent("0");
+var ONE_HUNDRED_PERCENT = new swapSdkCore.Percent("1");
 var FACTORY_ADDRESS = "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73";
 var FACTORY_ADDRESS_ETH = "0x1097053Fd2ea711dad45caCcc45EfF7548fCB362";
 var FACTORY_ADDRESS_MAP = {
@@ -126,6 +76,22 @@ var WETH9 = {
     "WETH",
     "Wrapped Ether",
     "https://weth.io"
+  ),
+  [56 /* BSC */]: new ERC20Token(
+    56 /* BSC */,
+    "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
+    18,
+    "ETH",
+    "Binance-Peg Ethereum Token",
+    "https://ethereum.org"
+  ),
+  [97 /* BSC_TESTNET */]: new ERC20Token(
+    56 /* BSC */,
+    "0xE7bCB9e341D546b66a46298f4893f5650a56e99E",
+    18,
+    "ETH",
+    "ETH",
+    "https://ethereum.org"
   )
 };
 var WBNB = {
@@ -191,13 +157,6 @@ function isTradeBetter(tradeA, tradeB, minimumDelta = ZERO_PERCENT) {
   }
   return tradeA.executionPrice.asFraction.multiply(minimumDelta.add(ONE_HUNDRED_PERCENT)).lessThan(tradeB.executionPrice);
 }
-
-// src/entities/pair.ts
-var import_swap_sdk_core3 = require("@pancakeswap/swap-sdk-core");
-var import_address2 = require("@ethersproject/address");
-var import_solidity = require("@ethersproject/solidity");
-var import_jsbi = __toESM(require("jsbi"));
-var import_tiny_invariant2 = __toESM(require("tiny-invariant"));
 var PAIR_ADDRESS_CACHE = {};
 var composeKey = (token0, token1) => `${token0.chainId}-${token0.address}-${token1.address}`;
 var computePairAddress = ({
@@ -210,9 +169,9 @@ 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)(
+      [key]: address.getCreate2Address(
         factoryAddress,
-        (0, import_solidity.keccak256)(["bytes"], [(0, import_solidity.pack)(["address", "address"], [token0.address, token1.address])]),
+        solidity.keccak256(["bytes"], [solidity.pack(["address", "address"], [token0.address, token1.address])]),
         INIT_CODE_HASH_MAP[token0.chainId]
       )
     };
@@ -246,21 +205,21 @@ var Pair = class {
    */
   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);
+    return new swapSdkCore.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 new swapSdkCore.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");
+    invariant4__default.default(this.involvesToken(token), "TOKEN");
     return token.equals(this.token0) ? this.token0Price : this.token1Price;
   }
   /**
@@ -282,82 +241,82 @@ var Pair = class {
     return this.tokenAmounts[1];
   }
   reserveOf(token) {
-    (0, import_tiny_invariant2.default)(this.involvesToken(token), "TOKEN");
+    invariant4__default.default(this.involvesToken(token), "TOKEN");
     return token.equals(this.token0) ? this.reserve0 : this.reserve1;
   }
   getOutputAmount(inputAmount) {
-    (0, import_tiny_invariant2.default)(this.involvesToken(inputAmount.currency), "TOKEN");
-    if (import_jsbi.default.equal(this.reserve0.quotient, import_swap_sdk_core3.ZERO) || import_jsbi.default.equal(this.reserve1.quotient, import_swap_sdk_core3.ZERO)) {
-      throw new import_swap_sdk_core3.InsufficientReservesError();
+    invariant4__default.default(this.involvesToken(inputAmount.currency), "TOKEN");
+    if (JSBI__default.default.equal(this.reserve0.quotient, swapSdkCore.ZERO) || JSBI__default.default.equal(this.reserve1.quotient, swapSdkCore.ZERO)) {
+      throw new swapSdkCore.InsufficientReservesError();
     }
     const inputReserve = this.reserveOf(inputAmount.currency);
     const outputReserve = this.reserveOf(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0);
-    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(
+    const inputAmountWithFee = JSBI__default.default.multiply(inputAmount.quotient, swapSdkCore._9975);
+    const numerator = JSBI__default.default.multiply(inputAmountWithFee, outputReserve.quotient);
+    const denominator = JSBI__default.default.add(JSBI__default.default.multiply(inputReserve.quotient, swapSdkCore._10000), inputAmountWithFee);
+    const outputAmount = swapSdkCore.CurrencyAmount.fromRawAmount(
       inputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
-      import_jsbi.default.divide(numerator, denominator)
+      JSBI__default.default.divide(numerator, denominator)
     );
-    if (import_jsbi.default.equal(outputAmount.quotient, import_swap_sdk_core3.ZERO)) {
-      throw new import_swap_sdk_core3.InsufficientInputAmountError();
+    if (JSBI__default.default.equal(outputAmount.quotient, swapSdkCore.ZERO)) {
+      throw new swapSdkCore.InsufficientInputAmountError();
     }
     return [outputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
   }
   getInputAmount(outputAmount) {
-    (0, import_tiny_invariant2.default)(this.involvesToken(outputAmount.currency), "TOKEN");
-    if (import_jsbi.default.equal(this.reserve0.quotient, import_swap_sdk_core3.ZERO) || import_jsbi.default.equal(this.reserve1.quotient, import_swap_sdk_core3.ZERO) || import_jsbi.default.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient)) {
-      throw new import_swap_sdk_core3.InsufficientReservesError();
+    invariant4__default.default(this.involvesToken(outputAmount.currency), "TOKEN");
+    if (JSBI__default.default.equal(this.reserve0.quotient, swapSdkCore.ZERO) || JSBI__default.default.equal(this.reserve1.quotient, swapSdkCore.ZERO) || JSBI__default.default.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient)) {
+      throw new swapSdkCore.InsufficientReservesError();
     }
     const outputReserve = this.reserveOf(outputAmount.currency);
     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(
+    const numerator = JSBI__default.default.multiply(JSBI__default.default.multiply(inputReserve.quotient, outputAmount.quotient), swapSdkCore._10000);
+    const denominator = JSBI__default.default.multiply(JSBI__default.default.subtract(outputReserve.quotient, outputAmount.quotient), swapSdkCore._9975);
+    const inputAmount = swapSdkCore.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)
+      JSBI__default.default.add(JSBI__default.default.divide(numerator, denominator), swapSdkCore.ONE)
     );
     return [inputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
   }
   getLiquidityMinted(totalSupply, tokenAmountA, tokenAmountB) {
-    (0, import_tiny_invariant2.default)(totalSupply.currency.equals(this.liquidityToken), "LIQUIDITY");
+    invariant4__default.default(totalSupply.currency.equals(this.liquidityToken), "LIQUIDITY");
     const tokenAmounts = tokenAmountA.currency.sortsBefore(tokenAmountB.currency) ? [tokenAmountA, tokenAmountB] : [tokenAmountB, tokenAmountA];
-    (0, import_tiny_invariant2.default)(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
+    invariant4__default.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
+    if (JSBI__default.default.equal(totalSupply.quotient, swapSdkCore.ZERO)) {
+      liquidity = JSBI__default.default.subtract(
+        swapSdkCore.sqrt(JSBI__default.default.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)),
+        swapSdkCore.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);
-      liquidity = import_jsbi.default.lessThanOrEqual(amount0, amount1) ? amount0 : amount1;
+      const amount0 = JSBI__default.default.divide(JSBI__default.default.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient);
+      const amount1 = JSBI__default.default.divide(JSBI__default.default.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient);
+      liquidity = JSBI__default.default.lessThanOrEqual(amount0, amount1) ? amount0 : amount1;
     }
-    if (!import_jsbi.default.greaterThan(liquidity, import_swap_sdk_core3.ZERO)) {
-      throw new import_swap_sdk_core3.InsufficientInputAmountError();
+    if (!JSBI__default.default.greaterThan(liquidity, swapSdkCore.ZERO)) {
+      throw new swapSdkCore.InsufficientInputAmountError();
     }
-    return import_swap_sdk_core3.CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity);
+    return swapSdkCore.CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity);
   }
   getLiquidityValue(token, totalSupply, liquidity, feeOn = false, kLast) {
-    (0, import_tiny_invariant2.default)(this.involvesToken(token), "TOKEN");
-    (0, import_tiny_invariant2.default)(totalSupply.currency.equals(this.liquidityToken), "TOTAL_SUPPLY");
-    (0, import_tiny_invariant2.default)(liquidity.currency.equals(this.liquidityToken), "LIQUIDITY");
-    (0, import_tiny_invariant2.default)(import_jsbi.default.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), "LIQUIDITY");
+    invariant4__default.default(this.involvesToken(token), "TOKEN");
+    invariant4__default.default(totalSupply.currency.equals(this.liquidityToken), "TOTAL_SUPPLY");
+    invariant4__default.default(liquidity.currency.equals(this.liquidityToken), "LIQUIDITY");
+    invariant4__default.default(JSBI__default.default.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), "LIQUIDITY");
     let totalSupplyAdjusted;
     if (!feeOn) {
       totalSupplyAdjusted = totalSupply;
     } else {
-      (0, import_tiny_invariant2.default)(!!kLast, "K_LAST");
-      const kLastParsed = import_jsbi.default.BigInt(kLast);
-      if (!import_jsbi.default.equal(kLastParsed, import_swap_sdk_core3.ZERO)) {
-        const rootK = (0, import_swap_sdk_core3.sqrt)(import_jsbi.default.multiply(this.reserve0.quotient, this.reserve1.quotient));
-        const rootKLast = (0, import_swap_sdk_core3.sqrt)(kLastParsed);
-        if (import_jsbi.default.greaterThan(rootK, rootKLast)) {
-          const numerator = import_jsbi.default.multiply(totalSupply.quotient, import_jsbi.default.subtract(rootK, rootKLast));
-          const denominator = import_jsbi.default.add(import_jsbi.default.multiply(rootK, import_swap_sdk_core3.FIVE), rootKLast);
-          const feeLiquidity = import_jsbi.default.divide(numerator, denominator);
-          totalSupplyAdjusted = totalSupply.add(import_swap_sdk_core3.CurrencyAmount.fromRawAmount(this.liquidityToken, feeLiquidity));
+      invariant4__default.default(!!kLast, "K_LAST");
+      const kLastParsed = JSBI__default.default.BigInt(kLast);
+      if (!JSBI__default.default.equal(kLastParsed, swapSdkCore.ZERO)) {
+        const rootK = swapSdkCore.sqrt(JSBI__default.default.multiply(this.reserve0.quotient, this.reserve1.quotient));
+        const rootKLast = swapSdkCore.sqrt(kLastParsed);
+        if (JSBI__default.default.greaterThan(rootK, rootKLast)) {
+          const numerator = JSBI__default.default.multiply(totalSupply.quotient, JSBI__default.default.subtract(rootK, rootKLast));
+          const denominator = JSBI__default.default.add(JSBI__default.default.multiply(rootK, swapSdkCore.FIVE), rootKLast);
+          const feeLiquidity = JSBI__default.default.divide(numerator, denominator);
+          totalSupplyAdjusted = totalSupply.add(swapSdkCore.CurrencyAmount.fromRawAmount(this.liquidityToken, feeLiquidity));
         } else {
           totalSupplyAdjusted = totalSupply;
         }
@@ -365,32 +324,28 @@ var Pair = class {
         totalSupplyAdjusted = totalSupply;
       }
     }
-    return import_swap_sdk_core3.CurrencyAmount.fromRawAmount(
+    return swapSdkCore.CurrencyAmount.fromRawAmount(
       token,
-      import_jsbi.default.divide(import_jsbi.default.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)
+      JSBI__default.default.divide(JSBI__default.default.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)
     );
   }
 };
-
-// src/entities/route.ts
-var import_tiny_invariant3 = __toESM(require("tiny-invariant"));
-var import_swap_sdk_core4 = require("@pancakeswap/swap-sdk-core");
 var Route = class {
   constructor(pairs, input, output) {
     this._midPrice = null;
-    (0, import_tiny_invariant3.default)(pairs.length > 0, "PAIRS");
+    invariant4__default.default(pairs.length > 0, "PAIRS");
     const chainId = pairs[0].chainId;
-    (0, import_tiny_invariant3.default)(
+    invariant4__default.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");
+    invariant4__default.default(pairs[0].involvesToken(wrappedInput), "INPUT");
+    invariant4__default.default(typeof output === "undefined" || pairs[pairs.length - 1].involvesToken(output.wrapped), "OUTPUT");
     const path = [wrappedInput];
     for (const [i, pair] of pairs.entries()) {
       const currentInput = path[i];
-      (0, import_tiny_invariant3.default)(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), "PATH");
+      invariant4__default.default(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), "PATH");
       const output2 = currentInput.equals(pair.token0) ? pair.token1 : pair.token0;
       path.push(output2);
     }
@@ -405,23 +360,19 @@ var Route = class {
     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)
+        this.path[i].equals(pair.token0) ? new swapSdkCore.Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new swapSdkCore.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);
+    return this._midPrice = new swapSdkCore.Price(this.input, this.output, reduced.denominator, reduced.numerator);
   }
   get chainId() {
     return this.pairs[0].chainId;
   }
 };
-
-// src/entities/trade.ts
-var import_tiny_invariant4 = __toESM(require("tiny-invariant"));
-var import_swap_sdk_core5 = require("@pancakeswap/swap-sdk-core");
 function inputOutputComparator(a, b) {
-  (0, import_tiny_invariant4.default)(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
-  (0, import_tiny_invariant4.default)(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
+  invariant4__default.default(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
+  invariant4__default.default(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
   if (a.outputAmount.equalTo(b.outputAmount)) {
     if (a.inputAmount.equalTo(b.inputAmount)) {
       return 0;
@@ -456,7 +407,7 @@ var Trade = class {
    * @param amountIn the amount being passed in
    */
   static exactIn(route, amountIn) {
-    return new Trade(route, amountIn, import_swap_sdk_core5.TradeType.EXACT_INPUT);
+    return new Trade(route, amountIn, swapSdkCore.TradeType.EXACT_INPUT);
   }
   /**
    * Constructs an exact out trade with the given amount out and route
@@ -464,72 +415,72 @@ var Trade = class {
    * @param amountOut the amount returned by the trade
    */
   static exactOut(route, amountOut) {
-    return new Trade(route, amountOut, import_swap_sdk_core5.TradeType.EXACT_OUTPUT);
+    return new Trade(route, amountOut, swapSdkCore.TradeType.EXACT_OUTPUT);
   }
   constructor(route, amount, tradeType) {
     this.route = route;
     this.tradeType = tradeType;
     const tokenAmounts = new Array(route.path.length);
-    if (tradeType === import_swap_sdk_core5.TradeType.EXACT_INPUT) {
-      (0, import_tiny_invariant4.default)(amount.currency.equals(route.input), "INPUT");
+    if (tradeType === swapSdkCore.TradeType.EXACT_INPUT) {
+      invariant4__default.default(amount.currency.equals(route.input), "INPUT");
       tokenAmounts[0] = amount.wrapped;
       for (let i = 0; i < route.path.length - 1; i++) {
         const pair = route.pairs[i];
         const [outputAmount] = pair.getOutputAmount(tokenAmounts[i]);
         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(
+      this.inputAmount = swapSdkCore.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+      this.outputAmount = swapSdkCore.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");
+      invariant4__default.default(amount.currency.equals(route.output), "OUTPUT");
       tokenAmounts[tokenAmounts.length - 1] = amount.wrapped;
       for (let i = route.path.length - 1; i > 0; i--) {
         const pair = route.pairs[i - 1];
         const [inputAmount] = pair.getInputAmount(tokenAmounts[i]);
         tokenAmounts[i - 1] = inputAmount;
       }
-      this.inputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(
+      this.inputAmount = swapSdkCore.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.outputAmount = swapSdkCore.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
     }
-    this.executionPrice = new import_swap_sdk_core5.Price(
+    this.executionPrice = new swapSdkCore.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);
+    this.priceImpact = swapSdkCore.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) {
+    invariant4__default.default(!slippageTolerance.lessThan(swapSdkCore.ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === swapSdkCore.TradeType.EXACT_OUTPUT) {
       return this.outputAmount;
     }
-    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);
+    const slippageAdjustedAmountOut = new swapSdkCore.Fraction(swapSdkCore.ONE).add(slippageTolerance).invert().multiply(this.outputAmount.quotient).quotient;
+    return swapSdkCore.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) {
+    invariant4__default.default(!slippageTolerance.lessThan(swapSdkCore.ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === swapSdkCore.TradeType.EXACT_INPUT) {
       return this.inputAmount;
     }
-    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);
+    const slippageAdjustedAmountIn = new swapSdkCore.Fraction(swapSdkCore.ONE).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
+    return swapSdkCore.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
@@ -546,16 +497,16 @@ var Trade = class {
    * @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");
-    (0, import_tiny_invariant4.default)(currencyAmountIn === nextAmountIn || currentPairs.length > 0, "INVALID_RECURSION");
+    invariant4__default.default(pairs.length > 0, "PAIRS");
+    invariant4__default.default(maxHops > 0, "MAX_HOPS");
+    invariant4__default.default(currencyAmountIn === nextAmountIn || currentPairs.length > 0, "INVALID_RECURSION");
     const amountIn = nextAmountIn.wrapped;
     const tokenOut = currencyOut.wrapped;
     for (let i = 0; i < pairs.length; i++) {
       const pair = pairs[i];
       if (!pair.token0.equals(amountIn.currency) && !pair.token1.equals(amountIn.currency))
         continue;
-      if (pair.reserve0.equalTo(import_swap_sdk_core5.ZERO) || pair.reserve1.equalTo(import_swap_sdk_core5.ZERO))
+      if (pair.reserve0.equalTo(swapSdkCore.ZERO) || pair.reserve1.equalTo(swapSdkCore.ZERO))
         continue;
       let amountOut;
       try {
@@ -568,12 +519,12 @@ var Trade = class {
         throw error;
       }
       if (amountOut.currency.equals(tokenOut)) {
-        (0, import_swap_sdk_core5.sortedInsert)(
+        swapSdkCore.sortedInsert(
           bestTrades,
           new Trade(
             new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut),
             currencyAmountIn,
-            import_swap_sdk_core5.TradeType.EXACT_INPUT
+            swapSdkCore.TradeType.EXACT_INPUT
           ),
           maxNumResults,
           tradeComparator
@@ -601,7 +552,7 @@ var Trade = class {
    * @param slippageTolerance the allowed tolerated slippage
    */
   worstExecutionPrice(slippageTolerance) {
-    return new import_swap_sdk_core5.Price(
+    return new swapSdkCore.Price(
       this.inputAmount.currency,
       this.outputAmount.currency,
       this.maximumAmountIn(slippageTolerance).quotient,
@@ -624,16 +575,16 @@ var Trade = class {
    * @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");
-    (0, import_tiny_invariant4.default)(currencyAmountOut === nextAmountOut || currentPairs.length > 0, "INVALID_RECURSION");
+    invariant4__default.default(pairs.length > 0, "PAIRS");
+    invariant4__default.default(maxHops > 0, "MAX_HOPS");
+    invariant4__default.default(currencyAmountOut === nextAmountOut || currentPairs.length > 0, "INVALID_RECURSION");
     const amountOut = nextAmountOut.wrapped;
     const tokenIn = currencyIn.wrapped;
     for (let i = 0; i < pairs.length; i++) {
       const pair = pairs[i];
       if (!pair.token0.equals(amountOut.currency) && !pair.token1.equals(amountOut.currency))
         continue;
-      if (pair.reserve0.equalTo(import_swap_sdk_core5.ZERO) || pair.reserve1.equalTo(import_swap_sdk_core5.ZERO))
+      if (pair.reserve0.equalTo(swapSdkCore.ZERO) || pair.reserve1.equalTo(swapSdkCore.ZERO))
         continue;
       let amountIn;
       try {
@@ -646,12 +597,12 @@ var Trade = class {
         throw error;
       }
       if (amountIn.currency.equals(tokenIn)) {
-        (0, import_swap_sdk_core5.sortedInsert)(
+        swapSdkCore.sortedInsert(
           bestTrades,
           new Trade(
             new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency),
             currencyAmountOut,
-            import_swap_sdk_core5.TradeType.EXACT_OUTPUT
+            swapSdkCore.TradeType.EXACT_OUTPUT
           ),
           maxNumResults,
           tradeComparator
@@ -675,11 +626,7 @@ var Trade = class {
     return bestTrades;
   }
 };
-
-// src/entities/native.ts
-var import_tiny_invariant5 = __toESM(require("tiny-invariant"));
-var import_swap_sdk_core6 = require("@pancakeswap/swap-sdk-core");
-var _Native = class extends import_swap_sdk_core6.NativeCurrency {
+var _Native = class extends swapSdkCore.NativeCurrency {
   constructor({
     chainId,
     decimals,
@@ -690,14 +637,14 @@ var _Native = class extends import_swap_sdk_core6.NativeCurrency {
   }
   get wrapped() {
     const wnative = WNATIVE[this.chainId];
-    (0, import_tiny_invariant5.default)(!!wnative, "WRAPPED");
+    invariant4__default.default(!!wnative, "WRAPPED");
     return wnative;
   }
   static onChain(chainId) {
     if (chainId in this.cache) {
       return this.cache[chainId];
     }
-    (0, import_tiny_invariant5.default)(!!NATIVE[chainId], "NATIVE_CURRENCY");
+    invariant4__default.default(!!NATIVE[chainId], "NATIVE_CURRENCY");
     const { decimals, name, symbol } = NATIVE[chainId];
     return this.cache[chainId] = new _Native({ chainId, decimals, symbol, name });
   }
@@ -707,20 +654,11 @@ var _Native = class extends import_swap_sdk_core6.NativeCurrency {
 };
 var Native = _Native;
 Native.cache = {};
-
-// src/router.ts
-var import_swap_sdk_core7 = require("@pancakeswap/swap-sdk-core");
-var import_tiny_invariant6 = __toESM(require("tiny-invariant"));
 function toHex(currencyAmount) {
   return `0x${currencyAmount.quotient.toString(16)}`;
 }
 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
@@ -729,19 +667,19 @@ var Router = class {
   static swapCallParameters(trade, options) {
     const etherIn = trade.inputAmount.currency.isNative;
     const etherOut = trade.outputAmount.currency.isNative;
-    (0, import_tiny_invariant6.default)(!(etherIn && etherOut), "ETHER_IN_OUT");
-    (0, import_tiny_invariant6.default)(!("ttl" in options) || options.ttl > 0, "TTL");
+    invariant4__default.default(!(etherIn && etherOut), "ETHER_IN_OUT");
+    invariant4__default.default(!("ttl" in options) || options.ttl > 0, "TTL");
     const to = validateAndParseAddress(options.recipient);
     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((/* @__PURE__ */ new Date()).getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
+    const deadline = "ttl" in options ? `0x${(Math.floor(( new Date()).getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
     const useFeeOnTransfer = Boolean(options.feeOnTransfer);
     let methodName;
     let args;
     let value;
     switch (trade.tradeType) {
-      case import_swap_sdk_core7.TradeType.EXACT_INPUT:
+      case swapSdkCore.TradeType.EXACT_INPUT:
         if (etherIn) {
           methodName = useFeeOnTransfer ? "swapExactETHForTokensSupportingFeeOnTransferTokens" : "swapExactETHForTokens";
           args = [amountOut, path, to, deadline];
@@ -756,8 +694,8 @@ var Router = class {
           value = ZERO_HEX;
         }
         break;
-      case import_swap_sdk_core7.TradeType.EXACT_OUTPUT:
-        (0, import_tiny_invariant6.default)(!useFeeOnTransfer, "EXACT_OUT_FOT");
+      case swapSdkCore.TradeType.EXACT_OUTPUT:
+        invariant4__default.default(!useFeeOnTransfer, "EXACT_OUT_FOT");
         if (etherIn) {
           methodName = "swapETHForExactTokens";
           args = [amountOut, path, to, deadline];
@@ -780,31 +718,841 @@ var Router = class {
     };
   }
 };
+var _Ether = class extends swapSdkCore.NativeCurrency {
+  constructor(chainId) {
+    super(chainId, 18, "ETH", "Ether");
+  }
+  get wrapped() {
+    const weth9 = WETH9[this.chainId];
+    invariant4__default.default(!!weth9, "WRAPPED");
+    return weth9;
+  }
+  static onChain(chainId) {
+    if (!this._etherCache[chainId]) {
+      this._etherCache[chainId] = new _Ether(chainId);
+    }
+    return this._etherCache[chainId];
+  }
+  equals(other) {
+    return other.isNative && other.chainId === this.chainId;
+  }
+};
+var Ether = _Ether;
+Ether._etherCache = {};
 
-// src/index.ts
-__reExport(src_exports, require("@pancakeswap/swap-sdk-core"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ChainId,
-  ERC20Token,
-  FACTORY_ADDRESS,
-  FACTORY_ADDRESS_MAP,
-  INIT_CODE_HASH,
-  INIT_CODE_HASH_MAP,
-  JSBI,
-  NATIVE,
-  Native,
-  ONE_HUNDRED_PERCENT,
-  Pair,
-  Route,
-  Router,
-  Trade,
-  WBNB,
-  WETH9,
-  WNATIVE,
-  ZERO_PERCENT,
-  computePairAddress,
-  inputOutputComparator,
-  isTradeBetter,
-  tradeComparator
+// src/abis/ERC20.json
+var ERC20_default = [
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [{ name: "", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/abis/IPancakePair.json
+var IPancakePair_default = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount0",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount1",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      }
+    ],
+    name: "Burn",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount0",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount1",
+        type: "uint256"
+      }
+    ],
+    name: "Mint",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount0In",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount1In",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount0Out",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount1Out",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      }
+    ],
+    name: "Swap",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint112",
+        name: "reserve0",
+        type: "uint112"
+      },
+      {
+        indexed: false,
+        internalType: "uint112",
+        name: "reserve1",
+        type: "uint112"
+      }
+    ],
+    name: "Sync",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "DOMAIN_SEPARATOR",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "MINIMUM_LIQUIDITY",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "PERMIT_TYPEHASH",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    payable: false,
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      }
+    ],
+    name: "burn",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "amount0",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "amount1",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    payable: false,
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "factory",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "getReserves",
+    outputs: [
+      {
+        internalType: "uint112",
+        name: "reserve0",
+        type: "uint112"
+      },
+      {
+        internalType: "uint112",
+        name: "reserve1",
+        type: "uint112"
+      },
+      {
+        internalType: "uint32",
+        name: "blockTimestampLast",
+        type: "uint32"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "initialize",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "kLast",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      }
+    ],
+    name: "mint",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "liquidity",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "nonces",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "deadline",
+        type: "uint256"
+      },
+      {
+        internalType: "uint8",
+        name: "v",
+        type: "uint8"
+      },
+      {
+        internalType: "bytes32",
+        name: "r",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32"
+      }
+    ],
+    name: "permit",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "price0CumulativeLast",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "price1CumulativeLast",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      }
+    ],
+    name: "skim",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "amount0Out",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "amount1Out",
+        type: "uint256"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "swap",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [],
+    name: "sync",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "token0",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "token1",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/fetcher.ts
+var TOKEN_DECIMALS_CACHE = {
+  [56 /* BSC */]: {}
+};
+var Fetcher = class {
+  /**
+   * Cannot be constructed.
+   */
+  // eslint-disable-next-line no-useless-constructor,@typescript-eslint/no-empty-function
+  constructor() {
+  }
+  /**
+   * Fetch information for a given token on the given chain, using the given ethers provider.
+   * @param chainId chain of the token
+   * @param address address of the token on the chain
+   * @param provider provider used to fetch the token
+   * @param symbol symbol of the token
+   * @param name optional name of the token
+   */
+  static async fetchTokenData(chainId, address, provider = providers.getDefaultProvider(networks.getNetwork(chainId)), symbol, name) {
+    var _a;
+    const parsedDecimals = typeof ((_a = TOKEN_DECIMALS_CACHE == null ? void 0 : TOKEN_DECIMALS_CACHE[chainId]) == null ? void 0 : _a[address]) === "number" ? TOKEN_DECIMALS_CACHE[chainId][address] : await new contracts.Contract(address, ERC20_default, provider).decimals().then((decimals) => {
+      TOKEN_DECIMALS_CACHE = {
+        ...TOKEN_DECIMALS_CACHE,
+        [chainId]: {
+          ...TOKEN_DECIMALS_CACHE == null ? void 0 : TOKEN_DECIMALS_CACHE[chainId],
+          [address]: decimals
+        }
+      };
+      return decimals;
+    });
+    return new swapSdkCore.Token(chainId, address, parsedDecimals, symbol, name);
+  }
+  /**
+   * Fetches information about a pair and constructs a pair from the given two tokens.
+   * @param tokenA first token
+   * @param tokenB second token
+   * @param provider the provider to use to fetch the data
+   */
+  static async fetchPairData(tokenA, tokenB, provider = providers.getDefaultProvider(networks.getNetwork(tokenA.chainId))) {
+    invariant4__default.default(tokenA.chainId === tokenB.chainId, "CHAIN_ID");
+    const address = Pair.getAddress(tokenA, tokenB);
+    const [reserves0, reserves1] = await new contracts.Contract(address, IPancakePair_default, provider).getReserves();
+    const balances = tokenA.sortsBefore(tokenB) ? [reserves0, reserves1] : [reserves1, reserves0];
+    return new Pair(
+      swapSdkCore.CurrencyAmount.fromRawAmount(tokenA, balances[0]),
+      swapSdkCore.CurrencyAmount.fromRawAmount(tokenB, balances[1])
+    );
+  }
+};
+
+Object.defineProperty(exports, 'JSBI', {
+  enumerable: true,
+  get: function () { return JSBI__default.default; }
+});
+exports.ChainId = ChainId;
+exports.ERC20Token = ERC20Token;
+exports.Ether = Ether;
+exports.FACTORY_ADDRESS = FACTORY_ADDRESS;
+exports.FACTORY_ADDRESS_MAP = FACTORY_ADDRESS_MAP;
+exports.Fetcher = Fetcher;
+exports.INIT_CODE_HASH = INIT_CODE_HASH;
+exports.INIT_CODE_HASH_MAP = INIT_CODE_HASH_MAP;
+exports.NATIVE = NATIVE;
+exports.Native = Native;
+exports.ONE_HUNDRED_PERCENT = ONE_HUNDRED_PERCENT;
+exports.Pair = Pair;
+exports.Route = Route;
+exports.Router = Router;
+exports.Trade = Trade;
+exports.WBNB = WBNB;
+exports.WETH9 = WETH9;
+exports.WNATIVE = WNATIVE;
+exports.ZERO_PERCENT = ZERO_PERCENT;
+exports.computePairAddress = computePairAddress;
+exports.inputOutputComparator = inputOutputComparator;
+exports.isTradeBetter = isTradeBetter;
+exports.tradeComparator = tradeComparator;
+exports.validateAndParseAddress = validateAndParseAddress;
+Object.keys(swapSdkCore).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return swapSdkCore[k]; }
+  });
 });