@pancakeswap/sdk 3.1.5 → 3.2.1

package/dist/index.mjs

@@ -1,23 +1,23 @@
-// src/index.ts
-import JSBI2 from "jsbi";
-
-// src/constants.ts
-import { Percent } from "@pancakeswap/swap-sdk-core";
-
-// src/entities/token.ts
-import { Token } from "@pancakeswap/swap-sdk-core";
+import JSBI from 'jsbi';
+export { default as JSBI } from 'jsbi';
+import { Percent, Token, Price, ZERO, InsufficientReservesError, _9975, _10000, CurrencyAmount, InsufficientInputAmountError, ONE, sqrt, MINIMUM_LIQUIDITY, FIVE, TradeType, computePriceImpact, Fraction, sortedInsert, NativeCurrency } from '@pancakeswap/swap-sdk-core';
+export * from '@pancakeswap/swap-sdk-core';
+import { getAddress, getCreate2Address } from '@ethersproject/address';
+import invariant4 from 'tiny-invariant';
+import warning from 'tiny-warning';
+import { keccak256, pack } from '@ethersproject/solidity';
+import { Contract } from '@ethersproject/contracts';
+import { getNetwork } from '@ethersproject/networks';
+import { getDefaultProvider } from '@ethersproject/providers';
 
-// src/utils.ts
-import { getAddress } from "@ethersproject/address";
-import invariant from "tiny-invariant";
-import warning from "tiny-warning";
+// src/index.ts
 function validateAndParseAddress(address) {
   try {
     const checksummedAddress = getAddress(address);
     warning(address === checksummedAddress, `${address} is not checksummed.`);
     return checksummedAddress;
   } catch (error) {
-    invariant(false, `${address} is not a valid address.`);
+    invariant4(false, `${address} is not a valid address.`);
   }
 }
 
@@ -29,12 +29,12 @@ var ERC20Token = class extends Token {
 };
 
 // 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 Percent("0");
 var ONE_HUNDRED_PERCENT = new Percent("1");
@@ -70,6 +70,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 = {
@@ -135,25 +151,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
-import {
-  InsufficientInputAmountError,
-  InsufficientReservesError,
-  sqrt,
-  CurrencyAmount,
-  Price,
-  FIVE,
-  ONE,
-  ZERO,
-  _10000,
-  _9975,
-  MINIMUM_LIQUIDITY
-} from "@pancakeswap/swap-sdk-core";
-import { getCreate2Address } from "@ethersproject/address";
-import { keccak256, pack } from "@ethersproject/solidity";
-import JSBI from "jsbi";
-import invariant2 from "tiny-invariant";
 var PAIR_ADDRESS_CACHE = {};
 var composeKey = (token0, token1) => `${token0.chainId}-${token0.address}-${token1.address}`;
 var computePairAddress = ({
@@ -216,7 +213,7 @@ var Pair = class {
    * @param token token to return price of
    */
   priceOf(token) {
-    invariant2(this.involvesToken(token), "TOKEN");
+    invariant4(this.involvesToken(token), "TOKEN");
     return token.equals(this.token0) ? this.token0Price : this.token1Price;
   }
   /**
@@ -238,11 +235,11 @@ var Pair = class {
     return this.tokenAmounts[1];
   }
   reserveOf(token) {
-    invariant2(this.involvesToken(token), "TOKEN");
+    invariant4(this.involvesToken(token), "TOKEN");
     return token.equals(this.token0) ? this.reserve0 : this.reserve1;
   }
   getOutputAmount(inputAmount) {
-    invariant2(this.involvesToken(inputAmount.currency), "TOKEN");
+    invariant4(this.involvesToken(inputAmount.currency), "TOKEN");
     if (JSBI.equal(this.reserve0.quotient, ZERO) || JSBI.equal(this.reserve1.quotient, ZERO)) {
       throw new InsufficientReservesError();
     }
@@ -261,7 +258,7 @@ var Pair = class {
     return [outputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
   }
   getInputAmount(outputAmount) {
-    invariant2(this.involvesToken(outputAmount.currency), "TOKEN");
+    invariant4(this.involvesToken(outputAmount.currency), "TOKEN");
     if (JSBI.equal(this.reserve0.quotient, ZERO) || JSBI.equal(this.reserve1.quotient, ZERO) || JSBI.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient)) {
       throw new InsufficientReservesError();
     }
@@ -276,9 +273,9 @@ var Pair = class {
     return [inputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
   }
   getLiquidityMinted(totalSupply, tokenAmountA, tokenAmountB) {
-    invariant2(totalSupply.currency.equals(this.liquidityToken), "LIQUIDITY");
+    invariant4(totalSupply.currency.equals(this.liquidityToken), "LIQUIDITY");
     const tokenAmounts = tokenAmountA.currency.sortsBefore(tokenAmountB.currency) ? [tokenAmountA, tokenAmountB] : [tokenAmountB, tokenAmountA];
-    invariant2(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
+    invariant4(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
     let liquidity;
     if (JSBI.equal(totalSupply.quotient, ZERO)) {
       liquidity = JSBI.subtract(
@@ -296,15 +293,15 @@ var Pair = class {
     return CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity);
   }
   getLiquidityValue(token, totalSupply, liquidity, feeOn = false, kLast) {
-    invariant2(this.involvesToken(token), "TOKEN");
-    invariant2(totalSupply.currency.equals(this.liquidityToken), "TOTAL_SUPPLY");
-    invariant2(liquidity.currency.equals(this.liquidityToken), "LIQUIDITY");
-    invariant2(JSBI.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), "LIQUIDITY");
+    invariant4(this.involvesToken(token), "TOKEN");
+    invariant4(totalSupply.currency.equals(this.liquidityToken), "TOTAL_SUPPLY");
+    invariant4(liquidity.currency.equals(this.liquidityToken), "LIQUIDITY");
+    invariant4(JSBI.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), "LIQUIDITY");
     let totalSupplyAdjusted;
     if (!feeOn) {
       totalSupplyAdjusted = totalSupply;
     } else {
-      invariant2(!!kLast, "K_LAST");
+      invariant4(!!kLast, "K_LAST");
       const kLastParsed = JSBI.BigInt(kLast);
       if (!JSBI.equal(kLastParsed, ZERO)) {
         const rootK = sqrt(JSBI.multiply(this.reserve0.quotient, this.reserve1.quotient));
@@ -327,26 +324,22 @@ var Pair = class {
     );
   }
 };
-
-// src/entities/route.ts
-import invariant3 from "tiny-invariant";
-import { Price as Price2 } from "@pancakeswap/swap-sdk-core";
 var Route = class {
   constructor(pairs, input, output) {
     this._midPrice = null;
-    invariant3(pairs.length > 0, "PAIRS");
+    invariant4(pairs.length > 0, "PAIRS");
     const chainId = pairs[0].chainId;
-    invariant3(
+    invariant4(
       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");
+    invariant4(pairs[0].involvesToken(wrappedInput), "INPUT");
+    invariant4(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];
-      invariant3(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), "PATH");
+      invariant4(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), "PATH");
       const output2 = currentInput.equals(pair.token0) ? pair.token1 : pair.token0;
       path.push(output2);
     }
@@ -361,29 +354,16 @@ var Route = class {
     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)
+        this.path[i].equals(pair.token0) ? new Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new 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 Price2(this.input, this.output, reduced.denominator, reduced.numerator);
+    return this._midPrice = new Price(this.input, this.output, reduced.denominator, reduced.numerator);
   }
   get chainId() {
     return this.pairs[0].chainId;
   }
 };
-
-// src/entities/trade.ts
-import invariant4 from "tiny-invariant";
-import {
-  ONE as ONE2,
-  TradeType,
-  ZERO as ZERO2,
-  CurrencyAmount as CurrencyAmount2,
-  Fraction,
-  Price as Price3,
-  sortedInsert,
-  computePriceImpact
-} from "@pancakeswap/swap-sdk-core";
 function inputOutputComparator(a, b) {
   invariant4(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
   invariant4(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
@@ -443,8 +423,8 @@ var Trade = class {
         const [outputAmount] = pair.getOutputAmount(tokenAmounts[i]);
         tokenAmounts[i + 1] = outputAmount;
       }
-      this.inputAmount = CurrencyAmount2.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
-      this.outputAmount = CurrencyAmount2.fromFractionalAmount(
+      this.inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+      this.outputAmount = CurrencyAmount.fromFractionalAmount(
         route.output,
         tokenAmounts[tokenAmounts.length - 1].numerator,
         tokenAmounts[tokenAmounts.length - 1].denominator
@@ -457,14 +437,14 @@ var Trade = class {
         const [inputAmount] = pair.getInputAmount(tokenAmounts[i]);
         tokenAmounts[i - 1] = inputAmount;
       }
-      this.inputAmount = CurrencyAmount2.fromFractionalAmount(
+      this.inputAmount = CurrencyAmount.fromFractionalAmount(
         route.input,
         tokenAmounts[0].numerator,
         tokenAmounts[0].denominator
       );
-      this.outputAmount = CurrencyAmount2.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+      this.outputAmount = CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
     }
-    this.executionPrice = new Price3(
+    this.executionPrice = new Price(
       this.inputAmount.currency,
       this.outputAmount.currency,
       this.inputAmount.quotient,
@@ -477,24 +457,24 @@ var Trade = class {
    * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
    */
   minimumAmountOut(slippageTolerance) {
-    invariant4(!slippageTolerance.lessThan(ZERO2), "SLIPPAGE_TOLERANCE");
+    invariant4(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === TradeType.EXACT_OUTPUT) {
       return this.outputAmount;
     }
-    const slippageAdjustedAmountOut = new Fraction(ONE2).add(slippageTolerance).invert().multiply(this.outputAmount.quotient).quotient;
-    return CurrencyAmount2.fromRawAmount(this.outputAmount.currency, slippageAdjustedAmountOut);
+    const slippageAdjustedAmountOut = new Fraction(ONE).add(slippageTolerance).invert().multiply(this.outputAmount.quotient).quotient;
+    return CurrencyAmount.fromRawAmount(this.outputAmount.currency, slippageAdjustedAmountOut);
   }
   /**
    * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
    * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
    */
   maximumAmountIn(slippageTolerance) {
-    invariant4(!slippageTolerance.lessThan(ZERO2), "SLIPPAGE_TOLERANCE");
+    invariant4(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
     if (this.tradeType === TradeType.EXACT_INPUT) {
       return this.inputAmount;
     }
-    const slippageAdjustedAmountIn = new Fraction(ONE2).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
-    return CurrencyAmount2.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn);
+    const slippageAdjustedAmountIn = new Fraction(ONE).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
+    return CurrencyAmount.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn);
   }
   /**
    * Given a list of pairs, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
@@ -520,7 +500,7 @@ var Trade = class {
       const pair = pairs[i];
       if (!pair.token0.equals(amountIn.currency) && !pair.token1.equals(amountIn.currency))
         continue;
-      if (pair.reserve0.equalTo(ZERO2) || pair.reserve1.equalTo(ZERO2))
+      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO))
         continue;
       let amountOut;
       try {
@@ -566,7 +546,7 @@ var Trade = class {
    * @param slippageTolerance the allowed tolerated slippage
    */
   worstExecutionPrice(slippageTolerance) {
-    return new Price3(
+    return new Price(
       this.inputAmount.currency,
       this.outputAmount.currency,
       this.maximumAmountIn(slippageTolerance).quotient,
@@ -598,7 +578,7 @@ var Trade = class {
       const pair = pairs[i];
       if (!pair.token0.equals(amountOut.currency) && !pair.token1.equals(amountOut.currency))
         continue;
-      if (pair.reserve0.equalTo(ZERO2) || pair.reserve1.equalTo(ZERO2))
+      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO))
         continue;
       let amountIn;
       try {
@@ -640,10 +620,6 @@ var Trade = class {
     return bestTrades;
   }
 };
-
-// src/entities/native.ts
-import invariant5 from "tiny-invariant";
-import { NativeCurrency } from "@pancakeswap/swap-sdk-core";
 var _Native = class extends NativeCurrency {
   constructor({
     chainId,
@@ -655,14 +631,14 @@ var _Native = class extends NativeCurrency {
   }
   get wrapped() {
     const wnative = WNATIVE[this.chainId];
-    invariant5(!!wnative, "WRAPPED");
+    invariant4(!!wnative, "WRAPPED");
     return wnative;
   }
   static onChain(chainId) {
     if (chainId in this.cache) {
       return this.cache[chainId];
     }
-    invariant5(!!NATIVE[chainId], "NATIVE_CURRENCY");
+    invariant4(!!NATIVE[chainId], "NATIVE_CURRENCY");
     const { decimals, name, symbol } = NATIVE[chainId];
     return this.cache[chainId] = new _Native({ chainId, decimals, symbol, name });
   }
@@ -672,20 +648,11 @@ var _Native = class extends NativeCurrency {
 };
 var Native = _Native;
 Native.cache = {};
-
-// src/router.ts
-import { TradeType as TradeType2 } from "@pancakeswap/swap-sdk-core";
-import invariant6 from "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
@@ -694,19 +661,19 @@ var Router = class {
   static swapCallParameters(trade, options) {
     const etherIn = trade.inputAmount.currency.isNative;
     const etherOut = trade.outputAmount.currency.isNative;
-    invariant6(!(etherIn && etherOut), "ETHER_IN_OUT");
-    invariant6(!("ttl" in options) || options.ttl > 0, "TTL");
+    invariant4(!(etherIn && etherOut), "ETHER_IN_OUT");
+    invariant4(!("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 TradeType2.EXACT_INPUT:
+      case TradeType.EXACT_INPUT:
         if (etherIn) {
           methodName = useFeeOnTransfer ? "swapExactETHForTokensSupportingFeeOnTransferTokens" : "swapExactETHForTokens";
           args = [amountOut, path, to, deadline];
@@ -721,8 +688,8 @@ var Router = class {
           value = ZERO_HEX;
         }
         break;
-      case TradeType2.EXACT_OUTPUT:
-        invariant6(!useFeeOnTransfer, "EXACT_OUT_FOT");
+      case TradeType.EXACT_OUTPUT:
+        invariant4(!useFeeOnTransfer, "EXACT_OUT_FOT");
         if (etherIn) {
           methodName = "swapETHForExactTokens";
           args = [amountOut, path, to, deadline];
@@ -745,30 +712,808 @@ var Router = class {
     };
   }
 };
+var _Ether = class extends NativeCurrency {
+  constructor(chainId) {
+    super(chainId, 18, "ETH", "Ether");
+  }
+  get wrapped() {
+    const weth9 = WETH9[this.chainId];
+    invariant4(!!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
-export * from "@pancakeswap/swap-sdk-core";
-export {
-  ChainId,
-  ERC20Token,
-  FACTORY_ADDRESS,
-  FACTORY_ADDRESS_MAP,
-  INIT_CODE_HASH,
-  INIT_CODE_HASH_MAP,
-  JSBI2 as 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 = getDefaultProvider(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 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 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 = getDefaultProvider(getNetwork(tokenA.chainId))) {
+    invariant4(tokenA.chainId === tokenB.chainId, "CHAIN_ID");
+    const address = Pair.getAddress(tokenA, tokenB);
+    const [reserves0, reserves1] = await new Contract(address, IPancakePair_default, provider).getReserves();
+    const balances = tokenA.sortsBefore(tokenB) ? [reserves0, reserves1] : [reserves1, reserves0];
+    return new Pair(
+      CurrencyAmount.fromRawAmount(tokenA, balances[0]),
+      CurrencyAmount.fromRawAmount(tokenB, balances[1])
+    );
+  }
 };
+
+export { ChainId, ERC20Token, Ether, FACTORY_ADDRESS, FACTORY_ADDRESS_MAP, Fetcher, INIT_CODE_HASH, INIT_CODE_HASH_MAP, NATIVE, Native, ONE_HUNDRED_PERCENT, Pair, Route, Router, Trade, WBNB, WETH9, WNATIVE, ZERO_PERCENT, computePairAddress, inputOutputComparator, isTradeBetter, tradeComparator, validateAndParseAddress };